text:
# Plot Scan
`plot_scan` is a command-line tool to visualize Neato Botvac LDS scans
from a file, which can be found in the `lds_tools` subpackage.
It is meant to parse the output of the Botvac Command Line Interface (CLI)
and extract any LDS scans presented from the use of the `getldsscan` command.

For example, when running the command on the file [lds_scan.txt](example_outputs/lds_scan.txt)
```
$ plot_scan lds_scan.txt
```
It will produce the following output
![Single LDS scan image](example_outputs/lds_scan1.png)

Saving the output of the Botvac CLI after `getldsscan` is called is sufficient
and should not require any manual processing.
For example, when running the command on the file [lds_scan_dirty1.txt](example_outputs/lds_scan_dirty1.txt)
```
$ plot_scan lds_scan_dirty1.txt
```
It will still produce the LDS scan.
![Single LDS scan image from dirty.](example_outputs/lds_scan2.png)

# Multiple Scans
If the text file presented to `plot_scans` contains multiple scans,
it will present each scan sequentially. The scan found at the top of the file
is assumed to be the first scan, until the last scan found at the bottom of
the file.
`plot_scan` does not automatically replay each scan, but takes keyboard inputs
to advance the display of each scan.
  - 'd' key will go to the next scan.
  - 'a' key will go to the previous scan.

The scan index will be presented on the terminal.

gha_language: Python


text:
## Changelog
0.0.7
* Manual time input
* Time fast forward and reverse

0.0.6
* I forgot to add 0.0.6 changes...

0.0.5
* Heavy refactoring
* Added DSOs down to mag 6
* Stars and DSOs now drawn with symbol, indicating type for DSO and rough magnitude for stars
* Very simple search added, just searches names and moves to that location.  I don't want to go too nuts with this right now because I expect the dataset to change eventually and I don't want to rework search if the data structure changes.

0.0.4
* Current facing now displayed in info panel
* NSEW cardinal directions now appear in main window at ground level
* Constellation names displaying
* Constellation lines displaying
* Ground layer available, toggle with g.
* Cycle through label visibility with L.  Will show all stars with designation, only named stars or none.
* Adjusted displayed width to compensate for font ratio (this is pretty arbritrary without a way to actually read the terminal font, but I think it's better than trying to get the user to install a square font)
* Input new geographic location with (G)

0.0.3
* Help window added.
* User input and main program broken into threads to enable automatic timer.
* Timer thread added, default to 5 seconds.
* Currently selected object now stays selected when panning, zooming, filtering and as time progresses.  There might be some bugs here but nothing's jumped out yet.
* Time added to info bar, reflects time as shown in main window
* Help screen no longer hangs application.  Hacky fix that pauses the normal input thread and then resumes it.
* Viewer rewritten using a basic 3d engine.  No more flat map, now an actual perspective view allowing full view above and below the horizon.

0.0.2
* Scrolling enabled, moves 1 degree at a time
* Magnification enabled, 1 degree min, 180 max
* Info sidebar created, currently showing field of view in degrees and lat/lon.
* Refactored current settings like magnitide and current center info single settings object.
* No more prompt for a star to initially center on, goes right to zenith
* Can select stars, and get basic info in info panel
* Filter by magnitude with m and M.

repository: minstrel/mystars

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: minstrel/mystars


text:
---
lab:
    title: 'Lab: Create knowledge articles'
    module: 'Module 4: Knowledge Management'
---

Module 4: Knowledge Management
==============================

## Practice Lab 1 – Create knowledge articles

Scenario
--------

As a customer care coordinator at City Power & Light, you are responsible for
instructing the customer service team and providing them with troubleshooting
articles to support case resolution. You need to create a knowledge article
within Dynamics 365 for Customer Service. In this lab, you will create a
knowledge article, walk through the publishing process and then revise that
article.

Exercise 1 – Knowledge Management
---------------------------------

In this exercise, you will create, approve, publish, and revise an internal
Knowledge Article for missing parts.

### Task 1 – Create Internal Article

In this task, you will create an internal Knowledge Article for missing parts.

1.  Navigate to <wwllab006.crm.dynamics.

2.  Select **Customer Service Hub**.

5.  Click on the **Sitemap** button and select **Service**.  Select **Knowledge Articles** under the **Knowledge** section

6.  Click **+ New**.

7.  Enter *[your prefix ex. mollyc]+ Missing Parts* for **Title**, enter **missing, parts** for
    **Keywords** and click **Save**.

8.  Go to the **Content** area and make sure you have the **Designer** tab
    selected.

9.  Type *[your prefix ex. mollyc]+ Purpose & Scope*.

10. Click on the **Paragraph Format** selector and select **H2**. This option
    will only appear if your screen is fully expanded.

11. Hit the **\<Return\>** key to start a new line. The **Format Selector**
    should change back to **Normal**.

12. Type the paragraph below.

    Use procedure below to resolve Phone call Cases that are related to missing
    parts.

13. Hit the **\<Return\>** key to start a new line.

14. Click on the **Paragraph Format** selector and select **Heading 2**.

15. Type **Procedure**.

16. Hit the **\<Return\>** key to start a new line.

17. Go to the ribbon and click **Insert/Remove Numbered List**. This action will
    insert numbered list.

18. Provide the steps below.

    1.  Get Order Number for Customer.

    2.  Locate Order record.

    3.  Locate the product in question and open it.

    4.  Is the product the Customer received listed?

    5.  If yes, Send the Customer a replacement order and a return label.

    6.  If no, escalate Case.

19. Minimize the window. Click Save.

20. Go to the **Business Process Flow** and click on the **Author** stage.

21. Select **Default Subject** for **Article Subject**, check the **Mark for Review** checkbox, and click **Next Stage**.

### Task 2 – Approve and Publish Knowledge Article

In this task, you will assume the role of the Knowledge Article Approver and
Approve the Knowledge Article you created, and then publish it.

1.  Go to the **Business Process Flow** and click on the **Review** stage.

2.  Select **Approved** for **Review**.

3.  Click **OK**.

4.  Go to the **Business Process Flow** and click on the **Review** stage.

5.  Click **Next Stage**.

6.  Click on the **Publish** stage.

7.  Check the **Set Product Association** checkbox and click **Finish**.

8.  Go to the command bar and click **Publish**. YOu may need to click the ellipsis to see it.

9.  Select Now for Publish, Published for Published Status, and click Publish.
    Do NOT navigate away from this page.

### Task 3 – Revise Knowledge Article

In this task, you will change step 6 of the Knowledge Article you created from
Escalate Case to Assign to Manager, and then you will revise the Knowledge
Article.

1.  Make sure you still have the Knowledge Article you created opened.

2.  Click **Create Minor Version** from the command bar. You may need to click the ellipsis to see this

3.  Click **OK**.

4.  Go to the **Content** section.

5.  Replace step **6** of the **Procedure** from **If no, escalate Case** to
    **If no, assign to manager**.

6.  Click **Save**.

7.  Click **Approve**. You may need to click the ellipsis to see this

9.  Click **Publish**.

10. Select **Now** and click **Publish** again.

11. Click on the Sitemap and select Knowledge Articles.

12. You should find the new version of the **Missing Parts** article in the **My
    Active Articles** view but not the old version.

13. Change the view to **Archived Articles**. You should find the old version of
    the **Missing Parts** article in this view.

license: MIT


text:
# JIRA REST API PHP Client

[![SensioLabsInsight][sensiolabs-insight-image]][sensiolabs-insight-link]
[![Build Status][testing-image]][testing-link]
[![Coverage Status][coverage-image]][coverage-link]
[![Latest Stable Version][stable-image]][package-link]
[![Total Downloads][downloads-image]][package-link]
[![License][license-image]][license-link]

JIRA provides REST APIs that you can use to interact with JIRA programmatically.
This API client will help you interact with JIRA by REST API.

# License

MIT License

# JIRA REST API Reference

https://docs.atlassian.com/jira/REST/latest/

# Contributing
To create new endpoint - [create issue](https://github.com/madmis/jira-api/issues/new) or [create pull request](https://github.com/madmis/jira-api/compare)

# Install

    composer require madmis/jira-api 1.0.*

# Usage
```php
$api = new madmis\JiraApi\JiraApi('http://localhost:8080/', '/rest/api/2');

$auth = new<EMAIL_ADDRESS>'password');
$api->setAuthentication($auth);

$projectList = $api->project()->getProjects();

$project = $api->project()->getProject('MFTP');

$issue = $api->issue()->getIssue('MFTP-4');

// Issue result
array [
  'expand' => "renderedFields,names,schema,transitions,operations,editmeta,changelog"
  'id' => "10003"
  'self' => "http://localhost:8080/rest/api/2/issue/10003"
  'key' => "MFTP-4"
  'fields' => { ... }
]
```

###Create Issue

```php
$api = new madmis\JiraApi\JiraApi('http://localhost:8080/', '/rest/api/2');

$auth = new<EMAIL_ADDRESS>'password');
$api->setAuthentication($auth);

// without mapping
$result = $api->issue()->createIssue('PROJ', 'summary', 1, ['description' => 'description']);

// Issue result
array [
  'id' => "10105"
  'key' => "PROJ-9"
  'self' => "http://<IP_ADDRESS>:8080/rest/api/2/issue/10105"
]

// with mapping
$result = $api->issue()->createIssue('PROJ', 'summary', 1, ['description' => 'description'], true);

// Issue result
class madmis\JiraApi\Model\Issue {
  protected $self => "http://<IP_ADDRESS>:8080/rest/api/2/issue/10104"
  protected $id => 10104
  protected $key => "PROJ-8"
  protected $labels => []
  protected $description => NULL
  protected $summary => NULL
  protected $updated => NULL
  protected $created => NULL
  protected $issueType => NULL
  protected $project => NULL
  protected $creator => NULL
  protected $reporter => NULL
  protected $assignee => NULL
  protected $status => NULL
}
```

###Tempo worklog (Tempo timesheets)

```php
// This is default options, it is not required to set them.
// Set them only it Tempo REST API has another urn
$options = [
    'tempo_timesheets_urn' => '/rest/tempo-timesheets/3',
];
$api = new madmis\JiraApi\JiraApi('http://localhost:8080/', '/rest/api/2', $options);

$auth = new<EMAIL_ADDRESS>'password');
$api->setAuthentication($auth);

$issue = $api->issue()->getIssue('MFTP-4');

// Tempo worklog result
array [
  array [
    'timeSpentSeconds' => 28800
    'dateStarted' => "2015-08-29T00:00:00.000"
    'comment' => "2323"
    'self' => "http://<IP_ADDRESS>:8080/rest/tempo-timesheets/3/worklogs/10000"
    'id' => 10000
    'author' => [ ... ]
    'issue' => [ ... ]
    'worklogAttributes' => [ ... ]
  ]
]
```

###Mapping

```php
$issue = $api->issue()->getIssue('MFTP-4', '*all', '', true);

// Result
class madmis\JiraApi\Model\Issue {
    protected $self => "http://localhost:8080/rest/api/2/issue/10003"
    protected $id => 10003
    protected $key => "MFTP-4"
    protected $updated => class DateTime
    protected $issueType => class madmis\JiraApi\Model\IssueType
    protected $project => class madmis\JiraApi\Model\Project
    protected $creator => class madmis\JiraApi\Model\User
    protected $reporter => class madmis\JiraApi\Model\User
    protected $assignee => class madmis\JiraApi\Model\User
    protected $status => class madmis\JiraApi\Model\IssueStatus
  }
```

###Error handling
Each client request errors wrapped to custom exception **madmis\JiraApi\Exception\ClientException**

```php
class madmis\JiraApi\Exception\ClientException {
  private $request => class GuzzleHttp\Psr7\Request
  private $response => NULL
  protected $message => "cURL error 7: Failed to connect to <IP_ADDRESS> port 8080: Connection refused (see http://curl.haxx.se/libcurl/c/libcurl-errors.html)"
  ...
}
```

**ClientException** contains original **request object** and **response object** if response available

```php
class madmis\JiraApi\Exception\ClientException {
  private $request => class GuzzleHttp\Psr7\Request
  private $response => class GuzzleHttp\Psr7\Response {
    private $reasonPhrase => "Unauthorized"
    private $statusCode => 401
    ...
  }
  protected $message => "Client error: 401"
  ...
}
```

So, to handle errors use try/catch

```php
try {
    $issue = $api->issue()->getIssue('MFTP-4');
} catch (madmis\JiraApi\Exception\ClientException $ex) {
    // any actions (log error, send email, ...)
}
```

# Running the tests
To run the tests, you'll need to install [phpunit](https://phpunit.de/) and [behat](https://github.com/Behat/Behat).
Easiest way to do this is through composer.

    composer install

### Running Unit tests

    php vendor/bin/phpunit -c phpunit.xml.dist

### Running Behat tests

To run Behat test you'll need to install [Jira](https://www.atlassian.com/software/jira/download).
Create config file from example `behat.yml.dist`

    php vendor/bin/behat -c behat.yml

[testing-link]: https://travis-ci.org/madmis/jira-api
[testing-image]: https://travis-ci.org/madmis/jira-api.svg?branch=master

[sensiolabs-insight-link]: https://insight.sensiolabs.com/projects/7332bbe0-7ecf-4228-afdb-e599c60c9aa0
[sensiolabs-insight-image]: https://insight.sensiolabs.com/projects/7332bbe0-7ecf-4228-afdb-e599c60c9aa0/mini.png

[package-link]: https://packagist.org/packages/madmis/jira-api
[downloads-image]: https://poser.pugx.org/madmis/jira-api/downloads
[stable-image]: https://poser.pugx.org/madmis/jira-api/v/stable
[license-image]: https://poser.pugx.org/madmis/jira-api/license
[license-link]: https://packagist.org/packages/madmis/jira-api

[coverage-link]: https://coveralls.io/github/madmis/jira-api?branch=master
[coverage-image]: https://coveralls.io/repos/github/madmis/jira-api/badge.svg?branch=master

repository: madmis/jira-api

gha_language: PHP

repo_name: madmis/jira-api


text:
# Hello Classic

This repository contains the raw source code of the first snap using *classic confinement*.

## About classic confinement

Classic confinement is a new feature that is under development for snapd 2.19.
It allows snaps coming from trusted sources to execute both without the
security sandbox and without the `pivot_root` to the core snap (aka kind-of
chroot).

## Building and testing

Ensure that you have snapcraft version at least 2.24 (run `snapcraft --version`
to check). To build the snap just run `snapcraft`.

## Installation

Install this snap just as any regular snap. If built locally please use `snap
install --dangerous --classic hello-classic_*.snap`. Note the presence of
`--classic` switch. This switch tells snapd that you allow this snap to be
installed with classic confinement.

## Exploration

After you install the snap please inspect the file in
`/snap/hello-classic/current/hello-classic` with `ldd`. It is also useful to
use `snap run --shell hello-classic` and see what you can do from there and how
the classic environment looks like.

## Theory

This snap contains one dynamically linked C executable, `hello-classic`. The
executable uses the dynamic linker and runtime libraries from the core snap. It
is totally independent of the classic distribution with the exception that the
kernel and provided snapd need to be recent enough to support this construct.

Unlike regular snaps the classic snap has full access to the file system of the
classic distribution.

## Ideas

You can use classic snaps to package your shell, your toolchain, your brand new
tool or your clunky internal script that you've been sharing with your
colleagues.

repository: zyga/hello-classic

gha_language: Makefile

repo_name: zyga/hello-classic


text:
---
title: A misunderstanding about life expectancy

# Summary for listings and search engines
summary: A misunderstanding about life expectancy

# Link this post with a project
projects: []

# Date published
date: "2016-04-20T00:00:00Z"

# Date updated
lastmod: "2016-06-08T00:00:00Z"

# Is this an unpublished draft?
draft: false

# Show this page in the Featured widget?
featured: false

authors:
- admin

tags:
- Academic

categories:
- Epidemiology
---

Here I want to talk about a very common mistake when it comes to *life expectancy* and its interpretation. In one of my epidemiology courses, the lecturer showed the below figure.

![png](./Life_Exp.png)

I am sure you also see graphs like that not this particular one (I mean for Switzerland) but maybe similar. OK, we see a very clear trend that life expectancy increasing in the last century. It was even doubled, right? That's very nice. And we also see that there is clear difference between men and women but it is not my issue here.

I am more interested in the increase of the life expectancy. To understand it better first important question is, as always, why. In other words what is the possible *explanation*. And second question, what can we guess about the life expectancy of 2100 for example, so the *prediction*. My lecturer gave the answer for the first question: the remarkable achievement of *modern medicine*. And so by this logic, he said that the life expectancy probably may continue to increase as we had in the last century.

Now, let's consider not 1900 but long before, for instance think about our ancestors, hunter gatherers. What we expect is that they may have similar (or even low say 30?) life expectancy like 1900, right? So lets think from a hunter gatherer perspective and see this below Figure for this purpose.

![png](Foragers.png)

Our ancestors did not get it why they could not survive after 30. But the achievements of the medicine fully can explain it?

At this point, to understand better, we need to look at the precise definition of the life expectancy (from Wikipedia):

> The mean length of life of a hypothetical cohort (all individuals born in a given year) assumed to be exposed since birth until death of all their member to the mortality rate observed at a given year.

OK, the definition seems unnecessarily complicated, but important point is that life expectancy is just a mean. So it is one type of statistical measure. But to gain more insight about the data maybe it is better to look more than just mean values. Unfortunately, I don't have the real data, so lets just simulate some data for our purpose and plot it:

<img src="{{< blogdown/postref >}}index_files/figure-html/plot1-1.png" width="672" />

Now in the above Figure, you see all data points (the mean length of life bla bla bla *per person*) as well as the life expectancy as red crosses (or let's call it mean values). But the problem is that in reality data do not look like that Figure, but instead more look like the below Figure.

<img src="{{< blogdown/postref >}}index_files/figure-html/plot2-1.png" width="672" />

So lets compare those two Figures which are based on two different simulated datasets. Firstly the red crosses are exactly has the same values (monotonically increasing from a value close to 40 to a value close to 80). That implies mean values are the same. But in the second Figure, there are many data points very close to zero values. But the second set of data points of each given year (values which are far away to zero) seem to not increasing much. So what does that mean?. Those very small data points corresponding to children who died at very early ages (*infant mortality*). And as you can see, with decreasing of the infant mortality, the mean values are going away from zero even if the adult mortality stays constant.

 But once you reach the adulthood then it is not that low like 30. That's why even in the times when the life expectancy is 30, you can see many people of high ages like 60.

OK, I exaggerated a little bit to make the point, and of course the advancement of modern medicine (better medications etc.) is a very important explanation of the increase of life expectancy. But still I think considering only the mean values can be misleading since infant mortality has possibly more effect on the increase of life expectancy.

repository: gunhanb/guenhan

extension: markdown

repo_name: gunhanb/guenhan


text:
---
layout: docs
title: 'Understanding the basics'
---

## Creating Database vs opening existing

IndexedDB (and Dexie) has a built-in system for db installation and schema upgrades. Many people think they will have to check if database needs to be created and run different code depending on whether the database was installed on the client or not. This is not neeeded. Your dexie code can be declarative (you declare what tables and schemas you have in current and previously released versions and you let Dexie / indexedDB handle the situation where a database wasn't created yet, needs upgrade or is already on latest version).

IndexedDB is designed for handling database creation and upgrades through the `onupgradeneeded` event, and define the schema there. There is no native method for checking whether a database exists or not. Dexie adds a declarative schema syntax on top of that so that you don't need to subscribe to the `onupgradeneeded` event either.

## Declarative Schema
The database schema is declarative, not imperative.

```javascript
var db = new Dexie('dbname');
db.version(1).stores({
    friends: 'name, age'
});
db.open().then(function (db) {
    // Database opened successfully
}).catch (function (err) {
    // Error occurred
});
```

## Understanding the flow

### First time
First time a browser hits the appdb.js code the following happens:

1. Database is being created
2. If [on('populate')](/docs/Dexie/Dexie.on.populate.html) is triggered to populate ground data.
3. db.open() promise resolves.

### Second time

1. Database is just opened and promise resolves.

### Modify Schema

When you need to modify the schema of existing tables, you keep current schema but just add a new version instead.

```javascript
db.version(1).stores({
    friends: 'name, age'
});
db.version(2).stores({
    friends: 'name, age, firstName, lastName',
});
```

### Migrate Data

And if you need to migrate existing data, you add an upgrade function to the new version.

```javascript
db.version(1).stores({
    friends: 'name, age'
});
db.version(2).stores({
    friends: 'name, age, firstName, lastName',
    pets: 'name'
}).upgrade(tx => {
    return tx.friends.toCollection().modify(friend => {
        friend.firstName = friend.name.split(' ')[0];
        friend.lastName = friend.name.split(' ')[1];
    });
});
```

### Changing a few tables only
If you are just adding or changing a few tables, you do not need to repeat the schemas of all the old tables.

```javascript
db.version(2).stores({
    friends: 'name, age, firstName, lastName',
});
db.version(3).stores({
    pets: 'name' // Only need to specify pets, as friends should be same as for version 2.
});
```

### Deleting tables
Since it is not mandatory to repeat old tables, Dexie has to be explicitely informed about table deletion. This is done by specifying *null* as the table schema.

```javascript
db.version(1).stores({
    friends: 'name, age'
});
db.version(2).stores({
    friends: 'name, age, firstName, lastName',
});
db.version(3).stores({
    pets: 'name'
});
db.version(4).stores({
    pets: null // Will delete 'pets' table
});
```

## Conclusions

* You do never need to check whether the database need to be created. Your code is just declarative.
* Don't edit schemas. Add new versions instead.
* Keep previous versions as long as there are people out there that may have it installed.
* New versions only need to specify the tables that differs from previous version
* To delete a table, add a new version specifying the table as *null*.

*NOTE: In an upcoming Dexie version, you will no longer need to keep old versions unless they have upgraders associated, but for now (as of Dexie 2.0.0-beta.10), this is still the way to do it*

branch_name: refs/heads/gh-pages

gha_language: JavaScript


text:
# Trulioo SDK for Java #

## Version 1.0.3

### Introduction

Trulioo provides a collection of API methods to help you build business processes powered by the GlobalGateway Normalized API. The Normalized API is a loosely coupled API; fields may be added to our services and responses as the API evolves, and a client must be able to safely ignore fields and data that are not expected. The GlobalGateway Normalized API can help automate your business processes by performing the following tasks:

#### Identity Verification

Electronic identity verification (eIDV) was created specifically to help your business comply with Anti-Money Laundering (AML) and Know Your Customer (KYC) rules and has since evolved to support a diverse range of international electronic identity verification requirements.

#### Document Verification

ID Document Verification analyzes, verifies, and authenticates 3,500 different types of identity documents from nearly every country in the world. The combination of eIDV and ID Document Verification during the Customer Due Diligence check can assist your business in meeting your AML, KYC and Counter Terrorist Financing (CTF) compliance requirements.

#### Business Verification

Business Verification analyzes, verifies and provides data intelligence for business entities in 83 countries. During Customer Due Diligence, Business Verification assists clients to automate compliance workflows, reduce manual front-to- back office operations, take advantage of digital processes, decrease the risk of fraud, and allow staff to focus on key compliance considerations.

#### AML Watchlist

Global AML Watchlist helps your business comply with domestic and international AML, CTF and sanctions enforcement regulations. The watchlist covers sanction lists, law enforcements lists and governing regulatory bodies from around the world.
## Requirements

Building the API client library requires:
1. Java 1.7+
2. Maven/Gradle

## Installation

To install the API client library to your local Maven repository, simply execute:

```shell
mvn clean install
```

To deploy it to a remote Maven repository instead, configure the settings of the repository and execute:

```shell
mvn clean deploy
```

Refer to the [OSSRH Guide](http://central.sonatype.org/pages/ossrh-guide.html) for more information.

### Maven users

Add this dependency to your project's POM:

```xml
<dependency>
  <groupId>com.trulioo</groupId>
  <artifactId>normalizedapi</artifactId>
  <version>1.0.3</version>
  <scope>compile</scope>
</dependency>
```

### Gradle users

Add this dependency to your project's build file:

```groovy
compile "com.trulioo:normalizedapi:1.0.3"
```

### Others

At first generate the JAR by executing:

```shell
mvn clean package
```

Then manually install the following JARs:

* `target/normalizedapi-1.0.3.jar`
* `target/lib/*.jar`

## Getting Started

Please follow the [installation](#installation) instruction and execute the following Java code:

```java

import com.trulioo.normalizedapi.*;
import com.trulioo.normalizedapi.api.*;
import com.trulioo.normalizedapi.model.*;

//Set client here
ApiClient apiClient = new ApiClient();
apiClient.setUsername("-- USER NAME --");
apiClient.setPassword("-- PASSWORD --");

//ConnectionApi
ConnectionApi connectionClient = new ConnectionApi(apiClient);

//testAuthentication
String testResult = connectionClient.testAuthentication();
System.out.println(testResult);

//testAuthenticationAsync
connectionClient.testAuthenticationAsync(new ApiCallback<String>() {
	@Override
	public void onFailure(ApiException ae, int i, Map<String, List<String>> map) {
		Logger.getLogger(SdkJavaV1Sample.class.getName()).log(Level.SEVERE, null, ae);
	}

	@Override
	public void onSuccess(String t, int i, Map<String, List<String>> map) {
		System.out.println(t);
	}

	@Override
	public void onUploadProgress(long l, long l1, boolean bln) {
		//To change body of generated methods, choose Tools | Templates.
	}

	@Override
	public void onDownloadProgress(long l, long l1, boolean bln) {
		//To change body of generated methods, choose Tools | Templates.
	}
});

```

## Documentation for API Endpoints

All URIs are relative to *https://api.globaldatacompany.com*

Class | Method | HTTP request | Description
------------ | ------------- | ------------- | -------------
*BusinessApi* | [**getBusinessSearchResult**](docs/BusinessApi.md#getBusinessSearchResult) | **GET** /business/v1/search/transactionrecord/{id} | returns the a business search result.
*BusinessApi* | [**search**](docs/BusinessApi.md#search) | **POST** /business/v1/search | Calling this method will perform a business search.
*ConfigurationApi* | [**getConsents**](docs/ConfigurationApi.md#getConsents) | **GET** /configuration/v1/consents/{configurationName}/{countryCode} | This method retrieves the consents required for data sources currently configured in your account configuration.   The response for this method contains a collection of strings that Verify method's ConsentForDataSources field expects to perform a verification using those data sources.   A failure to provide an element from the string collection will lead to a 1005 service error.
*ConfigurationApi* | [**getCountryCodes**](docs/ConfigurationApi.md#getCountryCodes) | **GET** /configuration/v1/countrycodes/{configurationName} | This method retrieves all the countries that are available to perform a verification.
*ConfigurationApi* | [**getCountrySubdivisions**](docs/ConfigurationApi.md#getCountrySubdivisions) | **GET** /configuration/v1/countrysubdivisions/{countryCode} | Gets the provinces states or other subdivisions for a country, mostly matches ISO 3166-2
*ConfigurationApi* | [**getDatasources**](docs/ConfigurationApi.md#getDatasources) | **GET** /configuration/v1/datasources/{configurationName}/{countryCode} | Gets datasource groups configured for your product and country.
*ConfigurationApi* | [**getDetailedConsents**](docs/ConfigurationApi.md#getDetailedConsents) | **GET** /configuration/v1/detailedConsents/{configurationName}/{countryCode} | This method retrieves details about consents required for data sources currently configured in your account configuration.   The response for this method contains a collection of objects.  Each object contains the Name of the data source, Text outlining what the user is consenting to, and optionally a Url where the user can find more information about how their data will be used.    Failure to provide a Name from the object collection will lead to a 1005 service error.
*ConfigurationApi* | [**getDocumentTypes**](docs/ConfigurationApi.md#getDocumentTypes) | **GET** /configuration/v1/documentTypes/{countryCode} | Gets the document types available for a country.
*ConfigurationApi* | [**getFields**](docs/ConfigurationApi.md#getFields) | **GET** /configuration/v1/fields/{configurationName}/{countryCode} | Generates json schema for the API, the schema is dynamic based on the country and configuration you are using.  http://json-schema.org/documentation.html
*ConfigurationApi* | [**getRecommendedFields**](docs/ConfigurationApi.md#getRecommendedFields) | **GET** /configuration/v1/recommendedfields/{configurationName}/{countryCode} | Generates json schema for the API, the schema is dynamic based on the recommendedFields country and account you are using.  http://json-schema.org/documentation.html
*ConfigurationApi* | [**getTestEntities**](docs/ConfigurationApi.md#getTestEntities) | **GET** /configuration/v1/testentities/{configurationName}/{countryCode} | Gets the test entities configured for your product and country.
*ConnectionApi* | [**connectionAsyncCallbackUrl**](docs/ConnectionApi.md#connectionAsyncCallbackUrl) | **POST** /connection/v1/async-callback | If set, the transaction will run asynchronously and Trulioo will try to update the client with transaction state updates until completed. If callback is not desired but the client wants to initiate an asynchronous transaction, provide https://api.globaldatacompany.com/connection/v1/async-callback as the Callback URL.
*ConnectionApi* | [**sayHello**](docs/ConnectionApi.md#sayHello) | **GET** /connection/v1/sayhello/{name} | This method enables you to check if your system can connect to our system. You can even use a web browser to verify a connection to our system.
*ConnectionApi* | [**testAuthentication**](docs/ConnectionApi.md#testAuthentication) | **GET** /connection/v1/testauthentication | This method enables you to check if your credentials are valid. You will need to use basic authentication to ensure a successful response.
*VerificationsApi* | [**documentDownload**](docs/VerificationsApi.md#documentDownload) | **GET** /verifications/v1/documentdownload/{transactionRecordId}/{fieldName} | Download Document
*VerificationsApi* | [**getTransactionRecord**](docs/VerificationsApi.md#getTransactionRecord) | **GET** /verifications/v1/transactionrecord/{id} | This method is used to retrieve the request and results of a verification performed using the verify method.  The response for this method includes the same information as verify method's response, along with data present in the input fields of the verify request.
*VerificationsApi* | [**getTransactionRecordAddress**](docs/VerificationsApi.md#getTransactionRecordAddress) | **GET** /verifications/v1/transactionrecord/{id}/withaddress | Fetch the results of a verification with the TransactionRecordId for the transaction this will include additional information if your account  includes address cleansing.
*VerificationsApi* | [**getTransactionRecordVerbose**](docs/VerificationsApi.md#getTransactionRecordVerbose) | **GET** /verifications/v1/transactionrecord/{id}/verbose | Fetch the results of a verification with the TransactionRecordId for the transaction this will include additional information if your account  includes address cleansing and watchlist details.
*VerificationsApi* | [**getTransactionStatus**](docs/VerificationsApi.md#getTransactionStatus) | **GET** /verifications/v1/transaction/{id}/status | This method is used to retrieve the processing status of an asynchronous transaction. The response for this method includes the processing status of the verification, the TransactionID, the TransactionRecordID as well as whether the verification request has timed out.
*VerificationsApi* | [**verify**](docs/VerificationsApi.md#verify) | **POST** /verifications/v1/verify | Calling this method will perform a verification. If your account includes address cleansing set the CleansedAddress flag to get  additional address information in the result.  You can query configuration to get what fields are available to you in each each country.  It is also possible to get sample requests from the customer portal.

## Documentation for Models

 - [Address](docs/Address.md)
 - [AppendedField](docs/AppendedField.md)
 - [Business](docs/Business.md)
 - [BusinessRecord](docs/BusinessRecord.md)
 - [BusinessResult](docs/BusinessResult.md)
 - [BusinessSearchRequest](docs/BusinessSearchRequest.md)
 - [BusinessSearchRequestBusinessSearchModel](docs/BusinessSearchRequestBusinessSearchModel.md)
 - [BusinessSearchResponse](docs/BusinessSearchResponse.md)
 - [Communication](docs/Communication.md)
 - [Consent](docs/Consent.md)
 - [CountrySubdivision](docs/CountrySubdivision.md)
 - [DataField](docs/DataField.md)
 - [DataFields](docs/DataFields.md)
 - [DatasourceField](docs/DatasourceField.md)
 - [DatasourceResult](docs/DatasourceResult.md)
 - [Document](docs/Document.md)
 - [DriverLicence](docs/DriverLicence.md)
 - [Location](docs/Location.md)
 - [LocationAdditionalFields](docs/LocationAdditionalFields.md)
 - [NationalId](docs/NationalId.md)
 - [NormalizedDatasourceField](docs/NormalizedDatasourceField.md)
 - [NormalizedDatasourceGroupCountry](docs/NormalizedDatasourceGroupCountry.md)
 - [Passport](docs/Passport.md)
 - [PersonInfo](docs/PersonInfo.md)
 - [PersonInfoAdditionalFields](docs/PersonInfoAdditionalFields.md)
 - [Record](docs/Record.md)
 - [RecordRule](docs/RecordRule.md)
 - [Result](docs/Result.md)
 - [ServiceError](docs/ServiceError.md)
 - [TransactionStatus](docs/TransactionStatus.md)
 - [VerifyRequest](docs/VerifyRequest.md)
 - [VerifyResult](docs/VerifyResult.md)
 - [TransactionRecordResult](docs/TransactionRecordResult.md)

## Documentation for Authorization

Authentication schemes defined for the API:
### basic

- **Type**: HTTP basic authentication

## Recommendation

It's recommended to create an instance of `ApiClient` per thread in a multithreaded environment to avoid any potential issues.

### Changelog

The [CHANGELOG.md](https://github.com/Trulioo/sdk-java-v1/blob/master/CHANGELOG.md) file in the root of the repository contains a description of changes for each version of the SDK.

### Documentation and resources

If you need to know more:

* For more about the Trulioo REST API V1, see the [REST API Reference](https://developer.trulioo.com/v1.0/reference).

* For starter guides, product information and best practices see the [Documentation](https://developer.trulioo.com/docs).

* For more about Trulioo in general, see [Trulioo Website](https://www.trulioo.com/).

### Support

1. You will be granted support if you or your company are already covered under an existing maintenance/support agreement. Send an email to<EMAIL_ADDRESS>and include "Trulioo SDK for Java V1" in the subject line.

2. Trulioo will NOT provide support for the extension if the core library has been modified. We would also like to know why you modified the code please send feedback to<EMAIL_ADDRESS>
### Contact Us

You can reach via channels listed on [Trulioo website](https://www.trulioo.com/company/contact-us/)

## License

The Trulioo SDK for Java is licensed under the Apache License 2.0. Details about the license can be found in the LICENSE file. Copyright 2017 Trulioo Information Services Inc. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0. Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


text:
# How to Contribute to Aietes-js

## Reporting issues or requesting features
1. Describe what you expected to happen.
2. If possible, include a minimal, complete, and verifiable example to help us identify the issue. This also helps check that the issue is not with your own code.
3. Describe what actually happened. Include the full traceback if there was an exception.
4. More detailed pointers are included in the issue templates

## Pull Request Process
1. Create a branch with descriptive name, including whether it is a bugfix or a feature as well as the ticket number if applicable
2. Apply principles of Clean Code to ensure your change is readable and maintainable.
3. Ensure your change is fully tested.
4.
5. Update the README.md with relevant details of changes.
6. Update the sample project if necessary.
7. Create a pull request for review.
8. Squash your commits on merge.

### Code of conduct
Examples of behavior that contributes to creating a positive environment include:
* Using non-emotional and objective language
* Being respectful of differing viewpoints and experiences
* Gracefully accepting constructive criticism
* Focusing on what is best for the project
* Showing empathy and acting professional towards other contributors or community members

Examples of unacceptable behavior include:
* The use of sexualized language or imagery and unwelcome sexual attention or
  advances
* Trolling, insulting/derogatory comments, and personal or political attacks
* Publishing others' private information, such as a physical or electronic
  address, without explicit permission
* Other conduct which could reasonably be considered inappropriate in a
  professional setting

This Code of Conduct is adapted from the Contributor Covenant, version 1.4,
available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html

repository: dtobe/aietes-js

gha_license_id: MIT

repo_name: dtobe/aietes-js


text:
---
title: Promote an image using policies
description: Learn how to create a promotion policies that can automatically
  promote an image to production if it passes all tests and doesn't have
  vulnerabilities.
keywords: registry, promotion, pipeline
redirect_from:
  - /datacenter/dtr/2.5/guides/user/create-promotion-policies/
---

Docker Trusted Registry allows you to create image promotion pipelines based on
policies.

In this example we'll create an image promotion pipeline such that:

1. Developers iterate and push their builds to the `dev/website` repository.
2. When the team creates a stable build, they make sure their image is tagged
with `-stable`.
3. When a stable build is pushed to the `dev/website` repository, it will
automatically be promoted to `qa/website` so that the QA team can start testing.

With this promotion policy, the development team doesn't need access to the
QA repositories, and the QA team doesn't need access to the development
repositories.

![promotion example](../../images/internal-promotion-1.svg)

## Configure your repository

Once you've [created the repository](../manage-images/index.md), navigate to
the **DTR web UI**, go to the **repository details** page, and choose
**Promotions**.

![repository policies](../../images/internal-promotion-2.png){: .with-border}

Click **New promotion policy**, and define the criteria that an image needs
to meet to be promoted.

DTR allows defining the following criteria:

| Name            | Description                                        |
|:----------------|:---------------------------------------------------|
| Tag name        | If the tag name contains                           |
| Component name  | If the image has a given component                 |
| Vulnerabilities | If the image has vulnerabilities                   |
| License         | If the image uses an intellectual property license |

Now you need to choose what happens to an image that meets all the criteria.

Select the **organization** and **repository** where the image is going to be
pushed. You can choose to keep the image tag, or transform the tag into
something more meaningful in the destination repository, by using a tag template.

In this example, if an image in the `dev/website` is tagged with a word that
ends in "stable", DTR will automatically push that image to the `qa/website`
repository. In the destination repository the image will be tagged with the
timestamp of when the image was promoted.

![repository with policies](../../images/internal-promotion-3.png){: .with-border}

Everything is set up! Once the development team pushes an image that complies
with the policy, it automatically gets promoted.

![tag promoted](../../images/internal-promotion-4.png){: .with-border}

## Where to go next

* [Mirror images to another registry](push-mirror.md)


text:
# Development-strategy

## Homepage

### `type: html` (Home)

- Left part

  - Navigation bar
    - [ ] Image on the top - img
    - [ ] links for the 4 pages

- Right part
  - [ ] Profile Picture - img
  - [ ] Name as Title - h2
  - [ ] Small description - h4

### `type: css` (Home)

- Navigation bar

  - [ ] Background color : DDFBF0
  - [ ] text color black
  - [ ] text color changes to red on selection
  - [ ] Background color BFFBFB on selection
- Name and Description

  - [ ] Background color : BFFBFB
  - [ ] Color Black
  - [ ] Font
  - [ ] Font size

## About Page

### `type: html` (About)

- Left part

  - Navigation bar
    - [ ] Image on the top - img
    - [ ] links for the 4 pages

- Right part - div
  - [ ] Title - h2
  - [ ] Description- p

### `type: css` (About)

- Navigation bar

  - [ ] Background color : DDFBF0
  - [ ] text color black
  - [ ] text color red on selection
  - [ ] Background color BFFBFB on selection

- Title and Description
  - [ ] Background color : BFFBFB
  - [ ] Title-Bold with text color black
  - [ ] Description- Regular text with color black
  - [ ] Left Aligned

## Resume Page

### `type: html` (Resume)

- Left part

  - Navigation bar
    - [ ] Image on the top - img
    - [ ] links for the 4 pages

- Right part
  - Education - div
    - [ ] Title - h2
    - [ ] Description - p
  - -Experience - div
    - [ ] Title - h2
    - [ ] Description - p
  - Link -
    - [ ] link to view CV - a

### `type: css` (Resume)

- Navigation bar

  - [ ] Background color : DDFBF0
  - [ ] text color black
  - [ ] text color changes to red on selection
  - [ ] Background color BFFBFB on selection

- Education and Experience
  - [ ] Background color : BFFBFB
  - [ ] div color : B3D8FB
  - [ ] Text color Black
  - [ ] Font
  - [ ] Font size
  - [ ] Title - center aligned
  - [ ] Description - left aligned
- Navigation link for CV
  - [ ] Text color: FD0D1B
  - [ ] Underlined

## Contact Page

### `type: html` (Contact)

- Left part

  - Navigation bar
    - [ ] Image on the top - img
    - [ ] links for the 4 pages

- Right part - div
  - [ ] Image of contact pic - img
  - [ ] Title- h2
  - [ ] Links to 3 social media - a

### `type: css` (Contact)

- Navigation bar

  - [ ] Background color : DDFBF0
  - [ ] text color black
  - [ ] text color red on selection
  - [ ] Background color BFFBFB on selection

- Title and Description
  - [ ] Background color : BFFBFB
  - [ ] Title-Bold with text color black
  - [ ] Links- semi bold, color:F81C36, underlined
  - [ ] Center aligned

branch_name: refs/heads/main


text:
Javascript implementation of Weng-Lin Rating, using Bradley Terry model as described at [https://jmlr.csail.mit.edu/papers/volume12/weng11a/weng11a.pdf](https://jmlr.csail.mit.edu/papers/volume12/weng11a/weng11a.pdf)

## Installation

Add `wenglin` to your list of dependencies in `package.json`:

```bash
npm install --save wenglin
```

## Importing wenglin module

Use CommonJS's `require`

```js
const {
  Rater,
  Team,
  Player
} = require('wenglin');
```

## Quick example

```js
const rater = Rater();
const WINNER = 1;
const LOSER = 0;

const team_1 = new Team({players: [new Player()], score: WINNER});
const team_2 = new Team({players: [new Player()], score: LOSER});

const result = rater(team_1, team_2)
```

## Modules

Player skill is represented by two parameters: mu and sigma
Mu is the actual skill of the player and sigma is its standard deviation.
Default values for mu and sigma are 25. and 25 / 3.

**Rater** is the main rating processor. It is initialized with BETA (sigma / 2) parameter by default so it can me omitted.

```js
const rater = new Rater();
const rater = new Rater(BETA);
```

Once rater is initialized, it can be invoked with all teams as separated arguments:

```js
rater(team_1, team_2, team_3, ...);
```

**Team**: Team represents a set of players, each with its skill data and a score. Score scale does not matter. It is compared between teams pairs and considered win, draw or loss.

```js
const team_1 = new Team({players: [player_1, player_2, ...], score: 0});
const team_1 = new Team({players: [player_x, player_y, ...], score: 1});
```

**Player**: This class stores a player's skill, mu and sigma.
Player class is initialized with default mu and sigma but can also be overwritten.

```js
> const player = new Player();
> const player = new Player({mu: 25, sigma: 25 / 3,});
```

Player skill can be obtained calling its **skill** method
```js
> const player = new Player({mu: 25, sigma: 25 / 3, ref: my_db_player});
> player.skill()
{ mu: 25, sigma_sq: 69.44444444444446, sigma: 8.333333333333334 }
```

Player can also store a reference to an object of your choice to keep track of players in your implementation and ease its usage after Rater results are returned.

```js
> const my_db_player = {id: 'Player id'};
> const player = new Player({mu: 25, sigma: 25 / 3, ref: my_db_player});
> player.ref();
{ id: 'Player id' }
```

## Full usage example
Following example represents a match between tree teams of two players each.
Team 1 loses the match and teams 2 and 3 win with a draw.
```js
> const {
  Rater,
  Team,
  Player
} = require('wenglin');
> const team_1 = new Team({players: [new Player(), new Player()], score: 60});
> const team_2 = new Team({players: [new Player(), new Player()], score: 80});
> const team_3 = new Team({players: [new Player(), new Player()], score: 80});
> const BETA = 4.16;
> Rater(BETA)(team_1, team_2, team_3);

[
  Player {  _mu: 21.071628993408070, _sigma: 8.018753738744802, _sigma_sq: 64.30041152263375, _ref: undefined},
  Player {  _mu: 21.071628993408070, _sigma: 8.018753738744802, _sigma_sq: 64.30041152263375, _ref: undefined},
  Player {  _mu: 26.964185503295965, _sigma: 8.018753738744802, _sigma_sq: 64.30041152263375, _ref: undefined},
  Player {  _mu: 26.964185503295965, _sigma: 8.018753738744802, _sigma_sq: 64.30041152263375, _ref: undefined},
  Player {  _mu: 26.964185503295965, _sigma: 8.018753738744802, _sigma_sq: 64.30041152263375, _ref: undefined},
  Player {  _mu: 26.964185503295965, _sigma: 8.018753738744802, _sigma_sq: 64.30041152263375, _ref: undefined}
]
```

## Results

Rater output is an array of Player objects with the new rating and in the same input order. Original players are kept intact. After results are returned by rater, you can iterate over result items to obtain each reference and data at your side.

```js
> const BETA = 4;
> const result = Rater(BETA)(team_1, team_2, ...);
> player_1_skill = result.map(it => it.skill())
[
 {mu: 23.035814496704035, sigma: 8.17755635771097, sigma_sq: 66.8724279835391},
 {mu: 23.035814496704035, sigma: 8.17755635771097, sigma_sq: 66.8724279835391},
 {mu: 26.964185503295965, sigma: 8.17755635771097, sigma_sq: 66.8724279835391},
 {mu: 26.964185503295965, sigma: 8.17755635771097, sigma_sq: 66.8724279835391}
]
```


text:
# Change Log

## [1.0.0](https://github.com/xmartlabs/BuildSlackNotifier/releases/tag/1.0.0)
<!-- Released on 2017-03-08. -->

* This is the initial version.

[xmartlabs]: https://xmartlabs.com

repository: xmartlabs/BuildSlackNotifier

repo_name: xmartlabs/BuildSlackNotifier


text:
![alt text](https://github.com/hxtree/LivingMarkup/raw/master/assets/images/logo/434x100.jpg "LivingMarkup")
# Welcome to LivingMarkup Documentation

***LivingMarkup is an PHP implementation of a LHTML5 parser.*** It is a powerful and flexible way to build dynamic web pages.

## Quick Start
Get an instance of LivingMarkup up and running in less than 5 minutes.

Install the LivingMarkup Package
```shell script
composer require hxtree/livingmarkup
```

You're done! Take the rest of the time to read our docs.

For information on:

- The LHTML5 standard see the official spec [LHTML5](https://github.com/hxtree/lhtml5).
- Customizing LivingMarkup see [configuration](configuration.md) and [modules](modules.md).
- For detail explanation of this package's design see [classes](classes.md).


text:
# ocd - OpenShift for developers

`ocd` is command line tool designed for engineers working with OpenShift

This is a proof of concept and not meant to be used for 'real' work.

## Installation

To get started clone the git repo and source the entrypoint.sh script

```
$ git clone https://github.com/openshift-evangelists/ocd.git
$ source ocd/entrypoint.sh
```

## Requirements

Most of the commands require just `oc` and `bash`, though, some have external dependencies

### ocd link

Requires also

* [`jq`](https://stedolan.github.io/jq/)
* `sed`
* `awk`
* `base64`

## Help

### ocd app [name]

Creates new application context.

`name` is mandatory.

Will create project `name` if not project currently selected.

### ocd create [type] [name] [path]

Deploy new thing of type `type` and name it `name`.

`type` is mandatory. `name` defaults to `type` when no specified. `path` is manadatory for s2i apps.

`oc create mysql` is equivalent to `oc create mysql mysql`, will create new deployment from the `mysql` temaplate with name `mysql`.

`oc create php php <url>` will create new deployment using `php` from source code `<url>`.

### ocd deploy [name] [path]

Triggers new build.

`name` is mandatory.

`path` is mandatory for `--from-dir` builds.

### ocd sync [name] [path]

Start rsync to the pod. Will take first running pod for deployment `name`.

`name` is mandatory. `path` defaults to `.`.

### ocd link [name] [target]

Expects to find secret with name `name`, create e.g. my MySQL template, and copies the values as ENV to `target`.

`name` and `target` are mandatory.

### ocd storage add [type] [size] [path] [name]

Adds new persistent `local or shared` storage of `size` to deployment `name` mounted at `path`.

`type` is mandatory and is either `shared` or `local`. `size`, `path` and `name` are mandatory.

### ocd url add [name]

Create route for deployment `name`.

`name` is mandatory.

### ocd scale [count] [name]

Scale deployment `name` to `count` pods.

`name` and `count` are mandatory.

### ocd destroy [name]

Undeploy deployment `name`.

`name` is mandatory.

### ocd wipe

Delete all deployments in current application context.

### ocd exit

Exit the application context.

## How to

After installation the `ocd` command is available to use.

## License

`ocd` is released under the MIT License.

repository: openshift-evangelists/ocd

repo_name: openshift-evangelists/ocd


text:
# pablo
Card game

## Human-facing Options
* Number of platers: 2-6
* Number of cards per player: 4 or 6 or 8 or 2
* Skill level: Easy, Medium, Hard, Very Hard.
*

## Internal Options
* Does caller have advantage in a tie?
* How long does computer or player have to flip a card?
* How long until computer pulls next card?
*

repository: dphochman/pablo

gha_language: TypeScript

repo_name: dphochman/pablo


text:
We are delighted to present version v1.25.1 of Contour, our layer 7 HTTP reverse proxy for Kubernetes clusters.

- [All Changes](#all-changes)
- [Installing/Upgrading](#installing-and-upgrading)
- [Compatible Kubernetes Versions](#compatible-kubernetes-versions)

# All Changes
- Update to Envoy v1.26.4. See the [Envoy release notes](https://www.envoyproxy.io/docs/envoy/v1.26.4/version_history/v1.26/v1.26.4) for more information about the content of the release.
- Update to Go v1.20.6. See the [Go release notes](https://go.dev/doc/devel/release#go1.20.minor) for more information.
- Failure to automatically set GOMAXPROCS using the [automaxprocs](https://github.com/uber-go/automaxprocs) library is no longer fatal. Contour will now simply log the error and continue with the automatic GOMAXPROCS detection ignored.

# Installing and Upgrading

For a fresh install of Contour, consult the [getting started documentation](https://projectcontour.io/getting-started/).

To upgrade an existing Contour installation, please consult the [upgrade documentation](https://projectcontour.io/resources/upgrading/).

# Compatible Kubernetes Versions

Contour v1.25.1 is tested against Kubernetes 1.25 through 1.27.

 We would love to know!
If you're using Contour and want to add your organization to our adopters list, please visit this [page](https://github.com/projectcontour/contour/blob/master/ADOPTERS.md). If you prefer to keep your organization name anonymous but still give us feedback into your usage and scenarios for Contour, please post on this [GitHub thread](https://github.com/projectcontour/contour/issues/1269).

repository: projectcontour/contour

gha_language: Go

repo_name: projectcontour/contour


text:
# The sample repository (on the embedded-login branch) (01-Embedded-Login)
https://github.com/auth0-samples/auth0-react-samples.git

# Info for setting up the additional sign up fields
https://github.com/auth0/lock#additional-sign-up-fields
1) Need to extend the options to include the fields that you want the user to have to fill out
2) You should be able to see these fields on the form and in the management form (https://manage.auth0.com/#/users) for each user

#Info for defining custom claims to be returned
https://auth0.com/docs/api-auth/tutorials/adoption/scope-custom-claims
1) You'll need to add a custom rule (https://manage.auth0.com/#/rules)
2) Example Rule:
function (user, context, callback) {
  var namespace = 'https://onsched.com/';
  context.idToken[namespace + 'firstname'] = user.user_metadata.firstname;
  context.idToken[namespace + 'lastname'] = user.user_metadata.lastname;
  context.idToken[namespace + 'skypename'] = user.user_metadata.skypename;
  callback(null, user, context);
}

After those steps you should be able to receive the additional fields in a request to lock.getUserInfo

repository: Onsched/APISamples

repo_name: Onsched/APISamples


text:
darkWorm Coin Source
=====================================

[![Build Status](https://travis-ci.org/darkWormcoin-project/darkWormcoin.svg?branch=master)](https://travis-ci.org/darkWormcoin-project/darkWormcoin)

## PlaceHolder for Official darkWorm website ##

What is darkWorm?
----------------

More to come...so mysterious.

License (if you care about that shit)
-------

darkWorm is released under the terms of the MIT license. See [COPYING](COPYING) for more
information or see https://opensource.org/licenses/MIT.

Development Process (I am the development process)
-------------------

more to come, or maybe not. #staywoke #darkWorm

repository: DivisionStreetDevs/darkWormCoin-master

repo_name: DivisionStreetDevs/darkWormCoin-master


text:
#thinglator-driver-aeotec-door-window-sensor

Allows the Thinglator platform to Aeotec Door / Window sensors on your zwave network.

## Requirements

* node.js
* Thinglator - https://github.com/richardwillars/thinglator

- Thinglator zwave interface

## Installation for usage

Navigate to the root of your Thinglator installation and run:

> yarn add thinglator-driver-aeotec-door-window-sensor

> yarn dev

# Installation for development

Navigate to the root of the thinglator-driver-aeotec-door-window-sensor project and run:

> yarn install

> yarn link

Navigate to the root of your Thinglator installation and run:

> yarn add thinglator-driver-aeotec-door-window-sensor

Go to the thinglator project and run:

> yarn link thinglator-driver-aeotec-door-window-sensor

This will point thinglator/node_modules/thinglator-driver-aeotec-door-window-sensor to the directory where you just installed thinglator-driver-aeotec-door-window-sensor. This makes it easier for development and testing of the module.

> yarn dev

## Test

> yarn test
> or
> yarn test:watch


text:
# Phlomoides dentosa (Franch.) Kamelin & Makhm. SPECIES

#### Status
ACCEPTED

#### According to
International Plant Names Index

#### Published in
null

#### Original name
Phlomis dentosa Franch.

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
# linprofile

Generate a profile for a linux system.
The goal is to be able to compare system profiles in a meaningful way.

This project has been moved to : https://bitbucket.org/matthewlinton/linprofile

## Install

* Checkout: `git clone https://github.com/matthewlinton/linprofile.git`
* Change into the linconfig directory `cd linprofile`
* run `make` to build the binary tools
* run `systemprofile.sh` to generate a profile of your system

By default, the results of _linprofile_ are stored in `${HOME}/systemprofile`

## Features

TODO : describe output

## Misc Goals

linprofile should be able to run on any linux system. This means that it is necessary to forgo using more usefull tools that may not be present on some systems. This also means keeping binaries very basic, and file sizes to a minimum.

repository: matthewlinton/linprofile

repo_name: matthewlinton/linprofile


text:
# Java Language Definition for Panic Nova

This is a simple Java Language Definition of Panic's new Nova Editor. It provides basic
highlighting of reserved words, package and class names, primitives, and a few other
things.

Pull requests welcome!

repository: farmdawgnation/nova-java-language

repo_name: farmdawgnation/nova-java-language


text:
# go-json-talk
Presentation on JSON parsing for Denver Gophers

This slide deck was made using [present](https://godoc.org/golang.org/x/tools/present)

    present advanced_json_strategies.slide

- aodin, 2015

repository: cjqian/go-json-talk

repo_name: cjqian/go-json-talk


text:
# ETX_Firmeware
The BLE based Transmitter project of EVRS

The Electronic Voting Response System (EVRS) is our capstone project in the UoM. It contains multiple transmitters (ETX) based on customized PCB and CC2650MODA, a base station (EBS) using CC2650 LaunchXL, a basestation controller (EBC) based on Raspberry Zero W and a PC client software (EPC) based on Java.

The wireless communication protocol would be Bluetooth LE.

Device
	Custmized device using CC2650MODA module
Environment
	CodeComposerStudio 8.0.0
	Compiler TI v16.9.4.LTS
	tirtos_cc13xx_cc26xx_2_21_01_08
	ble_sdk_2_02_02_25
	xdctools_3_32_00_06

gha_language: C


text:
[<<< Previous question <<<](0426.md)   Question ID#0427.md   [>>> Next question >>>](0428.md)
---

One way to format currencies in PHP is to use the built-in money_format() function. Before using it you must set the locale for the type of currency you're trying to format. What is the output of the following PHP script? The currency name for en_US is USD and uses $ as the currency symbol. Additionally, there are 100 cents to the dollar.

```php
setlocale(LC_MONETARY, 'en_US');
$amt = 100;
echo money_format('%.2n', $amt);
```

- [ ] A) $100.00
- [ ] B) USD100.0
- [ ] C) $1.00
- [ ] D) USD $100

Answer

  Answer: A

repository: alceanicu/zce

repo_name: alceanicu/zce


text:
+++
title = "Setup Grafana for High availability"
type = "docs"
keywords = ["grafana", "tutorials", "HA", "high availability"]
[menu.docs]
parent = "tutorials"
weight = 10
+++

# How to setup Grafana for high availability

> Alerting does not support high availability yet.

Setting up Grafana for high availability is fairly simple. It comes down to two things:

  * Use a shared database for multiple grafana instances.
  * Consider how user sessions are stored.

## Configure multiple servers to use the same database

First you need to do is to setup mysql or postgres on another server and configure Grafana to use that database.
You can find the configuration for doing that in the [[database]]({{< relref "configuration.md" >}}#database) section in the grafana config.
Grafana will now persist all long term data in the database.
It also worth considering how to setup the database for high availability but thats outside the scope of this guide.

## User sessions

The second thing to consider is how to deal with user sessions and how to balance the load between servers.
By default Grafana stores user sessions on disk which works fine if you use `sticky sessions` in your load balancer.
Grafana also supports storing the session data in the database, redis or memcache which makes it possible to use round robin in your load balancer.
If you use mysql/postgres for session storage you first need a table to store the session data in. More details about that in [[sessions]]({{< relref "configuration.md" >}}#session)

For Grafana itself it doesn't really matter if you store your sessions on disk or database/redis/memcache.
But we suggest that you store the session in redis/memcache since it makes it easier to add/remote instances from the group.

## Alerting

Currently alerting supports a limited form of high availability. Since v4.2.0 of Grafana, alert notifications are deduped when running multiple servers. This means all alerts are executed on every server but no duplicate alert notifications are sent due to the deduping logic. Proper load balancing of alerts will be introduced in the future.

repository: HediDlp/grafana

repo_name: HediDlp/grafana


text:
---
title: Area and Area Stacked
description: In this video, see how to add Area and Area Stacked visualizations to your project in Analysis Workspace, and learn a few tips to help customize the visualizations for your needs.
feature: Visualizations
role: User
level: Beginner
thumbnail: 334261.jpg
kt: 8113
exl-id: d2d1ff79-0fcc-4de5-872d-8547ed48cf98
---
# Area and Area Stacked

In this video, see how to add Area and Area Stacked visualizations to your project in Analysis Workspace, and learn a few tips to help customize the visualizations for your needs.

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

For more information, please visit the [documentation](https://experienceleague.adobe.com/docs/analytics/analyze/analysis-workspace/visualizations/area.html?lang=en#)


text:
# Usage

## Create your Adapter

In order to make an http request, you need to create an adapter.

### cURL

``` php
use Widop\HttpAdapter\CurlHttpAdapter;

$curlHttpAdapter = new CurlHttpAdapter();
```

### Stream

``` php
use Widop\HttpAdapter\StreamHttpAdapter;

$streamHttpAdapter = new StreamHttpAdapter();
```

### Buzz

``` php
use Widop\HttpAdapter\BuzzHttpAdapter;

$buzzHttpAdapter = new BuzzHttpAdapter();
```

or

``` php
use Buzz\Browser;
use Widop\HttpAdapter\BuzzHttpAdapter;

$browser = new Browser();
$buzzHttpAdapter = new BuzzHttpAdapter($browser);
```

### Guzzle

``` php
use Widop\HttpAdapter\GuzzleHttpAdapter;

$guzzleHttpAdapter = new GuzzleHttpAdapter();
```

or

``` php
use Guzzle\Http\Client;
use Widop\HttpAdapter\GuzzleHttpAdapter;

$client = new Client();
$guzzleHttpAdapter = new GuzzleHttpAdapter($client);
```

## Zend

``` php
use Widop\HttpAdapter\ZendHttpAdapter;

$zendHttpAdapter = new ZendHttpAdapter();
```

or

``` php
use Widop\HttpAdapter\ZendHttpAdapter;
use Zend\Http\Client;

$client = new Client();
$zendHttpAdapter = new ZendHttpAdapter($client);
```

## Make a GET request

Each adapter allows you to make a GET request:

``` php
$response = $httpAdapter->getContent($url);
```

If you want to pass custom headers, you can use the second argument:

``` php
$response = $httpAdapter->getContent($url, $headers);
```

## Make a POST request

Each adapter allows you to make a POST request:

``` php
$response = $httpAdapter->postContent($url);
```

If you want to pass custom headers, you can use the second argument:

``` php
$response = $httpAdapter->postContent($url, $headers);
```

If you want to pass POST datas, you can use the third argument:

``` php
$response = $httpAdapter->postContent($url, $headers, $data);
```

If you want to pass POST files, you can use the fourth argument:

``` php
$response = $httpAdapter->postContent($url, $headers, $data, $files);
```

## Inspect the response

All http adapter methods return a `Widop\HttpAdapter\HttpResponse` which wraps the base URL, the http headers, the
body and the effective URL.

``` php
$url = $response->getUrl();
$headers = $response->getHeaders();
$header = $reponse->getHeader('Date');
$body = $response->getBody();
$effectiveUrl = $response->getEffectiveUrl();
```

Be aware that the effective URL is supported by most of the adapters except Buzz and Zend ones...

repository: tacone/http-adapter

repo_name: tacone/http-adapter


text:
---
layout: post
title:      "Final Project for Flatiron - React/Redux : Adventure Challenge"
date:       2020-03-15 17:52:32 -0400
permalink:  final_project_for_flatiron_-_react_redux
---

Four weeks into my React/Redux project and it's finally done! It felt a lot longer like every other project. They always start as a struggle that later ends with me gaining a lot of useful knowledge and experience.

I got the concept of my app from a book that I received as a gift from my husband for our anniversary. The book is made of random date challenges that a couple has to commit to before scratching off the challenge and finding out what it is. Then once the couple completes the challenge they can add photos inside of the book for memories. I used the same concept for my app, but in digital form.

## Rails API Backend
I built this App with React/Redux Frontend and Rails API Backend.
In order to connect the backend with frontend, I needed to install `gem 'rack-cors'`. Rack::Cors provides support for Cross-Origin Resource Sharing (CORS) for Rack compatible web applications. The CORS spec allows web applications to make cross domain AJAX calls without using workarounds such as JSONP.

```
Rails.application.config.middleware.insert_before 0, Rack::Cors do
    allow do
      origins 'localhost:3000'
      resource '*',
        headers: :any,
        methods: [:get, :post, :put, :patch, :delete, :options, :head],
        credentials: true
    end
  end
  Rails.application.config.action_controller.forgery_protection_origin_check = false
```

So, this cors.rb file in the config folder allows the frontend to access `localhost:3000` and communicate with the backend. I have 4 models and some nested routes associated with the models relationship. There's basic CRUD actions in the controller so a user has the option to signup, login or logout.

```
class Api::V1::SessionsController < ApplicationController

    def auth
        render json: {csrf_auth_token: form_authenticity_token}
    end

    def create
        @user = User.find_by(username: params[:user][:username])
        if @user && @user.authenticate(params[:user][:password])
            session[:user_id] = @user.id
            render json: @user, only: [:id, :username], status: 200
        else
            render json: {error: "Unable to login, try again."}, status: 400
        end
    end

    def destroy
        session.delete(:user_id)
        render json: {status: 200}
    end
end
```

Because of setting up the current user in the backend and rendering to the frontend when needed, the user is allowed to scratch(default value of scratch:false changes to true) the adventure and add the evidence.

```
def current_user
        @user = User.find_by(id: session[:user_id])
        if @user
            render json: @user, except: [:password_digest, :created_at, :updated_at], status: 200
        end
end
```

## React/Redux Frontend
React is a JavaScript library created by Facebook. When I first started learning it was a lot of fun right away and much easier than vanilla JavaScript. Using JSX is a lot more efficient because I do not have to code as much.

What is JSX then? JSX is an XML/HTML-like syntax used by React that extends ECMAScript so that XML/HTML-like text can co-exist with JavaScript/React code. The easy wayt to explain this is that JSX allows us to write HTML elements in JavaScript and place them in the DOM without any createElement()  and/or appendChild() methods. Basically, it combines Javascript code and HTML like syntax into a single file.

Here are the one of the components.

```
import React from 'react'
import { withRouter } from 'react-router-dom'

class Home extends React.Component {

    componentDidMount() {
        this.props.get_token()
        this.props.setCurrentUser()
    }

    deleteHandler = () => {
        this.props.logoutUser(this.props.token)
        console.log("Logged out")
        this.props.history.push("/logout")
    }

    render() {
        return (
            <div>
                <h1 id="home-top">Welcome to </h1>
                <h3 id="home-middle">the</h3>
                <h1 id="home-bottom">Adventure Challenge</h1>
            </div>
        )
    }
}

export default withRouter(Home)
```

React components implement a render() method that takes input data and returns what to display.
Components are independent and reusable bits of code. It has properties called `props` and parent component passes it down to its child component just like arguments. In my application, App.js is the very top parent component of all. It passes down `user`, `token` and `setCurrentUser` props to most of the components so they can access to those props.

```
import React from 'react'
import './App.css'
import { BrowserRouter as Router, Switch, Route } from 'react-router-dom'
import NavBar from './components/NavBar'

import AdventuresContainer from './containers/AdventuresContainer'
import EvidenceContainer from './containers/EvidenceContainer'
import AdventureEvidence from './components/evidences/AdventureEvidence'
import Home from './components/Home'
import LoginContainer from './containers/LoginContainer'
import SignupContainer from './containers/SignupContainer'
import User from './components/users/User'
import Logout from './components/Logout'
import { getToken } from './actions/auth'
import { signup, login, logout, setCurrentUser } from './actions/user'
import { connect } from 'react-redux'
import UserContainer from './containers/UserContainer'

class App extends React.Component {

componentDidMount() {
    this.props.get_token()
    this.props.setCurrentUser()
  }

render() {
  return (
    <Router>
      <div className="App">
        <NavBar user={this.props.user}/>
        <Switch>
          <Route exact path="/adventures">
            <AdventuresContainer
            token={this.props.token}
            setCurrentUser={this.props.setCurrentUser}
            user={this.props.user}/>
          </Route>

          .  .  .

          <Route path="/logout">
            <Logout />
          </Route>
          <Route exact path="/" >
            <Home
            get_token={this.props.get_token}
            token={this.props.token}
            setCurrentUser={this.props.setCurrentUser}
            logoutUser={this.props.logoutUser}
            user={this.props.user}/>
          </Route>
        </Switch>
      </div>
    </Router>
  );
 }
}

const mapStateToProps = state => {
  return {
    token: state.csrf_token,
    user: state.user
  }
}

const mapDispatchToProps = dispatch => ({
    get_token: () => dispatch(getToken()),
    signupUser: (token, username, password) => dispatch(signup(token, username, password)),
    loginUser: (token, username, password) => dispatch(login(token, username, password)),
    logoutUser: token => dispatch(logout(token)),
    setCurrentUser: () => dispatch(setCurrentUser())
})

export default connect(mapStateToProps, mapDispatchToProps)(App)
```

As you see my App class is wrapped with `connect`. This is imported from `react-redux`.
Redux is a state container for JavaScript apps. It makes it easy to manage the state of my application. It took me a while to understand these `state` and `props`.
State is a JavaScript object that stores a component's dynamic data and determines the component's behaviour. It is local or owned by that specific component. Because state is dynamic, it enables a component to keep track of changing information in between renders and for it to be dynamic and interactive. Also state can only be used within a class component. So I have to map the state to props so I can pass it down to child component. They are immutable and read-only in the child component.
So basically Redux is a store for the data. You can call the action which is event and this is the only way you can send data from your application to your Redux store. The data can be from user interactions, API calls, or even form submissions. The action must contain the type property and the payload to be stored.

```
export const signup = (csrf_token, username, password) => {

    return async function (dispatch) {
        try{
            const res = await fetch("http://localhost:3001/api/v1/signup", {
                method: 'POST',
                headers: {
                    'Accept': 'application/json',
                    'Content-Type': 'application/json',
                    'X-CSRF-TOKEN': csrf_token
                },
                body: JSON.stringify({user: {username, password}}),
                credentials: 'include'
            })
            if(!res.ok){
                throw res
            }
            const user = await res.json()
            dispatch({
                type: 'SET_USER',
                payload: user
            })
        }catch(error){
            console.log(error)
        }
    }
}
```

Above the file is my user action. It sends the data from the form and POST request to the Rails API and stores the user in the payload. This action type and payload is set in the reducer file. Reducer takes the previous state of the app and returns a new state based on the action passed to it. Then all of this data will be stored in the redux store.

```
import React from 'react';
import ReactDOM from 'react-dom';

import './index.css';
import App from './App';

import rootReducer from './reducers'

import { Provider } from 'react-redux'
import { createStore, applyMiddleware, compose } from 'redux'
import thunk from 'redux-thunk'

const store = createStore(rootReducer,
compose(
    applyMiddleware(thunk),
    window.devToolsExtension ? window.devToolsExtension() : f => f
  ))

ReactDOM.render(
    <Provider store={store}>
        <App />
    </Provider>,
document.getElementById('root')
)
```

As you can see from the code above, the most important thing you need to have is this `redux-thunk`.
Redux Thunk middleware allows you to write action creators that return a function instead of an action. Thunk is a functional programming technique used to delay computation. Instead of performing some work now, you produce a function body or unevaluated expression (the “thunk”) which can optionally be used to perform the work later. This enable us to avoid directly causing side effects in our actions, action creators, or components.

## Conclusion
React and Redux are powerful and fun to use to build an app. However, it can be confusing if you lose track of all the flows. After eleven months attending Flatiron school I've managed to build five projects. This React/Redux project took the longest time to finish, but is also the closest to a completed app. It's not 100% done, but it's an ongoing project that I plan on adding more functionality as I continue to learn and progress as a developer. It would be amazing to see an app that I designed being used by a large company like Facebook or instagram. Hopefully over time I can reach that level of developing.


text:
# airminx
Low level python code able to control remotely the air minx cambridge audio speakers

Provides a python class to send commands to the Cambridge AirMinx 100 or 200 audio speakers through the network.
 - get preset name by number (buttons on the top of the audio speaker)
 - get preset thumb icon by number
 - get currently playing : the name of the radio currently played
 - play preset (by number)
 - pause
 - get current volume
 - volume up
 - volume down
 - set stream name and url : not fully working

repository: yawks/airminx

repo_name: yawks/airminx


text:
# hashcash plugin for Nodemailer

This plugin adds [hashcash headers](http://www.hashcash.org/) for the Nodemailer generated e-mail messages.

> NB! Generating hashcash values with JavaScript might be **very** slow (might take even 10s of seconds for a 20 bit hashcash value) and every recipient requires its own unique X-Hashcash header, so do not use this for messages with a large list of recipients.

## Install

Install from npm

    npm install nodemailer-hashcash --save

## Usage

#### 1. Load the `hashcash` function

```javascript
var hashcash = require('nodemailer-hashcash');
```

#### 2. Attach it as a 'compile' handler for a nodemailer transport object

```javascript
nodemailerTransport.use('compile', hashcash(options));
```

Where

  * **options** - is an optional options argument with the following values:
      * **bits** - (defaults to 20) how many bits to calculate

## Example

```javascript
var nodemailer = require('nodemailer');
var transporter = nodemailer.createTransport();
transporter.use('compile', hashcash());
transporter.sendMail({
    from<EMAIL_ADDRESS>    to<EMAIL_ADDRESS>    …
});
```

## License

**MIT**

repository: Shilpa-Arora/nodemailer

repo_name: Shilpa-Arora/nodemailer


text:
Demonstrates issue with loading data migration generator withing engine.

```
bundle install
```

Run generator:

```
✗ bin/rails g data_migration Foo
/usr/local/opt/rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/rails-data-migrations-1.0.4/lib/generators/data_migration_generator.rb:7:in `create_migration_file': uninitialized constant DataMigrationGenerator::RailsDataMigrations (NameError)
  from /usr/local/opt/rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/thor-0.19.4/lib/thor/command.rb:27:in `run'
  from /usr/local/opt/rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/thor-0.19.4/lib/thor/invocation.rb:126:in `invoke_command'
  from /usr/local/opt/rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/thor-0.19.4/lib/thor/invocation.rb:133:in `block in invoke_all'
  from /usr/local/opt/rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/thor-0.19.4/lib/thor/invocation.rb:133:in `each'
  from /usr/local/opt/rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/thor-0.19.4/lib/thor/invocation.rb:133:in `map'
  from /usr/local/opt/rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/thor-0.19.4/lib/thor/invocation.rb:133:in `invoke_all'
  from /usr/local/opt/rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/thor-0.19.4/lib/thor/group.rb:232:in `dispatch'
  from /usr/local/opt/rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/thor-0.19.4/lib/thor/base.rb:444:in `start'
  from /usr/local/opt/rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/railties-<IP_ADDRESS>/lib/rails/generators.rb:180:in `invoke'
  from /usr/local/opt/rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/railties-<IP_ADDRESS>/lib/rails/commands/generate.rb:13:in `<top (required)>'
  from /usr/local/opt/rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/railties-<IP_ADDRESS>/lib/rails/engine/commands_tasks.rb:68:in `require'
  from /usr/local/opt/rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/railties-<IP_ADDRESS>/lib/rails/engine/commands_tasks.rb:68:in `require_command!'
  from /usr/local/opt/rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/railties-<IP_ADDRESS>/lib/rails/engine/commands_tasks.rb:73:in `generate_or_destroy'
  from /usr/local/opt/rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/railties-<IP_ADDRESS>/lib/rails/engine/commands_tasks.rb:44:in `generate'
  from /usr/local/opt/rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/railties-<IP_ADDRESS>/lib/rails/engine/commands_tasks.rb:37:in `run_command!'
  from /usr/local/opt/rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/railties-<IP_ADDRESS>/lib/rails/engine/commands.rb:14:in `<top (required)>'
  from bin/rails:14:in `require'
  from bin/rails:14:in `<main>'
```


text:
---
categories:
- community
date: "2018-12-13T11:21:21+01:00"
description: I started a mini project this week to collect developer blogs so that
  I can connect more with the community. I hope that this can be a way of encouraging
  people to do more with their personal blogs...
draft: false
tags:
- community
title: Send Your Blogs!
---

I was privileged to attended View Source London this year, and gained a lot once more by seeing talks by many members of the W3C and others. Lots of the talks had something really outstanding to share, but one in particular resonated with my desire to connect more with the developer community.

 Ana hilighted that there is value in having your own blog because you're more in control, and it can be more personal to you.

She concluded with the request to "send me your blogs!"

There was a similar request from Sara Soueidan via Twitter. I was going to share it with you but it's either been deleted or the Twitter search algorithm isn't picking it up today. Sara's request was for blogs that had RSS feeds. That alone is an interesting idea...

## RSS Is Back

I've recently adopted Sara's approach.  So I opened a repo that will list all of the developer blogs I discover.

Please submit a PR to add yours.

My idea is to extend this so that I can show categories (for example, give a general idea of what these blogs talk about) and possibly even curating a website that collects articles together...

## Send Your Blogs

[Request for PRs on the awesome-developer-blogs repo is open!


text:
# cex-graphs
An iOS Application to consume cex.io/rest-api and display information on charts and lists.

Live Line Graph from CEX.IO 🕶|
:-------------------------:

Currency Limit from CEX.IO 🕶|
:-------------------------:

## Cocoapods:
(Use of OpenSource)
Charts,
Alamofire

repository: AshishKapoor/cex-graphs

gha_language: Swift

repo_name: AshishKapoor/cex-graphs


text:
# Clooney
Clooney is an actor (ayooo) library for the web. Classes given to Clooney will be instantiated and run in a worker, keeping the main thread responsive.

## Quickstart
An example says more than 1000 words:

```html
<script src="/clooney.bundle.js"></script>
<script>
  (async function() {
    class MyRemoteClass {
      doExpensiveCalculation(a, b) {
        return a + b;
      }
    }

    const instance = await Clooney.spawn(MyRemoteClass);
    console.log(await instance.doExpensiveCalculation(5, 23));
  })();
</script>
```

## API
Clooney’s job is to take _actors_ (class definitions) and _spawn_ those actors in _containers_ ([Web Workers][Web Worker]). You can use that instance as if it was a local instance (this is magic provided by [Comlink]).

### `Clooney.spawn(class)`
This call is equivalent to `Clooney.defaultStrategy.spawn(class)`. Clooney creates an instance of `RoundRobinStrategy` as the default strategy.

### Strategies
Strategies decide how many containers are spun up and where a new instance is created.

```typescript
export interface Strategy {
  /**
   * `spawn` instantiates the given actor in an actor container of the strategy’s choice.
   * @returns The return type is the type as T, but every method is implicitly async.
   */
  spawn<T>(actor: new () => T, opts: Object): Promise<T>;
  /**
   * `terminate` calls `terminate()` on all existing containers of the strategy.
   */
  terminate(): Promise<void>;
}
```

#### `Clooney.RoundRobinStrategy(opts)`
`RoundRobingStrategy` creates up to n containers and cycles through the containers with every `spawn` call. `RoundRobinStrategy` is the default strategy.

### Strategy Options

- `maxNumContainers`: Maximum number of containers to create (default: 1)
- `newWorkerFunc`: Asynchronous function that creates a new container (default: `new Worker(Clooney.defaultWorkerSrc)`)

### `Clooney.asRemoteValue(obj)`

`asRemoteValue` marks a value. If a marked value is used as an parameter or return value, it will not be transferred but instead proxied. This is necessary, for example, for callbacks.

```js
class MyActor {
  async callCallback(cb) {
    await cb('ohai');
  }
}

const actor = await Clooney.spawn(MyActor);
await actor.callCallback(Clooney.asRemoteValue(msg => console.log(msg))); // logs 'ohai'
```

## CDN
If you want to use Clooney from a CDN, you need to work around the same-origin restrictions that workers have:

```html
<script<EMAIL_ADDRESS><script>
  async function newWorkerFunc() {
    const blob = await fetch(Clooney.defaultWorkerSrc).then(resp => resp.blob())
    return new Worker(URL.createObjectURL(blob));
  }

  const strategy = new Clooney.RoundRobinStrategy({newWorkerFunc});
  // Business as usual using strategy.spawn() ...
</script>
```

[Comlink]: https://github.com/GoogleChromeLabs/comlink
[Web Worker]: https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API

---
License Apache-2.0

repository: forabi/clooney

repo_name: forabi/clooney


text:
---
layout: post
published: true
title: 'Solidity 0.5.1 Release Announcement'
date: '2018-12-03'
author: Solidity Team
category: Releases
---

This release improves the usability of interfaces, fixes some bugs, extends the SMT checker and provides an early preview of the Yul optimizer.

A big thank you to all contributors who helped make this release possible!

Download the new version of Solidity [here](https://github.com/ethereum/solidity/releases/tag/v0.5.1).

repository: ethereum/solidity-blog

gha_language: HTML

repo_name: ethereum/solidity-blog


text:
## Using Azure Database for PostgreSQL to Run a Python Application
### Overview
Azure Database for PostgreSQL is a PostgreSQL database service built on Microsoft's scalable cloud infrastructure for application developers.

Leverage your existing open-source PostgreSQL skills and tools and scale on-the-fly without downtime to efficiently deliver existing and new applications with reduced operational overhead.

Built-in features maximize performance, availability, and security. Azure Database for PostgreSQL empowers developers to focus on application innovation instead of database management tasks.

### Scenario Overview
This hands-on lab will step you through the following:

1.	Create an Azure storage account and initialize Azure Cloud Shell for Azure CLI.
1.  Create an **Azure Database for PostgreSQL** instance.
1.  Create an **Ubuntu Azure VM**.
2.	Enable the firewall.
3.	Create a database for an app written in Python and Django in Azure PostgreSQL database instance.
4.	Login to ubuntu VM.
5.	Download the app from GitHub: git clone https://github.com/vitorfs/bootcamp.git - cd bootcamp.
7.	Change your connection string - vim .env - Paste this in the .env file (change database credentials to yours)

    DEBUG=True
SECRET_KEY='mys3cr3tk3y'
DATABASE_URL='postgres://pgsqluser@postgresql<inject story-id="story://Content-Private/content/dfd/SP-OSS/postgresql/ossexperience1/story_a_postgresql" key="resourceGroupName" />:P@ssword1@<inject story-id="story://Content-Private/content/dfd/SP-OSS/postgresql/ossexperience1/story_a_postgresql" key="resourceGroupName" />.database.windows.net:5432/bootcamp'
ALLOWED_HOSTS = "*"
8.  Run migration and serve the app

          Python manage.py migrate
          Python manage.py runserver <IP_ADDRESS>:8000

9.  Open browser and go to http://[externalIpAddress]:8000 to interact with the app.
10. Play around with the app, and demonstrate that it works.

repository: Azure/azure-postgresql

gha_language: Bicep

repo_name: Azure/azure-postgresql


text:
# TODO

The purpose of this file is to keep track of all ongoing tasks of the project.

This includes the TODOs for the next version(s), non programming tasks like updating README etc. and
bugfixes as well as new features which are not directly related to the upcoming version(s).

The TODOs of the released versions will be moved to the
[OLD_VERSIONS.md][old_versions-url] file.

---

## Version 1.1.0

- [X] (Optimizations) (C)

    Run through the directory entries only once and update `considered_directories` on the way.

- [X] Manual argument handling (C)

    Therefore string args will be possible.

- [X] Code Cleanup (Python)

    Implement data structure as used in the C version.

- [X] Convert TODO to Markdown file

- [X] Move the old version TODOs into the separate [OLD_VERSIONS.md][old_versions-url] file.

### Bugfixes:

- [X] Bugfix for Issue [#10][issue_10-url]
- [X] Bugfix for Issue [#12][issue_12-url]
- [X] Bugfix for Issue [#13][issue_13-url]

### Features:

- [X] Argument `[Number]`

    A Number can be added to args which tells the program how many directories should be made.

    e.g. `cdir test 10`

### Status: `READY`

---

## Version 1.1.1

### Bugfixes:

### Features:

### Status: `not started`

---

## General

- [ ] Create a Wiki.

---

## Additional Features

- [ ] Argument `-v` changes to `--verbose`

  Displays directories which have the correct formatting.
  Shows occurrences of directories, and their numbering as well.

- [ ] Measure execution times of both versions under static circumstances.

  Show the results in the [README][readme-url] but also this measurement
  code should stay in the codebase as an additional printable information
  for `verbose` (see above).

- [ ] Argument `-s`

    CDIR should add numbering at the beginning.
    Will be interesting with argument `-f` (see below).

- [ ] Argument `-f FILE`

    A file can be used for multiple directory creation and configuration.

---

## Additional Bugfixes

[old_versions-url]: https://github.com/TristanBandat/cdir/blob/main/OLD_VERSIONS.md
[readme-url]: https://github.com/TristanBandat/cdir/blob/main/README.md
[issue_10-url]: https://github.com/TristanBandat/cdir/issues/10
[issue_12-url]: https://github.com/TristanBandat/cdir/issues/12
[issue_13-url]: https://github.com/TristanBandat/cdir/issues/13

repository: TristanBandat/cdir

repo_name: TristanBandat/cdir