text:
### Summary
  This enhancement provides the ability to centrally manage configuration files. By
  defining in a centralized management file called `values.json` or `values.yaml`
  or `values.yml`. Values located in different config file can be selectively
  override with any value (Including environment variables by pattern). As the result,
  There would be no necessary to change previous code when config value need to be
  changed.

  * Enable Flag

    Please define `true` or `false` for `enable_centralized_management` in commend line in
    order to enable this enhancement. The default status is `true` without setting.

  * Unique key

    In order to let centralized management work properly. each key can only appear once in
    one config file.

### Motivation

### Guide-level explanation
* Feature

  This enhancement support overriding Stirng, List, and Map, regardless nested in List or Map.

  * Override String

    String can be overrided with any String, List or Map, including environment variables
    by pattern.

  * Override List

    List can be overrided with any String, List or Map, including environment variables
    by pattern.

  * Override Map

    Map can be overrided with any String, List or Map, including environment variables
    by pattern.

* Example

  Suppose we need to change the port value and database password in the `server.yaml`
  and `service.yaml` respectively. Such `values.yaml` can be defined.

  * values.yaml
  ```
    server:
      port:8080
    service:
      password: mysql

  ```

  * server.yaml
  ```
    port: 4563
  ```

  * service.yaml
  ```
    singletons:
    - javax.sql.DataSource:
      - com.zaxxer.hikari.HikariDataSource:
          DriverClassName: oracle.jdbc.pool.OracleDataSource
          jdbcUrl: jdbc:oracle:thin:@localhost:1521:XE
          username: SYSTEM
          password: oracle
          maximumPoolSize: 10
          useServerPrepStmts: true
          cachePrepStmts: true
          cacheCallableStmts: true
          prepStmtCacheSize: 10
          prepStmtCacheSqlLimit: 2048
          connectionTimeout: 2000
  ```

  * Result
  ```
    // server.yaml
    port: 8080

    // service.yaml
    singletons:
    - javax.sql.DataSource:
      - com.zaxxer.hikari.HikariDataSource:
          DriverClassName: oracle.jdbc.pool.OracleDataSource
          jdbcUrl: jdbc:oracle:thin:@localhost:1521:XE
          username: SYSTEM
          password: mysql
          maximumPoolSize: 10
          useServerPrepStmts: true
          cachePrepStmts: true
          cacheCallableStmts: true
          prepStmtCacheSize: 10
          prepStmtCacheSqlLimit: 2048
          connectionTimeout: 2000
  ```

  * Implementation

    1. The configuration file is first parsed into the map because it is easier to merge than using
    the object.

    2. The value.yaml is also parsed into map.

    3. There are two methods provided by `CentralizedManagement.class` to merge the value of
    values.yaml into ObjectConfig or MapConfig respectively.
    ```
    public static Map<String, Object> merge(String configName, Map<String, Object> config) {
        if (valueConfig == null) {
            logger.error("centralized management file \"values.yaml\" cannot be found");
            return config;
        }
        merge(config, valueConfig.get(configName));
        return config;
    }

    public static Object merge(String configName, Map<String, Object> config, Class clazz) {
        if (valueConfig == null) {
            logger.error("centralized management file \"values.yaml\" cannot be found");
            return convertMapToObj(config, clazz);
        }
        merge(config, valueConfig.get(configName));
        return convertMapToObj(config, clazz);
    }
    ```
    4. The merge process is recursive.
    ```
    private static void merge(Object m1, Object m2) {
        if (m1 instanceof Map && m2 instanceof Map) {
            Iterator<String> fieldNames = ((Map<String, Object>) m1).keySet().iterator();
            while (fieldNames.hasNext()) {
                String fieldName = fieldNames.next();
                Object field1 = ((Map<String, Object>) m1).get(fieldName);
                Object field2 = ((Map<String, Object>) m2).get(fieldName);
                if (field1 != null && field2 == null
                        && (field1 instanceof Map || field1 instanceof List)) {
                    merge(field1, m2);
                } else if (field2 != null) {
                    ((Map<String, Object>) m1).put(fieldName, field2);
                }
            }
        } else if (m1 instanceof List) {
            for (Object field1 : ((List<Object>) m1)) {
                merge(field1, m2);
            }
        }
    }
    ```

### Reference-level explanation

### Drawbacks

### Rationale and Alternatives

### Unresolved questions

repository: networknt/light-rfcs

repo_name: networknt/light-rfcs


text:
# GetFwLeaderboardsOkKills

## Properties
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**active_total** | [**\Swagger\Client\Model\GetFwLeaderboardsOkKillsActiveTotal[]**](GetFwLeaderboardsOkKillsActiveTotal.md) | Top 4 ranking of factions active in faction warfare by total kills. A faction is considered \"active\" if they have participated in faction warfare in the past 14 days. |
**last_week** | [**\Swagger\Client\Model\GetFwLeaderboardsOkKillsLastWeek[]**](GetFwLeaderboardsOkKillsLastWeek.md) | Top 4 ranking of factions by kills in the past week |
**yesterday** | [**\Swagger\Client\Model\GetFwLeaderboardsOkKillsYesterday[]**](GetFwLeaderboardsOkKillsYesterday.md) | Top 4 ranking of factions by kills in the past day |

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

repository: TCOMI/AuthSite

branch_name: refs/heads/master

extension: md

gha_language: PHP

license_type: permissive

repo_name: TCOMI/AuthSite


text:
### Person and Organisations

The following table defines the organisations (companies, trusts, partnerships) associated with the farm. Many of the items in this table are based upon definitions at [http://schema.org](http://schema.org), which is an output of the W3C Semantic Web group, and is used by Google and Microsoft. Alternatives schemas can be found in the work of [OASIS](www.oasis-open.org) / [UBL](http://ubl.xml.org) and [UN/EDIFACT](www.unece.org/cefact/edifact).

A Full list of person attributes can be found in the Health and Safety Data Standard. [INFORMATIVE](FMDS_Definitions-and-Abbreviations_Interpretation.md#Interpretation) examples of person attributes can also be found in the Health and Safety Standard, referencing the schema.org/Employee Role attributes.

#### Organisation Identification

Attributes | Data Types | Notes
:--------- | :--------- | :----
Name | String | Name of the Organisation
Global Location Number | | EPC Global number for a business – in New Zealand, this is the NZ Business Number. See [Schema.org](http://schema.org/globalLocationNumber) for definition.
Email | String | An email address described in RFC 5322[1](#f1) and RFC 5321[2](#f2).
Website	URL | String

#### Footnotes

1. See [Internet Message Format (IMF)](http://tools.ietf.org/html/rfc5322). [↩](#IMF)

2. See [Simple Mail Transfer Protocol](http://tools.ietf.org/html/rfc5321). [↩](#SMTP)

repository: Datalinker-Org/Farm-Data-Standards

repo_name: Datalinker-Org/Farm-Data-Standards


text:
# Regional HIV/Aids Connection Project
This project is for teams of Fanshawe students to pitch, design and develop a professional advertising campaign and website for the Regional HIV/Aids Connection.

## Prerequisites
This project use the Vue.js to create the front-end framework and using CMS to control the content and MySql and PHP for the server side, also using the gulp to assit that.

- Insatll SASS(scss)
    - Macs have it installed by default.
    - Windows machine ->https://sass-lang.com/

- Install GUlP
    - Install GUlP by "npm install gulp", "npm install gulp-sass"
        and "npm install sass" in terminal

- Link the VUE.JS and VueRoutes in code
    - https://unpkg.com/vue
    - https://unpkg.com/vue-router/dist/vue-router.js

## Installation:

1.Clone the repo
    git clone https://github.com/ling89889988952/finalproject.git

## Usage:

1.Before staring the project please make sure to install the Sass and gulp package (how to install these package can follow the **Prerequisites**)

2.Sass fllowes the nested rules. Do not only change the variable of the main.scss which will cause the website makeup is invaild. Please check the nesting rules between the related file main.scss.

3.Do not modify all file path and file name which may cause the function of the website can not run. All the js file has its own function, please do not

4.Different screen resolutions may cause subtle chromatic aberrations on the website.

5.Please link the related url (vue, bootscript) in the code, in ordr to run the website.

6.Please confirm to open the MAMP and upload the data (In database) to phpmyadmin, in order to get the content from the database, and can be run on 'localhost'

## Contributing:

Pull requests are welcome.  Thanks!

## Built With:

Project Manager         : Mingqian Xia
Front-end Web Developer : Bolin Chen
Back-end Web Developer  : Ling Zou
Motion/3D Artist        : Yufeng Lin
Graphic Designer        : Jianghaonan Wang

## License:

This project is licensed under the MIT License - see the LICENSE file for details

license: MIT

gha_license_id: MIT


text:
---
uid: articles.misc.debug_symbols
title: Debug Symbols
---

# I want to diagnose a problem I believe originates from the library, how do?

In the event you need to debug DSharpPlus, we offer debug symbols. They are available at the following locations:

## Symbol sources

All of our symbols can be found on [Nuget](https://www.nuget.org/packages/DSharpPlus/). Nightly builds have symbols and source included inside of the packages, while release builds will only contain the symbols.

## Using the symbols

In Visual Studio:

1. Go to Tools > Options > Debugging and make sure "Just My Code" is disabled and "Source Server Support" is enabled.
2. Go to Tools > Options > Debugging > Symbols, and add the URL in there.

repository: DSharpPlus/DSharpPlus

gha_language: C#

repo_name: DSharpPlus/DSharpPlus


text:
# Lists

A list is a collection of JSON records which can grow or shrink at either end, and supports fast random access.  It's basically a double-ended linked list, but implemented internally using "pages" of N records per page, and each page can be randomly accessed.  This allows for great speed with pushing, popping, shifting, unshifting, and random access, with a list of virtually any size.  Methods are also provided for iterating, searching and splicing, but those often involve reading / writing many pages, so use with caution.

All list operations will automatically lock the list using [Advisory Locking](../README.md#advisory-locking) (shared locks or exclusive locks, depending on if the operation is read or write), and unlock it when complete.  This is because all list operations involve multiple concurrent low-level storage calls.  Lists can be used inside [Transactions](Transactions.md) as well.

The code examples all assume you have your preloaded `Storage` component instance in a local variable named `storage`.  The component instance can be retrieved from a running server like this:

```javascript
var storage = server.Storage;
```

## Table of Contents

> ← [Return to the main document](https://github.com/jhuckaby/pixl-server-storage/blob/master/README.md)

<!-- toc -->
- [List Page Size](#list-page-size)
- [Creating Lists](#creating-lists)
- [Pushing, Popping, Shifting, Unshifting List Items](#pushing-popping-shifting-unshifting-list-items)
- [Fetching List Items](#fetching-list-items)
- [Splicing Lists](#splicing-lists)
- [Sorted Lists](#sorted-lists)
- [Iterating Over List Items](#iterating-over-list-items)
- [Updating List Items](#updating-list-items)
- [Searching Lists](#searching-lists)
- [Copying and Renaming](#copying-and-renaming)
- [Deleting Lists](#deleting-lists)
- [List Internals](#list-internals)

## List Page Size

List items are stored in groups called "pages", and each page can hold up to N items (the default is 50).  The idea is, when you want to store or fetch multiple items at once, the storage engine only has to read / write a small amount of records.  The downside is, fetching or storing a single item requires the whole page to be loaded and saved, so it is definitely optimized for batch operations.

You can configure how many items are allowed in each page, by changing the default [page size](../README.md#list_page_size) in your storage configuration, or setting it per list by passing an option to [listCreate()](API.md#listcreate).

Care should be taken when calculating your list page sizes.  It all depends on how large your items will be, and how many you will be storing / fetching at once.  Note that you cannot easily change the list page size on a populated list (this may be added as a future feature).

## Creating Lists

To create a list, call [listCreate()](API.md#listcreate).  Specify the desired key, options, and a callback function.  You can optionally pass in a custom page size via the second argument (otherwise it'll use the default size):

```javascript
storage.listCreate( 'list1', { page_size: 100 }, function(err) {
	if (err) throw err;
} );
```

You can also store your own key/value pairs in the options object, which are retrievable via the [listGetInfo()](API.md#listgetinfo) method.  However, beware of name collision -- better to prefix your own option keys with something unique.

## Pushing, Popping, Shifting, Unshifting List Items

Lists can be treated as arrays to a certain extent.  Methods are provided to [push](API.md#listpush), [pop](API.md#listpop), [shift](API.md#listshift) and [unshift](API.md#listunshift) items, similar to standard array methods.  These are all extremely fast operations, even with huge lists, as they only read/write the pages that are necessary.  Note that all list items must be objects (they cannot be other JavaScript primitives).

Examples:

```javascript
// push onto the end
storage.listPush( 'list1', { username: 'tsmith', age: 25 }, function(err) {
	if (err) throw err;
} );

// pop off the end
storage.listPop( 'list1', function(err, item) {
	if (err) throw err;
} );

// shift off the beginning
storage.listShift( 'list1', function(err, item) {
	if (err) throw err;
} );

// unshift onto the beginning
storage.listUnshift( 'list1', { username: 'fwilson', age: 40 }, function(err) {
	if (err) throw err;
} );
```

Furthermore, the [listPush()](API.md#listpush) and [listUnshift()](API.md#listunshift) methods also accept multiple items by passing an array of objects, so you can add in bulk.

## Fetching List Items

Items can be fetched from lists by calling [listGet()](API.md#listget), and specifying an index offset starting from zero.  You can fetch any number of items at a time, and the storage engine will figure out which pages need to be loaded.  To fetch items from the end of a list, use a negative index.  Example use:

```javascript
storage.listGet( 'list1', 40, 5, function(err, items) {
	if (err) throw err;
} );
```

This would fetch 5 items starting at item index 40 (zero-based).  To fetch the entire list, set the index and length to zero:

```javascript
storage.listGet( 'list1', 0, 0, function(err, items) {
	if (err) throw err;
} );
```

## Splicing Lists

You can "splice" a list just like you would an array.  That is, cut a chunk out of a list at any location, and optionally replace it with a new chunk, similar to the built-in JavaScript [Array.splice()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice) function.  [listSplice()](API.md#listsplice) is a highly optimized method which only reads/writes the pages it needs, but note that if the list length changes as a result of your splice (i.e. you insert more or less than you remove) it does have to rewrite multiple pages up to the nearest end page, to take up the slack or add new pages.  So please use with caution on large lists.

Here is an example which removes 2 items at index 40, and replaces with 2 new items:

```javascript
var new_items = [
	{ username: 'jhuckaby', age: 38, gender: 'male' },
	{ username: 'sfields', age: 34, gender: 'female' }
];
storage.listSplice( 'list1', 40, 2, new_items, function(err, items) {
	if (err) throw err;
	// 'items' will contain the 5 removed items
} );
```

You don't have to insert the same number of items that you remove.  You can actually remove zero items, and only insert new ones at the specified location.

As with [listGet()](API.md#listget) you can specify a negative index number to target items from the end of the list, as opposed to the beginning.

## Sorted Lists

While it is possible to manually sort your list by fetching all the items as an array, sorting it in memory, then rewriting the entire list, this can be quite time consuming.  Instead, you can perform a [listInsertSorted()](API.md#listinsertsorted) when adding items to a list.  This will find the correct location for a single item based on sorting criteria, and then splice it into place, keeping the list sorted as you go.  Example:

```javascript
var new_user = {
	username: 'jhuckaby',
	age: 38,
	gender: 'male'
};

storage.listInsertSorted( 'users', new_user, ['username', 1], function(err) {
	if (err) throw err;
	// item inserted successfully
} );
```

That third argument is an array of sort criteria, consisting of the property name to sort by (e.g. `username`) and a sort direction (`1` for ascending, `-1` for descending).  You can alternately specify a comparator function here, which is called with the item you are inserting, and the item to compare it to.  This is similar to the built-in [Array.sort()](), which should return `1` or `-1` depending on if your item should come after, or before, the second item.  Example:

```javascript
var new_user = {
	username: 'jhuckaby',
	age: 38,
	gender: 'male'
};

var comparator = function(a, b) {
	return( (a.username < b.username) ? -1 : 1 );
};

storage.listInsertSorted( 'users', new_user, comparator, function(err) {
	if (err) throw err;
	// item inserted successfully
} );
```

For large lists, this can still take considerable time, as it is iterating over the list to locate the correct location, and then performing a splice which grows the list, requiring all the remaining pages to be rewritten.  So please use with caution.

## Iterating Over List Items

Need to iterate over the items in your list, but don't want to load the entire thing into memory?  Use the [listEach()](API.md#listeach) method.  Example:

```javascript
storage.listEach( 'list1', function(item, idx, callback) {
	// do something with item, then fire callback
	callback();
},
function(err) {
	if (err) throw err;
	// all items iterated over
} );
```

Your iterator function is passed the item and a special callback function, which must be called when you are done with the current item.  Pass it an error if you want to prematurely abort the loop, and jump to the final callback (the error will be passed through to it).  Otherwise, pass nothing to the iterator callback, to notify all is well and you want the next item in the list.

Alternatively, you can use [listEachPage()](API.md#listeachpage), which iterates over the internal list [pages](#list-page-size), and only fires your iterator function once per page, instead of once per item.  This is typically faster as it requires fewer function calls.  Example:

```javascript
storage.listEachPage( 'list1', function(items, callback) {
	// do something with items, then fire callback
	callback();
},
function(err) {
	if (err) throw err;
	// all items iterated over
} );
```

## Updating List Items

To iterate over and possibly update items, you can use the [listEachUpdate()](API.md#listeachupdate) method.  Your iterator callback accepts a second boolean argument which can indicate that you made changes.  Example:

```javascript
storage.listEachUpdate( 'list1', function(item, idx, callback) {
	// do something with item, then fire callback
	item.something = "something new!";
	callback(null, true);
},
function(err) {
	if (err) throw err;
	// all items iterated over
} );
```

As you can see, the iterator callback accepts two arguments, an error (or something false for success), and a boolean which should be set to `true` if you made changes.  The storage engine uses this to decide which list pages require updating.

For a speed optimization, you can optionally iterate over entire list [pages](#list-page-size) rather than individual items.  To do this, use the [listEachPageUpdate()](API.md#listeachpageupdate) method.  In this case your iterator callback is passed an array of items on each page.  Example:

```javascript
storage.listEachPageUpdate( 'list1', function(items, callback) {
	// do something with items, then fire callback
	items.forEach( function(item) {
		item.something = "something new!";
	} );
	callback(null, true);
},
function(err) {
	if (err) throw err;
	// all items iterated over
} );
```

## Searching Lists

Several methods are provided for searching through lists for items matching a set of criteria.  Use [listFind()](API.md#listfind) to find and retrieve a single item, [listFindCut()](API.md#listfindcut) to find and delete, [listFindReplace()](API.md#listfindreplace) to find and replace, [listFindUpdate()](API.md#listfindupdate) to find and apply updates, or [listFindEach()](API.md#listfindeach) to find multiple items and iterate over them.

All of these methods accept a "criteria" object, which may have one or more key/value pairs.  These must *all* match a list item for it to be selected.  For example, if you have a list of users, and you want to find a male with blue eyes, you would pass a criteria object similar to this:

```javascript
{
	gender: "male",
	eyes: "blue"
}
```

Alternatively, you can use regular expression objects for the criteria values, for more complex matching.  Example:

```javascript
{
	gender: /^MALE$/i,
	eyes: /blu/
}
```

Example of finding a single object with [listFind()](API.md#listfind):

```javascript
storage.listFind( 'list1', { username: 'jhuckaby' }, function(err, item, idx) {
	if (err) throw err;
} );
```

Example of finding and deleting a single object with [listFindCut()](API.md#listfindcut):

```javascript
storage.listFindCut( 'list1', { username: 'jhuckaby' }, function(err, item) {
	if (err) throw err;
} );
```

Example of finding and replacing a single object with [listFindReplace()](API.md#listfindreplace):

```javascript
var criteria = { username: 'jhuckaby' };
var new_item = { username: 'huckabyj', foo: 'bar' };

storage.listFindReplace( 'list1', criteria, new_item, function(err) {
	if (err) throw err;
} );
```

Example of finding and updating a single object with [listFindUpdate()](API.md#listfindupdate):

```javascript
var criteria = { username: 'jhuckaby' };
var updates = { gender: 'male', age: 38 };

storage.listFindUpdate( 'list1', criteria, updates, function(err, item) {
	if (err) throw err;
} );
```

You can also increment or decrement numerical properties with [listFindUpdate()](API.md#listfindupdate).  If an item key exists and is a number, you can set any update key to a string prefixed with `+` (increment) or `-` (decrement), followed by the delta number (int or float), e.g. `+1`.  So for example, imagine a list of users, and an item property such as `number_of_logins`.  When a user logs in again, you could increment this counter like this:

```javascript
var criteria = { username: 'jhuckaby' };
var updates = { number_of_logins: "+1" };

storage.listFindUpdate( 'list1', criteria, updates, function(err, item) {
	if (err) throw err;
} );
```

And finally, here is an example of finding *all* items that match our criteria using [listFindEach()](API.md#listfindeach), and iterating over them:

```javascript
storage.listFindEach( 'list1', { gender: 'male' }, function(item, idx, callback) {
	// do something with item, then fire callback
	callback();
},
function(err) {
	if (err) throw err;
	// all matched items iterated over
} );
```

## Copying and Renaming

To duplicate a list and all of its items, call [listCopy()](API.md#listcopy), specifying the old and new key.  Example:

```javascript
storage.listCopy( 'list1', 'list2', function(err) {
	if (err) throw err;
} );
```

To rename a list, call [listRename()](API.md#listrename).  This is basically just a [listCopy()](API.md#listcopy) followed by a [listDelete()](API.md#listdelete).  Example:

```javascript
storage.listRename( 'list1', 'list2', function(err) {
	if (err) throw err;
} );
```

With both of these functions, it is highly recommended you make sure the destination (target) key is empty before copying or renaming onto it.  If a list already exists at the destination key, it will be overwritten, but if the new list has differently numbered pages, some of the old list pages may still exist and occupy space, detached from their old parent list.  So it is always safest to delete first.

## Deleting Lists

To delete a list and all of its items, call [listDelete()](API.md#listdelete).  The second argument should be a boolean set to `true` if you want the list *entirely* deleted including the header (options, page size, etc.), or `false` if you only want the list *cleared* (delete the items only, leaving an empty list behind).  Example:

```javascript
storage.listDelete( 'list1', true, function(err) {
	if (err) throw err;
	// list is entirely deleted
} );
```

## List Internals

Lists consist of a header record, plus additional records for each page.  The header is literally just a simple JSON record, stored at the exact key specified for the list.  So if you created an empty list with key `mylist`, and then you fetched the `mylist` record using a simple [get()](API.md#get), you'd see this:

```javascript
{
	type: 'list',
	length: 0,
	page_size: 50,
	first_page: 0,
	last_page: 0
}
```

This is the list header record, which defines the list and its pages.  Here are descriptions of the header properties:

| Property | Description |
|----------|-------------|
| `type` | A static identifier, which will always be set to `list`. |
| `length` | How many items are currently in the list. |
| `page_size` | How many items are stored per page. |
| `first_page` | The page number of the beginning of the list, zero-based. |
| `last_page` | The page number of the end of the list, zero-based. |

The list pages are stored as records "under" the main key, by adding a slash, followed by the page number.  So if you pushed one item onto the list, the updated header record would look like this:

```javascript
{
	type: 'list',
	length: 1,
	page_size: 50,
	first_page: 0,
	last_page: 0
}
```

Notice that the `first_page` and `last_page` are both still set to `0`, even though we added an item to the list.  That's because pages are zero-based, and the algorithm will fill up page `0` (`50` items in this case) before adding a new page.

So then if you then fetched the key `mylist/0` you'd actually get the raw page data, which is a JSON record with an `items` array:

```javascript
{
	items: [
		{ username: "jhuckaby", gender: "male" }
	]
}
```

This array will keep growing as you add more items.  Once it reaches 50, however, the next item pushed will go into a new page, with key `mylist/1`.  That's basically how the paging system works.

Remember that lists can grow from either end, so if the first page is filled and you *unshift* another item, it actually adds page `mylist/-1`.

The two "end pages" can have a variable amount of items, up to the `page_size` limit.  The algorithm then creates new pages as needed.  But the *inner* pages that exist between the first and last pages will *always* have the full amount of items (i.e. `page_size`).  Never more, never less.  So as future list operations are executed, the system will always maintain this rule.

repository: jhuckaby/pixl-server-storage

gha_language: JavaScript

repo_name: jhuckaby/pixl-server-storage


text:
# licy.js

[![Build Status]](https://travis-ci.org/mantoni/licy.js)
[![SemVer]](http://semver.org)
[![License]](https://github.com/mantoni/licy.js/blob/master/LICENSE)

Objects with managed lifecycles for Node and the browser.

## Features

- Async creation: Function calls are automatically deferred until constructor
  invokes callback
- All function calls are observable and can be intercepted
- Create hierarchies of instances that get destroyed together

## How does it work?

Licy types can be defined in two ways. Using an object:

```js
var Hello = licy.define({
  constructor: function (name) {
    this.name = name;
  },
  log: function () {
    console.log('Hello ' + this.name);
  }
});
```

Or using a function:

```js
var Hello = licy.define(function (name) {
  return {
    log: function () {
      console.log('Hello ' + name);
    }
  };
});
```

Types that where defined with licy can be newed up like any other JavaScript
type. Both of the examples above can be used like this:

```js
var hello = new Hello('world');
hello.log(); // logs "Hello world"
```

### Async object creation

Any defined type can be changed to be created asynchronously:

```js
var Hello = licy.define(function (name, callback) {
  setTimeout(callback, 500);
  return { /* as above */ };
});

var hello = new Hello('world');
hello.log(); // logs "Hello world" after 500 milliseconds
```

All function calls will be implicitly deferred until the constructor invoked
the callback.

As a consequence, obtaining the return value of a function only works with
callbacks:

```js
var Hello = licy.define(function (name) {
  return {
    get: function () {
      return 'Hello ' + name;
    }
  };
});

var hello = new Hello('world');

console.log(hello.get()); // logs "Hello undefined"
hello.get(function (err, value) {
  console.log(value); // logs "Hello world"
});
```

Note that the callback follows the Node.js `(err, value)` convention.

### Observing and intercepting calls

Each licy instance inherits the [hub.js][] event emitter API and emits an event
for each function call:

```js
hello.on('log', function () {
  // Invoked on hello.log() calls
});
```

[Filters][filter] can be used to intercept calls:

```js
hello.addFilter('log', function (next) {
  // Defer all calls by 500 milliseconds:
  setTimeout(function () {
    next();
  }, 500);
});
```

### Destroying instances

Each licy instance has a `destroy([callback])` implementation which emits a
`"destroy"` event and invokes the defined `destroy` function, if given:

```js
var Hello = licy.define(function (name) {
  return {
    destroy: function () {
      console.log('Bye ' + name);
    }
  };
});

var hello = new Hello('world');

hello.destroy();
```

Calling `licy.destroy()` will destroy all existing licy instances. This can be
used to shut down an application cleanly, e.g. closing a server gracefully.

To bind the lifecycle of one object to another, invoke `a.destroyWith(b)`. Use
`create(definition)` to bind a child object to a parent: `var b = a.create(B)`.

## Install with npm

    npm install licy --save

## Browser support

Use [Browserify][] to create a standalone file. The licy test suite passes on
IE 9, 10, 11, Chrome \*, Filefox \* and PhantomJS.

## API

Licy is a [hub.js][] instance with these additions:

- `Licy`: The `Licy` constructor (`licy instanceof licy.Licy` is `true`)
- `define([definition])`: Defines a new type. The `definition` must be either
  ommitted, of type `function` or an `object`:
    - No `definition`: A plain licy type is returned that creates objects with
      the same API as the parent object.
    - `function`: The function is used as the constructor and is expected to
      return the API as an object.
    - `object`: Defines the API directly. A `constructor` can be defined
      optionally.
  The returned type creates new Licy instances. Each instance is derived from
  Licy itself and also inherits the [hub.js][] API. All created instances are
  destroyed when the defining instance is destroyed.
- `create([definition])`: Creates an instance that will be destroyed with this
  instance. If `definition` is not a type, `define(definition)` is called
  before creating an instance.
- `destroy([callback])`: Emits the `destroy` event on the licy instance and all
  children. If a callback is given, it is invoked after this instance and all
  children are destroyed. If an error occurred, it is passed as the only
  argument to the callback.
- `destroyWith(type)`: Destroy this instance when `type` is destroyed.
- `extend(Super, definition)`: Defines a new type which is derived from the
  `Super` type. Instances of the new type are `instanceof Super`. If a
  constructor is given, or if `definition` is a function, the super constructor
  must be explicitly invoked with `Super.super_.call(this)`. If a method is
  defined that already exists in the super type, it is registered as a
  [filter][].

## Type API

Each type returned by `licy.define()` is a Licy instance with these additions:

- `Type.extend(definition)`: Is a shortcut for `licy.extend(Type, definition)`.

## Events

Each type instance and the root licy object emit these events:

- `define(type, callback)`: When a new child type is defined.
- `create(instance, type, callback)`: When a child instance is created.
- `destroy(callback)`: When the instance is destroyed.

The `prototype` of custom defined types is a licy instance itself. It can be
used to emit and subscribe global type specific events. These events are always
emitted:

- `instance.create(instance, type, callback)`: When a new instance is created.
- `instance.destroy(instance, error, callback)`: When an instance is destroyed.
  If an error occurred during destruction, the Error is passed on as `error`.

## Development

- `npm install` to install the dev dependencies
- `npm test` to lint, run tests on Node and PhantomJS and check code coverage

## License

MIT

[Build Status]: http://img.shields.io/travis/mantoni/licy.js.svg
[SemVer]: http://img.shields.io/:semver-%E2%9C%93-brightgreen.svg
[License]: http://img.shields.io/npm/l/licy.svg
[Browserify]: http://browserify.org
[hub.js]: http://github.com/mantoni/hub.js
[filter]: https://github.com/mantoni/glob-filter.js


text:
 Data-Structure-and-Algorithms

![GitHub open issues](https://img.shields.io/github/issues-raw/Nivedita967/Data-Structure-and-Algorithms?color=%23f&logo=Github)
![GitHub closed issues](https://img.shields.io/github/issues-closed-raw/Nivedita967/Data-Structure-and-Algorithms?color=%2300&logo=Github)
![GitHub open pull requests](https://img.shields.io/github/issues-pr-raw/Nivedita967/Data-Structure-and-Algorithms?logo=Github)
![GitHub closed pull requests](https://img.shields.io/github/issues-pr-closed-raw/Nivedita967/Data-Structure-and-Algorithms?logo=Github)
![GitHub Repo stars](https://img.shields.io/github/stars/Nivedita967/Data-Structure-and-Algorithms?color=%233493eb&logo=Github)
![GitHub forks](https://img.shields.io/github/forks/Nivedita967/Data-Structure-and-Algorithms?color=%233493eb&label=Forks&logo=Github)
![GitHub contributors](https://img.shields.io/github/contributors/Nivedita967/Data-Structure-and-Algorithms?logo=Github)
[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://GitHub.com/Naereen/StrapDown.js/graphs/commit-activity)

This repository covers various practice problems of Arrays, Stacks, Queues, Trees, Graphs and different other Algorithms. A collection of solutions for Data Structure and Algorithm problems across various platforms in different languages.
## Contributing
[![Open Source Love svg1](https://badges.frapsoft.com/os/v1/open-source.svg?v=103)](https://github.com/ellerbrock/open-source-badges/)

This repository is contribution friendly. If you'd like to add or improve any algorithm, your contribution is welcomed!
Don't forget to follow [Contribution Guidelines](.github/contributing.md) 🚀
*`Plagiarism is not allowed`*

## Currently Used Languages
* C
* C++
* Java
* Python
* JavaScript

## Contact
* Gitter Channel 🠮 [![Join the chat at https://gitter.im/Data-Structure-and-Algorithms-Nivedita/community](https://badges.gitter.im/Data-Structure-and-Algorithms-Nivedita/community.svg)](https://gitter.im/Data-Structure-and-Algorithms-Nivedita/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
* Project is maintained by 🠮 [Nivedita Singh](https://github.com/Nivedita967)
### Give it a 🌟 if you ❤ this project.

### This Project was a part of the following Open Source Program

[](https://crosswoc.ieeedtu.in/)

repository: UG-SEP/Data-Structure-and-Algorithms

branch_name: refs/heads/UG

repo_name: UG-SEP/Data-Structure-and-Algorithms


text:
![python-bootcamp-for-geoengineers-logo](https://user-images.githubusercontent.com/51282928/83759266-80d8f580-a69d-11ea-9149-9c2eed8b025f.png)

*By: Yohanes Nuwara*

**Python Bootcamp for Geoengineers** was created in June 2020, seeing lots of geoengineers and geoscientists are interested to start programming in Python. This Bootcamp is structured into **4 Courses** and **1 Demo Room** (so far), each of the courses contains several modules that can be accessed using **Google Colab**, a web-cloud Python IDE.

It is always recommended to start with the first 2 courses (**Intro to Python I and II**). Then, you could choose either to take the **Python Course for Oil and Gas** (ideal for geoengineers, such as petroleum engineers or reservoir engineers) or to take the **Python Course for Geoscience** (ideal for geoscientists, such as geologists or geophysicists).

At the end of each course, there is a dummy **Exam** to test how far you already master each course!

**Demo Room** is a place to showcase some wonderful programs that will make you more excited to explore more with Python.

So, enjoy!

## Intro to Python I (Absolute Beginner)

1. [Intro to Google Colab]()
2. [Intro to Numpy](https://colab.research.google.com/drive/1C2RCLJCQcyjw3pdfjWpQgOwCQWvHbqJs?usp=sharing)
3. [Intro to Visualization with Matplotlib]()
4. [Intro to Data with Pandas]()
5. [Exam]()

## Intro to Python II (Next Level)

5. [Intro to Scientific Computing with Scipy]()
6. [Intro to Exploratory Data Analysis with Seaborn]()
7. [Exam]()

## Python Course for Oil and Gas

1. [Exploring Production Data with Pandas]()
2. [Plotting Production with Matplotlib]()
3. [Decline Curve Analysis with Scipy]()
4. [Volumetric Calculation in Python]()
5. [Exam]()

## Python Course for Geoscience

1. [Accesing Open Geoscience Data]()
2. [Well-log Data Processing and Petrophysics]()
3. [Exploring Seismic Data]()
4. [Exam]()

## Demos

1. [Seismic Widget]()


text:
# LBCacheImage

LBCacheImage is an image caching library for iOS

How to use this library:
=======
- drag the LBCacheImage folder to your project.
- import the CommonCrypto.h header to the Objective C bridging header file because the NSString class extension is using CommonCrypto for hashing.

This library offer:
=======
- asynchronous image download;
- cache support (memory and disk) with the option to set the days to keep the cache on disk;
- option to get the local path to an image.
- create MD5,SHA1,SHA256 hash.

Classes and extensions to use:
=======
I. UIImageView class extension:
-------
- this UIImageView class extension offers the option to set a URL string of the image location on the server;
- the image is downloaded asynchronous in the background;
- the image is saved on the disk in the caches directory;

Methods to use:
- setImageWithURLString:placeholderImage: - download and cache the image
- setImageWithURLString:placeholderImage:options: - download and cache the image
- setImageWithURLString:placeholderImage:options:completionBlock: - download, cache and return the image
- imageForURLString: - search the UIImage directly in cache (memory or disk), nil is returned if not found

There are 3 LBCacheImageOptions to use:
- .Default - it first search the memory cache, if not found it search on the disk, if not found it will download asynchronous and cache it
- .ReloadFromWebOrCache - it will try to reload the image from the web, if it fails it will load from local cache
- .LoadOnlyFromCache - it will only search in memory and on the disk

II. LBCacheImage:
-------
- this class is used by the UIImageView class extension for the download but you can use it directly.

Options to use:
- kDaysToKeepCache - stores the days to keep the images in cache
- kDefaultHashType - stores the hash type declared in the NSString class extension and it has 3 values: .MD5, .SHA1, .SHA256

Methods to use:
- imagePathLocationForURLString: - a string with the local path location of the image saved on disk or nil if the image for the URLString is not found
- downloadImageFromURLString:options:progressBlock:completionBlock: - same as UIImageView class extension, cache and return the image
- imageForURLString: - same as UIImageView class extension, search the UIImage directly in cache (memory or disk), nil is returned if not found

III. NSString class extension:
-------
- use this class extension to get hash value from a string.
- there are 3 options available, MD5, SHA1 and SHA256

Methods to use:
- lbHashMD5 - create an MD5 hash
- lbHashSHA1 - create an SHA1 hash
- lbHashSHA256 - create an SHA256 hash
- lbHashWithType: - create a hash using the 3 available options

LICENSE
=======

This content is released under the MIT License https://github.com/lucianboboc/LBCacheImage/blob/master/LICENSE.md

Enjoy!

repository: lucianboboc/LBCacheImage

repo_name: lucianboboc/LBCacheImage


text:
# Resources in this folder

- This folder contains resources used in Google Cloud codelabs on [Google Developers Codelabs](https://codelabs.developers.google.com/?category=cloud).
- Each folder is named after the codelab ID. Example:
  - Folder: `cloud-functions-python-http`
  - Codelab: <https://codelabs.developers.google.com/codelabs/cloud-functions-python-http>

repository: OtterOriented/python-docs-samples

repo_name: OtterOriented/python-docs-samples


text:
# Using Dac-Man on HPC Clusters

## Requirements

The `mpi4py` is required to enable running Dac-Man with MPI.
Installation steps and additional information
on how to install Dac-Man's MPI dependencies are given in the following.

### Installing dependencies for running Dac-Man with MPI

The `mpi4py` package is required to use Dac-Man with MPI.

To update Dac-Man's environment, run this command from the root of the local copy
of the Dac-Man's source code repository:

```sh
conda env update --name dacman-env --file dependencies/conda/mpi.yml
```

!!! important
    Different computing environments might have specific requirements for interfacing user applications with MPI, e.g. using custom versions of MPI libraries. This is especially true for HPC systems. In this case, refer to the system's own documentation to find out how to enable MPI.

## Using MPI

Dac-Man allows you to parallelize the following steps:

- `index`
- `diff` with the `--datachange` option

To parallelize on HPC clusters, you need to enable the MPI support
by using the appropriate flags:

```sh
dacman index ... -m mpi
dacman diff ... -e mpi --datachange
```

To distribute the tasks to multiple workers,
you need to use the MPI executable appropriate for the system in use,
e.g. `srun`, `mpiexec`, `mpirun`, etc.

For example, to run Dac-Man on an HPC cluster with 8 nodes and 32 cores per node,
where the MPI executable is `srun`,
you can use:

```sh
srun -n 256 dacman index ... -m mpi
srun -n 256 dacman diff ... -e mpi --datachange
```

## Batch Script

To submit a batch job to a cluster,
you need to include the Dac-Man command in your job script.
The example below shows a batch script (`hpcEx.batch`) for the Slurm scheduler.

```sh
# !/bin/bash

#SBATCH -J example
#SBATCH -t 00:30:00
#SBATCH -N 8
#SBATCH -q myqueue

srun -n 256 dacman diff /old/data /new/data -e mpi --datachange
```

The script can then be submitted to the batch scheduler as:

```sh
sbatch hpcEx.batch
```

---

## Using Dac-Man on NERSC

This sections provides information on how to run Dac-Man at scale on the Cori HPC cluster at NERSC.

### Installation

#### Enabling Conda

The Conda package manager is already installed at NERSC.
To enable it, from one of Cori's login nodes,
load one of the Anaconda Python modules as described [here](https://docs.nersc.gov/programming/high-level-environments/python/#anaconda-python):

```sh
module load python/3.7-anaconda-2019.07
```

#### Installing Dac-Man

Then, follow the same steps to install Dac-Man using Conda as illustrated in the [*Installing Dac-Man*](../../install/) section,
including installing additional [plug-in dependencies](../../install/dependencies/) as needed:

```sh
git clone https://github.com/dghoshal-lbl/dac-man
cd dac-man
conda env create --file environment.yml
# optional - install dependencies for built-in plug-ins
conda env update --name dacman-env --file dependencies/conda/builtin-plugins.yml
```

#### Enable MPI

The installation method for MPI dependencies described above will not work on Cori,
since the package versions installed via Pip or Conda are not compatible with the MPI libraries supported on Cori.

To enable MPI on Cori, the `mpi4py` package must be built manually.
To do so, first activate the Dac-Man Conda environment:

```sh
conda activate dacman-env
```

Then, follow the steps described in [this section](https://docs.nersc.gov/programming/high-level-environments/python/mpi4py/#mpi4py-in-your-custom-conda-environment) of the NERSC documentation
to download, build, and install the `mpi4py` package.

### Running a test job

After the installation is finished,
test Dac-Man on one of Cori compute nodes using an interactive session.

To access a node in an interactive session, run:

```sh
salloc -N 1 -C haswell -q interactive -t 30:00
```

Finally, once inside the interactive compute node session,
invoke `dacman` on any two test data directories.
 Running MPI on login nodes is discouraged at NERSC, and the above command might fail if run on a login node.

repository: yocheah/dac-man

gha_license_id: NOASSERTION

repo_name: yocheah/dac-man


text:
# Non-Query Materializers

There are two Non-Query materializers. `AsNonQuery` has no return value, while `AsRowsAffected` returns the number of rows affected.

## Limitations

The rows affected count is not necessarily accurate. For example, if a stored procedure uses `SET NOCOUNT ON` then there will be nothing to report.

## SQL Generation

These materializers respond with NoColumns when participating in SQL generation.

## Internals

These materialziers use DbCommand.ExecuteNonQuery.

## Roadmap

repository: hellfirehd/Chain

repo_name: hellfirehd/Chain


text:
[![R-CMD-check](https://github.com/devOpifex/g2r/workflows/R-CMD-check/badge.svg)](https://github.com/devOpifex/g2r/actions)
[![Coveralls test coverage](https://coveralls.io/repos/github/devOpifex/g2r/badge.svg)](https://coveralls.io/r/devOpifex/g2r?branch=master)

An R wrapper for the G2.js visualisation library.

Gallery
Get Started

```r
# install.packages("remotes")
remotes::install_github("devOpifex/g2r")
```

Easy to use

An intuitive, familiar API, and easy to pick up API.

Crosstalk

Support for crosstalk selection and filtering.

Shiny

Integration with shiny events and proxies.

Rmd

Integration for dynamic charts in Rmarkdown.

```r
g2(penguins, asp(flipper_length_mm, body_mass_g, color = species)) %>%
  fig_point(
    asp(size = body_mass_g, shape = "circle"),
    fillOpacity = .5,
    stroke = 0
  ) %>%
  fig_smooth() %>%
  axis_title_x("Flipper Length (mm)") %>%
  axis_title_y("Body Mass (gram)")
```

Limitations

g2r currently does not work well with large datasets (performance drop), and some features are still under development, namely rmarkdown actions, shiny proxies, and maps. Theming is not currently rather unwieldy.


text:
### What does this PR do?
-

#### Type of change
<!--- What types of changes does your code introduce? Put an `x` in all the boxes that apply: -->
- [ ] Bug fix (non-breaking change which fixes an issue)
- [ ] New feature (non-breaking change which adds functionality)
- [ ] Breaking change (fix or feature that would cause existing functionality to change)
- [ ] Scout (e.g. improves readability or does some small fixes without causing **ANY** impact)

#### Checklist
- [ ] I added at least 2 reviewers
- [ ] I have added necessary documentation (if appropriate)
- [ ] I did review at least 2 **existing pull requests** before submitting mine.
- [ ] I have added tests proving that my fix is effective and/or the feature works
- [ ] In case this is a `breaking change`, I have already warned backend and/or frontend
- [ ] I already added the pull request link to related Issue
- [ ] I have cleaned up at least one file before checking in <!--- http://programmer.97things.oreilly.com/wiki/index.php/The_Boy_Scout_Rule -->
- [ ] I handled nicely the exceptions in possible scenarios where my changes could make the app crash

repository: alfonsoirai/roommate-app

branch_name: refs/heads/develop

gha_language: Java

repo_name: alfonsoirai/roommate-app


text:
# cdeb

[![wercker status](https://app.wercker.com/status/1214b503d63d0bf2178dda7373d98983/m "wercker status")](https://app.wercker.com/project/bykey/1214b503d63d0bf2178dda7373d98983)
[![Go Report Card](https://goreportcard.com/badge/github.com/dz0ny/cdeb)](https://goreportcard.com/report/github.com/dz0ny/cdeb)

```
usage: cdeb [<flags>] <command> [<args> ...]

Build packages for debian with great ease or declaritive template.

Flags:
  --help         Show context-sensitive help (also try --help-long and --help-man).
  -v, --verbose  Verbose mode.
  --version      Show application version.

Args:
  <root>     Path to deb root folder
  <control>  Path to debian control folder
  <deb>      Path to output deb file

Commands:
  help [<command>...]
    Show help.

  dumb <root> <control> <deb>
    Create debian file from root and control folder.

  gen <root> <deb>
    Create debian file from root folder and .cdeb template.

  init
    Create .cdeb template.

```

You can find compiled binaries for your platform under "Releases" or if you prefer quick install:

```
$ curl -L https://github.com/dz0ny/cdeb/releases/download/v1.0.0/cdeb-`uname -s`-`uname -m` > /usr/local/bin/cdeb
$ chmod +x /usr/local/bin/cdeb
```

cdeb is sponsored by [NiteoWeb Ltd.](http://www.niteoweb.com/)


text:
# Commit tagger

Tags the commit with a given text

## Getting Started
To use, create a workflow (eg: `.github/workflows/label.yml` see [Creating a Workflow file](https://help.github.com/en/articles/configuring-a-workflow#creating-a-workflow-file)) and add a step like 'Tag commit' on the below sample. A token will be needed so the workflow can make calls to GitHub's rest API.

```yaml
name: "My workflow"

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - name: Tag commit
      uses<EMAIL_ADDRESS>      with:
        repo-token: "${{ secrets.GITHUB_TOKEN }}"
        tag: "my_tag"
```

An optional commit sha can be specified to override the default

```yaml
    steps:
    - name: Tag commit
      uses<EMAIL_ADDRESS>      with:
        repo-token: "${{ secrets.GITHUB_TOKEN }}"
        tag: "my_tag"
        commit-sha: abc123
```


text:
# Component Webpack Config

Extensible webpack configuration for the OVH Components.

## Usage

The webpack configuration can be imported and extended in your component. To import the configuration, simply add component-webpack-config as a devDependency :

```js
yarn add -D @ovh-ux/component-webpack-config
```

### Parameters

The following configuration parameters are _optionals_ :
 - _library_: your component name (used to name the dist files), if not provided the component directory name will be used instead

## Example

```js
const config = require('@ovh-ux/component-webpack-config');

module.exports = config({
  library: 'my-lib',
}).merge({
    entry: "./src/index.js",
    externals: [
      'angular', // please note that by default peerDependencies are automatically added to the externals
    ]
});
```

repository: ovh-ux/component-webpack-config

repo_name: ovh-ux/component-webpack-config


text:
# The Foundation 5 Theme
Inspired by the Statarkers Theme I tried to make a foundation 5 Theme for everyone to use.
This is what I came up with so far.

# Version
Foundation 5.3.3

# Update

I use bower to update foundation. The path to the bower_component-folder is `./_themes/foundation5/bower_components/`

# More Information
Thanks to [Statamic Themes](http://www.statamicthemes.com/themes) for making the Statarkers-Theme.


text:
# Changelog

All notable changes to `laravel-html-table` will be documented in this file

## [Unreleased](https://github.com/lloricode/laravel-html-table/compare/v2.1.0...develop)

## [v2.1.0 2023-05-28](https://github.com/lloricode/laravel-html-table/compare/v2.0.0...v2.1.0)

### Changed

- Use DTO for table tags (\Lloricode\LaravelHtmlTable\TableTags).
- Can DTO for table tags (\Lloricode\LaravelHtmlTable\TableTags).
- Add set attributes to header cells.

## [v2.0.0 2023-05-13](https://github.com/lloricode/laravel-html-table/compare/v1.3.4...v2.0.0)

### What's Changed

- Massive clean up with latest tools and standard.
- Drop support PHP 8.0 and below.
- Set laravel 10 minimum support
- Convert to pest test.
- Use spatie/pest-plugin-snapshots for clean up test.
- Install rector for easy upgrade php support inn later version.
- Fix psr 12 coding style.
- Use GitHub action test
- Install phpstan

repository: lloricode/laravel-html-table

repo_name: lloricode/laravel-html-table


text:
---
layout: post
title: "PHP Apache MySQL Set-up Note"
date: 2014-03-25 13:09:31 +0800
comments: true
categories: server
description: "my notes to setup local development environment"
keywords: "PHP, Apache, setup"
cover:
---

- Apache is pre-installed in Mac OS X, and it can be started by running `sudo apachectl start` in terminal. After this, {% blockquote %} It works! {% endblockquote %} is shown when visiting `localhost` in browser. Create a `Sites` folder in your home folder, then this folder is accessible through `localhost/~yourusername`.
- Enable PHP by uncommenting `LoadModule php5_module libexec/apache2/libphp5.so` in `/etc/apache2/httpd.conf`. Then restart Apache via `sudo apachectl restart`. To verify if php works, creating a `phpinfo.php` in the `Sites` folder:
{% codeblock php phpinfo.php  %}
<?php
	phpinfo();
?>
{% endcodeblock %}
<!-- more -->
When visiting `localhost/~yourusername/phpinfo.php` you should see php mata information instead of plain text of the code.
- Install MySQL and phpMyAdmin
- Set MySQL root password `mysqladmin -u root password PASSWORD`
If you're getting `#2002 Cannot log in to the MySQL server` when logging in to phpmyadmin, try editing `phpmyadmin/config.inc.php` and change:
`$cfg['Servers'][$i]['host'] = 'localhost';`
to:
`$cfg['Servers'][$i]['host'] = '<IP_ADDRESS>';`
- Create VirtualHost by adding to the end of `/etc/apache2/extra/httpd-vhosts.conf`
{% codeblock %}
<VirtualHost *:80>
        DocumentRoot "PATH TO SITE ROOT"
        ServerName "SERVER.local"
        ErrorLog "/private/var/log/apache2/jason.local-error_log"
        CustomLog "/private/var/log/apache2/jason.local-access_log" common

        <Directory "PATH TO SITE ROOT">
                AllowOverride All
                Order allow,deny
                Allow from all
        </Directory>
</VirtualHost>
<VirtualHost *:80>
	DocumentRoot "PATH TO SITE ROOT"
	ServerName "SERVER.local"
	ErrorLog "/private/var/log/apache2/"SERVER.local"-error_log"
	CustomLog "/private/var/log/apache2/"SERVER.local"-access_log" common
	<Directory "PATH TO SITE ROOT">
		Options +Indexes
		AllowOverride All
		Order allow,deny
		Allow from all
	</Directory>
</VirtualHost>
{% endcodeblock %}
- Edit `/etc/hosts` to append ```<IP_ADDRESS> 	SERVER.local```

repository: huqiang/octopress

extension: markdown

repo_name: huqiang/octopress


text:
```
BOYCOTT on russia! Don't buy, sell, support - HELP TO STOP WAR!
«Русский военный корабль, иди на хуй!» (c) Grybov, Ukrainian Frontier Guard

ATTENTION: This is a demo - use it as you wish. Reference is appriciated.
If you want to thank - buy me coffee: https://secure.wayforpay.com/donate/asperi
```

Q: Optional Binding in parameter SwiftUI (by Sofiane Lyno)

A: There is special Binding constructor for this purpose

```
SingleFileView(showSheetModifFile: Binding(self.$showModifFileSheet),
   fileToModify: Binding(self.$fileToModify))
```

Update: alternate solution

```
struct FileDemoView: View {
    @State var showModifFileSheet : Bool? = false
    @State var fileToModify : File? = File()

    var body: some View {
        SingleFileView(showSheetModifFile: $showModifFileSheet, fileToModify: $fileToModify)
    }

}

struct SingleFileView: View {
    @Binding var showSheetModifFile : Bool?
    @Binding var fileToModify : File?

    init(showSheetModifFile : Binding<Bool?> = .constant(nil), fileToModify : Binding<File?> = .constant(nil)) {
        _showSheetModifFile = showSheetModifFile
        _fileToModify = fileToModify
    }

    var body: some View {
        Text("")
    }
}
```

gha_language: Swift


text:
# BOOKS REVIEWS
This is repository in which I have created a API which renders data to html templates from a JSON file. This is a book api with random books and their review.

# PROJECT SETUP

- `fork repository`
- `clone repoitory`
- `npm install`
- `npm run dev`

# API ROUTES

- `/api/books` OR `/api`
- `/api/book?id={bookID}`

branch_name: refs/heads/main


text:
# GiBUUToStdHep output file format.

The output format is based around a ROOT tree where each event contains a stdhep
particle stack of incoming and nuclear-leaving particles. Some extra generation
information is also included, as well as a best-guess at determining the
NEUT-equivalent neutrino interaction mode.

The individual output branches are well documented in the doxygen autodocs
below: GiRooTracker.

The correspondence between GiBUU's internal 'prodid' and the converted
Neut-equivalent code can be seen in the documentation for
GiBUUUtils::GiBUU2NeutReacCode.

The correspondence between GiBUU's internal particle numbering scheme and the
pdg codes can be seen in the documentation for: GiBUUUtils::GiBUUToPDG.

**Note:** Some of the GiBUU Ids correspond baryons without an equivalent PDG
code, there are also a few undocumented Ids that have been seen, in this case
the PDG code in the particle stack will unfortunately be 0.

**Note:** Following the GENIE convention, the struck nucleon is given a
`StdHepStatus == 11`.

**Note:** The target nucleus information is saved at index `1` in the StdHep
arrays. The `StdHepPdg` is a nuclear PDG code (100ZZZAAA0) and can be decomposed
into target A, and Z like:

    TargetZ = ((StdHepPdg[1] / 10000) % 1000);
    TargetA = ((StdHepPdg[1] / 10) % 1000);


text:
### [CVE-2010-3671](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2010-3671)
![](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

TYPO3 before 4.1.14, 4.2.x before 4.2.13, 4.3.x before 4.3.4 and 4.4.x before 4.4.1 is open to a session fixation attack which allows remote attackers to hijack a victim's session.

### POC

#### Reference
- https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=590719
- https://typo3.org/security/advisory/typo3-sa-2010-012/#Broken_Authentication_and_Session_Management

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

repository: trickest/cve

gha_language: HTML

repo_name: trickest/cve


text:
---
layout: article
mathjax: true
title: Rules of Inference
image: "/assets/images/covers/tim-johnson-Vwf8q3RzBRE-unsplash.jpg"
categories:
- DM
desc: ### Subtopics
imagealt: Cover Image for article
---

### Subtopics
- [Arguments]({% post_url 2021-06-04-arguments %})
- [Modus Ponens]({% post_url 2021-06-04-modus-ponens %})
- [Modus Tollens]({% post_url 2021-06-04-modus-tollens %})
- [Hypothetical syllogism]({% post_url 2021-06-04-hypothetical-syllogism %})
- [Disjunctive syllogism]({% post_url 2021-06-04-disjunctive-syllogism %})
- [Addition]({% post_url 2021-06-04-addition %})
- [Simplification]({% post_url 2021-06-04-simplification %})
- Conjunction Tautology
- [Resolution]({% post_url 2021-06-04-resolution %})
- [Fallacies]({% post_url 2021-06-04-fallacies %})
- [Rules of Inference of Quantified Statements]({% post_url 2021-06-04-rules-of-inference-of-quantified-statements %})
- [Universal Modus Ponens]({% post_url 2021-06-04-universal-modus-ponens %})
- [Universal Modus Tollens]({% post_url 2021-06-04-universal-modus-tollens %})
- [Proof by Cases Tautology]({% post_url 2021-06-04-proof-by-cases-tautology %})
- [Composition Rule]({% post_url 2021-06-17-composition-rule %})

This blog was published directly from my notes.
To check the source of my notes and images used in this blog, visit Credits.

To read my notes, download this repository.


text:
# BioMASS

[![Actions Status](https://github.com/biomass-dev/biomass/workflows/Tests/badge.svg)](https://github.com/biomass-dev/biomass/actions)
[![Documentation Status](https://img.shields.io/readthedocs/biomass-core/latest.svg?logo=read%20the%20docs&logoColor=white&&label=Docs&version=latest)](https://biomass-core.readthedocs.io/en/latest/?badge=latest)
[![PyPI version](https://img.shields.io/pypi/v/biomass.svg?logo=PyPI&logoColor=white)](https://pypi.python.org/pypi/biomass)
[![License](https://img.shields.io/badge/License-Apache%202.0-green.svg?logo=apache)](https://opensource.org/licenses/Apache-2.0)
[![Downloads](https://pepy.tech/badge/biomass)](https://pepy.tech/project/biomass)
[![PyPI pyversions](https://img.shields.io/pypi/pyversions/biomass.svg?logo=Python&logoColor=white)](https://pypi.python.org/pypi/biomass)
[![Language grade: Python](https://img.shields.io/lgtm/grade/python/g/biomass-dev/biomass.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/biomass-dev/biomass/context:python)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

<img align="left" src="https://raw.githubusercontent.com/biomass-dev/biomass/master/docs/_static/img/logo.png" width="300">

Mathematical modeling is a powerful method for the analysis of complex biological systems. Although there are many researches devoted on producing models to describe dynamical cellular signaling systems, most of these models are limited and do not cover multiple pathways. Therefore, there is a challenge to combine these models to enable understanding at a larger scale. Nevertheless, larger network means that it gets more difficult to estimate parameters to reproduce dynamic experimental data needed for deeper understanding of a system.

To overcome this problem, we developed _BioMASS_, a Python framework for **M**odeling and **A**nalysis of **S**ignaling **S**ystems. The BioMASS framework allows efficient optimization of multiple parameter sets simultaneously and generates the multiple parameter candidates that explain the signaling dynamics of interest. These parameter candidates can be further evaluated by their distribution and sensitivity analysis as a part of alternative information about the hidden regulatory mechanism of the system.

## Features

- Parameter estimation of ODE models
- Local sensitivity analysis
- Effective visualization of simulation results

## Documentation

Online documentation is available at https://biomass-core.readthedocs.io/.

## Installation

The BioMASS library is available at the [Python Package Index (PyPI)](https://pypi.org/project/biomass).

```bash
$ pip install biomass
```

BioMASS supports Python 3.7 or newer.

## Example

### Parameter estimation

```python
from biomass import Model, optimize
from biomass.models import Nakakuki_Cell_2010

model = Model(Nakakuki_Cell_2010.__package__).create()

optimize(model, x_id=range(1, 11))
```

![estimated_parameter_sets](https://raw.githubusercontent.com/biomass-dev/biomass/master/docs/_static/img/estimated_parameter_sets.png)

```python
from biomass import run_simulation

run_simulation(model, viz_type="average", stdev=True)
```

![simulation_average](https://raw.githubusercontent.com/biomass-dev/biomass/master/docs/_static/img/simulation_average.png)
Points (blue diamonds, EGF; red squares, HRG) denote experimental data, solid lines denote simulations.

### Sensitivity analysis

```python
from biomass import run_analysis

run_analysis(model, target="reaction", metric="integral", style="barplot")
```

![sensitivity_PcFos](https://raw.githubusercontent.com/biomass-dev/biomass/master/docs/_static/img/sensitivity_PcFos.png)

Control coefficients for integrated pc-Fos are shown by bars (blue, EGF; red, HRG). Numbers above bars indicate the reaction indices, and error bars correspond to simulation standard deviation.

## Citation

When using BioMASS, please cite the following paper:

- Imoto, H., Zhang, S. & Okada, M. A Computational Framework for Prediction and Analysis of Cancer Signaling Dynamics from RNA Sequencing Data—Application to the ErbB Receptor Signaling Pathway. _Cancers_ **12**, 2878 (2020). https://doi.org/10.3390/cancers12102878

## Author

[Hiroaki Imoto](https://github.com/himoto)

## License

[Apache License 2.0](https://github.com/biomass-dev/biomass/blob/master/LICENSE)

repository: johannesnicolaus/biomass

repo_name: johannesnicolaus/biomass


text:
Scrape ss.com category and collect data in Google Spreadsheet.
Project as part of Python and BeautifulSoup learning process.
Python files are served as base templates. Feel free to modify/adopt them as needed.

**How it works:**

1. Loads list(s) from ss.com categories. For example https://www.ss.com/lv/real-estate/flats/riga/agenskalns/sell/
2. Collects ad detail links from first page and writes these details and other vital information in Google Spreadsheet.
3. On next run only new ads are added.

**Requirements**

1. Python env. (tested with 2.7 only)
2. Libraries: requests, BeautifulSoup, sleep, datetime, gspread, ServiceAccountCredentials
3. Google Account and Sheets API enabled and access file.

**To get started**

`pip install -r requirements.txt` This should add all required libraries.

Enable Google Sheets API and generate credentials JSON. You can follow step 1 from this tutorial:
https://developers.google.com/sheets/api/quickstart/python

Create Google Sheet and share it with e-mail from JSON file ("client_email").

Copy JSON file content in `data/creds.json`.

Add five column names in top row: `Fetch date`, `URL`, `Price`, `Date`, `Description`.
Everything else script should be able to add by itself.

Add ss.com ad categories of interest (links) in `target_list` in python file. Change `google_filename` and `google_sheet_name` accordingly.

Run `python base.py` (tested with real estate) or  `python base_cars.py` (tested with cars).

Check scraping process in Sheet. Add this task to scheduler if needed.

**Important notes**

Template `base.py` is written for real estate. Template `base_cars.py` is for cars. These may work well
for other categories as well but do not hesitate to modify accordingly if needed.

This is tested only for Selling ads. Renting, Buying and Exchange ads may not work out of the box.

Google Sheet API has strict limits on read/write operation (https://developers.google.com/sheets/api/limits).
That' s why process should be paused on each ad.

repository: ArtisKrumins/sscom-scrapper

repo_name: ArtisKrumins/sscom-scrapper


text:
# vagralf
Vagrant shell provisioner for Alfresco Content Services

Tested with:
- Vagrant 2.0, 2.2
- Virtualbox 5.2, 6.0

but should work with any reasonably recent mix of the two

Steps:
```console
$ git clone https://github.com/saidone75/vagralf.git
$ cd vagralf
$ vagrant up
```

[![asciicast](https://asciinema.org/a/295525.svg)](https://asciinema.org/a/295525)

Listening on a private NIC with address <IP_ADDRESS>

Alfresco Share URL: http://<IP_ADDRESS>:8080/share

Username/password: admin/admin

## License
Copyright (c) 2020-2022 Saidone

Distributed under the MIT License

gha_language: Shell


text:
# angular-svg-character-animations

This project is generated with [yo angular generator](https://github.com/yeoman/generator-angular)
version 0.11.1.

## Build & development

Run `grunt` for building and `grunt serve` for preview.

## Testing

Running `grunt test` will run the unit tests with karma.

# Who's using this
This repository is pretty old now, but the code driving the character animations in [TrumpTweetTrumps](https://trumptweettrumps.com/) and [Mein Trumpf](https://mein.trumpfgames.com/).

gha_language: ApacheConf


text:
---
title: Adder/Subtractor
author:
author_email:

date: 2018/12/4 10:03:10
updated: 2018/12/4 10:03:10

type: components
category: -3002
order: 100

classname: _newSum
symbol: newSum
---
## Basic Description

> **The component models the addition and subtraction operation of 1-7 one-dimensional input signals, and each input port can be selected as one of three states of addition, subtraction and disable.**

## Parameter
### Configuration
| Parameter name | Remark | Type | Description |
| :--- | :--- | :--: | :--- |
| Name | Name of component | Text | Enter the name of this component |
| Input A | Input A | Select | Select "Input A" as "Add", "Subtract" or "Disable" |
| Input B | Input B | Select | Select "Input B" as "Add", "Subtract" or "Disable" |
| Input C | Input C | Select | Select "Input C" as "Add", "Subtract" or "Disable" |
| Input D | Input D | Select | Select "Input D" as "Add", "Subtract" or "Disable" |
| Input E | Input E | Select | Select "Input E" as "Add", "Subtract" or "Disable" |
| Input F | Input F | Select | Select "Input F" as "Add", "Subtract" or "Disable" |
| Input G | Input G | Select | Select "Input G" as "Add", "Subtract" or "Disable" |

## Pin List

| Pin name | Dimension | Description |
| :--- | :--:  | :--- |
| A | 1×1 | Input A，only valid when this pin is enabled |
| B | 1×1 | Input B，only valid when this pin is enabled |
| C | 1×1 | Input C，only valid when this pin is enabled |
| D | 1×1 | Input D，only valid when this pin is enabled |
| E | 1×1 | Input E，only valid when this pin is enabled |
| F | 1×1 | Input F，only valid when this pin is enabled |
| G | 1×1 | Input G，only valid when this pin is enabled |
| Output | 1×1 | Output pin |

## Using Instructions

## See Also

repository: CloudPSS/docs

repo_name: CloudPSS/docs


text:
# AScript

AScript (ArduinoScript, or An AScript) is my attempt to create a custom language that can be converted into assembly for use by the Arduino UNO's ATmega328P processor. I decided to do this while in CS383 (Computer Organization and Programming), in which we had to learn assembly language for use on an Arduino UNO with an ATmega328P processor.

## Syntax

#### Commenting

AScript has support for commenting, which works exactly the same way as the double slash comments available in C, C++, and other C-family languages. To illustrate:

```
//This is a byte called 'a'. It is instantiated as zero.
byte a = 0;

//This is an infinite loop that continuously increments a.
while(1) {
    a = a + 1;
};

```

#### Variables

Currently, the only datatype supported is byte. They can be instantiated like so:

```
byte foo = 12;
```

If a variable is not given an initial value, then it will automatically default to 0 in the compiler. Every program should only initialize variables at the start of the program, or outside of any loops. It is important to note that one should not name variables after tokens or numbers, since the compiler will treat those cases incorrectly. For example,

```
byte 123;
byte byte;
byte if;
```

are all extremely terrible things that you should not do in any program. One can also create arrays of values. These can be doing the following:

```
byte[6] byteArray;
byte i = 4;
byte j = byteArray[i];
```

In the segment above, the first line creates an array of length 6. Arrays can only be instantiated with a constant length, meaning that an array cannot be created with a length equal to the result of a computation. However, an array can be accessed based on the result of a computation. In the example, one can access the ith element of an array in order to assign it to a variable. This allows for a user to iterate over a list, which enables actions such as sorting.

#### Arithmetic

The compiler is written so that it will have the program run through the correct order of operations. The program will use the same order of operations used by the C family of operations. That is, ```() -> * -> + or - -> < or > -> == or != -> & -> |```. Currently, division is not supported, but that and other operations will eventually be supported.

#### Conditionals

AScript allows for if-else statements and while loops. Both must be terminated with a semicolon when present.

```
byte factorial = 1;
byte n = 2;
while(n <= 6) {
    factorial = factorial * n;
    n = n + 1;
};
```

This code snippet will iterate and compute n!. In the function, n will continuously decrement until it equals zero, in which case the loop will terminate.

```
byte input = 6;
if(input) {
    input = 0;
} else {
    input = 1;
};
```

This segment of code takes the value of input and sets it to zero if it is not already zero. Otherwise, it will set the value equal to 1. In a sense, this statement is equivalent to the ! operation, which negates the truth of a statement.

#### Functions
AScript also has the ability to allow users to write functions. Like with conditional statements, functions should be terminated with a semicolon. A function can be written like so:

```
function <TYPE> <NAME>(<TYPE> x, <TYPE> y) {
    ...
};
```

Here, <TYPE> represents any variable type that can be instantiated, and <NAME> is the name of the function. A function can also be called doing something like

```
byte x = byteFunc(2);
```

provided that there exists a function called byteFunc that takes a number. One can also call functions inside of other functions. So, one function that could be written is

```
function byte factorial(byte n) {
    if(n > 1) {
        return n * factorial(n-1);
    } else {
        return 1;
    };
};
```

Note that factorial takes a byte as a parameter, and returns a byte. In its code, it also calls a function that takes a byte as a parameter and returns a byte.

# Usage

Currently, there is no available builds of the compiler. However, the compiler source can be downloaded from here and compiled. To build the compiler, run the included makefile with

```
make all
```

This will compile the source into an executable. Then, run the executable with your sourcefile, which must be a .scr file, as a parameter:

```
./ascript srcfile.scr
```

Note that the source file must be a .scr file. The program will output the result into a .asm file in the current directory as long as it compiled correctly. The asm file can then be used in your IDE of choice. Compilation can go wrong in several instances. For example, if one does not provide a valid input file, the program will indicate this and immediately terminate.

The executable also provides several flags that can be enabled to customize compilation. They are as follows:

| Flag | Name | Description |
| ---- | ---- | ----------- |
| o | Output Selector |Sets the output file to compile to (must be an asm file). |
| O | Optimization Flag | Enables optimization. The compiler will give extra output to indicate the number of changes. |
| w | Warning Error Flag | Interprets all warnings as errors. |

For example, if I wanted to compile the sorting demo (examples/sorting.scr) to test.asm, using the O and w flags, I would run:

```
./ascript -o test.asm examples/sorting.scr -Ow
```

Note that the -o flag is separate from the other flags, and that test.asm immediately succeeds it. This rule must be followed when using the output flag, although -o does not have to be immediately after the program name.

## Future

In the future, I hope to add more functionality to the language. At this point, the language still needs to undergo a lot of testing and improvement. Future changes will hopefully include optimization and I/O through the Arduino's I/O ports.

repository: WattleFoxxo/AScript

repo_name: WattleFoxxo/AScript


text:
---
_id: 5a88e1afbd6dca0d5f0d2f94
title: "Differences Between ASP.NET Web API and ASP.NET MVC – Routing"
url: 'http://www.cloudydeveloper.com/?p=1971'
category: articles
slug: 'differences-between-asp-net-web-api-and-asp-net-mvc-routing'
user_id: 5a83ce59d6eb0005c4ecda2c
username: 'bill-s'
createdOn: '2012-07-27T07:21:19.000Z'
tags: []
---

I’ve done a fair amount of work with ASP.NET MVC over the years, and I understand how routing works in that world. Routing with ASP.NET Web API is bit different though and when I first started with it, some of the basics escaped me. Primarily, there’s an additional level of logic that executes when doing request to route matching. Specifically, the HTTP verb used in the request plays a critical role in determining which controller action method is invoked. Let’s see what happens when I try to simply add an additional method (i.e., endpoint) to a Web API controller.

repository: dotnetweekly/dnw-gatsby

repo_name: dotnetweekly/dnw-gatsby


text:
# [Slimming Down Your Docker Images](https://towardsdatascience.com/slimming-down-your-docker-images-275f0ca9337e)

* When building a Docker image, Docker looks through Dockerfile line by line
* Docker looks for each instruction's intermediate image in it's caching layer
* If it cannot find this instruction's image in it's caching layer, it, and all subsequent images are regenerated
* So if base image is not cached or is a cache miss, the entire image is regenerated
* So Docker will look for the `RUN pip install -r requirements.txt` instruction in locally cached intermediate images
  * No comparison between old and new requirements file is done (so no way to know if `requirements.txt` has been updated...yet)
* `ADD` and `COPY` do require Docker to take a look at file contents to see if anything has changed - if file is different than cache is invalidated
* If instructions are often going to change in Dockerfile, to take advantage of caching put these instructions as late in the Dockerfile as possible
  * This way, only a smaller subset of the Dockerfile will be regenerated when those instructions change
* To properly invalidate earlier `requirements.txt` example,
  * `COPY` the file first (since the file has changed, this instruction / cached image will be out of date and will force all subsequent images / caches to be regenerated)
* Use Alpine images as they're usually the best-maintained / slimmest / simplest
* Multistage builds use multiple `FROM` instructions
  * Can copy files from one stage to another and can leave behind anything you don't want in final image
  * Each `FROM` begins new stage of build
  * Leaves behind any state from previous stage
  * Can use different base
  * Adds complexity and is used to optimize memory as much as possible
  * Alias prior stage's build like `FROM golang:1.7.3 AS build` so it can be used later like `COPY --from=build`
* `.dockerignore` can help cache control simply by limiting any unnecessary files (both reducing image size and unnecessary files updating like log files and invalidating cached images)
* `docker container ls -s` - approximate size of running container
* `docker image ls` - size of images
* `docker image history my_image:my_tag` - size of intermediate images used to make up image
* Combine `RUN` `apt*` commands, including package installations to keep layer count down
  * `rm -rf /var/lib/apt/lists/*` at end of aforementioned `RUN` command so that `apt` cache is not stored in layer

repository: jaebradley/notes

repo_name: jaebradley/notes


text:
## Spree 2.3.0 (unreleased) ##

*   Drop first_name and last_name fields from spree_credit_cards.  Add
    first_name & last_name methods for now to keep ActiveMerchant happy.

    Jordan Brough

*   Replaced cookies.signed[:order_id] with cookies.signed[:guest_token].

    Now we are using a signed cookie to store the guests unique token
    in the browser.  This allows customers who close their browser to
    continue their shopping when they visit again.
    Since we set cookies.signed[:guest_token] whenever a vistor comes
    you may also use this cookie token on other objects than just orders.
    For instance if a guest user wants to favorite a product you can
    assign the cookies.signed[:guest_token] value to a token field on your
    favorites model.  Which will then allow you to analyze the orders and
    favorites this user has placed before which is useful for recommendations.

    Jeff Dutil

*   Order#token is no longer fetched from another table.

    Both Spree::Core::TokeResource and Spree::TokenizedPersmission are deprecated.
    Order#token value is now persisted into spree_orders.guest_token. Main motivation
    here is save a few extra queries when creating an order. The TokenResource
    module was being of no use in spree core.

    NOTE: Watch out for the possible expensive migration that come along with this

    Washington L Braga Jr

*   Replaced session[:order_id] usage with cookies.signed[:order_id].

    Now we are using a signed cookie to store the order id on a guests
    browser client.  This allows customers who close their browser to
    continue their shopping when they visit again.
    Fixes #4319

    Jeff Dutil

*   Order#process_payments! no longer raises. Gateways must raise on failing authorizations.

    Now it's a Gateway or PaymentMethod responsability to raise a custom
    exception any time an authorization fails so that it can be rescued
    during checkout and proper action taken.

*   Assign request headers env to Payment when creating it via checkout.

    This might come in handy for some gateways, e.g. Adyen, actions that require
    data such as user agent and accept header to create user profiles. Previously
    we had no way to access the request headers from within a gateway class

*   More accurate and simpler Order#payment_state options.

    Balance Due. Paid. Credit Owed. Failed. These are the only possible values
    for order payment_state now. The previous `pending` state has been dropped
    and order updater logic greatly improved as it now mostly consider total
    values rather than doing last payment state checks.

    Huge thanks to dan-ding. See https://github.com/spree/spree/issues/4605

*   Config settings related to mail have been removed. This includes
    `enable_mail_delivery`, `mail_bcc`, `intercept_email`,
    `override_actionmailer_config`, `mail_host`, `mail_domain`, `mail_port`,
    `secure_connection_type`, `mail_auth_type`, `smtp_username`, and
    `smtp_password`.

    These should instead be [configured on actionmailer directly](http://api.rubyonrails.org/classes/ActionMailer/Base.html#class-ActionMailer::Base-label-Configuration+options).
    The existing functionality can also be used by including the [spree_mail_settings](https://github.com/spree-contrib/spree_mail_settings) gem.

    John Hawthorn

*   refactor the api to use a general importer in `lib/spree/importer/order.rb`

    Peter Berkenbosch

*   Ensure transition to payment processing state happens outside transaction.

    Chris Salzberg

*   Increase the precision of the amount/price columns in order for support other currencies. See https://github.com/spree/spree/issues/4657

    Gonzalo Moreno

*   Preferences on models are now stored in a serialized `preferences` column instead of the `Spree::Preferences` table.

    `Spree::Preferences` are still used for configuration (like `Spree::Config`).
    For models with preferences (`Calculator`, `PromotionRule`, and
    `PaymentMethod` in spree core) they are now serialized using
    `ActiveRecord::Base.serialize`, storing the preferences as YAML in the
    `preferences` column.

    ```
    > c = Spree::Calculator.first
    => #<Spree::Calculator::Shipping::FlatRate id: 1, type: "Spree::Calculator::Shipping::FlatRate",
    calculable_id: 1, calculable_type: "Spree::ShippingMethod", created_at: "2014-06-29 21:56:59",
    updated_at: "2014-06-29 21:57:00", preferences: {:amount=>5, :currency=>"USD"}>
    > c.preferred_amount
    => 5
    > c.preferred_amount = 10
    => 10
    > c
    => #<Spree::Calculator::Shipping::FlatRate id: 1, type: "Spree::Calculator::Shipping::FlatRate",
    calculable_id: 1, calculable_type: "Spree::ShippingMethod", created_at: "2014-06-29 21:56:59",
    updated_at: "2014-06-29 21:57:00", preferences: {:amount=>10, :currency=>"USD"}>
    ```

    John Hawthorn

*   Add Spree::Store model for basic multi-store/multi-domain support

    This provides a basic framework for multi-store/multi-domain, based on the
    spree-multi-domain extension. Some existing configuration has been moved to
    this model, so that they can have different values depending on the site
    being served:

    * `Spree::Config[:site_name]` is moved to `name`
    * `Spree::Config[:site_url]` is moved to `url`
    * `Spree::Config[:default_meta_description]` is moved to `meta_description`
    * `Spree::Config[:default_meta_keywords]` is moved to `meta_keywords`
    * `Spree::Config[:default_seo_title]` is moved to `seo_title`

    A migration will move existing configuration onto a new default store.

    A new `ControllerHelpers::Store` concern provides a `current_store` helper
    to fetch a helper based on the request's domain.

    Jeff Dutil, Clarke Brunsdon, and John Hawthorn


text:
# PHPStomp Server
Pure PHP Reactive Message Queue Server

## Scope of work to do
- [ ] Define features of the server
- [ ] Narrow down the domain model
- [ ] Create basic async STOMP protocol parser
- [ ] Create adapter for ReactPHP
- [ ] Create adapter for pure libuv implementation

repository: phpstomp/server

repo_name: phpstomp/server


text:
# Quotes
This project was generated with [Angular CLI](https://github.com/angular/angular-cli) version 8.1.0.
## Screenshots
!-- ![homepage](images/screenshts/homepage_yp.png);

#BDD

 | Behavior :                                                |                                                Input .                                               |                                                                             Output example |.
| :-------------------------------------------------------- | :-------------------------------------------------------------------------------------------------: | -----------------------------------------------------------------------------------------: |
| User types the quote(s) and the author and selects the date and clicks on Add a Quote(S)||

## Setup/Installation Requirements
  Connect to the internet
  Download a web browser of your preference
    click here to open the link : <https://github.com/hukish/Quotes-master git>

 ##Known Bugs
   {In case you experience bugs kindly refresh your web page or restart your web browser }

## Technologies Used
  1 .Angular.
    2, CSS.
      3, bootstrap.
        4, html.
      5, Typescript.
        6, FontAWesome.

## Support and contact details

Contact me on my email address<EMAIL_ADDRESS>
## Development server
Github Link :https://github.com/hukish/Quotes-master.git

# LICENCE
MIT License

Copyright (c) 2019 Moringa School

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.

This project was generated with [Angular CLI](https://github.com/angular/angular-cli) version 8.0.6.

## Development server

Run `ng serve` for a dev server. Navigate to `http://localhost:4200/`. The app will automatically reload if you change any of the source files.

## Code scaffolding

Run `ng generate component component-name` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module`.

## Build

Run `ng build` to build the project. The build artifacts will be stored in the `dist/` directory. Use the `--prod` flag for a production build.

## Running unit tests

Run `ng test` to execute the unit tests via [Karma](https://karma-runner.github.io).

## Running end-to-end tests

Run `ng e2e` to execute the end-to-end tests via [Protractor](http://www.protractortest.org/).

## Further help

To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI README](https://github.com/angular/angular-cli/blob/master/README.md).

repository: hukish/Quotes-master

repo_name: hukish/Quotes-master


text:
---
layout: default
---

# 1996-02-01 - Japanese Firm Announces E-cash Implementation

## Header Data

From: Andrew Barrett/CheckFree Corporation<EMAIL_ADDRESS>To: cypherpunks<EMAIL_ADDRESS>Message Hash: 9672ac42af4060da76306e539c83a48840b1a28c52527673fd68af472de34eeb

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1996-02-01 18:20:00 UTC

Raw Date: Fri, 2 Feb 1996 02:20:00 +0800

## Raw message

```
{% raw  %}From: Andrew Barrett/CheckFree Corporation<EMAIL_ADDRESS>Date: Fri, 2 Feb 1996 02:20:00 +0800
To: cypherpunks<EMAIL_ADDRESS>Subject: Japanese Firm Announces E-cash Implementation
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

  Multimedia Business Analyst via Individual Inc. : NTT has developed a
secure electronic cash system for smart cards and  Internet-based
transactions, reports Reuter. Using very secure  encryption algorithms, the
system allows users to transfer cash from  their bank accounts to smart
cards after verification by the issuing  bank.

  NTT researcher Mikio Suzuki said the Japanese telecom operator plans to
begin trials of the system with a number of major city banks in the  near
future. These are expected to include Fuji Bank and Sakura Bank.

{% endraw %}
```

## Thread

+ Return to [February 1996](/archive/1996/02)

+ Return to "[Andrew Barrett/CheckFree Corporation <Andrew_Barrett@checkfree.com>](/authors/andrew_barrettcheckfree_corporation_andrew_barrett_at_checkfree_com_)"

+ 1996-02-01 (Fri, 2 Feb 1996 02:20:00 +0800) - Japanese Firm Announces E-cash Implementation - _Andrew Barrett/CheckFree Corporation<EMAIL_ADDRESS>


text:
---
title: English topics
category: [english]
excerpt: collect some english topics here.
---

# English Topics
***

## Topic one: Introduce your home

### Part one: introducing where you live
> I live in a two-dedroom apartment. The bedrooms are quite small, but there's a big living room with a dining area, a modern kitchen, and also a small balcony where we can sit outside in the summer.
```
  - Terraced house
  - Semi-detached house
  - Detached house
  - High-rise(us) = tower block(en)
  - Converted apartment = when a house is divided into apartments
  - Studio apartment = a one-room apartment, with the bedroom and living room together
  - Duplex apartment = an apartment with more than one floor
  - Balcony = terrace

```

### Part two: describing the inside of your home

```
  - Kitchen
  - living room
  - garden
```
### Part three: saying what you like or dislike about your home
##### Positive words for your home:
	- Spacious: large, with a lots of room
	- Cosy: comfortable in warm, welcoming way
	- Light: describes a home which gets lots of natural light
	- Warm/cool: comfortable in winter and summer
	- Convenient+for: close to other places you need to go regularly
 ##### negative words for your home:
	- Cramped: small, with not enough room
	- Dart: doesn't get much natural light
	- Drafty: lets in cold air in the winter
	- Stuffy: uncomfortable and airless in the summer
	- Noisy

### Part five: Talking about your neighbourhood = the area near your home
```
Suburb, Outskirts: 郊区

```
  My home is ..
	  ...in the city center
	  ...In the suburbs
	  ...Outside the city
	  ...On the outskirts of the city
	  ...In a village
    ...In the middle of nowhere

  > I live in a very lively area just south of the city centre. Thee are lots of cafes, shops, and places to go.

  > I live in a quiet area in the suburbs, in the north of the city. It is a nice area, and it's quite but it's a bit boring. There isn't really anything to go.

### Part six: conclusion
> I live in a two-storey terraced house. It has two bedrooms, a living room, a small kitchen and a garden. It's cosy and convenient for getting to work, but it's a bit cramped, especially when we have guests. I live with my wife and daughter. Our house is near the city center, in a quiet neighbourhood. There isn't much tod do, but there are some small shops and a park where we go if the weather's nice.

> I live by myself in a studio apartment. It just has one main room, with a tiny kitchen. It's very warm in winter, but it can get a bit stuffy in summer. I live in the city center, very close to everything. it's very lively, with lots of bars and restaurants. It's a good place for young people to live, but not many families choose to live herer.


text:
## Harberger Collectibles Smart Contracts

This is a smart contract platform for the deployment of scalable Harberger Collectibles on Ethereum. It's an extension of "This Artwork Is Always On Sale". (https://github.com/simondlr/thisartworkisalwaysonsale)

### Contracts

This is a work-in-progress.

The contracts consists of three components:

1) A global HarbergerSteward, responsible for collecting deposits and foreclosing ERC721. Forked from OpenZeppelin implementation.
2) ERC721 alongside a fixedOperator extension.
3) A Cheap Proxy Factory to readily deploy/mint Harberger Collectible ERC721 contracts.

### Front-end

The front-end is a modified version of 'This Artwork Is Always On Sale' with a routable interface to a deployed Harberger Collectible. The front-end checks if the contract interface complies with the standards and then displays the necessary information.

A demo is incoming.

### Testing

`npm run chain`
then
`truffle test`

The Gas Reporter is disabled (since it is slower). Enable gas reporter in truffle config to check.

The test may sometimes fail due to split-second changes in when the test is run due to patronage incrementing per second.
Just re-run.

NOTE: It costs ~$0.12 tx fee at 5 gwei gas price & 133 usd/eth to buy.

### Running

After installing packages, main directory:

`npm run chain`
or
`npm run moving_chain`

This creates a local ganache-cli instance. The latter includes auto-mining of blocks to showcase the patronage owed increasing on the front-end.

`truffle migrate`

This deploys the ERC721-artwork/nft & the ArtSteward.

`cd app`
`npm run start`

### Patronage As An Asset Class

This concept is based this blog post: https://blog.simondlr.com/patronage-as-an-asset-class. To create Patronage as an asset class.

### Thanks

The initial Steward code was inspired by code from Billy Rennekamp: https://github.com/okwme/harberger-ads-contracts & Todd Proebsting: https://programtheblockchain.com/posts/2018/09/19/implementing-harberger-tax-deeds/.

### License

Code License:
MIT


text:
---
Layout:
Title:	Secure Shell
Date:	2017-08-03
---

### SSH- Secure Shell

- Is a cryptographic network protocol for operating network services securely over an unsecured network.

- SSH uses public-key cryptography to authenticate the remote computer and allow it to verify the identity of the remote computer and the user on the network.

- SSH only verifies whether the same person who is offering the public key also owns the matching private key.

### Ways to use SSH:

- to use automatically generated Public-Private Key pair to encrypt a network connection, and then use password authentication to log on.

- or use a manually generated Public-Private Key pair to perform verification which allows programs or users to log on without specifying passwords.


text:
---
title: "Welcome McAfee & MS Azure Workshop"
weight: 80
chapter: true
draft: false
tags:

---

# Workshop Welcome

Thank you for attending this workshop! Here is a brief introduction of the lab objectives and what we hope you learn today.

![MVISION Azure](/images/mfe/McAfee-Microsoft-Azure.jpg?classes=border,shadow)

### What to expect ###

1- The initial use-case is based upon managing cloud resources through Cloud Security Posture Management (CSPM). As you deploy resources like AKS into Azure,
   McAfee MVISION Cloud will check configuration against best practices and standards.

2- MVISION Cloud Container Vulnerability Scan (CVS) assesses the vulnerability of container components. The scan evaluates the code embedded in containers at build    time, and periodically after that, to make sure that known risks are exposed or mitigated to reduce the opportunities malicious actors have to exfiltrate a          container workload.

3- The next use case concerns itself with sensitive data stored in Micrsoft Azure. Customers often do not have visibility into what kind of data lives in clouds.
   In this case, an Blob storage is protected by MVISION Cloud

4- Lastly, we will guide you through the "Shift Left" use-case. What if security principles were applied BEFORE a devops team pushed infrastructure?
   The scan results will show discrepancies that need to be remediated before being allowed to deploy to production.

repository: lmarecha-creator/mcafeecloudguru

repo_name: lmarecha-creator/mcafeecloudguru


text:
### Config File Manager
> this class written 5 years ago . it's better to not use regular expressions for performance and faster interpreting . this project is just for ... !

you may have file like this in your projects

**#config.ini**

 >Title=My App
 >TemplateDirectory=temp dir

start with create new instance of **ConfigFileManager**
```php
    $config = new ConfigFileManager('configs/config.ini');  //opening file config.ini from configs directory

    echo $config->Title;  //read  "Title" value which is equal to  "My App"

    $config->Title = "Your App";  //changing value of "Title"

    $config->save();  //save changes to config.ini easily
```
### installation
---
`composer require ghalambaz/config-file-manager `

repository: ghalambaz/ConfigFileManager

repo_name: ghalambaz/ConfigFileManager