text:
# Laravel-Pagebuilder

![Laravel Pagebuilder](img/laravel-pagebuilder.png)

### Docs

-   [Installation](#installation)
-   [Configuration](#configuration)
-   [Migrations](#migrations)
-   [Seeds](#seeds)
-   [Generators](#generators)
-   [Slugs](#slugs)
-   [Fields](#fields)
-   [JS](#js-components)
-   [Laravel compatibility](#laravel-compatibility)

## Installation

#### Install the package

```bash
composer require flobbos/laravel-pagebuilder
```

#### Install pagebuilder

Laravel 5.7+

```bash
php artisan pagebuilder:install
```

This will run all migrations and trigger the seeder for the initial elements
and a language entry

## Configuration

The only thing in the config file is the classes you wish to use with Pagebuilder.

You need to generate a model class first using the built in generator.

```php
'builder_classes' => [
        'page' => App\Page::class,
    ]
```

Set additional classes that are supposed to run in a Pagebuilder controller. You can
generate multiple controllers for multiple resources using the Pagebuilder.

```php
$this->articles->setClass('page');
```

This setting in the generated controller will tell it which resource it needs to
use for generating content.

## Generators

You can generate the controller and views for creating pagebuilder based resources
using the following generator commands:

```php
php artisan pagebuilder:controller ArticleController --route=pagebuilder.pages --views=pagebuilder.pages
```

This will generate a complete resource controller named PageController where the routes
and view calls are replaced with the values above. The views will always be prefixed with
vendor.

```php
php artisan pagebuilder:views pagebuilder.pages --route=pagebuilder.pages
```

Use the corresponding routes that you set with the controller and it will all work magically.

```php
pagebuilder:model Page
```

This will generate a Page model that extends the BasePage model that comes with
the package so all necessary relationships and translation options are included.
This step is necessary to be able to generate content because the BasePage model
should not be used as a resource directly.

## Slugs

The pagebuilder is capable of generating translated URL slugs for you. All you
need to do is uncomment the following line from your generated model:

```php
//protected $slug_field = 'title';
```

This will tell the pagebuilder which field in the translations is supposed to
generate the URL slug. The slug will automatically be regenerated when you change
the named field.

## Fields

There are some basic fields in the settings area for an resource but you are free
to add as many additional fields as needed. These fields will be automatically
saved in the database without further modifications to the DB structure.

## JS Components

To use the pagebuilder you need to install its VueJS counterpart by running:

```bash
npm install @chrisbielak/vue-pagebuilder
```

All the needed documentation can be found here:
[Vue Pagebuilder](https://www.npmjs.com/package/@chrisbielak/vue-pagebuilder "Google's Homepage")

## Laravel compatibility

| Laravel | Crudable |
| :------ | :------- |
| 9.x     | >2.0.0   |
| 8.x     | >1.0.10  |
| 7.x     | >1.0.10  |
| 6.x     | >1.0.3   |
| 5.8     | >1.0.0   |
| 5.7     | >1.0.0   |

license: MIT

repository: Flobbos/laravel-pagebuilder

branch_name: refs/heads/master

extension: md

gha_language: PHP

gha_license_id: MIT

license_type: permissive

repo_name: Flobbos/laravel-pagebuilder


text:
# Details about Reddit Repost Checker

## Governance Model

  * Discuss the governance model of the project you are working on

  xXAligatorXx is the sole owner of the project but allows anyone to contribute. Therefore the goverance model of the project is benevolant dictator/ bazaar.

## Resources available (URLs)

  * Main language used:
    Python3.5+

  * Other technologies used (databases, frameworks, languages):
    * sqlite
    * Dependencies: Praw, Pillow, Dhash, Levenshtein, PyAV

## Resources available (URLs)

  * Homepage: https://github.com/xXAligatorXx/RepostCheckerBot
  * Contribution guide: N/A
  * Issue tracker: https://github.com/xXAligatorXx/RepostCheckerBot/issues
  * Code of conduct: N/A
  * Development wiki: N/A

## Finding an issue to work on

  * Does the project use tags to identify easy tasks?
  * If yes, which tag(s) is(are) used?
  * Good First Issue
  * Hacktoberfest
  * Help Wanted

## Key personnel

  * Do you have any contact in the project? Who?
  * xXAligatorXx

  * Who are the main contributors of the project (find it)?
  * xXAligatorXx

## Communicating with the community

  * What are the communication means available and what are the focus of each? (Forums, mailing lists, issue tracker, IRC, Slack, etc.)
  * Issue Tracker(Main Method)

  * Have you already used any of them?
    * Yes (Issue Tracker)

## Workspace setup

  * Are there tutorials, guidelines or FAQs about setting up the local workspace?
    * Readme outlines setup process

  * Does the community recommend any specific OS or IDE? Which one(s)?
    * No

## Code documentation

   * Is any kind of code documentation available? Where?
   * No

   * Is the architecture documented?
   * No

   * Are there code standards policies/guidelines available? Where?
   * No

## Submitting your contribution

  * Are there guidelines on how to create a submission? Where?
  * No
  * Is there any kind of checklist to follow?
  * No


text:
# crypto-containers
JavaScript library to encrypt plain text or raw data into a crypto container and decrypt crypto container with randomly generated an encryption key. Encryption and decryption derive by reassembling encryption key which was split into shares by [Shamir's Secret Sharing algorithm](http://en.wikipedia.org/wiki/Shamir's_Secret_Sharing).

## What you can do with it?
The crypto-containers library allows you to encrypt and decrypt any information. We use this library in Key2Lyf production as a secure way to split access and storing any sensitive information.

## Usage
To use it in the browser, include cryptoContainers.js or cryptoContainers.min.js in your HTML. You can find them in the `lib/ ` folder.

  ` <script src="cryptoContainers.min.js"></script> `

To build minified file: ` npm run build `

## API
* cryptoContainers.generateKey()
* cryptoContainers.getEncryptionKey()
* cryptoContainers.encryptContainer()
* cryptoContainers.decryptContainer()
* cryptoContainers.encryptionKeyIsValid()
* cryptoContainers.userShareIsValid()
* cryptoContainers.hashData()

See all `Variables description` below.

#### cryptoContainers.generateKey( salt )
Generate a random encryption key with default length 24 symbols. Salt is an optional argument. If salt wasn't provided random salt value will be generated.
The output of `cryptoContainers.generateKey()` is an Object like this:

` {encryptionKeyHash: "6a8e835ed6412428e3bf1347a85d3f37c65777d36fe2ce59f7b082ef85fbe29a",
userHashedShare: "0fc46dc212e5b7d6be1741abf8e2503ca4e712a9db3b51cb29b4ce129db6510c",
k2lShare: "801bfd2ba3b2b38b56e0211c33a9da6d23ffcf338d18868f8b…97425aa1e8212e0d58ec82ac15c59103614520c0f72b2af2b",
userShare: "80260b9ca76f37024dca122ce747b51137e4afb29bf5dd04e7…de8024966198bddee012b54d7b817203328fd18bbe423430a",
salt: "e6d2b914"}`

Each item in the object is a String.

#### cryptoContainers.getEncryptionKey( k2lShare, userShare, action )
Reconstructs the encryption key from `k2lShare` and `userShare` shares. The output is an encryption key, a String.

#### cryptoContainers.encryptContainer( rawData, encryptionKey, action )
Returns an encrypted by the encryption key data.

#### cryptoContainers.decryptContainer(encryptedData, encryptionKey, action)
Uses the encryption key to decrypt encryptedData. Returns rawData.

#### cryptoContainers.encryptionKeyIsValid( encryptionKeyHash, encryptionKey, salt )
Hashes the encryptionKey and compares gotten hash with encryptionKeyHash. Returns true or false.

#### cryptoContainers.userShareIsValid( userShare, userHashedShare, salt )
Hashes the userShare and compares gotten hash with userHashedShare. Returns true or false.

#### cryptoContainers.hashData( data, salt )
Returns hashed data.

## Variables description

Each variable used in the library is described below:
* `encryptionKey`: The key used for encryption and decryption data. Example, "46c75c8b7e68ea07ef43c1ca".
* `encryptionKeyHash`: The hash of the generated encryption key. Example, "40a26f14d7e32968e5a61f530c88b6af1c3db63e0edbd235ff6bf29f33b9795a".
* `k2lShare`: The share which goes to the key2lyf server. The length of this string depends on the length of the encryption key. Example, "801bfd2ba3b2b38b56e0211c33a9da6d23ffcf338d18868f8b1597425aa1e8212e0d58ec82ac15c59103614520c0f72b2af2b".
* `userShare`: The share which goes to the user. The length of this string depends on the length of the encryption key. Example, "80260b9ca76f37024dca122ce747b51137e4afb29bf5dd04e7f1de8024966198bddee012b54d7b817203328fd18bbe423430a".
* `userHashedShare`: The hash  of the userShare. Example, "0fc46dc212e5b7d6be1741abf8e2503ca4e712a9db3b51cb29b4ce129db6510c"
* `action`: js function, is always optional.
* `rawData`: Raw data or plain text for encryption. Example, "Any your sensitive data here. For example, Login: iam.key2lyf, password: dRfi238Pe".
* `encryptedData`: Encrypted data String. Example, "U2FsdGVkX1+WrNdyOv9qqd2rB2tR47au5otU/5Y7tjIQJaurIJN/FK5LJr2R0gmZFbLKxfyc7g6zePNAV+M6C35W1H4caZayE9GlLeHbb7nX5tl9k+KIahrsZPTB+aC3sHoj1oicQTr8x63C7OFEYg=="
* `salt`: Is random generated 8 symbols length String.

## Contributing

Please send pull requests for bug fixes, code optimization, and ideas for improvement.

## License

Code released under [the MIT license](https://github.com/Key2Lyf/crypto-containers/blob/master/LICENSE).

Copyright 2018 Key2Lyf

gha_language: JavaScript


text:
# suitescript/log-args

Enforces correct log arguments (title and details) in all `Log` methods.

## Rule Details

If no options are provided, the rule will require both title and details.

:white_check_mark: The following patterns are **correct**:

```js
/* eslint suitescript/log-args: "error" */

log.debug({ title: 'Title', details: 'Details' });
```
```js
/* eslint suitescript/log-args: "error" */

log.audit('Title', 'Details');
```
```js
/* eslint suitescript/log-args: "error" */

log.error('', 'Details');
```

:x: The following patterns are **incorrect**:

```js
/* eslint suitescript/log-args: "error" */

log.debug('Title');
```
```js
/* eslint suitescript/log-args: "error" */

log.audit({ details: 'Details' });
```

## Rule Options

```js
'suitescript/log-args': [<enabled>, {
  requireTitle: <boolean>,
  requireDetails: <boolean>
}]
```

> **Note**: Setting both options to `false` is the same as not using the rule at all. Setting both options to `true` is the same as not providing options.

### `requireTitle`

_default: true_

Explicitly requires a `title` argument no matter what.

```js
/* eslint suitescript/log-args: ["error", { requireTitle: true }] */

log.debug({ title: 'Title' });
```

### `requireDetails`

_default: true_

Explicitly requires a `details` argument no matter what.

```js
/* eslint suitescript/log-args: ["error", { requireDetails: true }] */

log.debug({ details: 'Details' });
```

## Version

This rule was introduced in version 1.0.0.

## Source

- [Rule source](../../lib/rules/log-args.js)

repository: codacy/codacy-eslint

gha_language: TypeScript

repo_name: codacy/codacy-eslint


text:
# Erocci java-dbus integration

## Prerequisite

* JDK
* Maven
* java D-Bus implementation. It can be installed with:

```sh
$ make deps
```

See "troubleshooting" part below in case of error.

## Quickstart

```sh
$ make run
```

## Project format

`src/main/dbus/` contains the XML file describing the erocci DBus interface.

pom.xml imports the maven-dbus-plugin (to generate a java interface)
and specifies dependencies (to compile).

Note: the maven-dbus-plugin version is the one available online at
maven central (0.1). To compile locally your own version from sources,
set version to 0.2-SNAPSHOT in pom.xml.

## Code generation

```sh
$ mvn clean install
```
The java interface is generated in src/generated/java, then compiled in
target/classes .

## Launch as standalone service (outside Eclipse/IDE)

```sh
$ mvn exec:java -Dexec.mainClass="org.ow2.erocci.backend.BackendDBusService"
```

The dbus service is called "org.ow2.erocci.backend".

See "troubleshooting" part below in case of error.

## Interface with erocci

An erocci-dbus-java.config file is provided (in the project's home directory).
Launch erocci with this file used as configuration; for example, in the erocci directory:

```sh
./start.sh -c ../erocci-dbus-java/erocci-dbus-java.config
```

## Troubleshooting

* "no unix-java in java.library.path"
Generally occurs when you do not use your system's default JDK. To fix it:
Copy libunix-java.so in your JDK's jre/lib/<arch> directory, eg.
sudo cp /usr/lib/jni/libunix-java.so /usr/lib/jvm/jdk1.8.0_45/jre/lib/amd64/

* "Failed to connect to bus unknown address type kernel"

Check the DBUS_SESSION_BUS_ADDRESS environment variable. It is a list of one or more items (separated by semicolons).
The 1st item should start with "unix:". If its starts with "kernel:", remove the 1st item from the list.
Example:
```sh
$ printenv DBUS_SESSION_BUS_ADDRESS
kernel:path=/sys/fs/kdbus/1000-user/bus;unix:path=/run/user/1000/bus
$ export DBUS_SESSION_BUS_ADDRESS=unix:path=/run/user/1000/bus
```

(can also be done using a sed command:
```sh
DBUS_SESSION_BUS_ADDRESS=$(printenv DBUS_SESSION_BUS_ADDRESS | sed -e 's/kernel:.*;//' ).
```

repository: jeanparpaillon/erocci-dbus-java

gha_language: Java

repo_name: jeanparpaillon/erocci-dbus-java


text:
# WordPress Boilerplate

A simplified WordPress theme boilerplate to save your time. I'm using [gulp.js](https://github.com/gulpjs/gulp), [PostCSS](https://github.com/postcss/postcss) and es2015.

With gulp.js, I'm using [gulp-connect](https://github.com/AveVlad/gulp-connect) to create a live server with hot reload to preview the static assets (css/js).

Also, with [gulp-fn](https://github.com/ThierrySpetebroot/gulp-fn) I'm dynamically appending to the compiled css the banner required by Wordpress.

### Dev stuff
```bash
# install dependencies
yarn

# serve with hot reload at localhost:9567
gulp
```

### Disclaimer

This boilerplate was originally created by my buddy [@koganas](https://github.com/koganas) - I just added some utilities.

Feel free to use, improve and share it!

repository: jlozovei/wordpress-boilerplate

repo_name: jlozovei/wordpress-boilerplate


text:
# Bootstrap Node

Includes:
- Node.js chat application code so that you can chat with the Bootstrap node.
- A WebRTC Signaling Server, that is used in the browser example.

**Important!**: If you are running through the example with others, only 1 person should run the Bootstrap Node.

## Run
1. Install the node modules if you have not already done so from the [../nodejs](../nodejs) folder, `npm clean-install`.
1. Run the Bootstrap server, `node index.js`


text:
# Jakarta Bean Validation API

This repository contains the Java Jakarta Bean Validation 3.0 API.

Jakarta Bean Validation defines a metadata model and API for JavaBean and method validation.

You can learn more about it here:
* Official website: <https://beanvalidation.org/>
* Latest draft of the spec: <https://beanvalidation.org/latest-draft/spec/>
* Reference implementation: <https://github.com/hibernate/hibernate-validator/>

## System requirements

JDK 8.

## Licensing

The Jakarta Bean Validation API is provided and distributed under the Apache Software License 2.0.
Refer to [license.txt](https://github.com/eclipse-ee4j/beanvalidation-api/blob/master/license.txt) for more information.

## Build from Source

You can build the Jakarta Bean Validation API from source by cloning the git repository https://github.com/eclipse-ee4j/beanvalidation-api.git.
You will also need a JDK 8 and Maven 3 (>= 3.0.3). With these prerequisites in place you can compile the source via:

    mvn clean install

## Contribute

Want to join us? You can find all the relevant information about contributing to Jakarta Bean Validation on the [website](https://beanvalidation.org/contribute/).

## Continuous Integration

The official Continuous Integration service for the project is hosted on [ci.eclipse.org](https://ci.eclipse.org/bean-validation/).

## Publishing the Schemas
The schema files should be published to the https://github.com/jakartaee/jakarta.ee website repository by following the
procedure described at https://eclipse-ee4j.github.io/jakartaee-platform/publish-xml-schemas. The location for
the schema files in the repsitory is the static/xml/ns/validation directory.

repository: jakartaredhat/beanvalidation-api

gha_license_id: NOASSERTION

repo_name: jakartaredhat/beanvalidation-api


text:
# What publisher is right for you?

Wagtail Live supports various publishers.
Their task is to update the live page every time a post is created.

## Interval polling

Interval polling is Javascript running in the browser, that asks the webserver for updates with a regular interval.
Wagtail Live has a configurable interval, the default is 3 seconds. This value is typically between seconds and a couple of minutes.

Even if there are no new posts, the request is made.
This is server-resource heavy and doesn't scale well.

➕

- Easy to set up
- Normal HTTP protocol

➖

- Can take up to the interval time for a post to appear
- Server resource-heavy
- Does not scale

_Use interval polling on low-traffic websites, and when update delay isn't an issue._

[Set up interval polling](/getting_started/publishers/setup_interval_polling/)

## Long polling

Long polling is a bit like interval polling. The difference is that the server keeps the connection open for the interval time.
This way, there is always an open connection. Updates can be sent the moment they are created. Updates appear instantaneous.

➕

- Easy to set up
- Instant updates
- Normal HTTP protocol

➖

- Server resource-heavy
- Does not scale
- Server can only handle a finite amount of connections

_Use long polling for low-volume sites, evaluation, and demonstration purposes._

[Set up long polling](/getting_started/publishers/setup_long_polling/)

## WebSocket

A [WebSocket](https://datatracker.ietf.org/doc/html/rfc6455) is the better choice. Wagtail Live supports multiple ways to set up a WebSocket.

Traditionally, Python applications (like Django/Wagtail) use the Web Server Gateway Interface ([WSGI](https://wsgi.readthedocs.io/en/latest/index.html)) to communicate between application and server.
HTTP and WSGI are designed to handle a request response cycle. A browser requests an URL, the webserver serves the response. One at the time.
This kind of setup is event based. It only does something when a request comes in, and idles for the rest of the time.

The WebSocket protocol is more advanced, lightweight and server resource friendly.
It allows a persistent connection between server and browser. It is set up once and used for a long time.
Communication is full-duplex. Messages can be sent from server to browser, and the other way around.
This kind of setup runs an event loop and handles messages as they occur.
Note that we talk about messages and not request/response. A message doesn't have a response.
Maybe a message triggers the application to send another message. But, in the meantime, other messages can be sent and received. It is asynchronous.

To use the WebSocket protocol, the server and applications need support asynchronous communications.

➕

- Lightweight on server resources
- Persistent connection
- Instant updates
- Handles many users

➖

- Takes more effort to set up

!!! note
    Websockets are full-duplex. However, Wagtail Live only sends messages to the browser.

### Piesocket

[Piesocket](https://www.piesocket.com/) is software-as-a-service.
Run your Django/Wagtail application like normal. Use Piesocket to handle the WebSocket.

Create an account, set up the credentials, and you are ready to go.

[Set up Piesocket](/getting_started/publishers/setup_piesocket/)

### Django Channels

With [Django Channels](https://channels.readthedocs.io/), you'll have a single application handling both HTTP and WS protocols.

Django Channels runs your application over [ASGI](https://asgi.readthedocs.io) and requires [Daphne](https://github.com/django/daphne).
Daphne is a pure-Python ASGI server, maintained by members of the Django project.

[Set up Django Channels](/getting_started/publishers/setup_django_channels/)

### Starlette

[Starlette](https://www.starlette.io) is a lightweight toolkit for building high-performance WebSocket service.
You need to run a [ASGI](https://asgi.readthedocs.io) server, such as [Uvicorn](https://www.uvicorn.org), [Daphne](https://github.com/django/daphne), or [Hypercorn](https://pgjones.gitlab.io/hypercorn/).

Start both the ASGI server for the Websocket and your Django/Wagtail application.

[Set up Starlette](/getting_started/publishers/setup_starlette/)

### Websockets

[Websockets](https://websockets.readthedocs.io) is a library for building WebSocket server. It is built on top of Asyncio, Python’s standard asynchronous I/O framework.

Start both the Websockets server for the Websocket and your Django/Wagtail application.

[Set up Websockets](/getting_started/publishers/setup_websockets/)

branch_name: refs/heads/main


text:
---
title: Schedule
type: docs
weight: 3
---

**NOTE:** You **MUST** pick up your badge before attending the summit or social evening event.

## Steering AMA

The Summit will start off with an AMA with members of the Kubernetes Steering
Committee.  Bring any and all questions about how we're running the project,
ongoing efforts & issues, and whatever you'd like to discuss with Steering.

## Unconference

The Contributor Summit will be primarily an [Unconference-style event](https://blog.crisp.se/2016/08/30/henrikkniberg/what-is-an-unconference).  This means that
you should arrive with topics in mind, and we will pitch them and vote on them
in the morning, and then hold sessions in the afternoon, after the Steering AMA.
This is the format used at many [DevOps Days](https://devopsdays.org/open-space-format/), and helps us accommodate changing
needs and unpredictable travel schedules.

If you have a topic in mind, please add it to the [GitHub Issue](https://github.com/kubernetes/community/issues/7157).

## Doc Sprint

SIG-Docs will have a full-day Documentation working session during the Summit.
If you contribute to the docs -- and who doesn't -- or you want to learn to
do it better, join them.

## CFP

If you would like to submit a formal session, please use the [CFP Form](https://docs.google.com/forms/d/1z7TnjixN9fiuQulF-EU9rw7_U9I-I8HNOv28IAFsHZc/viewform).
This form will be open through Friday, March 31st, and covers presentation, workshop, and collaboration style sessions.
Unconference sessions should use the GitHub issue referenced above.

## Schedule

{{% schedule
  text="Kubernetes Contributor Summit Europe 2023"
  link="https://kcseu2023.sched.com"
  script="https://kcseu2023.sched.com/js/embed.js"
%}}

repository: chris-short/contributor-site

repo_name: chris-short/contributor-site


text:
Change Log
==========

`[15/08/2012]`

- Fix bug when ajax with `dataType: 'plain'` not to parse as JSON object.

`[03/08/2012]`

- Update Utils.js to add deep object extend function

`[02/08/2012]`

- Recapture device width and height in Como.device upon device change orientation.
- Recalculate tablet definition when orientation change.
- Throw error when loading Models but no definition in config.

`[26/07/12]`

- Move UI Factories config out of UIShortcut.js into UIConfig.js and provide user defined extension to it.

`[25/07/12]`

- Provide addAll method to all UI created with UIShortcut module to add array of child elements into parent elements.

`[23/07/12]`

- Add on method as shortcut for addEventListener with ability of action path aware.
- Restructure UIShortcut for readibility.

`[17/07/12]`

- Move complete sample usage to another project.
- Fix to be able to put model configs as Array of String.

`[16/07/12]`

- Add parameter on extended event assignment method to remove method before add new one.
- Move remote base URL into configuration `/app/config/app.js`.
- Use new backend login script.

`[13/07/12]`

- Restructure baseline code to follow CommonJS pattern.

`[03/07/12]`

- Add download file demo using custom progress bar UI.
- Wrap ajax download/upload callback into ondatatream/onsendstream.
- Add more UI factory on `UIShortcut.js`.

`[02/07/12]`

- Fix to avoid Closure while applying action handler function.
- Move utility Function in `Como/App.js` into `Como/Utils.js`.

`[29/06/12]`

- Add Utility Module in `/lib/Como/Utils.js` to add `HTTPClient` utility.

`[26/06/12]`

- Move tablet form factor to config and Remove unused image folder.

`[25/06/12]`

- Initial Release of Como MVC Framework.

repository: geekzy/tiapp-como

repo_name: geekzy/tiapp-como


text:
# Demo of Glucose uptake and clearance in Alzheimer's disease mouse brain with tauopathy detected by onVDMP MRI

Authors: Lin Chen, Jiadi Xu*

Email<EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS>
Affiliations:
Russell H. Morgan Department of Radiology and Radiological Science, The Johns Hopkins University School of Medicine, Baltimore, MD, USA

Matlab version: <IP_ADDRESS>3654 (R2018a)

This toolbox contains demo for the following paper:

Lin Chen, Zhiliang Wei, Kannie Chan, Jianpan Huang, Xiang Xu, Philip C. Wong, Hanzhang Lu, Peter C. M. van Zijl, Tong Li*, Jiadi Xu*, D-Glucose uptake and clearance in the tauopathy Alzheimer’s disease mouse brain detected by on-resonance variable delay multiple pulse MRI. Journal of Cerebral Blood Flow & Metabolism. https://doi.org/10.1177/0271678X20941264

Welcome your comments and suggestions.

September 09, 2019

repository: LinChenMRI/AD-OnVDMP

repo_name: LinChenMRI/AD-OnVDMP


text:
---
name: Bug report
about: Create a report to help us improve Tink
assignees: 'thaidn, chuckx'

---

**Help us help you**

Please tell us more about
[your Tink deployment](https://docs.google.com/forms/d/1mhHvyNJQgTXFDnqOermB7-BD8GQSyvtFPUAhILRbYcA/edit).

**Describe the bug**

Provide clear and concise description of the bug.

**To Reproduce**

Include buildable code snippets or gists which triggered the bug.

**Expected behavior**

Describe of what you expected to happen.

**Error messages, stack traces, etc.**

If applicable, please include error messages, stack traces or any debugging
information.

**Version information**

 - Language: (e.g., Java, Python, etc.)
 - Version: (e.g., 1.2.0)
 - Environment: (e.g., JDK 8, Python3.7, iPhone 11, Android M, etc.)

**Additional context**

Add any other context about the problem.

repository: thaidn/tink

repo_name: thaidn/tink


text:
# ObjectDetection
* C++/WinRT AI/ML Computer Vision Project for object detection.
* The Project uses Window's AI APIs.
* The pretrained model which is used: (SqueezeNet deep neural network https://en.wikipedia.org/wiki/SqueezeNet).
* Works well with 224 x 224 pictures(max)(Bigger Scale - Worse performance).
* U can use your own pictures to test the model and it's results.
* Define the file path of your picture as a string object in main(), call the ProcessModel function, and .... voilà.
* Fun Pictures for testing included.
* Thumbs up to Microsfost AI Docs and SqueezeNet.
* Microsoft Visual Studio 2019
* C++17 or C++20.
* Windows 10, verison 1903(10.0; Build 18362).

# Update
* URL: https://drive.google.com/drive/folders/1NAIrIPILmOqWhMMrEYtD6xi_NTwDeA54?usp=sharing
* Created, Designed and Deployed a GUI in Qt/C++ to control the Computer Vision Project Above.
* The DeployedMLAppQtGui Folder, contains the deployed .exe with all libraries(tested on windows 10, version described above).
* Contains the code for the GUI at ComputerVisionAndObjectDetection subfolder.
* Contains the code for C++/WinRT AI/ML Computer Vision Project at ML_Object_Detection subfolder.
* The video contained, shows everything u need to handle and use the Project.

repository: AlexanderArgyriou/ObjectDetection

repo_name: AlexanderArgyriou/ObjectDetection


text:
#Musitect
Musitect was a school project with the ideal to create a tool for musicians wanting to write lyrics with chords and other musical abbreviations. It is a project written in Laravel with only server rendered UI. Feel free to contribute anything that would further in the ideal of making a better songwriting tool for musicians

#Setup

```
docker-compose up
```

#Contributing

Feel free to:
- open issues
- make suggestions
- make PRs for features you want!

repository: jasperboyd/Musitect

repo_name: jasperboyd/Musitect


text:
Trac Search
===========

Bring the modernity of Elastic Search to the classical Trac.

Trac is a nice tool, but it search engine is confusing.

![Screenshot](screenshot.png)

Install it
----------

Create a nice virtualenv.

    pip install -r requirements.txt
    python setup.py install

The command line application is named _tracsearch_.

Try it
------

Launch a local elastic.

Configure

    cp tracsearch.ini.sample tracsearch.ini
    vim tracsearch.ini

Index some tickets

    tracsearch ticket

Launch the web application

    tracsearch web

Deploy it
---------

For now, there is no automatic indexation.

### Virtualenv and supervisord

Use supervisord to launch the web application.

Use the source folder as virtualenv folder.

    pip install gunicorn

Edit _/etc/supervisor/conf.d/tracsearch.conf_

    [program:tracsearch]
    user=tracsearch
    command=/opt/tracsearch/bin/gunicorn -b <IP_ADDRESS>:5000 -w 4 tracsearch.web:app
    directory=/opt/tracsearch
    environment=PATH="/opt/tracsearch/bin"

### Sentry

You can use [Sentry](http://www.getsentry.com/) to watch Tracsearch's errors.

Grab your sentry dsn and add it to tracsearch.ini

    [sentry]
<EMAIL_ADDRESS>
You can use Tracseerch without a _sentry_ section in the conf file.

repository: bearstech/tracsearch

repo_name: bearstech/tracsearch


text:
---
layout: post
title: "Dealing with Time Zones using Rails and Postgres"
date: 2014-05-21 20:37
comments: true
published: true
categories: [rails, ruby, time-zones, postgres]
---

In the [last post](/essays/handling-time-zones-in-rails), I layed out what I think are the basic rules for dealing with time zones in a Rails app:

1. Always deal with times and zones in pairs.
2. Do any time calculations in the user's time zone.
3. Interpret times from the user in the user's time zone.

Those are the basics, but they don't cover every situation. In particular, we could add a 4th principle:

* Watch out for the edges of your system.

Every time you exchange time information with an outside system, you must either
1) send time zone info to the external system, or
2) once you receive times back from the system, convert them into the correct zone, or
3) both.
We'll look at a common example of an external system in web applications: the database. In our case, it's Postgres. We'll have to use strategies 1 and 2.

## Writing time zones to Postgres

The [last post](/essays/handling-time-zones-in-rails) showed that Rails will convert times to the `Time.zone` when retrieving them from the database. What about writing them to the database? Take this example from the reminder app, again for the user in Hawaii:

```ruby
Time.zone = ActiveSupport::TimeZone.new('Pacific/Honolulu')

reminder = Reminder.first
reminder.remind_at = Time.zone.parse('2014-06-21 12:30pm')
# => Sat, 21 Jun 2014 12:30:00 HST -10:00

reminder.save
# UPDATE "reminders" SET "remind_at" = '2014-06-21 22:30:00.000000' …

reminder.reload.remind_at
# => Sat, 21 Jun 2014 12:30:00 HST -10:00
```

Notice that when the time is written to the database, it is stored in UTC, but when we reload the reminder and return `remind_at`, Rails converts to HST again. `update_column` also works:

```ruby
reminder.update_column :remind_at, Time.zone.parse('2014-08-21 10:30am')
# UPDATE "reminders" SET "remind_at" = '2014-08-21 20:30:00.000000'

reminder.reload.remind_at
# => Thu, 21 Aug 2014 10:30:00 HST -10:00
```

## Querying times in Postgres

When possible, use ActiveRecord's safe interpolation to build time queries. It will correctly handle the time zones for you.

Let's try to retrieve that reminder that we just updated:

### Safe Interpolation

Safe interpolation works:
```ruby
Reminder.where("remind_at < ?", Time.zone.parse('2014-08-21 12:00pm'))
# Reminder Load (2.4ms)  SELECT "reminders".* FROM "reminders" WHERE (remind_at < '2014-08-21 22:00:00.000000')
# => [#<Reminder id: …>]
```

We query for reminders before 12 noon on August 21. Our reminder is for 10:30am on that day, so it is returned, as we expect.

Remember that times are stored in UTC in the database, so Rails converts your time from HST to UTC when building the SQL query.

### Standard Ruby Interpolation

What happens if we try to interpolate with standard Ruby string interpolation?

```ruby
Reminder.where("remind_at < '#{Time.zone.parse('2014-08-21 12:00pm')}'")
#  Reminder Load (0.5ms)  SELECT "reminders".* FROM "reminders" WHERE (remind_at < '2014-08-21 12:00:00 -1000')
# => []
```

Standard interpolation does not convert the time to UTC, and Postgres doesn't know to interpret it as HST. Postgres runs a query for reminders before 12 Noon UTC, which is 10 hours before 12 Noon HST, the time that we meant.

You should be using safe interpolation anyway. If for some reason you need to use regular string interpolation, you can tell Postgres to interpret the string as a time and zone with the Postgres type `TIMESTAMP WITH TIME ZONE`.

```ruby
Reminder.where("remind_at < TIMESTAMP WITH TIME ZONE '#{Time.zone.parse('2014-08-21 12:00pm')}'")
#  Reminder Load (2.1ms)  SELECT "reminders".* FROM "reminders" WHERE (remind_at < TIMESTAMP WITH TIME ZONE '2014-08-21 12:00:00 -1000')
# => [#<Reminder id: …>]
```

Postgres correctly interprets `'2014-08-21 12:00:00 -1000'` as 12 Noon HST (or 10pm UTC), and returns the correct reminder.

#### Using Postgres' DATE_TRUNC function with Rails

What if we do time calculations **inside the database**? We have to pass the time to the database so that it makes the right calculation. `DATE_TRUNC` is an example that requires us to do this.

Say you want to do a calender view for your reminder app. You want to return a list of days, and a list of the names of the reminders for each day. You want a speedy query, so you will group by day in SQL using Postgres' `DATE_TRUNC` function. How will you group by days in the user's time zone, rather than the database's time zone?

The user in Hawaii has a reminder for 5pm HST, August 21st. You try to your DATE_TRUNC query for reminders that week, and this is what you get:

```
time = Time.zone.parse('2014-08-21 17:00:00')
# => Thu, 21 Aug 2014 17:00:00 HST -10:00

Reminder.create(:remind_at => time, :name => 'Go Running!')

days_with_reminders = Reminder.select("
    ARRAY_AGG(name) AS reminder_names,
    DATE_TRUNC('Day', remind_at) AS reminder_day
  ").
  group('reminder_day')
days_with_reminders.map{|r| [r.reminder_day, r.reminder_names] }
# => [["2014-08-22 00:00:00", ["Go Running!"]]]
```

The reminder is showing up for the 22nd, not the 21st. What happened? In Postgres, the time is stored in 2014-08-22 03:00:00 UTC. When `DATE_TRUNC('Day')` truncates the time values, what we get is '2014-08-22 00:00:00'. We need to convert the time to HST **before** we truncate the time values. For this purpose we can use Postgres' `TIMESTAMPTZ AT TIME ZONE`

```ruby
days_with_reminders = Reminder.select("
    ARRAY_AGG(name) AS reminder_names,
    DATE_TRUNC(
      'Day',
      remind_at::TIMESTAMPTZ AT TIME ZONE '#{Time.zone.now.formatted_offset}'::INTERVAL
    ) AS reminder_day
  ").
  group('reminder_day')
days_with_reminders.map{|r| [r.reminder_day, r.reminder_names] }
# => [["2014-08-21 00:00:00", ["Go Running!"]]]
```

Now the reminder is showing up on the 21st, which is correct for our user in Hawaii. What's going on?

### Digression: TIMESTAMP WITHOUT TIME ZONE

Rails actually uses `TIMESTAMP WITHOUT TIME ZONE` columns in Postgres to store datetimes.

```sql
> rails dbconsole
psql (9.3.2)
Type "help" for help.

reminders_dev=# \d+ reminders
                                                         Table "public.reminders"
   Column   |            Type             |                       Modifiers                        | Storage  | Stats target | Description
------------+-----------------------------+--------------------------------------------------------+----------+--------------+-------------
 id         | integer                     | not null default nextval('reminders_id_seq'::regclass) | plain    |              |
 name       | character varying(255)      |                                                        | extended |              |
 remind_at  | timestamp without time zone |                                                        | plain    |              |
 created_at | timestamp without time zone | not null                                               | plain    |              |
 updated_at | timestamp without time zone | not null                                               | plain    |              |
Indexes:
    "reminders_pkey" PRIMARY KEY, btree (id)
Has OIDs: no
```

Normally, this would not make sense, because a timestamp without a time zone does not make sense. `'2014-05-29 12:00:00'` (without time zone info) could be one of dozens of different times in all the time zones across the globe. There's no way to know what time is meant without the time zone. Rails gets around this by storing everything in UTC. The database column doesn't include time zone information, but the time zone is implicitly UTC.

### Mashing time zone info into Postgres

Back to the example: in order to do our `DATE_TRUNC` calculation, we have to convert the time-zone-less (implicitly UTC) time values to the local time first. We can do this with the Postgres function `TIMESTAMPTZ AT TIME ZONE`. `TIMESTAMPTZ` is the Postgres type for a timestamp with a time zone included. `TIMESTAMPTZ AT TIME ZONE` requires that we tell it which time zone to use:

```sql
// remind_at in UTC
# SELECT remind_at FROM reminders LIMIT 1;
      remind_at
---------------------
 2014-08-22 03:00:00
(1 row)

// remind_at converted to HST
# SELECT remind_at::TIMESTAMPTZ AT TIME ZONE INTERVAL '-10:00'::INTERVAL FROM reminders LIMIT 1;
      timezone
---------------------
 2014-08-21 21:00:00
(1 row)
```

Fortunately, you can pass the time zone as a Postgres `INTERVAL`, which can easily be created in from a string: `'-10:00'::INTERVAL`. Even more luckily, Rails offers `Time.zone.now.formatted_offset` to return the current user's time zone in exactly that format.

```ruby
Time.zone.now.formatted_offset
# => "-10:00"
```

(Potential gotcha: using `Time.zone.formatted_offset`, without the `now`. That always returns the standard offset, even when it is Daylight Savings Time! My tests were off by 1 hour until I figured that one out.)

We interpolate the `formatted_offset` into the SQL query for the solution:

```ruby
days_with_reminders = Reminder.select("
  remind_at::TIMESTAMPTZ AT TIME ZONE INTERVAL '#{Time.zone.now.formatted_offset}'::INTERVAL
  AS remind_at_in_time_zone
")

days_with_reminders.map &:remind_at_in_time_zone
# => [2014-08-21 17:00:00 UTC]
```

Oops. Rails 4 casts values returned in custom `SELECT` clauses, but it doesn't handle timezones in this case. We can get around this inconsistency by getting the raw value, and parsing it ourselves.

```ruby
days_with_reminders.map do |r|
  Time.zone.parse(
    r.attributes_before_type_cast['remind_at_in_time_zone']
  )
end
#=> [Thu, 21 Aug 2014 17:00:00 HST -10:00]
```

We break out `Time.zone.parse`, and Ruby parses it correctly, as a Hawaii time. Does this work with our `DATE_TRUNC` example problem?

```ruby
days_with_reminders = Reminder.select("
    ARRAY_AGG(name) AS reminder_names,
    DATE_TRUNC(
      'Day',
      remind_at::TIMESTAMPTZ AT TIME ZONE '#{Time.zone.now.formatted_offset}'::INTERVAL
    ) AS reminder_day
  ").
  group('reminder_day')

days_with_reminders.map do |r|
  [
    Time.zone.parse(
      r.attributes_before_type_cast['reminder_day']
    ),
    r.reminder_names
  ]
end

#=> [[Thu, 21 Aug 2014 00:00:00 HST -10:00, ["Go Running!"]]]

```

Yup! We get the 21st in HST, which is exactly what we want. We would then call `to_date` and get `Thu, 21 Aug 2014` to indicate that we mean the whole day, and not any specific time. We can now display reminders for the correct day.

## Wrap Up

That's one example of working with time zones in Postgres. Hopefully it gives you a good idea of the problems that arise when using time zones in conjunction with an external system. We got to try both 1) passing time zone info to the external system so that it could do time zone calculations and 2) converting times into the correct zones after they were returned from the external system. The specifics were particular to Postgres, but the types of issues you deal with should be similar for any external system, be that a reporting sytem, queuing, email, whatever.

If you have any questions about Postgres and time zones, or external services and time zones, feel free to email me at the address in the footer.

extension: markdown


text:
# _Hair Salon_

#### _A web app build to manage, edit, and delete stylist and client information using a msql database.  02/24/17_

#### By _**Katharyn Reed**_

## Description

_This web app allows salon owners to add new stylists, view the clients associated with each stylist, and edit or delete client or stylist information. This web app was built to build skills with msql databases and database interaction with Silex._

## Database Setup Commands
* _In the msql shell run the following commmands_
* _CREATE DATABASE hair_salon;_
* _USE hair_salon;_
* _CREATE TABLE stylists(name VARCHAR (255), bio VARCHAR (500), id serial PRIMARY KEY);_
* _CREATE TABLE clients(name VARCHAR (255), stylist_id INT, id serial PRIMARY KEY);_
* _Navigate to localhost:8888/phpmyadmin and click on hair_salon, then operations, then copy the database to a new database named hair_salon_test;_

## Setup/Installation Requirements

* _Clone this repository to your device_
* _Start MAMP or other combination of Apache server and MySQL, and make sure the port is set to localhost:8889_
* _Install composer in the project folder_
* _Navigate to the web folder and start a development server at localhost:8000_
* _Navigate to localhost:8000 in your preferred web browser_

## Known Bugs

_No known bugs_

## Support and contact details

_Please contact Katharyn Reed at<EMAIL_ADDRESS>for questions, support, or suggestions_

## Technologies Used

* _PHP_
* _Twig_
* _Silex_
* _MySQL_
* _Composer_
* _phpUnit_
* _Bootstrap/CSS_

### License

*This software is licensed under the MIT license*

Copyright (c) 2017 **_Katharyn Reed_**


text:
---
title: "Special Circumstances Ltd"
timePeriod: "January 2017 - current"
jobTitle: "Freelancer"
date: 2017-01-01T00:00:00+00:00
---

I founded _Special Circumstances_ to be free to offer the best of the expertise I gathered so far in my career, anywhere, to any firm in the world.

_Special Circumstances_ coaches and supports teams and firms on a wide variety of important tasks that constantly challenge the modern IT industry, like:

- choose right tools and Cloud providers
- _how to migrate from/to the Cloud_ strategies
- _Infrastructure as Code_ setup and refactoring
- extend system automation to free operators from toil
- gather visibility over KPIs through telemetry
- unit + integration + E2E test and code review workflows via Continuous Integration / Continuous Delivery pipelines
- Serverless architectures and dev environment (local and remote) setups
- _SPA_ applications leveraging modern technologies like reactive/responsive web frameworks and JAMStack
- planning and execution of deliverable (_build_) deploys, dataset migrations, middleware major version upgrades, etc.
- _Monolith vs. Micro-services_ strategy analysis
- (virtual) network layout design
- ...and more

Keeping everything secure and usable by both end users _and_ operators is our most dear core value.

repository: shaftoe/curriculum-vitae

gha_language: HTML

repo_name: shaftoe/curriculum-vitae


text:
# CONTRIBUTING

Contributions are always welcome, no matter how large or small.
Before contributing, please read the [code of conduct](CODE_OF_CONDUCT.md).

## COMMITS

This repository follows the [Conventional Commit](https://www.conventionalcommits.org/) structure.

## License

By contributing to Programming Bits, you agree that your contributions will be licensed
under its [MIT license](LICENSE).

repository: programming-bits/blog

repo_name: programming-bits/blog


text:
# Security Policy

## Supported Versions

LibOSDP will support the last 2 [releases](https://github.com/goToMain/libosdp/releases) for security and and bug fixes.

| Version | Supported          |
| ------- | ------------------ |
| <= 1.5  | :x:                |
| 2.0.x   | :white_check_mark: |
| 2.1.x   | :white_check_mark: |
| master  | :white_check_mark: |

## Reporting a Vulnerability

Please end an email to Siddharth Chandrasekaran<EMAIL_ADDRESS>([GPG](https://github.com/sidcha.gpg))

repository: jeanpierrefortune/libosdp

repo_name: jeanpierrefortune/libosdp


text:
# Cinephile
An App that list the upcoming movies based on [The Movie DB](https://www.themoviedb.org)

![](screenshots/image01.jpg)
![](screenshots/image02.jpg)

Third-party libraries used:

- ReactiveUI: MVVM framework based on RFP.

- Xamarin.Froms: I decide to go with forms because it was the faster and simpler aproach here, I could invest much more time in the UI and improve it, but this wasn't my main concern here.

- Reactive Extensios: Set of extensios and classes to alow reactive funcional programming.

- Splat: Service Locator. The best reason why using a Service Locator instead of a IoC can be found in Paul Bets answer [here](http://stackoverflow.com/questions/26898381/reactiveui-view-viewmodel-injection-and-di-in-general)

- FFImageLoading: This library helps to reduce the memory usage of images downsampling them as needed, caching and using just one bitmap in memory when the same image is displayed multiple times.

- Akavache: Akavache will store the requests/reponses and use it as a cache for every request I make. If I repeat a request, he will get in the cache and queue an update

- Refit: It turns your REST API into a live interface. And reduces a lot the amount of code that you need to right to access an API.

- Fusillade: It' used to deduplicate requests, about the excessive amount of open connections and request prioritization.

- Nunit: Library to run the Unit Tests. I usually go with it, because it's supported inside the Xamarin Studio by default.

- Moq: Used to mock a few things, especially because we don' wanna Unit Tests trying to access any kind of network.

repository: PureWeen/Cinephile

repo_name: PureWeen/Cinephile


text:
Static Activity Transition Graph Creation
---------------------------------------------
Modify the following parameter in the wala.properties file as per your system. For example in MacOS X this path may be something
similar:

	java_runtime_dir = /Library/Java/JavaVirtualMachines/jdk1.7.0_25.jdk/Contents/Home/jre/lib

This is actually the path that contains the rt.jar or classes.jar file. This file contains the initial java classes that are loaded
by the JVM when a java program runs.

After that, run

	./apk2satg.sh your_apk.apk

The procedure may take several minutes depending on the size of the apk. The output will be two files,

your_apk.apk.g.xml: This xml file will contain the relation between parent and child activties.
your_apk.apk.g.dot: This dot file is for visualization purpose.


text:
A repo for working with data from [CMS's EHR Incentive Programs Data and Program Reports page.](http://www.cms.gov/Regulations-and-Guidance/Legislation/EHRIncentivePrograms/DataAndReports.html) after a tweet from [@Cascadia](https://twitter.com/cascadia/status/307973508833615873) and subsequent chat through direct messages inspired me to do something with the data.

Screenshot
----------
![Screenshot](public/screenshots/US_Healthcare_Provider_Mashup-2.png "Screenshot")
*Screenshot last updated 9/12/2013 at 12pm EST*

Notes
-----
* Disclaimer front and center on the live site: according to [CMS's EHR Incentive Programs Data and Program Reports page](http://www.cms.gov/Regulations-and-Guidance/Legislation/EHRIncentivePrograms/DataAndReports.html), only hospital-level data on _Medicare_ eligible hospitals (EH) and providers (EP) are available as HITECH "Act does not require CMS to post the names of eligible professionals, eligible hospitals and CAHs that have received Medicaid EHR Incentive Program payments."
* All files in this repo's `data` directory are from [CMS's EHR Incentive Programs Data and Program Reports page](http://www.cms.gov/Regulations-and-Guidance/Legislation/EHRIncentivePrograms/DataAndReports.html). They are included only for convenience to fellow developers looking to get up and running with a copy of the data.
* Using [Data Science Toolkit](http://www.datasciencetoolkit.org/) for geocoding provider addresses but started getting 500 Internal Server Errors when using public DSTK host so I brought up my own instance (m1.medium) on Amazon EC2. If you choose to do the same, edit the `DSTK_HOST` variable in `lib/tasks/geocode.rake`
* *ProvidersPaidByEHRProgram_June2013* data files have been normalized by @geek_nurse and @skram to make them more suitable for database querying
* When geocoding, the address information from the CMS ProvidersPaidByEHRProgram is used, if available. If the provider has not received incentive payments or no address is available, the address from the Hospital General Information data set is used in the geocoding process
* The normalized EP spreadsheet has about 1,300 duplicate NPIs out of 190,000+. This is after the normalization effort.

Procedure
---------
**EH: Providers Paid By EHR Program: September 2013 Eligible Hospitals**

  1. Create a directory for the raw data and later exports:

        mkdir -p public/data/ProvidersPaidByEHRProgram_Sep2013_EH/geojson

  2. Download data file:

        curl http://www.cms.gov/Regulations-and-Guidance/Legislation/EHRIncentivePrograms/Downloads/EH_ProvidersPaidByEHRProgram_Sep2013_FINAL.zip -o public/data/ProvidersPaidByEHRProgram_Sep2013_EH/EH_ProvidersPaidByEHRProgram_Sep2013_FINAL.zip

  3. Unzip data file:

        unzip public/data/ProvidersPaidByEHRProgram_Sep2013_EH/EH_ProvidersPaidByEHRProgram_Sep2013_FINAL.zip -d public/data/ProvidersPaidByEHRProgram_Sep2013_EH/

  4. Import CSV into MongoDB and ensure the fields are properly formatted.

        bundle exec rake hospitals:ingest_latest_payments_csv
        bundle exec rake hospitals:ensure_fields_are_properly_formatted

  5. Bring in additional data from the General Hospital Information and HCAHPS (patient experience) data sets on Socrata:

        bundle exec rake hospitals:ingest_general_info
        bundle exec rake hospitals:ingest_hcahps
        bundle exec rake hospitals:ingest_joint_commission_ids
        bundle exec rake hospitals:ingest_hc_hais
        bundle exec rake hospitals:ingest_hc_hacs
        bundle exec rake hospitals:ingest_ahrq_m
        bundle exec rake hospitals:ingest_ooc
        bundle exec rake hospitals:ingest_cms_form_2552_10

  6. Geocode provider addresses:

        bundle exec rake geocode

  7. Print out a nice little report about hospital counts with different types of data (geo, general info, hcahps):

        bundle exec rake hospitals:simple_report

  8. Export _select_ information to CSV for safe keeping and offline analysis:

        mongoexport --csv -d cms_incentives -c ProvidersPaidByEHRProgram_June2013_EH -o public/data/ProvidersPaidByEHRProgram_June2013_EH/ProvidersPaidByEHRProgram_June2013_EH-normalized-geocodedAndSelectedData.csv -f "PROVIDER NPI,PROVIDER CCN,PROVIDER - ORG NAME,PROVIDER STATE,PROVIDER CITY,PROVIDER  ADDRESS,PROVIDER ZIP 5 CD,PROVIDER ZIP 4 CD,PROVIDER PHONE NUM,PROVIDER PHONE EXT,PROGRAM YEAR 2011,PROGRAM YEAR 2012,PROGRAM YEAR 2013,geo.provider,geo.updated_at,geo.data.types.0,geo.data.geometry.location.lat,geo.data.geometry.location.lng,general.hospital_type,general.hospital_owner,general.emergency_services,general.country_name,hcahps.survey_response_rate_percent,hcahps.number_of_completed_surveys,hcahps.percent_of_patients_who_reported_yes_they_would_definitely_recommend_the_hospital_,jc.org_id,hc_hais"

  9. Create MongoDB indexes:

        bundle exec rake mongodb:mongoid_create_indexes

  10. *If you intend to run the visualization in a production environemnt:*

        # You will want to create a static `.geojson`
        bundle exec ruby app.rb -p 4567 -e development
        curl http://localhost:4567/db/cms_incentives/EH/all.geojson -o public/data/ProvidersPaidByEHRProgram_Sep2013_EH/geojson/all.geojson

        # Refresh the minified static assets
        rm public/static/*
        bundle exec rake assetpack:build

        # Push the code to Heroku or similar
        git push heroku master

        # Send updated mongodb database to MongoHQ or similar
        bundle exec rake mongodb:export_to_mongohq

        # Don't forget to clear AWS Cloudfront caches for static assets and root route.

**EP: Providers Paid By EHR Program: June 2013 Eligible Providers**

  1. Create a directory for the raw data and later exports:

        mkdir -p public/data/ProvidersPaidByEHRProgram_June2013_EP/

  2. Download data file:

        curl http://www.cms.gov/Regulations-and-Guidance/Legislation/EHRIncentivePrograms/Downloads/ProvidersPaidByEHRProgram_June2013_EP.zip -o public/data/ProvidersPaidByEHRProgram_June2013_EP/ProvidersPaidByEHRProgram_June2013_EP.zip

  3. Unzip data file:

        unzip public/data/ProvidersPaidByEHRProgram_June2013_EP/ProvidersPaidByEHRProgram_June2013_EP.zip -d public/data/ProvidersPaidByEHRProgram_June2013_EP/

  4. Import CSV into MongoDB and ensure the fields are properly formatted. _See EH section note for step 4 above. Same applies here, for EPs._

        mongoimport --type csv -d cms_incentives -c ProvidersPaidByEHRProgram_June2013_EP --headerline --file public/data/ProvidersPaidByEHRProgram_June2013_EP/ProvidersPaidByEHRProgram_June2013_EP-normalizedByBrianNorris.csv

        bundle exec rake providers:ensure_fields_are_properly_formatted

  5. Update for latest CSV which includes payment data:
        mkdir -p public/data/ProvidersPaidByEHRProgram_Sep2013_EP/geojson

        curl http://www.cms.gov/Regulations-and-Guidance/Legislation/EHRIncentivePrograms/Downloads/EP_ProvidersPaidByEHRProgram_Sep2013_FINAL.zip -o public/data/ProvidersPaidByEHRProgram_Sep2013_EP/ProvidersPaidByEHRProgram_Sep2013_EP.zip

        unzip public/data/ProvidersPaidByEHRProgram_Sep2013_EP/ProvidersPaidByEHRProgram_Sep2013_EP.zip -d public/data/ProvidersPaidByEHRProgram_Sep2013_EP/

        iconv -f ISO-8859-1 -t UTF-8 public/data/ProvidersPaidByEHRProgram_Sep2013_EP/EP_ProvidersPaidByEHRProgram_Sep2013_FINAL.csv > public/data/ProvidersPaidByEHRProgram_Sep2013_EP/EP_ProvidersPaidByEHRProgram_Sep2013_FINAL-utf8.csv

        bundle exec rake providers:ingest_latest_payments_csv

  5. If you are running in a production environment, export the geojson to flat files (instead of hitting the database) by running the following rake task:

        bundle exec rake providers:output_provider_geojson_by_state


text:
![Crs](https://github.com/fencl/fencl.github.io/raw/master/crs/logomd.svg)

# Crs
A programming language based on ideas and concepts from programming languages like C, C++ and newer languages like Rust or Zig.

## Documentation
[Language documentation](https://fencl.github.io/crs/) - everything about Crs, under construction

## Building
Crs uses [Premake5](https://premake.github.io/) to generate build files .
Clone Crs:
- `git clone https://github.com/fencl/Crs.git`
- `cd Crs`

Build on Windows using Visual Studio 2019:
- `premake5 vs2019`
	- open solution crs_build.sln inside build folder and build solution

Build using make and gcc (msys on Windows):
- `premake5 gmake2`
- `cd build`
- `make config=release_linux_x64` ( debug | release \_ windows | linux \_ x86 | x64 )
	- currently supported configurations
		- windows x64
		- windows x86
		- linux x64
		- linux x86

Executable will be placed inside bin folder in subdirectory tree corresponding to build configuration

## Compile/Run
To run crs program use `crs file -r` where `file` is path to build file and `-r` is argument to tell the compiler to run the program directly
 - There is currently no other option, without this switch, compiler will generate nothing

## Examples
Run `crs ex_helloworld.crs -r` inside examples folder. Other examples are currently `ex_hellofile.crs`, `ex_tuple.crs`, `ex_list.crs`, `ex_trait.crs` and `ex_stdcall.crs`

repository: fencl/Crs

repo_name: fencl/Crs


text:
# Base Box
In order to create a new base box, three files are required:
- metadata.json: name the provider this box is for
- Vagrantfile: some basic settings
- disk.img: installed OS image

## Vagrantfile
The configurations here are used as defaults.
- config.vm.guest: set this to OpenBSD til detection is rock solid
- config.ssh.shell: set this to ksh to override bashism defaults in vagrant(?)

## disk.img
To create such an image, use the VMM base tools like this:
````
vmctl create disk.img -s 2G
doas vmctl start "myvm" -m 1G -L -i 1 -b /bsd.rd -d disk.img -c
````
Run through the installer add doas and HALT the machine
````
echo 'permit nopass keepenv root' > /mnt/etc/doas.conf
halt -p
````
Stop the vm on host
````
doas vmctl stop "myvm"
````

## Box bundling
It's a simple tar archive:
````
tar zcf myvm.box ./metadata.json ./Vagrantfile ./disk.img
````

## Adding the box
````
vagrant box add --provider=openbsd --name=myvm myvm.box
````

repository: double-p/vagrant-openbsd

gha_language: Ruby

repo_name: double-p/vagrant-openbsd


text:
# HTTP Request

This is a simple autoscaler designed to show how to use a HTTP method as part of
a Custom Pod Autoscaler. This example reaches out to the
[random.org](http://random.org/) HTTP API to generate a random integer between 1
and 5 and uses that to decide what value to scale the managed resource to.

## Overview

The metric gathering stage of this autoscaler uses the HTTP method to reach out
to [https://www.random.org/integers/](https://www.random.org/integers/) to
generate a random integer. This HTTP method is defined in `config.yaml`:

```yaml
metric:
  type: "http"
  timeout: 2500
  http:
    method: "GET"
    url: "https://www.random.org/integers/?num=1&min=1&max=5&col=1&base=10&format=plain&rnd=new"
    successCodes:
      - 200
    parameterMode: query
```

This makes a `GET` request to
`https://www.random.org/integers/?num=1&min=1&max=5&col=1&base=10&format=plain&rnd=new`.

This URL has some parameters specific to the `random.org` API:
- `num=1` means return only 1 number.
- `min=1` means minimum value 1.
- `max=5` means maximum value 5.
- `col=1` means return the results in a single column.
- `base=10` means numbers in base 10.

The HTTP request has a timeout of `2500` milliseconds (2.5 seconds), and is only
presumed successful if it recieves a response code of `200`. Additional
information is provided by query parameter, but for this example it is
unimportant and is ignored.

The autoscaler then takes the results of this and feeds it into `evaluator.py`
which wraps it in JSON and returns it back to the autoscaler to scale the
resource being managed.

repository: jthomperoo/custom-pod-autoscaler

gha_language: Go

repo_name: jthomperoo/custom-pod-autoscaler


text:
# Docker_webtest
Some tests using Docker on WAGO Controllers (PFC200 G2, TP600 and edge controllers).
Here is an example of nginx webserver (port 8001) with php5 (with mysqli), MySQL database (port 3306) and MQTT Broker (port 1884 and websockets 9001).

HOW TO:
=======
1. Install Docker: https://github.com/WAGO/docker-ipk
2. Add docker-compose: https://github.com/WAGO/docker-compose
3. Copy all files to the controller (using ftp of ssh client)
4. Connect via SSH (www.putty.org) to the controller and run command *"docker-compose up -d"* in catalog where docker-compose file is.
5. Check http://<controller_ip>:8001


text:
# Chapter 2 - Overview and User Guide

This page is a stub right now.  Please continue to the next chapter or help improve this page by adding a pull request.

User Guide Coming soon ..

## Sign In

A pre requisite to signing in is to have a decentralized identity.  Solid Social does not control your identity, the user if in full control of where it lives, which provider to use.  Advanced users can even use their own homepage.

repository: kustomzone/solid-sample-docs

repo_name: kustomzone/solid-sample-docs


text:
# Release Process

- [Release Process](#release-process)
  - [Major Release Procedure](#major-release-procedure)
    - [Changelog](#changelog)
    - [Release Notes](#release-notes)
    - [Tagging Procedure](#tagging-procedure)
      - [Test building artifacts](#test-building-artifacts)
      - [Installing goreleaser](#installing-goreleaser)
  - [Non-major Release Procedure](#non-major-release-procedure)
  - [Major Release Maintenance](#major-release-maintenance)
  - [Stable Release Policy](#stable-release-policy)

This document outlines the release process for Cosmos Hub (Gaia).

Gaia follows [semantic versioning](https://semver.org), but with the following deviations to account for state-machine and API breaking changes:

- State-machine breaking changes will result in an increase of the major version X (X.y.z).
- Emergency releases & API breaking changes (changes in node interactions e.g. queries) will result in an increase of the minor version Y (x.Y.z | x > 0).
- All other changes will result in an increase of the patch version Z (x.y.Z | x > 0).

**State compatibility**:
It is critical for the patch releases to be state-machine compatible with prior releases in the same minor version.
For example, v9.2.1 must be compatible with v9.2.0.

Minor releases will be handled on a case-by-case basis, but generally should only arise in case of safety or security issues that require a co-ordinated network upgrade without a governance process.

This is to ensure determinism, i.e. that given the same input, the nodes will always produce the same output.
State-incompatibility is allowed for major upgrades because all nodes in the network perform it at the same time.
Therefore, after the upgrade, the nodes continue functioning in a deterministic way.

**Note**: State-machine breaking changes include changes that impact the amount of gas needed to execute a transaction as it results in a different `apphash` after the code is executed.

## Major Release Procedure

A _major release_ is an increment of the first number (eg: `v9.1.0` → `v10.0.0`). Each major release opens a _stable release series_ and receives updates outlined in the [Major Release Maintenance](#major-release-maintenance) section.

**Note**: Generally, PRs should target either `main` or a long-lived feature branch (see [CONTRIBUTING.md](./CONTRIBUTING.md#pull-requests)).
An exception are PRs open via the Github mergify integration (i.e., backported PRs).

* Once the team feels that `main` is _**feature complete**_, we create a `release/vY` branch (going forward known a release branch),
  where `Y` is the version number, with the minor and patch part substituted to `x` (eg: 11.x).
  * Update the [GitHub mergify integration](./.mergify.yml) by adding instructions for automatically backporting commits from `main` to the `release/vY` using the `A:backport/vY` label.
  * **PRs targeting directly a release branch can be merged _only_ when exceptional circumstances arise**.
* In the release branch
  * Create a new version section in the `CHANGELOG.md`
    * All links must point to their respective pull request.
    * The `CHANGELOG.md` must contain only the changes of that specific released version.
      All other changelog entries must be deleted and linked to the `main` branch changelog ([example]([TBA](https://github.com/cosmos/gaia/blob/release/v9.0.x/CHANGELOG.md))).
    * Note: `CHANGELOG.md` should not contain release candidate entries.
  * Create release notes, in `RELEASE_NOTES.md`, highlighting the new features and changes in the version.
    This is needed so the bot knows which entries to add to the release page on GitHub.
  * Additionally verify that the `UPGRADING.md` file is up to date and contains all the necessary information for upgrading to the new version.
* We freeze the release branch from receiving any new features and focus on releasing a release candidate.
  * Finish audits and reviews.
  * Add more tests.
  * Fix bugs as they are discovered.
* After the team feels that the release branch works fine (i.e., has `~90%` chance of reaching mainnet), we cut a release candidate.
  * Create a new annotated git tag for a release candidate in the release branch (follow the [Tagging Procedure](#tagging-procedure)).
  * The release verification on public testnets must pass.
  * When bugs are found, create a PR for `main`, and backport fixes to the release branch.
  * Create new release candidate tags after bugs are fixed.
* After the team feels the release candidate is mainnet ready, create a full release:
  * Update `CHANGELOG.md`.
  * Run `make format` to format the code.
  * Create a new annotated git tag in the release branch (follow the [Tagging Procedure](#tagging-procedure)). This will trigger the automated release process (which will also create the release artifacts).
  * Once the release process completes, modify release notes if needed.

### Changelog

You can obtain the changelog by running:
```bash
git log --oneline --decorate <previous_version>..<current_version>

# example
git log --oneline --decorate v9.0.0..v9.1.0
```

### Release Notes

Release notes will be created using the `RELEASE_NOTES.md` from the release branch.
Once the automated releases process is completed, please add any missing information the the release notes using Github UI.

With every release, the `goreleaser` tool will create a file with all the build artifact checksums and upload it alongside the artifacts.
The file is called `SHA256SUMS-{{.version}}.txt` and contains the following:
```
098b00ed78ca01456c388d7f1f22d09a93927d7a234429681071b45d94730a05  gaiad_0.0.4_windows_arm64.exe
15b2b9146d99426a64c19d219234cd0fa725589c7dc84e9d4dc4d531ccc58bec  gaiad_0.0.4_darwin_amd64
604912ee7800055b0a1ac36ed31021d2161d7404cea8db8776287eb512cd67a9  gaiad_0.0.4_darwin_arm64
76e5ff7751d66807ee85bc5301484d0f0bcc5c90582d4ba1692acefc189392be  gaiad_0.0.4_linux_arm64
bcbca82da2cb2387ad6d24c1f6401b229a9b4752156573327250d37e5cc9bb1c  gaiad_0.0.4_windows_amd64.exe
f39552cbfcfb2b06f1bd66fd324af54ac9ee06625cfa652b71eba1869efe8670  gaiad_0.0.4_linux_amd64
```

### Tagging Procedure

**Important**: _**Always create tags from your local machine**_ since all release tags should be signed and annotated.
Using Github UI will create a `lightweight` tag, so it's possible that `gaiad version` returns a commit hash, instead of a tag.
This is important because most operators build from source, and having incorrect information when you run `make install && gaiad version` raises confusion.

The following steps are the default for tagging a specific branch commit using git on your local machine. Usually, release branches are labeled `release/v*`:

Ensure you have checked out the commit you wish to tag and then do:
```bash
git pull --tags

# test tag creation and releasing using goreleaser
make create-release-dry-run TAG=v11.0.0

# after successful test push the tag
make create-release TAG=v11.0.0
```

To re-create a tag:
```bash
# delete a tag locally
git tag -d v11.0.0

# push the deletion to the remote
git push --delete origin v11.0.0

# redo create-release
make create-release-dry-run TAG=v11.0.0
make create-release TAG=v11.0.0
```

#### Test building artifacts

Before tagging a new version, please test the building releasing artifacts by running:

```bash
TM_VERSION=$(go list -m github.com/tendermint/tendermint | sed 's:.* ::') goreleaser release --snapshot --clean --debug
```

#### Installing goreleaser
Check the instructions for installing goreleaser locally for your platform
* https://goreleaser.com/install/

## Non-major Release Procedure

A minor release_ is an increment of the _point number_ (eg: `v9.0.0 → v9.1.0`, also called _point release_).
A _patch release_ is an increment of the patch number (eg: `v10.0.0` → `v10.0.1`).

**Important**: _**Non-major releases must not break consensus.**_

Updates to the release branch should come from `main` by backporting PRs
(usually done by automatic cherry pick followed by a PRs to the release branch).
The backports must be marked using `backport/Y` label in PR for main.
It is the PR author's responsibility to fix merge conflicts, update changelog entries, and
ensure CI passes. If a PR originates from an external contributor, a member of the stewarding team assumes
responsibility to perform this process instead of the original author.
Lastly, it is the stewarding team's responsibility to ensure that the PR meets all the Stable Release Update (SRU) criteria.

Non-major Release must follow the [Stable Release Policy](#stable-release-policy).

After the release branch has all commits required for the next patch release:

* Update the [changelog](#changelog) and the [release notes](#release-notes).
* Create a new annotated git tag in the release branch (follow the [Tagging Procedure](#tagging-procedure)). This will trigger the automated release process (which will also create the release artifacts).
* Once the release process completes, modify release notes if needed.

## Major Release Maintenance

Major Release series continue to receive bug fixes (released as either a Minor or a Patch Release) until they reach **End Of Life**.
Major Release series is maintained in compliance with the **Stable Release Policy** as described in this document.

**Note**: Not every Major Release is denoted as stable releases.

After two major releases, a supported major release will be transitioned to unsupported and will be deemed EOL with no further updates.
For example, `release/v10.x` is deemed EOL once the network upgrades to `release/v12.x`.

## Stable Release Policy

Once a Gaia release has been completed and published, updates for it are released under certain circumstances
and must follow the [Non-major Release Procedure](#non-major-release-procedure).

The intention of the Stable Release Policy is to ensure that all major release series that are not EOL,
are maintained with the following categories of fixes:

- Tooling improvements (including code formatting, linting, static analysis and updates to testing frameworks)
- Performance enhancements for running archival and synching nodes
- Test and benchmarking suites, ensuring that fixes are sound and there are no performance regressions
- Library updates including point releases for core libraries such as IBC-Go, Cosmos SDK, Tendermint and other dependencies
- General maintenance improvements, that are deemed necessary by the stewarding team, that help align different releases and reduce the workload on the stewarding team
- Security fixes

Issues that are likely excluded, are any issues that impact operating a block producing network.

repository: cosmos/gaia

repo_name: cosmos/gaia


text:
Asserts that an object has its properties defined in sorted order at
all levels.

```javascript
expect({ a: 123, b: 456 }, 'to be canonical');
expect([456, { a: 123 }], 'to be canonical');
```

In case of a failing expectation you get the following output:

```javascript
expect([456, { b: 456, a: 123 }], 'to be canonical');
```

```output
expected [ 456, { b: 456, a: 123 } ] to be canonical
```

repository: snaplytics/unexpected

repo_name: snaplytics/unexpected


text:
# Distributed Version System

While doing research for this project, I ran into [IPFS](https://github.com/ipfs/ipfs), which is nearly identical to the DVS concept. Hats off to @jbenet for stumbling into this concept first and doing a great job so far.

IPFS seems to lack a few features, for which I have filed issues. Because it is much more mature, I suggest using IPFS. Hopefully these features will be supported soon (if they aren't already):

- https://github.com/ipfs/ipfs/issues/68
- https://github.com/ipfs/ipfs/issues/69

I will direct my efforts toward IPFS and applications built on top of it.

- Eric Vicenti

repository: ericvicenti/dvs

repo_name: ericvicenti/dvs


text:
+++
title = "Knife Common Options"
draft = false

gh_repo = "chef-workstation"

aliases = ["/knife_options.html", "/knife_options/"]

[menu]
  [menu.workstation]
    title = "Knife Common Options"
    identifier = "chef_workstation/chef_workstation_tools/knife/knife_options.md Knife Common Options"
    parent = "chef_workstation/chef_workstation_tools/knife"
    weight = 30
+++

The following options can be run with all knife subcommands and
plug-ins:

`-c CONFIG_FILE`, `--config CONFIG_FILE`

: The configuration file to use. For example, when knife is run from a node that is configured to be managed by the Chef Infra Server, this option is used to allow knife to use the same credentials as Chef Infra Client looks when communicating with the Chef Infra Server.

`--chef-zero-host HOST`

: The host to start Chef Infra Zero on. Chef Infra Zero is a lightweight, in-memory Chef Infra Server.

`--chef-zero-port PORT`

: The port (or port range) to start chef-zero on. Port ranges l `1000,1010` or `8889-9999` will try all given ports until one works.

`-d`, `--disable-editing`

: Prevent the \$EDITOR from being opened and accept data as-is.

`--defaults`

: Cause knife to use the default value instead of asking a user to provide one.

`-e EDITOR`, `--editor EDITOR`

: The \$EDITOR that is used for all interactive commands.

`-E ENVIRONMENT`, `--environment ENVIRONMENT`

: The name of the environment. When this option is added to a command, the command will run only against the named environment. This option is ignored during search queries made using the `knife search` subcommand.

`-F FORMAT`, `--format FORMAT`

: The output format: `summary` (default), `text`, `json`, `yaml`,  `pp`.

`-h`, `--help`

: Show help for the command.

`-k KEY`, `--key KEY`

: The USER.pem file that knife uses to sign requests made by the API client to the Chef Infra Server.

`--[no-]color`

: View colored output.

`--[no-]fips`

: Allows OpenSSL to enforce FIPS-validated security during a C Infra Client run.

`--print-after`

: Show data after a destructive operation.

`-s URL`, `--server-url URL`

: The URL of the Chef Infra Server.

`-u USER`, `--user USER`

: The user name used by knife to sign requests made by the API client to the Chef Infra Server. Authentication fails if the user name does not match the private key.

`-v`, `--version`

: The Chef Infra Client version.

`-V`, `--verbose`

: Set for more verbose outputs. Use `-VV` for much more verbose outputs. Use `-VVV` for maximum verbosity, which may provide more information than is actually helpful.

`-y`, `--yes`

: Respond to all confirmation prompts with "Yes".

`-z`, `--local-mode`

: Run Chef Infra Client looks in local mode. This allows all commands that work against the Chef Infra Server to also work against the local chef-repo.

repository: chef/chef-workstation

repo_name: chef/chef-workstation


text:
---
date: 2018-12-28
title: Troubleshooting http/https redirects with authentication
categories:
   - troubleshooting
description: Troubleshooting http/https redirects with authentication
type: Document
---

### Troubleshooting http/https redirects

When setting up TLS encryption for Deck and Gate (the UI and API) for Spinnaker, if you have a load balancer (service, ingress, etc.) in front of your Deck/Gate that are terminating TLS and forwarding communications insecure to the Spinnaker microservices, sometimes the authentication process will redirect to the incorrect path.

For example, if you have LDAP set up and the following flow:

* Client Browser `--HTTPS-->` AWS ELB `--HTTP-->` Deck/Gate

Then you'll likely get two invalid redirects - one to your gate address on HTTP and one on your deck address on HTTP.  This is regardless of your `override-base-url` settings.

One option to try is to add/create `.hal/<deployment-name>/profiles/gate-local.yml`:

```yml
server:
  tomcat:
    protocolHeader: X-Forwarded-Proto
    remoteIpHeader: X-Forwarded-For
    internalProxies: .*
    httpsServerPort: X-Forwarded-Port
```

(Then run `hal deploy apply`, and clear / update your cache).

Alternately, you can do the following:

There are a number of ongoing projects to improve this behavior (for example, when working with OAuth2.0, you can specify a `preEstablishedRedirectUri` via the `--pre-established-redirect-uri` flag).

In the interim, you can work around this issue by putting a self-signed certificate on Deck and Gate.  This requires two steps:

1. Create self-signed certificates for Deck (in `pem` format) and Gate (in `jks` format), and configure them to use them.  You can follow the official documentation for this [here](https://www.spinnaker.io/setup/security/authentication/ssl/).
1. Configure your load balancer to communicate with your backend with HTTPS rather than HTTP.  The method of achieving this will depend on your load balancer configuration.
    * For example, with an ALB ingress controller, you'll want these additional annotations in your ingress configuration:
        ```yaml
        metadata:
          annotations:
            alb.ingress.kubernetes.io/backend-protocol: "HTTPS"
            alb.ingress.kubernetes.io/healthcheck-protocol: "HTTPS"
        ```

repository: armory/knowledge-base

repo_name: armory/knowledge-base


text:
Given an integer  `n`, find the number of trailing zeros in the decimal representation of  `n!`  (the exclamation mark means  factorial).

Example

For  `n = 10`, the output should be
`factorialTrailingZeros(n) = 2`.
`10! = 3628800`, it has  `2`  trailing zeros.

Input/Output

-   **[execution time limit] 4 seconds (js)**

-   **[input] integer n**

    _Guaranteed constraints:_
    `10 ≤ n ≤ 35`.

-   **[output] integer**

repository: M-Ekrim/codeSignal

repo_name: M-Ekrim/codeSignal


text:
# Generate a custom form

## Description

Generate a custom form based extension for Refinery automatically. It works very similarly to the Refinery Engine generator.

The first string attribute should always be the one which is the title or name field in your model.

There must be at least one attribute.

## Additional Supported Field Types

All field types that are supported by the Refinery Engine generator are
supported with the addition of these form specific ones:

* radio - creates a set of radio buttons based off `Model::FIELD_NAMES`
* checkbox - creates a checkbox for `true`/`false` values.
* select - creates a select list with options using `Model::FIELD_NAMES`

Example:

```shell
$ rails generate refinery:form job_inquiry name:string message:text job_type:radio brochure:checkbox qualification:select
```

url: https://raw.githubusercontent.com/refinery/refinerycms/04f07c1e661dae7a0501d075e104a52fce4b71b1/doc/guides/4 - Refinery Extensions/6 - Generate a custom form.md

repository: refinery/refinerycms

filename: 6 - Generate a custom form.md

repo_name: refinery/refinerycms


text:
# LightWeightHOG #

A fast HOG feature extractor is implemented in this [repo](https://github.com/joshua19881228/LightWeightHOG). This code for extracting HOG features in images is a naive implementation based on the work of [The Fastest Deformable Part Model for Object Detection](http://www.cv-foundation.org/openaccess/content_cvpr_2014/papers/Yan_The_Fastest_Deformable_2014_CVPR_paper.pdf), which is published in CVPR2014. Note that only the feature extraction part is implemented.

It was every interesting that I wrote this HOG extractor on a Saturday in 2014. My roomate went to his company and locked me home. I could not open the door, having nothing to do. Then I thought why not implementing this fast HOG extractor. So here it is.

| Input | Output |
| ----- | ------ |
| ![input](https://raw.githubusercontent.com/joshua19881228/LightWeightHOG/master/test.jpg "Input") | ![output](https://raw.githubusercontent.com/joshua19881228/LightWeightHOG/master/test_hog.png "Output") |

## Reference ##

Yan, Junjie, et al. "The Fastest Deformable Part Model for Object Detection." IEEE Conference on Computer Vision and Pattern Recognition IEEE, 2014:2497-2504.


text:
# Delani Studio
This is a project that entails of a website for the Delani studio  that is a group of software developers  and it shows different things i.e about them ,services they offer ,what they do, and also how you can contact them.

Below is a screenshot of how it looks;
![](images/studio.jpg)

##Author

Joseck Osugo-A junior software developer

##contributors

Joseck Osugo

##installation and setup instructions

First you need to access the git-hub then add the following link and fork it https://github.com/Osugo38/delani.git to run the project ,no additional settings are needed just

##Technology  Used

Different languages were used in the same as stated below:
.html
.CSS
.JavaScript
.bootstrap
.jQuery

##contact information

You can email me at<EMAIL_ADDRESS>tel :0726526801

##license and copyright
This project is licensed under the MIT License and its attached below

MIT License

Copyright (c) 2019 Osugo38

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

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

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


text:
# Hangfire Service
A sample solution to demonstrate how to employ Hangfire within a windows service. Keep in mind this is not an in-depth exploration of Hangfire itself, but should provide an example of how to get up and running quickly.

### Packages
* [Topshelf](http://topshelf-project.com/)
* [Hangfire](http://hangfire.io/)

### Install

To install the windows service after building the solution, navigate to the output directory and execute the following:

`HangfireService.exe install`

### Uninstall

To uninstall the windows service, navigate to the output directory and execute the following:

`HangfireService.exe uninstall`

repository: ubercellogeek/hangfire-service

repo_name: ubercellogeek/hangfire-service


text:
To install the converter do the following

1. `$cd ./src`
2. `make depend tags all`
3. Add .../src/con3d++ to your PATH variable

You may wish to modify the compile flags for production use. This may
be done at the command line by adding, e.g., 'CFLAGS="-g -O3 -Wall"'
to the 'make' command.

See `con3d++ -h` and other documentation for information on how to run
the code.


text:
## Micrometer website source [![CircleCI](https://circleci.com/gh/micrometer-metrics/micrometer-docs.svg?style=svg)](https://circleci.com/gh/micrometer-metrics/micrometer-docs)

This repo is the source code for [micrometer.io](https://micrometer.io).

This project was bootstrapped with [Create React App](https://github.com/facebookincubator/create-react-app).

To check changes to this repository locally use `yarn start` for development mode. To run the build use `yarn build`. Note that you need to run `yarn` or `yarn install` first to install all the dependencies defined in `package.json`.

To upgrade project dependencies, run `yarn upgrade` which will update the `yarn.lock` file based on the defined version ranges and transitive dependencies from `package.json`.

-------------------------------------
_Licensed under [Apache Software License 2.0](https://www.apache.org/licenses/LICENSE-2.0)_

_Sponsored by [Pivotal](https://pivotal.io)_

repository: rieske/micrometer-docs

repo_name: rieske/micrometer-docs


text:
---
layout : default
title : Uncomplicated Firewall configuration and Setup
---

# Uncomplicated Firewall on digital-Ocean

If you're looking to get started securing your network, and you're not sure which tool to use, UFW may be the right choice for you.

Let's start by checking if is it really installed by default, before you can get to configure it.

How to do that ?Go to:point_right:  [step1](/24-checkIfInstalledByDefault.html).

repository: codex-academy/DigitalOceanServerSetup

branch_name: refs/heads/gh-pages

repo_name: codex-academy/DigitalOceanServerSetup


text:
# Specification
## Goals
1. Create ordering of given rows of DB table and save it the same table.
2. Ordering is made by Drug and Drop technology.

## Workflow
1. Parent page has set of rows.
2. Row has column order (or other with the same sense).
3. Parent page has button "Order".
4. After clicking on button "Order" page "Ordering" is open (child page).
5. Making of ordering.
6. Child page has button "Save and back".
7. Click on the button "Save and back" leads to parent page.

## Config
* Column name of "order" column
* DB table name
* Array of columns that are shown in the child page
* Title of "Save and back" button.

## Using
Parent page has button "Order" with href
````
/ordering/config_name
````

repository: vadiasov/ordering

repo_name: vadiasov/ordering


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

### Description

An issue was discovered in Titan SpamTitan 7.07. Improper validation of the parameter fname on the page certs-x.php would allow an attacker to execute remote code on the target server. The user has to be authenticated before interacting with this page.

### POC

#### Reference
- http://packetstormsecurity.com/files/159218/SpamTitan-7.07-Remote-Code-Execution.html
- https://sensepost.com/blog/2020/clash-of-the-spamtitan/

#### Github
- https://github.com/ARPSyndicate/cvemon
- https://github.com/sensepost/ClashofSpamTitan

repository: trickest/cve

repo_name: trickest/cve


text:
## Actions

Sometimes complex work flows are required, especially when `date` parts are involved. Those fields come from an external source (the system clock), and their updated status is thus unpredictable. You can obviously say at each execution if the field will be updated or not, but the link between the command line options and the updates performed by Punch is in general not evident.

Consider a configuration like the following

``` python
__config_version__ = 1

GLOBALS = {
    'serializer': '{{year}}.{{build}}',
}

FILES = ["README.md"]

VERSION = [
    {
        'name': 'year',
        'type': 'date',
        'fmt': '%Y'
    },
    'build'
]
```

This captures a situation where `build`, which is hierarchically lower than `year`, is reset when `year` changes.

During the year the command issued by the user is `punch --part build`, which updates `build` and leaves `year` untouched, creating versions like `2019.0`, `2019.1`, and so on.

On the 1st of January of the new year, the command has to be `punch --part year`, otherwise the `year` part doesn't get modified, and `part` doesn't get reset. If we run this last command during the year, however, doesn't solve the issue, as `year` doesn't change, and `build` is not incremented. As mentioned before, this happens because date version parts are updated from an external source, which is unpredictable.

Punch allows to define actions, that is specific work flows that cannot be captured by the standard syntax. The only possible action type at the moment is `conditional_reset`.

Actions are defined by an `ACTIONS` dictionary in the configuration file, with the following syntax

``` python
ACTIONS = {
    'my_action_name': {
        'type': 'action_type',
        # ...
    }
}
```

where `my_action_name` is a free name that represents the action in your specific setup and `action_type` can only be `conditional_reset` at the moment. The dictionary can contain other keys required or supported by the specific action type.

### Conditional reset

``` python
GLOBALS = {
    'serializer': '{{year}}.{{month}}-{{build}}',
}

FILES = ["README.md"]

VERSION = [
    {
        'name': 'year',
        'type': 'date',
        'fmt': '%Y'
    },
    {
        'name': 'month',
        'type': 'date',
        'fmt': '%m'
    },
    'build'
]
ACTIONS = {
    'mbuild': {
        'type': 'conditional_reset',
        'field': 'build',
        'update_fields': ['year', 'month']
    }
}
```

The `conditional_reset` action work flow is the following

1. Update all the fields listed in `update_fields`.
2. If the full version changed, reset `field`. Otherwise just increment it.

So for the above configuration if the current version is `2017.01-4` on 31 January 2017 the command `punch --action mbuild` creates version `2017.01-5` (`year` and `month` do not change, so `build` is incremented), while on the 01 February 2017 it will create version `2017.02-0` (`month` changed and with it the full version, so `build` is reset).

## Release notes

Punch can check if your release notes are in sync with the version that will be created or not. If this option is enabled, Punch requires the release notes files to already contain the entry before the version is created. This was decided to avoid interrupting the flow, requiring a double execution of Punch, and generally making the work flow more complex (not to mention error management).

You can specify the `RELEASE_NOTES` **list** in the configuration file, each entry of which is a tuple with a file name and a regular expression. The regular expression can (and probably should) mention one of the serializers.

When Punch runs, it renders the regular expression string as a Jinja template, using the new version as rendered by the named serializer. Then it scans the associated file, looking for matches. If there are no matches, Punch exits with an error.

Example:

``` python
__config_version__ = 1

GLOBALS = {
    'serializer': {
        'semver': '{{major}}.{{minor}}.{{patch}}',
    }
}

FILES = ["README.md"]

VERSION = ['major', 'minor', 'patch']

RELEASE_NOTES = [
    ('HISTORY.rst', r'^{{semver}} \\(')
]
```

In this example, if the new version returned by the `'semver'` serializer is `'2.0.0'`, Punch scans the `HISTORY.rst` file with the `r'^2.0.0 \\(` regular expression. If that file' content is something like

```
=======
History
=======

1.0.0 (1980-01-01)
------------------

* Initial version

2.0.0 (1980-01-01)
------------------

* Second version
```

Punch finds a match and continues, otherwise it interrupts the process before applying any change.

Another way to manage release notes is to replace a fixed string that you already have in the release notes file, as described by the example in the Complex serializers section below.

## Complex serializers

Punch assumes that each serializer represents both the search and the replacement patterns, filling the given template respectively with the old and the new version. Sometimes this is not true, so you can express more complex configurations with this syntax

``` python
GLOBALS = {
    'serializer': {
        'semver': {
            'search': 'Next Release',
            'replace': '{{major}}.{{minor}}.{{patch}}'
        }
    },
}
```

Where `search` is the pattern used to find the old version and `replace` is the pattern used to replace it. In this example the `search` pattern is a fixed string, but can use the usual Jinja2 syntax with the version fields. Complex serializers are supported in the configuration of single files as well

``` python
GLOBALS = {
    'serializer': '{{major}}.{{minor}}.{{patch}}',
}

FILES = [
    {
        'path': "CHANGELOG.rst",
        'serializer': {
            'semver': {
                'search': 'Next Release',
                'replace': '{{major}}.{{minor}}.{{patch}}'
            },
        }
    }
]
```

license: ISC

repository: vovanbo/punch

repo_name: vovanbo/punch


text:
---
sidebar_position: 3
title: webpackFinal
---
# `webpackFinal`: `function|undefined`
The `@js-widgets/webpack-cli` comes with a [default webpack
configuration](https://github.com/js-widgets/webpack-cli/blob/main/src/defaultConfig/webpack.config.js). This function
takes this defaults and applies modifications to it suited for this particular project.

Every project will use different webpack configurations because it will use different technologies. The good news is
that it is likely that your component library (Storybook, Fractal, ...) will already have this function in order to
render the components in the library. You should leverage it!

In particular Storybook [uses the same function](https://storybook.js.org/docs/react/configure/webpack#extending-storybooks-webpack-config)!

Running the CLI in debug mode will print the composed webpack configuration. You can use that to see how to make the
necessary changes.

## Examples

```js
(config) => {
  config.module.rules[2].use.options.presets.push('@babel/preset-react');
  return config;
}
```

repository: KeyboardCowboy/webpack-cli

repo_name: KeyboardCowboy/webpack-cli


text:
# Lab 02 Report - Introduction to Git

## Part 1:
Part 1 Link: https://github.com/dchau2017/lab2part1

GitK Screenshot:
![GitK Screenshot](./gitk.png?raw=true)

Git Log Screenshot:
![Git Log Screenshot](./git_log_capture.PNG?raw=true)

## Part 2:
Forked Repo: https://github.com/dchau2017/Spoon-Knife

Learn Git Branching:
![Git Branching Capture](./introSequence.PNG?raw=true)

## Part 3:
Pull Req Forked Repo: https://github.com/dchau2017/PullReq

Git Diff Screenshot:
![Git Diff Screenshot](./gitdiff.PNG?raw=true)

Git Tag Screenshot:
![Git Tag Screenshot](./gittag.PNG?raw=true)

OSS Project Ideas Forked Repo: https://github.com/dchau2017/OSSProjectIdeas


text:
# Changelog

## v0.8.0

* New features
  * Add a WiFi signal strength polling feature. This works when connected to a
    WiFi access point.
  * Support vintage_net v0.8.0's `required_ifnames` API update

## v0.7.0

Initial `vintage_net_wifi` release. See the [`vintage_net v0.7.0` release
notes](https://github.com/nerves-networking/vintage_net/releases/tag/v0.7.0)
for upgrade instructions if you are a `vintage_net v0.6.x` user.