text:
# WireGuard x86 edge router, using Arch Linux
How to make a fully functional Arch Linux edge router, with stateful firewall and NAT, running WireGuard VPN.

This readme has been cobbled together in an hour because I didn't want to just post my reference files without comment. This guide will be fleshed out and formatted nicely over the coming day(s) as I get the opportunity **[It never was, but I'm glad some people found it useful!]**, and will ultimately include full copies of all referenced config files etc. For now, anyone who is attempting this project should have a fair understanding of Linux anyway, so I assume you know how to parse my cut down config example files and amend your own (full versions) to match.

I also start this guide by assuming that you are running the latest Arch Linux, you are using AzireVPN as your VPN provider, and you have at least three physical interfaces - WAN, LAN and DMZ (for your NAS/servers). You can amend this guide easily to account for any differences.

For now, in essence:

Install the latest Arch Linux, following the Arch Wiki's installation guide if necessary. You may wish to consider a switch to the `linux-lts` and `linux-lts-headers` kernel to save updates needing reboots as often as time goes on. Just add them, remove the normal linux package, and then regenerate the GRUB config file. Next time you reboot you're on LTS (or hardened, or whatever).

I also assume that as part of that process you have set up your local network interfaces using netctl profiles (which live in `/etc/netctl`), and then enabled and started them. I'm using a repurposed Dell Optiplex 7010 from eBay with an additional low profile Intel Pro 1000 VT quad port server NIC, so my netctl profiles are `/etc/netctl/WAN`, `./LAN`, and `./DMZ`. They are enabled and started like this:

```shell
netctl enable eno1 #WAN
```
```shell
netctl enable enp3s0f0 #LAN
```
```shell
netctl enable enp3s0f1 #DMZ
```
```shell
netctl start emo1
````
```shell
netctl start en3ps0f0
```
```shell
netctl start en3ps0f1
```

In future, netctl will bring up and handle the interfaces by itself.

Now the basics are out of the way, we install the basic requirements for this project:

```shell
pacman -S dhcp shorewall dnscrypt-proxy linux-headers wireguard-tools wireguard-dkms jq resolvconf iperf3 glances openssh
```

After a reboot, put your AzireVPN (or other) .conf file in `/etc/wireguard`. Edit it to remove references to DNS, add your private key and your provider's public key and endpoint, and have it wind up matching the example in this repo.

Next, edit `/etc/dnscrypt-proxy/dnscrypt-proxy.toml` to enable the service on your interfaces (e.g. `<IP_ADDRESS>:53`, `<IP_ADDRESS>:53`, `<IP_ADDRESS>:53`). Enable whichever servers you prefer, for example Cloudflare and Quad9 - or whatever. Then enable dnscrypt-proxy:

```shell
systemctl enable --now dnscrypt-proxy
```

Next we need to tell Shorewall what to do. For simplicity's sake, first copy over the Three Interfaces example from the Shorewall documentation like this:

```shell
cp /usr/share/doc/shorewall/Samples/three-interfaces/* /etc/shorewall/
```

Edit the files in the `/etc/shorewall` directory as per the conf files in this repo. In essence, you need to edit the `./interfaces` file to list your interfaces by name, outline your network segments in `./zones`, tell Shorewall who can talk with whom using `./policy` and set up `./rules` with any necessary changes. Finally we set the `./snat` file to tell Shorewall that our LAN subnet should `MASQUERADE` via our VPN, and the DMZ zone should `MASQUERADE` via the WAN IP.

My example rules config file in this repo gives examples for allowing SSH from local clients only, and using DNAT to allow people on the internet as well as LAN and DMZ clients to access servers on local machines (without having to hairpin back through the firewall). Once this is done, we can enable and start shorewall:

```shell
systemctl enable --now shorewall
```

Then we need to set up dhcpd to serve our local clients with DHCP IP addresses (the ones who aren't issued static IPs, anyway). Edit `/etc/dhcpd.conf` and use the repo's example .conf file as a guide. Start it with `authoritative;` and amend the subnets to your liking (eg `<IP_ADDRESS>/24` instead of `<IP_ADDRESS>/24` or whatever). You can flesh out the example static IP hosts as or if required. Then start and enable the DHCPD's server:

```shell
systemctl enable --now dhcpd4
```

At this point, you may wish to configure and enable SSH so you can administer your router from elsewhere on your network. This is especially useful if (likely) you are to run the router headless. If you get stuck, check out the Arch SSH wiki, but in essence just edit `/etc/ssh/sshd.conf` to uncomment the port and to allow root login if required (only do this if not allowing WAN access to SSH, and even then it's probably a bad idea). Hardening SSH is beyond the scope of this guide (for now), but I can recommend `sshguard`.

Now we have the ability to form WireGuard tunnels, `dnscrypt-proxy` to resolve DNS for local clients, `dhcpd` to issue and track IP addresses, and `shorewall` to keep everything running smoothly and safely. With regards to bringing up and down the WireGuard tunnel itself, I don't use the `wg-quick` utility as it overwrites rules and makes its own tables - which in my particular case intefered with my preferred routing for my DMZ subnet. Instead I made two very simple shell scripts, `wg-up.sh` and `wg-down.sh`, which are fairly self-explanatory.

Specifically, `wg-up.sh` brings up a WireGuard interface to AzireVPN (in my case). It then adds a table called `VPN` to `iproute2`'s `rt_tables`, and adds rules to it so that all traffic on my LAN subnet looks up this table. The rules in this table say:

```shell
ip rule add unicast iif {LAN interface} table vpn
```
```shell
ip route add default dev azirevpn-uk1 via 10.xx.xx.xx table vpn
```
```shell
ip route add <IP_ADDRESS>/24 via <IP_ADDRESS> dev {DMZ interface} table vpn
```

This basically means if you're on my LAN you get sent to the WireGuard tunnel and everything is protected by the VPN. That is, however, unless you wish to access a machine on the DMZ subnet (`<IP_ADDRESS>/24`). In this case you're sent there directly by the router, bypassing the VPN. Everyone else (the firewall, the DMZ zone clients) get sent directly over WAN and bypass the tunnel. This was necessary for me to keep my servers running properly (Plex, SABnzbd, Sonarr etc) and be able to reach them using mydomain.com over the internet.

This is all very well and good, but bringing up the WireGuard interface, adding tables, fleshing out that table with rules and so on is time consuming. That's where my script comes in. I made a systemd unit to launch the `wg-up.sh` script on boot. Now any time my router (re)starts, within 10 seconds everything is up and online, and my WireGuard tunnel is ready for action too. Seamless!

To make the systemd service, make a file called wg-up.service (or whatever) and place it in `/etc/systemd/system/` with its contents as per the example file in this repo. Don't forget to place your scripts in `/root/` or else to amend the content of the service file to point to the right location. Then enable the service like any other, so it comes up at boot in future:

```shell
systemctl enable --now wg-up.service
```

If for any reason you want/need to restart your tunnel, you can just issue `/root/wg-down.sh` and then invoke your startup service again:

    systemctl restart wg-up.service

If you want to see the status of your WireGuard VPN tunnel you can always issue the ever-useful command `wg`. It's as simple as that. To test that things are working nicely, you can do the following *from the router itself*:

```shell
curl ipinfo.io #Should return WAN IP
```
```shell
curl ipinfo.io --interface azirevpn-uk1 #Should return AzireVPN's IP
```

We're all done! Now you should have a barebones, fully functional, powerful, stateful firewall with (D/S)NAT, WireGuard, network segregation between LAN and servers/CCTV/etc for security, and all the great tools (like `iperf3`, `traceroute`, `dig`, `ping`, `glances`, etc) that Linux affords.

My own little Arch Router has been up for several ~~days~~ years now. I have two switches (one coming out of the LAN interface and one coming out of the DMZ interface), and my Unifi UAC AP PRO access point is plugged into the DMZ zone's PoE switch. The AP runs an SSID for us to use, and a captive portal for guests to our home, which is cut off from everything and everyone else. This provides convenience and security in one step.

You can see a little topology diagram of my network as it was when I first posted this repo (sans some recent changes like IPs, and my wireless AP is now in DMZ) here:

![My old network topology](https://i.imgur.com/6GAEsGf.png)

I'll tidy it up at some point to reflect the new reality of my network, but it still gives you a nice visual idea of what this guide accomplishes. Finally here's a speedtest from a LAN client using the WireGuard tunnel (with some wifi users browsing, so slightly low - you get the idea though):

![Speedtest.net result using the Arch router](https://www.speedtest.net/result/7878355703.png)

So far on my 'router', the average load is 0.00 (lol). It puts through my full ISP line speed (380Mbs) without breaking double digits CPU usage (even via WireGuard - which spreads the load beautifully over the i7's 8 threads), and is using about 125MB RAM. Overkill? Certainly. Fun? Absolutely. Future-proof? Hell yeah. Try it out and let me know how you find it!

## Update
This router ran a couple of years for me, before I moved to vanilla BSD. It shovelled WireGuard over gigabit just as well as it did my old 380Mbps plan, and never went wrong. Kudos.
These days, I'm on gigabit WAN and have a single x86 BSD edge router, a managed L2/L3 core switch, a Ruckus R710 Wireless AP managing guest isolation, and one flat subnet. I'm happy to see this guide helped a few people achieve similar goals.

repository: RainmakerRaw/WireGuard-ArchRouter

repo_name: RainmakerRaw/WireGuard-ArchRouter


text:
### [Assignment6] Static Assets, Partials, and TLS

#### Configure the application to use TLS/SSL
- Generate your own TLS/SSL certificate
- Make "certs" directory in ./lib.
- Place the certificates you generate into "certs" directory.

#### Configure two server connections
 - One labelled ['web'] on port 8000 with no TLS configured.
 - The other labelled ['web-tls'] on port 8001 will use TLS.
      Configure this connection to use the ssl/tls certificates you just generated
      and placed in ./lib/certs

#### Use TLS everywhere
Configure the application to always use TLS [Transport Layer Security] (http://en.wikipedia.org/wiki/Transport_Layer_Security).  <br/> Every http request should be redirected to https.
Two references:
* [@hueniverse on the issue](https://github.com/hapijs/hapi/issues/778)
* [related StackOverflow post](http://stackoverflow.com/questions/28650829/hapijs-using-both-http-and-https-on-one-connection)

### Configure the home plugin.
  - Make a new point in the home plugin called: "login"
    * Make login route display view template named login.html.
  - Use partials to display the login form
    * make a directory inside of the ./views called partials
    * configure the home plugin to use the ./views/partials directory to load partials from.
        * In ./views/partials/ directory make a file named form.html.
           * form should have two inputs one type="text" named "username" and the second type="password" named "password".
          * form should have one submission button with text value "Login".
        * Inside login.html template load the partial file named "form.html"

#### Use Static Assets
- Make directory in root of project called "assets".
- Inside the assets directory, make three directories:
  "styles" for css,
  "scripts" for JS scripts,
   "images" for project images.
    * Place Hapi University logo into the images directory
      and display it on the home page (home.html).
      (image is in the repo ./images/logo.png)
    * Place a CSS file in the stylesheets directory (styles).
      Name css file styles.css:
       * Make one simple style:
         h3 { font-size: 24px; font-weight: bold; }
       * Use the stylesheet in home.html. Make a title inside h3 tags.
    * Make a script named login.js and put in ./assets/scripts
      * Make this script print a console message to the browser when the form button is clicked.
    * In the home plugin configure the application to serve these static assets.
    * Make a login link in home.html that links to the login route.

#### 100% test coverage required

### Other resources to learn from
* server certificate configuration at [npm newww ](https://github.com/npm/newww/blob/13e26e0eaf5c6699f068bb5418d932af76be4aef/server.js)

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
---
layout: project
type: project
image: images/2022_01_23_azur_dvp_cicp.png
title: Azure Devops > CI|CD > Visual Studio
permalink: projects/2022_01_23_azur_dvp_cicp
# All dates must be YYYY-MM-DD format!
date: 2022-01-23
labels:
- Devops
- Pipeline
- Microsoft
- Azure
- Visual Studio
- Continuous Deployment
- Continuous Integration
- Automation

summary: In this project-based course on Microsoft Azure, we will be using a sample application in Visual Studio to create a CI/CD pipeline completely using the Microsoft Azure cloud development suite.

---

In this project-based course on Microsoft Azure, we will be using a sample application in Visual Studio to create a CI/CD pipeline completely using the Microsoft Azure cloud development suite.

We will show direct deployment from local to Azure web apps, a simple CI process that builds our application on an agent and produces artifacts, and we will also create a CD process that adds on the deployment component to our CI pipeline. We will end up with a fully automated pipeline in Azure that is triggered on new code pushes to the Main branch.

[Accomplishments > Course Certificate > Azure Devops Introduction to CI_CD > Visual Studio](https://www.coursera.org/account/accomplishments/verify/GE9JV2EE6DD4)

Source: kikosikera/2022_01_23_azur_dvp_cicp

license: MIT


text:
# Use Case: Add Guest

## **Related Requirements**

REQ-32, REQ-33, and REQ-34

## **Initiating Actors**

Manager

## **Actor's Goal**

To add guest to the system so that the guest can use the library system

## **Participating Actors**

Guest, Database

## **Preconditions**

- Manager is logged in the system and is shown a 'add guest' menu.

## **Postconditions**

- The guest is added to the library system.
- The library system allows the guest to use the system.

## Flow of Events for Main Success Scenario
| Direction | n | Actor Action                                                                                |
| --------- | - | -------------------------------------------------------------------------------------------------------------------- |
|           | 1 | Include Login (UC-1) |
| →         | 2 | Manager clicks the 'add guest' menu. |
| ←         | 3 | System shows 'add guest' page with input fields for entering guest information. |
| →         | 4 | Manager clicks the 'generate ID' button. |
| ←         | 5 | System (a) generates a new ID for the guest and (b) shows it to Manager. |
| →         | 6 | Manager inputs the information of guest, such as name, phone number, password, profile image, and e-mail. |
| →         | 7 | Manager clicks the 'add' button. |
| ←         | 8 | System prepares a database query that perfectly matches the entered information and retrieves the record from the Database. |
| →         | 9 | Database does not return any matching record. |
| ←         | 10 | System (a) verifies that the guest is new and (b) passes the information to the Database. |
| →         | 11 | Database (a) creates a new record using the guest information and (b) informs System of successful addition. |
| ←         | 12 | System shows Manager a message that the addition is successful. |

## Flow of Events for Extensions (Alternate Scenarios)
9a. Database returns a matching record.
| Direction | n | Actor Action                                                                                |
| --------- | - | -------------------------------------------------------------------------------------------------------------------- |
| ←         | 1 | System (a) detects error, and (b) shows a message that the guest already exists. |
| →         | 2 | Manager inputs other valid information of guest, such as name, phone number, password, profile image, and e-mail. |
|           | 3 | Same as in Step 7 above. |

path: /docs/UseCases/UC-14_Add Guest.md

branch_name: refs/heads/main

filename: UC-14_Add Guest.md

gha_language: Python

gha_license_id: MIT


text:
# Reactjs reference

This repository holds a **reference** for the development of a **React.js App**

## Quickstart

-   Install [NodeJS 14.x](https://nodejs.dev/learn/how-to-install-nodejs)
-   Install [Docker Desktop 4.10.x](https://docs.docker.com/desktop/)
-   Clone this repository
-   Execute setup script `bin/setup`
    >   For unix systems execute shell file `*.sh` (without sudo) and for windows batch `.bat` (e.g `bin/setup.sh` or `bin/setup.bat`)
-   Start server with `bin/start`

### Examples

-   Example app [http://localhost:3003/examples](http://localhost:3003/examples)
    >   Before using the app execute a ([django-reference](https://github.com/erick-rivas/django-reference)) based project
    >><EMAIL_ADDRESS>pass: 123

## Documentation

-   All documentation is in the [docs](./src/seed/docs/010_general.md) directory

repository: erick-rivas/reactjs-reference

gha_language: JavaScript

repo_name: erick-rivas/reactjs-reference


text:
# Bactrodesmium masonii S. Hughes, 1953 SPECIES

#### Status
SYNONYM

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Can. J. Bot. 31: 654 (1953)

#### Original name
Bactrodesmium masonii S. Hughes, 1953

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Ascomycota/Bactrodesmiella/Bactrodesmiella masonii/ Syn. Bactrodesmium masonii/README.md

repo_name: mdoering/backbone


text:
---
title: OnSetValues
page_title: OnSetValues - RadDataForm
description: Check our Web Forms article about OnSetValues.
slug: dataform/client-side-programming/events/onsetvalues
tags: onsetvalues
published: True
position: 6
---

# OnSetValues

##

The **OnSetValues** client-side event is raised when values are set in the fields in the **ItemTemplate**. Used with client-side binding.

Two parameters are passed to the event handler:

* **sender** - the **RadDataForm** control that fired the event

* **eventArgs** - an event arguments object of type **Sys.EventArgs**

repository: telerik/ajax-docs

gha_language: C#

repo_name: telerik/ajax-docs


text:
# Innisfil Toastmasters

![Screenshot](screenshot.png)

This is the source code for the [InnisfilToastmasters.org](InnisfilToastmasters.org) website.

It's redirect to a free Github page using a minimal, type-focused Jekyll theme.

Original theme is forked from [brianmaierjr/long-haul](https://github.com/brianmaierjr/long-haul).

Modified by [Paul Gamble](https://github.com/paulywill).

gha_language: SCSS


text:
# _Triple Triad_

A clone of the strategy game from Final Fantasy VIII, Triple Triad.

#### By
Jared Farkas, Darrion Gering, Liz Kelley

Special thanks to Ryan McLean for help on the card assets

## Description

The card minigame from Final Fantasy VIII. Each player is dealt a random starting hand and places them on the board, starting with the blue player. If a card's strength to one side is higher than the adjacent card's strength, the adjacent card is captured upon placement. Whichever player controls more cards at the end is the winner.

## Setup/Installation Requirements

* Clone the project from https://github.com/j-farkas/ttreact
* Import the database in the root directory.
* Host using dotnet
* Run in browser
* Start a new game

## Known Bugs
Drag and drop does not work on mobile.

## Specs
_A player drags a card onto the board / The card's image is appended to the space dragged to_

_A player clicks a card, then clicks a spot on the board / The card's image is appended to the space clicked_

_A player places a card adjacent to a card with a lower number than the card's number / The previously placed card is captured by the player_

_A player places a card adjacent to a card with a higher number than the card's number / Nothing happens_

_A player places a card adjacent to a card with the same number as the card's number / Nothing happens_

_A game ends in a tie and sudden death is toggled / Cards are re-dealt to each player based on which were captured. The red player will move first now_

## Technologies Used
* HTML
* CSS
* C#
* .NET
* Jquery
* React
* EF core
* MySQL

### License
This software is licensed under the MIT license

Copyright (c) 2019 **_Jared Farkas, Darrion Gering, Liz Kelley_**

repository: j-farkas/ttreact

repo_name: j-farkas/ttreact


text:
---
title: Alternate Delimiters
weight: 30
---

{{<lead>}}
Hof uses Go's text/template package which defaults to `{{` & `}}` for delimiters.
This can conflict with other systems, so hof enables you to change them.
{{</lead>}}

### Per-file Template Delimiters

You can configure delimiters per-file
by setting the `TemplateDelims` field
on a `gen.#File`.

{{< codePane title="per-file template delimiters" file="code/code-generation/template-writing/delimiters/per-file.html" >}}

### Per-glob Template Delimiters

You can set delimiters when loading
`Templates` and `Partials` when
you have a directory of files
which need alternative delimiters,
or you prefer a different syntax.
Set the `Delims` field in the configuration.

{{< codePane title="per-glob template delimiters" file="code/code-generation/template-writing/delimiters/per-glob.html" >}}

repository: hofstadter-io/hof

gha_language: Go

repo_name: hofstadter-io/hof


text:
Managing services with SYSMGR
=============================

sysmgr is an alternative service supervisor written in POSIX sh. It is similar
in usage to runit.

Installation
------------

Begin by first verifying that you have sysmgr installed.

    # Available in the Community repository.
    $ kiss b sysmgr && kiss i sysmgr

Basic usage
-----------

As mentioned above, the usage of sysmgr is similar to runit.

| Action  | Command                                                            |
|---------|--------------------------------------------------------------------|
| List    | $ ls /etc/sysmgr/                                                  |
|         |                                                                    |
| Enable  | $ ln -s  /etc/sysmgr/SERVICE_NAME /var/sysmgr                      |
| Disable | $ unlink /var/sysmgr/SERVICE_NAME                                  |
|         |                                                                    |
| Stop    | $ svctl stop  SERVICE_NAME                                         |
| Start   | $ svctl start SERVICE_NAME                                         |

See svctl(1) for more usage information.

Running sysmgr on startup
-------------------------

sysmgr can be run at boot via /etc/inittab or a hook in /etc/rc.d.

    # Enabling on inittab
    ::respawn:/usr/bin/sysmgr

    # Enabling from /etc/rc.d/sysmgr.boot
    while :; do /usr/bin/sysmgr; done &

Switching from runit
--------------------

In order to switch from runit to sysmgr, copy the contents of the /var/service
directory to /var/sysmgr, and the same for /etc/sv to /etc/sysmgr.

    # Create the service directory for sysmgr
    $ mkdir -p /etc/sysmgr

    # Copy runit services
    for service in /etc/sv/*; do
        cp "$service/run" "/etc/sysmgr/${service##*/}"
    done

    # Copy all enabled services
    for service in /var/service/*; do
        ln -sf /etc/sysmgr/${service##*/} /var/sysmgr
    done


text:
# About Haskell

* Haskell is a general-purpose programming language.
* Haskell is a functional programming language (FPL).
* Haskell is a purely functional programming language.

* Haskell is a general-purpose, purely functional programming language that incorporates many innovations in programming language design.

> Haskell is both the culmination and solidification of many years of research on non-strict functional languages.

This report defines the *syntax* for Haskell programs and an informal *abstract semantics* for the meaning of such programs. We leave as implementation- dependent the ways in which Haskell programs are to be manipulated, interpreted, compiled, etc. This includes such issues as *the nature of programming environments* and the *error messages* returned for undefined programs, i.e. programs that formally evaluate to `⟘` (bottom).


text:
# Unnoticeable Backdoor Attacks on Graph Neural Networks

```
@inproceedings{ubagnn_webconf23,
title = {Unnoticeable Backdoor Attacks on Graph Neural Networks},
author = {Dai, Enyan and Lin, Minhua and Zhang, Xiang and Wang, Suhang},
booktitle = {Proceedings of the ACM Web Conference (TheWebConf)},
pages = {2263--2273},
year = {2023}
}
```

links
- [acm](https://dl.acm.org/doi/10.1145/3543507.3583392)

gha_language: Jupyter Notebook


text:
# 2. TypeScript as project language

Date: 2020-04-09

## Status

Status: Accepted on 2020-04-09

## Context

* This is Open Source app which may be used by big variety of projects
* TypeScript is widely known nowadays, so there is high chance to get contribution from other peple if this technology is used
* Project's author and main contibutor (@kopach) is fluent in this technology, so no need in spending extra efort in learning something differrent
* TypeScript is type safe, so more secure and potentially should prevent from common mistakes
* TypeScript integrates well with JavaScript so all libraries from both ecosystems can be used easilly

## Decision

Use TypeScript as main and only programming language in this project

## Consequences

* A bit more boilerplate code in comparison to JavaScript, thus more effort to write on the beginning
* Sometimes there could be issues related to TypeScript itself, e.g. wrong/outdated types defined under<EMAIL_ADDRESS>project

repository: kopach/karma-sabarivka-reporter

gha_language: TypeScript

repo_name: kopach/karma-sabarivka-reporter


text:
# crest

`crest` is a simple program to perform HTTP requests.  Its main purpose
is to explore and use HTTP API from the command line, with a non-verbose
syntax and being not resource-heavy.

### Usage

(for a longer and cleaner description you should check out the
[manpage][manpage].)

`crest` uses a simple language to perform HTTP requests.  The syntax is
`http-verb url payload` where the payload can be absent.  For example:

	get localhost:8080/foo

To avoid typing possibly multiple times the same part of an URL `crest`
has the concept of *prefix*.  The prefix is a string that is appended
before every URL in a way that is guaranteed that a single `/` will
separate the prefix and the given URL.

	set prefix localhost:8080/

	# this is now equivalent to `get localhost:8080/foo`
	get foo

	# this is also equivalent
	get /foo

At the moment the methods supported are delete, get, head, options
and post.

Headers can be added and removed with the `add` and `del` commands:

	# add a custom header, just like the -H flag
	add Accept: text/plain

	# remove that header
	del Accept

`crest` has also some options that can be changed at runtime.  In a
previous example I used `set prefix localhost:8080` to set the option
`prefix` (equivalent to the `-p` flag by the way.)  There are other
options documented in the manpage like the HTTP version, the port and
so on.  The `show` command is used to print the value of an option and
`unset` will reset that option.

Lastly, `crest` has `sh(1)`-like pipes:

	get /user/5

	# this will execute jid with the output of the last
	# command as input
	|jid

(be sure to try [jid][jid] if you're working with json APIs: the whole
idea of pipes was implemented just to leverage jid ability to dig into
complex json.)

### Building

Make sure you have `libcurl` installed (you may need a package called
libcurl-dev, libcurl-devel or curl-dev), that's the only dependency.

To build the project you'll need `meson`:

	meson build
	cd build
	ninja
	ninja install # optional

or more simply:

	meson install

The install target will add only two files to your system: `crest`
(the executable) and `crest.1` (the man page.)

### Integrations

 - emacs: there is a mode that lets you run crest directly from emacs.
   You can find the sources in the `crest4e` directory.
 - acme: `crest` works great within `win`.

### Architecture

`crest` will `fork(2)` as soon as it can: the parent process will do
user interaction (reading commands, parsing, executing pipes) while the
child process will do the HTTP calls.  On OpenBSD the processes are
`pledge(2)`ed and the child is also `unveil(2)`ed (it needs to open
files in /etc/ssl to verify TLS certificates.)

The communication between the parent and the child is done through
OpenBSD' [imsg][imsg] functions (they're bundled in the `compat`
directory.)

### TODOs

random order:

 - [x] split the code into two processes and pledge(2) 'em
 - [ ] CONNECT, PATCH, PUT & TRACE.
 - [x] DELETE, OPTIONS
 - [x] flag to define headers
 - [x] flag to choose the default HTTP version
 - [ ] flag to hide/blacklist some/all response header
 - [x] `set` command to change some parameters at runtime
 - [x] document the set command
 - [x] document that it will execute file passed as arguments
 - [x] `del` command to delete HTTP headers
 - [ ] encoding & print (not so sure about this)
 - [ ] cookie support (not so sure about this)
 - [ ] support response bigger than UINT16_MAX bytes
 - [x] write a nice manpage
 - [ ] add syntax to define field
 - [ ] add syntax to help with managing json?
 - [ ] use yacc to parse?

### License

All the code is released under the OpenBSD license, with the only
exception being `compat/queue.h` and `compat/vis.{c,h}` that are under
BSD 3-clause.  All copyright notices are in the first lines of each
source file.

[imsg]: http://man.openbsd.org/imsg_init
[jid]: https://github.com/simeji/jid
[manpage]: crest.1.md

repository: omar-polo/crest

repo_name: omar-polo/crest


text:
AudiOS
======

iOS Audio Library.

Provides various classes to read/write audio files and to provide an audio callback to manipulate audio samples in real time.

repository: urinieto/AudiOS

repo_name: urinieto/AudiOS


text:
# Employee Tracker
### Author
 Peter Consagra

[![License](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

---

# Table of Contents
1. [Description](#description)
2. [Installation](#installation)
3. [Usage](#usage)
5. [Contributing](#contributing)
6. [Testing](#tests)
7. [License](#license)
8. [Contact](#contact)

---

## Description
This project creates tables for tracking employees. It allows for adding departments, roles, and IDs, and well as changing the roles of different employees, and their managers. It uses sql and javascript.

## Installation
you can get this application from my github

## Usage
you must open the application on vs code, and activate the sql files. Then in terminal command "node index.js"

## Contributing
at this point no contributions are neccesary

## Tests
there are no tests available at the moment

## License
This application is using the MIT license.

## Contact
email<EMAIL_ADDRESS>
Github: (https://github.com/pcon27)

## Video
Link: (https://drive.google.com/file/d/1j308qtX_onfA_NBeej7z2H643zupnG7K/view?usp=sharing)

## Images of the Code
![alt text](https://github.com/Pcon27/Employee_tracker/blob/b3dd394cbdc46347afb2606c6a7d73afecf2089a/assets/Employee%20Tracker%20Image%201.png)

![alt text](https://github.com/Pcon27/Employee_tracker/blob/b3dd394cbdc46347afb2606c6a7d73afecf2089a/assets/Employee%20Tracker%20Image%202.png)


text:
# Curriculum Learning for Language Modeling

## Setup
Install python version 3.5 or later, tensorflow version 1.2 and h5py:

```
pip install tensorflow-gpu==1.2 h5py
python setup.py install
```

Ensure the tests pass in your environment by running:
```
python -m unittest discover tests/
```


repository: ghuioio/Quantum-Dots

repo_name: ghuioio/Quantum-Dots


text:
---
layout: post
title: CodeSchool 3rd week - Tokens
date: 2013-06-03 18:10:47.000000000 +10:00
categories: []
tags:
- codeschool
image: /assets/images/background_image.jpg
---

That was all we did in week 3, creating email tokens and testing it. It doesn't sound like a lot for 6 hours of lesson but we sure did a lot of discovering when dealing with BCrypt in creating tokens and the output of encoding the hash using urlsafe_encode64.

At the moment, every attendee will have a 3 unique tokens generated for the actions confirm, pay and decline.  These tokens are generated using the BCrypt::Password create function with a hash.

BCrypt is the most recommended hash function compared to MD5,SHA1,SHA256 etc. From my understanding, BCrypt uses a variant of the Blowfish encryption algorithm that introduces a work factor which determines how expensive the hash function will be. BCrypt is really slow as the work factor increases compared to other hash functions. This would only mean it would take much longer to crack passwords with massive amounts of resources.

With every email sent out, there will be a link for the attendee to click on to notify of his/her decision be it confirm, pay or decline in one step. Dependent on their decision, the attendee object will be moved into a different state and forwarded to the appropriate link.

This is where BrainTree payment gateway comes into play in the app. All credit card transactions and information storage is handled by BrainTree. The integration to their APIs will be in the next few lessons.

Of course we took a lot of time writing the RSpec tests on the tokens and the links and refactoring our code to ensure there are no unnecessary repetition. At the moment we have not done anything to the view hence I can't provide any screenshots of our progress. However, this is the project link https://github.com/net-engine/tedx-brisbane in case you want to have a look around.

extension: markdown


text:
[![Build Status](https://travis-ci.com/pawandubey/cuckoo_filter.svg?token=3cAzkSrcDxPpHpxsqQyX&branch=master)](https://travis-ci.com/pawandubey/cuckoo_filter) [![codecov](https://codecov.io/gh/pawandubey/cuckoo_filter/branch/master/graph/badge.svg)](https://codecov.io/gh/pawandubey/cuckoo_filter)

# CuckooFilter

Pure Ruby implementation of the [Cuckoo Filter](https://www.cs.cmu.edu/~dga/papers/cuckoo-conext2014.pdf) - a probabilistic datastructure which is objectively better than Bloom Filters for set-membership queries.

It is a probabilistic data structure which is used to determine set-membership, i.e. finding out if a given element exists in a given set.

For practical uses think - checking if an item is present in a cache, if it is present in a database or YouTube trying to figure out if you have already watched some video before it is recommended to you.

It is closely related to Bloom Filters - but outshines them in performance and space efficiency. You can read more from the [original paper](https://www.cs.cmu.edu/~dga/papers/cuckoo-conext2014.pdf) that introduced it in 2014. Yes, it is that young!

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'cuckoo_filter'
```

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install cuckoo_filter

## Usage

```ruby
# Create a filter with 1024 (next power of 2) slots with each bucket holding 4
cf = CuckooFilter.make(size: 1000, kicks: 500, bucket_size: 4)
# => returns a CuckooFilter::CuckooFilter instance

# Insert an element into the filter
cf.insert("foo")
# => true

# Lookup the existence of an element
cf.lookup("foo")
# => true

cf.lookup("bar")
# => false

# Delete an existing element
cf.delete("foo")
# => true
```

## Frequenty Anticipated Questions

- Q: *Is this useful?*

  A: Yes, but have a look at the benchmarks below to see if it satisfies your performance requirements before using it in a real world app.

- Q: *Why did you make this?*

  A: For fun and education, of course! Although that is not stopping it from having any real world usage!

- Q: *But why Ruby? Why not Go/Rust/Elixir/FooBar*

  A: Because why not? I like Ruby and I couldn't find a full blown implementation in it.

- Q: *Can I use it in a real project?*

  A: If it satisfies your criteria, then why not? Have a look at the benchmarks for performance stats. Let me know if you do!

## Benchmarks

You can run the benchmark script to see the iterations per second performance of different methods on an initially half full filter.

```
$ ruby test/benchmark.rb

Setting up for benchmarking...
Done.
Warming up --------------------------------------
# warmup stats -> can be ignored

Calculating -------------------------------------
Iterations per second - Insertions
                        214.863M (±47.1%) i/s -      1.214B in   9.859735s
Iterations per second - Lookups
                        355.392M (±10.9%) i/s -      3.371B in   9.697599s
Iterations per second - Deletions
                        343.890M (± 9.6%) i/s -      3.286B
```

## Development

After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

## Contributing

Bug reports and pull requests are welcome on GitHub at https://github.com/pawandubey/cuckoo_filter.

## License

Copyright 2017 Pawan Dubey

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.


text:
We have a problem at work in that we're still using Grails 1.3.7, which is about
five years old.  We couldn't switch to Grails 2.0 when it came out because it
meant porting all of our code.  There was too much code and we couldn't stop
shipping features for the time it would take to port all the existing code.
This has hampered our ability to use newer plugins that were written against
Grails 2.0.

Now, Grails 3.0.1 just came out.  The migration guide says:

> The best approach to take when upgrading a plugin or application (and if your
> application is using several plugins the plugins will need upgrading first) is
> to create a new Grails 3.0 application of the same name and copy the source
> files into the correct locations in the new application.

So, basically a new port all over again.  Maybe we'll be able to port our app
directly from 1.3.7 to 3.0.1.  Someday.

I thought this sucked pretty badly, until a came upon a discussion in the
AngularJS world that AngularJS 2.0 is not backwards compatible and porting
applications written with AngularJS 1.0 to the new AngularJS 2.0 will require a
fair bit of rewrite.  So even though our situation with Grails is uncomfortable,
at least we are not alone.  At least one other platform is forcing its
developers to do major rewrites in order to upgrade to their latest and greatest
version.

Then, I came upon a tweet that said
"[One does not simply upgrade Rails](https://twitter.com/agile_memes/status/568718928345583616)",
as a parody of Boromir saying "One does not simply walk into Mordor."

And then, I saw this
[keynote by Guido van Rossum where he talks about the woes of upgrading to Python 3](https://youtu.be/G-uKNd5TSBw?t=2m20s).
One more platform where upgrades will be difficult this year.

I guess we're in great company indeed.


text:
# Templating for Fluent

On the front end of the website you can include the `LocaleMenu.ss` template to provide
a simple locale navigation.

```html
<% include LocaleMenu %>
```

If you are using partial caching then you will need to ensure the current locale is a part of the cache key.

```html
<% cached 'navigation', List(Page).max(LastEdited), $CurrentLocale %>
	<% loop Menu(1) %>
		<li class="$LinkingMode"><a href="$Link" title="$Title.XML">$MenuTitle.XML</a></li>
	<% end_loop %>
<% end_cached %>
```

repository: tractorcow-farm/silverstripe-fluent

gha_language: PHP

repo_name: tractorcow-farm/silverstripe-fluent


text:
# velero

![](https://i.imgur.com/feo6EpE.png)

[Velero](https://velero.io/) is a cluster backup & restore solution.  I can also leverage restic to backup persistent volumes to S3 storage buckets.

* [velero](velero/)
* [rules/velero.yaml](rules/velero.yaml) - Prometheus alertmanager rules for Velero
* [change-storage-class-config.yaml](change-storage-class-config.yaml) - (disabled) example ConfigMap demonstrating how to restore from one storage class type to a different storage class type


text:
# Phragmidium rosarum f. rosae-pimpinellifoliae Rabenh., 1873 FORM

#### Status
SYNONYM

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Fungi europ. exsicc. 4: no. 1671 (1873)

#### Original name
Phragmidium rosarum f. rosae-pimpinellifoliae Rabenh., 1873

### Remarks
null

path: /life/Fungi/Basidiomycota/Pucciniomycetes/Pucciniales/Phragmidiaceae/Phragmidium/Phragmidium rosae-pimpinellifoliae/ Syn. Phragmidium rosarum rosae-pimpinellifoliae/README.md


text:
Project: Mobile Service Usage for Geographic Diversity Analysis

This project contains the code for our paper titled "Urban Vibes and Rural Charms: Analysis of Geographic Diversity in Mobile Service Usage at National Scale" published at The Web Conference 2019.

repository: rajkarn/mobdiv

repo_name: rajkarn/mobdiv


text:
# rumq
[![img](https://github.com/tekjar/rumq/workflows/CI/badge.svg)](https://github.com/tekjar/rumq/actions)
[![img](https://img.shields.io/discord/633193308033646605?style=flat)](https://discord.gg/mpkSqDg)

MQTT ecosystem in rust which strives to be simple, robust and performant

* Fully asynchronous. Built on top of tokio 0.2 and futures 0.3

#### Client
* Mqtt eventloop is just a stream. Easily plug it into async ecosystem
* Takes a `Stream` for user requests. Solves both bounded and unbounded
  usecases
* Reconnections are just a loop away. Resumes from previous state
* Request throttling
* Inflight queue size based throttling
* Tls using RustTLS. Cross compilation and multi platform support is painless

#### Broker
* Embeddable
* Passes mqtt 3.1.1 paho conformance test suite (Without qos2)
* Supports retained messages
* Supports will messages
* Offline message queueing
* Deduplicates overlapping subscriptions

#### REFERENCES
----------------
* http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html

repository: braeutigamj/rumq

repo_name: braeutigamj/rumq


text:
# Create a local and remote repository

## Command

```bash
rit github create repo
```

## Requirements

- git installed

- set github username and token credentials using

```bash
rit set credential
```

## How to generate personal access token

To generate a personal access token click [here](https://github.com/settings/tokens)

## How it works

![gif](doc/github-create-repo.gif)

repository: antonioolf/ritchie-formulas

repo_name: antonioolf/ritchie-formulas


text:
--------------------------------------------------
### Summary of Folder Structure and File Contents
Last updated: Sept. 15, 2021
--------------------------------------------------

**Data**
  - Contains information used in Drasil (for ODEs)

**Language**
  - Contains the code for Drasil

repository: JacquesCarette/Drasil

gha_language: Haskell

repo_name: JacquesCarette/Drasil


text:
This Cordova plugin combines two others:

#### [PrivacyScreenPlugin](https://github.com/devgeeks/PrivacyScreenPlugin)
The Android part of this plugin is used. It sets `FLAG_SECURE` which achieves two things:

- It prevents users from taking screenshots.
- It hides the app interface in the task switcher.

#### [cordova-plugin-detect-screenshot](https://github.com/Restocks/cordova-plugin-detect-screenshot)
The iOS part of this plugin is used. It detects when users take a screenshot.


text:
# (your app name)

A brief description of your app.

## Requirements

- [Yarn](https://yarnpkg.com/en/docs/install)
- [React Native CLI](https://facebook.github.io/react-native/docs/getting-started) (click the "Building Projects with Native Code" tab)

## Installation

```bash
$ yarn install
```

## Running

```bash
$ yarn start
```

Then, in another terminal, run one of:

```bash
$ yarn ios
$ yarn android
```

## Testing

### Linting

```bash
$ yarn lint
```

### Unit Tests

```bash
$ yarn test
```

repository: CodingItWrong/nativeup

gha_language: Shell

repo_name: CodingItWrong/nativeup


text:
### Constructor & Begin Play II

[previous](../constructor-begin/README.md#user-content-constructor--begin-play) • [home](../README.md#user-content-ue4-blueprints) • [next](../collision/README.md#user-content-collision-events)

The Constructor runs in different scenarios.  The **Begin Play** event **ONLY** runs when you press **Run** in the editor.  It always runs **AFTER** the construction script runs.

---

##### `Step 1.`\|`ITB`|:small_blue_diamond:

Go to the **Blueprints | Room1** folder and right click on **BP_TextOnConstructor** and select **Duplicate**:

![duplicate BP_TextOnConstructor](images/DuplicateBPRm1.jpg)

##### `Step 2.`\|`FHIU`|:small_blue_diamond: :small_blue_diamond:

Rename the file to `BP_TextInBeginPlay`.

![rename blueprint to BP_TextOnBeginPlay](images/RenameBeginPlayRm1.jpg)

##### `Step 3.`\|`ITB`|:small_blue_diamond: :small_blue_diamond: :small_blue_diamond:

Drag the new **BP_TextOnBeginPlay** blueprint into the room, next to the other text blueprint.

![drag BP_TextOnBeginPlay in room](images/DragBPInRoom1.jpg)

##### `Step 4.`\|`ITB`|:small_blue_diamond: :small_blue_diamond: :small_blue_diamond: :small_blue_diamond:

Drag and drop the blueprint instances from the level into the **Room 1** folder in the **World Outliner**.

![put both blueprints in Room folder in world outliner](images/WorldOutlinerCleanupRm1.jpg)

##### `Step 5.`\|`ITB`| :small_orange_diamond:

*Open* **BP_TextInBeginPlay**, enter the **Construction Script** tab and *copy* and *delete* all the nodes to the right of the **Construction Script** node.

![copy and delete construction script nodes](images/CopyAndDeleteConstructionNodes.jpg)

##### `Step 6.`\|`ITB`| :small_orange_diamond: :small_blue_diamond:

Go into the **Event Graph** tab and click on an open space next to the **Event Begin Play** that is greyed out and press *paste*.

![paste nodes in event graph](images/PasteInEventGraphRm1.jpg)

##### `Step 7.`\|`ITB`| :small_orange_diamond: :small_blue_diamond: :small_blue_diamond:

Adjust the position of the nodes to keep then neet. Attach the pin from **Event Begin Play** to the **Set Text** node. Now the **Begin Play** will only fire once when you run the game. So anything you connect to this pin will only run when you press the play button. Change the message to reflect that this will run when the **Begin Play** event is triggered. I put `I am the <br>BeginPlay Script node!`.  Notice that **
** is a carriage return (new line) that is the same syntax used in **HTML**.

![connect begin play](images/ConnectBeginPlayToSetTextExPins.jpg)

##### `Step 8.`\|`ITB`| :small_orange_diamond: :small_blue_diamond: :small_blue_diamond: :small_blue_diamond:

Press the Compile button until you get the green check mark.

![press compile](images/PressCompileRm1.jpg)

##### `Step 9.`\|`ITB`| :small_orange_diamond: :small_blue_diamond: :small_blue_diamond: :small_blue_diamond: :small_blue_diamond:

Go into the game and notice that it now says **Text**. This is the default value of that **Text** node that you could change in the blueprint if you wish.

![look at blueprint in game](images/image_02.jpg)

##### `Step 10.`\|`ITB`| :large_blue_diamond:

Press the Play button and voila the text changes.

![press play and see text change](images/image_03.jpg)

When you stop the game, it goes back to its prior state of just having **Text** on the screen.

![stop game text disapears](images/BackToText.jpg)

##### `Step 11.`\|`ITB`| :large_blue_diamond: :small_blue_diamond:

So **Begin Play** only runs when we run the game and it runs **ONCE**. Now we saw that the **Construction Script** ran when we compiled the blueprint. It also changes when that object changes in the level even before the game is run.

Go to **BP_TextInConstructor** and *delete* the **Make Literal Text**. Replace it with **Make Literal String**. Add to the **Value** box `I am the <br>BeginPlay Script node!`. Add a **Random Integer in Range** node and add two values that the game will randomly generate. I used `20` and `50`.

Add a **String | Append** node and connect **Make Literal String** into the **A** of the **Append** node and the **Random Integer In Range | Return Value** to the **B** side of the **Append** node. This adds an integer to string conversion node for you. This will concatonate the two strings together joining the message and the random number.

Send the output of the **Append** node to the **Value** input pin in **Set Text** (it will add a **ToText(string)** conversion node for you).

![add random integer to end of string](images/image_04.jpg)

##### `Step 12.`\|`ITB`| :large_blue_diamond: :small_blue_diamond: :small_blue_diamond:

Now you can change the random number and run that node every time you compile the blueprint or change that blueprint object in the editor. It only runs in these two conditions and will not run during the game. If you hit play that text will always be the same for as long as the game is running.

https://user-images.githubusercontent.com/5504953/132024649-72889840-7518-45a7-adb6-55a6aa6d1edf.mp4

##### `Step 13.`\|`ITB`| :large_blue_diamond: :small_blue_diamond: :small_blue_diamond:  :small_blue_diamond:

Lets connect Unreal with our GitHub repository. Click on **Source Control | Connect to Source Control...** and select the provider **Git (beta version)**. Click on the Accept Settings button.

![connect to source control with git](images/image_05.jpg)

##### `Step 14.`\|`ITB`| :large_blue_diamond: :small_blue_diamond: :small_blue_diamond: :small_blue_diamond:  :small_blue_diamond:

Press **File | Save All** then go into **Source Control | Submit to Source Control**, add a message that you have completed room 1 and press the Submit button. Open up **GitHub Desktop** and **Push** changes to server. The first time you do this it will say **Publish Branch**.  Select this to finish off this section.

![commit to source control in unreal](images/image_06.jpg)

![push in github desktop](images/RmOneGithub.jpg)

___

| [previous](../constructor-begin/README.md#user-content-constructor--begin-play)| [home](../README.md#user-content-ue4-blueprints) | [next](../collision/README.md#user-content-collision-events)|
|---|---|---|


text:
---
title: Expeditious Retreat
tags: notes
season: summer
toc: true
comments: true
---
# Expeditious Retreat

*1st-level transmutation*

**Casting Time:** 1 bonus action

**Range:** Self

**Components:** V, S

**Duration:** Concentration, up to 10 minutes

This spell allows you to move at an incredible pace. When you cast this spell, and then as a bonus action on each of your turns until the spell ends, you can take the Dash action.

[[Spells]]

path: /_notes/No Graph/5e Reference/spells/Expeditious Retreat.md

filename: Expeditious Retreat.md


text:
![LICENSE](https://img.shields.io/badge/license-MIT-blue.svg?style=flat-square)
![Security Status](https://img.shields.io/security-headers?label=Security&url=https%3A%2F%2Fgithub.com&style=flat-square)
![Gluten Status](https://img.shields.io/badge/Gluten-Free-green.svg)
![Eco Status](https://img.shields.io/badge/ECO-Friendly-green.svg)

# Pixar Error 404

_29 group website project_

This project is for educational porpuses only. Pull request are welcome, but priority for my real-life students! Thank you for your cooperation!

Site published at https://justas1988.github.io/3-pixar-error-404/

Design: [Pixar Error 404](https://miro.medium.com/max/2646/1*847Jp_9BIkm95T42f1Wczw.png)

## Project features

- Github pages
- desktop only
- html
- img
- paragraphs
- css

## Authors

[Justas](https://github.com/Justas1988)


text:
# Pithomyces graminicola R.Y. Roy & B. Rai, 1968 SPECIES

#### Status
ACCEPTED

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Trans. Br. mycol. Soc. 51(1): 154 (1968)

#### Original name
Pithomyces graminicola R.Y. Roy & B. Rai, 1968

### Remarks
null


text:
# validate-tree

Validates a rojo-esque tree definition, like so:

## Demo

```ts
const projectTree = {
	$className: "Folder",
	NumItems: {
		$className: "IntValue",
		Data: "Folder", // This is a shorthand for { $className: "Folder" }
	},
} as const;

function g(o: EvaluateInstanceTree<typeof projectTree>) {
	return o.NumItems.Value++;
}

function f(o: Instance) {
	if (validateTree(o, projectTree)) {
		print(o.NumItems.Data.GetFullName()); // good
		g(o); // good!
	}
	o.NumItems.Data.GetFullName(); // error!
	g(o); // error!

	promiseTree(o, projectTree).then(project => {
		print(project.NumItems.Value)
	})
}
```

The first parameter must be an Instance (or extend from it). The second parameter must be an object tree similar to ones considered valid by Rojo. Every tree must have a `$className` member, and can have any number of keys which represent the name of a child instance, which should have a corresponding value which is this same kind of tree. There is also a shorthand syntax, seen above with `Folder: "Folder"`, which is equivalent to `Folder: { $className: "Folder" }`.

###### Note: Currently, the `as const` may be necessary to preserve the true type of the object tree. Your types will not work if you do not use the tree object in-line or declare it with `as const` after it.

This library also exports `EvaluateInstanceTree` if you want to use it for your own nefarious purposes.

license: ISC

repository: Validark/Roblox-TS-Libraries

gha_language: Lua

gha_license_id: ISC

repo_name: Validark/Roblox-TS-Libraries


text:
Source Files for the Keyboard featured on my Youtube channel https://youtu.be/L04CBJteuHE
firmware files for this build are located here https://github.com/wlard/vial-qmk/tree/vial/keyboards/w60

Notes before you start to replicate this build:
the 2 switches located under the microcontoller are using the hotswap sockets without the wing part but i also cutoff the top wireguides before printing those in the slic3r

if you get keys sending a keystroke twice then most likely a wire is loose or the connection in the hotswap socket is not secure an easy way to fix this is to remove the switch and bend the legs of the switch about 10 degrees this will be addressed in a future update of the hotswap sockets but is not implemented yet.

license: Unlicense


text:
+++
title = "Concepts"
weight = 1
sort_by = "weight"
template = "sections/docs/chapters.html"
+++

The documents in this section are high-level introductions to the Urbit project and components thereof.

* [Technical Overview](technical-overview): An in-the-weeds explanation of the components of the Urbit stack.
* [Azimuth](azimuth): An overview of Azimuth, the Urbit identity layer.


text:
# About RIDE

**RIDE** is a functional programming language based on [expressions](/ride/base-concepts/expression.md).

RIDE is used for writing [scripts](/ride/script.md).

The language:

* has a [strong](https://en.wikipedia.org/wiki/Strong_and_weak_typing) [static typing](https://en.wikipedia.org/wiki/Type_system#Static_type_checking)
* has no loops, recursions and goto-like expressions, and therefore is not [Turing complete](https://en.wikipedia.org/wiki/Turing_completeness)
* is [case-sensitive](https://en.wikipedia.org/wiki/Case_sensitivity)

## IDE

Use [Waves IDE](/smart-contracts/tools/waves-ide.md) or Visual Studio Code with the [RIDE extension](https://marketplace.visualstudio.com/items?itemName=wavesplatform.waves-ride) for writing scripts.

## The history of creation

RIDE was created in 2018. The [white paper](https://wavesplatform.com/files/docs/white_paper_waves_smart_contracts.pdf) of the language was published at that time also.


text:
# Spellviewer Change Log

## Version 0.6.3
 ### Major Changes
   - Recreated the classes layout so it would act the same as levels.
   - Created the correct testing folder with a few tests inside for creating a spell.
 ### Minor Changes
   - Added an if statement inside useFilterTable, that way classes an be used. It needs to be updated, im trying to figure out how to use it affectively with removing spells.
   - Cleaned up the SpellList class.
 ### Bug Fixes
   - This isnt so much a fix, but the DiplayTable.clear(); is causig a few issues inside the useFilterClass. When multiple checkboxes are selected it causes the display to become null. we need to find a way around it or keep it commented out for now.

## Version 0.6.2
  ### Major Changes
    - Spells are now displayed in a predetermined format.

## Version 06.1
  ### Major Changes
    - The methods for the checkbox commands. Changing the format inside the design window, creating it so that it can effect the way each checkbox can be effected directly by using the parameter.
  ### Minor Changes
    - The way the Xml file is loaded in is automatic and doesn't have to be placed inside the debug folder.
  ### Bug Fixes
    - Some of the loading issues with the level attributes, and errors with selecting 2 or more checkboxes and then deselecting 1.


text:
Brigade Organizer’s Playbook

**Version Two**

**Updated December 15th, 2016**

**Introduction**

Over the past four years, Code for America Brigades have learned a lot about how to build sustainable, civic hacking groups and bring 21st century government practices and products to their cities. Based on these lessons, we’ve compiled this playbook to help Brigade organizers get started.

This playbook is a work in progress. We will continue to update the content, design, and format. Please email us at [brigade-info<EMAIL_ADDRESS>with any questions or feedback.

Thank you to the United States Digital Service for playbook [inspiration](https://playbook.cio.gov/).

**Table of Contents**

[[TOC]]

## ORGANIZE

### Host hack nights and days of action

**Description**

Hosting regular hack nights and days of action (CodeAcross, National Day of Civic Hacking, CityCamp) are primary activities for Brigades. These events provide consistent spaces for Brigade members and government and community partners to come together to conduct user research, build prototypes, and more.

**Checklis****t:**Identify day/times for hack nights or larger events

* Identify themes for hack night or events. Often hack nights are less theme-based but some Brigades do special activities once a month, such as hosting speakers or touring city departments

* Lock down a venue for your event

* Find sponsors for your event

* Create an online invite for your event

* Invite government and community partners to your hack nights and events

* Recruit Brigade members from a diverse range of places to your events and hack nights

* Get logistics in place for your event, such as food, AV, etc.

**Key Questions**

* What is our plan for recruiting and engaging a diverse group of people for our event?

* What is our plan for welcoming new people to our Brigade hack nights and events?

* How will our core team manage logistics for hack nights and events?

* How will the work continue from hack night to hack night OR after a big event?

* What research can be done to prepare attendees for the event?

**Resources**

* [How to run a civic hackathon](http://www.smartchicagocollaborative.org/civic-innovation-toolkit-how-to-run-a-civic-hackathon/) (Smart Chicago)

* [Projects for new Brigade members](https://docs.google.com/document/d/1wo_skwazuom_Zkp7AmCSjy5JD8Z5WYSbhr2IUmqWdQ0/edit)

* [How to welcome new coders to a hackathon](https://18f.gsa.gov/2015/04/03/how-to-welcome-new-coders-to-a-civic-hackathon/) (18F)

* [How to start a CityCamp](http://www.citycamp.govfresh.com/start-a-camp/) (CityCamp)

* [Lessons learned from organizing Chi Hack Night (Video](https://www.youtube.com/watch?v=V7MDrILmMIk&list=PL65XgbSILalUbldgqtt8e03hN01L4Z978&index=13)[)](https://www.youtube.com/watch?v=V7MDrILmMIk&list=PL65XgbSILalUbldgqtt8e03hN01L4Z978&index=13) (Derek Eder and Claire Micklin)

* [Onboarding new members to projects (Video)](http://forum.codeforamerica.org/t/2015-february-5-brigade-discussion-onboarding-new-members-to-projects/140)

* BONUS: [@CivicWhitaker Anthology: Three years of organizing, writing, and documenting in Chicago civic tech at the Smart Chicago Collaborative](http://www.slideshare.net/smartchicago/the-civicwhitaker-anthology-53351581) (Smart Chicago)

### Cultivate government partnerships

**Description**

Collaborating with government is the central tenet of Code for America’s theory of change, so building strong relationships with government partners is key to building a strong Brigade. Government partners bring subject matter expertise to a Brigade, skills around outreach, public administration, and valuable experience  around solving the toughest problems in our cities. Brigades support local governments by working together on events and civic technology projects.

**Checklist**

* Start small. Identify a few departments or government partners your Brigade would like to work with.

* Introduce yourself to these potential partners, or better yet, find someone who knows them to introduce you.

* Get to know one another. This might mean introducing potential government partners to the idea of civic hacking and concepts like user-centered design.

* [Host a workshop to help partners identify user needs](#heading=h.4vt81gxpuzke) and determine where your Brigade could use technology to make an impact for government partners and/or the people they serve

* Invite government partners to hack nights

* Start with small wins - experiment with a small project

* Set up tours of government departments for your Brigade members to get a closer look at government in action

* Acknowledge good work

**Key Questions**

* Do we have a point of contact at the city that can help guide us through city government?

* How can we meet government partners where they are?

* What can we do to make it easy for government partners to collaborate with our Brigade?

* Is our space a learning environment where it’s easy to collaborate?

**Resources**

* [What is Civic Tech?](https://medium.com/@CivicWhitaker/what-is-civic-tech-b61a58c3eba8)

* [10 Ways to Collaborate with Government](https://docs.google.com/document/d/1WtoE_Kfqcu73MCUOIXujrzTfqrQAW3DGt0sC8iKJ6Rw/edit#)

* [Collaborative Project Management](http://www.smartchicagocollaborative.org/collaborative-project-management/) (Smart Chicago)

* [A User-Centered approach to food stamps (Video)](https://www.youtube.com/watch?v=lqTFi2U2Ebc)

* [Code for San Jose’s Guide to collaborating with Government](http://codeforsanjose.com/collaboration-guide-for-government/)

### Cultivate community partnerships

**Description**

Community organizations are an important part of the equation when tackling the biggest problems in our cities. Community organizations include foundations, social service nonprofits, and educational institutions. These partners bring subject matter expertise to a Brigade, skills around outreach, service delivery, and valuable experience around solving the toughest problems in our cities. Brigades support local community partners by working together on events and civic technology projects.

**Checklist**

* Start small. Identify a few community partners your Brigade would like to work with.

* Introduce yourself to these potential partners, or better yet, find someone who knows them to introduce you.

* Get to know one another. Attend a community organization’s events and invite them to yours.

* [Host a workshop to help partners identify user needs](#heading=h.4vt81gxpuzke) and determine where your Brigade could use technology to make an impact for community partners and/or the people they serve.

* Start with small wins - experiment with a small project.

* Acknowledge good work.

**Key Questions**

* How can we meet community partners where they are?

* What can we do to make it easy for community partners to collaborate with our Brigade?

* Is our space a learning environment where it’s easy to collaborate?

**Resources**

* [Q&A’s lead to more Q&A’s - and that’s OK!](http://blog.codeforboston.org/2015/09/30/qas-lead-to-more-qs-than-as-and-thats-ok/) (Code for Boston)

* [Collaborative Project Management](http://www.smartchicagocollaborative.org/collaborative-project-management/) (Smart Chicago)

## BUILD

### Host a workshop to help partners identify user needs

**Description**

One of the most common questions at hack nights is, what should we do? By researching and understanding user needs with government and community partners, Brigade members can get a better idea about what projects to take on and how they should be shaped.

**Code for Boston’s User Needs Workshop Checklist**

* Host a workshop for government and community partners. The goal of the workshop is to identify user needs that your Brigade can prototype at a hack night or upcoming event.

* At the workshop, kickoff by explaining civic hacking concepts that it will be useful for your partners to know. This might include hack nights/hackathons; prototyping and lean development; user research.

* Next, conduct an exercise where each person in the room writes down problems they are interested in solving for their organization or department. You can do this a few ways:

    * Use the prompt "how might we..." For example "How might we help youth in Codman Square to find jobs that they can get to without a car."

    * Use the prompt "As a ____, I want to ____, so that I can ______." For example, “As a parent, I want find out about public school enrollment so that I can get my child registered for kindergarten.”

* Give the participants homework to A.) continue to refine their statement(s) for the hack night or event that they’ll be attending B.) gather any data or research they think might be useful.

**Key Questions**

* Do we understand the problem set the user faces?

* Are we talking to real people that are facing the challenge? Are we in the trenches trying to help?

* As we start to identify needs, what are the project ideas that are feasible for our Brigade to take on?

**Resources**

* [GDS Design Principles](https://www.gov.uk/design-principles) (UK Government Digital Service)

* [Experimental Modes in Civic Technology](http://www.smartchicagocollaborative.org/launch-experimental-modes-of-civic-engagement-in-civic-tech-meeting-people-where-they-are/) (Smart Chicago)

* [Subject Matter Primers](http://www.smartchicagocollaborative.org/category/primer/) (Smart Chicago)

* [Building User-Friendly Tools: Lessons Learned from the City of Asheville](https://www.youtube.com/watch?v=3P_98VeTlDs) (Video)

* Is this a good brigade project?  Some guiding questions to determine of whether we can or should try a project [https://files.slack.com/files-tmb/T024F66L9-F07VCMHC3-15f0381db1/img_2282_720.jpg](https://files.slack.com/files-tmb/T024F66L9-F07VCMHC3-15f0381db1/img_2282_720.jpg) )

### Practice lean software development

**Description**

There are a lot of resources out there about how to build software in a lean way. We won’t reinvent the wheel but here are some parts of the lean process that are particularly relevant to building Brigade projects.

**Checklist**

* Organize up front. Getting the right partners and members involved at the beginning of a project allows you to develop in a lean way and makes it easier to iterate faster

* Experiment and have fun

* Make the project accessible for others who want to help, have a clear README

* Break down project into the smallest parts. Short cycles and deliverables are motivating for volunteers and also make it easier to bring new people in.

* Design, build, test, repeat.

* ID metrics to measure project impact

**Key Questions**

* What is the user need?

* How can we break this project into small enough pieces so we’ll always be shipping?

* How can our Brigade help non-technical members and partners understand lean software development? What infrastructure do we need to build around this (i.e. monthly Lean 101 Workshop)?

**Resources**

* [Minimum Viable Civic Tech Projects (Video)](http://forum.codeforamerica.org/t/2015-march-17-minimum-viable-civic-tech-projects/175)

* [The Big Thing about Small Things (Video)](https://youtu.be/yViYA8IG36U)

### Conduct user testing

**Description**

User testing is vital to ensuring that your project both works and actually solves the problem it’s trying to address.

**Cyd Harrell’s Usability Checklist**

* Grab a human

* Set up to see their screen and hear them talk

* Ask what they need from your (process, website, app)

* Have them actually try it and narrate for you

* Zip your lip and take notes

**Key Questions**

* What infrastructure can our Brigade setup to ensure we are always testing our projects? (i.e. CUTGroup)

* Does our project work like we designed it?

* Does our project solve the problem?

* Are there ways that we can improve the project to make it better suit user needs?

**Resources**

* [User Research 101 Skillshare](https://docs.google.com/presentation/d/1XSsQB0RR3k5_Pn_eOzX9uC-jb_ULTz3I71Eze6TzEAI/edit#slide=id.p4) (Cyd Harrell)

* [CUTgroup Book](http://www.cutgroupbook.org/) (Smart Chicago)

## INFRASTRUCTURE

### Implement a Code of Conduct

**Description**

An enforceable Code of Conduct is important in ensuring that your Brigade’s activities, events, and digital forums provide safe environments that allow for participation from a diverse set of people. The proper implementation of the Code of Conduct is required to become an Official Brigade or receive any resources from Code for America.

**Checklist**

* Adopt the [Code for America Code of Conduct](https://github.com/codeforamerica/codeofconduct) or fork it and create your own

* Designate points of contact for concerns about breaches of the Code of Conduct

* Publish the Code of Conduct on your website

* Socialize the Code of Conduct regularly on your digital forums and at your events

**Key Questions**

* Who can Brigade members turn to if they have an issue?

* What is our strategy for enforcing the Code of Conduct?

* What is our strategy if someone contacts us with concerns?

* How will we address individuals who do not respect the Code of Conduct?

**Resources**

* [Code for America’s Code of Conduct on GitHub](https://github.com/codeforamerica/codeofconduct)

* [Ashe Dryden’s Code of Conduct 101](http://www.ashedryden.com/blog/codes-of-conduct-101-faq)

* For Code of Conduct concerns at any Code for America event, please email [safespace<EMAIL_ADDRESS>

### Build a core team

**Description**

Brigades with a diverse team of leaders are more sustainable and more effective than groups with just one leader. Because of this, it’s important to develop a core team early. By working collaboratively, the core team can manage your Brigade as it grows and takes on more projects and activities.

**Checklist**

* Identify what core roles you think are needed for your Brigade have to be successful. For an Official Brigade, Code for America requires a Brigade to have a Captain, Delivery Lead, Community Organizer and Storyteller

* Recruit people to fill your core team roles

* Meet regularly

* Communicate consistently

**Key Questions**

* Is our core team representative of our city?

* Does our team have a variety of skillsets?

* How will our core team make decisions?

* What methods of collaboration work well for us?

**Resources**

* [Roles within a Brigade](https://docs.google.com/document/d/1SAGXWKPqDXwHHSVxXv_rzJRCjLTSqgjyWN6vcGOvLcY/edit?usp=sharing)

* [Suggestions for additional Core Team members](https://docs.google.com/a/codeforamerica.org/document/d/18euVp1WUDWz7Fd625lVuK4kUUqAwsa-BSsNbNEAqbyA/edit?usp=sharing)

* [Recruiting for a Diverse Core Team](https://www.codeforamerica.org/brigade/tools/recruiting-diverse-leadership/) , Steve Spiker and Ellie Tumbuan from Open Oakland

### Draft a strategic plan

**Description**

A strategic plan will help your Brigade identify what you want to do in 2016. Use this as an opportunity to collectively decide what your Brigade will focus on and how you will get there.

**Checklist**

* Invite your core team (and government and community partners, if appropriate) to a planning meeting

* Think about what you want to accomplish in the next year (small wins are ok!)

* Document your vision

* Articulate your tactics (the more specific the better!)

* Submit your strategic plan to Code for America

* Schedule time to revisit your strategic plan throughout the year

**Key Questions**

* What does our Brigade want to accomplish this year?

* What partners would we like to work with in 2016?

* What strategies and tactics will our Brigade use to meet our goals?

* What outcomes do we envision for the end of 2016? Why is it worth it for our core team and the Brigade volunteers to do this work?

**Resources **

* [201](https://docs.google.com/document/d/1EB0Vv0yIkFQM_xpOaUS13loogYy0qtcnVxdo32mlCRA/edit#)[6 Strategic Plan Template](https://docs.google.com/document/d/1EB0Vv0yIkFQM_xpOaUS13loogYy0qtcnVxdo32mlCRA/edit#)

* [Advice from experienced Brigade leaders](http://forum.codeforamerica.org/t/brigade-pre-summit-storytelling-on-advice/287)

### Fundraise

**Description**

In order build sustainable Brigade chapters, groups should develop local partnerships to fundraise for food for hack nights and other costs associated with running regular Brigade meetings.  Here are a few key strategies to help you fundraise for your Brigade.

**Checklist**

* Designate fundraising lead(s)

* Understand the donor ecosystem in your community including individual, institutional, and corporate donors

* Develop a fundraising strategy. Set S.M.A.R.T fundraising goals: specific, measurable, attainable, relevant and timely

* Set up a database or CRM to track prospects and donors. This could be as simple as a spreadsheet in Google docs

* Identify fundraising prospects

* Execute on your strategy through the donor cultivation cycle: qualification, cultivation, solicitation, stewardship

**Key Questions**

* What is our budget for the year? How much money is needed to balance our budget and promote growth?

* Who are all the individual, institutional and corporate donors in our area and networks that would be interested in funding our work?

* What narratives from our work would be compelling for these donors?

**Resources**

* [Brigade Fundraising Handbook](https://docs.google.com/document/d/1c9Jbtdj_wKP2dDwxslXhBQoobzpTwsxkrSjAlLQdkI0/edit#heading=h.c8bc7axfomwl)

* [2016 Strategic Plan Template](https://docs.google.com/document/d/1EB0Vv0yIkFQM_xpOaUS13loogYy0qtcnVxdo32mlCRA/edit#)

* [Expense Reimbursement Process](https://docs.google.com/document/d/1dD1hcMO5XbiHRQfMS-3rw1PLO0H8MAoOu1p_khLGdeQ/edit#)

* [Getting Sponsors for Your Event](http://www.smartchicagocollaborative.org/getting-sponsors-for-your-local-civic-hacking-event/) (Smart Chicago)

### Set up tools to manage your Brigade

**Description**

Your Brigade will need tools to communicate with one another and build projects. A tool is only useful, however, if people use it. Select and implement the tools your Brigade needs to do its work and add others as needed.

**Checklist**

* Set up a Meetup account for your Brigade.

* Set up a free Github organization account for your Brigade.

* Set up a Brigade website. The most popular templates are [Code for San Francisco](http://codeforsanfrancisco.org/) and [Code for Philly](https://codeforphilly.org/).

* Add your Brigade to the [Code for America API](https://github.com/codeforamerica/cfapi#how-to-add-your-brigade-to-the-api).

* Choose a project management tool for your core team to use. Brigades use a mix of Waffle.io, Trello, Github Issues, etc. Don’t spend much time debating what to use, just choose one and go.

* If needed, choose a forum tool for your Brigade to share resources and have online discussions. Brigades use Discourse, Google Groups, Meetup, and GitHub Issues.

* If needed, choose a tool for your Brigade to chat with one another. Most Brigades use Slack.

**Key Questions**

* What tools does our Brigade need to get its work done?

* How will we socialize these tools across our Brigade?

* How will we onboard new members to these tools?

**Resources**

* [Brigade Tools](http://wiki.codeforamerica.org/DTeam/inkinds.md)

### Develop a brand and media strategy

**Description**

Humanizing the theory behind your work and sharing a captivating narrative will help people understand what your Brigade does. Consistency in branding will help unify all the Brigades and clearly articulate the power of our interconnected network.

**Checklist**

* Know your Brigade, what is the character of your group and its relationship to your city?

* Choose a couple events or projects you want to share. Decide why these represent your Brigade well

* Use the Brigade logos, templates, fonts, and colors

**Key Questions**

* What is the story we’d like to tell about our Brigade?

* What is our strategy for letting the community know about our work?

* Do we have an ask at the end of each story?

**Resources**

* **Brand**

    * [Code for America Brigade Branding Guidelines](http://www.codeforamerica.org/blog/2015/07/29/code-for-america-brigade-branding-guidelines/)

    * [Code for America Logos](http://www.codeforamerica.org/logos/)

    * [How to make an Amazing Slide Deck](https://docs.google.com/a/codeforamerica.org/presentation/d/1g5U9XzxXoZ-iolBMejqu9LmP8Zf6D9aHIf8Vxcuv7vw/edit?usp=drive_web)

* **Media**

    * [Brigade Media Tips](http://www.codeforamerica.org/blog/2015/07/28/brigade-media-tips/)

    * [Tools for interacting with the Press](https://docs.google.com/presentation/d/1V74_KGwtAxPejtOwputxtpP5We-lZ7xuMSJCk71_bag/edit#slide=id.g5b922e4c6_0_84) (Slide Deck)

    * [How to Blog](http://www.smartchicagocollaborative.org/how-to-blog/)  (Smart Chicago)

    * [Using Twitter to boost your event ](http://www.smartchicagocollaborative.org/using-twitter-to-boost-your-event/)(Smart Chicago)

Have a play you want to add? Write it up at [http://forum.codeforamerica.org/](http://forum.codeforamerica.org/).

 Email us at [brigade-info@codeforamerica.org](mailto:brigade-info@codeforamerica.org).

url: https://raw.githubusercontent.com/isabella232/brigade-knowledge/76e1c48eff7d4edea47f575d125ddf9accb6168d/guides/Brigade Organizer's Playbook 2017 (v2).md


text:
# SalesManago API Client

Implementation of SalesManago API version `1.45`.
For more details about the API go to [SalesManago site].

## Installation

Install the package through composer.
For the latest stable version use:

```
php composer.phar require pixers/salesmanago-api:1.1.1
```

For the latest version use:

```
php composer.phar require pixers/salesmanago-api:dev-master
```

## Usage

API Client is divided into several sub-services, responsible for particular resources (e.g. Contacts, Events):

* [ContactService](src/Pixers/SalesManagoAPI/Service/ContactService.php)
    * ContactService::create($owner, $data)
    * ContactService::update($owner, $email, $data)
    * ContactService::upsert($owner, $email, $data)
    * ContactService::delete($owner, $email, $data)
    * ContactService::has($owner, $email)
    * ContactService::useCoupon($email, $coupon)
    * ContactService::listByEmails($owner, $data)
    * ContactService::listByIds($owner, $data)
    * ContactService::listRecentlyModified($owner, $data)
    * ContactService::listRecentActivity($data)
* [CouponService](src/Pixers/SalesManagoAPI/Service/CouponService.php)
    * CouponService::create($owner, $email, $data)
* [EmailService](src/Pixers/SalesManagoAPI/Service/EmailService.php)
    * EmailService::create($data)
* [EventService](src/Pixers/SalesManagoAPI/Service/EventService.php)
    * EventService::create($owner, $email, $data)
    * EventService::update($owner, $eventId, $data)
    * EventService::delete($owner, $eventId)
* [MailingListService](src/Pixers/SalesManagoAPI/Service/MailingListService.php)
    * MailingListService::add($email)
    * MailingListService::remove($email)
* [PhoneListService](src/Pixers/SalesManagoAPI/Service/PhoneListService.php)
    * PhoneListService::add($email)
    * PhoneListService::remove($email)
* [RuleService](src/Pixers/SalesManagoAPI/Service/RuleService.php)
    * RuleService::create($owner, $data)
* [SystemService](src/Pixers/SalesManagoAPI/Service/SystemService.php)
    * SystemService::registerAccount($data)
    * SystemService::authorise($userName, $password)
* [TagService](src/Pixers/SalesManagoAPI/Service/TagService.php)
    * TagService::getAll($owner, $data)
    * TagService::modify($owner, $email, $data)
* [TaskService](src/Pixers/SalesManagoAPI/Service/TaskService.php)
    * TaskService::create($data)
    * TaskService::update($taskId, $data)
    * TaskService::delete($taskId)

### Basic usage

```php
<?php

use Pixers\SalesManagoAPI\Client;
use Pixers\SalesManagoAPI\SalesManago;

// First - initialize configured client
// endpoint - e.g. https://app3.salesmanago.pl/api/
$client = new Client($clientId, $endpoint, $apiSecret, $apiKey);

// Then - initialize SalesManago Services Locator
$salesManago = new SalesManago($client);

// Now you can use specific services
$contactResponse = $salesManago->getContactService()->delete($owner, $email, $data);

$eventResponse = $salesManago->getEventService()->delete($owner, $eventId);
```

## Tests

Create phpunit configuration in `phpunit.xml` file, based on template from [phpunit.xml.dist](phpunit.xml.dist).
After that you can run tests with:

`phpunit -c phpunit.xml`

## Authors

* Sylwester Łuczak<EMAIL_ADDRESS>* Antoni Orfin<EMAIL_ADDRESS>* Michał Kanak<EMAIL_ADDRESS>
## License

Copyright 2016 PIXERS Ltd - www.pixersize.com

Licensed under the [BSD 3-Clause](LICENSE)

[SalesManago site]:http://www.salesmanago.pl/marketing-automation/developers.htm

repository: VFiber/salesmanago-api

repo_name: VFiber/salesmanago-api