text:
---
description: Configuring a Custom SMS Provider for MFA using Infobip
topics:
  - mfa
  - sms
  - custom-sms-provider
contentType:
  - how-to
useCase:
  - customize-mfa
---
# Configuring a Custom SMS Provider for MFA using Infobip

## Prerequisites

Before you begin this tutorial, please:

* Login to the [Infobip Portal](https://portal.infobip.com/) or [signup for a free trial](https://www.infobip.com/signup).
* Create and capture a new API Key in the [Infobip API Keys page](https://portal.infobip.com/.settings/accounts/api-keys)

## 1. Create a Send Phone Message hook

You will need to create a [Send Phone Message](/hooks/extensibility-points/send-phone-message) hook, which will hold the code and secrets of your custom implementation.

::: note
You can only have **one** Send Phone Message Hook active at a time.
:::

## 2. Configure Hook secrets

Add a [Hook Secret](/hooks/secrets/create) with key = `API_KEY` and the API key provided by Infobip.

## 3. Implement the Hook

[Edit](/hooks/update) the Send Phone Message hook's code to match the example below.

```js
/**
@param {string} recipient - phone number
@param {string} text - message body
@param {object} context - additional authorization context
@param {string} context.factor_type - 'first' or 'second'
@param {string} context.message_type - 'sms' or 'voice'
@param {string} context.action - 'enrollment' or 'authentication'
@param {string} context.language - language used by login flow
@param {string} context.code - one time password
@param {string} context.ip - ip address
@param {string} context.user_agent - user agent making the authentication request
@param {string} context.client_id - to send different messages depending on the client id
@param {string} context.name - to include it in the SMS message
@param {object} context.client_metadata - metadata from client
@param {object} context.user - To customize messages for the user
@param {function} cb - function (error, response)
*/
module.exports = function(recipient, text, context, cb) {

    const axios = require('axios').default;
    const API_KEY = context.webtask.secrets.API_KEY;;
    const BASE_URL = 'https://2622w.api.infobip.com';
    const instance = axios.create({
        baseURL: BASE_URL,
        headers: {
            'Authorization': 'App ' + API_KEY,
            'Accept': 'application/json',
            'Content-Type': 'application/json'
        },
    });
    instance({
        method: 'post',
        url: '/sms/2/text/advanced',
        data: {
            "messages": [
                {
                    "destinations": [
                        { "to": recipient }
                    ],
                    "text": text
                }
            ]
        }
    })
    .then((response) => {
        cb(null, {});
    })
    .catch((error) => {
        cb(error);
    });

};
```

## 4. Test your hook implementation

Click the **Run** icon on the top right to test the hook. Edit the parameters to specify the phone number to receive the SMS and click the **Run** button.

## 5. Test the MFA flow

Trigger an MFA flow and double check that everything works as intended. If you do not receive the SMS, please take a look at the [Hook Logs](/hooks/view-logs).

## Troubleshooting

If you do not receive the SMS, please look at the logs for clues and make sure that:

- The Hook is active and the SMS configuration is set to use 'Custom'.
- You have configured the Hook Secrets as per Step 2.
- Those secrets are the same ones you created in the Infobip Portal.
- Your phone number is formatted using the [E.164 format](https://en.wikipedia.org/wiki/E.164).

repository: civility-bot/docs

repo_name: civility-bot/docs


text:
# launch containers using docker-compose
Aim : launch containers (mysql and php symfony)
as we have done it already in [01-docker](../../01-docker/Readme.md)
but with a slighter different stack

## docker images build
we will build apache image and pull the images for phpmyadmin and mysql

during the build, analyse the content of the directory exercise
```bash
# go to the exercise directory
cd "${TUTO_BASE_DIR}/02-docker-compose/exo1-apache-mysql/exercise"
# builds the images that need to be built
docker-compose build
# pull (already built) images from official docker repository
docker-compose pull
```

## analyse the files
first take the time to analyse the files in the folder 02-docker-compose/exo01/exercise in this order:
* docker-compose.yml
* apache/Dockerfile

and apache configuration file that you don't really need to analyse this time:
* apache/vhosts/sf4.conf

## launch our docker containers
now we will launch all the services defined in the docker-compose.yml file
in background process (-d option)
```bash
docker-compose up -d
```

see the logs of the different services
-f option, follow mode
Ctrl-C to go back to the bash prompt
```bash
docker-compose logs -f
```

## initialize the symfony project
connect to the sf4_php container
> **Note**
> On window git bash you will need to open tty (see [Previous tutorial](../../01-docker/Readme.md))
> just prepend *winpty* to the following command

```bash
docker exec -it -u root sf4_apache bash
```

from this container, we will initialize the symfony project
launch the following commands:
```bash
cd /home/wwwroot/sf4
composer create-project symfony/skeleton .
chown -R www-data:www-data * .*
```

Finally type 'exit' to return to the host

## inspect the volume
inspect volume structure
```bash
docker volume inspect exercise_web-site-volume
```
you can see in the property Mountpoint the place where the files of the volume are actually stored

list the files in the volume
```bash
sudo ls -al "$(docker volume inspect exercise_web-site-volume | grep "Mountpoint" | sed -E 's/[ \t]+"Mountpoint": "([^"]+)",$/\1/')"
```

## open the web sites
Open the web site in your browser [http://localhost](http://localhost)
You should see a page with 'Welcome to Symfony 4.2.3'

Open phpmyadmin [http://localhost:8080](http://localhost:8080)
Notice that you can't authenticate to it using server/login/password mysql/sf4/sf4
defined in the docker-compose.yml file
we will see in the next exercise how to correct this

## cleaning
now remove the containers and the volumes associated (option -v)
```bash
docker-compose down -v
```

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# d20-tools

A PWA with some tools for playing D20 based role playing games.

You can use these tools live at [d20-tools.wilanthaou.de](https://d20-tools.wilanthaou.de).

* A scalable **Game Grid** which can help organize combats.

## Development

`d20-tools` is built using

* [TypeScript](https://www.typescriptlang.org/)
* [wecco](https://wecco.bitbucket.io/)
* [sass](https://sass-lang.com/)
* [webpack](https://wecco.bitbucket.io/)

Everything can be installed using `npm`. To get started you need to have a working
installation of _nodejs_ and _npm_.

Run

```
$ npm i
```

to install all dependencies. Run

```
$ npm start
```

to launch the webpack dev server, then open [localhost:9999](http://localhost:9999) in
your favorite browser.

### Generating the icons

The icon is maintained as `icon.svg`. To generate a PNG version, we use `inkscape` with
the following command:

```
$ inkscape icon.svg -w 48 --export-filename public/icon.png
$ inkscape icon.svg -w 32 --export-filename public/favicon.png
```

Make sure to commit the generated files to git when changing the SVG.

## License

This project is licensed under the Apache License V2.

gha_language: TypeScript


text:
# Halty

[![Build Status](https://secure.travis-ci.org/krrrr38/halty.png)](http://travis-ci.org/krrrr38/halty)
[![codecov.io](http://codecov.io/github/krrrr38/halty/coverage.svg?branch=master)](http://codecov.io/github/krrrr38/halty?branch=master)
[![Codacy Badge](https://www.codacy.com/project/badge/8379734cad1a4b069a7bd76e3620de57)](https://www.codacy.com/app/k-kaizu38/halty)
[![Maven Central 2.11.x](https://maven-badges.herokuapp.com/maven-central/com.krrrr38/halty_2.11/badge.svg)](https://maven-badges.herokuapp.com/maven-central/com.krrrr38/halty_2.11)
[![Maven Central 2.10.x](https://maven-badges.herokuapp.com/maven-central/com.krrrr38/halty_2.10/badge.svg)](https://maven-badges.herokuapp.com/maven-central/com.krrrr38/halty_2.10)
[![License: MIT](http://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)

Text-to-HTML converter with Halty syntax.

Halty syntax is based on [Hatena syntax](http://hatenadiary.g.hatena.ne.jp/keyword/%E3%81%AF%E3%81%A6%E3%81%AA%E8%A8%98%E6%B3%95%E4%B8%80%E8%A6%A7).

## Usage

```scala
libraryDependencies += "com.krrrr38" %% "halty" % "0.1.3"
```

or

```scala
resolvers += Opts.resolver.sonatypeSnapshots

libraryDependencies += "com.krrrr38" %% "halty" % "0.1.4-SNAPSHOT"
```

## Synopsys

```scala
val input =
    """
    |* h3 header
    |text
    |
    |>https://github.com/krrrr38/halty>
    |cite from halty - github
    |<<
    |
    |- LIST
    |-- https://github.com/krrrr38/halty
    |-- [https://github.com/krrrr38/halty]
    |-- [https://github.com/krrrr38/halty:title]
    |-- [https://github.com/krrrr38/halty:title=foo]
    |
    |:dt:dd
    |
    ||table|table|
    ||100|200|
    |
    |>|scala|
    |case class Person(name: String)
    |||<
    """.stripMargin
val ast = Halty(input)
XHTMLGenerator.generate(ast)    # generate xhtml
MarkdownGenerator.generate(ast) # generate markdown
```

## Contribution

1. Fork ([https://github.com/krrrr38/halty/fork](https://github.com/krrrr38/halty/fork))
1. Create a feature branch
1. Commit your changes
1. Rebase your local changes against the target version branch
1. Run test suite with the `sbt test` command and confirm that it passes
1. Create new Pull Request

## Author

[krrrr38](https://github.com/krrrr38)


text:
ClientLibs
==========

The client libs are a power feature of the AEM platform.

When developing a component, in most if not all cases there is CSS and or JavaScript that is specific to the component. In the case of the Button Component the css is rolled into the core css file and there is no JavaScript.

Lets take a look at the Events Listing Component's clientlibs
[![Screen](http://upworks.github.io/aem-development/imgs/events-client-libs.png)](http://upworks.github.io/aem-development/imgs/events-client-libs.png)

Here you will see that the clientlibs node contains a CSS folder and a JS folder as well as two text files `css.txt` and `js.txt`

Lets take a quick look at the the two txt files. If we open the js text file.
````
#base=js
event-listing.js
````

The `#base=js` instructs the compiler that the base folder is js followed by the name or names of the JavaScript files that are to be included within the ClientLib.  During the build process AEM will create one js file and one css file respectively.  If there were more than 1 file all the files would be concatenated into one file and minified.

**Minified in AEM = White Space remove, line breaks still exist :(

Now in my component JSP I can include the client lib with one line:
`<cq:includeClientLibcategories="nextgen.event-listing" />`
Or
`<cq:includeClientLibcss="nextgen.event-listing" />`
And
`<cq:includeClientLibjs="nextgen.event-listing" />`

There is also the option to include this component's clientlib into a parent or global lib such as a head clientlib. Or the CSS can be including in the `css.txt` of the head and the JavaScript can by included in the foot clientlib's `js.txt` to delay the loading until the end of the page.

###Debugging Client Libs
From time to time it will be necessary to have to trouble shoot JavaScript or CSS in the browser.  AEM has a great feature to do so. Simply apply `?debugClientLibs=true` to the a URL path and AEM will unpack the concatenated  code.

Let's try that now and work with breakpoints in a JS file.

repository: Floriangomis/aem-front-end-development

repo_name: Floriangomis/aem-front-end-development


text:
---
title: RC Dozer with Bonus Recycling Center
year: 2003
description: >-
  Rev up your RC Dozer & head over to your new Recycling Center.  When you're ready, use your Dozer to push the ROK balls up, over & into a quarry, hopper or another RC Vehicle.
archiveLinks:
  - name: 08/08/2003
    link: https://web.archive.org/web/20030808010144/http://www.rokenbok.com/catalog/pd_rcv_DozerRCtr.html
priceHistory:
  - date: 08/08/2003
    price: 59.99
skus:
  - "04273"
categories:
  - Vehicle (RC)
video: ""
videoEmbeds:
  - "KJALxknZihI"
plans:
- name: RC Dozer & Recycling Center
  link: /plans/04273_rc_dozer_recycling_center.pdf

thumb: /img/sets/thumb_rc_dozer_recycling_center.jpg
images:
cmseditable: true

parts:
  - qty: 10
    name: Half Beam
    color: gray

  - qty: 10
    name: Full Beam
    color: gray

  - qty: 1
    name: Billboard Frame Back
    color: orange

  - qty: 1
    name: Billboard Frame Front
    color: orange

  - qty: 2
    name: 2 Way Brace
    color: blue

  - qty: 2
    name: Large Curved Beam
    color: gray

  - qty: 21
    name: Single Block/Cube
    color: orange

  - qty: 1
    name: Billboard
    color: printed

  - qty: 2
    name: Wall 1x7
    color: light gray
    desc: squares

  - qty: 2
    name: Girder
    color: blue

  - qty: 2
    name: Lamp
    color: yellow

  - qty: 10
    name: 16mm Red ROK
    color: red

  - qty: 10
    name: 19mm Blue ROK
    color: blue

  - qty: 1
    name: Spillway
    color: light gray

  - qty: 1
    name: Dozer Ramp
    color: gray

  - qty: 1
    name: Recycling Center Large Scoop
    color: green

  - qty: 1
    name: Barrel Sorter
    color: green

  - qty: 1
    name: Pump Plant Sign
    color: yellow

  - qty: 1
    name: Rokenbok Tool
    color: metal

  - qty: 1
    name: Recycling Center Small Scoop
    color: green

  - qty: 1
    name: Tall Sign
    color: light gray
    desc: Stop

  - qty: 2
    name: Box/Bin Rack
    color: green

  - qty: 20
    name: Barrel
    color: orange

  - qty: 1
    name: Worker/Figure
    color: blue

  - qty: 1
    name: RC Dozer
    color: orange
---
We've Turned Work Into Play!
Rev up your RC Dozer & head over to your new Recycling Center. Dump your payload into the sorting station, watch as the balls and barrels are automatically separated into their own storage quarries. When you're ready, use your Dozer to push the ROK balls up, over & into a quarry, hopper or another RC Vehicle.  It's RC Dozer fun over & over again! Now, that's what we call recycling!

 Requires Start Set and 3 AA batteries.

repository: jetmound/Rokenbok-Archive

repo_name: jetmound/Rokenbok-Archive


text:
WYSIWYG extension for babrahams:editable-text package
-----------------------------------------------------

This package provides a wysiwyg widget for editing text in-place. It is for apps that use bootstrap-3.

Example app: [http://editable-text-demo.taonova.com](http://editable-text-demo.taonova.com)

Example app repo: [https://github.com/JackAdams/editable-text-demo](https://github.com/JackAdams/editable-text-demo)

Minimal example app on meteorpad: [http://meteorpad.com/pad/2YdGJmZ9LthGZaLao/editable-text-wysiwyg-bootstrap-3](http://meteorpad.com/pad/2YdGJmZ9LthGZaLao/editable-text-wysiwyg-bootstrap-3)

#### Quick Start

If your project does not already use bootstrap-3 and fontawesome:

	meteor add fortawesome:fontawesome
    meteor add twbs:bootstrap-noglyph

This package requires fontawesome and bootstrap-3 to work, but the choice of the particular fontawesome and bootstrap-3 packages is left to the individual - they are not added automatically by this package. Once those are included in your project:

	meteor add babrahams:editable-text-wysiwyg-bootstrap-3

You can then drop an editable text widget into any Blaze template with `wysiwyg=true`:

	{{> editableText collection="posts" field="body" wysiwyg=true}}

where "posts" is the name of the mongo collection and "body" is the name of a document field for the `posts` collection.

`collection` and `field` are mandatory fields.

Note: The widget assumes that the data context is that of a single document from the `posts` collection (with _id value included).

You can also set the data context explicitly as follows:

    {{> editableText context=singlePostDocument collection="posts" field="body"}}

where `singlePostDocument` can be a single post document already set in the current context, or provided by a template helper from the template that the widget was dropped into.

(You can use `document`, `doc`, `object`, `obj`, `data` or `dataContext` instead of `context` - go with whichever you prefer.)

#### Documentation

If you have `wysiwyg=true`, you can also set `toolbarPosition=top` (instead of the default which is at the bottom) and `showToolbar=true` (instead of the default where the toolbar is initially concealed).

Read the [full documentation](https://github.com/JackAdams/meteor-editable-text#editable-text-for-meteor) for the `babrahams:editable-text` package at [https://github.com/JackAdams/meteor-editable-text](https://github.com/JackAdams/meteor-editable-text).

gha_language: JavaScript


text:
# 놀미 7. by value or by reference

## passing by value

### passing by value decays

## passing by reference

### passing by value does not decay

### passing by nonconstant reference

### passing by forwarding reference

forwarding reference or universal reference

```c++
template<typename T>
void passR (T&& arg) {      // arg declared as forwarding reference
...
}

std::string s = "hi";
passR(s);                   // OK: T deduced as std::string& (also the type of arg)
passR(std::string("hi"));   // OK: T deduced as std::string, arg is std::string&&
passR(returnString());      // OK: T deduced as std::string, arg is std::string&&
passR(std::move(s));        // OK: T deduced as std::string, arg is std::string&&
passR(arr);                 // OK: T deduced as int(&)[4] (also the type of arg)
```

## using std::ref() and std::cref()

```c++
template <>
struct minus<void> {
    template <class _Ty1, class _Ty2>
    constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
        noexcept(noexcept(static_cast<_Ty1&&>(_Left) - static_cast<_Ty2&&>(_Right))) // strengthened
        -> decltype(static_cast<_Ty1&&>(_Left) - static_cast<_Ty2&&>(_Right)) {
        return static_cast<_Ty1&&>(_Left) - static_cast<_Ty2&&>(_Right);
    }

    using is_transparent = int;
};
```

이제 이런 건 읽을 수 있다. 더 놀자!

url: https://raw.githubusercontent.com/nolmeunion/learn/482f4b8a5de81375e5663ea0b065d25f2f7da4b6/cplus/template/learn/tcg/[nolme 7] by value or by reference.md

repository: nolmeunion/learn

filename: [nolme 7] by value or by reference.md

repo_name: nolmeunion/learn


text:
---
title: "Backup plan?"
date: "2017-03-10"
layout: post
---

![]({{site.baseurl}}/images/{{page.coverImage}})

So after wanting to do a PhD for a few years (I am still making my way there, slowly) I finally questioned: what if I don't?

**DIY PhD.** Keep doing the same thing. Skim papers, tinker with code, chill out with textbooks, stare at math, ... Hmm, but I will need to support myself financially. Stay at home to cut costs. I could; tutor at Uni, do work part time in data science, get better at piano, ... I would need to get more involved in the SE / twitter /... community to make connections and discuss ideas.

**The internet.** Try to make some money off the internet; blog posts explaining ideas, write books on interesting topics, data science consultant.

**Work.** There are many interesting problems that come out of managing ML at scale.

But this begs the question. What is a PhD? And what is it for? 3 years of focused thought, while being supervised... Is it possible for me to focus for 3 years?

Having this plan (if you can call it that) helps take some of the pressure off having a good CV (for PhD applications) and allows me to research, rather than appearing to research...


text:
# Checkpoint-Store

In-memory key-value store with history!
Keys are strings, values are any type.

```js
var store = new CheckpointStore()
store.put('xyz', 'hello world')
store.checkpoint()
store.put('xyz', 'haay wuurl')

store.get('xyz') //=> 'haay wuurl'
store.revert()
store.get('xyz') //=> 'hello world'
```

Uses [functional-red-black-tree](https://github.com/mikolalysenko/functional-red-black-tree) under the hood.

### api

##### new CheckpointStore(initialState)

creates a new store. optionally pass in the intial state as a pojo.

##### store.put(key, value)

sets a value. key is a string. value is any type.

##### store.get(key)

returns a value. key is a string. value is any type.

##### store.del(key)

deletes a value. key is a string.

##### store.checkpoint()

adds a checkpoint. state of the store can be returned to this point.

##### store.revert()

returns to the state of the previous checkpoint. throws an error if there are no checkpoints.

##### store.commit()

keeps the state and removes the previous checkpoint. throws an error if there are no checkpoints.

##### store.isCheckpointed()

returns true if the store has remaining checkpoints.

##### store.copy()

returns a new CheckpointStore with matching state and checkpoints.

##### store.toJSON()

returns an object (not a string!) of the current state.

repository: Hsiang-xxs/via-issuer

gha_license_id: MIT

repo_name: Hsiang-xxs/via-issuer


text:
---
date: 2021-02-09
title: "Molecule docking"
linkTitle: "Molecule docking"
description: >
  TBD
author: Argonne National Laboratory
resources:
- src: "**.{png,jpg}"
  title: "Image #:counter"
---

Molecule docking: Docking small molecules to a protein’s
binding site is often one of the first steps for virtual screening
[^56]. Although many open-source and commercial packages exist for
docking, AI approaches can be equally powerful (and computationally
more efficient) for docking studies [^57]. Utilizing advances in
control from reinforcement learning (RL), Argonne researchers trained
an agent to drive the docking of a rigid ligand into a flexible
protein pocket. The RL agent treats the ligand as a rigid body to
which it can move through affine transformations along the
protein. This procedure bypasses sampling on a grid as the agent is
trained to optimize the pose against OpenEye Fred docking function
[^58], and/or other openly available docking tools such as UCSF DOCK,
Autodock/Vina. The challenge of this approach is that there is a need
to train the agent based on the protein target, which can still take
considerable time on single-GPU systems. This area comes from the
major Argonne CANDLE [^59] project and other applications (DeepDriveMD)
will come from this project in the new submissions category.

## Refernces

[^56]: P. D. Lyne, “Structure-based virtual screening: an overview,”
       Drug Discov. Today, vol. 7, no. 20, pp. 1047–1055, Oct. 2002
       [Online]. Available:
       http://dx.doi.org/10.1016/s1359-6446(02)02483-2

[^57]: J. Li, A. Fu, and L. Zhang, “An overview of scoring functions
	   used for protein--ligand interactions in molecular docking,”
	   Interdiscip. Sci., pp. 1–9, 2019 [Online]. Available:
	   https://idp.springer.com/authorize/casa?redirect_uri=https://link.springer.com/article/10.1007/s12539-019-00327-w&casa_token=Usuqtf4tu-4AAAAA:VD0uKAo49lSwaEEpmufft87cpUtbmE9MSdlR_Wpv880jHArsLIfLy8PQPAaN6ODJIArQ9GMz15wJ6lSX

[^58]: M. McGann, “FRED pose prediction and virtual screening
	   accuracy,” J. Chem. Inf. Model., vol. 51, no. 3, pp. 578–596,
	   Mar. 2011 [Online]. Available:
	   http://dx.doi.org/10.1021/ci100436p

[^59]: “CANDLE Exascale Deep Learning and Simulation Enabled Precision
	   Medicine for Cancer.” [Online]. Available:
	   https://candle.cels.anl.gov/. [Accessed: 01-May-2020]

branch_name: refs/heads/main


text:
---
title: Range Sliders
layout: variation
section: components
secondary_section: Forms
status: Released
description: >-
  More information can be found at:

  http://cfpb.github.io/design-manual/page-components/form-fields.html#range-sliders
variation_groups:
  - variations:
      - variation_code_snippet: <marquee>Some sample code will eventually show up here.</marquee>
        variation_description: '![](/design-system/images/uploads/slider-default.png)'
        variation_name: Basic range slider
usage: >-

Content guidelines

  Range sliders can work well for discovery and education, where the inputs are
  [a relative quantity and not a specific numeric
  input](https://medium.com/@paulvddool/sliders-are-bad-practice-b56c3b7a6e19).
  As an example, users can narrow a list of flight options on kayak.com with
  sliders that show a range of takeoff times. Sliders are an elegant and
  intuitive way to allow the user to discover which takeoff times will yield the
  lowest fares.

  Because they’re imprecise and difficult to manipulate, range sliders are not a
  good choice when the user is likely to have a specific number that they want
  to input. If you choose to implement a slider in this latter case, consider
  adding steppers or an input box as an alternative means of entering the same
  data. Also consider the balance between the length of the slider and the
  number of data points it covers (the range as well as how discrete the points
  are). The more points to choose from, the harder it is for the user to target
  a specific number.
accessibility: Make sure that sliders are accessible by keyboard using the arrow keys
research: ''
last_updated: 2020-01-28T15:55:47.394Z
---

repository: nosahama/design-system

repo_name: nosahama/design-system


text:
---
title: Enhancements to Fallout Visualization in Analysis Workspace
description: This video shows updates to the Fallout Visualization that have been highly requested by customers, including direct vs eventual steps, renaming touch points, comparing unlimited segments, and trending touchpoint conversion percentages over time.
feature: Visualizations
topics:
activity: use
doc-type: feature video
team: Technical Marketing
thumbnail: 24047.jpg
kt: 2276
role: User
level: Beginner
exl-id: d5c95e0c-48c7-48e6-a4e9-d8cda06b4ca1
---
# Enhancements to [!DNL Fallout Visualization] in Analysis Workspace {#enhancements-to-fallout-visualization-in-analysis-workspace}

This video shows updates to the [!DNL Fallout Visualization] that have been highly requested by customers, including direct vs eventual steps, renaming touch points, comparing unlimited segments, and trending touchpoint conversion percentages over time.

>[!VIDEO](https://video.tv.adobe.com/v/24047/?quality=12&learn=on)

For more information on this feature, visit the [documentation](https://experienceleague.adobe.com/docs/analytics/analyze/analysis-workspace/visualizations/fallout/fallout-flow.html?lang=en).


text:
---
title: Payment
---

## Definition

| Property | Type/Class | Definition |
|----------| ---------- | ---------- |
| channel | *string* | Payment channel |
| funding_source | *string* | Funding source |
| amount | *object* [Amount](/Resources/Amount) | Payment amount |

repository: harshavardhanc/developer-docs

repo_name: harshavardhanc/developer-docs


text:
# poquito ivybuild

ivybuild is a build system based on [ant](http://ant.apache.org/) and [ivy](http://ant.apache.org/ivy/). It supports builds for simple java artifacts and also complete JavaEE applications.

For more informations, please take a look into the [wiki](https://github.com/poquito/ivybuild/wiki).

repository: poquito/ivybuild

repo_name: poquito/ivybuild


text:
---
title: 'Podcast #25 What Happened in New Zealand'
date: 2019-03-17 21:00:28
tags:
  - Podcast
  - New Zealand
  - Terrorism
author: 'Toasted Buns'
image: ../../images/podcast.jpg
---
Episode 25 of Toasted Buns Podcast.

This time we are discussing the events that took place in New Zealand over the weekend.

It is still an on going case so many things can change very quickly but I believe that it is important to understand what happened and why he did what he did. We will not show his face or use his name but we will discuss his manifesto and some of the ideas that led to this event.

We are still trying to figure out how to do Live Podcasts as good as we can so please excuse all technical issues!

I love you all and you are the best!

Make sure you join us Live on Youtube every Sunday @ 7pm!

Gab: https://gab.com/ToastedBuns

<script async src="//pagead2.googlesyndication.com/pagead/js/adsbygoogle.js"></script><ins class="adsbygoogle" style="display:block; text-align:center;"  data-ad-layout="in-article"  data-ad-format="fluid"  data-ad-client="ca-pub-2164900147810573"  data-ad-slot="8817307412"></ins><script>(adsbygoogle = window.adsbygoogle || []).push({});</script>

Image from:
https://l7.alamy.com/zooms/7d5a116da48648b488aea7f796cd76cc/male-in-muslim-keffiyeh-with-gun-in-hand-and-national-flag-on-background-f728g0.jpg

```audio
autoplay: true
name: Podcast #25 What Happened in New Zealand
src: "podcasts/episode25.mp3"
span: 3
```


text:
# awda
Queries the November 2019 Iron March database, to extract information about the Atomwaffen Division.

## Introduction

Founded in 2015, the American neo-nazi terrorist group Atomwaffen Division (AWD) has defied analysis. Though they present themselves as white supremacists, they flirt with islamic extremism — an ideology to which white ethno-nationalists are traditionally opposed. Furthermore, the nature of AWD's relationship with James Mason — the author of the ethno-nationalist Siege manifesto — and the Order of the Nine Angles — an esoteric Hitlerist/Satanist organisation — remain unclear, as does its organisational structure. [SPIEGEL]

On November 6, 2019 a torrent was released, containing the entire SQL database of the right-wing extremist Iron March forum. It contains the forum's user data, direct messages, and posts, ranging from its founding in 2011 to its termination in 2017. [BELLINGCAT]

This project aims to extract information on AWD's organisational structure from the Iron March database.

## Getting the data, installing and running the program

This software has only been tested on x64 Linux. Use on other systems is not recommended.

1. Make sure you have the following software installed:
    * Python 3.8.0-1 or higher.
    * Sqlite 3.30.1-1 or higher.
    * TeXLive, a version from November 2019, or later.
    * Standard Unix tools such as sh and Make.
1. Clone the repository with `git clone https://github.com/mennohellinga/awda`
1. Download the dataset via [IRONMARCH]
1. Follow the instructions in `iron_march_201911/README` to generate a set of sqlite databases under `iron_march_201911/split_sqlite`
1. Create a subdirectory in the cloned repository and call it `data` Copy the following files from `iron_march_201911/split_sqlite` into `awda/data`
    * `core_members.db`
    * `core_message_posts.db`
    * `core_message_topics.db`
    * `core_search_index.db`
1. Navigate to the top level of the cloned repository and run `run_linux.sh`

## Output

The software will create `awda.pdf`, containing the following information:

1. Table Descriptions
    1. Description of `core_members`
    1. Description of `core_message_posts`
    1. Description of `core_message_topics`
    1. Description of `core_search_index`

## To do

- [ ] clearly comment all py files
- [ ] all py functions should provide descriptive output to STDOUT for diagnostic purposes
- [ ] remove references to SGT course
- [ ] update output description
- [ ] `run_linux.sh` should move `LaTeX/master.pdf` to `awda.pdf`

### Completed
- [x] identify users who DM'ed about AWD (2020-01-19)
- [x] implement proper unicode support. We need to be able to display latin, cyrillic and arabic text (2019-12-03)
- [x] create LaTeX code to display threads (2019-12-02)
- [x] create Python code to retrieve threads (2019-12-02)
- [x] separate data-gathering from table printing functionality (2019-12-01)
- [x] create LaTeX header for stand-alone use of individual files (2019-11-28)
- [x] define all fixed LaTeX strings in a separate file (2019-11-28)
- [x] move OS interaction to the shell script (2019-11-20)

## References

* **BELLINGCAT:** _Massive White Supremacist Message Board Leak: How to Access and Interpret the Data_, November 6, 2019, [link.](https://www.bellingcat.com/resources/how-tos/2019/11/06/massive-white-supremacist-message-board-leak-how-to-access-and-interpret-the-data/)
* **IRONMARCH:** The data set can be downloaded via the following magnet link: <magnet:?xt=urn:btih:f745eb1b86eb55f638517654c015fcaaadc96919&dn=iron_march_201911&tr=http%3a%2f%2fbt1.archive.org%3a6969%2fannounce&tr=http%3a%2f%2fbt2.archive.org%3a6969%2fannounce&ws=http%3a%2f%2fia601401.us.archive.org%2f17%2fitems%2f&ws=https%3a%2f%2fia801401.us.archive.org%2f17%2fitems%2f>
* **SPIEGEL:** Epp, Alexander, Roman Höffner, et al. "Das Hass-Netzwerk: »Atomwaffen Division« nennt sich eine militante Nazi-Gruppe in den USA. Wer steckt dahinter?" _Der Spiegel 71,_ 35, [link.](https://www.spiegel.de/politik/ausland/neonazi-zelle-atomwaffen-division-das-hass-netzwerk-a-1225341.html)

repository: mennohellinga/awda

repo_name: mennohellinga/awda


text:
# fh-cup
```
 ( (
  ) )
........
|  fh  |]
\      /
 `----'
```

Wrapper CLI for `oc cluster up` to give you a working local RHMAP core for development with OpenShift Origin.

# CI
PRs are built using Travis CI

# Installation and Running

* Clone this repo to your $GOPATH
  * You'll also need to clone [rhmap-ansible](https://github.com/fheng/rhmap-ansible), [fh-core-openshift-templates](https://github.com/fheng/fh-core-openshift-templates) & [fh-openshift-templates](https://github.com/feedhenry/fh-openshift-templates) to a working directory
* Copy `fh-cup.toml` to `~/.fh-cup.toml` and configure the paths and Docker Hub details
# Install dependencies via `dep ensure` using [dep](https://github.com/golang/dep)
* Build `fh-cup` via `go build`
* Run `./fh-cup up --clean`

Some other commands and options

* `./fh-cup down --clean # Tear down cluster & clean leftover config/persistence`
* `./fh-cup check # Check for pre-requisites (WIP)`
* `./fh-cup up --skip-image-seeding # Skip image seeding (Not recommended)`
* `./fh-cup install # Run rhmap-ansible installer on an already running cluster`
* `./fh-cup seed # Seed RHMAP Core & MBaaS images into Docker`

## TODO
- [ ] Drop in config into `~/.fh-cup.toml` (maybe interactive)
- [ ] More pre-flight checks
- [ ] Embed templates into binary - use embedded by default. Single distributable.
- [ ] Build for multiple platforms

## Prerequisites

- [x] Docker (for Mac* / Linux**)
- [x] OpenShift 3 Client CLI Tool `oc` version >= *[v1.3](https://github.com/openshift/origin/releases/tag/v1.3.1)*
- [x] `socat` installed
- [x] `docker` logged in to a Docker Hub account with access to the rhmap project

## Pre-requisites for Development
- Golang >=1.9
- [dep](https://github.com/golang/dep)

## * Docker for Mac
- For an RHMAP Core & MBaaS install, you should allocate ~7GB of memory & > 5 CPU cores
- You *must* add `<IP_ADDRESS>/16` as an insecure registry (via the Docker for Mac UI)
- Kubernetes is currently broken when using CE editions of Docker. For macOS, it's recommended to use [Docker 1.13.1](https://download.docker.com/mac/stable/<IP_ADDRESS>53/Docker.dmg) for now.

## ** Docker for Linux

[CF: https://github.com/openshift/origin/blob/master/docs/cluster_up_down.md#getting-started]

| WARNING |
| ------- |
| The default Firewalld configuration on Fedora blocks access to ports needed by containers running on an OpenShift cluster. Make sure you grant access to these ports. See step 3 below. |
| Check that `sysctl net.ipv4.ip_forward` is set to 1. |

1. Install Docker with your platform's package manager.
2. Configure the Docker daemon with an insecure registry parameter of `<IP_ADDRESS>/16`
   - In RHEL and Fedora, edit the `/etc/sysconfig/docker` file and add or uncomment the following line:
     ```
     INSECURE_REGISTRY='--insecure-registry <IP_ADDRESS>/16'
     ```

   - After editing the config, restart the Docker daemon.
     ```
     $ sudo systemctl restart docker
     ```
3. Ensure that your firewall allows containers access to the OpenShift master API (8443/tcp) and DNS (53/udp) endpoints.
   In RHEL and Fedora, you can create a new firewalld zone to enable this access:
   - Determine the Docker bridge network container subnet:
     ```
     docker network inspect bridge -f "{{range .IPAM.Config }}{{ .Subnet }}{{end}}"
     ```
     You will should get a subnet like: ```<IP_ADDRESS>/16```

   - Create a new firewalld zone for the subnet and grant it access to the API and DNS ports:
     ```
     firewall-cmd --permanent --new-zone dockerc
     firewall-cmd --permanent --zone dockerc --add-source <IP_ADDRESS>/16
     firewall-cmd --permanent --zone dockerc --add-port 8443/tcp
     firewall-cmd --permanent --zone dockerc --add-port 53/udp
     firewall-cmd --permanent --zone dockerc --add-port 443/tcp
     firewall-cmd --permanent --zone dockerc --add-port 80/tcp
     firewall-cmd --reload
     ```

## Troubleshooting & Known Issues

#### General

* Docker configuration needs to be at `$HOME/.docker/config.json` - login via `docker login`

### FHC Core & MBaaS linking

If you see an error similar to the following:

```
fhc ERR! Error: getaddrinfo ENOTFOUND rhmap.cup.feedhenry.io rhmap.cup.feedhenry.io:443
```

This is likely because this hostname is not resolved correctly. `*.cup.feedhenry.io` should resolve to `<IP_ADDRESS>`. Verify this with `dig` or similar, for example:

```
dig rhmap.cup.feedhenry.io
```

#### `No such file or folder` when looking for templates/generated/fh-core-XXXXX.json

* Ensure the `generated/` folder is populated, if not, run `npm install` and `grunt` from the templates root
* Make sure to use complete paths in `~/.fh-cup.toml` eg. `/Users/ecrosbie/dir` instead of `~/dir`

### Error: Waiting for API server to start listening

If you see the following error (usually on a Mac):

```
   Waiting for API server to start listening
FAIL
   Error: timed out waiting for OpenShift container "origin"
   WARNING: <IP_ADDRESS>:8443 may be blocked by firewall rules
   Details:
     No log available from "origin" container
```

Along with lots of lines in the origin container logs with the following:

```
I0926 20:55:00.077851   29405 logs.go:41] http: TLS handshake error from <IP_ADDRESS>:37680: EOF
```

It's likely that traffic is being blocked by a firewall or filter (e.g. Little Snitch). Disable or allow access to fix.

repository: feedhenry/fh-cup

gha_language: Go

repo_name: feedhenry/fh-cup


text:
# FMKe HTTP API

FMKe has a total of 7 entities: `patient`, `facility`, `pharmacy`, `staff`, `event`, `prescription` and `treatment`.
Once an FMK node is running, an HTTP server will be started on the port defined for the environment variable `HTTP_PORT`.
**Important notes:**

1. The order of the parameters listed in each request matters since pattern matching imposes order on the list of body parameters that is passed in.
2. The casing (upper/lower case) for each of the parameters here listed matters.

The HTTP endpoints that will be available are:

## Patients ```/patients[/:id]```

### GET
A patient with id `7` can be fetched by sending a GET request to `/patients/7`.
### POST
It's possible to create a patient by sending a POST request to `/patients` with the following parameters:

| Parameter     | Type          |
| ------------- |:-------------:|
| id            | integer       |
| name          | string        |
| address       | string        |
### PUT
You can update an existing patient by sending a PUT request to `/patients/:patient_id`, where `:patient_id` is an ID of an already existent patient. You need to supply the following parameters:

| Parameter     | Type          |
| ------------- |:-------------:|
| name          | string        |
| address       | string        |

## Facilities ```/facilities[/:id]```
### GET
A facility with id `7` can be fetched by sending a GET request to `/facilities/7`.
### POST
It's possible to create a facility by sending a POST request to `/facilities` with the following parameters:

| Parameter     | Type          |
| ------------- |:-------------:|
| id            | integer       |
| name          | string        |
| address       | string        |
| type          | string        |
### PUT
You can update an existing facility by sending a PUT request to `/facilities/:facility_id`, where `:facility_id` is an ID of an already existent facility. You need to supply the following parameters:

| Parameter     | Type          |
| ------------- |:-------------:|
| name          | string        |
| address       | string        |
| type          | string        |

## Pharmacies ```/pharmacies[/:id]```
### GET
A pharmacy with id `7` can be fetched by sending a GET request to `/pharmacies/7`.
### POST
It's possible to create a pharmacy by sending a POST request to `/pharmacies` with the following parameters:

| Parameter     | Type          |
| ------------- |:-------------:|
| id            | integer       |
| name          | string        |
| address       | string        |
### PUT
You can update an existing pharmacy by sending a PUT request to `/pharmacies/:pharmacy_id`, where `:pharmacy_id` is an ID of an already existent pharmacy. You need to supply the following parameters:

| Parameter     | Type          |
| ------------- |:-------------:|
| name          | string        |
| address       | string        |

## Staff ```/staff[/:id]```
### GET
A staff member with id `7` can be fetched by sending a GET request to `/staff/7`.
### POST
It's possible to create a staff member by sending a POST request to `/staff` with the following parameters:

| Parameter     | Type          |
| ------------- |:-------------:|
| id            | integer       |
| name          | string        |
| address       | string        |
| speciality    | string        |

### PUT
You can update an existing staff member by sending a PUT request to `/staff/:staff_id`, where `:staff_id` is an ID of an already existent staff member. You need to supply the following parameters:

| Parameter     | Type          |
| ------------- |:-------------:|
| name          | string        |
| address       | string        |
| speciality    | string        |

## Events ```/events[/:id]```
### GET
An event with id `7` can be fetched by sending a GET request to `/events/7`.
### POST
It's possible to create an event by sending a POST request to `/events` with the following parameters:

| Parameter     | Type          |
| ------------- |:-------------:|
| id            | integer       |
| treatment_id  | integer       |
| staff_id      | integer       |
| timestamp     | string        |
| description   | string        |

### PUT
Events cannot currently be updated.

## Prescriptions ```/prescriptions[/:id]```
### GET
A prescription with id `7` can be fetched by sending a GET request to `/prescriptions/7`.
### POST
It's possible to create a prescription by sending a POST request to `/prescriptions` with the following parameters:

| Parameter       | Type          |
|  -------------  |:-------------:|
|  id             | integer       |
|  patient_id     | integer       |
|  prescriber_id  | integer       |
|  pharmacy_id    | integer       |
|  facility_id    | integer       |
| date_prescribed | string        |
|   drugs         | string        |

**Important note:** `drugs` is a String made up of comma separated values (CSV) for each drug in the prescription.

### PUT
You can update an existing staff member by sending a PUT request to `/prescriptions/:prescription_id`, where `:prescription_id` is an ID of an already existent prescription. You need to supply the following parameters:

| Parameter     | Type          |
| ------------- |:-------------:|
| date_processed| string        |
| drugs         | string        |

**Important note:** `drugs` is a String made up of comma separated values (CSV) for each drug in the prescription.
Despite both parameters having to be present in order for it to be considered a valid PUT request, the system will behave in the following way:

- If `date_processed` is set to a value, it will assume that you're trying to process the prescription.
- If `date_processed` is empty and `drugs` is not, it will add all CSV to as new drugs of the prescription.

## Treatments ```/treatments[/:id]```
### GET
A treatment with id `7` can be fetched by sending a GET request to `/treatments/7`.
### POST
It's possible to create a treatment by sending a POST request to `/treatments` with the following parameters:

| Parameter       | Type          |
|  -------------  |:-------------:|
|  id             | integer       |
|  patient_id     | integer       |
|  prescriber_id  | integer       |
|  facility_id    | integer       |
| date_prescribed | string        |

### PUT
Treatments cannot currently be updated.

repository: goncalotomas/FMKe

gha_language: Erlang

gha_license_id: NOASSERTION

repo_name: goncalotomas/FMKe


text:
# DanMuSpeech
A simple DouYu DanMu Speech script

# environments

Only work on **python2.7**, and install required packages by `requirements.txt`.

gha_language: Python


text:
# HELPERS

The app server: scheduled every ->

- download the image from bing
- read user configs from mongodb
- generate pool
- push images to user's buffer folder(mailto)

## locations

/usr/local/binks
/user/local/etc/binks.conf

## interface

binks
(logged in?)
connecting...
redirect? (Y/n)

binks init 3UA-BEejvnAAAAAAAAAASSB0DXolkWxVZZyLpU0cKLqfAik-muY2bXvYIFFBMlfK
binks uninstall
binks unsubscribe
binks email
binks email<EMAIL_ADDRESS>binks schedule Sunday
binks schedule everyday

todo:

binks threshold 30
binks locale en_US

## oauth2

(all fake keys for illustration)

user get code:
url: https://www.dropbox.com/oauth2/authorize?client_id=5g044eviqwmlsx1&response_type=code

return: 3UA-BEejvnAAAAAAAAAASAIzOOAdn5IdtGkGwiqSKV0

exchange access token
uri: https://api.dropboxapi.com/oauth2/token?client_id=5g044eviqwmlsx1&client_secret=5g044eviqwmlsx1&grant_type=authorization_code

return: {
    'access_token': '3UA-BEejvnAAAAAAAAAASSB0DXolkWxVZZyLpU0cKLqfAik-muY2bXvYIFFBMlfK',
    'token_type': 'bearer',
    'uid': '1397873296',
    'account_id': 'dbid:AABlO4yr558u2xf6xNyRseBKpuPSlpsiVB8'
}

dbx = dropbox.Dropbox('3UA-BEejvnAAAAAAAAAASSB0DXolkWxVZZyLpU0cKLqfAik-muY2bXvYIFFBMlfK')

## mongo

### user

It's quite easy:

```json
{
    "name": "username",
    "token": "dbxtoken",
    "email": "email",
    "schedule": "Monday"
}
```

### images

I'm not sure how long will bing keep the urls alive. But it looks like a bad idea to linkage the images in mails to my server.

That means the server maybe has to backup the meta infomations of the daily images, so I need just another mongo sheet, the schema is quite easy:

```json
{
    "date": "date",
    "image": "imagename",
    "meta": "resp.image"
}
```

repository: somarlyonks/Binks

repo_name: somarlyonks/Binks


text:
---
title: Provider Login
date: "2020-05-10"
order: 76
---

When the user chose to log in using a provider like Google or Facebook and after the user allowing our blog to access his/her public data on the provider the user will be redirected to this page.

## What You Will Learn Regarding Aventum?

- Making a `POST` request to `http://localhost:3030/users/login/${provider}/provider` and put the token that extracted from the URL into the request body as `token` will log the user in using that provider.

---

Inside the `containers` folder create the `ProviderLogin` folder and inside this one create the `ProviderLogin.js` file.

At the top of `ProviderLogin.js` file import the required modules:

```js title=src/containers/ProviderLogin/ProviderLogin.js
import React, { useCallback, useEffect } from "react"
import { useHistory, useParams } from "react-router-dom"
```

Next define our main component function:

```js highlight=4 title=src/containers/ProviderLogin/ProviderLogin.js
import React, { useCallback, useEffect } from "react"
import { useHistory, useParams } from "react-router-dom"

export default function ProviderLogin({ onLogin }) {}
```

Next, we need to extract the `provider` and the `token` params from the URL:

> The provider is a string like for example `facebook`

```js highlight=5 title=src/containers/ProviderLogin/ProviderLogin.js
import React, { useCallback, useEffect } from "react"
import { useHistory, useParams } from "react-router-dom"

export default function ProviderLogin({ onLogin }) {
  let { token, provider } = useParams()
}
```

We also need the `history` to redirect the user to the frontend on success:

```js highlight=6 title=src/containers/ProviderLogin/ProviderLogin.js
import React, { useCallback, useEffect } from "react"
import { useHistory, useParams } from "react-router-dom"

export default function ProviderLogin({ onLogin }) {
  let { token, provider } = useParams()
  let history = useHistory()
}
```

Next define our `loginWithProvider` function:

```js highlight=8-30 title=src/containers/ProviderLogin/ProviderLogin.js
import React, { useCallback, useEffect } from "react"
import { useHistory, useParams } from "react-router-dom"

export default function ProviderLogin({ onLogin }) {
  let { token, provider } = useParams()
  let history = useHistory()

  //Fetch public options
  const loginWithProvider = useCallback(async () => {
    const response = await fetch(
      `http://localhost:3030/users/login/${provider}/provider`,
      {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          "x-access-token": token,
        },
      }
    )

    localStorage.setItem(
      "x-access-token",
      response.headers.get("x-access-token")
    )

    let userData = await response.json()
    localStorage.setItem("user-data", JSON.stringify(userData))
    onLogin(userData)
    history.push("/")
  }, [])
}
```

The `loginWithProvider` function will make a `POST` request to `http://localhost:3030/users/login/${provider}/provider` and will put the token in the header as `x-access-token`, on the success we receive the user authentication token(`x-access-token`) in the response header so we save it to `x-access-token` local storage item and the user's data in the response body and we save them to `user-data` local storage item as well, finally we call `onLogin` props function and passing the user's data to it then we redirect the user to the home page.

We will call `loginWithProvider` inside `useEffect` React hook:

```js highlight=32-36 title=src/containers/ProviderLogin/ProviderLogin.js
import React, { useCallback, useEffect } from "react"
import { useHistory, useParams } from "react-router-dom"

export default function ProviderLogin({ onLogin }) {
  let { token, provider } = useParams()
  let history = useHistory()

  //Fetch public options
  const loginWithProvider = useCallback(async () => {
    const response = await fetch(
      `http://localhost:3030/users/login/${provider}/provider`,
      {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          "x-access-token": token,
        },
      }
    )

    localStorage.setItem(
      "x-access-token",
      response.headers.get("x-access-token")
    )

    let userData = await response.json()
    localStorage.setItem("user-data", JSON.stringify(userData))
    onLogin(userData)
    history.push("/")
  }, [])

  useEffect(() => {
    loginWithProvider()
  }, [loginWithProvider])

  return <div>Logging in...</div>
}
```

repository: TryAventum/docs

repo_name: TryAventum/docs