text:
## Operational Document

The core of the collaboration system is the operational document. The design of its structrue and the operations which can be performed on it are an attempt to make small changes quickly and with an extremely low chance of error or conflit.

### Schema
The schema of this document is
```json
{
    "definitions": {
        "layoutNode": {
            "type": "object",
            "properties": {
                "uuid": {
                    "type": "string",
                    "minLength": 1
                },
                "children": {
                    "$ref": "#/definitions/layoutChildren"
                }
            },
            "required": [ "uuid" ]
        },
        "layoutGroup": {
            "type": "array",
            "items": {
                "$ref": "#/definitions/layoutNode"
            }
        },
        "layoutChildren": {
            "type": "object",
            "additionalProperties": {
                "$ref": "#/definitions/layoutGroup"
            }
        },
        "layoutSection": {
            "type": "object",
            "properties": {
                "_": {
                    "$ref": "#/definitions/layoutChildren"
                }
            },
            "additionalProperties": {
                "$ref": "#/definitions/layoutSection"
            }
        },
        "dataNode": {
            "type": "object",
            "additionalProperties": {
                "type": "object",
                "properties": {
                    "_value": {
                        "type": "any"
                    },
                    "_ref": {
                        "type": "object",
                        "properties": {
                            "uuid": {
                                "type": "string",
                                "min": "1"
                            },
                            "type": {
                                "type": "string",
                                "min": "1"
                            }
                        },
                        "default": null,
                        "required": [ "uuid", "type" ]
                    },
                    "_detached": {
                        "type": "bool",
                        "default": "false"
                    },
                    "_bound": {
                        "type": "bool",
                        "default": "false"
                    }
                }
            }
        },
        "dataSection": {
            "type": "object",
            "properties": {
                "_": {
                    "$ref": "#/definitions/dataNode"
                }
            },
            "additionalProperties": {
                "$ref": "#/definitions/dataSection"
            }
        },
        "issuesNode": {
            "type": "object",
            "additionalProperties": {
                "type": "object",
                "additionalProperties": {
                    "type": "any"
                }
            }
        },
        "issuesSection": {
            "type": "object",
            "properties": {
                "_": {
                    "$ref": "#/definitions/issuesNode"
                }
            },
            "additionalProperties": {
                "$ref": "#/definitions/issuesSection"
            }
        }
    },
    "type": "object",
    "properties": {
        "_uuid": {
            "type": "string",
            "minLength": 1
        },
        "_type": {
            "type": "string",
            "minLength": 1
        },
        "_head": {
            "type": "object",
            "properties": {
                "name": {
                    "type": "string",
                    "minLength": 1
                },
                "description": {
                    "type": "string",
                },
                "created": {
                    "type": "number",
                },
                "updated": {
                    "type": "number",
                },
                "version": {
                    "type": "string",
                    "pattern": "^\\d+\\.\\d+\\.\\d+$"
                }
            }
        },
        "_refs": {
            "type": "object",
            "additionalProperties": {
                "type": "object",
                "properties": {
                    "count": {
                        "type": "number",
                        "min": 1
                    },
                    "type": {
                        "type": "string",
                        "minLength": 1
                    }
                },
                "required": ["count", "type"]
            }
        },
        "_body": {
            "type": "object",
            "properties": {
                "_layout": {
                    "$ref": "#/definitions/layoutSection"
                },
                "_data": {
                    "$ref": "#/definitions/dataSection"
                }
            },
            "required": ["_layout", "_body"]
        },
        "_issues": {
            "$ref": "#/definitions/issuesSection"
        }
    },
    "required": ["_uuid", "_type", "_head"]
}
```

### Document Sections

#### UUID
This property is a unique identifier for a document. It's value is determined by the system it is being used in.

#### Type
This property is one which defines the document and the data which is contained in th body. It's value is determined by the system it is being used in.

#### Head
This property containes static data about a document.

##### Name
This is a human readable name for the document.

##### Description
This is a human readable string which provides a summary of what the document is for or why it exists.

##### Created
This is an epoch value for when the document was created.

##### Updated
This is an epoch value for when the document was last updated.

##### Version
This is a string which is not the format of a three part version.

#### References(refs)
This section declares what other documents this document references.
Each property in this section is the uuid of the document which is references. The value for this key is another object which contains a count of the number of times it is referenced and the type of document it is referencing.

This section should not be updated directly but will be updated as node in the body declare references.

#### Body
The data contained in the body is defined dynamicly based on the system and the type of the document and how that system interprets data for that type. Each data point, called a node, is broken up into two parts:

- Layout - The layout part defines the structure of the data. It decribes how each node in the data interrelates to each other node.
- Data - The data part defines the data the node encapsulates.

##### Rules
- Each of these two parts can have the data broken up into sections.
- Each section is another object which can contain sections.
- When a section is defined this section must exist in both parts.
- Each section has a special key "_" which is used to contain the data for the section.
- A node defined in a section must have an id defined which is unique within that section.
- A node defined in a section in layout must exist in the same section in data.
- A node can defined in data without it existing in layout as long as _detached is set to true in the node data.

##### Layout
- The data of a section is an object with any property name. Each proeprty is a array of nodes. The default group name is "_".
- Each node is an object which only has two keys
    - uuid - A string which is the id of the node
    - children - Another object with properties where any property is an array of nodes.

##### Data
- The data of a section is an object which is a normalized list of the uuids defined for each node within that section.
- Each node is an object which can contain any data.
- The data contained in a node has the following restrictions.
    - The key "_ref" must be an objec with two keys
        - uuid - The id of the document being referenced.
        - type - The type of the document being referenced.
    - The key "_detached" must be a boolean value and can only be true if there is no layout representation for this node. Otherwise it must be false || null || undefined and must have a layout representation.
    - The key "_bound" must be a boolean value. The default value is false. If this field is set to true then when this data is removed any section by the same id as the node is removed. Only sections which are immediately child to this nodes section are checked for and removed.

#### issues
This section allow the consuming system to define messages, issues, or validation problems and target a node for this information.

The issues part must mirror the defined sections in the body. Structuraly it also mirrors the data part of the body. The data defined for each node though has no restrictions other than each node in this part must at least be a object. Other this object can contain any key of any type.

### Operational Changes

There are 5 operational changes which can be performed to manipulat any data in this format.

#### Rename
This a change that changes any data in the head section.

```json
{
    "type": "object",
    "properties": {
        "name": {
            "type": "string",
            "minLength": 1
        },
        "description": {
            "type": "string",
        },
        "created": {
            "type": "number",
        },
        "updated": {
            "type": "number",
        },
        "version": {
            "type": "string",
            "pattern": "^\\d+\\.\\d+\\.\\d+$"
        }
    }
}
```

#### Insert Item
This message defines data to insert into the body and where to place it in the layout. The uuid in the put property is required except for the last item in the array. If not defined then it is expected that the uuid is defined for the item when it is inserted.

If a group is provided then then the node will be placed in a group in that part of the layout. If not provided or is null then the default group "_" will be used.

If instead of an array as the value of the put property a string can be used. If provided then the data will be created as detached and no layout part will be created.

```json
{
    "definitions": {
        "putItem": {
            "type": "object",
            "properties": {
                "uuid": {
                    "type": "string"
                },
                "index": {
                    "type": "integer"
                },
                "group": {
                    "type": "string"
                }
            },
            "required": [ "uuid" ]
        }
    },
    "type": "object",
    "properties": {
        "section": {
            "type": "string"
        },
        "put": {
            "type": ["string", "array"],
            "items": {
                "$ref": "#/definitions/putItem"
            },
            "minLength": 1
        },
        "data": {
            "type": "object",
            "additionalProperties": {
                "type": "any"
            }
        }
    }
}
```

If this node references another document then in the data the key "_ref" must be used and must follow the rules for this key as specified above.

#### Remove Item
This message defines data to remove from the body.

If the put property is an array then each uuid is required as is the index. If a group is provided then then the node will be removed from that group in that part of the layout. If not provided or is null then the default group "_" will be used.

If the put property is a string then it is expected that the data being removed was inserted detached and this data will be removed.

```json
{
    "definitions": {
        "pullItem": {
            "type": "object",
            "properties": {
                "uuid": {
                    "type": "string"
                },
                "index": {
                    "type": "integer"
                },
                "group": {
                    "type": "string"
                }
            },
            "required": [ "uuid" ]
        }
    },
    "type": "object",
    "properties": {
        "section": {
            "type": "string"
        },
        "pull": {
            "type": ["string", "array"],
            "items": {
                "$ref": "#/definitions/pullItem"
            },
            "minLength": 1
        }
    }
}
```

If remove is called with a string but the node was inserted into the layout an error will be thrown.

If remove is called with an array and the node is not found anywhere in the layout then an error will be thrown.

If the property being removed has children then then each child will have it's data removed as well.

#### Move Item
This message identifies a node in the layout to move and where to place it. The pull property defines where the node exists in the layout. The uuid in the put property is required except for the last item in the array. In this case the last item cannot have a uuid because the value of the last item in the pull property will be used. Only node inserted into the layout can be moved.

```json
{
    "definitions": {
        "putItem": {
            "type": "object",
            "properties": {
                "uuid": {
                    "type": "string"
                },
                "index": {
                    "type": "integer"
                },
                "group": {
                    "type": "string"
                }
            },
            "required": [ "uuid" ]
        },
        "pullItem": {
            "type": "object",
            "properties": {
                "uuid": {
                    "type": "string"
                },
                "index": {
                    "type": "integer"
                },
                "group": {
                    "type": "string"
                }
            },
            "required": [ "uuid" ]
        }
    },
    "type": "object",
    "properties": {
        "section": {
            "type": "string"
        },
        "pull": {
            "type": "array",
            "items": {
                "$ref": "#/definitions/pullItem"
            }
        },
        "put": {
            "type": "array",
            "items": {
                "$ref": "#/definitions/putItem"
            }
        }
    }
}
```

#### Update Item
This message identifies the node which is getting its data updated. The uuid is the id of the node to update and the data property is the data by which to update it with.

```json
{
    "type": "object",
    "properties": {
        "section": {
            "type": "string"
        },
        "uuid": {
            "type": "string",
            "minLength": 1
        },
        "data": {
            "type": "object",
            "additionalProperties": {
                "type": "any"
            }
        }
    }
}
```

#### Set an issue for a node
This message identifies the node which is getting issue data applied. The uuid is the id of the node. Data is the issue information which will be stored.

```json
{
    "type": "object",
    "properties": {
        "section": {
            "type": "string"
        },
        "uuid": {
            "type": "string",
            "minLength": 1
        },
        "data": {
            "type": "object",
            "additionalProperties": {
                "type": "any"
            }
        }
    }
}
```

#### Define a section
Defines a new section in layout, data, and issues.

```json
{
    "type": "object",
    "properties": {
        "section": {
            "type": "string"
        }
    }
}
```

#### Undefine a section
Removed a section in layout, data, and issues.

```json
{
    "type": "object",
    "properties": {
        "section": {
            "type": "string"
        }
    }
}
```

This will remove all the data and sub sections defined in this section.


text:
# Wikipedia json data Loader

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

Load JSON files that made by [wiki-extractor-rs](https://github.com/johtani/wiki-extractor-rs) to search engines.
Now, the tool support only JSON files that are created wiki-extractor-rs default settings.

## Requirements

* Rust nightly : elasticsearch-rs support only nightly rustc

## Support search engines

* Elasticsearch >=7.x
* Azure Cognitive Search

## Usage

Sample schema and setting yaml in sample directory.

### Prepare

For Elasticsearch, sample index settings/mappings in [./sample/elasticsearch](sample/elasticsearch) directory.
For Azure Cognitive Search, sample index settings/mappings in [./sample/azure_cognitive_search](sample/azure_cognitive_search) directory.

The command will create an index with with schema json if the index doesn't exist.

### Load command
Show help with the following command::

```
$ ./bin/wiki-json-loader -h
```

#### Options

```
$ ./wiki-json-loader -c <SEARCH_ENGINE_CONFIG> -s <SEARCH_ENGINE_TYPE> <INPUT_DIR>
```

license: MIT

repository: johtani/wiki-json-loader

branch_name: refs/heads/master

extension: md

gha_language: Rust

gha_license_id: MIT

license_type: permissive

repo_name: johtani/wiki-json-loader


text:
# pico-accountancy

![npm](https://img.shields.io/npm/v/pico-accountancy) ![Build
status](https://github.com/flarebyte/pico-accountancy/actions/workflows/main.yml/badge.svg)
![npm bundle size](https://img.shields.io/bundlephobia/min/pico-accountancy)

![npm type definitions](https://img.shields.io/npm/types/pico-accountancy)
![node-current](https://img.shields.io/node/v/pico-accountancy)
![NPM](https://img.shields.io/npm/l/pico-accountancy)

> Accountancy script for very simple cases

CLI tool for converting a QIF bank statement to the different csv files
useful for accountancy

Highlights:

-   Written in `Typescript`
-   Understand QIF format
-   Automatically convert rows based on search terms

## Documentation and links

-   [Code Maintenance](MAINTENANCE.md)
-   [Code Of Conduct](CODE_OF_CONDUCT.md)
-   [Api for pico-accountancy](API.md)
-   [Contributing](CONTRIBUTING.md)
-   [Glossary](GLOSSARY.md)
-   [Diagram for the code base](INTERNAL.md)
-   [Vocabulary used in the code base](CODE_VOCABULARY.md)
-   [Architectural Decision Records](DECISIONS.md)
-   [Contributors](https://github.com/flarebyte/pico-accountancy/graphs/contributors)
-   [Dependencies](https://github.com/flarebyte/pico-accountancy/network/dependencies)
-   [Usage](USAGE.md)

## Related

-   [baldrick-zest-engine](https://github.com/flarebyte/baldrick-zest-engine)
    Run tests declaratively with a few cunning plans

## Installation

This package is [ESM
only](https://blog.sindresorhus.com/get-ready-for-esm-aa53530b3f77).

```bash
yarn global add pico-accountancy
pico-accountancy --help
```

Or alternatively run it:

```bash
npx pico-accountancy --help
```

If you want to tun the latest version from github. Mostly useful for dev:

```bash
git clone git@github.com:flarebyte/pico-accountancy.git
yarn global add `pwd`
```

repository: flarebyte/pico-accountancy

branch_name: refs/heads/main

gha_language: TypeScript

repo_name: flarebyte/pico-accountancy


text:
# SES Router

```go
func main() {
    sesReceiver := aegis.NewSESRouter()
<EMAIL_ADDRESS>handleEmail)

    handlers := aegis.Handlers{
        SESRouter: sesReceiver,
    }
    AegisApp = aegis.New(handlers)
    AegisApp.Start()
}

func handleEmail(ctx context.Context, d *aegis.HandlerDependencies, evt *aegis.SimpleEmailEvent) error {
    log.Println(evt)
    return nil
}
```

The AWS SES (Simple E-mail Service) router, `SESRouter`, and the ability for a Lambda to receive e-mail
is perhaps one of the coolest things ever. Yes, there is such a thing as serverless e-mail.

You can route based on any address match, or address matches within a specific domain, using
`NewSESRouter()` and `NewSESRouterForDomain()` respectively.

Like the `S3ObjectRouter`, the SES router will use glob based matching. So, first the domain is check if set,
and then your pattern is checked against the e-mail address.

## How to Read E-mails

> Example SES config

```yaml
sesRules:
  - ruleName: aegis-test
    enabled: true
    requireTLS: false
    scanEnabled: true
    # ruleSet: ... optional string, defaults to aegis-default-rule-set
    # invocationType: Event # default to Event, RequestResponse is other option less common and has to return in 30 seconds
    # snsTopicArn: ... optional SNS topic to also notify - SNS setup is outside aegis deploy for now
    recipients:
      -<EMAIL_ADDRESS>    # Also, an S3 bucketTrigger could be used to pick up the e-mail in its entirety OR the an SES event can be
    # used because it will provide a message ID that can be looked for in S3.
    s3Bucket: "aegis-incoming"
    # subdirectory
    s3ObjectKeyPrefix: "ses_"
    s3encryptMessage: false
    # s3KMSKeyArn: ... s3encryptMessage will use the default KMS key for encrypting email if true unless this is provided
    # s3SNSTopicArn: "sometopic" ... an optional SNS topic to publish when messages are saved to S3, different from the SNS topic about the event
```

There's something important to note about what you get in the event message from an SES event. You are not
getting the full body of the e-mail. Just the e-mail "headers" come through. Things like the from address,
to address, CC, BCC, and subject line.

If you want to actually read the body of the e-mail, you'll need to set up a few things in AWS first. What
happens is the e-mail gets stored, in full, into S3 (if it's set up to do so). You then read it from S3.
E-mails can be stored in S3 encrypted too if you configure that as well.

To help with all this configuration in AWS, Aegis `deploy` command will read settings from `aegis.yaml` to
set things up.

Also keep in mind that you can use an `S3ObjectRouter` to handle incoming objects into whatever bucket is
receiving your e-mails too. The difference is that you wouldn't then get the e-mail headers and you'd _have_
to read the file to know what the e-mail was about. The SES handler would let your code make a determination
as to whether or not it wanted to retrieve the file from S3.

repository: MicrohexHQ/aegis

repo_name: MicrohexHQ/aegis


text:
# Employee-Tracker [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

---

## Table of Contents

---

### [Description](#Description)

### [Installation](#Installation)

### [Usage](#Usage)

### [GitHub](#GitHub)

---

### Description:

Developers are often tasked with creating interfaces that make it easy for non-developers to view and interact with information stored in databases. Often these interfaces are known as **C**ontent **M**anagement **S**ystems. In this mission, I architected and built a solution for managing a company's employees using node, inquirer, and MySQL.

The application links to an SQL database and allows users to view and manage employee records from the command line interface in a more user friendly environment.

The following objectives were sought:

1. Get the SQL database and return it as a table in the command line by using linkages
2. The table should have the column names: id, first_name, last_name, title, salary, department, and manager (if applicable)
3. Allow the user to add, view or delete employees, roles, and departments
4. Allow the user to update employees, employee managers, roles, and departments

---

### Installation:

I created the Employee Management System with npm packages: **MySQL**, **Node**, **Inquirer**, and **console.table** design pattern.

---

### Usage:

Designed the following database schema containing three tables:

- **Department**:

  - **id**
  - **name**

- **Role**:

  - **id**
  - **title**
  - **salary**
  - **department_id**

- **Employee**:

  - **id**
  - **first_name**
  - **last_name**
  - **role_id**
  - **manager_id**

### GitHub Account:

http://github.com/jhong1016


text:
# Logging Configuration
Kos uses [SLF4J](http://www.slf4j.org) as main logging implementation. Vert.x
internal logging is also automatically configured to use SLF4J as its default
logging mechanism.

## Injecting the logger
Kos allows developers to inject SLF4J Loggers into their components.

=== "Kotlin"
    ```kotlin
    import org.slf4j.Logger;

    @Singleton
    class MyComponent(val logger: Logger) {

    }
    ```
=== "Java"
    ```java
    import org.slf4j.Logger;

    @Singleton
    class MyComponent {

        Logger logger;

        MyComponent(Logger logger) {
            this.logger = logger;
        }
    }
    ```

repository: Skullabs/kos

gha_language: Java

repo_name: Skullabs/kos


text:
# color-blind-checker

Based on [this post](https://www.vis4.net/blog/2018/02/automate-colorblind-checking/), compare pairs of colors under common color deficiency conditions.

Accepts colors in any format [chroma.js](https://www.npmjs.com/package/chroma-js) can parse.

repository: tommilligan/color-blind-checker

gha_language: JavaScript

repo_name: tommilligan/color-blind-checker


text:
---
id: class-download
title: "Download"
---

[Download] objects are dispatched by page via the [page.on('download')](api/class-page.md#pageondownload) event.

All the downloaded files belonging to the browser context are deleted when the browser context is closed. All downloaded files are deleted when the browser closes.

Download event is emitted once the download starts. Download path becomes available once download completes:

```js
const [ download ] = await Promise.all([
  page.waitForEvent('download'), // wait for download to start
  page.click('a')
]);
// wait for download to complete
const path = await download.path();
...
```

> **NOTE** Browser context **must** be created with the `acceptDownloads` set to `true` when user needs access to the downloaded content. If `acceptDownloads` is not set or set to `false`, download events are emitted, but the actual download is not performed and user has no access to the downloaded files.

- [download.createReadStream()](api/class-download.md#downloadcreatereadstream)
- [download.delete()](api/class-download.md#downloaddelete)
- [download.failure()](api/class-download.md#downloadfailure)
- [download.path()](api/class-download.md#downloadpath)
- [download.saveAs(path)](api/class-download.md#downloadsaveaspath)
- [download.suggestedFilename()](api/class-download.md#downloadsuggestedfilename)
- [download.url()](api/class-download.md#downloadurl)

## download.createReadStream()
- returns: <[Promise]<[null]|[Readable]>>

Returns readable stream for current download or `null` if download failed.

## download.delete()
- returns: <[Promise]>

Deletes the downloaded file.

## download.failure()
- returns: <[Promise]<[null]|[string]>>

Returns download error if any.

## download.path()
- returns: <[Promise]<[null]|[string]>>

Returns path to the downloaded file in case of successful download.

## download.saveAs(path)
- `path` <[string]> Path where the download should be saved.
- returns: <[Promise]>

Saves the download to a user-specified path.

## download.suggestedFilename()
- returns: <[string]>

Returns suggested filename for this download. It is typically computed by the browser from the [`Content-Disposition`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Disposition) response header or the `download` attribute. See the spec on [whatwg](https://html.spec.whatwg.org/#downloading-resources). Different browsers can use different logic for computing it.

## download.url()
- returns: <[string]>

Returns downloaded url.

repository: khanhdodang/playwright

repo_name: khanhdodang/playwright


text:
---
title: Life Cycle
layout: page-fullwidth
permalink: "/LifeCycle/"
categories:
    - documentation
header:
   image_fullwidth: "header.png"
---

This document outlines some basic issues regarding life cycle managing for our various platforms.

## Android

JXcore runs as a thread in Android. Threads have an odd life cycle in Android, they basically run forever. It doesn't matter what state the app is in. The only way the thread goes away is if the process is killed. So this means we basically can ignore life cycle issues in Android for the moment. Of course the new Doze and Standby modes in Marshmallow may complicate that. We need to investigate, see [Issue #413](https://github.com/thaliproject/Thali_CordovaPlugin/issues/413).

If the process is killed then the JXcore thread goes with it. In theory this should be o.k. It really depends on PouchDB and LevelDB. LevelDB normally does non-blocking writes using the system write() APIs. In theory these should survive a process getting killed as they are kernel level activity. But who knows what Android actually does? Some day I hope we get to [Issue #450](https://github.com/thaliproject/Thali_CordovaPlugin/issues/450) and find out.

## iOS

See [here](https://github.com/jxcore/jxcore-cordova/issues/133#issuecomment-171800533) for the gory details. But the upshot is that we have to disconnect all client connections, shut down all servers and kill all incoming connections to servers (alas in Node.js just closing a server doesn't kill existing connections so you have to track and kill them manually) as soon as we get an onPause event from JXcore-cordova. This means that when we get an onResume event we have to start up everything again.

To deal with this we need to have a global start() method that encapsulates all the actions needs to set up the Thali environment and a global stop() method that tears everything down. On Android we would call start() once and never call stop(). On iOS we would call start() when we get onResume and stop() on onPause.

We also need to create our own subclasss of HTTP (for discovery) and HTTPS servers where we automatically track all incoming connections and then create a "globalClose" method that will kill all those connections as well as close the server.

Classes that open HTTP connections will need to have a way to force them close everything. Typically we just open connections for discovery and for replication so this should be reasonably easy to handle.

repository: thaliproject/thali

branch_name: refs/heads/gh-pages

repo_name: thaliproject/thali


text:
# AWS CloudFormation Templates for Linux
----

For Linux, we are providing a set of sample [AWS CloudFormation](https://aws.amazon.com/cloudformation/) templates that can be used as a basis for building your own templates for deploying a fully functional Tableau Server to Amazon Web Services (AWS), following best practices from AWS and Tableau Software.  This repository contains AWS CloudFormation templates to automatically deploy a standalone or cluster (distributed) architecture for Tableau Server into your AWS account.

For detailed information about deploying Tableau Server on AWS using these templates, view the [AWS Cloud deployment guide](https://onlinehelp.tableau.com/v10.5/offline/en-us/tableau-server-on-the-aws-cloud_linux.pdf).

### Standalone Templates
* **tableau-single-server-centos.json** is a basic template used to set up a single-node Tableau Server on Linux CentOS.
* **tableau-single-server-ubuntu.json** is a basic template used to set up a single-node Tableau Server on Linux Ubuntu.

### Cluster Templates
* **tableau-cluster-server-linux-simple.json** is a template used to set up a simple three-node Tableau Server cluster on Linux CentOS.
* **tableau-cluster-server-linux-existing-vpc.json** is a template for an advanced setup of a three-node Tableau Server cluster on Linux CentOS or Ubuntu into an existing VPC with 3 private subnets.

### Usage

1. On the AWS Management Console go to CloudFormation > Create Stack.
2. Upload the template file > Click Next.
3. Provide a "Stack name" and fill out the rest of the parameters including License, Registration, and Admin account information for your Tableau Server installation.
4. Continue through the rest of the screens and Accept the IAM warning (if applicable) and click Submit.
5. Once the status has changed to CREATE_COMPLETE. Click on the Outputs tab and copy the PublicDNSName and/or PublicIpAddress.
6. Verify that you can connect to Tableau Server by navigating to the TableauServerURL/LoadBalancerDNSName and logging in with the admin account that you specified.

#### Optional for Cluster Deployment:

To improve the security of your Tableau Server installation, Tableau recommends the use of SSL for protected communication with clients. Note that all examples that use SSL assume the use of AWS Certificate Manager and Amazon Route53.  When launching the stack, provide the following additional information:

* Provide the ARN (Amazon Resource Name) for the SSL certificate you wish to use. (See AWS Certificate Manager in the AWS Management Console.)
* Provide the fully qualified host name (FQHN) for your new server; this MUST match the name in the SSL certificate you are using!
* Provide the hosted zone id (in Route53) in which you'd like to create the server. You'll be provided a list of potential zones; remember to pick one that works with the SSL cert and FQHN you're using.

### General Troubleshooting

To aid in troubleshooting, we suggest disabling automatic rollback of the AWS CloudFormation stack. This allows examination of any log files left in place on the Tableau Server instance(s); rolling back destroys these instances, which means the log files are lost.


text:
# Hero-Squad
Hero squad is a web java application that allows users to fill in squads of superheroes with their powers, weaknesses and squad missions. Users decide the size of their squads and fill in their favorite heroes.

## BDD
1. Users must fill in the squad names, maximum size and mission.
2. Users can't add more heroes than the maximum size.
3. Heroes can only appear once, users ca't fill in a siingle hero in the same or different squads.

## Setup
* Navigate to the [Hero-Squad](https://github.com/craig-ke/Hero-Squad) repository on GitHub.
* Clone the project into your local device.
* Go to the project directory on the terminal and run `gradle run`
* Open your website on `localhost:4567` to view the website.
* The live website is at [heroku link]

## Dependencies
1. Java
2. Gradle

## Technologies Used
1. Java
2. HTML
3. CSS

## Author and Contact Information
Written by [Craig Lawrence Olonyi](https://github.com/craig-ke). Email<EMAIL_ADDRESS>
## Licence
Licenced under The MIT Licence (refer to the licence file) Copyright(c) 2020 Craig Lawrence Olonyi.

repository: craig-ke/Hero-Squad

repo_name: craig-ke/Hero-Squad


text:
---
name: Bug report
about: Create a report to help us improve
title: ''
labels: bug, triage needed
assignees: ''

---

<!--
Before filing a bug
- Ensure the bug reproduces on the latest commit of your release branch.
- Search existing issues and make sure this issue is not already filed.
-->

**Describe the bug**
A clear and concise description of what the bug is.

**To Reproduce**
Steps to reproduce the behavior:
1. Go to '...'
2. Click on '....'
3. Scroll down to '....'
4. See error

**Expected behavior**
A clear and concise description of what you expected to happen.

**Logs**
Please provide relevant logs to help diagnose your issue. To assist in debugging, please enable *info* level logging of the Azure Kinect Sensor SDK and attach any logs you have to this issue.
See [k4atypes.h](https://github.com/Microsoft/Azure-Kinect-Sensor-SDK/blob/feecae0456511ac734287571b101d10fd7292673/include/k4a/k4atypes.h#L184) for how to enable logs.

Please also enable *DEBUG* level logging of the ROS node.
See [roscpp/Overview/Logging](http://wiki.ros.org/roscpp/Overview/Logging) for how to enable ROS DEBUG logs.

**Screenshots**
If applicable, add screenshots to help explain your problem.

**Desktop (please complete the following information):**
 - OS: [e.g. Windows 10, Ubuntu]
 - Version [e.g. Version 1903, 18.04]

**Additional context**
Add any other context about the problem here.

branch_name: refs/heads/melodic


text:
# Voyager Setup for Marqant Pay

### Installation

Require the package through composer.
```
$ composer require marqant-lab/marqant-pay-voyager
```

Install Voyager (if you don't install it yet):
```
$ php artisan voyager:install
```
Assign any existing user as admin:
```
$ php artisan voyager:admin<EMAIL_ADDRESS>```
Or create a new one:
```
$ php artisan voyager:admin<EMAIL_ADDRESS>--create
```
enter name and password

Go to your.awesome.site.com/admin
to check it installation successfully.

Create seeders for billable model, for example App\\User

```
$ php artisan marqant-pay-voyager:seeders-billable App\\User
```
you will get this message:
```
  don't forget run '$ composer dump-autoload' before execute seeders.
  execute seeder run: '$ php artisan db:seed --class="VoyagerUsersDataTypesSeeder"'
  execute seeder run: '$ php artisan db:seed --class="VoyagerUsersDataRowsSeeder"'
  execute seeder run: '$ php artisan db:seed --class="VoyagerUsersMenuSeeder"'
  execute seeder run: '$ php artisan db:seed --class="VoyagerUsersPermissionsSeeder"'
  run '$ composer dump-autoload' and execute seeders. Done! 👍
```

you can execute them separately or add row to your DatabaseSeeder.php
and just run:
```
$ composer dump-autoload
$ php artisan db:seed
```
DatabaseSeeder.php
```php

use Marqant\MarqantPayVoyager\Seeds\VoyagerDatabaseSeeder as VoyagerDatabaseSeederMP;
...
class DatabaseSeeder extends Seeder
{
    /**
     * Seed the application's database.
     *
     * @return void
     */
    public function run()
    {
        ...
        $this->call(VoyagerDatabaseSeeder::class);
        $this->call(VoyagerDatabaseSeederMP::class);
    }
}
```
find created seeders at `database/seeds/`
and add to your database/seeds/VoyagerDatabaseSeeder.php
example:
```php
class VoyagerDatabaseSeeder extends Seeder
{
...
    public function run()
    {
        ...
        // Users
        $this->call(VoyagerUsersDataTypesSeeder::class);
        $this->call(VoyagerUsersDataRowsSeeder::class);
        $this->call(VoyagerUsersMenuSeeder::class);
        $this->call(VoyagerUsersPermissionsSeeder::class);
    }
}
```
now you ready execute seders
you can also add all created seeders to your project git repository

not completed, to be continue...

repository: marqant-lab/marqant-pay-voyager

gha_language: PHP

repo_name: marqant-lab/marqant-pay-voyager


text:
# einstein-riddle-generator
:game_die: Einstein Riddle Generator

[![GoDoc](https://godoc.org/github.com/moul/einstein-riddle-generator?status.svg)](https://godoc.org/github.com/moul/einstein-riddle-generator)

Check out the [demo on Appspot](http://einsteins-riddle.appspot.com) !

## Install

```console
$ go get github.com/moul/einstein-riddle-generator/...
```

## Example

```console
$ einstein-riddle
Riddle
------
- job:cop == pet:shark
- room:kitchen == nationality:scottish
- house-color:red == pet:beaver
- nationality:spannish == house-color:pink
- job:scientist == room:bedroom
- room:restroom == job:designer
- job:teacher == pet:poney
- pet:bird is direct on the right of job:architect
- nationality:american == room:bathroom
- nationality:french == room:garden
- house-color:yellow is on the left of nationality:english
- house-color:blue is in the middle
- room:bedroom == nationality:english
- pet:beaver is on the right of room:bathroom
- job:architect is direct on the right of nationality:french
- job:cop is on the far left
- pet:shark is on the far left
- nationality:american is on the far left

- where is pet:snake ?
- where is house-color:magenta ?

Answer
------
              1             2            3              4             5
room          2: bathroom   1: garden    1: kitchen     1: restroom   2: bedroom
job           2: cop        1: teacher   2: architect   1: designer   1: scientist
pet           2: shark      1: poney     0: snake       1: bird       2: beaver
house-color   0: magenta    1: yellow    1: blue        1: pink       1: red
nationality   2: american   2: french    1: scottish    1: spannish   2: english
```

## License

MIT

repository: moul/einstein-riddle-generator

gha_language: Go

repo_name: moul/einstein-riddle-generator


text:
# Changelog

All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.

### [3.0.2](https://github.com/accessible-ui/drawer/compare/v3.0.1...v3.0.2) (2020-08-10)

### [3.0.1](https://github.com/accessible-ui/drawer/compare/v3.0.0...v3.0.1) (2020-08-10)

## 3.0.0 (2020-07-20)

### ⚠ BREAKING CHANGES

* Renames useTarget() to useA11yTarget(), useTrigger() to useA11yTrigger(),
useCloseButton() to useA11yCloseButton()

* add new hooks and update disclosure ([5447699](https://github.com/accessible-ui/drawer/commit/544769924f8752109d6c5cc2261834f4b150a5c3))

repository: accessible-ui/drawer

repo_name: accessible-ui/drawer


text:
# deep-rl-trading
Portfolio optimization and trading using Deep Reinforcement Learning

### Example usage for scripts

#### Split historical data into train / test files:

```
python preprocess_daily_ohlc.py ../../../data/daily-us-stocks-etfs/Stocks/aapl.us.txt ../historical_data -s 0.9
```

repository: bbrzycki/deep-rl-trading

repo_name: bbrzycki/deep-rl-trading


text:
## Chain Metrics
* `lnd_chain_block_height`: best block height from lnd
* `lnd_chain_block_timestamp`: best block timestamp from lnd

## Channel Metrics
* `lnd_channels_open_balance_sat`: total balance of channels in satoshis
* `lnd_channels_pending_balance_sat`: total balance of all pending channels in satoshis
* `lnd_channels_bandwidth_incoming_sat`: total available incoming channel bandwidth within this channel
* `lnd_channels_bandwidth_outgoing_sat`: total available outgoing channel bandwidth within this channel
* `lnd_channels_pending_htlc_count`: total number of pending active HTLCs within this channel
* `lnd_channels_active_total`: total number of active channels
* `lnd_channels_inactive_total`: total number of inactive channels
* `lnd_channels_pending_total`: total number of inactive channels
* `lnd_channels_csv_delay`: CSV delay in relative blocks for this channel
* `lnd_channels_unsettled_balance`: unsettled balance in this channel
* `lnd_channels_fee_per_kw`: required number of sat per kiloweight that the requester will pay for the funding and commitment transaction
* `lnd_channels_commit_weight`: weight of the commitment transaction
* `lnd_channels_commit_fee`: weight of the commitment transaction
* `lnd_channels_sent_sat`: total number of satoshis we’ve sent within this channel
* `lnd_channels_received_sat`: total number of satoshis we’ve received within this channel
* `lnd_channels_updates_count`: total number of updates conducted within this channel

## Graph Metrics
* `lnd_graph_edges_count`: total number of edges in the graph
* `lnd_graph_nodes_count`: total number of nodes in the graph
* `lnd_graph_timelock_delta`: time lock delta for a channel routing policy
* `lnd_graph_min_htlc_msat`: min htlc for a channel routing policy in msat
* `lnd_graph_fee_base_msat`: base fee for a channel routing policy in msat
* `lnd_graph_fee_rate_msat`: fee rate for a channel routing policy in msat
* `lnd_graph_max_htlc_msat`: max htlc for a channel routing policy in msat

## Peer Metrics
* `lnd_peer_count`: total number of peers
* `lnd_peer_ping_time_microsecond`: ping time for this peer in microseconds
* `lnd_peer_sent_sat`: satoshis sent to this peer
* `lnd_peer_recv_sat`: satoshis received from this peer
* `lnd_peer_sent_byte`: bytes transmitted to this peer
* `lnd_peer_recv_byte`: bytes transmitted from this peer

## Wallet Metrics
* `lnd_utxos_count_confirmed_total`: number of all conf utxos
* `lnd_utxos_count_unconfirmed_total`: number of all unconf utxos
* `lnd_utxos_sizes_min_sat`: smallest UTXO size
* `lnd_utxos_sizes_max_sat`: largest UTXO size
* `lnd_utxos_sizes_avg_sat`: average UTXO size
* `lnd_wallet_balance_confirmed_sat`: confirmed wallet balance
* `lnd_wallet_balance_unconfirmed_sat`: unconfirmed wallet balance
* `lnd_tx_num_confs`: number of confs

repository: Roasbeef/lndmon

repo_name: Roasbeef/lndmon


text:
---
layout: post
year: 2018
venue: workshop paper
title: Stream Characteristics for First-Order Monitoring
authors: Joshua Schneider, Srđan Krstić
details: In the Benchmark Challenge of the 18th International Conference on Runtime Verification (RV 2018).
pdf: /assets/papers/rv18-benchmark.pdf
slides: /assets/papers/rv18-benchmark-slides.pdf
doi:
bibtex: /assets/papers/rv18-benchmark.txt
draft: true
---

We present a benchmark suite for generating and reproducing streams of time-stamped parametric events. The benchmark generates a stream according to user-defined characteristics and reproduces it at a user-defined velocity. The characteristics relate to the frequencies of the different events and their data values. The benchmark also provides the expected result of monitoring the generated streams against a family of first-order temporal specifications. We envision the benchmark being used to attest the performance of online first-order monitors.


text:
# Dynamic queries flag migration

## What does this migration do?

In Angular version 8, a schematic added `static` flags to all `@ViewChild()` and `@ContentChild()` queries.
This was the first step towards changing the default behavior.
With version 9, the default value changes to `static: false` and the flag becomes optional.

This schematic scans classes in the compilation and for each class, checks if the members have a `@ViewChild()` or `@ContentChild()` query with the `static` flag set to `false`.
If so, the schematic removes the flag, as it now matches the default.

**Before**:

@ViewChild('foo', {static: false}) foo: ElementRef;

@ViewChild('bar', {static: true}) bar: ElementRef;

**After**:

@ViewChild('foo') foo: ElementRef;

// this query doesn't change because the static value is true
@ViewChild('bar', {static: true}) bar: ElementRef;

**NOTE**:

The flag is not supported in `@ViewChildren()` or `@ContentChildren()` queries, so the schematic will not check these properties.

## Why is this migration necessary?

This schematic performs a code cleanup to remove `static` flags that match the default, as they are no longer necessary.
Functionally, the code change should be a noop.

| Versions         | Details |
|:---              |:---     |
| Before version 9 | Angular figured out the static or dynamic nature of a query automatically, based on how the template was written. Looking at templates in this way, however, caused buggy and surprising behavior \(see more about that in the [Static Query Migration Guide](guide/static-query-migration#what-does-this-flag-mean)\). |
| As of version 9  | Angular uses dynamic queries \(`static: false`\) by default, which simplifies queries. Developers can still explicitly set a query to `static: true` if necessary.                                                                                |

### What is the difference between static and dynamic queries?

The `static` option for `@ViewChild()` and `@ContentChild()` queries determines when the query results become available.

| Queries                             | Details |
|:---                                 |:---     |
| Static queries \(`static: true`\)   | The query resolves once the view has been created, but before change detection runs. The result, though, will never be updated to reflect changes to your view, such as changes to `ngIf` and `ngFor` blocks.                           |
| Dynamic queries \(`static: false`\) | The query resolves after either `ngAfterViewInit()` or `ngAfterContentInit()` for `@ViewChild()` and `@ContentChild()` respectively. The result will be updated for changes to your view, such as changes to `ngIf` and `ngFor` blocks. |

For more information, see the following entries in the [Static Query Migration Guide](guide/static-query-migration):

*   [How do I choose which `static` flag value to use: `true` or `false`?](guide/static-query-migration#how-do-i-choose-which-static-flag-value-to-use-true-or-false)
*   [Is there a case where I should use `{static: true}`?](guide/static-query-migration#is-there-a-case-where-i-should-use-static-true)

## What does this mean for libraries?

In order to support applications that are still running with version 8, the safest option for libraries is to retain the `static` flag to keep the resolution timing consistent.

| Library and application combination                        | Details |
|:---                                                        |:---   |
| Libraries on version 9 with applications running version 8 | The schematic won't run on libraries. As long as libraries retain their `static` flags from version 8, they should work with apps on 8. |
| Libraries on version 8 with applications running version 9 | Libraries will have explicit flags defined. The behavior with explicit flags has not changed.                                           |

### What about applications using non-migrated libraries?

Because this is a code cleanup that is a noop, non-migrated libraries will work the same either way.

@reviewed 2022-02-28

repository: angular/angular-ja

gha_language: HTML

repo_name: angular/angular-ja


text:
---
uid: omfIngressTopics
---

# Topics (legacy)

**Note:** OMF topics and subscriptions have been replaced by <xref:omf-ingress-omf-connections>. See <xref:OMFmigration>.

OMF topics aggregate OMF messages received from one or more clients and make them available for consumption by a subscription.

## Topic information

A topic must contain at least one Client Id. Clients may be added to or removed from an existing topic. A given client may belong to multiple topics in separate namespaces.

When you create a topic, OMF messages sent from the topic's associated clients are routed to a queue where they can be consumed by a subscription. This queue makes OMF messages available to subscriptions for up to seven days. While the OMF messages are in the topic queue, they are not available for retrieval via an API. They must first be consumed by a subscription and forwarded to a data store. The topic queue stores the OMF messages in the region of its namespace.

## Topics API

- [Topics](xref:omf-ingress-topics)

repository: osisoft/OCS-Docs

repo_name: osisoft/OCS-Docs


text:
# Soba

[![Documentation][godoc-img]][godoc-url]
![License][license-img]
[![Build Status][circle-img]][circle-url]
[![Report Status][goreport-img]][goreport-url]

A highly configurable logging framework.

[![Soba][soba-img]][soba-url]

## Introduction

Soba is a highly configurable logging framework.
If you require a simpler solution, I highly recommend you one of the following:

 * [Zerolog](https://github.com/rs/zerolog)
 * [Zap](https://github.com/uber-go/zap)

> **NOTE:** Soba is still a work in progress, please be advised.

### Inspirations

Soba is modeled after Java's Logback and log4j libraries, but also from Zerolog and Zap logger from the Go ecosystem.

## Architecture

The basic units of configuration are **appenders**, **encoders**, **filters**, and **loggers**.

### Appenders

An appender takes a log entry and logs it somewhere, like for example, to a file, the console, or the syslog.

### Encoders

An encoder is responsible for taking a log record, transforming it into the appropriate output format,
and writing it out. An appender will normally use an encoder internally.

### Filters

Filters are associated with appenders and, like the name would suggest, filter log events coming into that appender.

### Loggers

A log event is targeted at a specific logger, which are identified by string names.

Loggers form a hierarchy: logger names are divided into components by `.`:
one logger is the ancestor of another if the first logger's component list is a prefix of the second logger's
component list.

Loggers are associated with a maximum log level. Log events for that logger with a level above the maximum will be
ignored. The maximum log level for any logger can be configured manually. If not, the level will be inherited
from the logger's parent.

Loggers are also associated with a set of appenders. Appenders can be associated directly with a logger.
In addition, the appenders of the logger's parent will be associated with the logger unless the logger
has its additivity set to false. Log events sent to the logger that are not filtered out by the logger's
maximum log level will be sent to all associated appenders.

The "root" _(or default)_ logger is the ancestor of all other loggers.
Since it has no ancestors, its additivity cannot be configured.

## Versioning or Vendoring

Expect compatibility break from `master` branch.

Using [Go dependency management tool](https://github.com/golang/dep) is **highly recommended**.

> **NOTE:** semver tags or branches could be provided, if needed.

## License

This is Free Software, released under the [`MIT License`][license-url].

[soba-url]: https://github.com/novln/soba
[soba-img]: soba.png
[godoc-url]: https://godoc.org/github.com/novln/soba
[godoc-img]: https://godoc.org/github.com/novln/soba?status.svg
[license-img]: https://img.shields.io/badge/license-MIT-blue.svg
[license-url]: LICENSE
[circle-url]: https://circleci.com/gh/novln/soba/tree/master
[circle-img]: https://circleci.com/gh/novln/soba.svg?style=shield&circle-token=253294d3873e767a02475e5b83533b683b2d401f
[goreport-url]: https://goreportcard.com/report/novln/soba
[goreport-img]: https://goreportcard.com/badge/novln/soba
[zap-url]: https://github.com/uber-go/zap
[zerolog-url]: https://github.com/rs/zerolog

repository: novln/soba

repo_name: novln/soba


text:
---
layout: post
title:  "100 Days of Code Day 20 report - Homebrew CSS Selectors"
date:   2018-09-09 10:47:00
categories: 100DaysOfCode
---

# Sublime text alias and homebrew broken

Lost some time today after I wanted to merge my fix for the header font

» git merge issue-39
subl -n -w: subl: command not found
error: There was a problem with the editor 'subl -n -w'.
Not committing merge; use 'git commit' to complete the merge.

The alias I had set for Sublime Text ("subl"), didn't seem to work anymore.
I thought I had installed with the homebrew cask install but I can't find any trace of that install. [Homebrew](https://brew.sh/) is a package manager for Mac OS X. Within the whole Homebrew ecosystem, [Homebrew Cask](https://github.com/Homebrew/homebrew-cask) goes beyond the installation of CLI packages, but also takes care of nicely installing bigger entire Mac OS X Applications automatically, like in my case, the Sublime Text editor.

Normally, I try to install *everything* with Homebrew cask, because, as is now the case, I run into trouble wondering if I installed something manually or through cask.

And when running "brew cask list", instead of getting the list of installed casks, it's now suddenly complaining about my java7 cask with

```
Error: Cask 'java7' is unreadable: undefined method `undent' for #<String:0x00000001032f89c0>
```

Found out it was not my fault and applied the current one liner solution [that gets suggested here](https://github.com/Homebrew/homebrew-cask/issues/49716).

Noticed that the cask sublime-text3 is no longer maintained, and that it's now just called sublime-text. Uninstalled the old sublime-text3 cask and installed the new, generic one.

I failed to uninstall the sublime-text3 cask, but it seems like my new installation of the sublime-text cask next to it just works and also fixed the alias for 'subl'.

In case I ever want to fix it further, here are the errors I got during uninstalling/zapping:

```
» brew cask uninstall sublime-text3
==> Uninstalling Cask sublime-text3
==> Running uninstall process for sublime-text3; your password may be necessary
==> Quitting application ID com.sublimetext.3
Error: It seems there is already an App at '/usr/local/Caskroom/sublime-text3/3103/Sublime Text.app'.
 ✘ bram@Sugarsmooth  ~ 
» brew cask zap sublime-text3
==> Implied "brew cask uninstall sublime-text3"
==> Running uninstall process for sublime-text3; your password may be necessary
==> Quitting application ID com.sublimetext.3
Error: It seems there is already an App at '/usr/local/Caskroom/sublime-text3/3103/Sublime Text.app'.
```

# CSS Fix one: make navbar white blue, and then fade to white
Where I was stuck yesterday:

```CSS
.navbar-custom a {
  color: #005989;
}
.navbar-custom.top-nav-collapse-font a {
  color: white;
}
```

Fix I ended up implementing that worked, by sheer trial and error and not by really understanding (yet) how the overrides really work & what takes preference over what. Deployed!

```CSS
.navbar-custom a {
  color: #005989;
}
a.top-nav-collapse-font {
  color: white;
}
```

# Day 21 Plan

* CSS: Down button at "basic principles" colour change
* CSS: revisit contrast for sections that are entirely white in background
* Investigate empty rows with TODO message showing up in the list of recently scanned repos

# Future days - Analyzer.atmire.com work

* Change String based implementation of error message handling with types and objects, according to Antoine Snyers recent Atmire DevTalk.
* Change string based implementation of the different browse styles to an object, according to Antoine Snyers recent Atmire DevTalk
* Add recently verified items to the homepage.
* Optimize my hideous methods for getItemcount and getRepoCount.
* Re-test the check if we return the right repository to a user who tries to add a new one
* Updating a repository: touch/change the base URL or not?
* Batch ingest: switch to newer add repository methods.
* WCAG testing against the start page to ensure it's accessible for people who rely on assistive tools.
* CSS: Down button at "basic principles" colour change
* CSS: revisit contrast for sections that are entirely white in background
* Investigate empty rows with TODO message showing up in the list of recently scanned repos

# Future Days - other ideas

1. Switch to a different project: start working on DSpace 7 Angular
2. Setup IDEA so I can start editing these blogposts from there, instead of in a text editor
3. Developer productivity: Get my IntelliJ IDEA Shortcuts in order (CMD+1, CMD+/, ...)

# Future Days - Atmire.com work

Investigate and work on search engine optimization (SEO) for the main atmire.com website.

# Future Days - Learning just for learning

* CSS: Go through the fabulous [CSS Diner](https://flukeout.github.io/)

# Sustainability - Raising the stakes - Looking for sponsors

I have raised the stakes by
* giving €100 to Charity:Water for every day I miss.
* asking people to sponsor me and to give an amount to a charity for each day I successfully complete

This way, every day would be a win. These are the rules that I'll apply:

1. I can anticipate or fix a lost day by doing an hour extra the day before, or an hour extra the day after. In theory this means I can maximally compensate a streak of 2 missed days.
2. Goal is to have a steady frequency, so I can't just do 8h on a sunday to get myself off the hook for the next 7 days.
3. Sponsor commitments are fully voluntarily: any sponsor can back out at any time.
4. My commitment is fully voluntarily: if I want to change the rules or back out, I can at any time.

In September, these are already days that will be very tough:
* Sep 8,9 - FoM Lanparty w friends
* Sep 14,15,16,17 - Abroad for a wedding
* Sep 27,28 - Supernova conference Antwerp

So that's already a lot of exposure to potentially missed days.

I will raise the stakes this way and gather money for Charity:Water. Let me know if you want to sponsor me and for how much per completed day in September. September 1st is the first successfully completed day.

# September tracking

Will only log the failed days here. No failed days so far.

# Thanks to the following sponsors!

1. Jan & Hilde: €2 per successful day (Yes, these are my parents)

extension: markdown


text:
# gulp-nunit-runner

[![NPM version](http://img.shields.io/npm/v/gulp-nunit-runner.svg?style=flat)](http://npmjs.org/gulp-nunit-runner)
[![NPM downloads](http://img.shields.io/npm/dm/gulp-nunit-runner.svg?style=flat)](http://npmjs.org/gulp-nunit-runner)
[![Build Status](http://img.shields.io/travis/keithmorris/gulp-nunit-runner/master.svg?style=flat)](https://travis-ci.org/keithmorris/gulp-nunit-runner)
[![Dependencies Status](http://img.shields.io/david/keithmorris/gulp-nunit-runner.svg?style=flat)](https://david-dm.org/keithmorris/gulp-nunit-runner)
[![DevDependencies Status](http://img.shields.io/david/dev/keithmorris/gulp-nunit-runner.svg?style=flat)](https://david-dm.org/keithmorris/gulp-nunit-runner#info=devDependencies)

A [Gulp.js](http://gulpjs.com/) plugin to facilitate running [NUnit](http://www.nunit.org/) tests on .NET assemblies. Much of this work was inspired by the [gulp-nunit](https://github.com/stormid/gulp-nunit) plugin.

## Installation

From the root of your project (where your `gulpfile.js` is), issue the following command:

```bat
npm install --save-dev gulp-nunit-runner
```

## Usage

The plugin uses standard `gulp.src` globs to retrieve a list of assemblies that should be tested with Nunit. By default the plugin looks for the NUnit console runner in your `PATH`. You can optionally specify the NUnit `bin` folder or the full path of the runner as demonstrated below. You should add `{read: false}` to your `gulp.src` so that it doesn't actually read the files and only grabs the file names.

```javascript
var gulp = require('gulp'),
    nunit = require('gulp-nunit-runner');

gulp.task('unit-test', function () {
    return gulp.src(['**/*.Test.dll'], {read: false})
        .pipe(nunit({
            executable: 'C:/nunit/bin/nunit-console.exe',
        }));
});

```
This would result in the following command being executed (assuming you had Database and Services Test assemblies.)

```bat
C:/nunit/bin/nunit-console.exe "C:\full\path\to\Database.Test.dll" "C:\full\path\to\Services.Test.dll"
```

Note: If you use Windows paths with `\`'s, you need to escape them with another `\`. (e.g. `C:\\nunit\\bin\\nunit-console.exe`). However, you may also use forward slashes `/` instead which don't have to be escaped.

You may also add options that will be used as NUnit command line switches. Any property that is a boolean `true` will simply be added to the command line, String values will be added to the switch parameter separated by a colon and arrays will be a comma seperated list of values.

For more information on available switches, see the NUnit documentation:

[http://www.nunit.org/index.php?p=consoleCommandLine&r=2.6.3](http://www.nunit.org/index.php?p=consoleCommandLine&r=2.6.3)

```javascript
var gulp = require('gulp'),
    nunit = require('gulp-nunit-runner');

gulp.task('unit-test', function () {
    return gulp.src(['**/*.Test.dll'], {read: false})
        .pipe(nunit({
            executable: 'C:/nunit/bin/nunit-console.exe',
            options: {
                nologo: true,
                config: 'Release',
                transform: 'myTransform.xslt'
            }
        }));
});
```
This would result in the following command:

```bat
C:/nunit/bin/nunit-console.exe /nologo /config:"Release" /transform:"myTransform.xslt" "C:\full\path\to\Database.Test.dll" "C:\full\path\to\Services.Test.dll"
```

## Options

Below are all available options. With the release of NUnit 3.x, some options have been removed and some added. Version specific options have been labeled with the version they apply to. For more information on deprecated options see [here](https://github.com/nunit/nunit/wiki/Breaking-Changes#console-command-line-options). For more information on new options see [here](https://github.com/nunit/nunit/wiki/Console-Command-Line).

```js
nunit({

    // The NUnit bin folder or the full path of the console runner.
    // If not specified the NUnit bin folder must be in the `PATH`.
    executable: 'c:/Program Files/NUnit/bin',

    // [2.x] If the full path of the console runner is not specified this determines
    // what version of the console runner is used. Defaults to anycpu.
    // NOTE: This has been superseded by the 'x86' option below in 3.x.
    // http://www.nunit.org/index.php?p=nunit-console&r=2.6.3
    platform: 'anycpu|x86',

    // [2.x] Output TeamCity service messages.
    // NOTE: This has been superseded by the 'teamcity' option below in 3.x.
    // https://confluence.jetbrains.com/display/TCD8/Build+Script+Interaction+with+TeamCity
    teamcity: true|false,

    // Do not throw a gulp error and stop the stream on failing NUnit tests.
    // This is useful on TeamCity, where tests can be muted after the tests
    // are run, which allow the build to pass.
    continueOnError: true|false,

    // The options below map directly to the NUnit console runner. See here
    // for more info: http://www.nunit.org/index.php?p=consoleCommandLine&r=2.6.3
    options: {

        // [3.x] Name of the test case(s), fixture(s) or namespace(s) to run.
        test: ['TestSuite.Unit', 'TestSuite.Integration'],

        // [3.x] Name of a file containing a list of the tests to run, one per line.
        testist: 'TestsToRun.txt',

        // [2.x] Name of the test case(s), fixture(s) or namespace(s) to run.
        // NOTE: This has been superseded by the 'test' option above in 3.x.
        run: ['TestSuite.Unit', 'TestSuite.Integration'],

        // [2.x] Name of a file containing a list of the tests to run, one per line.
        // NOTE: This has been superseded by the 'testlist' option above in 3.x.
        runlist: 'TestsToRun.txt',

        // [2.x] List of categories to include.
        include: ['BaseLine', 'Unit'],

        // [2.x] List of categories to exclude.
        exclude: ['Database', 'Network'],

        // [3.x] Test selection expression
        where: 'cat != critical',

        // Project configuration (e.g.: Debug) to load.
        config: 'Debug',

        // Process model for tests.
        process: 'Single|Separate|Multiple',

        // AppDomain Usage for tests.
        domain: 'None|Single|Multiple',

        // Framework version to be used for tests.
        framework: 'net-1.1',

        // [3.x] Run tests in a 32-bit process on 64-bit systems.
        x86: true|false,

        // [3.x] Dispose each test runner after it has finished running its tests.
        "dispose-runners": true|false,

        // Timeout for each test case in milliseconds.
        timeout: 1000,

        // [3.x] Random seed used to generate test cases.
        seed: 5150,

        // [3.x] Number of worker threads to be used in running tests.
        workers: 5,

        // Stop after the first test failure or error.
        stoponerror: true|false,

        // Wait for input before closing console window.
        wait: true|false,

        // [3.x] Pause before run to allow debugging.
        pause: true|false,

        // Work directory for output files.
        work: 'BuildArtifacts',

        // File to receive test output.
        output: 'TestOutput.txt',

        // File to receive test error output.
        err: 'TestErrors.txt',

        // Name of XML result file (Default: TestResult.xml)
        result: 'TestResult.xml',

        // [3.x] Save test info rather than running tests. Name of output file.
        explore: 'TestInfo.xml',

        // Suppress XML result output.
        noresult: true|false,

        // Label each test in stdOut.
        labels: true|false,

        // Set internal trace level.
        trace: 'Off|Error|Warning|Info|Verbose',

        // [3.x] Tells .NET to copy loaded assemblies to the shadowcopy directory.
        shadowcopy: true|false,

        // [2.x] Disable shadow copy when running in separate domain.
        // NOTE In 3.x, The console runner now disables shadow copy by
        // default. use new 'shadowcopy' option in 3.x to turn it on.
        noshadow: true|false,

        // [3.x] Turns on use of TeamCity service messages.
        teamcity: true|false,

        // [3.x] Suppress display of program information at start of run.
        noheader: true|false,

        // [3.x] Displays console output without color.
        nocolor: true|false,

        // [3.x] Display additional information as the test runs.
        verbose: true|false,

        // [2.x] Do not display the logo.
        nologo: true|false,

        // [2.x] Do not display progress.
        nodots: true|false,

        // [2.x] Apartment for running tests (Default is MTA).
        apartment: 'MTA|STA',

        // [2.x] Disable use of a separate thread for tests.
        nothread: true|false,

        // [2.x] Base path to be used when loading the assemblies.
        basepath: 'src',

        // [2.x] Additional directories to be probed when loading assemblies.
        privatebinpath: ['lib', 'bin'],

        // [2.x] Erase any leftover cache files and exit.
        cleanup: true|false

    }
});
```

## Release Notes

### 1.2.3

- Updated event-stream dependency for security issue. (thanks [alexmaris](https://github.com/alexmaris))

### 1.2.2

- Add parsing for number type options/switches ([alexmaris](https://github.com/alexmaris))

### 1.2.1

- Update dev dependencies

### 1.2.0

- Add continueOnError option ([cable729](https://github.com/cable729))

### 1.1.0

- Force using the `mono` command to execute the `nunit-console.exe` on non-windows systems ([dbones](https://github.com/dbones))

### 1.0.0

- Add handling of where switch for nunit3-console test runner ([Tuukka Turto](https://github.com/tuturto))
- Dependency update
- Update Travis tests to also test on node versions 4.x and 6.x
- Bump version to 1.0.0

### 0.5.2

- Add check for output file before creating the TeamCity output. ([Mike O'Brien](https://github.com/mikeobrien))
- Clean up publish package with `.npmignore`

### 0.5.1
- Fix #13 Running from Visual Studio Task Runner Fails

### 0.5.0
- Make the command line switch aware of OS so that it uses the correct character when running under mono on linux/mac.

### 0.4.2 (28 June 2015)
- Add NUnit 3.x options and labled 2.x options to README.md

### 0.4.1 (20 Nov 2014)
- Remove quotes around multi args.

### 0.4.0 (13 Nov 2014)
- Add build script with test, lint and watch.
- Add Travis CI integration.
- Add a TeamCity reporter.
- Add support for multi options e.g. include, exclude and privatebinpath.
- Add the ability to omit the explicit nunit path entirely and rely on it being in the PATH.
- Add the ability to just supply the path to the bin folder but not explicitly specify the filename.
- Add a platform flag that goes along with both exectable options to chose the x86 or anycpu version of nunit; defaults to anycpu.
- Document all the config options in the README.

### 0.3.0 (30 Sept 2014)
- Fixes large amount of writes by NUnit tests causing node to crash
- Switched to using `child_process::spawn`, much simpler command building.

### 0.2.0 (28 Sept 2014)
- Fixes #2 "Simultaneous runs of test tasks cause duplication"
- Major rearchitecture of plugin by @VoiceOfWisdom
- Adds release notes to README.md

### 0.1.2 (4 Sept 2014)
- Fixes #1 "runner fails if executable path has space"

### 0.1.1 (10 Aug 2014)
- Documentation update

### 0.1.0 (10 Aug 2014)
- Initial release

repository: keithmorris/gulp-nunit-runner

branch_name: refs/heads/develop

repo_name: keithmorris/gulp-nunit-runner


text:
---
title: Setting Up Weekly Goals
tags:
  - personal
  - productivity
---

In my [previous article]({{ '/posts/on-prioritizing-side-projects/' | url }}) I mentioned my struggle to manage and complete my side projects. While I have gotten better at time management and organization, I still struggle to keep my momentum.

In hopes of getting better at being accountable, I’m trying to limit my goals to a one-week time frame. I set up a small list of no more than three or four goals to complete by the end of the week. These goals have to be doable within that time frame. By the end of each week, I will reflect on these goals and evaluate my progress.

To be more disciplined, I’ve started to tweet my goals with a [#myWeeklyGoals](https://twitter.com/search?q=%23myWeeklyGoals%20&src=typd) hashtag. I feel like announcing my goals publicly will put more pressure on me to actually do  them. By the end of the week, I plan to tweet about my progress on each goal.

Here is why I’m really interested in trying this weekly goals method:

- **Forces me to break down my goals into smaller tasks with limited scope:** I have a huge list of broad project ideas that I never attempted to tackle because I am intimidated by their large scope. Having tasks broken into smaller actionable ones makes them more approachable.
- **Enables me to have better life balance:** For example, I sometimes feel guilty for having fun because there is this pressing feeling that I should be doing something productive. Having weekly goals means I can have a better reward system in my life.
- **Disciplines me to stay on track**: There are tasks which are no fun to do but required (called being an adult) such as calling the insurance company, laundry, meal prep, etc. Weekly goals along with a reward system help me get better at those kinds of tasks.
- **Helps me to be more focused:** Having set goals for the week prevents me from being tempted to switch to other tasks or projects.

Finally, I also want to clarify that goals can be literally anything you want and not limited to professional ones. Here is an example of some goals I might set for myself in the future:

- Finishing a certain number of chapters of a book I’m reading.
- Going to the gym 5 times a week.
- Finishing up a tutorial to learn a particular tech.
- Building one or two small core features of a side project.
- Cooking my own meals at least 3 times within a week.
- Finishing a blog post… done!

Join me in this initiative… share your goals on twitter [#myWeeklyGoals](https://twitter.com/search?q=%23myWeeklyGoals%20&src=typd) and post updates regularly. Let’s try it together! :)


text:
##### Prop

*  `gap` | `row_gap` | `rowGap` | `column_gap` | `columnGap` | **Type**: String | **Values**: xxs | xs | sm | md | lg | xl | none

- Setting the gap prop sets the row_gap || rowGap and the column_gap || columnGap props to the same size and creates equal space within a flex container.

- Setting the row_gap || rowGap prop creates space between rows in a flex container.

- Setting the column_gap || columnGap prop creates space between columns in a flex container.

license: ISC

repository: powerhome/playbook

gha_license_id: ISC

repo_name: powerhome/playbook


text:
# ExProxypay
[![](https://img.shields.io/badge/proxypay-elixir-blue)](https://developer.proxypay.co.ao/v2/)
[![](https://img.shields.io/badge/nextbss-opensource-blue.svg)](https://www.nextbss.co.ao)

**A library that helps you easily interact with the ProxyPay API using the elixir programming language.**

## Installation

If [available in Hex](https://hex.pm/docs/publish), the package can be installed
by adding `ex_proxypay` to your list of dependencies in `mix.exs`:

```elixir
def deps do
  [
    {:ex_proxypay, "~> 0.1.0"}
  ]
end
```

### Create a payment request with ProxyPay
Full code to create a payment request using ProxyPay.
```elixir
  config = %Config{api_key: "YOUR_API_KEY", environment: "SANDBOX"}
  {state, id} = ExProxyPay.generate_reference_id(config)
  ExProxyPay.create_reference(id, %PaymentReference{amount: 100, end_datetime: "2020/03/14", custom_fields: nil}, config)
```

output:
```terminal
  {:ok, "Reference was created or updated successfully"}
```

### Configure ProxyPay api key and environment:
To interact with ProxyPay you will need to define the environment to interact with and the api key for authentication.

You have at your disposal two environments: "SANDBOX" and "PRODUCTION".

```elixir
  config = Config.init(%{api_key: "YOUR_API_KEY", environment: "SANDBOX"})
```

### Get Payments
Returns Payment events stored on the server that were not yet Acknowledged

```elixir
  ExProxyPay.get_payments(n, config)
```

### Create reference id
This function generates a unique Reference Id to be associated with a given payment reference

```elixir
  {state, id} = ExProxyPay.generate_reference_id(config)
```

### Create Reference using reference id
The generateReference method creates or updates a payment reference with given Id
```elixir
  reference = %PaymentReference{amount: 100, end_datetime: "2020/03/14", custom_fields: nil}
  ExProxyPay.create_reference(id, reference, config)
```

### Delete Reference
This endpoint deletes a reference with given Id

```elixir
  ExProxyPay.delete_reference(id, config)
```

### Acknowledge a payment
This method is used to acknowledge that a payment was processed

```elixir
  ExProxyPay.acknowledge_payment(id, config)
```

License
----------------

The library is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

repository: ArlindoJose/proxypay-elixir

repo_name: ArlindoJose/proxypay-elixir


text:
---
templateKey: index-page
intro:
  heading: ""
  button: WHAT IS GOING ON?
  image_item:
    image: /img/header.jpg
    caption: Photo by [Job Wind](https://monkeystation.nl/)
  text: >-
    # This is going on

    Indonesia is drowning in plastic. **Every year 1.29 million tonnes of plastic** ends up in the **oceans of Indonesia** (about the weight of a million cars). The consequences for the environment and the ecological system are disastrous.

    Plastic is a chemical product and therefore **hardly biodegradable**. If it ends up in the environment, it will remain there for hundreds of years. For the most common plastics a decomposition time of **400 to 600 years** applies.

    Most of this plastic waste ends up in the ocean **via rivers**. People throw their trash into the rivers and the rivers carry it out to the ocean. These people often have **little knowledge** of the plastic pollution problem and have **no proper waste management** at their disposal. They are left with two options to get rid of their trash: **burn it or dump it in a river**.
mission:
  image_item:
    image: /img/why-problem2.jpg
    caption: Photo by [Job Wind](https://monkeystation.nl/) [[Google
      Maps](https://goo.gl/maps/7dxQ9evqARWsLTX36)]
  heading: ""
  vision: >-
    # Our vision

    An Indonesia where **no** **plastic waste** ends up in the environment, including its rivers and oceans.
  mission: >-
    # Our mission

    Our goal is to put a halt to plastic waste ending up in Indonesia’s oceans. To do this we want to:

    * **Educate** local communities about the cause and effect of plastic waste ending up in the oceans.

    * **Motivate** regencies to implement waste management solutions.

    * **Provoke** controversy by exposing the gravity of the situation and the lack of responsibility from government and industry.

    * **Advocate** governmental policies that reduce the use of plastic, enforce waste management, stimulate alternative plastic pollution reducing solutions and raise national awareness.
  values: >-
    # Our values

    Cleanup Indonesia is an independent campaigning organisation, which uses **online communication** to raise national **awareness** about Indonesia’s **oceans plastic pollution crisis**.
strategy:
  image_item:
    image: /img/how-ocean.jpg
    caption: Photo by [Job Wind](https://monkeystation.nl/) [[Google
      Maps](https://goo.gl/maps/RpeKk97iPqJgM7bBA)]
  heading: Strategy
  text: >-
    One of the **biggest struggles** for environmental organisations and even
    government is **being effective** in reachingthe fast amount of people
    living in the **remote areas** of Indonesia. Indonesia is the largest
    archipelago in the world with about 6000 inhabited islands and over 75.000
    villages scattered over its lands. Many organisations end up focussing on
    just a few of these areas, or they take a more international approach to
    raise awareness among a non-local audience.\

    This is where Cleanup Indonesia **stands out**. We actually **have found a way** to reach out to all of these communities and deliver our **clear and educational message** in an effective manner. For this we can thank our experience from working in the advertising industry.

    The concept is simple and consists of three key pillars:
  items:
    - item: >-
        **1. An educational website**\

        The core of Cleanup Indonesia is our educational website **[Membersihkan Indonesia](https://membersihkan.id/)**. It targets the people that live in the rural areas of Indonesia. The website provides a clear explanation of the cause and effect of the problems. It stimulates visitors to make a difference and spread the word, and also offers realistic solutions to regencies and local government. We strongly believe that delivering this website to the local communities **will directly result in a large reduction of plastic ending up in rivers** and the use of single-use plastic as a whole.
    - item: >-
        **2. Social media adverting**\

        How do we get our educational website to these local communities? We use the power of **social media advertising**! This may sound like an overly modern solution for a remote audience, but internet coverage and social media usage is quite up to par in Indonesia. With Facebook alone, we have a potential maximum target **audience of 130 million people**, which is about **half of the total population**. One other great advantage of social media advertising in Indonesia is that it’s very cheap. We can reach **2 million** Indonesian Facebook **users with a budget of only €100** ($110).
    - item: >-
        **3. Social community building**\

        An additional advantage of running social media campaigns is that it is a great way to build up a social community. Having a strong social community gives us a direct connection with our target audience and provides us with important exposure.
plan:
  image_item:
    image: /img/bali-dump.jpg
    caption: Photo by [Zainul Yasni](https://unsplash.com/@zainulyasni6118)
  heading: Action plan
  text: >-
    Although the costs of social media advertising is low in Indonesia, we do
    have a respectable sized target audience. Thus far our campaigns have been
    self financed, but to really be able to make an impact **we need your
    support!** By making a much needed
    **[donation](https://cleanupindonesia.org/support-us/)** you will join
    Cleanup Indonesia in our work **to protect our precious oceans and change
    the way plastic is being used and disposed of in Indonesia**.

    There are three types of campaigns that we are focussing on:
  items:
    - item: >-
        **Campaigns that raise awareness among the main target audience.**\

        Our primary goal is to bring our educational website under the attention of Indonesians living in remote rural areas. To do this we run campaigns with a targetaudience consisting of **all Indonesian Facebook users excluding the mayor cities**. The size of this target audience is **48 million people**. In order to **reach** them all we would need a total of €2400 ($2700).
    - item: >-
        **Campaigns that generate traffic to the educational website.**\

        This type of campaign is charged for per actual visitor to the website. In Indonesia this costs around €0.08 per visitor. Our first goal is to get at least 0.1% of the target audience to our website, so **48.000 visitors**. This comes down to €3800 ($4250).
    - item: >-
        **Campaigns that raise awareness among the total population.**\

        We run this type of campaign to raise **national awareness**, grow our **social media presence** and increase our chances of being picked up by the **media**. To reach the maximum of **130 million**Indonesian Facebook users, we would need a total of €6500 ($7300).
results:
  image_item:
    image: /img/other-solutions.jpg
    caption: Photo by [Get Plastic](http://www.getplastic.org/)
  heading: Key results
  text: The campaigns we’ve ran so far have been focussed on raising national
    awareness and building our social media presence. Now that we have
    established a strong presence, we are ready to run campaigns that deliver
    our education website to our target audience.
  items:
    - item: >-
        ### Lost & Found - campaign

        A campaign to **raise awareness** among the total population and to **stimulate** the growth of **our social community**. The campaign consisted of 16 ads, each displaying a disposed plastic bottle packaging on an Indonesia beach, and asking the brand in question to please come and pick up their lost item. We ran the campaign for one week with a total budget of €160.
      image_item:
        image: /img/lost&found.jpg
        alt: Lost & Found
    - item: >-
        ### Bali Ocean Plastic - campaign

        A campaign to **raise awareness** among the **Balinese** population, about the source of their ocean plastic. Many Balinese believe this plastic comes from their neighboring island Java. Our research shows a different story.
      youtube: https://www.youtube.com/embed/cOzyQTMk4o0
donate:
  image_item:
    image: /img/conclusion.jpg
    caption: Photo by [Job Wind](https://monkeystation.nl/)
  heading: Help cleanup Indonesia!
  text: ""
---

repository: Monkeystation/cleanup-indonesia

repo_name: Monkeystation/cleanup-indonesia


text:
## React-native Calendar Heatmap

[![A calendar heatmap component built on SVG. The component expands to size of container and is super configurable.](https://img.shields.io/badge/-A%20calendar%20heatmap%20component%20built%20on%20SVG.%20The%20component%20expands%20to%20size%20of%20container%20and%20is%20super%20configurable.-lightgrey?style=for-the-badge)](https://github.com/ayooby/react-native-calendar-heatmap)

[![npm version](https://img.shields.io/npm/v/react-native-calendar-heatmap.svg?style=for-the-badge)](https://www.npmjs.com/package/react-native-calendar-heatmap)
[![npm](https://img.shields.io/npm/dt/react-native-calendar-heatmap.svg?style=for-the-badge)](https://www.npmjs.com/package/react-native-calendar-heatmap)
![Platform - Android and iOS](https://img.shields.io/badge/platform-Android%20%7C%20iOS-blue.svg?style=for-the-badge)
[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg?style=for-the-badge)](https://opensource.org/licenses/MIT)
[![styled with prettier](https://img.shields.io/badge/styled_with-prettier-ff69b4.svg?style=for-the-badge)](https://github.com/prettier/prettier)

## Installation

Add the dependency:

### React Native:

```ruby
npm i react-native-calendar-heatmap
```

## Peer Dependencies

###### IMPORTANT! You need install them.

```
"react": ">= 16.x.x",
"react-native": ">= 0.55.x",
"lodash": ">= 4.17.10",
"react-native-svg": ">= 6.5.2"
```

## Usage

Import the component:

```javascript
import CalendarHeatmap from 'react-native-calendar-heatmap';
```

To show a basic heatmap of 100 days ending on April 1st:

```js
<CalendarHeatmap
  endDate={new Date('2016-04-01')}
  numDays={100}
  values={[
    { date: '2016-01-01' },
    { date: '2016-01-22' },
    { date: '2016-01-30' },
    // ...and so on
  ]}
/>
```

## Custom Colorized Usage

You can check the example for the advanced usage

```js
<CalendarHeatmap
  endDate={new Date("2019-03-25")}
  numDays={100}
  colorArray={["#eee", "#D44B79", "#6B1928", "#9F3251", "#360000"]}
  values={[
    { date: '2016-01-01' },
    { date: '2016-01-22' },
    { date: '2016-01-30' },
    // ...and so on
  ]}
/>
```

## Credits

It inspired by Github's commit calendar graph and [React Calendar Heatmap](https://github.com/patientslikeme/react-calendar-heatmap).

## License

React Native Calendar Heatmap Library is available under the MIT license. See the LICENSE file for more info.

repository: ayooby/react-native-calendar-heatmap

repo_name: ayooby/react-native-calendar-heatmap


text:
---
layout: help_page
title: Importing RSS & XML Feeds
permalink: /help_pages/39
folder: Developer Resources
date: 2009-11-16T16:09:00+00:00
---

Concerto can automatically generate and update content items from an RSS/XML feed for consumption by screens in the system.  Currently, this process does not have an interface exposed in the Admin panel.  You'll need access to the database (phpMyAdmin works well) to perform this setup.

Outside content sources are imported in dynamic feeds in Concerto.  Dynamic feeds update automatically when the cronjob runs ensuring the content is always up to date.

## Setup the destination feed

1.  Login as an administrator
2.  Navigate to the Browse Content page and click the New Feed button up top.
3.  Enter an appropriate name & description for the feed.  Select the "System Adminstrator" group for the feed owner.  Set the feed type to "Restricted" so no one can use the feed while its being setup.

## Database Work

1.  Login to your database.   We use phpMyAdmin, but any database management tool that can add/edit records should work.
2.  Navigate to the **Dynamic** table and prepare to **INSERT** a new record.
3.  Set the **type** field to **1**, the **path** field to the **URL** of your RSS feed, enter a ruleset into the **rules** field (see below), and set the **update_interval** to the minumun number of seconds between an update.  For an urgent feed you can use 0 seconds to always update, but most RSS news sources can wait a few minutes.  We use 600 seconds (10 minutes) for many of our feeds.
4.  Save the record, and note the **id** it was assigned in the **dynamic** table.
5.  Navigate to the **Feed** and browse to find the record associated with the feed you setup in the first part of the guide.
6.  Edit/UPDATE the record for the destination feed, changing the **type** to **1** and the **dynamic_id** to the id of the entry added to the dynamic table _(step 4)_.
7.  You're all set, navigate to http://<your concerto install>/common/scripts/cron.php to manually update the system or wait for the next cronjob run.

## Rulesets

The dynamic table uses the rule field to store information that tells the system how to process the RSS/XML input feed.  These rules control the HTML formatting the content is presented in and what operations are conducted on the source content (aggregation, truncation, regex, etc). This data is stored as a serialized PHP array.  Until full documentation for the rulesets is prepared, there are a few sample rulesets you can try.  Do not directly manipulate the content of these rules, unserialize them into the PHP array, make your changes, and re-serialize if needed.

### Show the 5 headlines per content for an RSS feed

Path: http://arstechnica.com/index.rssx

Rule:
<textarea class="ru" cols="50" rows="8">a:5:{s:17:"items_per_content";i:5;s:9:"max_items";i:0;s:6:"header";a:1:{s:8:"template";s:31:"
Ars Technica Headlines
";}s:4:"glue";a:1:{s:8:"template";s:2:" ";}s:6:"repeat";a:3:{s:5:"xpath";s:12:"channel/item";s:8:"template";s:12:"
%%1%%
";s:9:"bailiwick";a:1:{i:0;a:3:{s:2:"id";i:1;s:4:"type";s:3:"xml";s:5:"value";s:5:"title";}}}}</textarea>

### Show 1 story per content for an RSS feed

Path: http://rss.news.yahoo.com/rss/topstories

Rule:
<textarea class="ru" cols="50" rows="8">a:5:{s:17:"items_per_content";i:1;s:9:"max_items";i:0;s:6:"header";a:1:{s:8:"template";s:20:"
Yahoo! News
";}s:4:"glue";a:1:{s:8:"template";s:2:" ";}s:6:"repeat";a:3:{s:5:"xpath";s:12:"channel/item";s:8:"template";s:28:"
%%1%%

%%2%%
";s:9:"bailiwick";a:2:{i:0;a:4:{s:2:"id";i:1;s:4:"type";s:3:"xml";s:5:"value";s:5:"title";s:9:"transform";a:2:{i:0;a:2:{s:4:"type";s:4:"preg";s:5:"value";a:2:{s:7:"pattern";s:9:"/\s\s+/is";s:11:"replacement";s:1:" ";}}i:1;a:2:{s:4:"type";s:4:"preg";s:5:"value";a:2:{s:7:"pattern";s:12:"/[\n|\r]*/is";s:11:"replacement";s:0:"";}}}}i:1;a:4:{s:2:"id";i:2;s:4:"type";s:3:"xml";s:5:"value";s:11:"description";s:9:"transform";a:1:{i:0;a:1:{s:4:"type";s:9:"striptags";}}}}}}</textarea>

### Display the Weather:

Path: http://weather.yahooapis.com/forecastrss?p=12180

Rule:
<textarea class="ru" cols="50" rows="8">a:4:{s:17:"items_per_content";i:1;s:9:"max_items";i:0;s:6:"header";a:1:{s:8:"template";s:21:"
Troy Weather
";}s:6:"repeat";a:3:{s:5:"xpath";s:12:"channel/item";s:8:"template";s:24:"%%1%%
%%2%%
";s:9:"bailiwick";a:2:{i:0;a:3:{s:2:"id";i:1;s:4:"type";s:3:"xml";s:5:"value";s:5:"title";}i:1;a:4:{s:2:"id";i:2;s:4:"type";s:3:"xml";s:5:"value";s:11:"description";s:9:"transform";a:1:{i:0;a:2:{s:4:"type";s:9:"striptags";s:5:"value";s:16:", ,
";}}}}}}</textarea>


text:
Guidelines for Contributing
===========================

Welcome to the vibe.d repository and thank you for your interest in contributing to its development!

When contributing pull requests, the following points should ideally apply:

 - Each pull request should contain only one isolated functional change
 - The code adheres to the [style guide](https://vibed.org/style-guide)
 - For the occasional more complex pull request each change should be separated into its own commit
 - Try not to mix whitespace or style changes with functional changes in the same commit
 - The pull request must pass the test suite (run `dub test` to test locally)

Exceptions to these rules are accepted all the time, but please try to follow them as closely as possible, because otherwise it often considerably increases the total amount of work and communication overhead.

gha_language: D


text:
LaravelWP
=========

Laravel Wordpress Plugin - Integrates Laravel with Wordpress

* Copy LaravelWP to the wordpress plugins folder
* Activate Plugin
* $ cd src
* $ composer dump-autoload
* $ composer update
* Start Coding

Sample page at your-domain.com/hello-laravel (using twentyfourteen theme);

repository: kharysharpe/LaravelWP

repo_name: kharysharpe/LaravelWP


text:
# Handsontable [![Build Status](https://travis-ci.org/handsontable/handsontable.png?branch=master)](https://travis-ci.org/handsontable/handsontable)

Handsontable is a data grid component with an Excel-like appearance. Built in JavaScript, it integrates with any data source and comes with [features](http://docs.handsontable.com/0.17.0/tutorial-features.html) like data validation, sorting, grouping, data binding or column ordering. Actively supported by the Handsoncode team and the GitHub community.

Check out the demos at http://handsontable.com/examples.html or fork the example on
[JSFiddle](http://jsfiddle.net/js_ziggle/hU6Kz/3228/) to see Handsontable in action.

- - -

### Quick start

1. A recommended way to install Handsontable is through [Bower](http://bower.io/search/?q=handsontable) package manager using the following command:

  `bower install handsontable --save`

  Alternatively, you can [download it in a ZIP file](https://github.com/handsontable/handsontable/archive/master.zip).

2. After Handsontable is downloaded, embed the code into your project. All the files that you need are in the `dist\` directory:

  ```html
  <script src="dist/handsontable.full.js"></script>
  <link rel="stylesheet" media="screen" href="dist/handsontable.full.css">
  ```

3. Then, create a new `Handsontable` object, passing a reference to an empty div as a first argument. After that, load some data if you wish:

  ```html
  <div id="example"></div>

  <script>
    var data = [
      ["", "Kia", "Nissan", "Toyota", "Honda"],
      ["2008", 10, 11, 12, 13],
      ["2009", 20, 11, 14, 13],
      ["2010", 30, 15, 12, 13]
    ];

   var container = document.getElementById('example');
    var hot = new Handsontable(container,
     {
       data: data
      });
  </script>
  ```

### API Reference

- [Core methods](http://docs.handsontable.com/Core.html)
- [Options](http://docs.handsontable.com/Options.html)
- [Hooks](http://docs.handsontable.com/Hooks.html)

### Troubleshooting

Please follow this guidelines when reporting bugs and feature requests:

1. Use [GitHub Issues](https://github.com/handsontable/handsontable/issues) board to report bugs and feature requests (not our email address)
2. Please **always** write steps to reproduce the error. That way we can focus on fixing the bug, not scratching our heads trying to reproduce it.
3. If possible, please add a JSFiddle link that shows the problem (start by forking [this fiddle](http://jsfiddle.net/js_ziggle/hU6Kz/3228/)). It saves us much time.
4. If you can't reproduce it on JSFiddle, please add a screenshot that shows the problem. JSFiddle is much more appreciated because it lets us start fixing straight away.

Thanks for understanding!

### Compatibility

Handsontable is compatible with IE 9+, Firefox, Chrome, Safari and Opera.

### Want to help?

Please see [CONTRIBUTING.md](CONTRIBUTING.md)

### Changelog

To see the list of recent changes, see [Releases section](https://github.com/handsontable/handsontable/releases).

### License

The MIT License (see the [LICENSE](https://github.com/handsontable/handsontable/blob/master/LICENSE) file for the full text)

### Contact

You can contact us at<EMAIL_ADDRESS>

repository: suricactus/climatogramme

repo_name: suricactus/climatogramme


text:
Git
===

This package contains various configuration files required for setting up the
Git Version Control System. Apart from the configuration files which are
installed, the install script will also, **only for Arch Linux** download
and install other required files.

Files
=====

This package consists of 3 configuration files:

  * **gitk**: The `$HOME/.gitk` file configures how the inbuilt commit viewer,
gitk looks and behaves.
  * **gitconfig**: The `$HOME/.gitconfig` file has various customizations for
the overall look, feel and functioning of Git. It defines the committer name
and email id, along with different alises and various settings. **_Warning_**:
This file requires a newer version of Git. Installing this file on a system
with ancient versions of git *will* cause probelms. E.g. Debian Stable
  * **gitattributes**: The power-users Git customization file. This contains
more advanced customizations for Git, often used in conjunction with the
gitconfig file.

repository: darnir/dotfiles

gha_language: VimL

repo_name: darnir/dotfiles