text:
title: Observable.GroupJoin<TLeft, TRight, TLeftDuration, TRightDuration, TResult>()
---
# Observable.GroupJoin\<TLeft, TRight, TLeftDuration, TRightDuration, TResult\> Method

Correlates the elements of two sequences based on overlapping durations, and groups the results.

**Namespace:**  [System.Reactive.Linq](System.Reactive.Linq/System.Reactive.Linq)
**Assembly:**  System.Reactive (in System.Reactive.dll)

## Syntax

```vb
'Declaration
<ExtensionAttribute> _
Public Shared Function GroupJoin(Of TLeft, TRight, TLeftDuration, TRightDuration, TResult) ( _
    left As IObservable(Of TLeft), _
    right As IObservable(Of TRight), _
    leftDurationSelector As Func(Of TLeft, IObservable(Of TLeftDuration)), _
    rightDurationSelector As Func(Of TRight, IObservable(Of TRightDuration)), _
    resultSelector As Func(Of TLeft, IObservable(Of TRight), TResult) _
) As IObservable(Of TResult)
```

```vb
'Usage
Dim left As IObservable(Of TLeft)
Dim right As IObservable(Of TRight)
Dim leftDurationSelector As Func(Of TLeft, IObservable(Of TLeftDuration))
Dim rightDurationSelector As Func(Of TRight, IObservable(Of TRightDuration))
Dim resultSelector As Func(Of TLeft, IObservable(Of TRight), TResult)
Dim returnValue As IObservable(Of TResult)

returnValue = left.GroupJoin(right, _
    leftDurationSelector, rightDurationSelector, _
    resultSelector)
```

```csharp
public static IObservable<TResult> GroupJoin<TLeft, TRight, TLeftDuration, TRightDuration, TResult>(
    this IObservable<TLeft> left,
    IObservable<TRight> right,
    Func<TLeft, IObservable<TLeftDuration>> leftDurationSelector,
    Func<TRight, IObservable<TRightDuration>> rightDurationSelector,
    Func<TLeft, IObservable<TRight>, TResult> resultSelector
)
```

```c++
[ExtensionAttribute]
public:
generic<typename TLeft, typename TRight, typename TLeftDuration, typename TRightDuration, typename TResult>
static IObservable<TResult>^ GroupJoin(
    IObservable<TLeft>^ left,
    IObservable<TRight>^ right,
    Func<TLeft, IObservable<TLeftDuration>^>^ leftDurationSelector,
    Func<TRight, IObservable<TRightDuration>^>^ rightDurationSelector,
    Func<TLeft, IObservable<TRight>^, TResult>^ resultSelector
)
```

```fsharp
static member GroupJoin :
        left:IObservable<'TLeft> *
        right:IObservable<'TRight> *
        leftDurationSelector:Func<'TLeft, IObservable<'TLeftDuration>> *
        rightDurationSelector:Func<'TRight, IObservable<'TRightDuration>> *
        resultSelector:Func<'TLeft, IObservable<'TRight>, 'TResult> -> IObservable<'TResult>
```

```javascript
JScript does not support generic types and methods.
```

#### Type Parameters

- TLeft
  The type of left.

- TRight
  The type of right.

- TLeftDuration
  The type of left duration.

- TRightDuration
  The type of right duration.

- TResult
  The type of result.

#### Parameters

- left
  Type: [System.IObservable](https://msdn.microsoft.com/en-us/library/Dd990377)\<TLeft\>
  The left observable sequence to join elements for.

- right
  Type: [System.IObservable](https://msdn.microsoft.com/en-us/library/Dd990377)\<TRight\>
  The right observable sequence to join elements for.

- leftDurationSelector
  Type: [System.Func](https://msdn.microsoft.com/en-us/library/Bb549151)\<TLeft, [IObservable](https://msdn.microsoft.com/en-us/library/Dd990377)\<TLeftDuration\>\>
  A function to select the duration of each element of the left observable sequence, used to determine overlap.

- rightDurationSelector
  Type: [System.Func](https://msdn.microsoft.com/en-us/library/Bb549151)\<TRight, [IObservable](https://msdn.microsoft.com/en-us/library/Dd990377)\<TRightDuration\>\>
  A function to select the duration of each element of the right observable sequence, used to determine overlap.

- resultSelector
  Type: [System.Func](https://msdn.microsoft.com/en-us/library/Bb534647)\<TLeft, [IObservable](https://msdn.microsoft.com/en-us/library/Dd990377)\<TRight\>, TResult\>
  A function invoked to compute a result element for any element of the left sequence with overlapping elements from the right observable sequence.

#### Return Value

Type: [System.IObservable](https://msdn.microsoft.com/en-us/library/Dd990377)\<TResult\>
An observable sequence that contains result elements computed from source elements that have an overlapping duration.

#### Usage Note

In Visual Basic and C\#, you can call this method as an instance method on any object of type [IObservable](https://msdn.microsoft.com/en-us/library/Dd990377)\<TLeft\>. When you use instance method syntax to call this method, omit the first parameter. For more information, see [](https://msdn.microsoft.com/en-us/library/Bb384936) or [](https://msdn.microsoft.com/en-us/library/Bb383977).

## See Also

#### Reference

[Observable Class](Observable/Observable)

[System.Reactive.Linq Namespace](System.Reactive.Linq/System.Reactive.Linq)

repository: reactiveui/website

repo_name: reactiveui/website


text:
# ESP8266-sensors
Repository for all my ESP8266 sensors.

### SHT30 Sensor for Wemos D1 Mini
Use awesome library https://github.com/marvinroger/homie-esp8266 to manage sensors.

Compatible with OTA Updates (tested)

### WS2812B Led control from MQTT

Fill a led strips with solid color, or switch between predefined patterns.

Code adaptation to use Homie Library (almost identical) from : https://github.com/jasoncoon/esp8266-fastled-webserver

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
---
layout: default
---

# 1997-05-28 - Re: Nym Servers

## Header Data

From: Ray Arachelian<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 9b0fd6e572718805547f97a00fd4529e0717759e9c0a21b353d926fb6c7dd807

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1997-05-28 16:10:06 UTC

Raw Date: Thu, 29 May 1997 00:10:06 +0800

## Raw message

```
{% raw  %}From: Ray Arachelian<EMAIL_ADDRESS>Date: Thu, 29 May 1997 00:10:06 +0800
To<EMAIL_ADDRESS>Subject: Re: Nym Servers
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

On Wed, 28 May 1997, Anonymous wrote:

> However, the prices have changed since I brought up the idea
> a month ago.  At the time, they had auto-responders with POP mail -
> - - $50/2yrs POP+autoresponder, or $39 one-time for a mail forwarder.
> Now, however, they offer autoresponders for 3/$99 for three years,
> with no mention of POP mail or forwarding - I don't know if they've
> dropped the service (in favor of web hosting at $25/month),
> or if it's still there and just not advertised.  (Of course,
> there's still the moral dilemma that even $99 is $99 in Spamford's pocket :-)

Not to mention the fact that this bitch will grab any email addresses
(including your own) that pass through those accounts and use them for his
own spamming purposes.  Don't do it, it's not worth it, not just for the
money going to a shit eating weasel, but for the principle of the thing -
you'd cause the spamming of everyone using it or communicating with it.

If you get a web site with them, they'd grab all the email addresses from
the surfers' browsers.  Hell, you might as well get an account on
nsa.gov while you're at it.

=====================================Kaos=Keraunos=Kybernetos==============
.+.^.+.|  Ray Arachelian    | "Boy meets beer.  Boy drinks Beer,     |./|\.
<EMAIL_ADDRESS>      Boy gets another beer!"         |/\|/\
<--*-->| ------------------ |                                        |\/|\/
../|\..| "A toast to Odin,  | For with those which eternal lie, with |.\|/.
.+.v.+.|God of screwdrivers"| strange aeons, even death may die.     |.....
======================== http://www.sundernet.com =========================

{% endraw %}
```

## Thread

+ Return to [May 1997](/archive/1997/05)

+ Return to "[Bill Frantz <frantz@netcom.com>](/authors/bill_frantz_frantz_at_netcom_com_)"
+ Return to<EMAIL_ADDRESS>(Igor Chudov @ home)](/authors/ichudov_at_algebra_com_igor_chudov__at__home_)"
+ Return to<EMAIL_ADDRESS>(Anonymous)](/authors/nobody_at_replay_com_anonymous_)"
+ Return to "[Ray Arachelian <sunder@brainlink.com>](/authors/ray_arachelian_sunder_at_brainlink_com_)"

+ 1997-05-28 (Wed, 28 May 1997 10:44:25 +0800) - [Re: Nym Servers](/archive/1997/05/b427c869c54530c3765d4aed170acde9dcef6c700bfc74e20385fa52bbe43631) -<EMAIL_ADDRESS>(Anonymous)_
  + 1997-05-28 (Wed, 28 May 1997 12:32:28 +0800) - [Re: Nym Servers](/archive/1997/05/71de30a676fe99cb3930669ce9ad9dc56bdcdc8b918385c1912c8120861a2074) -<EMAIL_ADDRESS>(Igor Chudov @ home)_
  + 1997-05-28 (Thu, 29 May 1997 00:10:06 +0800) - Re: Nym Servers - _Ray Arachelian<EMAIL_ADDRESS>  + 1997-05-28 (Thu, 29 May 1997 02:33:47 +0800) - [Re: Nym Servers](/archive/1997/05/bd6e805bc2946d75ffedecaa63e5858599cea1043077c12a1e5e1dad3557d018) - _Bill Frantz<EMAIL_ADDRESS>

license: MIT

gha_license_id: MIT


text:
# docker-bitcoind

Dockerized bitcoin-core (Work in progress)

## Mission

Run your bitcoin node with various configurations and environments.

It's time to secure your valuable assets from vulnerabilities in other software.

**Ready to sandbox? Let's do it.**

## How?

Say you want to run a bitcoin node on a server, connect your Armory client and
sleep with the peace of knowing that if one part of your docker stack is vulnerable,
your wallets and node will be safe.

Pull the [docker-armorydb](https://github.com/s1kx/docker-armorydb) image and set up a `docker-compose` project. (Example coming)

Now connect your Armory client to the node and continue working on whatever you're doing.
It's that simple.


text:
# Welcome to aTFC

### Why?

Because we didn't like how [TFC-TNG][2] dropped the food mechanics from the original Mod, and were not happy with the current performance of [TFC+][1] which is still being based on Minecraft 1.7.10. We also wanted to dabble in writing Minecraft mods, after playing the game for a decade.

### What does aTFC stand for?

The term *aTFC* stands for *another* TFC, because this is yet another rewrite of the most amazing Minecraft mod that was ever made. Our goal is to recreate the original TFC mod, running on the newest Minecraft version (1.16.4), as well as introduce changes we enjoyed by both [TFC+][1] and [TFC-TNG][2].

This mod is different to...
* [TFC+][1]: as it is not based on the original code for Minecraft 1.7.10
* [TFC-TNG][2] as it is not dropping the food mechanics

### Contributors

* [Michael "dot_Sp0T" Stocker](https://github.com/dotSp0T)
* [Patrick "McDonnough" Bächli](https://github.com/McDonnough)

## Testers

### Install Forge
You will need `Minecraft Forge - MC 1.16.4` to play the mod: http://files.minecraftforge.net/maven/net/minecraftforge/forge/index_1.16.4.html

### Latest ALPHA Builds
You can get the latest `alpha`-build by...

1. selecting the `develop` branch on the top-left and then click on the green checkmark:
![image showing the above described process](README/images/testers_howtodownload_1.png "How to Download - Build & Checkmark")
2. selecting the `details` link from the `aTFC` build process:
![image showing the above described process](README/images/testers_howtodownload_2.png "How to Download - aTFC, Details")
3. selecting `artifacts` at the top of the page, and then the `aTFC` zip file to download it:
![image showing the above described process](README/images/testers_howtodownload_3.png "How to Download - Build & Checkmark")
4. inside the zip you will find the mod-jar

You can also download builds from any of the other branches, but please do not report bugs for anything else than `develop`.

### Play

Start the modded minecraft instance and, when generating a new world, select the `atfc-continental` worldtype.

### Report Bugs
If you happen upon bugs and/or behaviour you think is wrong, please report a bug under the [Issue-Tracker](https://github.com/CrumbleWorks/aTFC/issues). You can also propose new game-features, but please first check if the feature you thought of hasn't already been proposed.

## Development

### How to build & run

1. run `gradlew build`
2. run `gradlew runData` to generate json files (models, blockstates, ...)
3. run `gradlew build`
4. run `gradlew runClient` or use the `runClient.launch` config in eclipse to start the game

After the first build you only have to run steps 2, 3 and 4. If no generators were touched, step 4. is enough.

**OR**

1. run `gradlew buildData` to generate json files (models, blockstates, ...) and build, etc.
4. run `gradlew runClient` or use the `runClient.launch` config in eclipse to start the game

### Some blocks don't load properly?

Delete the `src/generated` directory or run `gradlew deleteGeneratedFiles`

### Versioning

* 0.0.x Enyo

### Coordinates

`x` increments towards `east` and decrements towards `west`
`y` increments towards `up` and decrements towards `down`
`z` increments towards `south` and decrements towards `north`

### Tools

* **Loot-Table Generator**: https://misode.github.io/loot-table/
* **Dimension Generator**: https://misode.github.io/dimension/
* **SRG-Names Lookup**: https://mcp.thiakil.com/

### Formats

* **blockstates**: https://minecraft.gamepedia.com/Model
* **loot-tables**: https://minecraft.gamepedia.com/Loot_table
* **resource-packs**: https://minecraft.gamepedia.com/Resource_Pack

* **RenderTypes**: https://greyminecraftcoder.blogspot.com/2020/04/block-rendering-1144.html

### Links

* **Unofficial Forge Wiki**: https://forge.gemwire.uk/wiki/
* **Forge Docu**: https://mcforge.readthedocs.io/en/1.16.x/
* **Cadiboo Forge 1.15.1 Tutorials**: https://cadiboo.github.io/tutorials/1.15.1/forge/
* **Modding with Forge 1.16.4**: https://youtube.com/playlist?list=PLaevjqy3Xufavi5mWXvWnGmwRylL-QZy7
* **Modding with Forge 1.16.x**: https://youtube.com/playlist?list=PLGProEDTdBjghW5IZsiWno6e9QAkHChyQ
* **Modding with Forge 1.11**: https://www.youtube.com/playlist?list=PLGProEDTdBjjNQrr1G4Nv3oqqQ14hZtYV
* **Modding with Forge 1.8**: https://www.youtube.com/playlist?list=PLiFAb_ju1TahVZ1uOer7T3m_17crt15kp

* **Modding for 1.14.4+**: https://greyminecraftcoder.blogspot.com/p/list-of-topics-1144.html

**Texturing**:
- Multi-Texturing: https://mcmodhelp.fandom.com/wiki/Multi-Texturing_Blocks
- Map/Material-Colors: https://minecraft.gamepedia.com/Map_item_format#Map_colors

**Modelling**:
- Blockmodels: https://mcmodhelp.fandom.com/wiki/Multi-Texturing_Blocks
- MrCrayfish Model Creator: https://mrcrayfish.com/tools.php?id=mc

**Mod Samples**:
- https://github.com/TheGreyGhost/MinecraftByExample

### Umlauts
Ä \u00c4
ä \u00e4
Ö \u00d6
ö \u00f6
Ü \u00dc
ü \u00fc
ß (sz) \u00df

[1]: https://plus.terrafirmacraft.com/
[2]: https://tng.terrafirmacraft.com/Main_Page

repository: CrumbleWorks/aTFC

branch_name: refs/heads/develop

gha_language: Java

repo_name: CrumbleWorks/aTFC


text:
# Getting Starting with Julia in Parallel

A simple example is here:
[https://oncomputingwell.princeton.edu/2019/08/running-parallel-julia-scripts-using-the-distributed-package](https://oncomputingwell.princeton.edu/2019/08/running-parallel-julia-scripts-using-the-distributed-package)


text:
# node-ssllabs

A node.js library for the [SSL Labs API][1].

[![npm version](https://img.shields.io/npm/v/node-ssllabs.svg)](https://www.npmjs.com/package/node-ssllabs)
[![Build Status](https://travis-ci.com/keithws/node-ssllabs.svg?branch=master)](https://travis-ci.com/keithws/node-ssllabs)
[![Coverage Status](https://coveralls.io/repos/github/keithws/node-ssllabs/badge.svg?branch=master)](https://coveralls.io/github/keithws/node-ssllabs?branch=master)
[![dependencies](https://img.shields.io/david/keithws/node-ssllabs.svg)](https://david-dm.org/keithws/node-ssllabs)
[![npm downloads per month](https://img.shields.io/npm/dm/node-ssllabs.svg)](https://www.npmjs.com/package/node-ssllabs)
[![License](https://img.shields.io/npm/l/node-ssllabs.svg?color=blue)](https://github.com/keithws/node-ssllabs/blob/master/LICENSE)

> SSL Labs APIs expose the complete SSL/TLS server testing functionality in a programmatic fashion, allowing for scheduled and bulk assessment. We are making the APIs available to encourage site operators to regularly test their server configuration.

## Install

	npm install node-ssllabs

## Usage

	var ssllabs = require("node-ssllabs");

	ssllabs.scan("www.ssllabs.com", function (err, host) {
		console.dir(host);
	});

## Test Usage

Testing with [Mocha][5] and [Should.js][6].

	var ssllabs = require("node-ssllabs"),
		should = require("should");

	describe("www.ssllabs.com", function () {
		it("should get an A+", function (done) {
			ssllabs.scan("www.ssllabs.com", function (err, host) {
				if (err) {
					throw err;
				}
				host.endpoints.forEach(function (endpoint) {
					endpoint.grade.should.equal("A+");
				});
				done();
			});
		});
	});

## Advanced Usage

	var ssllabs = require("node-ssllabs");

	ssllabs.scan({
		"host": "www.ssllabs.com",
		"fromCache": true,
		"maxAge": 24
	}, function (err, host) {
		console.dir(host);
	});

	ssllabs.info(function (err, info) {
		console.dir(info);
	});

	ssllabs.analyze({
		"host": "www.ssllabs.com",
		"publish": true,
		"startNew": true,
		"all": "done"
	}, function (err, host) {
		console.dir(host);
	});

	ssllabs.analyze({
		"host": "www.ssllabs.com",
		"fromCache": true,
		"maxAge": 72,
		"all": "on",
		"ignoreMismatch": true
	}, function (err, host) {
		console.dir(host);
	});

	ssllabs.getEndpointData({
		"host": "www.ssllabs.com",
		"s": "<IP_ADDRESS>",
		"fromCache": true
	}, function (err, endpointData) {
		console.dir(endpointData);
	});

	ssllabs.getStatusCodes(function (err, statusCodes) {
		console.dir(statusCodes);
	});

	ssllabs.getRootCertsRaw(function (err, rootCertsRaw) {
		console.dir(rootCertsRaw);
	});

	ssllabs.getRootCertsRaw({
		trustStore: 5
	}, function (err, rootCertsRaw) {
		console.dir(rootCertsRaw);
	});

	ssllabs.getRootCerts(function (err, rootCerts) {
		console.dir(rootCerts);
	});

	ssllabs.getRootCerts({
		trustStore: 5
	}, function (err, rootCerts) {
		console.dir(rootCerts);
	});

## Proxy all requests via a tunneling agent

As of version 1.1.0, this library will respect your `HTTPS_PROXY` environment variable and tunnel all requests to the specified URL. Compatible with all protocols supported by [proxy-agent](https://www.npmjs.com/package/proxy-agent).

As of version 2.1.0, this library will set the proxy agent on each request it makes and will not override the global HTTP agent.

## License

node-ssllabs is available under the [MIT License][2].

## Todo

* add (more) support for [access rate and rate limiting][4]
* incorporate new info field, newAssessmentCoolOff, to access rate and rate limiting
* add option to specify an array of hosts to scan
* figure out if the maxAge parameter is required with the fromCache parameter
* make API version changeable (maybe?) with createClient()?

## TODO for next minor release

* have the `scan` function emit events for polling progress

## TODO for next major release

* promise-ify and modernize
* refactor to be a Universal ES6 module that can be used client side and server side with the fetch and URL libraries
* maintain support for using tunneling proxies (server side only?)

## Change Log

*2.1.0— April 16, 2020*

* set proxy agent on each HTTP request instead

*2.0.0— April 10, 2020*

* dropping support for node 6 because eslint and nyc no longer support it

*1.1.3— April 10, 2020*

* added User Agent header to all requests
* improved error handling

*1.1.2— May 22, 2019*

* refactored code to reduce cognitive complexity
* increased test coverage

*1.1.1— May 21, 2019*

* refactored code to eliminate some duplicate code
* added test coverage reporting

*1.1.0— May 4, 2019*

* added support for tunneling proxies via [proxy-agent](https://www.npmjs.com/package/proxy-agent)

*1.0.2— May 3, 2019*

* smaller install
* better testing
* faster builds

*1.0.1— May 3, 2019*

* call callback with error instead of throwing
* normalized error handling code patterns
* reordered tests so the fast tests run before the slow tests
* added more tests for error handling in getEndpointData() and getRootCertsRaw()

*1.0.0— May 3, 2019*

* moved async to dev dependency (as it should have been)
* removed underscore dependency (was very lightly used)
* added dependency on node v4.0.0 for Object.assign

*0.6.0— May 2, 2019*

* updated API endpoint from v2 to v3
* updated dependencies
* switched from JSHint to eslint for syntax checking
* fixed typos
* added basic support for access rate and rate limiting to `scan()`
* added support for the `trustStore` parameter to the `getRootCertsRaw()` call
* added `getRootCerts()` call that returns the data as a plain-old object

*0.5.0 — July 14, 2016*

* added support for new API call, `getRootCertsRaw`
* improved testing with Mocha
* improved `normalizeOptions` function
* updated documentation

*0.4.3 — May 1, 2015*

* removed requirement that maxAge must be set if fromCache is set
* added check that fromCache is set if maxAge is set
* fixed bug where NaN was accepted for the maxAge parameter

*0.4.2 — April 27, 2015*

* added call to `info` before calling `analyze` in the `scan` function

*0.4.1 — April 27, 2015*

* refactored `scan` function to use `analyze` function for dryness
* improved test to ensure parallel scanning maintains context

*0.4.0 — April 23, 2015*

* added option to only specify a hostname for scanning
* added test for lost context in parallel scans
* added test if `startNew` and `fromCache` options are both true
* added additional parameter tests and verification

*0.3.0 — April 21, 2015*

* added `scan` function to encapsulate [protocol usage][3]

*0.2.0 — April 20, 2015*

* updated to work properly in other packages.

*0.1.0 — April 20, 2015*

* added support for the `getEndpointData` api endpoint.
* added support for the `getStatusCodes` api endpoint.
* improved error handling and reporting.

*0.0.1 — April 20, 2015*

* Initial version
* supports two api endpoints, `info` and `analyze`

  [1]: https://www.ssllabs.com/projects/ssllabs-apis/
  [2]: https://github.com/keithws/node-ssllabs/blob/master/LICENSE
  [3]: https://github.com/ssllabs/ssllabs-scan/blob/master/ssllabs-api-docs.md#protocol-usage
  [4]: https://github.com/ssllabs/ssllabs-scan/blob/master/ssllabs-api-docs.md#access-rate-and-rate-limiting
  [5]: http://mochajs.org
  [6]: http://shouldjs.github.io

branch_name: refs/heads/main


text:
# Docker support for VueJS

This is a basic setup with `docker-compose` and `vue-cli` to easily build a webpack-based VueJS scaffold.

## How to install
Simply run ``sh install.sh`` to build the container and start the `vue-cli` configuration.

## Change VueJS template
You can switch the template by changing `$TEMPLATE` the variable in `install.sh`.

All available templates are listed at: https://github.com/vuejs/vue-cli#official-templates

## Change listening port
To change the port your webserver is listening to, you should change the **`PORT`** variable in your `.env` file in the
root directory.

After changing the port, you have to restart your container.

repository: DracoBlue/vuejs-docker-starter

repo_name: DracoBlue/vuejs-docker-starter


text:
---
name: New Scaffolder request
about: Suggest a new scaffolder.

---

**Is there already a definition file for the scaffolder? (see https://github.com/log2timeline/L2tScaffolder/tree/master/l2tscaffolder/definitions).**
Yes/No

**If there isn't a definition, what is the link to the new project you want to add?**

*URL to the project path*

*Keep in mind that if this isn't a l2t project, you may have to explain here the reasoning behind wanting to add this project here. The l2tscaffolder is meant for open source forensics tool development, so only accept feature requests for projects that fall into that category.*

**What is required for this scaffolder to work?**

*A clear and concise description of the files that need to be copied and what files need to be created and modified. That is a full relative path to all files that will be generated by the scaffolder.*

**What questions are needed?**

*A clear and concise description of any questions that need to be asked before files are generated, what needs to be asked in order for the scaffolder to generate files, eg. "a list question that contains all the required tables, a dict question listing all SQL commands the callback function for each returned row", etc.*

**Do you have template files you can share?**

*These would be the jinja2 template files, or just examples of a generated code that can be used to create the template files.*

**Additional context**

*Add any other context or screenshots about the feature request here.*


text:
# Interview Meeting

Friday 10:00-10:30  11/12/2020

---

## Tangible Model Interview

---

### Unstructured interviews

- most like a conversation, often go into depth
- open questions
- exploratory

>absolute key is to listen rather than talk: practice silence!

#### pros/cons

[2]

|   Advantages  |  Limitations  |
| :----------- | :----------- |
| Can provide **more detailed information** than other data collection methods, such as surveys      | Can be **time-intensive** because of the time it takes to conduct interviews, transcribe them, and analyze the results |
| May provide a **more relaxed atmosphere** in which to collect information through conversation, in comparison to filling out a survey  | **Interviewer must be appropriately trained** in interviewing techniques in order to extract the most detailed and rich data from an interviewee  |
| Interviewee can provide firsthand and more personal knowledge of a given topic that was not anticipated by the researcher | Not generalizable; generalizations about the results are usually incapable of being made because small samples are chosen and random sampling methods are not used |
|  | **Prone to bias**; responses from interviewees (community members, program participants, etc) might be biased due to their stake in the program |

---

### 1. Interview questions about user charastaristic

1. How old are you?
2. What is your gender?(Man - Woman - etc...)
3. Do you need assistance in order to do your daily chores?
4. What is the level of the needed assistance on a scale of 6?
5. How often do you perform these tasks currently?
E.g., how often to you open/close the blinds per day? How often do you turn the TV on and off per day? etc. How do you currently perform these tasks?

<!-- 3. What kind of **physical** disorders do you have?
4. What kind of **cognitive** disorders do you have? -->

> This scale is graduated from 1 to 6, 6 represents independent persons for everyday life activities and 1 represents dependent persons with cognitive, physical, social, significant problems requiring a continued assistance[1].

---

### 2. Interview questions about Model intuitivity

First we introduce the shape of the model without further explanation, and we ask:

![Tangible Model](/img/Tangible2.jpg)

1. could you tell me what possible meaning of the icons on the panel?</u> Then base on their reply, we can set a score for that. This is for the (ease-of-use evaluation). **( I think the model should be introduced during this question.)**
2.  Family? Why? (to evaluate initial acceptability)~~ **same as what would be asked in 3.2**
3. Would you want to do daily jobs with this interface? Eg. TV, blinds, etc. Why?
4. How often would you use this interface compared to the current way you ~~close the blinds~~ do your daily jobs? Why? **(give some examples here, TV, blinds, windows, etc.)**
5. How often do you move from one room to another in your home? Would you take this model with you when you move from one room to another one? Why (not)? (to evaluate portability)
6. ~~ask the user/s to perform some of the gestures so that they can experience it before they comment on it.~~ **Merged into 3.1**

---

### 3. Interview questions after explaining the describtion

We provide a detailed explanasion about the Model, and the interaction inputs, and outputs, then we ask questions:

1. How can you use this model to do this functionality(and we specify the functionality: to control the TV, Conacts, Blinds)?(to evaluate Model complixity to the user)
2. Will you be comfortable to use this model in front of other people?(to evaluate acceptability)
3. How frequent you will use this interaction or that? (to evaluate useability)
4. Can you list the advantages and disadvantages?
5. Can you please comment on the difficulty of usage?(any pain or issues?)

---

## References

---

[1]: Elena Elias, Marc-Eric Bobillier-Chaumon, Michel Vacher. Methods to design home support for elders. HCI International 2018, Jul 2018, Las Vegas, United States. pp.276-289, ⟨10.1007/978-3-319-92037-5_21⟩. ⟨hal-01807679⟩

[2]: Boyce, C., Neale, P. (2006) Conducting In-depth interviews: A Guide for Designing and Conducting In-Depth Interviews for Evaluation Input, Pathfinder international, pp.1-12. [Link](http://www2.pathfinder.org/site/DocServer/m_e_tool_series_indepth_interviews.pdf)

[3]Bhuiyan M, Picking R. A gesture controlled user interface for inclusive design and evaluative study of its usability[J]. Journal of software engineering and applications, 2011, 4(09): 513.[Link](https://www.researchgate.net/publication/220204360_A_Gesture_Controlled_User_Interface_for_Inclusive_Design_and_Evaluative_Study_of_Its_Usability)

repository: Mahmoud-Ali-FCIS/HCI-Project

repo_name: Mahmoud-Ali-FCIS/HCI-Project


text:
# acm-cert-helper

This contains two related utilities, both of which are detailed below, that work with ACM
and ACM-PCA to make local Keystore and Truststore files.

## Testing locally

To run the acm-cert-helper self tests, you will need [tox](https://tox.readthedocs.io/en/latest/) installed:

```
$ pip install tox
$ tox
```

Running `tox` from the root of your git clone will run all the tests.

Note that there is no requirement to have an active ACM or ACM-PCA in your AWS account
for the tests to run; that functionality is stubbed to avoid incurring any
costs when running the tests.

## Installing locally from source.

Running `tox` as above will compile the project. You can also build and install it locally using

```
$ python setup.py build install
```

The installation command above will place two commands in your path, `acm-cert-retriever`  and
`acm-pca-cert-generator`.  Each script takes a number of command line arguments, most of
which are mandatory. Alternatively, the same information can be specified using environment variables.

## Cleaning outputs locally

Running the following will remove all the local files created by tox, in case you need to tidy up:

```
rm -rf build dist .tox
```

## Installing from github:

`pip install acm-cert-helper`

Note that if you only want to dev/test locally, you don't need to run this.

## acm-cert-retriever
`acm-cert-retriever` generates a Java KeyStore containing a keypair and cert it has fetched
from ACM, and a Java TrustStore containing one or more trusted certificates held on S3.

### Pre-Requisites:

The AWS services that call this script need the following permissions:

* `acm-pca:GetCertficate` on the ACM data specified in the `--acm-key-arn` argument
  - e.g. `arn:aws:acm:AWS_Region:AWS_Account:certificate/*`
* `s3:GetObject` on all buckets and objects specified in the `--truststore-certs` argument
  - e.g. `arn:aws:s3:::examplebucket/*`

### Running

The installation command above will place an `acm-cert-retriever` command in
your path.
The script takes a number of command line arguments, most of which are mandatory.
Alternatively, the same information can be specified using environment variables:
The help text is the authoritative source for this:

```
acm-pca-cert-retriever --help
```

If you want to run from a local git clone, rather than installing using `pip`
you can run:

`python ./src/acm_cert_retriever/retriever.py --help`

### Example

The following downloads a fictitious key and cert for the Keystore and adds two CAs from s3 to
the Truststore:

```
acm-cert-retriever \
--acm-cert-arn arn:aws:acm:us-east-1:012345678901:certificate/123a456b-7890-12cd-345e-6f78901f2a34 \
--acm-key-passphrase P4ssw0rd1 \
--keystore-path /tmp/keystore.jks \
--keystore-password P4ssw0rd2 \
--private-key-alias mykey \
--truststore-path /tmp/truststore.jks \
--truststore-password P4ssw0rd3 \
--truststore-aliases ca1,ca2 \
--truststore-certs s3://certbucket/certs/ca_1.pem,s3://certbucket/certs/ca_2.pem
```

## acm-pca-cert-generator
`acm-pca-cert-generator` generates a Java KeyStore containing a keypair signed
by ACM PCA, and a Java TrustStore containing one or more trusted certificates
held on S3.

### Pre-Requisites:

The AWS services that call this script need the following permissions:

* `acm-pca:IssueCertificate` on the ACM PCA specified in the `--ca-arn` argument
  - e.g. `arn:aws:acm-pca:AWS_Region:AWS_Account:certificate-authority/*`
* `acm-pca:GetCertficate` on the ACM PCA specified in the `--ca-arn` argument
  - e.g. `arn:aws:acm-pca:AWS_Region:AWS_Account:certificate-authority/*`
* `s3:GetObject` on all buckets and objects specified in the `--truststore-certs` argument
  - e.g. `arn:aws:s3:::examplebucket/*`

### Running

The installation command above will place an `acm-pca-cert-generator` command in
your path.
The script takes a number of command line arguments, most of which are mandatory.
Alternatively, the same information can be specified using environment variables:
The help text is the authoritative source for this:

```
acm-pca-cert-generator --help
```

If you want to run from a local git clone, rather than installing using `pip`
you can run:

`python ./src/acm_pca_cert_generator/certgen.py --help`

### Example

The following example generates a 2048-bit RSA certificate and has it signed by
an entirely fictitious ACM-PCA:

```
acm-pca-cert-generator \
--key-type RSA \
--key-length 2048 \
--subject-c "GB" \
--subject-st "Greater London" \
--subject-l "London" \
--subject-o "My Company" \
--subject-ou "IT Department" \
--subject-cn "myfqdn.example.com" \
--subject-emailaddress<EMAIL_ADDRESS>\
--ca-arn "arn:aws:acm-pca:us-east-1:012345678901:certificate-authority/123a456b-7890-12cd-345e-6f78901f2a34" \
--signing-algorithm "SHA384WITHRSA" --validity-period=1d \
--keystore-path /tmp/keystore.jks --keystore-password P4ssw0rd1 --private-key-alias mykey \
--truststore-path /tmp/truststore.jks --truststore-password P4ssw0rd2 \
--truststore-aliases ca1,ca2 \
--truststore-certs s3://certbucket/certs/ca_1.pem,s3://certbucket/certs/ca_2.pem
```

In this example, the certificate is being generated via Terraform instead of
via `acm-pca-cert-generator`. It is then retrived and placed in the OS
certificate and key stores only, not in a Java KeyStore:

Terraform:
```
resource "aws_acm_certificate" "tarball_ingestion" {
     certificate_authority_arn = data.terraform_remote_state.certificate_authority.outputs.root_ca.arn
     domain_name               = "${local.tarball_ingestion_name}.${local.env_prefix[local.environment]}dataworks.dwp.gov.uk"

     options {
       certificate_transparency_logging_preference = "DISABLED"
     }

     tags = merge(
       local.common_tags,
       {
         Name = "tarball-ingester-cert"
       },
     )
   }
```

ACM call:

```
ACM_KEY_PASSWORD=$(uuidgen -r)

acm-cert-retriever \
--acm-cert-arn "${acm_cert_arn}" \
--acm-key-passphrase "$ACM_KEY_PASSWORD" \
--private-key-alias "private-key" \
--truststore-aliases "ca1, ca2" \
--truststore-certs s3://certbucket/certs/ca_1.pem,s3://certbucket/certs/ca_2.pem >> /var/log/acm-cert-retriever.log 2>&1
```

The `private-key-alias` can be any string unique to your deployment.

### Container Image

The container image in the same pattern as the standard process.  The entrypoint is designed in such a way that you can pass the required parameters via environemnt variables. eg.
```
environment_variables = jsonencode([
      {
        name  = "LOG_LEVEL",
        value = "DEBUG"
      },
      {
        name  = "ACM_CERT_ARN",
        value = "${data.terraform_remote_state.snapshot_sender.outputs.ss_cert[0].arn}"
      },
      {
        name  = "PRIVATE_KEY_ALIAS",
        value = "${local.environment}"
      },
      {
        name  = "TRUSTSTORE_ALIASES",
        value = "${local.ss_host_truststore_aliases[local.environment]}"
      },
      {
        name  = "TRUSTSTORE_CERTS",
        value = "${local.ss_host_truststore_certs[local.environment]}"
      }
    ])
```

By running the container as a sidecar, and sharing the same mount point, you can use the container image to retrieve certs for your other containers.

```
mount_points = jsonencode([
      {
        "container_path" : "/acm-cert-helper",
        "source_volume" : "certs"
      }
    ])
```
The containers sharing this mount point can install certs from this location.

repository: dwp/acm-pca-cert-generator

gha_language: Python

repo_name: dwp/acm-pca-cert-generator


text:
---
layout: post
title: lesson 58 A spot of bother
categories: 新概念英语3
tags: 新概念
---

* content
{:toc}

USA
<audio id="audio" controls="" preload="none">
<source id="mp3" src="https://www.conceptenglish.cn/x/NCEUSA/3/58－A Spot of Bother.mp3">
</audio>

UK
<audio id="audio" controls="" preload="none">
<source id="mp3" src="https://www.conceptenglish.cn/x/NCEUK/3/58－A Spot of Bother.mp3">
</audio>

```
--- lesson 58 A spot of bother
一点儿小麻烦
--- Listen to the tape then answer the question below.
听录音，然后回答以下问题。
--- What did the old lady find when she got home?

The old lady was glad to be back at the block of flats where she lived.
老妇人回到了她居住的公寓楼，心里很高兴。
Her shopping had tired her and her basket had grown heavier with every step of the way home.
去商店买东西把她搞得筋疲力尽；在回家的路上，她每走一步，就感到手里的篮子又重了一点。
In the lift her thoughts were on lunch and a good rest;
她乘上电梯后，只想着午餐和好好休息一下。
but when she got out at her own floor, both were forgotten in her sudden discovery that her front door was open.
但她到了自己的楼层走出电梯后，就把这两件事忘了个干净，因为她突然发现她家的大门开着。
She was thinking that she must reprimand her home help the next morning for such a monstrous piece of negligence,
她心想明天上午一定要好好训斥那个干家务的帮手，她竟如此疏忽大意。
when she remembered that she had gone shopping after the home help had left and she knew that she had turned both keys in their locks.
但突然记起来了，帮手是在她出去买东西之前走的，她还记得曾用了两把钥匙把大门锁上了。
She walked slowly into the hall and at once noticed that all the room doors were open,
她慢慢地走进前厅，立即发现所有的房门都敞开着，
yet following her regular practice she had shut them before going out.
而她记得在出门买东西前，她按老规矩是把房门一一锁上的。
Looking into the drawing room, she saw a scene of confusion over by her writing desk.
她往起居室里看去，写字台边一片狼籍。
It was as clear as daylight then that burglars had forced an entry during her absence.
事情很清楚，在她外出时，窃贼曾闯进家门。
Her first impulse was to go round all the rooms looking for the thieves,
她第一个条件反射是到各个房间里搜寻一下窃贼，
but then she decided that at her age it might be more prudent to have someone with her,
但转念一想，像她这个年纪，最好是找个人一起去。
so she went to fetch the porter from his basement.
于是她到地下室去找看门的人。
By this time her legs were beginning to tremble, so she sat down and accepted a cup of very strong tea, while he telephoned the police.
这时她两腿累得开始发抖，于是坐了下来，喝了一杯浓茶。与此同时，看门的人给警察挂了电话。
Then, her composure regained, she was ready to set off with the porter's assistance to search for any intruders who might still be lurking in her flat.
此刻老妇人也镇定了下来，准备在看门人的协助下搜寻可能仍躲藏在她房里的窍贼。
They went through the rooms, being careful to touch nothing,
他俩搜遍这每一个房间，小心翼翼地不接触任何东西，
as they did not want to hinder the police in their search for fingerprints.
因为他们怕妨碍警察寻找指纹。
The chaos was inconceivable.
房间里的紊乱状况是无法想像的。
She had lived in the flat for thirty years and was a veritable magpie at hoarding;
老妇人在这套公寓里住了30年，她又是个名副其实的收藏家。
and it seemed as though everything she possessed had been tossed out and turned over and over.
看来她的每一件东西都被翻了出来，并且被里里外外看了遍。
At least sorting out the things she should have discarded years ago was now being made easier for her.
这样一来，她倒是容易将那些几年前就该扔掉的东西找出来了。
Then a police inspector arrived with a constable and she told them of her discovery of the ransacked flat.
过了一会儿，一位巡官带着一名警察来了。她向他们讲述了发现公寓遭劫的经过。
The inspector began to look for fingerprints, while the constable checked that the front door locks had not been forced,
巡官开始搜寻指纹，警察经检查发现大门锁头并无撬过的迹象。
thereby proving that the burglars had either used skeleton keys or entered over the balcony.
由此可以证明，窍贼或者是用了万能钥匙，或者是翻越阳台进来的。
There was no trace of fingerprints,
巡官没有发现指纹，
but the inspector found a dirty red bundle that contained jewellery which the old lady said was not hers.
却发现了一个装有珠宝的、肮脏的红包袱。老妇人说那不是她的。
So their entry into this flat was apparently not the burglars' first job that day and they must have been disturbed.
很明显，闯进这套公寓的窃贼那天并不是首次作案，而且他一定是受了惊吓。
The inspector then asked the old lady to try to check what was missing by the next day and advised her not to stay alone in the flat for a few nights.
巡官请老妇人在次日之前设法查清丢了些什么，并劝她几夜之内不要独自一人在公寓过夜。
The old lady thought he was a fussy creature,
老妇人觉得巡官大惊小怪，
but since the porter agreed with him, she rang up her daughter and asked for her help in what she described as a little spot of bother.
但既然看门人也同意他的意见，她只得打电话向女儿求援，说她碰到了一点儿小麻烦。
```

repository: voaabc/English

repo_name: voaabc/English


text:
---
layout: documentation
title: The Build Time
configuration: true
---

# The Build Time #

The initial step in every Propel project is the "build". During build time, a developer describes the structure of the datamodel in a XML file called the "schema".

From this schema, Propel generates PHP classes, called "model classes", made of object-oriented PHP code optimized for a given RDMBS. The model classes are the primary interface to find and manipulate data in the database in Propel.

The XML schema can also be used to generate SQL code to setup your database.
Alternatively, you can generate the schema from an existing database (see the
[Working with existing databases guide](/documentation/cookbook/working-with-existing-databases.html) for more details).

During build time, a developer also defines the connection settings for communicating with the database.

To illustrate Propel's build abilities, this chapter uses the data structure of a bookstore as an example. It is made of three tables: a `book` table, with a foreign key to two other tables, `author` and `publisher`.

Create a `bookstore` directory then setup Propel into it as covered in the previous
chapter. This will be the root of the bookstore project.

There's actually two ways to setup the build configuration ; the hard one (manually)
and the easy one (through the command line). This chapter explains both. Consider
that the command line approach is just here to simplify the process. You will
learn more about the Propel structure and API setting up your project the hard way.

## The Hard Way ##

### Describing Your Database as XML Schema ###

Propel generates PHP classes based on a _relational_ description of your data
model. This "schema" uses XML to describe tables, columns and relationships. The
schema syntax closely follows the actual structure of the database (you have
to describe any excluded tables inside your
[configuration file](/documentation/reference/configuration-file.html#exclude-tables)).

#### Database Connection Name ####

Create a file called `schema.xml` in the new `bookstore/` directory.

The root tag of the XML schema is the `<database>` tag:

```xml
<?xml version="1.0" encoding="UTF-8"?>
<database name="bookstore" defaultIdMethod="native">
  <!-- table definitions go here -->
</database>
```

The `name` attribute defines the name of the connection that Propel uses for the
tables in this schema. It is not necessarily the name of the actual database. In
fact, Propel uses some configuration properties to link a connection name with real
connection settings (like the database name, user and password).

The `defaultIdMethod` attribute indicates that the tables in this schema use the database's "native" auto-increment/sequence features to handle id columns that are set to auto-increment.

> **Tip** You can define several schemas for a single project. Just make sure
> that each of the schema filenames end with `schema.xml`.

#### Tables And Columns ####

Within the `<database>` tag, Propel expects a `<table>` tag for each table:

```xml
<?xml version="1.0" encoding="UTF-8"?>
<database name="bookstore" defaultIdMethod="native">
  <table name="book" phpName="Book">
    <!-- column and foreign key definitions go here -->
  </table>
  <table name="author" phpName="Author">
    <!-- column and foreign key definitions go here -->
  </table>
  <table name="publisher" phpName="Publisher">
    <!-- column and foreign key definitions go here -->
  </table>
</database>
```

This time, the `name` attributes are the real table names. The `phpName` is the name that Propel will use for the generated PHP class. By default, Propel uses a CamelCase version of the table name as its phpName - that means that you could omit the `phpName` attribute in the example above.

Within each set of `<table>` tags, define the columns that belong to that table:

```xml
<?xml version="1.0" encoding="UTF-8"?>
<database name="bookstore" defaultIdMethod="native">
  <table name="book" phpName="Book">
    <column name="id" type="integer" required="true" primaryKey="true" autoIncrement="true"/>
    <column name="title" type="varchar" size="255" required="true" />
    <column name="isbn" type="varchar" size="24" required="true" phpName="ISBN"/>
    <column name="publisher_id" type="integer" required="true"/>
    <column name="author_id" type="integer" required="true"/>
  </table>
  <table name="author" phpName="Author">
    <column name="id" type="integer" required="true" primaryKey="true" autoIncrement="true"/>
    <column name="first_name" type="varchar" size="128" required="true"/>
    <column name="last_name" type="varchar" size="128" required="true"/>
  </table>
  <table name="publisher" phpName="Publisher">
   <column name="id" type="integer" required="true" primaryKey="true" autoIncrement="true" />
   <column name="name" type="varchar" size="128" required="true" />
  </table>
</database>
```

Each column has a `name` (the one used by the database), and an optional `phpName` attribute. Once again, the Propel default behavior is to use a CamelCase version of the `name` as `phpName` when not specified.

Each column also requires a `type`. The XML schema is database agnostic, so the
column types and attributes are probably not exactly the same as the ones you
use in your own database. But Propel knows how to map the schema types with SQL
types for many database vendors. Check the [schema reference][schema] for more
details on each column type.

As for the other column attributes, `required`, `primaryKey`, and `autoIncrement`, they mean exactly what their names imply.

> **Tip** If you specify a `namespace` attribute in a `<table>` element, the
> generated PHP classes for this table will use this namespace.

#### Foreign Keys ####

A table can have several `<foreign-key>` tags, describing foreign keys to foreign tables. Each `<foreign-key>` tag consists of one or more mappings between a local column and a foreign column.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<database name="bookstore" defaultIdMethod="native">
  <table name="book" phpName="Book">
    <column name="id" type="integer" required="true" primaryKey="true" autoIncrement="true"/>
    <column name="title" type="varchar" size="255" required="true" />
    <column name="isbn" type="varchar" size="24" required="true" phpName="ISBN"/>
    <column name="publisher_id" type="integer" required="true"/>
    <column name="author_id" type="integer" required="true"/>
    <foreign-key foreignTable="publisher" phpName="Publisher" refPhpName="Book">
      <reference local="publisher_id" foreign="id"/>
    </foreign-key>
    <foreign-key foreignTable="author">
      <reference local="author_id" foreign="id"/>
    </foreign-key>
  </table>
  <table name="author" phpName="Author">
    <column name="id" type="integer" required="true" primaryKey="true" autoIncrement="true"/>
    <column name="first_name" type="varchar" size="128" required="true"/>
    <column name="last_name" type="varchar" size="128" required="true"/>
  </table>
  <table name="publisher" phpName="Publisher">
   <column name="id" type="integer" required="true" primaryKey="true" autoIncrement="true" />
   <column name="name" type="varchar" size="128" required="true" />
  </table>
</database>
```

A foreign key represents a relationship. Just like a table or a column, a relationship has a `phpName`. By default, Propel uses the `phpName` of the foreign table as the `phpName` of the relation. The `refPhpName` defines the name of the relation as seen from the foreign table.

There are many more attributes and elements available to describe a datamodel.
Propel's documentation provides a complete [reference of the schema syntax][schema],
together with a [DTD][DTD] and a [XSD][XSD] schema for its validation.

### Building The Model ###

#### Setting Up Configuration ####

The build process is highly customizable. Whether you need the generated classes to inherit one of your classes rather than Propel's base classes, or to enable/disable some methods in the generated classes, pretty much every customization is possible. Of course, Propel provides sensible defaults, so that you actually need to define only two settings for the build process to start: the RDBMS you are going to use, and a name for your project.

Propel expects the configuration to be stored in a file called `propel.ext`, where `.ext` stands for "one of the supported extensions" and stored at the same level as the `schema.xml`, or in a subdirectory named `conf` or `config`. See the [configuration chapter](10-configuration.html) of the documentation, for a detailed description.
Here's a minimal example configuration file for MySQL, for each supported format

propel.yaml

propel.php

propel.json

propel.ini

propel.xml

{% highlight yaml %}
propel:
  database:
      connections:
          bookstore:
              adapter: mysql
              classname: Propel\Runtime\Connection\ConnectionWrapper
              dsn: "mysql:host=localhost;dbname=my_db_name"
              user: my_db_user
              password: s3cr3t
              attributes:
  runtime:
      defaultConnection: bookstore
      connections:
          - bookstore
  generator:
      defaultConnection: bookstore
      connections:
          - bookstore
{% endhighlight %}

{% highlight php %}
<?php

return [
    'propel' => [
        'database' => [
            'connections' => [
                'bookstore' => [
                    'adapter'    => 'mysql',
                    'classname'  => 'Propel\Runtime\Connection\ConnectionWrapper',
                    'dsn'        => 'mysql:host=localhost;dbname=my_db_name',
                    'user'       => 'my_db_user',
                    'password'   => 's3cr3t',
                    'attributes' => []
                ]
            ]
        ],
        'runtime' => [
            'defaultConnection' => 'bookstore',
            'connections' => ['bookstore']
        ],
        'generator' => [
            'defaultConnection' => 'bookstore',
            'connections' => ['bookstore']
        ]
    ]
];
{% endhighlight %}

{% highlight json %}
{
    "propel": {
        "database": {
            "connections": {
                "bookstore": {
                    "adapter": "mysql",
                    "classname": "Propel\Runtime\Connection\ConnectionWrapper",
                    "dsn": "mysql:host=localhost;dbname=my_db_name",
                    "user": "my_db_user",
                    "password": "s3cr3t",
                    "attributes": []
                }
            }
        },
        "runtime": {
            "defaultConnection": "bookstore",
            "connections": ["bookstore"]
        },
        "generator": {
            "defaultConnection": "bookstore",
            "connections": ["bookstore"]
        }
    }
}
{% endhighlight %}

{% highlight ini %}
[propel]
;
; Database section
;
database.connections.bookstore.adapter    = mysql
database.connections.bookstore.classname  = Propel\Runtime\Connection\ConnectionWrapper
database.connections.bookstore.dsn        = mysql:host=localhost;dbname=my_db_name
database.connections.bookstore.user       = my_db_user
database.connections.bookstore.password   = s3cr3t
database.connections.bookstore.attributes =

;
; Runtime section
;
runtime.defaultConnection = bookstore
runtime.connections[0]    = bookstore

;
; Generator section
;
generator.defaultConnection = bookstore
generator.connections[0] = bookstore
{% endhighlight %}

{% highlight xml %}
<?xml version="1.0" encoding="ISO-8859-1" standalone="no"?>
<config>
    <propel>
        <database>
            <connections>
                <connection id="bookstore">
                    <adapter>mysql</adapter>
                    <classname>Propel\Runtime\Connection\ConnectionWrapper</classname>
                    <dsn>mysql:host=localhost;dbname=my_db_name</dsn>
                    <user>my_db_user</user>
                    <password>s3cr3t</password>
                    <attributes></attributes>
                </connection>
            </connections>
        </database>
        <runtime>
            <defaultConnection>bookstore</defaultConnection>
            <connection>bookstore</connection>
        </runtime>
        <generator>
            <defaultConnection>bookstore</defaultConnection>
            <connection>bookstore</connection>
        </generator>
    </propel>
</config>
{% endhighlight %}

Use your own database vendor driver, chosen among pgsql, mysql, sqlite, mssql
and oracle.

You can learn more about the available build settings and their possible values in
the [configuration reference](/documentation/reference/configuration-file.html).

#### Setup UTF-8 ####

If you want to save anything in UTF-8 in your database then depending on your database you have to set some extra configuration values.

MySQL

PostgreSQL

SQLite

MSSQL

Oracle

{% highlight yaml %}
propel:
  database:
    connections:
      default:
        adapter: mysql
        settings:
          charset: utf8mb4
          queries:
            utf8: "SET NAMES utf8mb4 COLLATE utf8mb4_unicode_ci, COLLATION_CONNECTION = utf8mb4_unicode_ci, COLLATION_DATABASE = utf8mb4_unicode_ci, COLLATION_SERVER = utf8mb4_unicode_ci"
{% endhighlight %}

{% highlight yaml %}
propel:
  database:
    connections:
      default:
        adapter: pgsql
        settings:
          charset: utf8
          queries:
            utf8: "SET NAMES 'UTF8'"
{% endhighlight %}

{% highlight yaml %}
propel:
  database:
    connections:
      default:
        adapter: sqlite
        settings:
          charset: utf8
{% endhighlight %}

{% highlight yaml %}
propel:
  database:
    connections:
      default:
        adapter: mssql
        settings:
          charset: UTF-8
{% endhighlight %}

{% highlight yaml %}
propel:
  database:
    connections:
      default:
        adapter: oracle
        settings:
          charset: UTF8
{% endhighlight %}

#### Using the `propel` Script To Build The SQL Code ####

As seen in the previous chapter, Propel ships with a script that allows you to
realize different actions such as schema generation.

Open a terminal inside your project's directory (here `bookstore/`), where you
saved the two previous files (`schema.xml` and `propel.ext`). Then use the `propel`
script to generate the SQL code of your schema:

```bash
$ propel sql:build
```

#### Generate Model Classes ####

Now that your database is ready, we are going to generate our model files. These files are just classes that allows you to interact easily with your different tables. To generate these tables, just run:

```bash
$ propel model:build
```

Propel will generate a new `generated-classes` folder containing all the stuff you need to interact with your different tables.

For every table in the database, Propel creates 3 PHP classes:

* a _model_ class (e.g. `Book`), which represents a row in the database;
* a _tablemap_ class (e.g. `Map\BookTableMap`), offering static constants and methods mostly for compatibility with previous Propel versions;
* a _query_ class (e.g. `BookQuery`), used to operate on a table to retrieve and update rows

Propel uses the `phpName` attribute of each table as the base for the PHP class names.

All these classes are empty, but they inherit from `Base` classes that you will find under the `Base/` directory in the `generated-classes` one:

```php
<?php

/**
 * Skeleton subclass for representing a row from the 'book' table.
 */
class Book extends BaseBook
{

}
```

These empty classes are called _stub_ classes. This is where you will add your own model code. These classes are generated only once by Propel ; on the other hand, the _base_ classes they extend are overwritten every time you call the `model:build` command, and that happens a lot in the course of a project, because the schema evolves with your needs.

Propel also generates one `TableMap` class for each table under the `Map/`
directory. You will probably never use the map classes directly, but Propel needs
them to get metadata information about the table structure at runtime.

> **Tip** Never add any code of your own to the classes generated by Propel in the
> `Map/` directory; this code would be lost next time you call the `model:build`
> command.

Basically, all that means is that despite the fact that Propel generates _five_ classes for each table, you should only care about two of them: the model class and the query class.

> **Warning** After generating the classes, you have to autoload them. For example,
> with composer this can be achieved with:
>
> ```json
> {
>   ...
>   "autoload": {
>     "classmap": ["generated-classes/"]
>   }
> }
> ```
>
> and then executing the command `composer dump-autoload`. See also
> [namespaces recipe](../cookbook/namespaces.html) if you prefer to autoload
> your model classes following PSR-0.

### Runtime Connection Settings ###

The database and PHP classes are now ready to be used. But they don't know yet
how to communicate with each other at runtime. You must tell Propel which database
connection settings should be used to finish the setup.

For performance reasons, Propel prefers to use a PHP version of the connection
settings rather than read it from the configuration file every time. So you must
use the `propel` script one last time to build the PHP version of the runtime
configuration:

```bash
$ propel config:convert
```

The `config:convert` command reads the `runtime` section of the configuration file
and generates the relative PHP script. The resulting file can be found under
`generated-conf/config.php`.

You can now setup Propel with the following script:

```php
<?php

// setup the autoloading
require_once '/path/to/vendor/autoload.php';

// setup Propel
require_once '/generated-conf/config.php';
```

It's also a good practice to add a logger to the service container, so that Propel
can log warnings and errors. You can do so by adding the following code to the
setup script:

```php
<?php

use Monolog\Logger;
use Monolog\Handler\StreamHandler;

$defaultLogger = new Logger('defaultLogger');
$defaultLogger->pushHandler(new StreamHandler('/var/log/propel.log', Logger::WARNING));

$serviceContainer->setLogger('defaultLogger', $defaultLogger);
```

> **Tip** You may wish to write the setup code in a standalone script that is
included at the beginning of your PHP files.

Now you are ready to start using your model classes!

#### Create the Database Schema ####

Now that your project is fully set up, you have to create the generated schema
in your database.

Before inserting it, you should create a database, let's say we want to call it
`bookstore`. If you are using MySQL for instance, just run:

```bash
$ mysqladmin -u root -p create bookstore
```

Then insert the SQL into your database:

```bash
$ propel sql:insert
```

You should normally have your tables created. Propel will also generate a
`generated-sql` folder containning the SQL files of your schema ; useful if you
are using a SCM, you can so compare the different versions of your schema.

Each time you will update your schema, you should run `sql:build` and `sql:insert`.

Depending on which RDBMS you are using, it may be normal to see some errors
(e.g. "unable to DROP...") when you first run this command. This is because some
databases have no way of checking to see whether a database object exists before
attempting to DROP it (MySQL is a notable exception). It is safe to disregard
these errors, and you can always run the script a second time to make sure that
the errors are no longer present.

> **Warning** The `schema.sql` file will DROP any existing table before
creating them, which will effectively erase your database.

## The easy way ##

To ease the setup of your build configuration, Propel ships with an `init` command
that will guide you through this process. Just type, in a terminal:

```bash
$ propel init
```

Propel will ask first for your database driver and then your database credentials.
It will ask you again if it's not able to establish a connection to the database.

Then, Propel will ask you if you want to import an existing database into your
project and where to store the different Propel specific files like the schema.

Finally, you need to specify the format of you configuration file. YAML is a
good default but you can pick the format you want ; the documentation explains
each one.

The command will also output a summary of your current configuration that you can
modify if you want to. Propel is now ready to be used!

---
[Next: Basic CRUD →](03-basic-crud.html)

[schema]: /documentation/reference/schema.html
[DTD]: https://github.com/propelorm/Propel2/blob/master/resources/dtd/database.dtd
[XSD]: https://github.com/propelorm/Propel2/blob/master/resources/xsd/database.xsd

extension: markdown

gha_language: HTML


text:
# phaxio-ios

Send faxes with [Phaxio](http://www.phaxio.com).

## Installation

####Cocoa-Pods
1. If you haven't already, install the latest version of [CocoaPods](https://guides.cocoapods.org/using/getting-started.html)

2. Add this line to your `Podfile`:
```pod 'Phaxio'```

3. Run `pod install`

4. Don't forget to use `.workspace` to open your project in Xcode

####Carthage
1. If you haven't alrady, install the latest version of [Carthage](https://github.com/Carthage/Carthage#installing-carthage)

2. Add this line to your `Cartfile`:
```github "phaxio/phaxio-ios"```

3. Follow the Carthage [installation instructions](https://github.com/Carthage/Carthage#if-youre-building-for-ios-tvos-or-watchos)

####Dynamic Framework
1. Head to our GitHub releases page and download and unzip Phaxio.framework.zip

2. Drag Phaxio.framework to the "Embedded Binaries" section of your Xcode project's "General" settings and be sure to select "Copy items if needed"

3. Head to the "Build Phases" section of your Xcode project settings, and create a new "Run Script Build Phase". Paste the followoing snippet into the text field:
`bash "${BUILT_PRODUCTS_DIR}/${FRAMEWORKS_FOLDER_PATH}/Phaxio.framework/integrate-dynamic-framework.sd"`

####Static Framework
1. Head to our GitHub releases page and download and unzip PhaxioiOS.zip

2. In Xcode, with your project open, click on "File" then "Add files to Project..."

3. Select Phaxio.framework in the directory you just unzipped.

4. Make sure "Copy items if needed" is checked.

5. Click "Add."

6. In Xcode, click on "File", then "Add files to Project...".

7. Select Phaxio.bundle, located within Phaxio.framework.

8. Make sure "Copy items if needed" is checked.

9. Click "Add".

## Setup

Sets the key and secret for Phaxio.
```objective-c

[PhaxioAPI setAPIKey:@"thisisthekey" andSecret:@"thisisthesecret"];

```

## Author

[Nick Schulze](http://twitter.com/nickschulze) ([nschulze16@gmail.com](mailto:nschulze16@gmail.com)).

## License

This project is [UNLICENSED](http://unlicense.org/) and not endorsed by or affiliated with [Phaxio](http://www.phaxio.com).

license: Unlicense


text:
# wasm-typescript-definition

Exports serde-serializable structs and enums to Typescript definitions when used with wasm-bindgen.

```typescript
#[derive(Serialize, TypescriptDefinition)]
enum Enum {
    #[allow(unused)]
    V1 {
        #[serde(rename = "Foo")]
        foo: bool,
    },
    #[allow(unused)]
    V2 {
        #[serde(rename = "Bar")]
        bar: i64,
        #[serde(rename = "Baz")]
        baz: u64,
    },
    #[allow(unused)]
    V3 {
        #[serde(rename = "Quux")]
        quux: String,
    },
}
```

With the patched version of wasm-bindgen that supports typescript_custom_section (TODO), this will output in your `.d.ts` definition file:

```typescript
export type Enum =
    | {"tag": "V1", "fields": { "Foo": boolean, }, }
    | {"tag": "V2", "fields": { "Bar": number, "Baz": number, }, }
    | {"tag": "V3", "fields": { "Quux": string, }, }
    ;
```

## Credit

Forked from [`rust-serde-schema` by @srijs](https://github.com/srijs/rust-serde-schema?files=1).

## License

MIT or Apache-2.0, at your option.

gha_license_id: NOASSERTION


text:
# LiteracyProCodingChallenge

### Initial Project

I have completed all of the aspects of what was required. The one choice I made was making the editor reside on the same page as the listings because that made more sense from a UI perspective. Here are the requirements as given to me.

##### Task #1: Using Laravel(4.2 or higher), create an application to keep track of your favorite bands and albums.

You should create both "Band" and "Album" database tables and models. All database tables should be created via Laravel migrations. Your application should consist of the following pages:

* Band list page - List all bands (HOMEPAGE)
* Album list page - List all albums. Include a "HTML select" field that contains all bands and can be used to filter the current list of Albums by Band.
* On both list pages, each item listed should contain edit and delete links.
* If you click the delete button on an album, the application should delete the album.
* If you click the delete button on a band, the application should delete all albums that belong to that band and then it should delete the band.
* If you click the edit link for any list item you should be taken to an edit page for that item. There you should be able to edit any of the fields on the item.
* Use Lavavel relationships to tie the band model to the album model and the album model to the band model.
* Use Lavavel relationships to display the band name on album detail/edit page.
* Use Lavavel relationships to display the album names for a band on the band detail/edit page.
* For the band create/edit page, “name” should be required.
* For the album create/edit page, you should have to select a band via a select box which should be required. The “name” field should also be required.

Band table should have the following fields:
* name
* start_date
* website
* still_active

Album:
* band_id
* name
* recorded_date
* release_date
* number_of_tracks
* label
* producer
* genre

##### Task 2: Describe what this database would look like it you were to use an entity attribute value(EAV) model.

The way that I would change the database using that model would primarily be in the `albums` table. I would change that to be like the following:

* id
* band_id
* name

Then I would have an `album_attributes` table that would look like this:

* id
* album_id
* attribute
* value

> Notice: I always have a Unique ID as that helps speed up MySQL

Also, I would add a `taxonomy` table for those things that should be defined elsewhere (i.e. Genre, Artist, etc.)

* id
* attribute
* value

As well as I would create an `attributes` table like the following:

* id
* attribute
* type
* ordinal

This allows me to have more control of what the attribute types are, as well as it will allow me to have the display of the form be completely dynamic.

repository: nghtstr/LiteracyProCodingChallenge

repo_name: nghtstr/LiteracyProCodingChallenge


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

### Description

The doc/PdfPage.cpp:609:23 code in PoDoFo 0.9.5 allows remote attackers to cause a denial of service (NULL pointer dereference and application crash) via a crafted PDF document.

### POC

#### Reference
- https://blogs.gentoo.org/ago/2017/03/31/podofo-four-null-pointer-dereference

#### Github
- https://github.com/0xCyberY/CVE-T4PDF
- https://github.com/ARPSyndicate/cvemon
- https://github.com/andir/nixos-issue-db-example
- https://github.com/mudongliang/LinuxFlaw
- https://github.com/oneoy/cve-

repository: trickest/cve

repo_name: trickest/cve


text:
# Peek-a-Moo
Dairy Cow Dashboard for UBC Faculty of Land and Food Systems - Animal Welfare Program

# Dependenices
Run the following command in R to install the dependencies:

`install.packages(
c("tidyverse",
"shiny",
"shinydashboard",
"shinyWidgets",
"shinycssloaders",
"plotly",
"visNetwork",
"lubridate",
"DT",
"here",
"tidygraph",
"memoise",
"png"))`

# Launching the app
From the root directory, run:

`shiny::runApp("dashboard")`

repository: MOO-VIS/Peek-a-Moo

repo_name: MOO-VIS/Peek-a-Moo


text:
# SharePoint 2013: Configure apps to be autohosted in SharePoint Online
## Requires
* Visual Studio 2012
## License
* Apache License, Version 2.0
## Technologies
* C#
* REST
* SharePoint Server 2013
* SharePoint Foundation 2013
* apps for SharePoint
## Topics
* Cloud
* data and storage
## IsPublished
* False
## ModifiedDate
* 2013-03-19 04:26:03
## Description

This sample autohosted app shows how to set values in the AppManifest.xml file and the web.config file to configure an app for SharePoint and a remote ASP.NET web application to be autohosted on a SharePoint Online site with
 an associated Windows Azure Web Site.

It also shows how to use the SharePoint REST APIs to perform Read operations on SharePoint lists and list items, and how to retrieve only selected fields from the list. The app displays all of the items in the Composed Looks
 list of the host web.

The default.aspx page of the app appears after you install and launch the app.

Figure 1. default.aspx page in the app

When the Metro-style button is chosen, a grid displays the items in the
Composed Looks list. Only three columns are shown.

The sample demonstrates how to read data by using the OData protocol from REST endpoints. Additionally, it demonstrates how to parse Atom-formatted XML returned from these endpoints by using the classes of the
System.Xml.Linq namespace. (Other samples of apps for SharePoint show how to do this by using the classes of the
System.Xml namespace.)

For more information about the SharePoint REST APIs, see the topic

Programming using the SharePoint 2013 Preview REST service in the SharePoint 2013 developer documentation. For more information about working with Atom and OData, see
OData: AtomPub Format.

Prerequisites

A SharePoint 2013 development environment that is configured for app isolation and OAuth.

Visual Studio 2012 and SharePoint development tools in Visual Studio 2012.

Web Deploy 2.0 installed on the computer with Visual Studio. The version of Visual
 Studio and its SharePoint tools available for SharePoint 2013 should install this automatically.

Important contents

FirstAutohostedApp project, which contains the AppManifest.xml file.

FirstAutohostedAppWeb project.

Default.aspx file, which contains the HTML and ASP.NET controls for the user interface of the app.

Default.aspx.cs file, which contains the C# code that uses the REST APIs to read data.

TokenHelper.cs file, which is added to the project by Visual Studio and is used to access the OAuth infrastructure.

Web.config, web.debug.config, and web.release,config files. (The web.config file that is packaged with the app is a merger of web.config and either web.debug.config or web.release.config.)

Configuration instructions

Open the FirstAutohostedApp.sln file in Visual Studio 2012. In
Properties pane of Visual Studio, change the Site URL
property of the app for SharePoint project in Visual Studio to the absolute URL of your SharePoint 2013 developer test site. For example, "http://MyDevServer/".

Build instructions

Choose the FirstAutohostedApp project in
Solution Explorer (not the top node for the whole Visual Studio solution). On the menu bar, choose
Publish, Build. (Do not choose the F5 key.)

In the Publish dialog box, choose the
Publish button. The resulting app package file (which has the Windows Azure Web Sites package inside) has an .app extension and is saved in the app.publish subfolder of the bin\Debug folder of the Visual Studio project.

Deploying and testing the sample

Log into SharePoint Online 2013 as a tenant administrator.

2. At the top of the page, choose Admin, SharePoint.

3. On the SharePoint Administration Center page, choose
apps, and then choose Corporate Catalog.

4. On the App Catalog page, choose the upload link.

5.  On the Add a document form, browse to your app for SharePoint package and choose the
OK button. A property form for new items opens.

6. Fill out the form as needed and choose the Save button. The app for SharePoint is saved in the catalog.

7. Browse to any website in the tenancy and choose Site Contents
to open the Site Contents page.

8. Choose Add an App, and on the Your Apps
page, find the app. If there are too many to scroll through, you can enter any part of the app title (First Autohosted App) into the search box.

9. When you find the app, choose the Details link beneath it, and then on the app details page that opens, choose
Add It.

10. You are prompted to grant permissions to the app. Choose Trust It.

11. The Site Contents page opens and the app is listed. For a short time, a message below the title indicates that it is being added. When this message disappears, you can choose the app title to launch the app. (You may need to refresh
 the page to make the message disappears.)

12. Choose the GET THE COMPOSED LOOKS button to display a grid with three fields from the Composed Looks list of the host web.

Change log

First release.

Related content

Open Data Protocol

OData: AtomPub Format

SharePoint 2013 developer documentation topics:

How to: Create a basic autohosted app

Programming using the SharePoint 2013 Beta REST service

Contact info

<a href="mailto:DocThis<EMAIL_ADDRESS>

repository: techbuzzz/Samples-archive-msdn-products

path: /Microsoft Office Developer Documentation Team/SharePoint-2013-Configure-apps-to-be-autohosted-17305/Readme.md

repo_name: techbuzzz/Samples-archive-msdn-products


text:
# Bucket Policy Only Module

This Terraform module allows to set a `Uniform Bucket-level Access` [Organization Policy](https://cloud.google.com/storage/docs/uniform-bucket-level-access). The policy may be applied on organization, folder or project level.

<!-- BEGINNING OF PRE-COMMIT-TERRAFORM DOCS HOOK -->
## Inputs

| Name | Description | Type | Default | Required |
|------|-------------|------|---------|:--------:|
| exclude\_folders | Set of folders to exclude from the policy | `set(string)` | `[]` | no |
| exclude\_projects | Set of projects to exclude from the policy | `set(string)` | `[]` | no |
| folder\_id | The folder id for putting the policy | `string` | `null` | no |
| organization\_id | The organization id for putting the policy | `string` | `null` | no |
| policy\_for | Resource hierarchy node to apply the policy to: can be one of `organization`, `folder`, or `project`. | `string` | n/a | yes |
| project\_id | The project id for putting the policy | `string` | `null` | no |

## Outputs

No output.

<!-- END OF PRE-COMMIT-TERRAFORM DOCS HOOK -->

gha_language: HCL


text:
# ZXing.NET

C# Port of ZXing QRCode encoder/decoder

This repo is a copy of the source code from the 14.0.0 release found here: http://zxingnet.codeplex.com  The readme below is from he info page on that site.

##Project Description

A library which supports decoding and generating of barcodes (like QR Code, PDF 417, EAN, UPC, Aztec, Data Matrix, Codabar) within images.

The project is a port of the java based barcode reader and generator library ZXing.
https://github.com/zxing/zxing

It has been ported by hand with a lot of optimizations and improvements.

The encoder supports the following formats:

UPC-A, EAN-8, EAN-13, Code 39, Code 128, ITF, Codabar, Plessey, MSI, QR Code, PDF-417, Aztec, Data Matrix

### Assemblies are available for the following platforms (on zxingnet.codeplex.com)

.Net 2.0, 3.5 and 4.0

Silverlight 4 and 5

Windows Phone 7.0, 7.1 and 8.0

Windows CE

Windows RT Class Library and Runtime Components (winmd)

Portable Class Library

Unity3D (.Net 2.0 built without System.Drawing reference)

Xamarin.Android (formerly Mono for Android)

The library is available in the download section and as NuGet package, too.

Additional platform support without pre-built binaries

The library can be built for Xamarin.iOS (formerly MonoTouch). The project file and solution is available in the source code repository.

A special version for the .Net Micro Framework can be found in a separate branch in the source code repository.

### The following demo clients are available:

decoder for the command line

encoder for the command line

Windows Forms demo (demonstrates decoding and encoding of static images and from a camera)

Windows Phone demo (demonstrates decoding of static images and from a camera)

Windows Service demo (demonstrates decoding of static images)

Windows Presentation Framework demo (demonstrates decoding of static images)

Windows CE demo (demonstrates decoding of static images)

Windows RT demo (demonstrates decoding of static images)

Windows Store App with HTML5/JS (demonstrates decoding of static images)

Unity3D and Vuforia demo (demonstrates encoding of barcodes and decoding of images from a camera with Unity3D)

Silverlight demo (demonstrates decoding and encoding of static images)

EmguCV demo (demonstrates decoding of images from a camera and uses the EmguCV framework)

AForge demo (demonstrates decoding of images from a camera and uses the AForge framework)

###Thanks

Many thanks to the team of the zxing project for their great work. ZXing.Net would not be possible without your work!
Usage examples

The source code repository includes small examples for Windows Forms, Silverlight and Windows Phone.

small example decoding a barcode inside a bitmap (.Net 2.0/3.5/4.0)
```
// create a barcode reader instance
IBarcodeReader reader = new BarcodeReader();
// load a bitmap
var barcodeBitmap = (Bitmap)Bitmap.LoadFrom("C:\\sample-barcode-image.png");
// detect and decode the barcode inside the bitmap
var result = reader.Decode(barcodeBitmap);
// do something with the result
if (result != null)
{
   txtDecoderType.Text = result.BarcodeFormat.ToString();
   txtDecoderContent.Text = result.Text;
}
```

### Help wanted

All help is welcome!
Feedback

### You use the library?
We would be happy if you give us a short note on the use of the library.

### You found a bug?
Please create a new issue here or start a discussion about it if you are not sure.

You use the library and you are not happy with it?
Write us an email please or start a discussion about your problems with it. We will try to help you.

And you can find me on Twitter: http://twitter.com/micjahn


text:
PNS (Personal note server)
==========================

Before starting the server you have to initialize the database
file. This is done with

```
$ pns -f filename.db -init
```

Next you can import data into the database with

```
$ pns -f filename.db -import input.md
```

And add a user with

```
$ pns -f filename.db -adduser login
```

Later, if you want to export all notes from the database use

```
$ pns -f filename.db -export / -o output.md
```

Or you can export notes matching a filter of the form
`/topic/tag1/.../tagn`, where topic may be `-` for given tags on all
topics.

You can use `-init`, `-import` and `-adduser` (and even `-export`) in
a single command. They are executed in this order.

Then you can start serving HTTP with

```
$ pns -f filename.db -http :8080 -host your.host.domain.name
```

where we (optionally) specify hostname which must be used in the
request, otherwise "404 not found" will be returned (this is a simple
countermeasure against evil crawlers using random IP numbers).

Or better use HTTPS with

```
pns -f test.db -https :8080 -https_cert cert.pem -https_key key.pem -host your.host.domain.name
```

Keyboard navigation
-------------------

PNS can be navigated using keyboard shortcuts.

On the pages with notes the following shortcuts are available

| Key     | Action
|---------|----------------------------------------------------------------------------------------------
| `Alt+n` | select next note (just `n` will work if some note is already selected)
| `Alt+p` | select previous note (just `p` will work if some note is already selected)
| `Alt+l` | switch between tag editing field and current note (just `l` if not in tag editing field)
| `Alt+a` | add new note (just `a` will work if tag editing field is not selected; as "Add note" button)
| `e`     | edit selected note (as "Edit" link)
| `c`     | copy selected note (as "Copy" link)

On the note editing/adding pages the following shortcuts are available

| Key     | Action
|---------|------------------------------------------------------
| `Alt+l` | switch between tag editing field and note text field
| `Alt+q` | quit editing note (as "Cancel" button)
| `Alt+r` | reload preview (as "Preview" button)
| `Alt+s` | submit note (as "Submit" button)

Upgrade database
----------------

### before commit "add two indexes on tags table"

To upgrade database which does not have indices (created before
"add two indexes on tags table" commit) start sqlite with the database
as argument and add indexes with

```
CREATE UNIQUE INDEX tagsIds ON tags (noteid, tagid);
CREATE INDEX tagsTagId ON tags (tagid);
```

You can check the names of defined indexes with sqlite command

```
.indexes
```

### before commit "add full text search"

To upgrade database which does not have full text search table
(created before "add full text search" commit) start sqlite with the
database as argument and add and populate full text index with

```
CREATE VIRTUAL TABLE ftsnotes USING fts4(note);
INSERT INTO ftsnotes(docid, note) SELECT rowid, note FROM notes;
```

repository: lukpank/pns

repo_name: lukpank/pns


text:
# Security Policy

## Supported Windows Versions

| Version | Supported          |
| ------- | ------------------ |
| Windows >=7   | :white_check_mark: |

## Reporting a Vulnerability
1. Open  `Issues` tab [here](https://github.com/EpicMorg/AirtestIDE-chocolatey/issues).
2. Select `CVE Report`.
3. Publish `CVE Report`.
4. Thank you :heart:

repository: EpicMorg/chocolatey

gha_language: PowerShell

repo_name: EpicMorg/chocolatey