text:
# react-component-generator

A CLI generator for React components, pages, styled-components and redux store, HTTP services, redux-box store, redux module.

## Install

```console
$ npm install -g reactjs-component-generator
```

## Usage

The most basic command runs a wizard to create a component.

```console
$ rg
```

**Note**: Names can be given in any format (slug-case, camelCase, PascalCase, UPPERCASE, lowercase etc.).

#### functional component

Directly create a functional component based on the current settings.

```console
$ rg functional-component <name>
```

#### class component

Directly create a class component based on the current settings.

```console
$ rg component <name>
```

#### Typescript component

Directly create a component with typeScript config based on the current settings.

```console
$ rg tscomponent <name>
```

The generated file will be
`*filename.ts *filename.scss`

#### Page [Recommended for Next.js]

Directly create a page based on the current settings.

```console
$ rg page <name>
```

The generated file will be
`*filename.js *index.js *filename.scss`

Arguments:

- `name`: The name you want to use for the component.

Options:

- `-d, --destination <destination>`: Override the destination for component.
- `-p, --template-path <template-path>`: Override template path.
- `-t, --template <template>`: Override template type. By default it uses the 'component' folder from the template path. With this option you can use a different template folder.
- `-f, --force`: Force creation of a component. By default it's impossible to create a component if the destination path doesn't exist. This option forces the creation of a component and will generates the destination folders if they don't exist.

Examples:

```console
$ rg component check-box
$ rg component RadioButton -d ./components/ui
$ rg component videoPlayer -d ./src/components/players/ -t base-video-component -f
```

The generated file will be
`*filename.css *index.js *filename.js`

#### Typescript Page [Recommended for Next.js + typeScript]

Directly create a page with typeScript config based on the current settings.

```console
$ rg tspage <name>
```

The generated file will be
`*filename.ts *index.ts *filename.scss`

#### styled component

Directly create a component based on the current settings with styled component.

```console
$ rg-styled <name>
```

Arguments:

- `name`: The name you want to use for the component.

Options:

- `-d, --destination <destination>`: Override the destination for component.
- `-p, --template-path <template-path>`: Override template path.
- `-t, --template <template>`: Override template type. By default it uses the 'component' folder from the template path. With this option you can use a different template folder.
- `-f, --force`: Force creation of a component. By default it's impossible to create a component if the destination path doesn't exist. This option forces the creation of a component and will generates the destination folders if they don't exist.

Examples:

```console
$ rg-styled check-box
$ rg-styled RadioButton -d ./my-component/ui
$ rg-styled videoPlayer -d ./src/my-component/players/ -t base-video-component -f
```

The generated file will be
`*filename.styled.js *index.js *filename.js`

#### redux [Recommended for redux]

Directly create a store based on the current settings.

```console
$ rg redux <name>
```

Arguments:

name: The name doen't have any impact here but required.
Options:

- `-d, --destination <destination>`: Override the destination for store.
- `-p, --template-path <template-path>`: Override template path.
- `-t, --template <template>`: Override template type. By default it uses the 'src' folder from the template path. With this option you can use a different template folder.
- `-f, --force`: Force creation of a store. By default it's impossible to create a store if the destination path doesn't exist. This option forces the creation of a component and will generates the destination folders if they don't exist.

Examples:

```
$ rg redux user
$ rg redux shopping-cart -d ./modules
$ rg redux Car -t complex-store
```

The generated file will be

```
$ user [Default module]
$ index.js [Container all the reducer]
```

#### redux module [Recommended for redux]

Directly create a store module based on the current settings.

```console
$ rg redux-module <name>
```

Arguments:

name: The name doesn't have any impact here but required.
Options:

- `-d, --destination <destination>`: Override the destination for store module.
- `-p, --template-path <template-path>`: Override template path.
- `-t, --template <template>`: Override template type. By default it uses the 'store' folder from the template path. With this option you can use a different template folder.
- `-f, --force`: Force creation of a store module. By default it's impossible to create a store module if the destination path doesn't exist. This option forces the creation of a store module and will generates the destination folders if they don't exist.

Examples:

```
$ rg redux-module user
$ rg redux-module shopping-cart -d ./modules
$ rg redux-module Car -t complex-store
```

The generated file will be

- action.js [All actions related to module]
- mutations.js [All mutations related to module]
- reducer.js [All reducer related to module]
- state.js [All state variable related to module]

#### route [using react-router]

Directly create a react-router route setup.

```console
$ rg route
```

#### services

Directly create a services based on the current settings.

```console
$ rg services <name>
```

Arguments:

name: The name doen't have any impact here but required.
Options:

- `-d, --destination <destination>`: Override the destination for services.
- `-p, --template-path <template-path>`: Override template path.
- `-t, --template <template>`: Override template type. By default it uses the 'src' folder from the template path. With this option you can use a different template folder.
- `-f, --force`: Force creation of a services. By default it's impossible to create a services if the destination path doesn't exist. This option forces the creation of a services and will generates the destination folders if they don't exist.

Examples:

```
$ rg services user
$ rg services shopping-cart -d ./modules
$ rg services Car -t complex-store
```

The generated file will be

- config [folder contains http request method, local storage methods, and api url file]
- user.js [Defaul service for api call]

#### service module

Directly create a service module based on the current settings.

```console
$ rg service-module <name>
```

Arguments:

name: The name you want to use for the service module.
Options:

- `-d, --destination <destination>`: Override the destination for service module.
- `-p, --template-path <template-path>`: Override template path.
- `-t, --template <template>`: Override template type. By default it uses the 'src/services' folder from the template path. With this option you can use a different template folder.
- `-f, --force`: Force creation of a service module. By default it's impossible to create a service module if the destination path doesn't exist. This option forces the creation of a service module and will generates the destination folders if they don't exist.

Examples:

```
$ rg service-module user
$ rg service-module shopping-cart -d ./modules
$ rg service-module Car -t complex-store
```

The generated file will be

- filename.js [contains api call request]

#### config [create a service configuration]

Directly create a service configuration based on the current settings.

```console
$ rg config <name>
```

Arguments:

name: The name you want to use for the config.
Options:

- `-d, --destination <destination>`: Override the destination for config.
- `-p, --template-path <template-path>`: Override template path.
- `-t, --template <template>`: Override template type. By default it uses the 'src/services' folder from the template path. With this option you can use a different template folder.
- `-f, --force`: Force creation of a config. By default it's impossible to create a config if the destination path doesn't exist. This option forces the creation of a config and will generates the destination folders if they don't exist.

Examples:

```
$ rg config util
$ rg config shopping-cart -d ./modules
$ rg config Car -t complex-store
```

The generated file will be

- apiUrl.js [contains api url ]
- request.js [contains http request methods (get, post, put, delete, patch, update)]
- storage.js [contains methods for local storage]

#### request

Directly create a request module based on the current settings.

```console
$ rg request <name>
```

Arguments:

name: The name you want to use for the request module.
Options:

- `-d, --destination <destination>`: Override the destination for request module.
- `-p, --template-path <template-path>`: Override template path.
- `-t, --template <template>`: Override template type. By default it uses the 'src/services/config' folder from the template path. With this option you can use a different template folder.
- `-f, --force`: Force creation of a config. By default it's impossible to create a request if the destination path doesn't exist. This option forces the creation of a request and will generates the destination folders if they don't exist.

Examples:

```
$ rg request apiRequest
$ rg request shopping-cart -d ./modules
$ rg request Car -t complex-store
```

The generated file will be

- filename.js [contains http request methods (get, post, put, delete, patch, update)]

#### storage

Directly create a storage module based on the current settings.

```console
$ rg storage <name>
```

Arguments:

name: The name you want to use for the storage module.
Options:

- `-d, --destination <destination>`: Override the destination for storage module.
- `-p, --template-path <template-path>`: Override template path.
- `-t, --template <template>`: Override template type. By default it uses the 'src/services/config' folder from the template path. With this option you can use a different template folder.
- `-f, --force`: Force creation of a storage. By default it's impossible to create a storage if the destination path doesn't exist. This option forces the creation of a storage and will generates the destination folders if they don't exist.

Examples:

```
$ rg storage localStorage
$ rg storage shopping-cart -d ./modules
$ rg storage Car -t complex-store
```

The generated file will be

- storage.js [contains methods for local storage]

#### setup

Directly create a setup for store and services based on the current settings.

```console
$ rg setup <name>
```

Arguments:

name: The name is required but doesn't have any impact.
Options:

- `-d, --destination <destination>`: Override the destination for setup.
- `-p, --template-path <template-path>`: Override template path.
- `-t, --template <template>`: Override template type. By default it uses the 'src' folder from the template path. With this option you can use a different template folder.
- `-f, --force`: Force creation of a setup. By default it's impossible to create a setup if the destination path doesn't exist. This option forces the creation of a setup and will generates the destination folders if they don't exist.

Examples:

```
$ rg setup text
$ rg setup shopping-cart -d ./modules
$ rg setup Car -t complex-store
```

This will generate the store and services module, the structure is mentioned above.

#### store [Recommended for redux-box]

Directly create a store module based on the current settings.

```console
$ rg store <name>
```

Arguments:

name: The name you want to use for the store module.
Options:

- `-d, --destination <destination>`: Override the destination for store module.
- `-p, --template-path <template-path>`: Override template path.
- `-t, --template <template>`: Override template type. By default it uses the 'store' folder from the template path. With this option you can use a different template folder.
- `-f, --force`: Force creation of a store. By default it's impossible to create a component if the destination path doesn't exist. This option forces the creation of a component and will generates the destination folders if they don't exist.

Examples:

```
$ rg store user
$ rg store shopping-cart -d ./modules
$ rg store Car -t complex-store
```

**Note**:This store is specifically for Redux-box users.
Take a look at redux-box : `https://www.npmjs.com/search?q=redux-box`

The generated file will be
`*action.js *index.js *mutations.js *sagas.js *state.js`

#### settings

Set or display settings. Without any options it will display the settings. By default it will set the settings locally in a .reactgenerator file.
You can also set global settings by using the global option ```-g --global```.

```console
$ rg settings
```

Options:

* ```-v, --view-destination <destination>```: Set default view destination.
* ```-c, --component-destination <destination>```: Set default component destination.
* ```-s, --store-destination <destination>```: Set default store destination.
* ```-t, --template-path <template-path>```: Set template path.
* ```-l, --log```: Log global or local settings depending on the global flag.
* ```-g, --global```: Set global settings.

Examples:
```console
$ rg settings -l
$ rg settings -v ./view -c ./component -s ./store/modules -t ./template
$ rg settings -g -c ./components
```

#### reset

Reset global settings to the defaults.

```console
$ rg reset
```

#### show-templates

Open the default template directory. The default templates can be edited to fit your needs.

```console
$ rg show-templates
```

#### copy-templates

Copy the default templates to another directory. This is handy when you want to customize the default templates.
Don't forget to run ```rg init``` or set the template path with ```rg settings```.

```console
$ rg copy-templates
```


text:
---
name: "\U0001F4A1 Ideas"
about: "If you have a \U0001F525 idea or proposals."
title: "[IDEA]"
labels: enhancement
assignees: luigel

---

<!--

PLEASE READ: FILLING IN THE TEMPLATE IS REQUIRED!
Issues that do not include enough information might not be picked up.

Have you read Laravel-Paymongo's
contributing guidelines (https://github.com/luigel/laravel-paymongo/blob/master/CONTRIBUTING.md)
and Code Of Conduct (https://github.com/luigel/laravel-paymongo/blob/master/CODE_OF_CONDUCT.md)?
By filing an Issue, you are expected to comply with it, including treating everyone with respect.

Please prefix your issue with: [IDEA].

-->

### Prerequisites

### Versions

<!-- Please be as exact and complete as possible when proving version numbers -->

* PHP version: <!-- put your FULL PHP version here -->
* Laravel version: <!-- put your FULL Laravel version here -->
* Package version: <!-- put FULL Laravel Paymongo package version here -->

### Description

<!-- Describe your proposal -->

### Example

<!-- Show an example of how this proposal will work.  -->

### Additional Information

Any additional information, configuration or data that might be needed to understand the proposal.

license: MIT

repository: luigel/laravel-paymongo

extension: md

gha_language: PHP

gha_license_id: MIT

license_type: permissive

repo_name: luigel/laravel-paymongo


text:
# PAClab - The Program Analaysis ColLABoratory

PAClab development repository using Django framework.

## This repository contains the frontend website for PACLab.

## Requirements
- Python3
- Pip
- dj-database-url==0.5.0
- Django==2.0.8
- python-decouple==3.1
- Pillow==5.2.0
- pytz==2018.5

## Installation
1. Install python
2. Install pip
3. Use pip to install django 2.0 or higher
4. Use command `pip install python-decouple` to install decouple
5. Use command `pip install dj-database-url` to install dj-database-url
6. Open terminal in location you want to install package
7. Initialize Django project: `django-admin startproject paclab`
8. Open `paclab/settings.py` and cut the string from the setting `SECRET_KEY`
9. Create a file named `.env` and add these lines:
   - `SECRET_KEY=your-secret-key-from-previous-step`
   - `DEBUG=True`
   - `ALLOWED_HOSTS=your-server-name` or localhost if using django's packaged development server
   - `DATABASE_URL=sqlite:///db.sqlite3` or url to your database
10. Clone repository from GitHub into your project directory
11. Navigate terminal to root of project directory (where `manage.py` is)
12. Create an admin user: `python3 manage.py createsuperuser`
13. Create migration files for database: `python3 manage.py makemigrations website`
14. Create database tables: `python3 manage.py migrate`
15. Run django's development server using command: `python3 manage.py runserver`

If you're using Ubuntu + Apache we recommend using this guide: https://www.digitalocean.com/community/tutorials/how-to-serve-django-applications-with-apache-and-mod_wsgi-on-ubuntu-16-04 to help set up Django on your server

repository: rebbrunner/paclab-www

branch_name: refs/heads/master

repo_name: rebbrunner/paclab-www


text:
# Welcome to Magja

Magento is a popular and emerging open-source e-commerce platform written in PHP with a market share of [around 30%](https://en.wikipedia.org/wiki/Magento).

Magja provides a Java Connector for Magento's Core API that allows easy integration with the shop installation and allows for exchange data offered by the API.
In doing so, Magja bridges the gap between the PHP system and Java ecosystem by offering a Java-Style client for integration in any kind  of applications.

## Core Features
Magja currently provides the following features:

 - Basic support for **Magento 1.x SOAP API V1**
 - Rich API support
 - Open for custom extensions of the API (without code generation)

Magja allows for exchange of the following data with your Magento installation:

 - Product data
 - Product media
 - Product link
 - Product categories
 - Product attributes
 - Country data
 - Region data
 - Customer data
 - Order data
 - Invoice data
 - Cart data

## Getting started

## Installation and configuration

Magja artifacts are available in the Maven central repository. Please add the dependency to your project:

    <dependency>
      <groupId>net.magja</groupId>
      <artifactId>magja</artifactId>
      <version>1.1.0</version>
    </dependency>

to get started. In order to connect to your Magento Shop installation, you need to put `magento-api.properties` on your classpath.
You can copy an example properties from samples folder. Essentially, the properties are self-explanatory:

    # SOAP XML/RPC user
    magento-api-username=<replace with user>

    # SOAP XML/RPC api key
    magento-api-password=<replace with api key>

    # URL of the Magento installation
    # If your shop is installed not using a prefix e.g. /magento
    # please add the prefix to the path:
    # http://<yourmagento-host>/magento/index.php/api/soap/
    magento-api-url=http://<yourmagento-host>/index.php/api/soap/

    # the ID of the default attribute set
    default-attribute-set-id=4

    # the ID of the default root category
    default-root-category-id=2

For further configuration please refer the [configuration guide](configuration.html).

## Basic usage

Magja is offering a set of services which can be used to access the Magento API. A service can be obtained
from the `RemoteServiceFactory` instance. The sample usage is demonstrated below:

    Logger log = LoggerFactory.getLogger("logger");
    RemoteServiceFactory remoteServiceFactory = new RemoteServiceFactory(MagentoSoapClient.getInstance());
    ProductRemoteService productService = remoteServiceFactory.getProductRemoteService();

    Product product = new Product();
    product.setSku("0001-QWER-12090");
    product.setName("Milk");

    try {
      productService.add(product);

      List<Product> allProducts = productService.listAll();
      for (Product shopProduct : allProducts) {
        log.info("{}", shopProduct);;
      }

    } catch (ServiceException e) {
      log.error("Error manipulating products", e);
    } catch (NoSuchAlgorithmException e) {
      log.error("Error manipulating products", e);
    }

More examples can be found in the [examples section](examples.html)


text:
---
layout: post
title: 'Quick hack: Calendar Inviter'
tags:
- appsscript
- calendar
- gmail
- google
- outlook
---

Working in different organisations sometimes means having different email addresses and calendars. Currently I have two Outlook instances I have to manage (one for [Bluefin](http://www.bluefinsolutions.com) and one for a client) on top of my Google-based personal calendar.

Keeping them in sync is a struggle that I avoid, but there’s recently been a specific case where I do want to make the effort, and that’s time / location scheduling – where I’ll be, on what days. This information needs to be in all calendars, to share with work colleagues, and for my own sanity (I see my Google calendar as my master instance in this case).

![image]({{ "/images/2014/01/calendars.jpg)So I wrote a quick Google Apps Script hack to allow me to quickly specify the where/when events in a particular Google calendar that I maintain (called “Work”" | url }}), and then have those events distributed, via invitations, to my other Outlook identities. It’s not very sophisticated – all it does is look through the Work calendar for all-day events matching a certain title pattern, then look at the guest list; if the emails I want to share the event with are not already on the list, they’re added, and invites are sent.

Because of [an issue with the CalendarService component of Google Apps Script](https://code.google.com/p/google-apps-script-issues/issues/detail?id=574) (that’s been open since May 2011!) you can’t directly cause invites to be sent to new guests that you add to an existing event. So one workaround is to create the calendar invitation (ICS file) yourself and email it. It’s pretty simple (and Romain Vialard [has an example](https://code.google.com/p/google-apps-script-issues/issues/detail?id=574#c2) in the commentary on the issue).

Actually creating the ICS file myself was a solution to not one but two issues. The ICS files that are auto-generated by Google Calendar when you add a guest via the UI contain entries like this for all-day events:

DTSTART;VALUE=DATE:20140305
 DTEND;VALUE=DATE:20140306

Unfortunately Outlook makes an incorrect guess as to the timezone for these dates, based on its own timezone, and when the recipient calendar is in a different timezone than the originating event (in my case UTC and UTC+1), it causes the replicated entry to be skewed by an hour, causing the all-day event to span the wrong days! So being in control of the ICS content generation means I can be more explicit which in turn means that Outlook doesn’t get it wrong.

DTSTART:20140305T000000Z
 DTEND:20140306T000000Z

So that’s it. [I’ve made the script available as a Gist](https://gist.github.com/qmacro/8219400) on Github and here’s a screenshot of some typical results.

![image]({{ "/images/2014/01/log.jpg" | url }})

Share & enjoy!

branch_name: refs/heads/main

gha_language: CSS


text:
# Credits, Notes, and Reference

## Previous Version of the App

  + https://github.com/data-creative/NextTrainCT

## Flutter Installation on Mac

  + https://appdividend.com/2018/12/10/how-to-install-flutter-on-mac/
  + https://flutter.dev/
  + https://flutter.dev/docs/get-started/install/macos
  + https://flutter.dev/docs/get-started/install/macos#update-your-path
  + https://flutter.dev/docs/get-started/editor?tab=vscode
  + restart VS code, then run "Flutter: Run Flutter Doctor" in the VS Code command pallete, or `flutter doctor` in the terminal. both should work. resolve any issues raised by the doctor.
  + optionally run `flutter config --no-analytics`

### Android Studio Configuration

  + https://flutter.dev/docs/get-started/install/macos#install-android-studio
  + in Android Studio: Configure > Plugins, install the "flutter" plugin by flutter.io, and restart the application

#### Acceleration

  + https://developer.android.com/studio/run/emulator-acceleration
  + "When you create an Android Virtual Device (AVD) in the AVD Manager, you can specify whether the emulator should use hardware or software to emulate the GPU of the AVD. Hardware acceleration is recommended and is typically faster. However, you might need to use software acceleration if your computer uses graphics drivers that aren't compatible with the emulator."
  + "SDK Tools: Latest release recommended (version 17 minimum)"
  + "SDK Platform: Latest release recommended (Android 4.0.3, Revision 3, minimum)"
  + https://developer.android.com/studio/run/emulator-commandline#starting
  + `emulator -list-avds`

### Emulator / Virtual Device

  + "need an Android device running Android 4.1 (API level 16) or higher."
  + https://flutter.dev/docs/get-started/install/macos#set-up-the-android-emulator
  + create a new device

### New App

  + vs code command pallette: "Flutter: New Project". this invokes `flutter create --ios-language objc --android-language java .`
  + "In order to run your application, type: `flutter run`"
  + "Your application code is in ./lib/main.dart."

### Running the App

  + from Android Studio > AVD Manager, run the emulator
  + https://flutter.dev/docs/get-started/test-drive?tab=vscode
  + https://dartcode.org/docs/quickly-switching-between-flutter-devices/
  + vs code command pallette: "Flutter: Select Device" to verify the device is running
  + press F5 to run the app on the emulator (might need to hold "fn" key to do it)
  + ... "Launching lib/main.dart on Android SDK built for x86 in debug mode..."

### Editing the App

  + edit components in the lib/main.dart file and watch hot reload update the app in the emulator. pretty cool.

## Flutter Framework

  + `Widget`, `StatelessWidget`, `StatefulWidget` `State` come from `package:flutter/src/widgets/framework.dart`
  + `MaterialApp` and `ThemeData` comes from `package:flutter/material.dart`
  + https://youtu.be/5VbAwhBBHsg

### Material Design Components

  + https://github.com/flutter/flutter/blob/master/packages/flutter/lib/material.dart
  + https://flutter.dev/docs/development/ui/widgets/material
  + https://api.flutter.dev/flutter/material/material-library.html
  + https://api.flutter.dev/flutter/material/MaterialApp-class.html
  + https://www.youtube.com/watch?v=DL0Ix1lnC4w

### Testing Flutter Apps

  + https://flutter.dev/docs/testing
  + https://medium.com/flutter/test-flutter-apps-on-travis-3fd5142ecd8c

### Debugging Flutter Apps

  + https://flutter.dev/docs/testing/code-debugging
  + https://flutter.dev/docs/testing/code-debugging#logging
  + https://flutter.dev/docs/testing/code-debugging#setting-breakpoints
  + Hmm only see print statements when running via the terminal

## Dart Language Reference

  + https://dart.dev/guides/language
  + https://dart.dev/guides/language/language-tour
  + https://dart.dev/guides/language/effective-dart
  + [Loading code from other files](https://stackoverflow.com/a/48875430/670433)
  + https://flutter.dev/docs/get-started/flutter-for/react-native-devs
  + "If you're using the Flutter SDK, don’t use the pub command directly. Instead use the flutter pub command, as described in Using packages on the Flutter website."
  + `flutter pub run lib/my_script.dart`
  + when I run the script the breakpoint pauses but i'm not able to interact.
  + https://stackoverflow.com/questions/57242352/how-to-interact-with-dart-debugger-from-the-command-line
  + https://dart.dev/tutorials/server/get-started
  + https://flutter.dev/docs/testing/build-modes#debug
  + https://flutter.dev/docs/testing/build-modes#profile
  + https://flutter.dev/docs/development/tools/devtools/cli
  + https://flutter.dev/docs/development/tools/devtools/debugger
  + VS Code Command Pallette: "Dart: New Project" .... needs stagehand. `pub global activate stagehand`
  + https://pub.dev/packages/stagehand
  + https://github.com/dart-lang/stagehand
  + [Installing dart via Homebrew](https://dart.dev/get-dart): `brew tap dart-lang/dart` and `brew install dart`
  + Running the script: `dart bin/main.dart`
  + Scripts go in the bin/ dir. Imports / modules go in the lib/ dir.
  + https://stackoverflow.com/questions/32108457/whats-the-difference-between-pub-dependencies-and-dev-dependencies
  + https://dart.dev/tools/pub/dependencies#dev-dependencies
  + https://dart.dev/tools/pub/pubspec
  + https://docs.travis-ci.com/user/languages/dart
  + https://dartpad.dartlang.org/

### Debugging

```dart
import "dart:developer";

main() {

  var x = 1;
  print("X: ${x}");

  var y = 2;
  debugger();
  print("Y: ${y}");

}
```

```sh
dart --observe bin/main.dart # then go visit the URL
```

Not able to interact...

```
Debugging isolate isolate 868979621 'main'
Type 'h' for help
Paused at main.dart:22:18
$ y
No such command: 'y'
$ h
List of commands:

break        - Add a breakpoint by source location or function name (hotkey: [F8])
clear        - Remove a breakpoint by source location or function name (hotkey: [F8])
cls          - Clear the console
continue, c  - Resume execution of the isolate (hotkey: [F7])
delete       - Remove a breakpoint by breakpoint id
down         - Move down one or more frames (hotkey: [Page Down])
finish       - Continue running the isolate until the current function exits
frame, f     - Set the current frame
help         - List commands or provide details about a specific command
info         - Show information on a variety of topics
isolate, i   - Switch, list, rename, or reload isolates
log          - Control which log messages are displayed
next, n      - Continue running the isolate until it reaches the next source location in the current function (hotkey: [F9])
next-async   - Step over await or yield
next-sync    - Run until return/unwind to current activation.
pause        - Pause the isolate (hotkey: [Ctrl ;])
print, p     - Evaluate and print an expression in the current frame
refresh      - Refresh debugging information of various sorts
reload       - Reload the sources for the current isolate
rewind       - Rewind the stack to a previous frame
set          - Set a debugger option
step, s      - Continue running the isolate until it reaches the next source location (hotkey: [F10]
up           - Move up one or more frames (hotkey: [Page Up])
vm           - Manage a Dart virtual machine

For more information on a specific command type 'help <command>'
For a list of hotkeys type 'help hotkeys'

Command prefixes are accepted (e.g. 'h' for 'help')
Hit [TAB] to complete a command (try 'is[TAB][TAB]')
Hit [ENTER] to repeat the last command
Use up/down arrow for command history

$ print(y)
No such command: 'print(y)'
$ p(y)
No such command: 'p(y)'
$ next
Continuing...
Paused at main.dart:22:3
```

### Classes

  + https://dart.dev/guides/language/language-tour#classes
  + https://www.tutorialspoint.com/dart_programming/dart_programming_classes

``` dart
class class_name {
   <fields>
   <getters/setters>
   <constructors>
   <functions>
}
```

  + https://www.w3adda.com/dart-tutorial/dart-classes
  + https://dart.dev/guides/language/language-tour#instance-variables
  + https://stackoverflow.com/a/55769496/670433
  + https://stackoverflow.com/a/54346031/670433

### The `http` Package

  + https://pub.dev/packages/http
  + https://github.com/dart-lang/http
  + https://pub.dev/documentation/http/latest/


text:
# A deep dive into Go’s http package
access to information from the Internet is as important as access to the local file system. Go provides a collection of packages, grouped under net, that make it easy to send and receive information through the Internet, make low-level network connections, and set up servers etc.

To illustrate the minimum necessary to retrieve information over HTTP, here’s a simple program called fetch that fetches the content of each specified URL and prints it as uninterpreted text; it’s inspired by the invaluable utility curl. Obviously one would usually do more with such data, but this shows the basic idea.

```

package main

import (
	"fmt"
	"io/ioutil"
	"net/http"
	"os"
)

func main() {
	for _, url := range os.Args[1:] {
		resp, err := http.Get(url)
		if err != nil {
			fmt.Fprintf(os.Stderr, "fetch: %v \n", err)
			os.Exit(1)
		}
		b, err := ioutil.ReadAll(resp.Body)
		resp.Body.Close()
		if err != nil {
			fmt.Fprintf(os.Stderr, "fetch : reading %s: %v\n ", url, err)
			os.Exit(1)
		}
		fmt.Printf("%s", b)
	}
}

```
output
```
go run main.go https://gopherlabs.collabnix.com

```

program introduces functions from two packages, ` net/http ` and ` io/ioutil`. The ` http.Get` function makes an HTTP request and, if there is no error, returns the result in the response struct resp. The Body field of resp contains the server response as a readable stream.

Next, ` ioutil.ReadAll ` reads the entire response; the result is stored in `b`. The Body stream is closed to avoid leaking resources, and Printf writes the response to the standard output.

# Fetching URLs Concurrently

```
//  fetching URLs Concurrently
package main

import (
	"fmt"
	"io"
	"io/ioutil"
	"net/http"
	"os"
	"time"
)

func main() {
	start := time.Now()
	ch := make(chan string)
	for _, url := range os.Args[1:] {
		go fetch(url, ch) // start a goroutine
	}
	for range os.Args[1:] {
		fmt.Println(<-ch)
	}
	fmt.Printf("%.2fs elapsed\n", time.Since(start).Seconds())
}

func fetch(url string, ch chan<- string) {
	start := time.Now()
	resp, err := http.Get(url)
	if err != nil {
		ch <- fmt.Sprint(err) // sent to channel
		return
	}
	nbytes, err := io.Copy(ioutil.Discard, resp.Body)
	resp.Body.Close()
	if err != nil {
		ch <- fmt.Sprintf("while reading %s: %v", url, err)
		return
	}
	secs := time.Since(start).Seconds()
	ch <- fmt.Sprint("%.2fs %s", secs, nbytes, url)
}
```
output
```
sangam$ go run main.go https://google.com https://google.com
%.2fs %s0.955698938 14029https://google.com
%.2fs %s1.324267501 14061https://google.com
1.32s elapsed
```
A goroutine is a concurrent function execution. A channel is a communication mechanism that allows one goroutine to pass values of a specified type to another goroutine. The function main runs in a goroutine and the go statement creates additional goroutines.

The main function creates a channel of strings using make. For each command-line argument, the go statement in the first range loop starts a new goroutine that calls fetch asynchronously to fetch the URL using http.Get. The io.Copy function reads the body of the response and discards it by writing to the ioutil.Discard output stream. Copy returns the byte count, along with any error that occurred. As each result arrives, fetch sends a summary line on the channel ch. The second range loop in main receives and prints those lines.

When one goroutine attempts a send or receive on a channel, it blocks until another goroutine attempts the corresponding receive or send operation, at which point the value is transferred and both goroutines proceed. In this example, each fetch sends a value (ch <- expression) on the channel ch, and main receives all of them (<-ch). Having main do all the printing ensures that output from each goroutine is processed as a unit, with no danger of interleaving if two goroutines finish at the same time.

# web server
Go’s libraries makes it easy to write a web server that responds to client requests like those made by fetch. In this section, we’ll show a minimal server that returns the path component of the URL used to access the server. That is, if the request is for http://localhost:8000/gopherlabs, the response will be URL.Path = "/gopherlabs".

```
package main

import (
	"fmt"
	"log"
	"net/http"
)

func main() {
	http.HandleFunc("/", handler) // each request calls handler
	log.Fatal(http.ListenAndServe("localhost:8000", nil))

}

// handler echoes the path component of the request URL.
func handler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "URL.Path = %q\n", r.URL.Path)

}

```
output
```
sangam$ go run main.go https://localhost:8000 URL.Path = "/gopherlabs"
```
via
open in browser http://localhost:8000/gophelabs

The program is only a handful of lines long because library functions do most of the work. The main function connects a handler function to incoming URLs whose path begins with /, which is all URLs, and starts a server listening for incoming requests on port 8000. A request is represented as a struct of type http.Request, which contains a number of related fields, one of which is the URL of the incoming request. When a request arrives, it is given to the handler function, which extracts the path component (/hello) from the request URL and sends it back as the response, using fmt.Fprintf.

repository: sahanabalappa/gopherlabs

repo_name: sahanabalappa/gopherlabs


text:
# Snowball

* petabyte-scale data transport solution in **disk format**
* uses secure appliance to **import or export data to AWS S3**
* solves high data transfer issues:
  * high network costs
  * long transfer times
  * security concerns
* simple, fast secure process as little as 1/5th the cost of high speed internet
* 50TB or 80TB
* Security:
  * tamper-resistant enclosure
  * 256-bit encryption
  * industry standard TMP (Trusted Platform Module) that ensure secuity and full chain-of-custody of data
  * upon completion of transfer, AWS performs a software erasure of Snowball appliance

* Snowball Edge
  * 100TB with onboard storage and compute properties
  * move LARGE amounts of data
  * temporary storage tier for large local datasets
  * support local workloads in remote or offline locations
  * connects to existing applications/infrastructure
  * can be clustered to form local storage tier

* Snowmobile
  * Exabyte-scale data transfer service used to move REALLY LARGE amounts of data
  * up to 100PB per Snowmobile
  * 45 foot long truck with ruggidized shipping container
  * great for video libraries, image repos, complete data centers

* When to use Snowball
  * Internet connection: T3
  * No. of theoretical days of network utilization: 269
  * when to use Snowball = 2TB or more

  * Internet connection: 100Mbps
  * No. of theoretical days of network utilization: 120
  * when to use Snowball = 5TB or more

  * Internet connection: 1000Mbps
  * No. of theoretical days of network utilization: 12
  * when to use Snowball = 60TB or more

  > *Back to S3 Notes:* [S3 README](./README.md)


text:
# ShapefileLoader

Shapefile loader

| Loader                | Characteristic                                                           |
| --------------------- | ------------------------------------------------------------------------ |
| File Extension        | `.shp`,                                                                  |
| File Type             | Binary, Multi-File                                                       |
| File Format           | [Shapefile](https://www.esri.com/library/whitepapers/pdfs/shapefile.pdf) |
| Data Format           | [Geometry](/docs/specifications/category-gis)                            |
| Supported APIs        | `load`, `parse`, `parseSync`                                             |
| Decoder Type          | Synchronous                                                              |
| Worker Thread Support | Yes, For Some Loaders                                                    |

## Usage

```js
import {ShapefileLoader} from<EMAIL_ADDRESS>import {load} from<EMAIL_ADDRESS>
const data = await load(url, ShapefileLoader);
```

## Options

N/A

## Format Summary

ESRI Shapefiles are a popular file format for storing geospatial vector data.
The format consists of a number of files that must be stored together and with
the same file name. Files with extensions `.shp`, `.shx`, `.dbf` must exist;
additional files with other extensions such as `.prj` and `.cpg` may exist.

| File   | Type   | Contents                                                                                |
| ------ | ------ | -------------------------------------------------------------------------------------------------------------- |
| `.shp` | Binary | The geometry, i.e. the geometry column in the resulting table.                                                 |
| `.dbf` | Binary | The attributes, i.e. the data columns in the resulting table.                                                  |
| `.shx` | Binary | The index (technically required, however it is sometimes possible to open shapefiles without the index)        |
| `.prj` | Text   | A small usually single line text file containing a WKT-CRS style projection. WGS84 is assumed if not present.  |
| `.cpg` | Text   | A small text file containing a text encoding name for the DBF text fields. `latin1` is assumed if not present. |

gha_license_id: NOASSERTION


text:
# Open SoC Debug Python Bindings

`opensocdebug` is a Python 3 library exposing the Open SoC Debug Software Reference Implementation (`libosd`) to Python.

This package is compatible with Python 3 on Linux only.
The source code is available from [GitHub](https://github.com/opensocdebug/osd-sw/tree/master/src/python).
The bindings are implemented using [Cython](https://cython.org/).

## Install from Source

- libosd and libglip must be installed on the system, including its development headers.
  The pkgconfig files (`*.pc`) must be present in the search path of pkgconfig.
  If you installed libosd or libglip into a non-standard location, pass the directories containing the `libosd.pc` and `libglip.pc` files through the environment variable `PKG_CONFIG_PATH`.

```sh
# optional (example, see see above for details)
export PKG_CONFIG_PATH=$HOME/libosd-install/share/pkgconfig:$HOME/libglip-install/lib/pkgconfig:$PKG_CONFIG_PATH

git clone https://github.com/opensocdebug/osd-sw.git
cd osd-sw/src/python
pip3 install --user -e .
```

## Develop

During the development you want to re-build the C extension (in `src/osd.c`) from the corresponding `src/osd.pxd` file using Cython.
To avoid running pip repeatedly you can use the following command (note the `--use-cython` to rebuild the C sources!):

```sh
make devbuild
```

To make use of the library point the `PYTHONPATH` environment variable containing the resulting `.so` file.
If `libosd.so` or `libglip.so` are not in your default library search path, make them available by using `LD_LIBRARY_PATH`.

### Debugging

If you experience a segfault during the execution of a Python script using this package you can get a stacktrace from GDB using the following command:

```sh
gdb -return-child-result -batch -ex r -ex bt --args python3 your_python_code.py
```

## Run the tests

```sh
# Install development requirements
# (Run this in the directory containing this README file.)
pip3 install -r dev-requirements.txt

# run the tests
python3 -m pytest

# or (as run in CI)
tox
```

## Run the tests with ASAN

The tests can also be run in an ASAN-enabled build of libosd (i.e. configured with `./configure --enable-asan`).
For that to work use

```sh
make pytest-asan
```

**Important:**
Running pytest with an ASAN-enabled libosd on Ubuntu 16.04 and 18.04 doesn't work.
The only real workaround is to use another distribution to run pytest with ASAN.

On Ubuntu 16.04 Python is compiled without PIE, which causes the error message `Shadow memory range interleaves with an existing memory mapping. ASan cannot proceed correctly. ABORTING`.

On Ubuntu 18.04, pytest fails with the error message `AddressSanitizer CHECK failed: ../../../../src/libsanitizer/asan/asan_interceptors.cc:734 "((__interception::real_memcpy)) != (0)" (0x0, 0x0)`.
This is caused by Ubuntu shipping a broken version of of gcc/libasan which prevents the usage of ASAN-enabled libraries with Python.
See `Ubuntu bug #1762683 <https://bugs.launchpad.net/ubuntu/+source/gcc-7/+bug/1762683>`_ and `AddressSanitizer bug #934 <https://github.com/google/sanitizers/issues/934>`_ for details.


text:
---
layout: post
title: intersection
---

Businessmodel of Intersection
------------------------------

### Customer Segments

Intersection has a segmented market business model, with customer segments that have slightly different needs. Its customer groups are as follows:

 * For-Profit Brands – The company provides advertisers the opportunity to promote their products and services on its public media platforms.
* Non-Profit Organizations – The company helps organizations create new products, services, systems, and experiences through its design and technology consultancy.
 ### Value Proposition

Intersection offers four primary value propositions: accessibility, price, performance, and brand/status.

The company creates accessibility by increasing the availability of various services. Its kiosks provide WiFi and phone service to consumers outside their homes, enabling them to obtain information and communicate with others while on the go. It also offers USB charging ports in case consumers’ device batteries become drained, and a 911 button that they can press in case of an emergency.

The company offers a price value proposition. The services offered through its kiosk are 100% free as costs are covered by allowing advertisers to promote their products/services on its screens.

The company demonstrates strong performance through tangible results. Each kiosk is powered by a fiber optic network that delivers speeds up to 100 times faster than the average public WiFi.

The company has established a strong brand due to its success. It plans to roll out 7,500 kiosks over the next few years, which it estimates will generate $500 million in revenues for New York City. Also, it has won a number of honors, including a Wood Pencil Award in the Urban Living category from D&AD Impact, recognition as a Finalist in the Spaces, Places, Cities category in Fast Company’s 2016 Innovation By Design Awards, and two-time rec ognition as a “Best Place to Work“ in NYC.

### Channels

Intersection’s main channels for consumers are its kiosks, while it connects with advertisers and cities through its business development team. The company promotes its offering through its social media pages and participation in summits and conferences.

### Customer Relationships

Intersection’s customer relationship is primarily of a self-service, automated nature. Customers utilize the service through the main platform while having limited interaction with employees. That said, there is a personal assistance component in the form of e-mail support through its website.

### Key Activities

Intersection’s business model entails designing and developing devices that consumers can use and that brands can advertise their offerings on, as well as services for organizations in general.

### Key Partners

Intersection’s key partners are the municipal authorities with whom it works to implement technology and media projects that enhance life for residents of their cities. The company also relies on third-party manufactures to produce technology objects, such as the kiosks it uses for LinkNYC.

### Key Resources

Intersection’s main resources are its human resources, who include the technologists, media experts, engineers, designers, and strategists that work together to develop its technology and media solutions.

### Cost Structure

Intersection has a cost-driven structure, aiming to minimize expenses through significant automation and low-price value propositions. Its biggest cost driver is likely sales/marketing, a fixed cost. Other major drivers are in the areas of customer support/operations and administration, both fixed costs.

### Revenue Streams

Intersection has two revenue streams:

 * Advertising Revenues – Revenues the company generates from fees charged to brands to advertise their offerings on its technology platforms.
* Service Revenues – Revenues the company generates from fees charged for the design and technology services it offers as part of its portfolio.


text:
# Cinnamon Boilerplate

#### Simple, scalable boilerplate to help kick start your projects.

## Features

* Scaleable directory structure with clear, granular & intuitive naming conventions.
* Ships with a handful goodies including an HTML5 template, jQuery, underscore, signals & cssmixins to help make your site awesome!
* Integrates seamlessly with [CodeKit][codekit] for all your concatenation and minification needs.

## Rationalle & Suggested Usage

* A *graphics* folder and an *images* folder, what's that all about? In a nutshell, if it's referenced as a background-image or is an embedded logo, it goes in the graphics folder. If it's referenced as the src of an img element, it goes in the images folder.
* Keep it consistent and adopt the conventions laid out before you. If you are embedding plugins such as SWFs, put them in a embeds folder. If you are referencing videos, put them in a videos folder. Maintain the verbose naming conventions and the world will be at peace with you.

## Author

Matthew Wagerfield: [@mwagerfield][mwagerfield]

## Contributors

Darcy Clarke: [@darcy][darcy]

## License

Licensed under [MIT][mit]. Enjoy.

[codekit]: http://incident57.com/codekit/
[mwagerfield]: https://twitter.com/mwagerfield
[darcy]: http://twitter.com/darcy
[mit]: http://www.opensource.org/licenses/mit-license.php


text:
# Bank or Bust

Bank or Bust is a simplistic app for sports bettors to track bets and see how much they are winning or losing! Visit [Bank or Bust](https://bank-or-bust98.herokuapp.com/) to start tracking your bets.

## Wireframes

![wireframe login screen](public/project4-mainscreen.png)

![wireframe players screen](public/project4-mybetspage.png)

![wireframe login screen](public/project4-bethistorypage.png)

## Technologies Used:

- Node.js
- MongoDB
- React
- Express
- Mongoose
- HTML
- CSS
- Bootstrap

## Getting Started

[Visit my App](https://bank-or-bust98.herokuapp.com/)

[See my Trello Board](https://trello.com/b/izoHZMC3/bank-or-bust)

## Next Steps

1. Implement Odds api for live odds of current match ups
2. add public chat room to app that will alow all users to communicate about bets

repository: spencerbrake/Bank-or-Bust

repo_name: spencerbrake/Bank-or-Bust


text:
# Project Details

This project trains an agent to navigate and collect bananas in a large, square world.

A reward of +1 is provided for collecting a yellow banana, and a reward of -1 is provided for collecting a blue banana.  The goal of the agent is to collect as many yellow bananas as possible while avoiding blue bananas.

The state space has 37 dimensions and contains the agent's velocity, along with ray-based perception of objects around agent's forward direction.  Given this information, the agent has to learn how to best select actions.  Four discrete actions are available, corresponding to:
- **`0`** - move forward.
- **`1`** - move backward.
- **`2`** - turn left.
- **`3`** - turn right.

The task is episodic, and to consider the environment solved, the agent must get an average score of +13 over 100 consecutive episodes.

# Getting Started

1. Clone this git repository on your local machine

2. Setup a Jupyter notebook on your local machine.   For details on how to do that, here is a resource that may be helpful:
https://www.dataquest.io/blog/jupyter-notebook-tutorial/

2. Download the environment from one of the links below.  You need only select the environment that matches your operating system:
    - Linux: [click here](https://s3-us-west-1.amazonaws.com/udacity-drlnd/P1/Banana/Banana_Linux.zip)
    - Mac OSX: [click here](https://s3-us-west-1.amazonaws.com/udacity-drlnd/P1/Banana/Banana.app.zip)
    - Windows (32-bit): [click here](https://s3-us-west-1.amazonaws.com/udacity-drlnd/P1/Banana/Banana_Windows_x86.zip)
    - Windows (64-bit): [click here](https://s3-us-west-1.amazonaws.com/udacity-drlnd/P1/Banana/Banana_Windows_x86_64.zip)

    (_For Windows users_) Check out [this link](https://support.microsoft.com/en-us/help/827218/how-to-determine-whether-a-computer-is-running-a-32-bit-version-or-64) if you need help with determining if your computer is running a 32-bit version or 64-bit version of the Windows operating system.

    (_For AWS_) If you'd like to train the agent on AWS (and have not [enabled a virtual screen](https://github.com/Unity-Technologies/ml-agents/blob/master/docs/Training-on-Amazon-Web-Service.md)), then please use [this link](https://s3-us-west-1.amazonaws.com/udacity-drlnd/P1/Banana/Banana_Linux_NoVis.zip) to obtain the environment.

3. Place this file in the directory that you cloned the git repositiory, and unzip (or decompress) the file.

# Instructions

Open the Navigation.ipynb notebook file, and run the notebook to train the agent


text:
#LevelDB - Swift

##A Swift wrapper for [LevelDB](https://github.com/google/leveldb)*

This is a pure Swift wrapper around the LevelDB C API, configured to build OS X & iOS dynamic frameworks. It's a minimal, low-level wrapper without a lot of the usual convenience methods (subscripts, string keys, queries etc). The goal is to eventually expose all of the LevelDB functionality with a reasonably idiomatic Swift API, so that more sophisticated mobile database frameworks can be built on top.

The current version should be considered an ALPHA release and the API will probably change from here.

Basic usage:

	let db = try Database.createDatabase(directory, options: Options(createIfMissing: true))
	try db.put(key, value: value)
	try db.get(key)

WriteBatch support:

	let batch = WriteBatch()
	batch.put(key1, value1)
	batch.delete(key2)
	try db.write(batch)

The C++ style LevelDB iterator has been wrapped with Swift `SequenceType`s:

	for key: String in db.keys()
		print(key)
	}

	for (key, value) in db.values(from: startKey, to: endKey, descending: true)
		print("\(key): \(value)")
	}

Custom Swift Comparator class. This required some C glue code - I'm not the world's best C programmer, so there's a good chance I've stuffed up something really basic.

	class MyCustomComparator: Comparator {
		var name: String {
			get {
				return "MyCustomComparator"
			}
		}

	    func compare(a: LevelDB.Slice, _ b: LevelDB.Slice) -> NSComparisonResult {
	        let string1 = String(bytes: a.bytes, length: a.length)
	        let string2 = String(bytes: b.bytes, length: b.length)
	        return string1.compare(string2)
	    }
	}

Note that all values are NSData instances, as this is the closest Foundation equivalent to LevelDB's Slice, but this will probably change to a Swift type eventually. Keys must conform to `KeyType` - there are built in implementations for `String` and `NSData` to allow the use of binary keys (and keep Andy happy).

The LevelDB source is included as a submodule (run `git submodule init && git submodule update` if you've cloned the source). It's compiled into the framework targets directly by Xcode rather than using an external build target because I rage-quit the LevelDB Makefile.

The TODO list:

* Implement filter policy support
* More code comments & better doco
* Enable Snappy compression?
* Snapshot might be better as a trailing closure method
* DB properties, compact & cache support
* Use `UnsafeBufferPointer<Int8>` rather than the `LevelDB.Slice`
* Check Carthage support
* SwiftCheck tests


text:
	Copyright Since 2005 ColdBox Platform by Luis Majano and Ortus Solutions, Corp

	www.coldbox.org |
	www.ortussolutions.com

----

Because of God's grace, this project exists. If you don't like this, then don't read it, it's not for you.

>"Therefore being justified by faith, we have peace with God through our Lord Jesus Christ:
By whom also we have access by faith into this grace wherein we stand, and rejoice in hope of the glory of God.
And not only so, but we glory in tribulations also: knowing that tribulation worketh patience;
And patience, experience; and experience, hope:
And hope maketh not ashamed; because the love of God is shed abroad in our hearts by the
Holy Ghost which is given unto us. ." Romans 5:5

----

# Welcome to ColdBox

ColdBox *Hierarchical* MVC is the de-facto enterprise-level [HMVC](https://en.wikipedia.org/wiki/Hierarchical_model%E2%80%93view%E2%80%93controller) framework for ColdFusion (CFML) developers. It's professionally backed, conventions-based, modular, highly extensible, and productive. Getting started with ColdBox is quick and painless.  ColdBox takes the pain out of development by giving you a standardized methodology for modern ColdFusion (CFML) development with features such as:

* [Conventions instead of configuration](https://coldbox.ortusbooks.com/getting-started/conventions)
* [Modern URL routing](https://coldbox.ortusbooks.com/the-basics/routing)
* [RESTFul APIs](https://coldbox.ortusbooks.com/the-basics/event-handlers/rendering-data)
* [A hierarchical approach to MVC using ColdBox Modules](https://coldbox.ortusbooks.com/hmvc/modules)
* [Event-driven programming](https://coldbox.ortusbooks.com/digging-deeper/interceptors)
* [Async and Parallel programming constructs](https://coldbox.ortusbooks.com/digging-deeper/promises-async-programming)
* [Integration & Unit Testing](https://coldbox.ortusbooks.com/testing/testing-coldbox-applications)
* [Included dependency injection](https://wirebox.ortusbooks.com)
* [Caching engine and API](https://cachebox.ortusbooks.com)
* [Logging engine](https://logbox.ortusbooks.com)
* [An extensive eco-system](https://forgebox.io)
* Much More

## LTS Support

For all ColdBox releases, updates are provided for 12 months and security fixes are provided for 2 years after the next major release.

**ColdBox 6.x will receive bug fixes until 2024 and security fixes until 2025.**

| Version | Release | Updates 	| Security Fixes |
| ------- | ------- | --------- | -------------- |
| 6.x     | 2022    | 2023      | 2025           |
| 7.x     | 2023    | 2024      | 2026           |
| 8.x     | 2024    | 2025      | 2027           |
| 9.x     | 2025    | 2026      | 2028           |

## License

Apache License, Version 2.0.

>The ColdBox Websites, logo and content have a separate license and they are a separate entity.

## Versioning

ColdBox is maintained under the Semantic Versioning guidelines as much as possible.

Releases will be numbered with the following format:

```html
<major>.<minor>.<patch>
```

And constructed with the following guidelines:

* Breaking backward compatibility bumps the major (and resets the minor and patch)
* New additions without breaking backward compatibility bumps the minor (and resets the patch)
* Bug fixes and misc changes bumps the patch

## Important Links

### Source Code

* https://github.com/coldbox/coldbox-platform

### Bug Tracking/Agile Boards

* https://ortussolutions.atlassian.net/browse/COLDBOX
* https://ortussolutions.atlassian.net/browse/CACHEBOX
* https://ortussolutions.atlassian.net/browse/LOGBOX
* https://ortussolutions.atlassian.net/browse/WIREBOX

### Documentation

* https://coldbox.ortusbooks.com
* https://cachebox.ortusbooks.com
* https://logbox.ortusbooks.com
* https://wirebox.ortusbooks.com

### Official Site

* https://www.coldbox.org
* https://www.ortussolutions.com/products/coldbox

## System Requirements

* Lucee 5+
* Adobe ColdFusion 2018+

## Quick Installation

Please go to our [documentation](https://coldbox.ortusbooks.com) for expanded instructions.

**CommandBox (Recommended)**

We recommend you use [CommandBox](https://www.ortussolutions.com/products/commandbox), our CFML CLI and package manager, to install ColdBox.

**Stable Release**

`box install coldbox`

**Bleeding Edge Release**

`box install coldbox@be`

Bleeding edge releases are updated automatically when code is committed.

## Collaboration

First, read our [contributing](CONTRIBUTING.md) guidelines, then you will need to download [CommandBox](https://www.ortussolutions.com/products/commandbox) so you can install dependencies, run the development server and much more.

Then you need to install some CommandBox modules in order to work with environment variables and CFML engine configuration. Once you fork/clone the repository, startup a CommandBox shell in the root of the project via `box` and then install all of the project development dependencies:

```bash
install
```

Create an `.env` file according to the `.env.template` in the root and spice it up for your local database.  Then import the SQL for the database which can be found in `/tests/resources/coolblog.sql`. You can then go ahead and start an embedded server `box server start` and start hacking around.

For running our test suites you will need 2 more steps, so please refer to the [Readme](tests/readme.md) in the tests folder.

----

### THE DAILY BREAD

 > "I am the way, and the truth, and the life; no one comes to the Father, but by me (JESUS)" Jn 14:1-12

repository: ColdBox/coldbox-platform

branch_name: refs/heads/development

gha_language: ColdFusion

repo_name: ColdBox/coldbox-platform


text:
# Cinder-Syphon

An implementation of the Syphon framework for Cinder
Anatomy:

example-Basic - contains a simple Syphon example
example-SyphonServerDirectory - a server directory example
lib - the framework and namebound client
src - the Cinder implementation

Objects:

Syphon Client - Receive frames from a Syphon server
Syphon Server - Publish frames to Syphon
Syphon Server Directory - Browse available Syphon servers

Requires Mac OS X 10.7+ and Cinder 0.9.0+

To add Syphon to your project:

 - Drag the Cinder-Syphon blocks folder into your project (like any other Cinder block)
 - Add a Copy Files build phase to new projects to copy the Syphon framework (in the /lib folder) into the Frameworks folder of the built product.

The included examples demonstrate these steps.

Use any Syphon-enabled application to send or receive frames. You can use the [Syphon Demo Apps](http://code.google.com/p/syphon-implementations/downloads/detail?name=Syphon%20Demo%20Apps%20Public%20Beta%202.dmg) to test functionality.

libcinder.org
syphon.v002.info/

Syphon Framework License:

Copyright 2013 bangnoise (Tom Butterworth) & vade (Anton Marini).
Cinder and Openframeworks implementation by astellato (Anthony Stellato).
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.

* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.

* Neither the name of the Syphon Project nor the names of its contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.

repository: videodromm/Cinder-Syphon

repo_name: videodromm/Cinder-Syphon


text:
> **Warning**
> This library is deprecated and no longer maintained. [simple-configuration](https://github.com/guardian/simple-configuration) is an alternative.

Configraun
==========

Configraun is a thin wrapper around AWS's [Systems Manager Parameter Store](https://aws.amazon.com/ec2/systems-manager/parameter-store/).
Parameter store allows you to manage your configuration data in one place including plain data and secure data encrypted through AWS KMS.

Using Parameter Store to store your applications configuration has a number of benefits:

1. You can control who and what resources access specific config through IAM credentials at a granular level.
2. You can make use of AWS KMS to encrypt information and protect the security of your keys.
3. Any changes to configuration in Parameter Store are versioned providing an audit trail of what has changed and by whom. In fact all calls to Parameter Store may be audited via Cloudtrail.
4. Parameter store gives you some type safety around the type of the configuration item returned to you. I.e String | Secure String | String List.
5. Config items can be tagged.

## Setup

Add the following line to your SBT build definition, and set the version number to be the latest from the [releases page](https://github.com/guardian/configraun/releases):

```scala
libraryDependencies += "com.gu" %% "configraun" % "x.y"
```

You will then need to create a new instance of the client and set the key:

```scala
  implicit val client: AWSSimpleSystemsManagement = AWSSimpleSystemsManagementFactory(region, profile)

  val stack: String = "STACK"
  val stage: Stage = Stage.PROD
  val app: String = "APP"

  val config = Configraun.loadConfig(stack, app, stage)
```

Or, for an EC2 instance with appropriate IAM policies (see below):

```scala
  implicit val client: AWSSimpleSystemsManagement = AWSSimpleSystemsManagementFactory(region, profile)

  val config = Configraun.loadConfig()
```

## Usage

Each of the get methods returns an `Either[ConfigraunError, T]`, designed to be traversed within
a for comprehension.

```scala
config.getAsString("/mydomain/mykey")

```
or

```scala
config.getAsList("/mydomain/mykey")

```

## Key Format

Configraun expects that any parameters are keyed with a parameter hierarchy format. The hierarchy can have a maximum of
5 levels and must begin with /$stack/$app/$stage.

```
/$stack/$app/$stage/key
```
or
```
/$stack/$app/$stage/domain/key
```

e.g.
```
/content-api/porter/PROD/aws/region
```

## Key Value Creation

Keys can be created from the command line using the following:

```bash
aws --region $region --profile $profile ssm put-parameter --name '/mystack/myapp/PROD/mydomain/mykey' --value 'myvalue' --type String
```

## IAM Policies

Instances will need to have Describe Tags permission in a policy in their instance role, or via some other form of credentials provider:

```
    "Effect": "Allow",
    "Action": "ec2:DescribeTags",
    "Resource": "*"
```

repository: guardian/configraun

gha_language: Scala

repo_name: guardian/configraun


text:
# /api/location/new

Creates a new location record in database.

Post request body:

* dbs: The name of the Postgres database connection as defined in the environment settings.
* table: The table name.
* qID: The ID field which is required to select individual locations from cluster. Defaults to 'id'.
* id: The ID of the location.
* geom: The name of the geometry field. Defaults to 'geom'.
* geometry: The geometry of the new location provided as stringified geojson.
* log\_table: The name of a table to store changes.

repository: RobiieHurst/xyz

repo_name: RobiieHurst/xyz