text:
[![Build Status](https://travis-ci.org/bestmike007/appbase.svg?branch=master)](https://travis-ci.org/bestmike007/appbase)
[![Code Climate](https://codeclimate.com/github/bestmike007/appbase/badges/gpa.svg)](https://codeclimate.com/github/bestmike007/appbase)
[![Test Coverage](https://codeclimate.com/github/bestmike007/appbase/badges/coverage.svg)](https://codeclimate.com/github/bestmike007/appbase)
[![Gem Version](https://badge.fury.io/rb/appbase.svg)](http://badge.fury.io/rb/appbase)

Nowadays BaaS and mBaaS platforms (e.g. [firebase](https://www.firebase.com/), [parse](https://www.parse.com/), [appbase.io](https://appbase.io/)) abound. Open source solutions (e.g. [usergrid](http://usergrid.incubator.apache.org/) using LAMP, [helios](http://helios.io/) using Ruby, [deployd](http://deployd.com/) and [StrongLoop](http://strongloop.com/) using nodejs, and a lot more) are also available. And appbase is much less than those.

What is appbase? Appbase is a lightweight backend based on rails for rubyists with the following basic features:

+ User registration and authentication
+ REST model crud api
+ Expose business logic with a simple line of code
+ 3rd party authentication
+ Push notifications
+ Payment integration
+ Other basic features mostly required by apps

Appbase is/does not:

+ Use GUI to configure models and/or business logic
+ Use configuration files

Appbase is under development; and will be kept as simple as possible.

## Basic Usage

Configure in `application.rb`:

``` ruby
  # enable appbase
  config.appbase.enabled = true
  # default: '/appbase'
  # config.appbase.mount = "/_api"
  config.appbase.user_identity = :User # required
  config.appbase.token_store = :cookies # :cookies, :headers, :params
  config.appbase.token_key_user = :u
  config.appbase.token_key_session = :s
  config.appbase.models.push :User, :Role, :Permission, :UserProfile, :TodoItem, :GroupTodoList
```

Implement `UserIdentityModel#authenticate_by_token(user, token)`:

``` ruby
  class User < ActiveRecord::Base
    def self.authenticate_by_token(user, token)
      # TODO cache the result
      User.find_by(user: user, token: token)
    end
  end
```

Set up CRUD permissions for models:

``` ruby
  class TodoItem < ActiveRecord::Base

    # Allow query
    allow_query :mine
    # or
    allow_query :within => :related_to_me
    def self.related_to_me(current_user)
      TodoItem.where user_id: current_user.id
    end
    # or
    allow_query :within do |current_user|
      TodoItem.where user_id: current_user.id
    end

    # Allow create/update/delete
    allow_create :mine
    # or
    allow_update :if => :related_to_me?
    def self.related_to_me?(current_user, obj)
      obj.user_id == current_user.id
    end
    # or
    allow_delete :if do |current_user, obj|
      obj.user_id == current_user.id
    end

    # restrict_query_columns usage:
    #   restrict_query_columns <only | except>: <single_column | column_list>
    # examples:
    #   restrict_query_columns only: [:user_id, :created_at, :updated_at]
    #   restrict_query_columns only: :updated_at
    #   restrict_query_columns except: [:content]
    restrict_query_columns only: [:updated_at, :created_at]

    # restrict_query_operators usage:
    #   restrict_query_operators :column1, :column2, <only | except>: <:equal | :compare | :in>
    # examples:
    #   restrict_query_operators :user_id, :created_at, :updated_at, only: [:equal, :compare]
    #   restrict_query_operators :user_id, :created_at, :updated_at, except: :in
    #   restrict_query_operators :title, only: :equal
    restrict_query_operators :updated_at, :created_at, except: :in

  end
```

Expose business logic methods:

``` ruby

  # don't have to be an active record
  class GroupTodoList

    include AppBase::ModelConcern

    expose_to_appbase :list_group_todos, auth: true # default to true

    def self.list_group_todos(current_user)
      TodoItem.find_all group_id: current_user.group_id
    end

  end

  # public methods, e.g. authentication, does not have the `current_user` parameter
  class User < ActiveRecord::Base

    expose_to_appbase :authenticate, :external_auth, auth: false

    def self.authenticate(user, pass)
      user = User.find_by username: user, password: pass
      return nil if user.nil?
      user.last_login = Time.now
      user.session_token = SecureRandom.hex
      user.save!
      user.session_token
    end

    def self.external_auth(user, options={})
      case options[:provider]
      when 'twitter'
        # do authenticate
      when 'facebook'
        # do authenticate
      else
        raise "unsupported provider"
      end
    end

  end
```

And that's all.

## The Request Scheme

Apps (including iOS app, Andriod app, web app with angularjs or similar frontend framework, etc.) are communicating with appbase using HTTP/HTTPS.

### The REST API

Basic CRUD api conforms to the representational state transfer (REST) architectural style. Following sections are using model `Note (id, title, content)` as an example to illustrate how a model is created, updated, deleted, and how to perform a query on a model (Supose that the appbase engine is mount on `/_api`).

#### Create

Request to create a model with JSON serialized body:

```
POST /_api/note HTTP/1.1
HOST xxx
Content-Type: application/json

{ "title" : "test" , "content" : "hello", "user_id" : 1 }
```

The server response on success:

```
HTTP/1.1 200 OK

{"status":"ok","id":1}
```

On failure:

```
HTTP/1.1 200 OK

{"status":"error","msg":"error_msg"}
```

#### Update

Almost the same as create except for using `PUT` and adding the `:id` parameter (e.g. `/_api/note/:id`):

```
PUT /_api/note/1 HTTP/1.1
HOST xxx
Content-Type: application/json

{ "title" : "test" , "content" : "hello appabse!", "user_id" : 1 }
```

#### Delete

```
DELETE /_api/note/1 HTTP/1.1
HOST xxx
```

#### Query

The request:

```
GET /_api/note?p=1&ps=20 HTTP/1.1
HOST xxx
```

In the parameters, `p` indicates the page of the query; `ps` indicates the page size of the query. Except for the pagination parameters, query parameters are allowed to filter the query. Supose we need to perform a query on `Note.id`, here are some examples on how to query:

+ /_api/note?p=1&ps=20`&id=1` Equal to 1
+ /_api/note?p=1&ps=20`&id.lt=10` Less than 10
+ /_api/note?p=1&ps=20`&id.le=10` Less than or equal to 10
+ /_api/note?p=1&ps=20`&id.gt=1` Greater than 1
+ /_api/note?p=1&ps=20`&id.ge=1` Greater than or equal to 1
+ /_api/note?p=1&ps=20`&id.lt=10&id.ge=1` Greater than or equal to 1 and less than 10
+ /_api/note?p=1&ps=20`&id.in=[1,2,3]` In 1, 2, 3
+ /_api/note?p=1&ps=20`&id.nin=[1,2,3]` Not in 1, 2, 3
+ /_api/note?p=1&ps=20`&id.n=true` Is null
+ /_api/note?p=1&ps=20`&id.nn=true` Not null

`OR` conditions are not supported for now, use exposed methods instead.

### RPC Methods

Model methods with custom business logic can be exposed as rpc methods, take the method `Note.related_to_me(current_user, limit)` as example.

```
POST /_api/note/related_to_me HTTP/1.1
HOST xxx

limit=10
```

Response from the backend should be:

```
HTTP/1.1 200 OK

{"status":"ok","data":[{"id":1,"key":"value"},{"id":2,"key":"value"},{"id":3,"key":"value"}]}
```

If the method is defined with an `options` parameter, e.g. `Note.related_to_me(current_user, options={})`, then optional request arguments are passed to the method within the option hash object.

## Known Issues

+ `OR` conditions are not supported for active record query
+ Multiple accessible query base
+ Write more test cases
+ Complete the document

You're welcome to contribute to this project by creating an issue / a pull request.

---

## License

Appbase is released under the [MIT License](http://opensource.org/licenses/MIT).


text:
# confirmToGo

Simple Rails application to create events and send invitation to the participants

1. `bundle install`
2. Update mailgun appId
3. Set mina configuration
4. `mina deploy`

## Feature Requests

- [ ] Add User Login
- [ ] Download Email List

license: MIT

repository: harryworld/confirmToGo

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: harryworld/confirmToGo


text:
# typeractive

Typeractive is a self-contained digital garden manager. Intended to "just work"
with minimal dependencies, it offers out-of-the-box support for most media types
and a rich set of social tools including blogs, forums, wikis, knowledge bases,
RSS feeds, mailing lists, and more.

This remarkable flexibility is accomplished with an interface-driven approach
that reaches very deep into the stack. Platform abstractions, data source
abstraction, and universal dependency injection make it easy to do cool stuff.

repository: starekrow/typeractive

repo_name: starekrow/typeractive


text:
---
title: "editObject"
description: "This method will edit an existing SoftLayer_Network_Subnet_Registration object. For more detail, see [SoftLayer_Network_Subnet_Registration::createObject](/reference/datatypes/$1/#$2). "
date: "2018-02-12"
tags:
    - "method"
    - "sldn"
    - "Network"
classes:
    - "SoftLayer_Network_Subnet_Registration"
type: "reference"
layout: "method"
mainService : "SoftLayer_Network_Subnet_Registration"
---

gha_language: HTML

gha_license_id: NOASSERTION


text:
Contributing to OpenZeppelin
=======

We really appreciate and value contributions to OpenZeppelin. Please take 5' to review the items listed below to make sure that your contributions are merged as soon as possible.

## Contribution guidelines

Smart contracts manage value and are highly vulnerable to errors and attacks. We have very strict guidelines, please make sure to review them: ["Contribution guidelines wiki entry"](https://github.com/OpenZeppelin/openzeppelin-solidity/wiki/Contribution-guidelines).

## Creating Pull Requests (PRs)

As a contributor, you are expected to fork this repository, work on your own fork and then submit pull requests. The pull requests will be reviewed and eventually merged into the main repo. See ["Fork-a-Repo"](https://help.github.com/articles/fork-a-repo/) for how this works.

*IMPORTANT*
* Please see ["Git flow wiki entry"](https://github.com/OpenZeppelin/openzeppelin-solidity/wiki/Git-flow) for understanding how to use branches in this repository.

## A typical workflow

1) Make sure your fork is up to date with the main repository:

```
cd openzeppelin-solidity
git remote add upstream https://github.com/OpenZeppelin/openzeppelin-solidity.git
git fetch upstream
git pull --rebase upstream master
```
NOTE: The directory `openzeppelin-solidity` represents your fork's local copy.

*IMPORTANT* Read the PR template very carefully and make sure to follow all the instructions. These instructions
refer to some very important conditions that your PR must meet in order to be accepted, such as making sure that all tests pass, JS linting tests pass, solidity linting tests pass, etc.

5) Maintainers will review your code and possibly ask for changes before your code is pulled in to the main repository. We'll check that all tests pass, review the coding style, and check for general code correctness. If everything is OK, we'll merge your pull request and your code will be part of OpenZeppelin.

*IMPORTANT* Please pay attention to the maintainer's feedback, since its a necessary step to keep up with the standards OpenZeppelin attains to.

## All set!

If you have any questions feel free to post them to github.com/OpenZeppelin/openzeppelin-solidity/issues.

Finally, if you're looking to collaborate and want to find easy tasks to start, look at the issues we marked as ["Good first issue"](https://github.com/OpenZeppelin/openzeppelin-solidity/labels/good%20first%20issue).

Thanks for your time and code!

repository: gwmccubbin/openzeppelin-solidity

gha_license_id: MIT

repo_name: gwmccubbin/openzeppelin-solidity


text:
# Generation of metadata
This document describes how formated metadata records can be generated from given raw information.

## Environment
Ubuntu 14.04 server

## Prerequisites

### 1. Python and the convert script
* Python 2.7 or later

#### 1.1. The script mdmanger.py
The python script ```mdmanger.py (mode ‘g’)``` is used for this training module and comes already with the training package.

#### 1.2
The needed pyton module *dublincore* can be installed by
```sh
pip install dublincore
```
> Note : If you get an error like
```sh
Requirement already satisfied (use --upgrade to upgrade): dublincore in /home/xxx/anaconda2/lib/python2.7/site-packages
```
> you have to add this path to your Python path by
```sh
export PYTHONPATH=$PYTHONPATH:/home/k204019/anaconda2/lib/python2.7/site-packages/
```

### 2. Some samples of raw data
Some examples of 'raw metadata', i.e. comma and tabulator seperated lists,are given in the directory *samples/RAW_data*.
```sh
ls samples/RAW_data
annotations.tsv  sample.csv  smallData.tsv
```
At the moment this part is fully tested with the comma separated lists in the file ```sample.csv```.

## Usage

### 1. Generation of DublinCore XML files

Please check first the usage of the script by :
```sh
./mdmanager.py -h
```
For this part we will only use some of the `Single Mode Options`
```sh
Use these options if you want to ingest from only ONE source.

--source=PATH, -s PATH  A URL to .xml files which you want to harvest
--verb=STRING           Verbs or requests defined in OAI-PMH, can be
                        ListRecords (default) or ListIdentifers here
--mdsubset=STRING       Subset of harvested meta data
--mdprefix=STRING       Prefix of harvested meta data
--target_mdschema=STRING
                        Meta data schema of the target
```

In the following we show how you can convert comma or tabular seperated lists of values to valid XML files formated in the [DublinCore](http://dublincore.org/) metadata schema. The usage of the several options mentioned above will explained in the following.

#### 1.2. Creation of a mapfile
In a first step we define the mapping of each field in the header line of the sample file
```sh
$ head -1 samples/RAW_data/sample.csv
Common name,Scientific name,Location,Temperament,Diet,Water,Size,Region of the Aquarium,Breeding
```
to one of the DublinCore elements (see ```mapfiles/dcelements.txt```) or the DublinCore terms (see ```mapfiles/dcterms.txt```).

You are free by assigning the original fields to any one of the DublinCore fields. The only mandatory fields to set are ```dc:title``` and ```dc:identifier```, whereby the value of the latter is used to build the filename of the generated XML record.

Beside the mode (`--mode g`, standing for generation) and the source (`-s FILE`, the path to the csv file) the following options are mandatory :
- ```-c COMMUNITY``` : a free choosen project or community name. Here and in the following modules we call our project *fishproject*.
- ```--mdprefix MDFORMAT``` : This is the target metadata schema, we choose here *oai_dc*, i.e. the Dublincore metadata schema.

Optionally a subset and the delimiter of the original source file can be specified.
- ```--mdsubset MDSUBSET``` : The subset that determines the sub directory the generated XML files reside. Default is the subset `SET_1`, we choose here `sample`, resulting in the sub directory `sample_1` of the output path.
- ```--verb DELIMITER``` specifies the delimiter by which the sample data are separated, by default (and in our example) set to *comma*.

From these parameters the name for the mapfile is built as ```mapfiles/<community>-<mdprefix>.csv``` and the output path is combined to ```oaidata/<community>-<mdprefix>/<mdsubset>_1```.

By calling the script for the first time, there will be no mapfile available. So you are asked for each original header field to enter a valid DublinCore element or term :

```sh
./mdmanager.py --mode g -s samples/RAW_data/sample.csv -c fishproject --mdprefix oai_dc --mdsubset sample --verb comma
...
|- Generation started : 2016-10-18 17:51:34
 |- Original fields:
	['Common name', 'Scientific name', 'Location', 'Temperament', 'Diet', 'Water', 'Size', 'Region of the Aquarium', 'Breeding']
 |- Generate mapfile	mapfiles/fishproject-oai_dc.csv
Target field for Common name : dc:identifier
Target field for Scientific name : dc:title
Target field for Location : dcterms:spatial
Target field for Temperament : dc:type
Target field for Diet : dcterms:requires
Target field for Water : dcterms:medium
Target field for Size : dcterms:extent
Target field for Region of the Aquarium : dcterms:provenance
Target field for Breeding : dcterms:created
 |- Generate XML files in oaidata/fishproject-oai_dc/sample_1/xml
  |--> Compressiceps.xml
  |--> Frontosa.xml
  |--> GoldenJulie.xml
  |--> ConvictJulie.xml
  |--> PrincessCichlid.xml
  |--> Cylindricus.xml
  |--> Multi.xml
  |--> FiveBarCichlid.xml
```

This results not only in the newly generated mapping file ```fishproject-oai_dc.csv```, but as well the mapping is excecuted and the associated XML files are written to the output directory ```oaidata/fishproject-oai_dc/sample_1/xml/```.

#### Excercise 2.1: Repeat the generation and do your own mapping by adapting the mapping rules in the mapfile to your needs. Hereby the seperator ```>``` is used to seperate the original field name and the target Dublincore element or term :
```sh
$ vi mapfiles/fishproject-oai_dc.csv
Common name>dc:identifier
Scientific name>dc:title
Location>dcterms:spatial
Temperament>dc:type
Diet>dcterms:requires
Water>dcterms:medium
Size>dcterms:extent
Region of the Aquarium>dcterms:provenance
Breeding>dcterms:created
```

#### Excercise 2.2: Check the results, i.e. the generated XML files in the output directory ```oaidata/fishproject-oai_dc/sample_1/xml/```. E.g. with the above mapping one of the resulted files looks as follows:

```sh
less oaidata/fishproject-oai_dc/sample_1/xml/Compressiceps.xml
<?xml version="1.0"?>

<metadata
    xmlns="http://example.org/myapp/"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://purl.org/dc/elements/1.1/"
    xmlns:dc="http://purl.org/dc/elements/1.1/"
    xmlns:dcterms="http://purl.org/dc/terms/">

        <dc:identifier>Compressiceps</dc:identifier>
        <dc:title>Haplochromis compressiceps</dc:title>
        <dc:type>Territorial</dc:type>
        <dcterms:created>Hard</dcterms:created>
        <dcterms:extent>5 inches</dcterms:extent>
        <dcterms:medium>PH 7.0 - 8.0, Temp. 73 - 77 F</dcterms:medium>
        <dcterms:provenance>Bottom</dcterms:provenance>
        <dcterms:requires>Omnivore</dcterms:requires>
        <dcterms:spatial>Lake Tanganyika</dcterms:spatial>
</metadata>
```

You can check this e.g. by one of the available XML validators, e.g. ```sh http://www.xmlvalidation.com/```.

> Note : Here starts the issue of semantic mapping and
> homogenisation of a research specific vocabulary to a common,
> restricted vocabulary or schema as DublinCore. I.e. the mapping above is quite "formal", e.g. `Diet` is mapped to `dcterms:requires`, but likely the intention of the DublinCore consortium by introducing the field `requires` was not in the sense of `a plant requires a specific diet`. So, if we want to cover these specific biological properties we have to add another extented shema, which covers the property `Diet`.


text:
---
layout: home
---

# Consultant on Buyer Understanding
for Software Founders

For sharpening your understanding of the buyer's motivation, your marketing copy and your feature set.

---

I'm {% include avatar.html %} Pascal Laliberté, and **I help software founders like you get into the minds of your buyers**.

* … when your customers continue to cancel, **despite your product's new features**;
* … when your **landing page and your product positioning** aren't working;
* … when your **customer interviews** are hit and miss;
* … when your product just isn't sharp enough;
{: .home-situations-summary }

I offer three levels of engagement: **Product Rescue** (multi-month), **Product Coach for 3 weeks**, or **Review of 8 Customer Interviews**.

[Jump down to Services I Offer](#services){: .cta-btn }

## _Maybe it's that_ Your customers continue to cancel, despite the new features you're building…
{: .maybe-heading }

You got there by doing the right thing. **You listened to your customers** and built what they asked for. But despite building the stuff people asked, buyers aren't buying like they used to.

You're getting churn. **More churn than normal.** A sustained wave of cancellations, and it's not just because of a market slowdown. Something needs to change _fast_.

You were going to overhaul your product. Change your whole vision, risk it all. But you decided instead to **dig deeper into the minds of your customers**. That's why you're here: to slow down and to do things right.

## _Maybe it's that_ Your landing page and your product positioning aren't working…
{: .maybe-heading }

You've put in some effort, but you're stuck not knowing which `h1` to use, which features to highlight...

> "Should I highlight this feature or this other one? Should I keep it general or should I center on specific use cases?"

**You did your best to explain what the software does**, why it would be beneficial. Target market, target problem. You've removed everything that wasn't helping, keep things simple and clean. But what's missing?

> "I've followed some of the norms, but it doesn't seem to be _converting_."

I can help you turn these problems around.

Maybe your buyers are different than what you originally thought they'd be. You'd like to dig deeper.

You've started talking to your buyers. But you don't think you're getting the whole story. **You want to _understand_ what's going on.** And you no longer know which questions to ask.

## _Maybe it's that_ Your product just isn't sharp enough…
{: .maybe-heading }

> "**Our buyers are using the product for purposes that surprise us.** We're getting cancellations, unused features. We thought we knew what problem our product was hired to solve, but we no longer do. We need to stop building and building and **we need to start digging and digging.**"

---

## What if _This_ Was Your Future:

Let's transport you to a time in your future when your product is on track:

* **You've made some new money** and you _know_ why the money happened.
* Visitors to your marketing pages keep telling you **"I felt understood"** and as a result have been signing up, upgrading with confidence, **keeping their subscription going for a longer time**...
* You _have_ what you need to **prioritize the next steps** in your product's development. You can now say you _understand_ your buyer's motivations, you _know_ what's going on.
* You've grown to have a deeper understanding of your buyers because **you heard some insightful purchase stories** from some of your buyers...
* You've upgraded your strategic direction with **a new vocabulary** to describe how your customers need help getting _progress_ on their struggles...
* You've discovered what _causes_ someone to buy your product, **which of the features** is really supporting the _"job"_ your product is being _"hired"_ to do...

That's what's in the books for you, once you **learn to get in the mind of your buyers**. I can help you with that.

---

## Services I Offer:
{: #services }

3 options...

purchasable-service#adjustPurchaseOptions"
  data-purchasable-service-slug="two_day_discovery_product_rescue"
>

### _Option #1_
Product Rescue

**Expensive (revenue share) because I run your product for a while.**

I'll lead improvements to the product positioning over multiple months. I'll run customer interviews, form hypotheses, prepare changes (Shape Up) to the app for your developers to implement, tweak the landing pages and track performance.

USD $10k+ with revenue share, multi-month project.

_Start here:_{: .home-service-offering-start-here }

[Two-day Discovery Exercise, USD $425](mailto:pascal@hey.com?subject=Two-day%20Discovery%20Exercise&body=Hi%2C%0A%0AI'd%20like%20to%20start%20a%20Two-day%20Discovery%20Exercise%20as%20soon%20as%20you're%20available.){: .cta-btn }

<template data-target="purchasable-service.buttonTemplate">
  <form action="%endpoint%" method="POST" class="checkout-button-wrapper">
    <input type="hidden" name="checkout[service_uuid]" value="%service_uuid%">
    <button type="submit" class="cta-btn">
      Two-day Discovery Exercise, USD $%price_in_dollars%
    </button>
  </form>
</template>

Over the next week, I'll initiate the discovery exercise by creating a page where we'll have our discussion (async video + text).
{: .home-service-offering-terms }

purchasable-service#adjustPurchaseOptions"
  data-purchasable-service-slug="product_coach_3_weeks"
>

### _Option #2_
Product Coach for 3 weeks

**Over 3 weeks, I coach you on your product strategy**. It'll be helpful if you're already introduced to the Jobs-to-be-done Theory of customer behavior, but we can cover quickly at the start of those 3 weeks.

I'll help:

* **Identify the struggling moments** your software is hired to resolve
* Hypothesize on the broader **aspirations (the progress) your customers wish to attain**
* Map out the anxieties they experience **while deliberating a purchase**.
* Review your **landing pages and taglines**
* Review some **interview recordings**
* Determine if your product needs **an overhaul, a tweak, or if it won't end up working** at all

We'll discuss your strategy over async text and screen shares on a page on which you'll be invited and I'll provide a 2-working-day turnaround time on our exchanges over the 3 weeks. No live calls, all async video and text.

_Start here:_{: .home-service-offering-start-here }

[Inquire about next available 3-week block](mailto:pascal@hey.com?subject=Product%20Coach%20for%203%20weeks&body=Hi%2C%0A%0AI'd%20like%20to%20inquire%20about%20your%20next%20availability%20for%20a%203%20week%20Product%20Coach%20engagement.){: .cta-btn }

**USD $3,100**

<template data-target="purchasable-service.buttonTemplate">
  <form action="%endpoint%" method="POST" class="checkout-button-wrapper">
    <input type="hidden" name="checkout[service_uuid]" value="%service_uuid%">
    <input type="hidden" name="checkout[start_date]" value="%start_date%">
    <input type="hidden" name="checkout[end_date]" value="%end_date%">
    <button type="submit" class="cta-btn">
      Start week of %start_week% + 2 following weeks, USD $%price_in_dollars%
    </button>
  </form>
</template>

After pre-payment, you'll receive an invitation to a page where we'll hold our coaching discussion.
{: .home-service-offering-terms }

    Pascal helped me tremendously to pin down the messaging and site structure of railsreviews.com. His systematic method for discovering hidden opportunities and buyer hesitations is one of a kind. With a sharp eye for customers' struggles, his analyses are insightful, actionable, and rewarding. I'm looking forward to collaborating with him again in future projects.

  —Julian Rubisch

purchasable-service#adjustPurchaseOptions"
  data-purchasable-service-slug="review_8_customer_interviews"
>

### _Option #3_
Review of 8 Customer Interviews

**I will provide feedback on 8 customer interview recordings you conducted over 2 weeks or less.** I'll provide interpretation, highlight things I spot, include thoughts on product strategy. I'll also provide feedback on what to improve for you next customer interviews, so it's best to pick two weeks where you'll have some more interviews you'll be performing.

Additionally, at the end of the two weeks, I'll provide a one-pager summarizing the insights identified from the interviews. Useful for sharing what was learned with other members of the team.

I worked with Brian Casel of [ZipMessage.com](https://zipmessage.com), reviewing his customer interviews. Here's what he had to say:

I also found it helpful to bring in someone else to listen to my calls, check my biases, and spot insights I'd miss.@pascallaliberte has a sharp ear for customer research and analysis. He's been a huge help with analyzing my calls, comparing notes and takeaways 👍
— Brian Casel (@CasJam) May 23, 2022

_Start here:_{: .home-service-offering-start-here }

[Inquire about next available 2-week block](mailto:pascal@hey.com?subject=Review%20of%208%20Customer%20Interviews&body=Hi%2C%0A%0AI'd%20like%20to%20inquire%20about%20your%20next%20availability%20for%20a%202-week%20%22Review%20of%208%20Customer%20Interviews%22%20engagement.){: .cta-btn }

**USD $1,295**

<template data-target="purchasable-service.buttonTemplate">
  <form action="%endpoint%" method="POST" class="checkout-button-wrapper">
    <input type="hidden" name="checkout[service_uuid]" value="%service_uuid%">
    <input type="hidden" name="checkout[start_date]" value="%start_date%">
    <input type="hidden" name="checkout[end_date]" value="%end_date%">
    <button type="submit" class="cta-btn">
      Book %date_range_as_string%, USD $%price_in_dollars%
    </button>
  </form>
</template>

After pre-payment, I'll create 8 pages on which you can upload your customer interview recordings. That's where I'll share with you videos of me providing my feedback and showing my notes. Interview recordings must each be 1 hour or less.
{: .home-service-offering-terms }

## Instead of...

If you're hesitating, consider the alternatives...

* **What's the impact of another month** with churn, with bounces on your site, with undecided visitors?
* **What if the overhaul you're considering** doesn't change a thing to your sales?
* **What if you were to put the same amout of money into ads**? Would you be better off on your goals?
* **What if you take some investment money**? You know they'll ask you to shorten your runway to be more bold and daring.

Instead of all this...

* You could **start conducting customer interviews** next week. I hope you do!
* You could **double down on applying Jobs-to-be-done theory** so you can have a predictive model of your buyer's deliberations.
* You could try **putting evidence on your landing page that you understand the buyer's struggle**. Make them say "I feel understood!"
* You could try changing your landing page copy to help **reduce anxieties, instead of adding appeal**.
* You could try **changing the words you use in customer interviews**, like asking retroactive questions that activate recall instead of asking for hypotheticals that activate creativity.

If you do any of this, I hope you'll tell me all about it. Just [drop me an<EMAIL_ADDRESS>to share.

Stay sharp!

{% include avatar.html %} Pascal Laliberté
[pascal<EMAIL_ADDRESS>
[@pascallaliberte][twitter]
Ottawa, Ontario, Canada

[twitter]: https://twitter.com/pascallaliberte

{% include email-sign-up-form.html context="home" %}

gha_language: SCSS


text:
# Nutanix Calm & Obtaining Info from External API

This Nutanix Calm blueprint will deploy a single VM and obtain information from an external API during deployment.

The intention of this blueprint is to allow quick demonstration of how eScript can be used to get information from an external/third-party API and apply that information during deployment.  For the purposes of this demo, the Prism Central v3 API has been used as the information source, although production versions of this script would use the relevant API for the service being accessed.

## Important Note

Ths blueprint should only be used in conjunction with the documentation provided by the Nutanix SE team.  Please contact your local rep for information on how to obtain this document.

## Components

- 1x CentOS 7 VM

## Prerequisites

To deploy this blueprint you will need the following things available.

- A CentOS 7 Linux VM image, published via the Nutanix Image Service

## Usage

- Import the blueprint into your Nutanix Calm environment
- Adjust credentials to suit your requirements (the import will warn about blueprint validation errors, since credentials are not saved in exported blueprints)
- Alter the blueprint service so that it deploys your CentOS 7 image
- Alter the new blueprint service so that it connects to your network
- Deploy the blueprint and pay special attention to the 3 required variables (Prism Central IP address, username and password)

## Support

These blueprints are *unofficial* and are not supported or maintained by Nutanix in any way.

In addition, please also be advised that these blueprints may deploy applications that do not follow best practices.  Please check through each blueprint to ensure the configuration suits your requirements.

***Changes will be required before these application blueprints can be used in production environments.***

repository: smandar-git/Automation

repo_name: smandar-git/Automation


text:
# vim-elixir

[![Build Status](https://travis-ci.org/elixir-lang/vim-elixir.svg?branch=master)](https://travis-ci.org/elixir-lang/vim-elixir)

[Elixir](http://elixir-lang.org) support for vim. This plugin also adds support
for Elixir's templating language, EEx.

Features included so far:

* Syntax highlighting for Elixir and EEx
* Filetype detection for `.ex`, `.exs` and `.eex` files
* Automatic indentation

## Installation

### Plugin managers

The most common plugin managers include [vim-plug][vim-plug],
[NeoBundle][neobundle], [Vundle][vundle] and [pathogen.vim][pathogen].

With pathogen.vim, just clone this repository inside `~/.vim/bundle`:

```bash
git clone https://github.com/elixir-lang/vim-elixir.git ~/.vim/bundle/vim-elixir
```

With the other plugin managers, just follow the instructions on the homepage of
each plugin. In general, you have to add a line to your `~/.vimrc`:

```viml
" vim-plug
Plug 'elixir-editors/vim-elixir'
" NeoBundle
NeoBundle 'elixir-editors/vim-elixir'
" Vundle
Plugin 'elixir-editors/vim-elixir'
```

### Manual installation

Run [./manual_install.sh](manual_install.sh) to copy the contents of each directory in the respective directories inside
`~/.vim`.

## Disabling `mix format` Integration

`mix format` integration is supported by setting `formatprg`. If you wish to opt-out of this (e.g. you're running a version prior to Elixir 1.6)
then you can do so by resetting this setting back to the default value in your `after` directory (e.g. `~/.vim/after/ftplugin/elixir.vim`):

```viml
setlocal formatprg=
```

## Development

To run the tests you can run `bundle exec rspec`

To spawn an interactive Vim instance with the configs from this repo use `bin/spawn_vim`

repository: jramnani/dotfiles

gha_language: Vim script

repo_name: jramnani/dotfiles


text:
---
name: Some Name
---
# Testsite

This is a introduction

## Some Second Heading

Heading | Another Heading
--- | ---
somevalue | somevalue
somevalue | somevalue
somevalue | somevalue
somevalue | somevalue
somevalue | somevalue

## Quick Demo
[![asciicast](https://asciinema.org/a/46djsde96ecsho9wqibjx2zye.png)](https://asciinema.org/a/46djsde96ecsho9wqibjx2zye?t=0)

## A link to a .md file
[test.md](./test.md)

## Usage

```javascript
let my = 'wow'
```

repository: pushrocks/quicksite

repo_name: pushrocks/quicksite


text:
!!! info
	This guide was submitted by a community member. Find something wrong? Submit a PR to get it fixed!

In a lot of ways, Home Assistant is why this project exists! Since Mealie has a robust API it makes it a great fit for interacting with Home Assistant and pulling information into your dashboard.

### Get Todays Meal in Lovelace
Starting in v0.4.1 you are now able to use the uri `/api/meal-plans/today/image?group_name=Home` to directly access the image to todays meal. This makes it incredibly easy to include the image into your Home Assistant Dashboard using the picture entity.

Here's an example where `sensor.mealie_todays_meal` is pulling in the meal-plan name and I'm using the url to get the image.

![api-extras-gif](../../assets/img/home-assistant-card.png)

```yaml
type: picture-entity
entity: sensor.mealie_todays_meal
name: Dinner Tonight
show_state: true
show_name: true
image: 'http://localhost:9000/api/meal-plans/today/image?group_name=Home'
style:
.: |
    ha-card {
    max-height: 300px !important;
    overflow: hidden;
    display: flex;
    align-items: center;
    justify-content: center;
    }
```

The sensor that gets the name of the meal can be achieved using the following REST sensor in Home Assistant
```yaml
sensor:
  - platform: rest
    resource: 'http://localhost:9000/api/meal-plans/today'
    method: GET
    name: Mealie todays meal
    headers:
      Authorization: Bearer MySuperSecretBearerCode
    value_template: "{{ value_json.name }}"
```
The Bearer token can be created from the User Settings page (https://hay-kot.github.io/mealie/documentation/users-groups/user-settings/#api-key-generation)

!!! tip
    Due to how Home Assistant works with images, I had to include the additional styling to get the images to not appear distorted. This includes and [additional installation](https://github.com/thomasloven/lovelace-card-mod) from HACS.

repository: dvdkon/mealie

repo_name: dvdkon/mealie


text:
# afl-utils Changelog

Version 1.33a

  - Added `--cmin-qemu`, `--tmin-qemu` options for QEMU mode support
    to afl-minimize (suggested by Isaac).
  - Made processing timeout for sample verification phase configurable
    in afl-collect.
  - Usage of python 3 virtualenv explicitly documented in README
    (Henri Salo).
  - Added quotes around sample filenames used in generated gdb script
    to keep gdb happy with fancy sample filenames.
  - Updated afl-collect to automatically detect exploitable.py location
    (contributed by Jurriaan Bremer).

Version 1.32a

  - SQLite db connector improved. Gives a huge afl-collect speed-up
    when using a database.
  - Changed afl-collect to print database related outputs only if
    a database is used.
  - Updated afl-stats to be compatible with afl-fuzz >= 2.32b (older
    afl versions will not work anymore).
  - afl-stats now optionally dumps fuzzer stats into a database.
  - Tweeting stats to twitter is now optional in afl-stats.
  - Fixed minor bug #34 in afl-multicore (reported by Bhargava Shastry).
  - Implemented option in afl-multicore to run arbitrary fuzzer instead
    of default afl-fuzz (#35, suggested by Bhargava Shastry).
  - Implemented multi-master mode support in afl-multicore (#36).
  - Bug affecting job counts in afl-multicore fixed (reported by Henri
    Salo).

Version 1.31a

  - Selective resumes added to afl-multicore.
  - Automatic calculation of delay values for afl-multicore startup
    implemented (use `-s auto`).
  - afl-multicore updated to not use a hard-coded path to the
    afl-fuzz binary.

Version 1.30a

  - Parsing of slightly different modified 'fuzzer_stats' file fixed
    in afl-stats.
  - Delayed startup added to afl-multicore.
  - Fixed a bug in afl-sync that caused some directories to not be pulled
    from the remote location when a session name was specified.
  - Added afl's .cur_input to the rsync exclude list in afl-sync.

Version 1.29a

  - afl-collect updated to not use a hard-coded path to the gdb binary
    (suggested by Martin Lindhe).
  - Fixed #30: CPU affinity settings removed from afl-multicore. (The
    option for explicitly setting CPU affinity in afl was dropped in
    afl-2.17b.)

Version 1.28a

  - afl-cron for periodic task execution added.
  - Main execution loop removed from afl-stats. afl-cron may be used for
    repeated executions of afl-stats!
  - Changed afl-utils to use JSON config files.

Version 1.27a

  - Basic version of afl-sync added.

Version 1.26a

  - afl-minimize now supports reseeding original afl queues with an optimized
    corpus.
  - Typo in test case setup method declaration fixed.
  - More test cases added.

Version 1.25a

  - Added CPU affinity option to afl-multicore.

Version 1.24a

  - afl-minimize now takes timeout and memory limit arguments that are passed
    to afl-cmin and afl-tmin.
  - Updated afl-collect to automatically detect whether operating on a single
    instance output directory or a multi instance synchronisation dir.
  - Fixed a minor bug in afl-collect that occurred when generating output sample
    names.
  - Scrots updated.

Version 1.23a

  - Minor bug-fixes for SampleIndex.
  - Updated afl-multicore to assure that newly created screen windows operate
    on the same directory afl-multicore was started from.
  - Bug fixed, that prevented use of afl -f file argument when running multiple
    afl instances. For this purpose '%%' was introduced to be used when
    referencing the desired file in the target's command line option (check
    README for details).
  - Refactored code to increase testability.
  - Remaining test cases completed and new tests were added.

Version 1.22a

  - Typo in afl-vcrash code fixed (by Emanuele Cozzi).
  - Added flag for configurable sample processing timeouts for afl-vcrash (by
    Emanuele Cozzi).
  - More tests added.

Version 1.21a

  - Ineffective subprocess timeout during crash verification fixed for afl-collect
    and afl-vcrash.
  - Added timeout handling to afl-collect, afl-minimize and afl-vcrash to avoid
    infinite/excessive blocking during sample processing.
  - Unreliable check_screen() fixed in afl-multicore.
  - Added a few test cases for afl-multicore.

Version 1.20a

  - afl-multicore docs updated to reflect latest changes (by Mark Janssen).
  - Fixed afl-multicore session check bug, that prevented adding additional
    afl instances in normal mode (spotted by Mark Janssen).
  - afl-multicore now properly updates its session file when adding additional
    instances. afl-multikill was adapted accordingly.
  - Simple interactive test mode added to afl-multicore.

Version 1.19a

  - afl-multicore revamped. Create config file for your target and desired afl
    options. Easily start and resume configured fuzzer instances. New feature:
    Subsequently add new instances using the 'add' command.
  - afl-multikill updated to terminate fuzzing sessions by process group id
    instead of individual PIDs and using SIGTERM instead of SIGKILL (by Mark
    Janssen).
  - Auto-installation of my hacked version of exploitable added (make sure to
    source exploitable.py as indicated during setup!).

Version 1.18a

  - Bug fixed that caused afl-stats to crash when monitoring more than one fuzzer
    output directory.
  - Added option to afl-collect that simplifies crash sample file names keeping only
    the originating fuzzer name and sample ID (by Martin Gallo).

Version 1.17a

  - afl-minimize will skip file collection if collection dir exists and is not empty.
    This way you can run the automated afl-cmin and afl-tmin invocations directly on
    any directory containing fuzzing samples.
  - All tools' outputs have been colorized.
  - https://github.com/rc0r/exploitable has been updated to avoid crashing when
    multiple inferiors have been detected. Instead an UNKNOWN classification with
    an according message is generated. Be sure to update exploitable to increase
    afl-collect stability!

Version 1.16a

  - afl-stat shows diffs of current and last stat.
  - afl-stat auto-shortens statuses to 140 chars.
  - afl-stat interval configuration setting is now a float. Thus polling
    intervals of less than one minute can be configured.

Version 1.15a

  - User comment field added in Data table of afl-collect crash database. Update
    your existing databases accordingly!
  - Added afl-stats for status printing and tweeting.

Version 1.14a

  - Path handling in afl-multicore improved.
  - Uninitialized variable bugs fixed in afl-collect.
  - afl-minimize now supports parallel afl-tmin invocation.

Version 1.13a

  - Added multi-threaded dry-runs in afl-minimize.

Version 1.12a

  - Target command path handling in afl-vcrash fixed.
  - Handling non-UTF-8 characters in afl-collect fixed (by Mark Janssen).
  - Incremental mode added to afl-collect: When afl-collect is pointed to an existing database,
    afl-collect will now skip samples having an entry in the database. This should be useful
    subsequent afl-collect runs on huge crash dirs.

## Old Releases

Release | Description
:-------:|----
1.11a | Minor bug-fix in afl-multicore, some explanations for afl-minimize added to README.md
1.10a | afl-minimize added, bug fixed in AflThread.py
1.09a | Docs refactored, target command path handling improved, bug-fix in afl-collect when collecting crashes without further processing
1.08a | `setup.py` added, tools names refactored to comply with afl naming scheme
1.07a | Minor afl-collect and afl-multikill bugs fixed. afl-collect will keep/collect crashes classified as 'UNKNOWN'
1.06a | Added flag `--afl-args` to afl-multicore to set custom afl command line options
1.05a | Added flag `--env-vars` to afl-multicore to set environment variables in all windows when using interactive screen mode
1.04a | Multi-threaded gdb script execution added
1.03a | Parallel sample verification support added to afl-vcrash
1.02a | Optimizations for afl-collect to reduce/eliminate file cp/rm operations
1.01a | De-duplication via exploitable backtrace hashes added to afl-collect
1.00a | stdin support added to afl-vcrash and afl-collect
0.23a | afl-multikill added
0.22a | Screen mode added to afl-multicore
0.21a | Initial version of afl-multicore added
0.20a | Sample collection from all `crashes*` sub directories added, minor bug fix for sample cleanup
0.19a | Added auto-cleanup feature for samples leading to uninteresting crashes
0.18a | Fixed gdb+exploitable script interruptions that occur on graceful exits of the target binary
0.17a | Basic SQLite3 database support added
0.16a | Minor bug fix for gdb+exploitable script generation
0.15a | Code refactoring, minor bug fixes
0.14a | gdb+exploitable script execution and output parsing added for easy crash classification
0.13a | Auto-cleanup of invalid crash samples added
0.12a | gdb+exploitable script generation added
0.11a | Crash sample file list creation added, afl-vcrash added
0.10a | Initial release, just collect crash sample files

repository: DeadManINDIA/fexm

repo_name: DeadManINDIA/fexm


text:
TwitterApi
==========

Simple Twitter API using OAuth 1.1, in PHP.

#Installation using Composer

Add the following line into the require section of your composer.json:
```json
  "require": {
    "maalls/TwitterApi": "~1.0"
  }
```
Then run the following command line:
```bash
$composer update
```

#Examples
```php
use Maalls\TwitterApi;

// A get request.
$api = new TwitterApi($access_token, $access_token_secret, $consumer_key, $consumer_secret);
$json = $api->get('search/tweets', array('q' => "github"));

// A post request.
$json = $api->>post("statuses/update", array("status" => "I love coding."));

// iterate() works for actions that returns an array of tweets: it collects all the tweets available by making several HTTP request and adjusting max_id parameters.
// see https://dev.twitter.com/rest/public/timelines
$json = $api->iterate('twitter/search', array('q' => 'githun'));
```

The class also collect the HTTP response header into an array, this is useful because it includes rate limit information:
```php
var_dump($api->header);

array(17) {
  [...]
  'x-rate-limit-limit' =>
  string(3) "180"
  'x-rate-limit-remaining' =>
  string(3) "179"
  'x-rate-limit-reset' =>
  string(10) "1416472112"
  [...]
}
```

repository: maalls/TwitterApi

repo_name: maalls/TwitterApi


text:
# LifeScope Browser Extension

This browser extension allows you to make LifeScope Events and Content from your browsing history.
Once installed, you can add domains that you want LifeScope to track to a Whitelist.
If the browser supports the history API, the extension will automatically parse your history on the whitelisted domains and create Events for each time you visited those pages.
It will also record any future visits to pages under those domains.

# Supported Browsers

Currently, the extension has been built and tested for:

* Chrome
* Firefox

We are planning to include support for other browsers in the future.

# Building the extension

Since each browser handles extensions differently, there are separate build commands for each.
Run

`npm run build:<browser>`

to build the extension for that browser. The files will be placed in /dist/<browser>.

The current valid build commands are:

* `npm run build:chrome`
* `npm run build:firefox`

These commands will place the built files in dist/<browser>.

To zip up the files for submission to extension/add-on stores, run

`gulp bundle:<browser>`

e.g.

* `gulp bundle:chrome`
* `gulp bundle:firefox`

This command will place the .zip file in dist/

gha_language: JavaScript


text:
# WebVisauls

In this assignment, an interactive dashboard to explore the Belly Button Biodiversity dataset is built, which catalogs the microbes that colonize human navels.

The dataset reveals that a small handful of microbial species (also called operational taxonomic units, or OTUs, in the study) were present in more than 70% of people, while the rest were relatively rare.

D3 library is used to read in samples.json datafile (provided).

A horizontal bar chart with a dropdown menu is created that displays the top 10 OTUs found in selected samples.

A bubble chart is created that displays information of each individual sample.

Demographics column is created to display the sample metadata for selected samples (individual's demographic information).

A Gauge Chart is created to plot weekly washing frequency of the individual sample.

Updates are added for each the plots when a new sample is selected.

The dashboard app is deployed to GitHub Pages.

About the Data
Hulcr, J. et al.(2012) A Jungle in There: Bacteria in Belly Buttons are Highly Diverse, but Predictable. Retrieved from: http://robdunnlab.com/projects/belly-button-biodiversity/results-and-data/

repository: tsubedy/WebVisauls

branch_name: refs/heads/main

repo_name: tsubedy/WebVisauls


text:
# Merge docs folder with other docs

This example shows how to merge a docs folder with other documentation.

## Configuration

mkdocs.yml

```yaml
{% include "examples/ok-mkdocs-docs-merge/mkdocs-test.yml" %}
```

Folder structure:

```
project
│   README.md
|   test.md
|
└───docs
|   |    draft.md
|   |    index.md
```

## Output

```
project
│   README.md
|   test.md
|
└───docs
|   |    draft.md
|   |    index.md
│
└───site
│   │   index.html  [From docs/index.md, _not_ from README]
|   |
|   └───draft
│   │   |    index.html
|   |
|   └───test
│   │   |    index.html
```

repository: macneib/mkdocs-simple-plugin

repo_name: macneib/mkdocs-simple-plugin


text:
---
lang: en
title: 'Reserved binding keys'
keywords: LoopBack 4.0, LoopBack 4
toc_level: 1
sidebar: lb4_sidebar
permalink: /doc/en/lb4/Reserved-binding-keys.html
---

## Overview

When using [dependency injection](Dependency-injection.md) there are a few
things to keep in mind with regards to binding keys.

Different packages and components for LoopBack 4 may have some bindings already
defined. You can change the default behavior by overriding the default binding,
but you must ensure the interface of the new binding is the same as the default
(but behavior can be different).

It is recommended to use the CONSTANT defined for each binding key in it's
respective namespace. You can import a namespace and access the binding key in
your application as follows:

```js
import {BindingKeyNameSpace} from 'package-name';

app.bind(BindKeyNameSpace.KeyName).to('value');
```

Following is a list of links to the apidocs on the binding keys in use by
various `@loopback` packages:

{% include note.html title="Declaring new binding keys" content="
For component developers creating a new Binding, to avoid conflict with other
packages, it is recommended that the binding key start with the package name as
the prefix. Example: `@loopback/authentication` component uses the prefix
`authentication` for its binding keys.
" %}

-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>

repository: strongloop/loopback-labs

gha_language: TypeScript

repo_name: strongloop/loopback-labs


text:
# Building & Tests

## Building

Building BUGOUT browser requires [Node.js 6.2.x or later](https://nodejs.org/en/download/) and npm. First, clone the repo:

```
$ git clone https://github.com/Terkwood/BUGOUT
$ cd BUGOUT/browser
```

### Desktop version

Install the dependencies of the browser using npm:

```
$ npm install
```

browser uses webpack to bundle all files into one single file. For development use the following command to create bundles automatically while you edit files:

```
$ npm run watch
```

To build a minified version:

```
npm run build
```

This creates a `bundle.js` file. To run Sabaki, simply open `browser/index.html` in a modern web browser, preferably Chrome.

repository: Terkwood/BUGOUT

branch_name: refs/heads/unstable

gha_language: Rust

repo_name: Terkwood/BUGOUT


text:
# Torino

Nothing special, just my stylesheets library without any dependencies.

![Ford Torino](https://upload.wikimedia.org/wikipedia/commons/thumb/2/21/1971_Ford_Torino_GT_%2812259626886%29.jpg/1200px-1971_Ford_Torino_GT_%2812259626886%29.jpg)

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'torino'
```

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install torino

## Usage

Add this line to your application.css:

```css
*= require torino
```

### Examples

Menu

```slim
.menu
  .container
    ul
      li : a href='#page1' Page 1
      li : a href='#page2' Page 2
    ul.pull-right
      li = current_user.email
      li
        a [
          href=sessions_url
          data-method='DELETE'
          data-no-turbolink='true'
        ] Exit
```

## Development

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

To install this gem onto your local machine, run `bundle exec rake install`.
To release a new version, update the version number in `version.rb`,
and then run `bundle exec rake release`, which will create a git tag
for the version, push git commits and tags, and push the `.gem`
file to [rubygems.org](https://rubygems.org).

## Contributing

Bug reports and pull requests are welcome
on GitHub at https://github.com/blackchestnut/torino. This project is
intended to be a safe, welcoming space for collaboration, and contributors
are expected to adhere to the
[Contributor Covenant](http://contributor-covenant.org) code of conduct.

## License

The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

repository: blackchestnut/torino

repo_name: blackchestnut/torino


text:
# `Loading`

Passing a message into this component directly via the `children` prop has been deprecated - please use the `LoadingMessage` component instead.

## Example

```js
<LoadingMessage>LoadingMessage</LoadingMessage>
```

repository: carbon-design-system/ibm-security

branch_name: refs/heads/dev

repo_name: carbon-design-system/ibm-security


text:
---
layout: default
title: Test function
parent: Creating Validations
nav_order: 1
---

## Test function

```js
/**
 * @param value test value
 * @param field current field that is being tested
 * @param path full path to the field that is being tested
 * @param objUnderTest whole object that is being passed to the validate function
 */
export type Test<T extends TestResult> = (
  value: any,
  field: string,
  path: string,
  objUnderTest: any
) => T
```

Function to test the values coming from the object under validation.

```js
const { validate, validation } = require('validar')
//object to validate
const testObj = {
  profile: {
    name: 'Mike',
  },
}

const stringLengthTest = (value, field, path, objectUnderTest) => {
  // value -> 'Mike'
  // field -> 'name'
  // path -> 'profile.name'
  // objectUnderTest  -> reference to the testObj
  return typeof value === 'string' && value.length > 5
}

//assemble the validation object
const validationObject = {
  profile: {
    name: validation(stringLengthTest),
  },
}

const result = validate(validationObject, testObj)
```

function parameters:

- `value`: value to test
- `field`: name of the field that is under the test
- `path`: a path to the field under test. If the field is deeply nested full path could be something like `person.profile.email`
- `objUnderTest`: reference to the object that is currently being tested. Here you can access all other properties of the object (so in case you have a `city` field that you are currently testing, you can also look at the `country` field to determine if the `city` is valid).

Any function that accepts `value` as the first parameter and returns `boolean` or [expected object](#return-values) can be used.

## Async test function

Test function can be asynchronous, you just need to return a `promise` that will eventually be resolved to the `boolean` or object that conforms to the [expected object](#return-values) that can be returned from the function.

```js
const stringLengthTest = (value, field, path, objectUnderTest) => {
  return new Promise((resolve, reject) => {
    // resolve later - maybe query the DB...
    resolve(typeof value === 'string' && value.length > 5)
  })
}
```

**Do not `reject` the promise if the test is negative** (e.g length is less than 5) just resolve the promise with the value of `false`
Using `reject()` will bubble up and will have to be handled with the validator function `validateAsync().catch()`

When using asynchronous tests you should use `validateAsync()` function

```js
const { validate, validation } = require('validar')

//object to validate
const testObj = {
  profile: {
    name: 'Mike',
  },
}

const stringLengthTest = (value, field, path, objectUnderTest) => {
  // value -> 'Mike'
  // field -> 'name'
  // path -> 'profile.name'
  // objectUnderTest  -> reference to the testObj
  return new Promise((resolve, reject) => {
    // resolve later - maybe query the DB...
    resolve(typeof value === 'string' && value.length > 5)
  })
}

//assemble the validation object
const validationObject = {
  profile: {
    name: validation(stringLengthTest),
  },
}

const result = validateAsync(testObj, validationObject)
  .then(result => {
    console.log(result)
  })
  .catch(error => {
    //something went wrong during the validation, a promise has timed out
    // or some async test rejected the promise
  })
```

## Return values

```js
export type TestResult = boolean | TestPayload | Promise<boolean | TestPayload>

/**
 * Object that is optionally returned from the test function.
 *
 * @param valid true if test is successful
 * @param payload custom object with arbitrary data
 */
export interface TestPayload {
  readonly valid: boolean
  readonly payload?: any
}
```

Test function can return few different values

- `boolean`: `true` if the test is successful.
- Special object `TestPayload` with the following properties.
  - `valid`: `boolean` -> `true` if test is successful.
  - `payload`: an object that can have any arbitrary data added, and that object will be passed to the [`test message`](test-message) function in case that the test is unsuccessful (function returns `false` or `promise` resolves to `false`)

```js
const stringLengthTest = (value, field, path, objectUnderTest) => {
  const r = typeof value === 'string' && value.length > 5
  return {
    valid: r,
    payload: {
      whatever: 'whatever',
    },
  }
}
```

Async example:

```js
const stringLengthTest = (value, field, path, objectUnderTest) => {
  return new Promise((resolve, reject) => {
    const r = typeof value === 'string' && value.length > 5
    resolve({
      valid: r,
      payload: {
        propA: 'propA',
        propB: 'propB',
      },
    })
  })
}
```

Then if the test is a failure [`message`]('test-message') function will be called with the result of the test and the payload.

```js
// message function will only be called if the test is a failure
const message = (value,field,path,objUnderTest,payload)=>{
    //value -> test value
    // payload -> {
            // propA:'propA',
            // propB:'propB'
        // }
    return 'Custom failure message'
    }
}
```

repository: ivandotv/validar

repo_name: ivandotv/validar


text:
# IO

## print(args...)

Print will print all args to standard output with NO space between them.

## println(args...)

Same as print() but will also output a newline after printing args.

## printenv()

For debugging. Prints the current symbol table as seen by the environment where
printenv() was called.

## readline([prompt: string]): string

readline() will read a line from standard input. If a string argument is given, it
will be printed before taking input. Calling readline() with more than one argument
or with an argument that's not a string, will cause the interpreter to error.

repository: jmptrader/nitrogen

repo_name: jmptrader/nitrogen


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

### Description

Hospital Management System v4.0 was discovered to contain a SQL injection vulnerability in /Hospital-Management-System-master/func.php via the email parameter.

### POC

#### Reference
- http://packetstormsecurity.com/files/165882/Hospital-Management-System-4.0-SQL-Injection.html
- https://github.com/kishan0725/Hospital-Management-System/issues/17
- https://github.com/nu11secur1ty/CVE-mitre/tree/main/2022/CVE-2022-24263

#### Github
- https://github.com/ARPSyndicate/cvemon
- https://github.com/Enes4xd/Enes4xd
- https://github.com/Nguyen-Trung-Kien/CVE-1
- https://github.com/Offensive-Penetration-Security/OPSEC-Hall-of-fame
- https://github.com/cr0ss2018/cr0ss2018
- https://github.com/ezelnur6327/Enes4xd
- https://github.com/ezelnur6327/enesamaafkolan
- https://github.com/ezelnur6327/ezelnur6327
- https://github.com/nu11secur1ty/CVE-mitre
- https://github.com/nu11secur1ty/CVE-nu11secur1ty
- https://github.com/oxf5/CVE
- https://github.com/superlink996/chunqiuyunjingbachang
- https://github.com/truonghuuphuc/CVE

repository: trickest/cve

repo_name: trickest/cve


text:
---
author: makumbe
comments: true
date: 2015-04-28 08:36:18+00:00
layout: post
link: http://blog.daanalytics.nl/2015/04/28/oracle-business-intelligence-cloud-service-data-sync-is-out-on-otn/
slug: oracle-business-intelligence-cloud-service-data-sync-is-out-on-otn
title: Oracle Business Intelligence Cloud Service Data Sync is out on OTN
wordpress_id: 1901
categories:
- Oracle BI Cloud Service
tags:
- A-Team
- BICS
- Data Load
- OTN
---

A typical Oracle BI Cloud Service (BICS) flow looks like the following:

  * Load your data to the Cloud

  * Model and Secure your data

  * Author Analyzes,Visualizations and Interactive Dashboards

  * Use and Share BICS content

In the current version of BICS you have to upload your data into the Cloud. There are several ways to load the data:

  * [BICS Data Loader](http://www.oracle.com/webfolder/technetwork/tutorials/obe/cloud/bics/DataLoader/dataloader.html)

  * REST API

  * [SQL Developer](http://www.oracle.com/webfolder/technetwork/tutorials/obe/cloud/bics/MigratingData/migrate_data.html)

  * PL/SQL Data Import

  * BICS Data Sync

The BICS Data Sync is a client utility to schedule and load data into the Cloud. If you are familiar with the Informatica version of Oracle BI Applications, you will see the similarities between BICS Data Sync and the DAC. BICS Data Sync has become GA on [OTN](http://www.oracle.com/technetwork/middleware/bicloud/downloads/index.html) recently.

For more details about BICS Data Sync check the following:

  * [BICS Data Sync getting started guide](http://www.oracle.com/technetwork/topics/virtualization/whatsnew/bicsdatasync-gs-v1-2525282.pdf)

  * [BICS Data Sync documentation](http://www.oracle.com/technetwork/topics/virtualization/whatsnew/bicsdatasync-doc-v1-2525284.pdf)

  * [Configuring the Data Sync Tool for BI Cloud Service (BICS)](http://www.ateam-oracle.com/configuring-the-data-sync-tool-for-bi-cloud-service-bics/)

In the first BICS version the only database option for BICS was the Oracle Schema-as-a-Service. This had its limitations. Oracle recently release the option to run BICS on a Oracle Database-as-a-Service. Check [here](https://cloud.oracle.com/database) for the differences between the two. One of the benefits of the Database-as-a-Service option that you can use any ETL tool to load data into the Cloud. Consider the BICS Data Sync option as a light option for ETL to the Cloud.

extension: markdown


text:
# weather-dashboard
A scheduling web application for keeping track of events throughout the day

Brian Palay

612-202-5710

<EMAIL_ADDRESS>
See the project live here:
https://bpplaysguitar.github.io/weather-dashboard/

![GitHub code size](https://img.shields.io/github/languages/code-size/bpplaysguitar/weather-dashboard?color=FF0000&logo=GitHub&logoColor=FF0000&style=for-the-badge)

![GitHub top language](https://img.shields.io/github/languages/top/bpplaysguitar/weather-dashboard?color=FF7F00&logo=GitHub&logoColor=FF7F00&style=for-the-badge)

![GitHub repo size](https://img.shields.io/github/repo-size/bpplaysguitar/weather-dashboard?color=FFFF00&logo=GitHub&logoColor=FFFF00&style=for-the-badge)

![GitHub followers](https://img.shields.io/github/followers/bpplaysguitar?color=00FF00&logo=GitHub&logoColor=00FF00&style=for-the-badge)

![GitHub language count](https://img.shields.io/github/languages/count/bpplaysguitar/weather-dashboard?color=0000FF&logo=GitHub&logoColor=0000FF&style=for-the-badge)

![GitHub license](https://img.shields.io/github/license/bpplaysguitar/weather-dashboard?color=2E2B5F&logo=GitHub&logoColor=2E2B5F&style=for-the-badge)

![GitHub repo stars](https://img.shields.io/github/stars/bpplaysguitar/weather-dashboard?color=8B00FF&logo=GitHub&logoColor=8B00FF&style=for-the-badge)

## Description
This web app assignemnt was a fun way to get acquainted with fetching data objects from APIs and using that data in useful and interesting ways. It provided me with some practice using if statements, for loops, and arrays as well. I liked building it, and I can definitely use the skills I've taken from this, in a group project which is currently in progress.

## Technologies Used
HTML
CSS
JavaScript
Local Storage
Luxon

## Installation

1. Provided that you have a code editor of your choosing installed on your system, such as VS Code (https://code.visualstudio.com/),

2. Provided that you have a Terminal installed for Windows (https://www.microsoft.com/en-us/p/windows-terminal/9n0dx20hk701?rtc=1&activetab=pivot:overviewtab) or are using a Mac with Terminal installed with the OS,

3. You have Git and Github Desktop installed (https://git-scm.com/downloads, https://desktop.github.com/) and have registered for an account,

4. Clone this repository:
git clone https://github.com/bpplaysguitar/weather-dashboard.git,

5. Create your own repository for the files on GitHub.

6. Edit in your code editor and continue to commit, push changes and perform other Git actions using your repository https://docs.gitlab.com/ee/gitlab-basics/start-using-git.html.

## Usage

Screenshot image of the project web page

![](assets/images/weather-gif.gif)

## Credits

Professional README guide template provided by Coding Boot Camp. https://github.com/coding-boot-camp

## License

MIT License

Copyright (c) 2021 Brian Palay

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

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

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

repository: bpplaysguitar/weather-dashboard

repo_name: bpplaysguitar/weather-dashboard


text:
[![Build Status](https://github.com/GentenStudios/Phoenix/workflows/C++%20CI/badge.svg)](https://github.com/GentenStudios/Phoenix/actions)
# GENTEN STUDIOS: PROJECT PHOENIX
## Introduction
Project Phoenix is an open world sandbox style voxel game with a twist. The program itself does not provide any content but gets that content entirely from modules written in Lua. An easy to use Lua API provides the capability to define all of the games content in addition to some functional features. This allows content to be quickly created by someone with little to no programming experience while still retaining the power of C++.

More information on this project and its mission can be found [here](https://docs.google.com/document/d/1vwmE24GTWhpxHRwjLutI63bD4uRy_4bxJ21YoKZWDv8).

## Community
[Here's a link to our public discord server](https://discord.gg/XRttqAm), where we collaborate and discuss the development of Phoenix.
[Here's a link to our community guidelines](./CODE_OF_CONDUCT.md)

## Dependencies
- CMake (Version >= 3.0)
- A C++17 compatible compiler. The following have been tested
  - Visual Studio 2017 & 2019 (MSVC >= 19.14)
  - Clang (>= 8)
  - GCC (>= 8)
- OpenGL (Version >= 3.3)

## Build Instructions
Clone with the `--recursive` flag to also clone all submodules
If you already cloned you can run `git submodule update --init` to do the same thing on an existing clone

Once cloned, navigate to the projects root directory and execute the following commands in a terminal.

  1. `cmake -H. -BBuild`
  2. `cmake --build Build`

Now follow the platform specific instructions detailed below.

### Visual Studio
  - Open the generated solution file in the `Build/` folder in Visual Studio
  - Set the Startup Project to `PhoenixClient`.
  - At this point you should be able to run, since the project should have already been
    built in step 2. above. You can always build the traditional way with Visual Studio.
  - And voila, all done. Now you should be able to run the project!

### Linux, Mac OS X, MSYS

  - Navigate to the `Build/Phoenix/PhoenixClient` folder and run `./PhoenixClient` to run the executable.

## Contributing
We encourage everyone to contribute, this is an open source project that will ultimately be powered by its community. If you are interested in contributing check out [our contributing guidelines](./CONTRIBUTING.md) for information on how we work and our coding standards. Before you get started, reach out on #programming on discord to collaborate so you aren't duplicating any work. Finally check out [Our issues on GitHub](https://github.com/GentenStudios/Phoenix/issues) for a list of what we currently have planned/ need help with.

branch_name: refs/heads/develop


text:
# dlevel
Get any level of subdomain from ```1....N```
## Install

```bash
go get -u github.com/MPaandeey/dlevel
```
## Usage Example
```
📄 files.txt
hackerone.com
info.hackerone.com
managed.hackerone.com
forwarding.hackerone.com
a.ns.hackerone.com
b.ns.hackerone.com

▶ cat files.txt | dlevel 2
ns.hackerone.com
info.hackerone.com
managed.hackerone.com
forwarding.hackerone.com

▶ cat files.txt | dlevel 3
a.ns.hackerone.com
b.ns.hackerone.com

```
## Credits
Inspired by [0xdln1](https://github.com/0xdln1/getlevels) and [tomnomnom](https://github.com/tomnomnom/anew) code for help to remove duplicates .

repository: slooppe/dlevel

repo_name: slooppe/dlevel


text:
Lesson Setup
============

As we will be using `make` as a tool for creating data pipelines, we should start
by creating some data input files.

We will be generating CSV files from statistics on your computer. The end result
will be that everyone in the room will have a slightly different set of statistics.

### Step 1: Download Dependencies

To begin, open the shell and install the `psutil` module. It is a cross-portable
way of gathering system statistics.

    pip install psutil

### Step 2: Generate Statistics

You are now able to run `generate_stats.py`. That script will create a CSV file –
named `systemstats.csv` by default – with a report on CPU usage, available memory,
and network traffic.

    python generate_stats.py --duration 120

All going well, you will see a stream of numbers beginning to scroll across your screen.
This should give us nice time series data that `make` will be able to process for us.

repository: timClicks/make-for-data

gha_language: Python

repo_name: timClicks/make-for-data


text:
        <img width="20%" src="/logo.png" alt="pysat" title="pysat"

# pysat: Python Satellite Data Analysis Toolkit
[![Build Status](https://travis-ci.org/pysat/pysat.svg?branch=master)](https://travis-ci.org/pysat/pysat)
[![Documentation Status](https://readthedocs.org/projects/pysat/badge/?version=latest)](http://pysat.readthedocs.io/en/latest/?badge=latest)
[![Coverage Status](https://coveralls.io/repos/github/pysat/pysat/badge.svg?branch=master)](https://coveralls.io/github/pysat/pysat?branch=master)
[![DOI](https://zenodo.org/badge/33449914.svg)](https://zenodo.org/badge/latestdoi/33449914)

The Python Satellite Data Analysis Toolkit (pysat) is a package providing a simple and flexible interface
for downloading, loading, cleaning, managing, processing, and analyzing scientific
measurements. Although pysat was initially designed for in situ satellite observations, it now supports many different types of ground- and space-based measurements.

Full [Documentation](http://pysat.readthedocs.io/en/latest/index.html)

JGR-Space Physics [Publication](https://doi.org/10.1029/2018JA025297)

[Citation Info](https://pysat.readthedocs.io/en/latest/citing.html)

# Main Features
* Instrument independent analysis routines.
* Instrument object providing an interface for downloading and analyzing a wide variety of science data sets.
  * Uses pandas or xarray for the underlying data structure;
  capable of handling the many forms scientific measurements take in a consistent manner.
  * Standard scientific data handling tasks (e.g., identifying, downloading,
  and loading files and cleaning and modifying data) are built into the
  Instrument object.
  * Supports metadata consistent with the netCDF CF-1.6 standard. Each variable
  has a name, long name, and units. Note units are informational only.
* Simplifies data management
  * Iterator support for loading data by day/file/orbit, independent of data storage details.
  * Orbits are calculated on the fly from loaded data and span day breaks.
  * Iterate over custom seasons
* Supports rigorous time-series calculations that require spin up/down time across day, orbit, and file breaks.
* Includes helper functions to reduce the barrier in adding new science instruments to pysat

# Installation
## Starting from scratch
* One simple way to get a complete science python package is from [enthought](https://store.enthought.com)
* at command line type
```
pip install pysat
```
* in python, run pysat.utils.set_data_dir('path to top level data dir')
  * Nominal organization of data is top_dir/platform/name/tag/*/files
* netCDF support
  * netCDF3 is supported by SciPy, no other libraries needed
  * Download and install python interface to netCDF using
  ```
  pip install netCDF4
  ```

repository: JonathonMSmith/pysat

repo_name: JonathonMSmith/pysat


text:
# Frequent Question and Answer

### 1. What is RoomAI ?

RoomAI is a toolkit for developing and comparing AI-bots of imperfect information games.
Now RoomAI provides Bridge, Kuhn Poker, FiveCardStud, Mahjong, SevenKing and Texas. DouDiZhu and Three are in developing.

Besides imperfect information games, we provides some baseline AI-bots of different games in RoomAI.

### 2. What is the chance player ?

There are some random events in the games. For example, the initialized hand cards in players are due to "Nature". The extensive form game adds "Nature" as a player, who decides the samples of these random events. In general, the probability of these random events is the uniform distribution.
 We call the "Nature" player as the chance player.