text:
# OBSOLETE.  Octotree now has first-class support for git enterprise

## Octotree
Browser extensions (Chrome, Firefox and Safari) to display GitHub code in tree format. Useful for developers who frequently read source in GitHub and do not want to download or checkout too many repositories. Features:

* Easy-to-navigate code tree like IDEs
* Fast browsing with pjax
* Support private repositories (require [personal access token](#github-api-rate-limit))

## Install on Chrome
* Download and install [Octotree](https://chrome.google.com/webstore/detail/octotree/bkhaagjahfmjljalopjnoealnfndnagc) from the Chrome store
* Navigate to any GitHub project (or just refresh this page as an example)
* The code tree should show as follows:

![When extension is active](https://raw.githubusercontent.com/buunguyen/octotree/master/docs/chrome.png)

## Install on Firefox and Safari
I'm in the process of submitting the extensions to Mozilla and Safari stores. Meanwhile, you can install the prebuilt extensions located in the [dist](https://github.com/jasonmit/octotree/tree/master/dist) folder.

* Firefox: drag `octotree.xpi` to the browser and follow the instructions
* Safari: drag `octotree.safariextz` to the browser and follow the instructions

## GitHub API Rate Limit
Octotree uses [GitHub API](https://developer.github.com/v3/) to retrieve repository metadata. By default, it makes unauthenticated requests to the GitHub API. However, there are two situations when requests must be authenticated:

* You access a private repository
* You exceed the [rate limit of unauthenticated requests](https://developer.github.com/v3/#rate-limiting)

When that happens, Octotree shows the screen below to ask for your [GitHub personal access token](https://help.github.com/articles/creating-an-access-token-for-command-line-use). If you don't already have one, [create one](https://github.com/settings/tokens/new), then copy and paste it into the textbox.

![Enter personal access token](https://raw.githubusercontent.com/buunguyen/octotree/master/docs/token.png)

Alternatively, you can manually enter or update the token by following these steps:

* Navigate to any GitHub page
* Open the Chrome (or Safari, Firefox) developer console
* Execute the following line:
```javascript
localStorage.setItem('octotree.github_access_token', JSON.stringify('REPLACE WITH TOKEN'))
```

## Contribution
There are several improvements that can be made to Octotree. Contribution is very welcome.

- [ ] Hide sidebar when navigating to non-code pages like Issues, PRs...
- [ ] Make the width of the sidebar resizable.
- [ ] Allow docking sidebar to either the left or right side.
- [ ] Allow users to enter access token any time.
- [ ] Synchronize (two-way) between sidebar selection and GitHub selection.
- [ ] Show progress indicator while the code tree or a file is being loaded (with Pjax). (Showing spinner in the toggle button?)

## Credit
* [Icon](https://github.com/pstadler/octofolders) by [pstadler](https://github.com/pstadler)
* Thanks to many people submitting pull requests, reporting bugs and suggesting ideas here and on [HN](https://news.ycombinator.com/item?id=7740226)

repository: jasonmit/octotree

repo_name: jasonmit/octotree


text:
# PipeRTManager

A user friendly pipeline manager for the [PipeRT project.](https://github.com/ItamarWilf/PipeRT)

## Installation

- Development: - Run "npm start" on both the server and client folders
- Production: - Run "docker-compose up -d" on the main folder

license: MIT

repository: DorTruzman/PipeRTManager

branch_name: refs/heads/master

extension: md

gha_language: JavaScript

gha_license_id: MIT

license_type: permissive

repo_name: DorTruzman/PipeRTManager


text:
The profiler module offers practical wrappers to use on top of libGDX [profiling utilities](https://github.com/libgdx/libgdx/wiki/Profiling).

### PerformanceProfiler

The [`PerformanceProfiler`](https://github.com/ImXico/Cyberpunk/blob/master/text/src/main/kotlin/cyberpunk/profiler/PerformanceProfiler.kt) is a tiny wrapper to use on top of
libGDX `PerformanceCounter`.

Imagine that, somewhere in your code, you call an expensive operation:

```kotlin
someExpensiveOperation()
```

To profile it, you need to first instantiate a `PerformanceCounter`:

```kotlin
private val performanceProfiler = PerformanceCounter("My Profiler")
```

Now, all that you need to do is wrap the operation inside the profiler's `profile` call:

```kotlin
performanceProfiler.profile {
  someExpensiveOperation()
}
```

After each call to `someExpensiveOperation`, you'll see the output in the log:

```
My Profiler: -----------------------------------------------------
My Profiler: Number of Calls: 7
My Profiler: Latest  OP Time: 1.0035133
My Profiler: Average OP Time: 1.002641
My Profiler: Maximum OP Time: 1.0029575
My Profiler: Minimum OP Time: 1.0021613
My Profiler: -----------------------------------------------------
```

repository: ezebecke/Cyberpunk

repo_name: ezebecke/Cyberpunk


text:
IBM Spectrum Protect Plus Monitoring
====================================

Provides monitoring of the IBM Spectrum Protect Plus appliance:

* CPU and Memory Usage
* Alert Messages
* File System
* Groups and Group Volumes
* Jobs (Active Sessions and Scheduled Jobs)
* Storage
* SQL Log Backup

The template uses the IBM Spectrum Protect Plus REST API.

* Add the IBM Spectrum Protect Plus host under the hosts tab and define the system type as `Other`.
* Provide appropriate username and password to access the REST API as system credentials.

repository: sentrysoftware/studioX-templates

repo_name: sentrysoftware/studioX-templates


text:
#Install the bot
## Table of Contents
- [Linux or Mac Automatic Installation](#linuxmac)
- [Windows Automatic Installation](#windows)
- [Docker Automatic Installation](#docker)

#Linux/Mac
### Requirements (click each one for install guide)
- [Python 2.7.x](http://docs.python-guide.org/en/latest/starting/installation/)
- [pip](https://pip.pypa.io/en/stable/installing/)
- [git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)
- [virtualenv](https://virtualenv.pypa.io/en/stable/installation/) (Recommended)

### Easy installation
1. Clone the git: `git clone https://github.com/PokemonGoF/PokemonGo-Bot`
2. Go into the new directory: `cd PokemonGo-Bot`
3. Run `./setup.sh -i`
    This will install the bot and all stuff that is needed to run it (follow the steps in this process)
4. Run `./run.sh`
    After you are done following it this will start your bot.

### To update the bot
1. Stop the bot if it's running. (use control + c twice to stop it)
2. Run `./setup.sh -r`
    This will reset and makes sure you have no changes made to any code since it will overide it
3. Rerun the bot `./run.sh`

for manual installation please refer to [here](https://github.com/nivong/PokemonGo-Bot/blob/dev/docs/manual_installation.md)

#Windows
We do recommend Windows users to use [Docker](#docker) this will work much easier and smoother (also saver)

##Requirements

- [Python 2.7.x](http://docs.python-guide.org/en/latest/starting/installation/)
- [git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)
- [Protoc](https://github.com/google/protobuf/releases/download/v3.0.0-beta-4/protoc-3.0.0-beta-4-win32.zip)
- [Microsoft Visual C++ Compiler for Python 2.7](http://www.microsoft.com/en-us/download/details.aspx?id=44266)

###Easy Installation
1. Download `PokemonGo-Bot-Install.bat` file from [HERE](https://raw.githubusercontent.com/nivong/PokemonGo-Bot/dev/windows_bat/PokemonGo-Bot-Install.bat)
2. Run `PokemonGo-Bot-install.bat`
After that has done the bot will be installed
3. Run `PokemonGo-Bot-Start.bat`
This will start the bot and the web interface

### To update the bot
3. Run `PokemonGo-Bot-Start.bat`
This will check for an update and will start the bot afterwards.

### To repair the bot if it isn't working for some reason
1. Stop the bot by closing everything
2. Run `PokemonGo-Bot-Repair.bat`
3. Rerun the bot by using `PokemonGo-Bot-StartBot.bat`

#Docker

###Easy installation
Start by downloading for your platform:
- [Mac](https://www.docker.com/products/docker#/mac)
- [Windows](https://www.docker.com/products/docker#/windows)
- [Linux](https://www.docker.com/products/docker#/linux)

Once you have Docker installed, simply create the various config files for your different accounts (e.g. `configs/config.json`, `configs/userdata.js`) and then create a Docker image for PokemonGo-Bot using the Dockerfile in this repo.

```
cd PokemonGo-Bot
docker build --build-arg timezone=Europe/London -t pokemongo-bot .
```

Optionally you can set your timezone with the --build-arg option (default is Etc/UTC)

After build process you can verify that the image was created with:

```
docker images
```

To run PokemonGo-Bot Docker image you've created:

```
docker run --name=bot1-pokego --rm -it -v $(pwd)/configs/config.json:/usr/src/app/configs/config.json pokemongo-bot
```

Run a second container provided with the OpenPoGoBotWeb view:

```
docker run --name=bot1-pokegoweb --rm -it --volumes-from bot1-pokego -p 8000:8000 -v $(pwd)/configs/userdata.js:/usr/src/app/web/userdata.js -w /usr/src/app/web python:2.7 python -m SimpleHTTPServer
```
The OpenPoGoWeb will be served on `http://<your host>:8000`

if docker-compose [installed](https://docs.docker.com/compose/install/) you can alternatively run the PokemonGo-Bot ecosystem with one simple command:
(by using the docker-compose.yml configuration in this repo)

```
docker-compose up
```

Also run one single service from the compose configuration is possible:

```
docker-compose run --rm bot1-pokego
```

command for remove all stopped containers: `docker-compose rm`

TODO: Add infos / configuration for running multiple bot instances.

Do not push your image to a registry with your config.json and account details in it!


text:
GrandMedia/Sentry
======

[![Build Status](https://travis-ci.org/GrandMedia/Sentry.svg?branch=master)](https://travis-ci.org/GrandMedia/Sentry)
[![Downloads this Month](https://img.shields.io/packagist/dm/grand-media/sentry.svg)](https://packagist.org/packages/grand-media/sentry)
[![Latest stable](https://img.shields.io/packagist/v/grand-media/sentry.svg)](https://packagist.org/packages/grand-media/sentry)
[![Coverage Status](https://coveralls.io/repos/github/GrandMedia/Sentry/badge.svg?branch=master)](https://coveralls.io/github/GrandMedia/Sentry?branch=master)
![PHPStan](https://img.shields.io/badge/style-level%207-brightgreen.svg?style=flat-square&label=phpstan)

Installation
------------

The best way to install GrandMedia/Sentry is using  [Composer](http://getcomposer.org/):

```sh
$ composer require grand-media/sentry
```

repository: GrandMedia/Sentry

repo_name: GrandMedia/Sentry


text:
---
layout: page
title: CPU usage
permalink: /metrics/cpu-usage/
parent: metrics-performanceefficiency
top: metrics
---

{% for m in site.data.metrics %}
    {% if m.name == 'CPU usage' %}
        {% assign metric = m %}
    {% endif %}
{% endfor %}

_{{ metric.excerpt }}_

Key Performance Indicator

No

Aggregable

No

Rationale

The CPU usage give an impression of the resource utilisation and the capacity of a system.
    High CPU usage may indicate the system is not as efficient as it should be, or the CPU capacity needs to be increased.

Improving

If you want to improve the CPU usage you'll have to look at ways to lower
        resource demand or better
        resource management.


text:
# Party-ify : Live Wireless Distributed Music Streaming Solution
Wireless distributed multi-speaker solution for parties, events, and celebratory occasions

- Supports Synchronized Simultaneous Playback Across Multiple Clients
- Any Internet Enabled Device with a Browser Can Connect and Stream

![Image description](https://i.ibb.co/WDWcr8t/Screen-Shot-2019-08-08-at-2-42-35-AM.png)

# How Audio Synchronization Works

## Clock Synchronization

All devices connected to the server must refer to the server time as a source of truth in order to perform timestamp dependent operations.

In this specific situation, the server acts as ntp server, where clients continually ping the server to determine the correct offset in which to synchronize their clocks too.

The offset algorithm can be seen below:

We define the following variables:

T1: Origin Timestamp: The timestamp of the client upon departure of the client's request\
T2: Receive Timestamp: The timestamp of the server upon receiving the client's request\
T3: Transmit Timestamp: The timestamp of the server upon departure of the server's reply\
T4: Destination Timestamp: The timestamp of the client upon receiving the server's reply

We can then add this offset to the client time to obtain a theoretical synchronized time.

## Latency Synchronization

Because network packets are received by clients at different times due to being on different networks or because of network traffic, latency must be accounted for to correctly synchronize audio playback.

To calculate the latency, we apply the below calculation with the previously defined variables:

If one client receives a packet before another, it must wait a certain amount of time such that it's playback matches with the client which receives the packet at a later time. To put our latency calculation to use, let us imagine the following senario:

- Client A receives a packet 2 seconds after server transmission.
- Client B receives a packet 1 second after server transmission.

If we specify a global buffer time, or rather, assuming 0 latency, a client should wait x number of seconds before playing the data packet they have received, than we can apply the following synchronizations.

Given that client A has a latency of 2 seconds and client B has a latency of 1 second,
client A must readjust it's wait time to be x - 2 and client B must readjust it's wait time to be x - 1.

A concrete example would help illustrate why this makes sense.

- Client A receives a packet at time 2.
- Client B receives a packet at time 1.

Assuming global buffer time is 3 seconds, with the aforementioned calculation:

- Client A will wait 3 - 2 seconds, starting playback at time 2 + 1 = 3.
- Client B will wait 3 - 1 seconds, starting playback at time 1 + 2 = 3.

As we can see, the clients both start playback at the sametime.

The limiting factor to this synchronization working in theory is the global buffer time.\
As long as the max latency among all the clients remain within global buffer time, then
the amount each client has to wait will always be greater than 0, guaranteeing synchronized playback.
Conversely, if a client has a greater latency than the global buffer time, and we cannot do the reverse of delaying(as the latency offset would now be negative), the algorithm would not work in this case.

## Prerequisites

What things you need to install the software and how to install them

The latest version of the Node runtime environment: [Download](https://nodejs.org/en/download/)

## Installing

A step by step series of examples that tell you how to get a development env running

1. Clone the repository to a folder
2. Execute "npm run start", this will start the electron app
3. In the case that any dependencies are missing, run "npm install"

4. In order for the server to stream audio, it requires an input audio source to read from. This could be a microphone device, or a virtual sound driver that captures system audio.
5. For Windows, I recommend Virtual Cable Audio; it works really well and is easy to setup: https://www.vb-audio.com/Cable/ An alternative would be to use Window's builtin Audio Recording API: stereo-mix
6. For Mac, soundflower is a good solution: https://rogueamoeba.com/freebies/soundflower/
On Linux, using either ALSA or PulseAudio, you can create a virtual sound sink.

## Deployment

1. To stream from a device, open the device's browser and connect to the ip address.
2. All of your devices' playback should be in sync - a great solution for multi-room audio setups, parties, or when you just simply don't have enough aux cable splitters for all your speakers.

## License

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


text:
# Migration Example

### Example with createMigrate
```ts
import { createMigrate, persist, MigrationManifest } from 'mobx-keystone-persist'

const migrations: MigrationManifest = {
  0: snapshot => {
    // migration clear out device state
    return {
      ...snapshot,
      device: undefined
    }
  },
  1: snapshot => {
    // migration to keep only device state
    return {
      device: snapshot.device
    }
  }
}

persist('store', someStore, {
  version: 1,
  migrate: createMigrate(migrations)
}).then(() => console.log('someStore has been hydrated'))
```

### Alternative (advanced)
The migrate method can be any function with which returns a promise of a new persisted state. This method is always called when loading persisted state, so make sure to handle versioning yourself.

Note that a persisted state wraps a snapshot and contains the version code for that snapshot. Look at the source code for createMigrate for inspiration.

```ts
persist('store', someStore, {
  version: 1,
  migrate: async (state, currentVersion) => {
    console.log('Migration Running!')

    return {
      version: currentVersion,
      snapshot: {
        ...state.snapshot,
        // alter the snapshot somehow
      }
    }
  }
})
```

repository: fchastanet/mobx-keystone-persist

repo_name: fchastanet/mobx-keystone-persist


text:
---
name: List stargazers
example: octokit.rest.activity.listStargazersForRepo({ owner, repo })
route: GET /repos/{owner}/{repo}/stargazers
scope: activity
type: API method
---

# List stargazers

Lists the people that have starred the repository.

You can also find out _when_ stars were created by passing the following custom [media type](https://docs.github.com/rest/overview/media-types/) via the `Accept` header: `application/vnd.github.star+json`.

```js
octokit.rest.activity.listStargazersForRepo({
  owner,
  repo,
});
```

## Parameters

      name
      required
      description

owner	yes

The account owner of the repository. The name is not case sensitive.

repo	yes

The name of the repository without the `.git` extension. The name is not case sensitive.

per_page	no

The number of results per page (max 100).

page	no

Page number of the results to fetch.

See also: [GitHub Developer Guide documentation](https://docs.github.com/rest/reference/activity#list-stargazers).

branch_name: refs/heads/main

gha_language: TypeScript


text:
# Entity naming prefixes clarification

- **Pg** - according entity (or some parts of it) stores in PostreSQL database
- **Partial** - according entity (or some parts of it) can be obtained via microservice handlers

repository: zpboff/interview-helper

repo_name: zpboff/interview-helper


text:
# Oeceoclades lanceata (H.Perrier) Garay & P.Taylor SPECIES

#### Status
ACCEPTED

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

#### Published in
null

#### Original name
Eulophia lanceata H.Perrier

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
# iss
Informational Screens System

Execution Environment Info
 - Verified environment: Tomcat 7 + mysql DB
 - The OpenShift jBOSS server:
     - `jbossews` cartridge documentation can be found at:
http://openshift.github.io/documentation/oo_cartridge_guide.html#tomcat

repository: iss-deweloper/iss

repo_name: iss-deweloper/iss


text:
[//]: # (title: Serialization)

_Serialization_ is the process of converting data used by an application to a format that can be transferred over a network
or stored in a database or a file. In turn, _deserialization_ is the opposite process of reading data from an external source
and converting it into a runtime object. Together they are an essential part of most applications that exchange
data with third parties.

Some data serialization formats, such as [JSON](https://www.json.org/json-en.html) and
[protocol buffers](https://developers.google.com/protocol-buffers) are particularly common. Being language-neutral and
platform-neutral, they enable data exchange between systems written in any modern language.

In Kotlin, data serialization tools are available in a separate component, [kotlinx.serialization](https://github.com/Kotlin/kotlinx.serialization).
It consists of several parts: the `org.jetbrains.kotlin.plugin.serialization` Gradle plugin, [runtime libraries](#libraries),
and compiler plugins.

Compiler plugins, `kotlinx-serialization-compiler-plugin` and `kotlinx-serialization-compiler-plugin-embeddable`,
are published directly to Maven Central. The second plugin is designed for working with the `kotlin-compiler-embeddable`
artifact, which is the default option for scripting artifacts. Gradle adds compiler plugins to your projects as compiler arguments.

## Libraries

`kotlinx.serialization` provides sets of libraries for all supported platforms – JVM, JavaScript, Native – and for various
serialization formats – JSON, CBOR, protocol buffers, and others. You can find the complete list of supported serialization
formats [below](#formats).

All Kotlin serialization libraries belong to the `org.jetbrains.kotlinx:` group. Their names start with `kotlinx-serialization-`
and have suffixes that reflect the serialization format. Examples:
* `org.jetbrains.kotlinx:kotlinx-serialization-json` provides JSON serialization for Kotlin projects.
* `org.jetbrains.kotlinx:kotlinx-serialization-cbor` provides CBOR serialization.

Platform-specific artifacts are handled automatically; you don't need to add them manually. Use the same dependencies in
JVM, JS, Native, and multiplatform projects.

Note that the `kotlinx.serialization` libraries use their own versioning structure, which doesn't match Kotlin's versioning.
Check out the releases on [GitHub](https://github.com/Kotlin/kotlinx.serialization/releases) to find the latest versions.

## Formats

`kotlinx.serialization` includes libraries for various serialization formats:

* [JSON](https://www.json.org/): [`kotlinx-serialization-json`](https://github.com/Kotlin/kotlinx.serialization/blob/master/formats/README.md#json)
* [Protocol buffers](https://developers.google.com/protocol-buffers): [`kotlinx-serialization-protobuf`](https://github.com/Kotlin/kotlinx.serialization/blob/master/formats/README.md#protobuf)
* [CBOR](https://cbor.io/): [`kotlinx-serialization-cbor`](https://github.com/Kotlin/kotlinx.serialization/blob/master/formats/README.md#cbor)
* [Properties](https://en.wikipedia.org/wiki/.properties): [`kotlinx-serialization-properties`](https://github.com/Kotlin/kotlinx.serialization/blob/master/formats/README.md#properties)
* [HOCON](https://github.com/lightbend/config/blob/master/HOCON.md): [`kotlinx-serialization-hocon`](https://github.com/Kotlin/kotlinx.serialization/blob/master/formats/README.md#hocon) (only on JVM)

Note that all libraries except JSON serialization (`kotlinx-serialization-json`) are [Experimental](components-stability.md),
which means their API can be changed without notice.

There are also community-maintained libraries that support more serialization formats, such as [YAML](https://yaml.org/)
or [Apache Avro](https://avro.apache.org/). For detailed information about available serialization formats, see the
[`kotlinx.serialization` documentation](https://github.com/Kotlin/kotlinx.serialization/blob/master/formats/README.md).

## Example: JSON serialization

Let's take a look at how to serialize Kotlin objects into JSON.

Before starting, you'll need to configure your build script so that you can use Kotlin serialization tools in your project:

1. Apply the Kotlin serialization Gradle plugin `org.jetbrains.kotlin.plugin.serialization` (or `kotlin("plugin.serialization")`
in the Kotlin Gradle DSL).

    <tabs group="build-script">
    <tab title="Kotlin" group-key="kotlin">

    ```kotlin
    plugins {
        kotlin("jvm") version "%kotlinVersion%"
        kotlin("plugin.serialization") version "%kotlinVersion%"
    }
    ```

    </tab>
    <tab title="Groovy" group-key="groovy">

    ```groovy
    plugins {
        id 'org.jetbrains.kotlin.jvm' version '%kotlinVersion%'
        id 'org.jetbrains.kotlin.plugin.serialization' version '%kotlinVersion%'
    }
    ```

    </tab>
    </tabs>

2. Add the JSON serialization library dependency:`org.jetbrains.kotlinx:kotlinx-serialization-json:%serializationVersion%`

    <tabs group="build-script">
    <tab title="Kotlin" group-key="kotlin">

    ```kotlin
    dependencies {
        implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:%serializationVersion%")
    }
    ```

    </tab>
    <tab title="Groovy" group-key="groovy">

    ```groovy
    dependencies {
        implementation 'org.jetbrains.kotlinx:kotlinx-serialization-json:%serializationVersion%'
    }
    ```

    </tab>
    </tabs>

Now you're ready to use the serialization API in your code. The API is located in the the `kotlinx.serialization` package
and its format-specific subpackages such as `kotlinx.serialization.json`.

First, make a class serializable by annotating it with `@Serializable`.

```kotlin
import kotlinx.serialization.Serializable

@Serializable
data class Data(val a: Int, val b: String)
```

You can now serialize an instance of this class by calling `Json.encodeToString()`.

```kotlin
import kotlinx.serialization.Serializable
import kotlinx.serialization.json.Json
import kotlinx.serialization.encodeToString

@Serializable
data class Data(val a: Int, val b: String)

fun main() {
   val json = Json.encodeToString(Data(42, "str"))
}
```

As a result, you get a string containing the state of this object in the JSON format: `{"a": 42, "b": "str"}`

You can also serialize object collections, such as lists, in a single call.

```kotlin
val dataList = listOf(Data(42, "str"), Data(12, "test"))
val jsonList = Json.encodeToString(dataList)
```

To deserialize an object from JSON, use the `decodeFromString()` function:

```kotlin
import kotlinx.serialization.Serializable
import kotlinx.serialization.json.Json
import kotlinx.serialization.decodeFromString

@Serializable
data class Data(val a: Int, val b: String)

fun main() {
   val obj = Json.decodeFromString<Data>("""{"a":42, "b": "str"}""")
}
```

For more information about serialization in Kotlin, see the [Kotlin Serialization Guide](https://github.com/Kotlin/kotlinx.serialization/blob/master/docs/serialization-guide.md).

repository: JetBrains/kotlin-web-site

repo_name: JetBrains/kotlin-web-site


text:
# simple-station
This is a simple station for a production line exposing values via an OPC UA server, which can be instantiated in three different types (Assembly, Test, Packaging) and is supposed to be controlled by a simple MES system, which is available as container [here](https://hub.docker.com/repository/docker/hansgschossmann/simple-mes).

# Usage

    Usage: simple-station.exe [<options>]

    Simple station for productionline simulation
    To exit the application, just press ENTER while it is running.

    Options:
          --lf, --logfile=VALUE  the filename of the logfile to use.
                                   Default: '<hostname>-station.log'
          --ll, --loglevel=VALUE the loglevel to use (allowed: fatal, error, warn,
                                   info, debug, verbose).
                                   Default: info
          --st, --stationtype=VALUE
                                 sets the station type
                                   Default: assemblystation
          --pn, --portnum=VALUE  the server port of the OPC server endpoint.
                                   Default: 51210
          --op, --path=VALUE     the enpoint URL path part of the OPC server
                                   endpoint.
                                   Default: ''
          --ga, --generatealerts the station should generate alerts.
                                   Default: False
          --pc, --powerconsumption=VALUE
                                 the stations average power consumption in kW
                                   Default:  150 kW
          --ct, --cycletime=VALUE
                                 the stations cycle time in seconds
                                   Default:  7000 sec
          --lr, --ldsreginterval=VALUE
                                 the LDS(-ME) registration interval in ms. If 0,
                                   then the registration is disabled.
                                   Default: 0
          --aa, --autoacceptcerts
                                 all certs are trusted when a connection is
                                   established.
                                   Default: False
          --to, --trustowncert   the application certificate is put into the
                                   trusted certificate store automatically.
                                   Default: False
          --at, --appcertstoretype=VALUE
                                 the own application cert store type.
                                   (allowed values: Directory, X509Store)
                                   Default: 'Directory'
          --ap, --appcertstorepath=VALUE
                                 the path where the own application cert should be
                                   stored
                                   Default (depends on store type):
                                   X509Store: 'CurrentUser\UA_MachineDefault'
                                   Directory: 'pki/own'
          --tp, --trustedcertstorepath=VALUE
                                 the path of the trusted cert store
                                   Default 'pki/trusted'
          --rp, --rejectedcertstorepath=VALUE
                                 the path of the rejected cert store
                                   Default 'pki/rejected'
          --ip, --issuercertstorepath=VALUE
                                 the path of the trusted issuer cert store
                                   Default 'pki/issuer'
          --csr                  show data to create a certificate signing request
                                   Default 'False'
          --ab, --applicationcertbase64=VALUE
                                 update/set this applications certificate with the
                                   certificate passed in as bas64 string
          --af, --applicationcertfile=VALUE
                                 update/set this applications certificate with the
                                   certificate file specified
          --pb, --privatekeybase64=VALUE
                                 initial provisioning of the application
                                   certificate (with a PEM or PFX fomat) requires a
                                   private key passed in as base64 string
          --pk, --privatekeyfile=VALUE
                                 initial provisioning of the application
                                   certificate (with a PEM or PFX fomat) requires a
                                   private key passed in as file
          --cp, --certpassword=VALUE
                                 the optional password for the PEM or PFX or the
                                   installed application certificate
          --tb, --addtrustedcertbase64=VALUE
                                 adds the certificate to the applications trusted
                                   cert store passed in as base64 string (multiple
                                   strings supported)
          --tf, --addtrustedcertfile=VALUE
                                 adds the certificate file(s) to the applications
                                   trusted cert store passed in as base64 string (
                                   multiple filenames supported)
          --ib, --addissuercertbase64=VALUE
                                 adds the specified issuer certificate to the
                                   applications trusted issuer cert store passed in
                                   as base64 string (multiple strings supported)
          --if, --addissuercertfile=VALUE
                                 adds the specified issuer certificate file(s) to
                                   the applications trusted issuer cert store (
                                   multiple filenames supported)
          --rb, --updatecrlbase64=VALUE
                                 update the CRL passed in as base64 string to the
                                   corresponding cert store (trusted or trusted
                                   issuer)
          --uc, --updatecrlfile=VALUE
                                 update the CRL passed in as file to the
                                   corresponding cert store (trusted or trusted
                                   issuer)
          --rc, --removecert=VALUE
                                 remove cert(s) with the given thumbprint(s) (
                                   multiple thumbprints supported)
      -h, --help                 show this message and exit

repository: hansgschossmann/simple-station

repo_name: hansgschossmann/simple-station


text:
vagrant-kubernetes-setup
========================

Inspired from https://github.com/Gurpartap/vagrant-kubernetes-setup/ and changed in a manner where we could spin docker instances even in the Kubernetes Master node.

Pre-requisites
==============

1. VirtualBox Installation
2. Vagrant Installation

Deployment
==========

TODO

How to run?
===========

Run following command in a terminal. This will destroy existing VMs, if you re-run it.

$ ./up.sh

2-VM Setup
==========

Kubernetes master node is capable of acting as a master/minion. In this mode, you can run the setup using only 2 Virtual machines which is convenient in many cases.

Please use following Vagrant file, if you would like to create the 2-VM setup.

https://github.com/nirmal070125/vagrant-kubernetes-setup/blob/master/2-vm-setup/Vagrantfile


text:
# Contributing to the Pony tutorial

Hi there! Thanks for your interest in contributing to the Pony Tutorial. The
book is being developed in Markdown and hosted at
[Gitbook](https://www.gitbook.com/book/ponylang/pony-tutorial/details). We
welcome external contributors. In fact, we encourage them.

Please note, that by submitting any content to the Pony Tutorial book you are
agreeing that it can be licensed under our [license](LICENSE.md). Furthermore,
you are testifying that you own the copyright to the submitted content and
indemnify Pony Tutorial from any copyright claim that might result from your not
being the authorized copyright holder.

## How the tutorial is organized

The tutorial layout is in the process of being reogranized. Previously, all
content for the tutorial was stored in the `docs` directory. Within that,
there were folders for each section of the book. The sections act as logical
groupings for chapters they contain. For new sections, they should be added to
the top level of the repo. When creating a new section, be sure to add an
`index.md` file that has the name of section as a level one entry: `#` as well
as an introductory paragraph or two for the section. After reading the
introduction, a reader should have a good idea of the type of content covered by
the chapters that make up the section.

## How to format chapters

Each chapter should start with the title of the chapter as a level one header:
`#` in Markdown. Each section of the page should appear as a second level
heading: `##`. If you need to have any subsections, make them a third level
heading: `###`. If you find yourself reaching for a forth level heading, stop
and figure out a different way to present the info in that section.

After the title, before diving into your first section, you should have some
level of expository text that explains what the reader can expect to get out of
reading the page.

Please make sure to keep any individual line under 80 characters except in
instance where that would break link with the markdown (which only happens if
the linked text and url are more than 76 characters).

## How to update the Table of Contents

Table of contents is handled by the `Summary.md` file. Each section of the book
will appear as a top level item in the list contained in `Summary.md`. Each
topic in turn appears as sub item beneath that. If you added a new section,
don't forget to link to both the section `index.md` as well as the content for
your topic.

## How to submit a pull request

Once your content is done, please open a pull request against this repo with
your changes. Based on the state of your particular PR, a number of requests for
change might be requested:

* Changes to the content
* Change to where the content appears in the Table of Contents
* Change to where the markdown file for the content is stored in the repo

Be sure to keep your PR to a single topic or logical change. If you are working
on multiple changes, make sure they are each on their own branch and that
before creating a new branch that you are on the master branch (others multiple
changes might end up in your pull request). To repeat, each PR should be for a
single logical change. We request that you create a good commit messages as laid
out in
['How to Write a Git Commit Message'](http://chris.beams.io/posts/git-commit/).

If your PR is for a single logical change (which is should be) but spans
multiple commits, we'll ask you to squash them into a single commit before we
merge. Steve Klabnik wrote a handy guide for that:
[How to squash commits in a GitHub pull request](http://blog.steveklabnik.com/posts/2012-11-08-how-to-squash-commits-in-a-github-pull-request).

repository: nerdatmath/pony-tutorial

repo_name: nerdatmath/pony-tutorial


text:
### [CVE-2021-1897](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-1897)
![](https://img.shields.io/static/v1?label=Product&message=Snapdragon%20Consumer%20IOT%2C%20Snapdragon%20Industrial%20IOT%2C%20Snapdragon%20Mobile%2C%20Snapdragon%20Voice%20%26%20Music%2C%20Snapdragon%20Wearables&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=Buffer%20Over-read%20in%20Boot&color=brighgreen)

### Description

Possible Buffer Over-read due to lack of validation of boundary checks when loading splash image in Snapdragon Consumer IOT, Snapdragon Industrial IOT, Snapdragon Mobile, Snapdragon Voice & Music, Snapdragon Wearables

### POC

#### Reference
- https://www.qualcomm.com/company/product-security/bulletins/july-2021-bulletin

#### Github
No PoCs found on GitHub currently.

repository: trickest/cve

gha_language: HTML

repo_name: trickest/cve


text:
### [CVE-2018-4251](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-4251)
![](https://img.shields.io/static/v1?label=Product&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=n%2Fa&color=brighgreen)

### Description

An issue was discovered in certain Apple products. macOS before 10.13.5 is affected. The issue involves the "Firmware" component. It allows attackers to modify the EFI flash-memory region that a crafted app that has root access.

### POC

#### Reference
No PoCs from references.

#### Github
- https://github.com/ptresearch/mmdetect


text:
# Reposi
Reposi is an easy way to import github repositories for personal portfolios

![preview](https://github.com/N1ght-Owls/reposi/blob/master/static/showcase.png)

repository: srevinsaju/reposi

repo_name: srevinsaju/reposi


text:
# Connecting Kafka with Elasticsearch using KafkaConnectS2I over SSL

(We'll use default namespace containing both Kafka cluster, KafkaConnect and Elasticsearch)
## Kafka cluster setup using AMQ Streams

1. Install AMQ Streams operator in default namespace
Search in in OperatorHub and install it in the default namespace.
2. Start a base Kafka cluster (1 zookeeper, 1 kafka broker) using the `kafka-my-cluster.yaml` file
```
oc apply -f kafka-my-cluster.yaml
```
3. Deploy a new topic `my-topic` using the kafkatopic-my-topic.yaml` file
```
oc apply -f kafkatopic-my-topic.yaml
```
4. Install Elasticsearch operator (https://www.elastic.co/guide/en/cloud-on-k8s/current/k8s-openshift-deploy-the-operator.html)
```
oc apply -f https://download.elastic.co/downloads/eck/1.1.2/all-in-one.yaml
```
5. Run Elasticsearch minimal setup using the `elasticsearch-elasticsearch-sample.yaml` file
```
oc apply -f elasticsearch-elasticsearch-sample.yaml
```
6. Create a truststore using the elasticsearch tls.crt included inside the `elasticsearch-sample-es-http-certs-public` secret
```
#extract certificate to tls.crt file
oc get secret "elasticsearch-sample-es-http-certs-public" -o go-template='{{index .data "tls.crt" | base64decode }}' > tls.crt
#generate a truststore file containing the tls.crt, note the es1234 password
keytool -import -file tls.crt -alias firstCA -keystore myTrustStore -storepass es1234 -noprompt
#create the es-truststore-secret
oc create secret generic es-truststore-secret --from-file=truststore.jks=myTrustStore --type=opaque
```
7. Create a secret containing a .properties file with elastic username and password inside. This secret will be mounted by the kafka-connect cluster and used by the kafka-sink-connector.
```
PW=$(oc get secret "elasticsearch-sample-es-elastic-user" -o go-template='{{.data.elastic | base64decode}}')
sed -i "" "s/REPLACEME/$PW/g" es-user.properties
oc create secret generic es-user-secret --from-file=es-user.properties
```
Please note that this secret is needed because the existing `elasticsearch-sample-es-elastic-user` containing the password is not a valid .properties file, so it cannot be read by the `org.apache.kafka.common.config.provider.FileConfigProvider` used in the kafka-connect configuration.

8. Start KafkaConnectS2I cluster using the `kafkaconnects2i-my-connect-cluster.yaml` file
```
oc apply -f kafkaconnects2i-my-connect-cluster.yaml
```
9. Load the `camel-elasticsearch-rest-kafka-connector` package into the my-connect-cluster-connect
```
mkdir connectors
curl https://repo1.maven.org/maven2/org/apache/camel/kafkaconnector/camel-elasticsearch-rest-kafka-connector/0.2.0/camel-elasticsearch-rest-kafka-connector-0.2.0-package.zip > connectors/file.zip
unzip -d connectors file.zip
rm connectors/file.zip
## Important note, it seems that log4j2 dependencies required by elasticsearch are missing. So download them manually
curl https://repo1.maven.org/maven2/org/apache/logging/log4j/log4j-core/2.13.3/log4j-core-2.13.3.jar > connectors/camel-elasticsearch-rest-kafka-connector/log4j-core-2.13.3.jar
curl https://repo1.maven.org/maven2/org/apache/logging/log4j/log4j-api/2.13.3/log4j-api-2.13.3.jar > connectors/camel-elasticsearch-rest-kafka-connector/log4j-api-2.13.3.jar
oc start-build my-connect-cluster-connect --from-dir=./connectors --follow
```
10. Create KafkaConnector inside the `my-connect-cluster-connect` using the `kafkaconnector-my-sink-connector.yaml` file
```
oc apply -f kafkaconnector-my-sink-connector.yaml
```
11. Test the connection between Kafka and Elasticsearch sending a test message
```
oc exec -it my-cluster-kafka-0 bash
echo '{"data":"Hello World"}' | bin/kafka-console-producer.sh --broker-list localhost:9092 --topic my-topic
```
Check that message is stored in Elasticsearch (it may take some time). Please use the $PW value in the command.
```
curl -k -u elastic:<password here> https://elasticsearch-sample-es-http:9200/my-topic/_search
```

repository: alessandromonguzzi/kafka-configs

repo_name: alessandromonguzzi/kafka-configs


text:
## Tutorials

Tutorials for mlpack can be found [here : mlpack tutorials](http://www.mlpack.org/tutorial.html).

### Method-specific tutorials
* [NeighborSearch tutorial (allknn / allkfn)](http://www.mlpack.org/doxygen.php?doc=nstutorial.html)
* [RangeSearch tutorial (range_search)](http://www.mlpack.org/doxygen.php?doc=rstutorial.html)
* [LinearRegression tutorial](http://www.mlpack.org/doxygen.php?doc=lrtutorial.html)
* [Density Estimation Trees tutorial (det)](http://www.mlpack.org/doxygen.php?doc=dettutorial.html)
* [Euclidean Minimum Spanning Trees tutorial (emst)](http://www.mlpack.org/doxygen.php?doc=emst_tutorial.html)
* [K-Means tutorial (kmeans)](http://www.mlpack.org/doxygen.php?doc=kmtutorial.html)
* [FastMKS tutorial (fastmks)](http://www.mlpack.org/doxygen.php?doc=fmkstutorial.html)

### General mlpack tutorials
* [Building mlpack from source](http://www.mlpack.org/doxygen.php?doc=build.html)
* [mlpack input and output](http://www.mlpack.org/doxygen.php?doc=iodoc.html)
* [Matrices in mlpack](http://www.mlpack.org/doxygen.php?doc=matrices.html)
* [Simple sample mlpack programs](http://www.mlpack.org/doxygen.php?doc=sample.html)
* [mlpack timers](http://www.mlpack.org/doxygen.php?doc=timer.html)

repository: varunnagpaal/mlpack

repo_name: varunnagpaal/mlpack


text:
## Module DOM.Node.Node

#### `nodeType`

``` purescript
nodeType :: Node -> NodeType
```

The type of a node.

#### `nodeTypeIndex`

``` purescript
nodeTypeIndex :: Node -> Int
```

The numeric value for the type of a node.

#### `nodeName`

``` purescript
nodeName :: Node -> String
```

For elements this is the tag name, for document types this is the doctype
name, for processing instructions this is the target, for all other nodes
it is a string like `"#text"`, `"#comment", etc. depending on the node
type.

#### `baseURI`

``` purescript
baseURI :: forall eff. Node -> Eff (dom :: DOM | eff) String
```

The node's base URL.

#### `ownerDocument`

``` purescript
ownerDocument :: forall eff. Node -> Eff (dom :: DOM | eff) (Nullable Document)
```

The document the node belongs to, unless the node is a document in which
case the value is null.

#### `parentNode`

``` purescript
parentNode :: forall eff. Node -> Eff (dom :: DOM | eff) (Nullable Node)
```

The parent node of the node.

#### `parentElement`

``` purescript
parentElement :: forall eff. Node -> Eff (dom :: DOM | eff) (Nullable Element)
```

The parent element of the node.

#### `hasChildNodes`

``` purescript
hasChildNodes :: forall eff. Node -> Eff (dom :: DOM | eff) Boolean
```

Indicates whether the node has any child nodes.

#### `childNodes`

``` purescript
childNodes :: forall eff. Node -> Eff (dom :: DOM | eff) NodeList
```

The children of the node.

#### `firstChild`

``` purescript
firstChild :: forall eff. Node -> Eff (dom :: DOM | eff) (Nullable Node)
```

The first child of the node, or null if the node has no children.

#### `lastChild`

``` purescript
lastChild :: forall eff. Node -> Eff (dom :: DOM | eff) (Nullable Node)
```

The last child of the node, or null if the node has no children.

#### `previousSibling`

``` purescript
previousSibling :: forall eff. Node -> Eff (dom :: DOM | eff) (Nullable Node)
```

The previous sibling node, or null if there is no previous sibling.

#### `nextSibling`

``` purescript
nextSibling :: forall eff. Node -> Eff (dom :: DOM | eff) (Nullable Node)
```

The next sibling node, or null if there is no next sibling.

#### `nodeValue`

``` purescript
nodeValue :: forall eff. Node -> Eff (dom :: DOM | eff) String
```

If the node type is text, comment, or processing instruction this is the
node's data, or null in all other cases.

#### `setNodeValue`

``` purescript
setNodeValue :: forall eff. String -> Node -> Eff (dom :: DOM | eff) Unit
```

If the node type is text, comment, or processing instruction this allows
the node's data to be changed, or has no effect in all other cases.

#### `textContent`

``` purescript
textContent :: forall eff. Node -> Eff (dom :: DOM | eff) String
```

If the node type is document fragment, element, text, processing
instruction, or comment this is the node's data, or null in all other
cases.

#### `setTextContent`

``` purescript
setTextContent :: forall eff. Node -> Eff (dom :: DOM | eff) Unit
```

If the node type is document fragment, element, text, processing
instruction, or comment this allows the node's data to be changed, or has
no effect in all other cases.

#### `normalize`

``` purescript
normalize :: forall eff. Node -> Eff (dom :: DOM | eff) Unit
```

Removes empty text nodes and then combines any remaining text nodes that
are contiguous.

#### `clone`

``` purescript
clone :: forall eff. Node -> Eff (dom :: DOM | eff) Unit
```

Clones the node without cloning the node's descendants.

#### `deepClone`

``` purescript
deepClone :: forall eff. Node -> Eff (dom :: DOM | eff) Unit
```

Clones the node and its descendants.

#### `isEqualNode`

``` purescript
isEqualNode :: forall eff. Node -> Node -> Eff (dom :: DOM | eff) Boolean
```

Checks whether two nodes are equivalent.

#### `compareDocumentPositionBits`

``` purescript
compareDocumentPositionBits :: forall eff. Node -> Node -> Eff (dom :: DOM | eff) Int
```

#### `contains`

``` purescript
contains :: forall eff. Node -> Node -> Eff (dom :: DOM | eff) Boolean
```

Checks whether the second node is contained within the first

#### `lookupPrefix`

``` purescript
lookupPrefix :: forall eff. String -> Node -> Eff (dom :: DOM | eff) (Nullable String)
```

#### `lookupNamespaceURI`

``` purescript
lookupNamespaceURI :: forall eff. String -> Node -> Eff (dom :: DOM | eff) (Nullable String)
```

#### `isDefaultNamespace`

``` purescript
isDefaultNamespace :: forall eff. String -> Node -> Eff (dom :: DOM | eff) Boolean
```

#### `insertBefore`

``` purescript
insertBefore :: forall eff. Node -> Node -> Node -> Eff (dom :: DOM | eff) Node
```

Inserts the first node before the second as a child of the third node.

#### `appendChild`

``` purescript
appendChild :: forall eff. Node -> Node -> Eff (dom :: DOM | eff) Node
```

Appends the first node to the child node list of the second node.

#### `replaceChild`

``` purescript
replaceChild :: forall eff. Node -> Node -> Node -> Eff (dom :: DOM | eff) Node
```

Uses the first node as a replacement for the second node in the children
of the third node.

#### `removeChild`

``` purescript
removeChild :: forall eff. Node -> Node -> Eff (dom :: DOM | eff) Node
```

Removes the first node from the children of the second node.

repository: hlian/barnacles

gha_language: Ruby

repo_name: hlian/barnacles


text:
Contributing to java-flags
==========================

Fork this GitHub repository (or ask me to make BitBucket mirror public) and prepare your changes into a Pull Request.

Make sure yo do:

1. Create tests all relevant changes and any fixed bugs!
2. Run all tests to make sure they are not broken.
3. Add your name and GitHub ID to CONTRIBUTING before submitting your Pull Request.
4. Check README.md for up-to-dateness (my favorite ness-ness)
5. No failing or broken tests ar accepted in Pull Requests and may result in excessive trolling in the Code Review.

## Maintainer

- Matej Gagyi @yin

repository: yin/java-flags

repo_name: yin/java-flags


text:
***Sitecore importer is a work in progress***

How to run
===

To start the script run: `node script.js`

Setup
==
* [http://devdocs.io/lodash/](http://devdocs.io/lodash/)
* [https://lodash.com/docs](https://lodash.com/docs)
* [https://sdn.sitecore.net/upload/sdn5/modules/sitecore%20item%20web%20api/sitecore_item_web_api_developer_guide_sc65-66-usletter.pdf](https://sdn.sitecore.net/upload/sdn5/modules/sitecore%20item%20web%20api/sitecore_item_web_api_developer_guide_sc65-66-usletter.pdf)

Upload media, get id and filepath.

Inserting Images into articles
====

```
<img height="1667" alt="Image Title" width="2500" src="~/media/{123-345-6789-101112}.ashx" />
```

Inserting Main images into articles
====

insert file path into main image field
```
/Images/Social/Connector/Facebook
```

===
```
/{image name}
```

Reading items by id
===
```
this.readItem('{123-345-6789-101112}');
```

Query support
===

```
this.query('/sitecore/content/*');
```

Run tests
===
Install mocha
`npm install -g mocha`

run tests
`mocha`

Story
===

New Content ( v1 )

* Upload zip of images e.g. (2015.zip)
* config has base media folder to upload into ( pops off zip name and creates or upserts images for 2015.zip it would be , /media/events/2015/* )
* Zip contains images named like "{name of image}.jpg" like "Event One.jpg"
* After all images are uploaded, upload articles from csv,
    * match main image to field in csv for main image location
    * serach description for {image name} without extension, swap out that string for `<img height="{image-y}" width="{image-x}" alt="{Name of Image}" src="~/media/{ID-Of-Image}.ashx" />`

Updating Content ( v2 )
* upload CSV
    * match title of article to post
    * Use that matched Id to get fields
    * swap out content with new content

Examples
===
```
    // Home directory
    this.readItem( '{110D559F-DEA5-42EA-9C1C-8A5DF7E70EF9}' );

    // Web Template
    this.readItem( '{AB86861A-6030-46C5-B394-E8F99E8B87DB}' );

    // Manufacture Template
    this.readItem( '{2987BF93-3CC5-4D01-91E7-2CD5B9553673}', {
        payload: 'full'
    });

    this.query('/sitecore/Content/Hemstreet/*');
    this.query('/sitecore/content/Home/Products/Manufacturers/0 to 9/3M');

    this.createItem({
        'name' : 'Script imported item',
        'body' : {
            'title' : 'Test Item',
            'description' : 'Test importing an article'
        }
    });

    // Import Manufacture Pages sheet from import/spreadsheets/site.xls
    this.importFromSpreadsheet('test.xls',
        'Manufacture Pages',
        [
            "Title",
            "Heading",
            "Description"
        ]
    );
```

repository: hemstreet/Sitecore-Importer

repo_name: hemstreet/Sitecore-Importer


text:
# Changelog

_This changelog follows the [keep a changelog][keep-a-changelog]_ format to maintain a human readable changelog.

### [0.14.0](https://github.com/typestack/class-validator/compare/v0.13.2...v0.14.0) (2022-12-09)

### Added

- add `@IsTimeZone` decorator to check if given string is valid IANA time zone
- add `@IsISO4217CurrencyCode` decorator to check if the string is an ISO 4217 currency code
- add `@IsStrongPassword` decorator to check if given password matches specific complexity criteria
- add `@IsBase58` decorator to check if a string is base58 encoded
- add `@IsTaxId` decorator to check if a given string is a valid tax ID in a given locale
- add support for passing function as date generator in `@MinDate` and `@MaxDate` decorators
- add option to print constraint error message instead of constraint type in validation error
- improve decorator metadata lookup performance
- return possible values in error message for `@IsEnum` decorator

### Fixed

- re-added `@types/validator` as dependency
- fix error generation when using `@NestedValidation`
- pass validation options correctly to validator in `@IsDateString` decorator
- support passing `Symbol` as parameter in error message generation
- specify supported locales for `@IsAlphanumeric` decorator
- correctly assign decorator name in metadata instead of loosing it
- fix various spelling errors in documentation
- fix various spelling errors and inconsistencies in JSDoc for decorators

### Changed

- enable `forbidUnknownValues` option by default
- remove documentation about deprecated schema based validation and added warning
- update warning message logged about missing decorator metadata
- update `libphonenumber-js` to `^1.10.14` from `^1.9.43`
- update various dev-dependencies

### BREAKING CHANGES

**`forbidUnknownValues` option is enabled by default**

From this release the `forbidUnknownValues` is enabled by default. This is the desired behavior for majority of
use-cases, but this change may break validation for some. The two scenarios that results in failed validation:

- when attempting to validate a class instance without metadata for it
- when using group validation and the specified validation group results in zero validation applied

The old behavior can be restored via specifying `forbidUnknownValues: false` option when calling the validate functions.

For more details see [PR #1798](https://github.com/typestack/class-validator/pull/1798) and [#1422 (comment)](https://github.com/typestack/class-validator/issues/1422#issuecomment-1317953863).

**`@NestedValidation` decorator correctly assigns validation errors**

Until now the errors from a nested validation in some cases were incorrectly assigned
to the parent instead of the child being validated. Now the validation errors are correctly assigned.

For more details see [#679](https://github.com/typestack/class-validator/issues/679).

### [0.13.2](https://github.com/typestack/class-validator/compare/v0.13.1...v0.13.2) (2021-11-20)

> **NOTE:** This version fixes a security vulnerability allowing denial of service attacks with a specially crafted request payload.
> Please update as soon as possible.

#### Fixed

- switched to use `Array.isArray` in array checks from `instanceof` operator

#### Changed

- `libphonenumber-js` package updated to `1.9.43` from `1.9.7`
- `validator` package updated to `13.5.2` from `13.5.2`
- various dev-dependencies updated

### [0.13.1](https://github.com/typestack/class-validator/compare/v0.13.0...v0.13.1) (2021-01-14)

#### Added

- optional mather function has been added to the `ArrayUnique` decorator

#### Fixed

- a typo was fixed in the error message generated by the `IsUUID` decorator
- calling `ValidationError.toString()` doesn't result in an error when `forbidNonWhitelisted` parameter was used
- fixed typo in error message generated by `IsIn` decorator
- the `@types/validator` package is correctly installed
- `inlineSources` option is enabled in tsconfig preventing various sourcemap errors when consuming the package

#### Changed

- various dev dependencies has been updated

### [0.13.0](https://github.com/typestack/class-validator/compare/v0.12.2...v0.13.0) (2021-01-11)

#### Added

- **project is restructured to allow three-shaking**
- added option to fail on first validation error (#620)
- two new validator option is added:
  - `always` - allows setting global default for `always` option for decorators
  - `strictGroups` - ignore decorators with at least one group, when `ValidatorOptions.groups` is empty

### Fixed

- the 'any' locale is allowed in the `isPostalCode` decorator (#634)
- the `IsDateString()` decorator now aliases the `IsISO8601()` decorator (#672)

#### Changed

- project tooling has been updated significantly
- google-libphonenumber has been replaced with libphonenumber-js (this should have no effect on validation)
- build process generates include both ES/CommonJS and UMD variations
- various dev dependencies has been updated

### [0.12.2](https://github.com/typestack/class-validator/compare/v0.12.1...v0.12.2) (2020-04-23)

#### Fixed

- move `tslib` from `peerDependencies` to `dependencies` ([827eff1](https://github.com/typestack/class-validator/commit/827eff1)), closes [#588](https://github.com/typestack/class-validator/issues/588)

### [0.12.1](https://github.com/typestack/class-validator/compare/v0.12.0...v0.12.1) (2020-04-18)

#### Fixed

- apply only nested validator for ValidateNested multi-dimensional array ([c463be5](https://github.com/typestack/class-validator/commit/c463be5))

### [0.12.0](https://github.com/typestack/class-validator/compare/v0.11.1...v0.12.0) (2020-04-18)

#### Fixed

- accept negative timezone in isDateString ([#564](https://github.com/typestack/class-validator/issues/564)) ([2012d72](https://github.com/typestack/class-validator/commit/2012d72)), closes [#565](https://github.com/typestack/class-validator/issues/565)
- apply all decorators type PropertyDecorator ([#556](https://github.com/typestack/class-validator/issues/556)) ([5fb36e3](https://github.com/typestack/class-validator/commit/5fb36e3)), closes [#555](https://github.com/typestack/class-validator/issues/555)
- avoiding metadataStorage from DI ([#335](https://github.com/typestack/class-validator/issues/335)) ([b57fef4](https://github.com/typestack/class-validator/commit/b57fef4)), closes [#328](https://github.com/typestack/class-validator/issues/328) [#261](https://github.com/typestack/class-validator/issues/261) [#132](https://github.com/typestack/class-validator/issues/132)
- correct registerDecorator options argument ([7909ec6](https://github.com/typestack/class-validator/commit/7909ec6)), closes [#302](https://github.com/typestack/class-validator/issues/302)
- IsNumberString accept isNumbericOptions as argument ([62b993f](https://github.com/typestack/class-validator/commit/62b993f)), closes [#518](https://github.com/typestack/class-validator/issues/518) [#463](https://github.com/typestack/class-validator/issues/463)
- optional `constraints` property in ValidationError ([#465](https://github.com/typestack/class-validator/issues/465)) ([84680ad](https://github.com/typestack/class-validator/commit/84680ad)), closes [#309](https://github.com/typestack/class-validator/issues/309)
- pass context to ValidationError for async validations ([#533](https://github.com/typestack/class-validator/issues/533)) ([4eb1216](https://github.com/typestack/class-validator/commit/4eb1216))
- switch isLatitude & isLongitude validators ([#513](https://github.com/typestack/class-validator/issues/513)) ([5497179](https://github.com/typestack/class-validator/commit/5497179)), closes [#502](https://github.com/typestack/class-validator/issues/502)
- switch isLatitude & isLongitude validators ([#537](https://github.com/typestack/class-validator/issues/537)) ([c27500b](https://github.com/typestack/class-validator/commit/c27500b))
- ValidateNested support multi-dimensional arrays ([#539](https://github.com/typestack/class-validator/issues/539)) ([62678e1](https://github.com/typestack/class-validator/commit/62678e1))

#### Changed

- update build process to enable tree shaking ([#568](https://github.com/typestack/class-validator/issues/568)) ([11a7b8b](https://github.com/typestack/class-validator/commit/11a7b8b)), closes [#258](https://github.com/typestack/class-validator/issues/258) [#248](https://github.com/typestack/class-validator/issues/248) [#247](https://github.com/typestack/class-validator/issues/247) [#212](https://github.com/typestack/class-validator/issues/212)

#### Added

- sync validatorjs version from v10.11.3 to v13.0.0 ([09120b7](https://github.com/typestack/class-validator/commit/09120b7)), closes [#576](https://github.com/typestack/class-validator/issues/576) [#425](https://github.com/typestack/class-validator/issues/425)

### BREAKING CHANGES

- Validatorjs releases contain some breaking changes e.g. `IsMobileNumber` or `IsHexColor`. Please check validatorjs [CHANGELOG](https://github.com/validatorjs/validator.js/blob/master/CHANGELOG.md)
- Validation functions was removed from `Validator` class to enable tree shaking.

  BEFORE:

  ```ts
  import { Validator } from 'class-validator';

  const validator = new Validator();
  validator.isNotIn(value, possibleValues);
  validator.isBoolean(value);
  ```

  AFTER:

  ```ts
  import { isNotIn, isBoolean } from 'class-validator';

  isNotIn(value, possibleValues);
  isBoolean(value);
  ```

- IsNumberString decorator arguments changed to `@IsNumberString(ValidatorJS.IsNumericOptions, ValidationOptions)`.

### [0.11.1](https://github.com/typestack/class-validator/compare/v0.11.0...v0.11.1) (2020-03-18)

#### Fixed

- IsNumber validator now works when maxDecimalPlaces=0 ([#524](https://github.com/typestack/class-validator/issues/524)) ([b8aa922](https://github.com/typestack/class-validator/commit/b8aa922))

#### Added

- add all option in isuuid validator ([#452](https://github.com/typestack/class-validator/issues/452)) ([98e9382](https://github.com/typestack/class-validator/commit/98e9382))
- add IsFirebasePushId validator ([#548](https://github.com/typestack/class-validator/issues/548)) ([e7e2e53](https://github.com/typestack/class-validator/commit/e7e2e53))
- add options for isISO8601 validator ([#460](https://github.com/typestack/class-validator/issues/460)) ([90a6638](https://github.com/typestack/class-validator/commit/90a6638))

### [0.11.0](https://github.com/typestack/class-validator/compare/v0.10.2...v0.11.0) (2019-11-01)

#### Fixed

- create instance of ValidationError for whitelist errors ([#434](https://github.com/typestack/class-validator/issues/434)) ([a98f5dd](https://github.com/typestack/class-validator/commit/a98f5dd)), closes [#325](https://github.com/typestack/class-validator/issues/325)
- pass context for isDefined and custom validators ([#296](https://github.com/typestack/class-validator/issues/296)) ([0ef898e](https://github.com/typestack/class-validator/commit/0ef898e)), closes [#292](https://github.com/typestack/class-validator/issues/292)

#### Added

- add isHash validator ([#445](https://github.com/typestack/class-validator/issues/445)) ([c454cf9](https://github.com/typestack/class-validator/commit/c454cf9))
- add isISSN validator ([#450](https://github.com/typestack/class-validator/issues/450)) ([4bd586e](https://github.com/typestack/class-validator/commit/4bd586e))
- add isJWT validator ([#444](https://github.com/typestack/class-validator/issues/444)) ([874861b](https://github.com/typestack/class-validator/commit/874861b))
- add isMACAddress validator ([#449](https://github.com/typestack/class-validator/issues/449)) ([45b7df7](https://github.com/typestack/class-validator/commit/45b7df7))
- add support for maxDecimalPlaces on IsNumber ([#381](https://github.com/typestack/class-validator/issues/381)) ([a4dc10e](https://github.com/typestack/class-validator/commit/a4dc10e))

### BREAKING CHANGES

- update @types/validator from 11.1.0 to version 12.0.0 - please check it's [changelog][validator-js-release-notes]

### [0.10.2](https://github.com/typestack/class-validator/compare/v0.10.1...v0.10.2) (2019-10-14)

#### Fixed

- apply custom constraint class validation to each item in the array ([#295](https://github.com/typestack/class-validator/issues/295)) ([5bb704e](https://github.com/typestack/class-validator/commit/5bb704e)), closes [#260](https://github.com/typestack/class-validator/issues/260)

#### Added

- add isLatLong, isLatitude, isLongtitude validators ([#427](https://github.com/typestack/class-validator/issues/427)) ([3fd15c4](https://github.com/typestack/class-validator/commit/3fd15c4)), closes [#415](https://github.com/typestack/class-validator/issues/415)
- add IsObject and IsNotEmptyObject new decorators ([#334](https://github.com/typestack/class-validator/issues/334)) ([0a41aeb](https://github.com/typestack/class-validator/commit/0a41aeb))
- support ES6 Map and Set for regular validators with each option ([#430](https://github.com/typestack/class-validator/issues/430)) ([a055bba](https://github.com/typestack/class-validator/commit/a055bba)), closes [#428](https://github.com/typestack/class-validator/issues/428)

### [0.10.1](https://github.com/typestack/class-validator/compare/v0.10.0...v0.10.1) (2019-09-25)

#### Fixed

- add default message for isMilitaryTime validator ([#411](https://github.com/typestack/class-validator/issues/411)) ([204b7df](https://github.com/typestack/class-validator/commit/204b7df)), closes [#287](https://github.com/typestack/class-validator/issues/287)
- add default message for isPort validator ([#404](https://github.com/typestack/class-validator/issues/404)) ([74e568c](https://github.com/typestack/class-validator/commit/74e568c))
- add locale parameter for isAlpha and isAlphanumeric validat… ([#406](https://github.com/typestack/class-validator/issues/406)) ([2f4bf4e](https://github.com/typestack/class-validator/commit/2f4bf4e))

#### Added

- add `skipUndefinedProperties`, `skipNullProperties` options ([#414](https://github.com/typestack/class-validator/issues/414)) ([76c948a](https://github.com/typestack/class-validator/commit/76c948a)), closes [#308](https://github.com/typestack/class-validator/issues/308)

### [0.10.0](https://github.com/typestack/class-validator/compare/v0.9.1...v0.10.0) (2019-08-10)

#### Fixed

- add correct signature for custom error message handler ([249c41d](https://github.com/typestack/class-validator/commit/249c41d))

#### Added

- add `IsISO31661Alpha3` and `IsISO31661Alpha2` validators ([#273](https://github.com/typestack/class-validator/issues/273)) ([55c57b3](https://github.com/typestack/class-validator/commit/55c57b3))
- **IsDecimal:** implement `IsDecimal` from validatorjs ([#359](https://github.com/typestack/class-validator/issues/359)) ([b4c8e21](https://github.com/typestack/class-validator/commit/b4c8e21))
- add `isPort` decorator ([#282](https://github.com/typestack/class-validator/issues/282)) ([36684ec](https://github.com/typestack/class-validator/commit/36684ec))
- allow validate Map/Set ([#365](https://github.com/typestack/class-validator/issues/365)) ([f6fcdc5](https://github.com/typestack/class-validator/commit/f6fcdc5))
- new `ValidatePromise` decorator - resolve promise before validate ([#369](https://github.com/typestack/class-validator/issues/369)) ([35ec04d](https://github.com/typestack/class-validator/commit/35ec04d))
- replace instanceof Promise and support Promise/A+ ([#310](https://github.com/typestack/class-validator/issues/310)) ([59eac09](https://github.com/typestack/class-validator/commit/59eac09))
- `isNumberString` now accept validator.js `IsNumericOptions` as second parameter ([#262](https://github.com/typestack/class-validator/issues/262))

### BREAKING CHANGES

- update @types/validator from 10.4.0 to version 10.11.2 - please check it's [changelog][validator-js-release-notes] ([cb960dd](https://github.com/typestack/class-validator/commit/cb960dd))
- `isDateString` now check to match only entire ISO Date ([#275](https://github.com/typestack/class-validator/issues/275)) ([5012464](https://github.com/typestack/class-validator/commit/5012464))
- remove `IsCurrencyOptions`, `IsURLOptions`, `IsEmailOptions`, `IsFQDNOptions` interfaces and replace with interfaces from `@types/validator`

### [0.9.1](https://github.com/typestack/class-validator/compare/v0.9.0...v0.9.1)

#### Added

- added option to pass custom context for the decorators

#### Fixed

- validating against a schema will validate against that one instead of every registered one

### [0.9.0](https://github.com/typestack/class-validator/compare/v0.8.5...v0.9.0) [BREAKING CHANGE]

#### Added

- updated [validator.js][validator-js] from 9.2.0 to 10.4.0 (Check it's [changelog][validator-js-release-notes] for what has changed.)
  - until now fractional numbers was not allowed in the `IsNumberString` decorator, now they are allowed
  - until now Gmail addresses could contain multiple dots or random text after a `+` symbol, this is not allowed anymore
- `IsPhoneNumber` decorator has been added which uses the [google-libphonenumber][google-libphonenumber] library to validate international phone numbers accurately

#### Fixed

- update `IsURLOptions` to match underlying validator host list options
- added a console warning when no metadata decorator is found as it's possibly not intended
- the `Min` and `Max` decorator will corectly show an inclusive error message when failing
- fixed a runtime error when `validationArguments.value` is not a string

### [0.8.5](https://github.com/typestack/class-validator/compare/v0.8.4...v0.8.5)

#### Fixed

- remove `ansicolor` package, because it's incompatible with IE

### [0.8.4](https://github.com/typestack/class-validator/compare/v0.8.3...v0.8.4)

#### Added

- `ValidatorOptions` now has a `forbidUnknownValues` key to prevent unknown objects to pass validation
  - it's highly advised to turn this option on
  - now this option defaults to `false` but will be default to `true` after the **1.0** release

### [0.8.3](https://github.com/typestack/class-validator/compare/v0.8.2...v0.8.3)

#### Fixed

- handle when `target` property is undefined when calling `ValidationError.toString()`

### [0.8.2](https://github.com/typestack/class-validator/compare/v0.8.1...v0.8.2)

#### Added

- added `ValidationError.toString()` method for easier debugging
- added `printError` method to pretty-print errors in NodeJS or the browser

#### Fixed

- fixed wrong type info in `ValidatorOptions`
- fixed wrong type info in `ValidationSchema` \(the `options` key now is optional\)
- corrected `IsNumericString` to `IsNumberString` in the README
- fixed type of `host_whitelist` and `host_backlist` in `IsURLOptions`

### [0.8.1](https://github.com/typestack/class-validator/compare/v0.8.0...v0.8.1)

#### Fixed

- fixed wrong type info in `ValidatorOptions`

### 0.8.0 \[BREAKING CHANGE\]

##### Added

- updated [validator.js][validator-js] from 7.0.0 to 9.2.0 (Check it's [changelog][validator-js-release-notes] for what has changed.)

  This caused breaking change, if you used the `IsUrl` decorator to validate `localhost` as a valid url, from now you must use the `require_tld: false` option

  ```typescript
  @IsUrl({ require_tld: false})
  url: string;
  ```

- added `@IsInstance` decorator and `validator.isInstance(value, target)` method.
- changed `@IsNumber` decorator has been changed to `@IsNumber(options: IsNumberOptions)`
- added option to strip unknown properties \(`whitelist: true`\)
- added option to throw error on unknown properties \(`forbidNonWhitelisted: true`\)
- added `@Allow` decorator to prevent stripping properties without other constraint

#### Fixed

- fixed issue with `@IsDateString` now it allow dates without fraction seconds to be set
- fixed issue with `@IsDateString` now it allow dates without with timezones to be set
- `@ValidateNested` correctly generates validation error on non object and non array values

### 0.6.7

#### Fixed

- fixed issue with `@ValidateNested` when nested property is not defined and it throw an error \(\#59\)

### 0.6.5

#### Fixed

- fixed bugs with `@IsUrl`, `@IsEmail` and several other decorators

### 0.6.4

#### Added

- added `@IsMilitaryTime` decorator.

### 0.6.3

#### Added

- added `validateOrReject` method which rejects promise instead of returning array of errors in resolved result

### 0.6.1

#### Added

- added `@IsArray` decorator.

### 0.6.0 \[BREAKING CHANGE\]

#### Added

- breaking change with `@ValidateNested` on arrays: Validator now groups the validation errors by sub-object, rather than them all being grouped together. See \#32 for a demonstration of the updated structure.
- added `@ValidateIf` decorator, see conditional validation in docs.

### 0.5.0 \[BREAKING CHANGE\]

#### Added

- async validations must be marked with `{ async: true }` option now.

  This is optional, but it helps to determine which decorators are async to prevent their execution in `validateSync` method.

- added `validateSync` method that performs non asynchronous validation and ignores validations that marked with `async: true`.
- there is a breaking change in `registerDecorator` method. Now it accepts options object.
- breaking change with `@ValidatorConstraint` decorator. Now it accepts option object instead of single name.

### 0.4.1

#### Fixed

- fixed issue with wrong source maps packaged

### 0.4.0 \[BREAKING CHANGE\]

#### Added

- everything should be imported from "class-validator" main entry point now
- `ValidatorInterface` has been renamed to `ValidatorConstraintInterface`
- contain can be set in the main entry point now
- some decorator's names changed. Be aware of this
- added few more non-string decorators
- validator now returns array of ValidationError instead of ValidationErrorInterface. Removed old ValidationError
- removed all other validation methods except `validator.validate`
- finally validate method is async now, so custom async validations are supported now
- added ability to validate inherited properties
- added support of separate validation schemas
- added support of default validation messages
- added support of special tokens in validation messages
- added support of message functions in validation options
- added support of custom decorators
- if no groups were specified, decorators with groups now are being ignored
- changed signature of the `ValidationError`. Now if it has nested errors it does not return them in a flat array

#### Fixed

- fixed all decorators that should not work only with strings

### 0.3.0

#### Added

- package has changed its name from `validator.ts` to `class-validator`.
- sanitation functionality has been removed from this library. Use [class-sanitizer][class-sanitizer] instead.

[class-sanitizer]: https://github.com/typestack/class-validator/class-sanitizer
[validator-js]: https://github.com/chriso/validator.js
[validator-js-release-notes]: https://github.com/chriso/validator.js/blob/master/CHANGELOG.md
[google-libphonenumber]: https://github.com/ruimarinho/google-libphonenumber
[keep-a-changelog]: https://keepachangelog.com/en/1.0.0/

repository: typestack/class-validator

branch_name: refs/heads/develop

repo_name: typestack/class-validator


text:
# Expand an existing Fabric network with a new org

This document describes the process how to do the following:

0. Set up two sites, one is considered an existing Fabric network, the other one is considered a new organization
1. Add a new organization into existing fabric network
2. Join peers from the new organization to the existing channel
3. Install chaincode running on the existing peers onto new peers
4. Approve and commit the chaincode
5. Verify endorsement and chaincode containers

Assume that you have two working directories, `mysite0` and `mysite1` under your root directory. Each working
directory will represent a site which may include one or multiple orgs and peers, the two working directory
can very well be on differnt servers, in that case, you will need to have other means such as `scp` to transfer
necessary files between servers. Here are the two spec.yaml files

```
cat ~/mysite0/spec.yaml

fabric:
  peers:
  - "peer1.org0.example.com"
  - "peer2.org0.example.com"
  - "peer1.org1.example.com"
  - "peer2.org1.example.com"
  orderers:
  - "orderer1.example.com"
  - "orderer2.example.com"
  - "orderer3.example.com"

cat ~/mysite1/spec.yaml

fabric:
  peers:
  - "peer1.orgx.example.com"
  - "peer2.orgx.example.com"

```

## Bring up both sites using the following commands

```
cd ~/mysite0
minifab up -e 7000 -n samplecc -p ''

cd ~/mysite1
minifab netup -e 7200 -o orgx.example.com
```

The first command brings up a complete running fabric network with a channel named `mychannel`
created and chaincode named `samplecc` installed, approved, committed and initialized. There are
two peer orgs and one orderer org. Once the command finished successfully, it is a fully running
Fabric network and consider this as an existing Fabric network.

The second command brings up a new organization with only two peer nodes. No channel, no orderer
nodes, just two peer nodes up running.

## Join orgx.example.com to the application channel with the following step
Since the mysite1 has the organization orgx.example.com, then the file produced
by Minifabric for joining an existing network will be called `JoinRequest_orgx-example-com.json`
under `~/mysite1/vars` directory. If you have different name for your organization, then the
join request file will have different file name, make changes accordingly when you run the commands.

```
cd ~/mysite0
sudo cp ~/mysite1/vars/JoinRequest_orgx-example-com.json ~/mysite0/vars/NewOrgJoinRequest.json
minifab orgjoin
```

## Import orderer nodes to orgx.example.com and join peers of orgx.example.com to the `mychannel`
For orgx.example.com peers to participate in Fabric network, the organization must know where orderers nodes are.
To do that, we do `nodeimport`

```
cd ~/mysite1
sudo cp ~/mysite0/vars/profiles/endpoints.yaml vars
minifab nodeimport,join
```

## Install and approve chaincode `samplecc` for orgx peers

```
cd ~/mysite1
minifab install,approve -n samplecc -p ''
```

## Approve the chaincode on org0 and org1
Since new orgs joined, the chaincode will need to be approved again so that new org can also commit

```
cd ~/mysite0
minifab approve,discover,commit
```

## Discover and verify the chaincode on orgx

```
cd ~/mysite1
minifab discover
```

Verify that the file `./vars/discover/mychannel/samplecc_endorsers.json` contains the orgx as
endorsing group.

```
cd ~/mysite1
minifab stats
```

The above command should show that mysite1 should have chaincode container like the following
running

```
  dev-peer1.orgx.example.com-samplecc_1.0-9ea5e3809f : Up 4 minutes
  dev-peer2.orgx.example.com-samplecc_1.0-9ea5e3809f : Up 4 minutes
```

## To use your own chaincode
If you want to use your own chaincode, then you should have the chaincode in vars/chaincode directory
and follow the structure to form chaincode. Then use your own chaincode in various commands.


text:
# graphql-nodes
Turns GraphQLResolveInfo into a map of the requested nodes. Flattens all fragments and duplicated nodes into a neat object to easily see which fields were requested at any level.

This project was originally created by Rob Richard [https://github.com/robrichard] and I take no credit for this project. I only 'ported' it to Typescript and re-organized it a bit. Thanks for your work, Rob! :clap:

## Installation
```
    npm install --save graphql-nodes
```

## Usage

```typescript
import { GraphQLResolveInfo } from 'graphql'
import GraphQLNodes from 'graphql-nodes'

function resolver (source, args, context, info : GraphQLResolveInfo) {
    // ...

    let nodes = new GraphQLNodes(info)
    let map = nodes.createMap() // <-- There you have it!

    /*
    query {
        employee(id: 2) {
            firstName
            lastName
        }
    }

    // Produces

    {
        "firstName" : {},
        "lastName" : {}
    }
    */

    // ...
}
```

## Tests
```
npm test
```


text:
# GitHub Docker Action Sample #

This is the sample GitHub Action built in Docker container.

## Inputs ##

* `name` (**Required**): Name to pass

## Outputs ##

* `greeting`: Greetings to be passed

## Example Usage ##

```yaml
steps:
- name: Run a sample Docker container action
  id: sampledockeraction
  uses<EMAIL_ADDRESS>  with:
    name: GitHub Actions

- name: Get the output
  shell: bash
  run: |
    echo ${{ steps.sampledockeraction.outputs.greeting }}
```

repository: vcelisBP/github-actions-docker-sample

repo_name: vcelisBP/github-actions-docker-sample


text:
# SmartCabinet

Just a random project made using Kivy, I made this about 2 years ago when my knowledge of kivy and Application Development in general was not that strong but still this project might help someone. Please use `Python2` for this.

Screens Implemented till now:

    - Inventory Screen
    - Filter Screen.
    - Dialog Popup.
    - Material Screen.
    - Menu Screen.
    - Episode Screen.

## how to run?

```
cd SmartCabinet
python main.py
```


text:
# Kraken (exchange) API implementation

### This repo is built as part of a final project of a coding bootcamp (CodingNomads)

[Kraken](https://www.kraken.com/) is a cryptocurrency exchange operating site functioning in Canada, EU, Japan, and the US;
usually rated as the best and most secure cryptocurrency exchange by independent outlets.
This Kraken interactive program is a Java library connecting a mapped API which consists of straightforward
instructions on how to analyze, record and interact with several cryptocurrency exchanges.

**Warning:** This project is a work in progress and should NOT be used as is. Any liabilities or damages
induced by the use of this tool is the sole responsibility of the user of this tool and not the developers.
Other features will be eventually implemented to improve the functionality and services of this project.

## Description
Kraken is a library providing a simple and consistent API for interacting with a diverse set of crypto currency exchanges.
To interact with the library, the first step is to either perform a trade or exchange, get the appropriate service and request
data, depending on whether the call is either [public](https://www.kraken.com/en-us/help/api#public-market-data) or
[private](https://www.kraken.com/en-us/help/api#private-user-data).

## Getting Started

Kraken requires a [Java 8 JDK](http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html)  to be
installed on the machine you are going to use to run the program.

Required:
* [JDK 8](ttp://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html)
* [Maven](http://maven.apache.org/download.cgi)

Clone the project on your desired location

```
$ git clone https://github.com/Thleruth/kraken
$ cd kraken
$ mvn clean install
```

### Maven
Add the following dependencies in your [`pom.xml`](https://github.com/Thleruth/kraken/blob/master/pom.xml)
file to include encoders and decoders, to extend and augment the Java Collections
Framework(collection), and data-binding functionality for Jackson.

#### Dependencies
```xml
<dependency>
    <groupId>commons-codec</groupId>
    <artifactId>commons-codec</artifactId>
    <version>1.9</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>4.3.12.RELEASE</version>
</dependency>
<dependency>
    <groupId>commons-collection</groupId>
    <artifactId>commons-collection</artifactId>
    <version>3.2.1</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.1</version>
</dependency>
```

#### Plugin
``` xml
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.3</version>
    <configuration>
        <source>1.8</source>
        <target>1.8</target>
    </configuration>
</plugin>
```

## Configuration
This Kraken project contains several main packages including: `exception`, `model`, `service` and `util`.
Aside from these classes we have also created two independent classes: `Controller` and `KrakenExchange`,
which regulate the interaction of the program.

Within the `Exception` package we have added the three different exception classes:
* [`KrakenException`](https://github.com/Thleruth/kraken/blob/master/src/main/java/co/codingnomads/kraken/exception/KrakenException.java):
  extends directly to Exception and is the one the other two extend to.

* [`RateLimitException`](https://github.com/Thleruth/kraken/blob/master/src/main/java/co/codingnomads/kraken/exception/RateLimitException.java):
 takes care of any Rate Limit errors that might occur.

* [`UnknownEcxeption`](https://github.com/Thleruth/kraken/blob/master/src/main/java/co/codingnomads/kraken/exception/UnknownException.java):
 sends an error Message covering up any unknown errors.

 The `model` package contains several other packages mapping the content of the program and the API calls. These subsections include the `account`,
 `market`, and `trade` packages. Each one containing the appropriate pojos for their respective API calls, as well as the response it will generate
 for those who are only GET. The API calls which generate a POST, DELETE, PATCH, etc., also contain a request section for the created body.
 Aside from the already mentioned packages, there are a few independent classes as well, those are:

* [`ApiAuthentication`](https://github.com/Thleruth/kraken/blob/master/src/main/java/co/codingnomads/kraken/model/ApiAuthentication.java):
  includes the basic parameters needed to authenticate a call to the API.

* [`KrakenRequestEnum`](https://github.com/Thleruth/kraken/blob/master/src/main/java/co/codingnomads/kraken/model/KrakenRequestEnum.java):
  is an enum class which was designed to get specific information from the calls such as the endpoint, the type of HTTP call
  it is, the number of calls allowed, and the response output.

* [`OutputWrapper`](https://github.com/Thleruth/kraken/blob/master/src/main/java/co/codingnomads/kraken/model/OutputWrapper.java):
  A generic class with a generic value for the different type of results.

* [`RequestBodyGeneric`](https://github.com/Thleruth/kraken/blob/master/src/main/java/co/codingnomads/kraken/model/RequestBodyGeneric.java):
  abstract class which sets the correct parameters for classes with Request Bodies.

The `service` package contains classes which regulate the program. The classes located within this package include:
* [`CallCounter`](https://github.com/Thleruth/kraken/blob/master/src/main/java/co/codingnomads/kraken/service/CallCounter.java):
  which determined the maximum amount of calls to the API the user is allowed to make.
* [`GenericRequestHandler`](https://github.com/Thleruth/kraken/blob/master/src/main/java/co/codingnomads/kraken/service/GenericRequestHandler.java):
  a generic Request Hanlder that is able to call all end points.
* [`KrakenSignature`](https://github.com/Thleruth/kraken/blob/master/src/main/java/co/codingnomads/kraken/service/KrakenSignature.java):
 which creates the API-Sign based on the particular Kraken requirement.

We also have the `util` package which contains classes that form the base for the API-calls from the Kraken site; encoding and decoding the data from
the cryptographic hash as well as providing the necessary security.

Lastly, we have the independent classes `Controller` and `KrakenExchange`. The KrakenExchange class contains methods for all Kraken Exchange API
calls and also sets the necessary call query parameters, which is why a method for each API call is needed. Once that method is ready, it can be called
on the Controller.

## Contributors

* [Thomas Leruth](https://github.com/Thleruth)
* [Jialor Cheung](https://github.com/PopoPenguin)
* [Meghan Boyce](https://github.com/meejahnsnutshell)
* [Kevin Neag](https://github.com/neagkv)
* [Ricardo Roque](https://github.com/rickypatillas)

## Acknowledgements
* [KrakenXchange](https://github.com/timmolter/XChange) by Tim Molter.

| Calls  | Status |
|:------:|--------|
|`GetServerTime` | Implemented and tested |
|`GetAssetInfo` | Implemented and tested |
|`GetTradableAssetPairs` | Implemented and tested |
|`GetTickerInformation` | Implemented and Tested |
|`GetOHLCdata` | Implemented and tested |
|`GetOrderBook` | Implemented and Tested |
|`GetRecentTrades` | Implemented and tested |
|`GetRecentSpreadData` | Implemented and tested |
|`GetAccountBalance` | Implemented and tested |
|`GetTradeBalance` | Implemented and tested |
|`GetOpenOrders` | Implemented and tested |
|`GetClosedOrders` | Implemented and tested |
|`QueryOrdersInfo` | Implemented and Tested |
|`GetTradesHistory` | Implemented and tested |
|`QueryTradesInfo` | Implemented and tested |
|`GetOpenPositions` | Requires Testing (could not be tested without a valid open order)|
|`GetLedgersInfo` | Implemented and tested |
|`QueryLedgers` | Implemented and tested |
|`GetTradeVolume` | Implemented and tested |
|`AddStandardOrder` | Implemented and tested     |
|`CancelOpenOrder` | Implemented and tested |

Resource used for this project include but not limited to-----------------------------
krakenXChange by Tim Molter: <url>https://github.com/timmolter/XChange/tree/5174f9e931955dc201fa57e228564d8b884c9f84/xchange-kraken</url>

repository: Thleruth/kraken

gha_language: Java

repo_name: Thleruth/kraken


text:
# linkedinwebscraping

Linkedin web scraping people from search result

1-install google chrome.

2-install https://chrome.google.com/webstore/detail/tampermonkey/dhdgffkkebhmkfjojejmpbldmpobfkfo?hl=en

3-create script with this name:saveLinkedIn.user.js

4-copy content from this file saveLinkedIn.user.js in the current repo.

5-change these lines 5(do not delete *) and 10 with your linkedin'search url

6-enable the script

7-the script will download file for each page

8-allow multiple file download for the site.

9-copy all results*.json to results folder

10-run python MergemyResults.py to merge all in finalFile.json

repository: tahazayed/linkedinwebscraping

repo_name: tahazayed/linkedinwebscraping


text:
---
# Documentation: https://wowchemy.com/docs/managing-content/

title: Tiling microarray analysis of rice chromosome 10 to identify the transcriptome
  and relate its expression to chromosomal architecture
subtitle: ''
summary: ''
authors:
- Lei Li
- Xiangfeng Wang
- Mian Xia
- Viktor Stolc
- Ning Su
- Zhiyu Peng
- Songgang Li
- Jun Wang
- Xiping Wang
- Xing Deng
tags: []
categories: []
date: '2005-01-01'
lastmod: 2021-04-20T16:24:45+08:00
featured: false
draft: false

# Featured image
# To use, add an image named `featured.jpg/png` to your page's folder.
# Focal points: Smart, Center, TopLeft, Top, TopRight, Left, Right, BottomLeft, Bottom, BottomRight.
image:
  caption: ''
  focal_point: ''
  preview_only: false

# Projects (optional).
#   Associate this post with one or more of your projects.
#   Simply enter your project's folder or file name without extension.
#   E.g. `projects = ["internal-project"]` references `content/project/deep-learning/index.md`.
#   Otherwise, set `projects = []`.
projects: []
publishDate: '2021-04-20T08:24:45.902436Z'
publication_types:
- '2'
abstract: ''
publication: '*Genome Biol*'
url_pdf: https://doi.org/10.1186%2Fgb-2005-6-6-r52
doi: 10.1186/gb-2005-6-6-r52
---

repository: wanglab-cau/CrazyHsu

repo_name: wanglab-cau/CrazyHsu


text:
# UI Template - Archived

This project has been archived in favor of [ts-react-template](https://github.com/marksfrancis/ts-react-template)

# UI Template

**This project is not a production ready app template**

This is an barebones HTML, JS and SCSS project, with bootstrap and snowpack (via npm), meant for throwing together UI prototypes.

## Features

1. The template HTML file sets up the minimal for HTML 5 (viewport scaling, language, etc.)
1. Snowpack
1. SCSS
1. Bootstrap
1. jQuery
1. Popper
1. Hot reloading
1. VS Code config
1. Auto-updated dependencies (via dependabot)

license: Unlicense

repository: MarkSFrancis/ui-template

gha_license_id: Unlicense

repo_name: MarkSFrancis/ui-template


text:
# # ESCOOccupationValue

## Properties

Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**preferred_label** | **string** | This field shows the preferred label according with the ESCO classification. | [optional]
**code** | **string** | This field shows the ESCO occupation code according with the ESCO classification. | [optional]

[[Back to Model list]](../../README.md#models) [[Back to API list]](../../README.md#endpoints) [[Back to README]](../../README.md)

gha_language: PHP


text:
# Source Code Management

^ Open this presentation with [Deckset](http://www.decksetapp.com/)
^ Jonas

---

# What You'll Learn

* Why use version control
* How to use Git
* How to use GitHub
* What a pull request is
* Branches and why they're really smart

---

# Day 2 Agenda

* Daily standup
* Basic tutorial on GitHub / Source Code Management
* 12 Factor Apps
* Team works via collaborative methods (Slack, Asana, Google Hangouts, etc) to complete tasks committed for that day.
* Optional: Vagrant & Packer

---

# Why use version control

 - Version control records changes that are made so you can recall specific version later
 - Makes it possible for you to work on a feature/bug fix/release without changing production code
 - No more "file-version3.py" or "config-020315.conf"!
 - Since everything is pure text it's easy to "merge" new code into existing

---

# Git

A distributed version control system, where every user has a complete and full copy of the source code.

If you can't check it in, you can't keep track of it, so you can't version it, so you can't automate it.

*Everything* belongs in source code control, and git is the standard in 3rd platform.

Other possible options: subversion (svn), mercurial (hg), Perforce (p4), ClearCase (cc).

---

# GitHub

A freemium service to host Git repositories (repos). Public repos are free, private ones are still cheap.

Most open source projects are hosted and collaborated on here.

> If you're not on GitHub you don't exists.
-- Friendly developer

---

# How does it work?

1. Initialize a central repository
2. Clone the repo
3. Make changes
4. Commit changes
5. Push those changes to the central repo
6. ...
7. Profit!

---

# Create a new repo

![inline, 100%](https://help.github.com/assets/images/help/repository/repo-create.png)

---

# Clone the repo

```git clone https://github.com/jonasrosland/training-repo.git```

---

# Make changes

```cd training-repo```
```echo "Hello World" > yourname.txt```

---

# Commit changes

```git add yourname.txt```
```git commit -m "added yourname.txt to the repo"```

---

# Push changes

```git push```

---

# What happened?

---

# DENIED!

You're not allowed to push to this repo

So how can we collaborate?

Fork it!

---

# Fork a repo

![inline, 100%](https://help.github.com/assets/images/help/repository/fork_button.jpg)

---

# Clone _that_ repo instead of the original one

```git clone https://github.com/<yourname>/training-repo```

Repeat your changes, and try to push

What happens?

---

# Compare to the original

![inline, 100%](images/github_compare.png)

---

![inline, 100%](images/github_compare2.png)

---

# Create a pull request

![inline](images/github_create_pr.png)

---

![inline](images/github_pr.png)

---

## If a Pull Request is alright, it can then be merged

---

![inline](images/github_merge.png)

---

![inline](images/github_merge_successful.png)

---

# Branches

---

# Why use a branch?

Create a branch for every new feature or bugfix

Keeps the "master" clean and with only working code

You can then pull in fixes and features to the master when they're complete

And then create new releases such as v1.1 or v20150215 from master

---

# Releases are stable

Use releases to make it easy for the community to use stable code

![inline,75%](https://camo.githubusercontent.com/9f23f54df9e2f69047fb0f9f80b2e33c8339606f/68747470733a2f2f662e636c6f75642e6769746875622e636f6d2f6173736574732f32312f3733373136362f62643163623637652d653332392d313165322d393064312d3361656365653930373339662e6a7067)

---

# Create a new branch

```git branch awesome-feature```

![inline](images/github_new_branch.png)

---

# Switch to your branch

```git checkout new-feature```

---

# Make changes, commit, then push

```echo "Hello World again" > yourname.txt```

```git diff```

```git add yourname.txt```

```git commit -m "made some changes"```

```git push```

What happens?

---

# You need to set the upstream

 - This is where we should push the new changes to

 - It might be a totally different repo than the original

```git push --set-upstream origin new-feature```

Now go look at that branch up on GitHub

---

## You can now create a pull request from that branch!

---

A great cheat sheet:

http://www.clearvision-cm.com/wp-content/uploads/2014/08/Git-Cheat-Sheet_Clearvision.pdf

repository: brntbeer/training

repo_name: brntbeer/training