text:
# Xtern Data Science Screen

The problem:

"While osXtern has a few highlighted features, the data science team is focusing all of its efforts on expanding osXte
rn’s feature set. As part of the Community Highlights feature, users agree to share their location with TechPointX and
any individuals they choose. In future iterations, TechPointX hopes that the Community Highlights data could be used to
do more.

In order to help identify what type of information could be surfaced in future iterations, you have been tasked with
reviewing the the sample data collected from recent user tests. In your research, highlight any conclusions you believe
the data can draw to help guide future development opportunities.

Your Task:

Review the test user data, and draw any conclusions you can from the data set. Your research and conclusions should be
submitted as a link to a github repository. It is encouraged that your repository hosts a Jupyter (formerly iPython)
notebook."

So, I wasn't sure quite what I supposed to do here, since:

    a) I don't know what kind of features the OS would want to focus on

    b) The location coordinates are not real

    c) There's not much data to work with anyways

Regardless I thought of two ways the data could still influence features:

    1) looking at what days people are most active

    2) looking at what locations each person is at the most

These are the conclusions I reached:

    a) There aren't any days which stand out to be more active than the others, so there's not really a feature I
       could propose based on that.

    b) Some users look like they tend to move around a lot more than others -- you can tell because their most common
       location coordinates are in the single digits. Vice versa applies to users who tend to be more stationary.
       Perhaps a feature could be developed on the OS that caters to how active or inactive a user is based on their
       common coordinate appearances.

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
---
layout: layout.pug
navigationTitle:
excerpt:
title: Limitations
menuWeight: 100
---
{% assign data = site.data.services.hdfs %}

{% include services/limitations.md data=data %}

## Zones

DC/OS Zones allow the service to implement rack-awareness. When the service is deployed with some zone configuration (or lack thereof), it cannot be upgraded/downgraded to another zone configuration.

<!-- TBD? ## Security

### Transport Encryption

### Kerberos -->

repository: portworx/dcos-commons

gha_language: Java

repo_name: portworx/dcos-commons


text:
# Server architecture at the Arne Elofsson Lab

# Hardware

## Servers at SciLifeLab

### vault.bioinfo.se
RAID (file raid 10 Tb). File system is full. Users have had the possibility to copy backups there (manually with scp or rsync).

### pcons1.scilifelab.se

4 cores 16 GiB RAM

cpubenchmark.net E3-1240 v3 = 9704
```
[eriksjolund@pcons1 ~]$ date
mån jun  5 14:51:50 CEST 2017
[eriksjolund@pcons1 ~]$ free -g
             total       used       free     shared    buffers     cached
Mem:            15         14          1          0          6          1
-/+ buffers/cache:          6          8
Swap:            7          0          7
[eriksjolund@pcons1 ~]$ cat /proc/cpuinfo |grep "model name" | head -1
model name	    : Intel(R) Xeon(R) CPU E3-1240 v3 @ 3.40GHz
[eriksjolund@pcons1 ~]$ cat /proc/cpuinfo |grep "model name" | wc -l
8
[eriksjolund@pcons1 ~]$ df -h
Filesystem            Size  Used Avail Use% Mounted on
/dev/mapper/vg_pcons1-lv_root
                       50G   21G   26G  45% /
tmpfs                 7,8G     0  7,8G   0% /dev/shm
/dev/mapper/vg_pcons2-lv_big
                      2,7T  2,3T  314G  88% /big
/dev/sda1             477M  172M  280M  38% /boot
/dev/mapper/vg_pcons1-lv_home
                      172G  3,9G  160G   3% /home
AFS                   8,6G     0  8,6G   0% /afs
[eriksjolund@pcons1 ~]$
```

### pcons2.scilifelab.se
4 cores 16 GiB RAM

cpubenchmark.net E3-1240 v3 = 9704

```
[eriksjolund@pcons3 ~]$ date
mån jun  5 14:40:28 CEST 2017
[eriksjolund@pcons3 ~]$ cat /proc/cpuinfo |grep "model name"|wc -l
32
[eriksjolund@pcons3 ~]$ cat /proc/cpuinfo |grep "model name"|head -1
model name	    : Intel(R) Xeon(R) CPU E5-2630 v3 @ 2.40GHz
[eriksjolund@pcons3 ~]$ free -g
             total       used       free     shared    buffers     cached
Mem:           315         37        277          0         19          2
-/+ buffers/cache:         15        299
Swap:           49          0         49
[eriksjolund@pcons3 ~]$ df -h
Filesystem            Size  Used Avail Use% Mounted on
/dev/mapper/vg_pcons3-lv_root
                       50G  5,9G   41G  13% /
tmpfs                 158G     0  158G   0% /dev/shm
/dev/sda2             976M  115M  810M  13% /boot
/dev/sdb2             976M  115M  810M  13% /boot2
/dev/sdc2             976M  115M  810M  13% /boot3
/dev/sda1             127M  256K  127M   1% /boot/efi
/dev/sdb1             127M  256K  127M   1% /boot2/efi
/dev/sdc1             127M  256K  127M   1% /boot3/efi
/dev/mapper/vg_pcons3-lv_home
                      148G  1,4G  139G   1% /home
/dev/mapper/vg_pcons3-lv_big
                      5,1T  1,5T  3,3T  32% /big
AFS                   2,0T     0  2,0T   0% /afs
[eriksjolund@pcons3 ~]$
```

### pcons3.scilifelab.se
32 cores  315 GiB RAM       (is not used right now)
cpubenchmark.net E5-2630 = 8906

```
[eriksjolund@pcons2 ~]$ date
mån jun  5 14:46:05 CEST 2017
[eriksjolund@pcons2 ~]$ free -g
             total       used       free     shared    buffers     cached
Mem:            15         15          0          0          0         13
-/+ buffers/cache:          1         13
Swap:           15          2         13
[eriksjolund@pcons2 ~]$ cat /proc/cpuinfo |grep "model name"|head -1
model name	    : Intel(R) Xeon(R) CPU E3-1240 v3 @ 3.40GHz
[eriksjolund@pcons2 ~]$ cat /proc/cpuinfo |grep "model name"|wc -l
8
[eriksjolund@pcons2 ~]$ df -h
Filesystem            Size  Used Avail Use% Mounted on
/dev/mapper/vg_pcons2-lv_root
                       50G  5,3G   42G  12% /
tmpfs                 7,8G     0  7,8G   0% /dev/shm
/dev/mapper/vg_pcons2-lv_big
                      2,5T  1,3T  1,2T  53% /big
/dev/md0              477M  105M  347M  24% /boot
/dev/mapper/vg_pcons2-lv_home
                      148G  271M  140G   1% /home
[eriksjolund@pcons2 ~]$
```

### EGI cluster
Right now 100 CPU cores from EGI are used (https://www.egi.eu) but Arne Elofsson's EGI project will expire December 31 2017.
The compute nodes have been allocated through an OpenStack API.

# Online web services

The online web services

- http://topcons.net/
- http://subcons.bioinfo.se/
- http://c3.pcons.net/
- http://c.pcons.net/
- http://pcons.net/
- http://proq3.bioinfo.se/
- http://boctopus.bioinfo.se/
- http://prodres.bioinfo.se/

are all running on the pcons1 frontend.

## Disk usage

topcons makes use of 450 Gb disk space.
A number of the other web services makes use of 100 Gb each.

## Architectural overview

1. Do a short search (about 1 minute)
2. If not found, do long search (about 1 core hour)

pcons3 does cache lookup. Has this sequence been run before?
If it is a short sequence, run on pcons3.

If job is too big, then put in queue.

## Possible improvements to the backend

- boctopus.bioinfo.se
- prodress.bioinfo.se
- topcons.net

all share some common backend functionality. The backend should not duplicated as it is right now.

# TODO

- Nanjiang moves prodres to cloud
- Erik Sj installs Centos7 on pcons3 (or SciLife IT)
- Erik Sj tries to install common backend (e.g. topcons)
- Change to cloud for pcons
- Change queueing system.  (Nanjiang suggested RabbitMQ)

gha_language: Python

gha_license_id: MIT


text:
We are grateful for the support of [Translatewiki](https://translatewiki.net/w/i.php?title=Special:Translate&group=oppia-android-app&filter=%21translated&action=translate) in contributing internationalized platform strings for the Oppia Android app! (Note that Translatewiki only provides support for translations of platform UI strings; content string translations are handled via the Contributor Dashboard on the Oppia.org website.)

## Table of Contents

- [Helping out with translations](#helping-out-with-translations)
- [Minimal set of topics](#minimal-set-of-topics)
- [Policy for enabling new languages](#policy-for-enabling-new-languages)
- [Procedure for enabling new languages](#procedure-for-enabling-new-languages)
  - [To enable a new language in Translatewiki](#to-enable-a-new-language-in-translatewiki)
  - [To enable a new language in the Android app](#to-enable-a-new-language-in-the-android-app)

## Helping out with translations

If you would like to help out with translations, you can do so by visiting the [Translatewiki dashboard](https://translatewiki.net/w/i.php?title=Special:Translate&group=oppia-android-app&filter=%21translated&action=translate) and picking a supported language from the dropdown menu on the right.

## Minimal set of topics

In addition to platform translations, we need the Oppia lessons themselves to be sufficiently translated before we can offer the app in a given language.

Currently, we define "sufficiently translated" to mean that the **minimal set** of topics are fully translated. This minimal set covers 6 topics: Place Values, Addition and Subtraction, Multiplication, Division, Fractions and Ratios.

## Policy for enabling new languages

Note that we only enable a select set of languages for Translatewiki, since releasing the lessons on the Android app is gated by the lessons themselves needing to be translated (see above). Therefore, in order not to waste translators' efforts, the policy for enabling languages for translation on Translatewiki is as follows:

  - The translations for all topics in the [minimal set](https://github.com/oppia/oppia-android/wiki/Internationalization#minimal-set-of-topics) on Oppia.org should be complete, or very close to complete.

And the policy for enabling a language in the Android app is as follows:

  - The translations for all topics in the [minimal set](https://github.com/oppia/oppia-android/wiki/Internationalization#minimal-set-of-topics) on Oppia.org should be complete.
  - All oppia-android-app translations for that language are completed in Translatewiki.

## Procedure for enabling new languages

### To enable a new language in Translatewiki

Please do the following steps:

  1. Verify that translations for all lessons in the [minimal set](https://github.com/oppia/oppia-android/wiki/Internationalization#minimal-set-of-topics) on Oppia.org are complete (or very close to complete) in that language, by going to the Contributor Dashboard and checking that there are no (or very few) translations left to do.
  2. Contact Ben/Sean and ask them to add the language to the oppia-android-app project. (They will do this by contacting<EMAIL_ADDRESS>.)

### To enable a new language in the Android app

Please do the following steps:

  1. Verify that translations for all lessons in the [minimal set](https://github.com/oppia/oppia-android/wiki/Internationalization#minimal-set-of-topics) on Oppia.org are complete in that language, by going to the Contributor Dashboard and checking that there are no translations left to do.
  2. Verify that the translations on [Translatewiki](https://translatewiki.net/w/i.php?title=Special:Translate&group=oppia-android-app&filter=%21translated&action=translate) for the Oppia Android app are complete in that language.
  3. In consultation with Ben, make a PR adding support for that language ([here](https://github.com/oppia/oppia-android/pull/4307/files) is an example for Swahili).

repository: oppia/oppia-android

branch_name: refs/heads/develop

gha_language: Kotlin

repo_name: oppia/oppia-android


text:
# Onestep

Prevent users sending duplicate requests by rapidly clicking links and buttons.

## Installation

Add this line to your application's Gemfile:

    gem 'onestep'

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install onestep

Once you've installed the gem, require it's JavaScript assets:

    // app/assets/javascripts/application.js
    //= require onestep/onestep

## Usage

TODO: Write usage instructions here

## TODO:

 1. Write a Heroku hosted Sinatra application which demos the functionality.
 2. Link to the application from this Readme.
 3. Make sure that the gem works with <button> tags.
 4. Consider initializing the jQuery so that it works automatically. Then add
    a class the users can attach to optout.
 5. Specify that the assets must be required after jQuery. I might be able to
    add jquery_ujs as a dependancy?

## Contributing

1. Fork it
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create new Pull Request

repository: dtuite/onestep

repo_name: dtuite/onestep


text:
# Introduction
This is the 1st project of the course "Software Development for Algorithmic Problems". In this
project, we achieved the following:
1. implemented 2 differrent approaches to tackle the approximate nearest neighbour search
problem: **LSH** and **Hypercube Randomized Projection**
2. implemented the improved version of the well-known clustering algorithm k-Means, which is
called **k-Medians++**

The dataset used in the 2 tasks above was [MNIST](http://yann.lecun.com/exdb/mnist/). Each
handwritten digit image has a resolution of 28x28 pixels. Consequently, we store each image
as a "flattened" vector of size 784 (28 x 28 = 784). To calulate the distance between 2 points
in our datasets we used the manhattan distance

# Nearest Neighbour Search
Both methods mentioned above (LSH and Hypercube) work in a similar manner. The following
sequence of steps happens before the actual search process takes place:
1. program reads in the input dataset (or training set), which in our case consists of 60.000
images of handwritten digits (0 - 9).
2. then, the program builds the actual data structures that will be used in the search process.
All input dataset points are stored in these data structures
3. next, the program reads in the query set (or test set)
4. search starts: for each point in the query set find:
    1. its _N_ nearest neighbours approximately (Approximate k-NN)
    2. its _N_ nearest neighbours using brute-force search (Exact k-NN)
    3. its nearest neighbours approximately that lie inside a circle of radius _R_

Where these 2 methods differ, is how each one builds its appropriate data structures and chooses to store (hashing) the input dataset.
In general, The whole purpose of these 2 methods is to deliver an efficient -but approximate-
type search that significantly reduces search time compared to Exact k-NN, but it also produces
high accuracy results

# Clustering
Using the same dataset file as input, the goal of this program is to "group" as accurately as
possible the input datapoints into clusters. Ideally, the clusters produced by the program
should only contain images of the same handwritten digit (default numbers of clusters is 10) .
The (iterative) algorithm selects its initial centroids using an improved initialization
technique called [initialization++](https://en.wikipedia.org/wiki/K-means%2B%2B#Improved_initialization_algorithm), assigns points to their closest centroid using one of Lloyd's or LSH or
Hypercube assignment methods and uses the median update rule to update the centroids.
The algorithm stops, when the observed change in cluster assignments is relatively small. For
this purpose, the k-medians objective function (l1 norm) is calculated after each iteration.

# Execution
For the **LSH** method, run the following commands:
```
$ cd src/lsh
$ make
$ ./lsh -d ../../datasets/train-images-idx3-ubyte -q ../../datasets/t10k-images-idx3-ubyte
        -k <num_hash_functions> -L <num_hash_tables> -o <output_file>
        -N <num_of_nearest_neighbours> -R <radius>
```
For the **Hypercube** method, run the following commands:
```
$ cd src/cube
$ make
$ ./cube -d ../../datasets/train-images-idx3-ubyte -q ../../datasets/t10k-images-idx3-ubyte
         -k <projection_dimension> -M <max_candidates> -probes <max_probes> -o <output_file>
         -N <num_of_nearest_neighbours> -R <radius>
```
Both methods can also run without explicit command line arguments i.e by simply running
`$ ./lsh` or `$ ./cube` after of course navigating to the appropriate directory.
In this case, default argument values will be used.
The formatted output will be written to the output file specified by the user.
This is how it looks like:
```
Query: image_number_in_query_set
Nearest neighbor-1: image_number_in_dataset
distanceLSH: <int> [or distanceHypercube respectively]
distanceTrue: <int>
...
Nearest neighbor-N: image_number_in_dataset
distanceLSH: <int> [or distanceHypercube respectively]
distanceTrue: <int>
tLSH: <double>  [or tHypercube respectively]
tTrue: <double>
R-near neighbors:
image_number_A
image_number_B
. . .
image_number_Z
```

Finally, for **clustering**, run the following commands:
```
$ cd src/cluster
$ make
$ ./cluster -i ../../datasets/train-images-idx3-ubyte -c ../../include/cluster/cluster.conf
            -o <output_file> --complete <optional> -m <method: Classic or LSH or Hypercube>
```

The formatted output will be written to the output file specified by the user.
This is how it looks like:
```
Algorithm: Lloyds OR Range Search LSH OR Range Search Hypercube
CLUSTER-1 {size: <int>, centroid: array with the centroid's components}
...
CLUSTER-Κ {size: <int>, centroid: array with the centroid's components}
clustering_time: <double> //in seconds
Silhouette: [s1,...,si,...,sΚ, stotal]
// si=average s(p) of points in cluster i, stotal=average s(p) of points in dataset
// Optionally with command line parameter –complete
CLUSTER-1 {centroid, image_numberA, ..., image_numberX}
...
CLUSTER-Κ {centroid, image_numberR, ..., image_numberZ}
```

repository: themisvr/Vector-Clustering-Algorithms

branch_name: refs/heads/main

repo_name: themisvr/Vector-Clustering-Algorithms


text:
---
title: "A New Era at the Hardening Framework Project"
date:   2015-04-15 21:00:00
authors:
- name: Christoph Hartmann
  image: https://avatars3.githubusercontent.com/u/1178413?v=4
  link: https://lollyrock.com
---

# Next

We are happy to announce, that the Hardening Framework moved to its [new home](https://github.com/dev-sec). As a vendor neutral project we aim to provide best-practice system hardening for various industries. We are now actively searching for supporters to build up the next level of this project. [Get in touch with<EMAIL_ADDRESS>
# Retrospection

About a year ago the Hardening Framework has started as a small challenge to proof if server hardening can be done with configuration management tools like Puppet, Chef, SaltStack or Ansible. As a small team started to find the answer.

Since [Deutsche Telekom](http://www.telekom.com/) was the first sponsor of this open source project, it was natural to use their [internal security guidelines](http://www.telekom.com/static/-/155996/18/technische-sicherheitsanforderungen-si) as a starting point for our security rules. Besides their interest in security, Deutsche Telekom faced the challenge that the manual harding processes just doesn't scale in the cloud. Especially [T-Labs](http://www.laboratories.telekom.com/), [Telekom Business Marketplace](https://portal.telekomcloud.com/) and the [Telekom Security](https://www.telekom.com/security) as well as [T-Systems](http://www.t-systems.com/) had great interests to find an industry-wide open source solution.

From the very beginning, the project had a few goals:

- support for multiple configuration management tools
- should work with existing open source modules / cookbooks
- reuse the same test scripts
- tests are developed first and are our baseline for the hardening implementation
- Puppet and Chef implementations have to adapt to the common tests

Quickly, we decided for [Serverspec](http://serverspec.org/) as the best tool for our tests, because it fulfilled all our needs, had a grown community and worked very well with existing configuration management tools.

Once we decided for Serverspec tests, we focused on the actual hardening implementation. This was a difficult task, because we wanted to reuse official deployment mechanisms for e.g. PostgreSQL but still add our hardening. After some prototypes we decided for an `overlay module` which acts as a companion to the original modules. It ensures that everything is properly configured and specific hardening options are added.

We identified some of the widely used open source modules that require hardening for live deployment:

- Linux OS
- SSH
- Apache Webserver
- Nginx
- PostgreSQL
- MySQL

For every project we started an implementation for Puppet and Chef like e.g. `os-hardening`:

 * [https://github.com/dev-sec/chef-os-hardening](https://github.com/dev-sec/chef-os-hardening)
 * [https://github.com/dev-sec/puppet-os-hardening](https://github.com/dev-sec/puppet-os-hardening)

For both implementations of the `os-hardening` module, we use a common test environment. [It combines all tests under one framework](http://ehaselwanter.com/en/blog/2014/05/08/using-test-kitchen-with-puppet/). We used [test-kitchen](http://kitchen.ci/) for Puppet and Chef tests:

 * [https://github.com/dev-sec/tests-os-hardening](https://github.com/dev-sec/tests-os-hardening)

Next, we selected the supported Linux distributions for our first release:

- RedHat 6.4, 6.5
- Ubuntu 12.04, 14.04
- CentOS 6.4, 6.5
- Oracle Linux 6.4, 6.5
- Debian 7

As a small team, we were required to automated the tests, otherwise this would not be manageable. We used Travis for code linting and style checks and complement it with a Jenkins environment, that spins up all supported Linux Vms in OpenStack, deploys the hardening, and runs the Serverspec tests and finally sends a report back. Those test are triggered with every Github Commit.

To get the Hardening Framework up and running easily, we have documented examples for Puppet and Chef:

 * [https://github.com/dev-sec/example-puppet-hardening](https://github.com/dev-sec/example-puppet-hardening)
 * [https://github.com/dev-sec/example-chef-hardening](https://github.com/dev-sec/example-chef-hardening)

The project has evolved over the last year. It has become a mature tooling and is running on thousands of production systems. A special thanks to all contributors who helped to build this amazing project:

* [Andreas Schmidt](https://github.com/aschmidt75)
* [lollyrocker](https://github.com/lollyrocker)
* [Jan Klare](https://github.com/jklare)
* [Petri Sirkkala](https://github.com/sirkkalap)
* [Trent Petersen](https://github.com/Rockstar04)
* [Zac Hallett](https://github.com/zhallett)
* [Stephan Großberndt](https://github.com/sgrossberndt)
* [Reik Keutterling](https://github.com/spielkind)
* [Daniel Dreier](https://github.com/danieldreier)
* [Timo Goebel](https://github.com/timogoebel)
* [Tristan Helmich](https://github.com/fadenb)
* [Guillaume Destuynder](https://github.com/gdestuynder)
* [Alexander Dupuy](https://github.com/dupuy)
* [Dana Merrick](https://github.com/dmerrick)
* [Drew Rapenchuk](https://github.com/rapenchukd)
* [Kurt Huwig](https://github.com/kurthuwig)
* [Matthew Haughton](https://github.com/3flex)
* [Michael Krieg](https://github.com/michaelkrieg)
* [lighttower](https://github.com/lighttower)
* [Artem Sidorenko](https://github.com/artem-sidorenko)
* [Thomas Dütsch](https://github.com/a-tom)
* [Patrick Meier](https://github.com/atomic111)
* [Bernhard Weisshuhn (a.k.a. bernhorst)](https://github.com/bkw)
* [Christoph Hartmann](https://github.com/chris-rock)
* [Edmund Haselwanter](https://github.com/ehaselwanter)
* [Dominik Richter](https://github.com/arlimus)

Thank you very much! We are looking forward to continue working with you.

branch_name: refs/heads/src

gha_language: SCSS


text:
# openrasp-v8

![CI](https://github.com/baidu-security/openrasp-v8/workflows/CI/badge.svg)

Google V8 JavaScript engine with OpenRASP builtins, and bridges that are used to embed V8 within languages which are supported by [OpenRASP](https://github.com/baidu/openrasp).

Currently supported languages:

- PHP
- Java
- Go

## Features

### OpenRASP attack detect engine in JavaScript

Full JavaScript runtime context of OpenRASP attack detect engine, with simple C++ interfaces and helpers.

Integrating openrasp-v8 in other languages only need several lines.

### Lexical analyzer

Flex lexical analyzer is embeded in openrasp-v8 to tokenize sql and command strings. Just call `RASP.sql_tokenize` or `RASP.cmd_tokenize`

### HTTP request

The http request method is `RASP.request`. It accepts a configure object and returns a promise. Just like the axios.

### Platform independent

You can build and use it on different OS types, different OS versions and different OS archs.

For convenience of build, we have built some third-party libraries to static libraries:

- Linux x64
- Linux x86
- Linux musl
- OSX x64
- Windows x64
- Windows x86

For compatibility of Linux, most libraries will be staticly linked into openrasp-v8, even libc++. You can even use centos6 sysroot to force linker to link old version glibc.

### Support multiple languages

We will continuely add more languages to our support list.

The language support briges are not just some C++ ports, but also the language specified native interfaces. Such as jni fo Java and cgo for Go.

## Build

We use CMake to generate the files needed by your build tool (GNU make, Visual Studio, Ninja, etc.) for building openrasp-v8 and its language ports.

For example:

```shell
mkdir build
cd build
cmake -DENABLE_LANGUAGES=all ..
make
make test
```

The openrasp-v8 specified cmake variables:

- ENABLE_LANGUAGES

  Cmake list of languages to build, or all for building all (base, php, java, go)

- BUILD_TESTING

  Boolean option for whether the tests will be built

- BUILD_COVERAGE

  Boolean option for whether the coverage will be built


text:
# Prabhat Arts International - The Temple of Art | Academy of Dance & Theatre Art

## grayscale theme modified- "Prabhat-hugo-theme"

### Mobile first aproach, minimal design, focus on content

[![Netlify Status](https://api.netlify.com/api/v1/badges/f7f5d2b2-85c3-4858-a9c7-40bbd6e12a50/deploy-status)](https://app.netlify.com/sites/prabhath/deploys)

repository: TenSketch/Prabhat

gha_language: HTML

repo_name: TenSketch/Prabhat


text:
---
title: Sequential legend
---

The Sequential legend can represent sequential data mapped to a color range.

## Data and scales

The legend component doesn't take any [data](data.md) as input directly, instead the data is implicitly fetched from the referenced [scales](scales.md).

There are two required scales, a `fill` scale and a `major` scale. The `fill` scale represent the color range, via a sequential color scale, and `major` is the numerical representation, via a linear scale.

## Layout

The legend can be laid out in two directions, horizontal and vertical. The direction is dependent on the docking area, `top` and `bottom` are horizontal and `left` and `right` are vertical.

Horizontal layout:
![Horizontal layout](/img/legend-seq-h.png)

Vertical layout:
![Vertical layout](/img/legend-seq-v.png)

### Custom labels

Custom labels can be configured using a ticks function. The ticks function is evaluated for each tick (start and stop) and expects a string value to be returned.

```js
{
  type: 'legend-seq',
  settings: {
    fill: 'sequential-color-scale',
    major: 'linear-scale',
    tick: {
      label: (tickValue, index) => {
        const temp = ['Hot', 'Cold'];
        return temp[index % 2];
      },
    }
  }
}
```

![Custom labels](/img/legend-seq-custom-ticks.png)

## Formatting

Label formatting is derived from the `major` scale and the data itself. But as with any component, it is possible to reference a [custom formatter](formatters.md) using the `formatter` property.

```js
{
  type: 'legend-seq',
  formatter: {
    formatter: 'd3', // The type of formatter to use
    type: 'number', // The type of data to format
    format: '-1.0%' // Format pattern
  }
}
```

## Interaction

There is no direct way to configure interactions, instead it is done via other components, such as the [brush-range](component-brush-range.md).

### Enable range selection

To enable range selelection, two scene nodes are exposed that can be referenced, via a CSS selector, by the [brush-range](component-brush-range.md) component as a target.
This reference enables the [brush-range](component-brush-range.md) component to limit the target area to a sub-area of the legends dock area.

```js
chartSettings = {
  interactions: [
    ... // Setup required brush-range interactions here.
  ],
  scales: {
    'sequential-color-scale': { source: '0/1', type: 'color' },
    'linear-scale': { source: '0/1', type: 'linear' },
  },
  components: [
    {
      type: 'legend-seq',
      layout: {
        dock: 'right',
      },
      key: 'myLegend' // Reference by the brush-range component,
      settings: {
        fill: 'sequential-color-scale',
        major: 'linear-scale'
      }
    },
    {
      type: 'brush-range',
      key: 'myBrushRange',
      layout: {
        dock: '@myLegend', // Legend reference
      },
      settings: {
        brush: 'highlight',
        scale: 'linear-scale',
        direction: 'vertical',
        bubbles: {
          align: 'start',
          placement: 'outside' // Render bubbles outside the legends dock area
        },
        target: {
          selector: '[id="legend-seq-target"]', // Define the target area. Must reference a node from @myLegend
          fillSelector: '[id="legend-seq-ticks"]', // Define the target fill area. Must reference a node from @myLegend
          fill: 'rgba(82,204,82,0.3)',
        }
      },
  }]
}
```

## API Reference

{{>struct definitions.component--legend-seq}}


text:
<properties
   pageTitle="Authoring Templates with Azure VM Extensions | Microsoft Azure"
   description="Learn more about authoring Templates with Extensions"
   services="virtual-machines"
   documentationCenter=""
   authors="kundanap"
   manager="timlt"
   editor=""
   tags="azure-resource-manager"/>

<tags
   ms.service="virtual-machines"
   ms.devlang="na"
   ms.topic="article"
   ms.tgt_pltfrm="na"
   ms.workload="infrastructure-services"
   ms.date="09/01/2015"
   ms.author="kundanap"/>

# Authoring Azure Resource Manager Templates with VM Extensions.

> [AZURE.NOTE] Azure has two different deployment models for creating and working with resources:  [Resource Manager and classic](../resource-manager-deployment-model.md).  This article covers using the Resource Manager deployment model, which Microsoft recommends for most new deployments instead of the classic deployment model.

## Overview of Azure Resource Manager Templates.

Azure Resource Manager Template allows you to declaratively specify the Azure IaaS infrastructure in Json language by defining the dependencies between resources. For a detailed overview of Azure Resource Manager Templates, please refer to the articles below:

[Resource Group Overview](../resource-group-overview.md)

## Sample template snippet for VM Extensions.
Deploying VM Extension as part of Azure Resource Manager template requires you to declaratively specify the Extension configuration in the template.
Here is the format for specifying the extension configuration.

      {
      "type": "Microsoft.Compute/virtualMachines/extensions",
      "name": "MyExtension",
      "apiVersion": "2015-05-01-preview",
      "location": "[parameters('location')]",
      "dependsOn": ["[concat('Microsoft.Compute/virtualMachines/',parameters('vmName'))]"],
      "properties":
      {
      "publisher": "Publisher Namespace",
      "type": "extension Name",
      "typeHandlerVersion": "extension version",
      "settings": {
      // Extension specific configuration goes in here.
      }
      }
      }

As you can see from the above, the extension template contains two main parts:

1. Extension name, publisher and version.
2. Extension Configuration.

## Identifying the publisher, type and the typeHandlerVersion for any extension.

Azure VM Extensions are published by Microsoft and trusted 3rd party publishers and each extension is uniquely identified by its publisher,type and the typeHandlerVersion. These can be determined as following:

From Azure PowerShell, run the following Azure PowerShell cmdlet:

      Get-AzureVMAvailableExtension

From Azure CLI, run the following Azure PowerShell cmdlet:

      Azure VM Extension list

This cmdlet returns the publisher name, extension name and version as following:

       Publisher                   : Microsoft.Azure.Extensions
      ExtensionName               : DockerExtension
      Version                     : 1.0

These three properties map to "publisher", "type" & "typeHandlerVersion" respectively in the above template snippet.
Note : Its always recommended to use the latest extension version to get the most updated functionality.

## Identifying the schema for the Extension configuration parameters

The next step with authoring extension template is to identify the format for providing configuration parameters. Each extension supports its own set of parameters.

To look at sample configuration for Windows Extensions, click the documentation [Windows Extensions Samples](virtual-machines-extensions-configuration-samples-windows.md).

To look at sample configuration for Linux Extensions, click the documentation for  [Linux Extensions Samples ](virtual-machines-extensions-configuration-samples-linux.md).

Please refer to the following to the VM Templates to get a fully complete Template with VM Extensions.

[Custom Script Extension on a Windows VM](https://github.com/Azure/azure-quickstart-templates/blob/b1908e74259da56a92800cace97350af1f1fc32b/201-list-storage-keys-windows-vm/azuredeploy.json/)

[Custom Script Extension on a Linux VM](https://github.com/Azure/azure-quickstart-templates/blob/b1908e74259da56a92800cace97350af1f1fc32b/mongodb-on-ubuntu/azuredeploy.json/)

After authoring the template, you can deploy them using Azure CLI or Azure Powershell.

repository: wacncontent/MooncakePortal

repo_name: wacncontent/MooncakePortal


text:
# BOM Manager FindChips Plugin

The BOM Manager FindChips Plugin provide a plug interface to
[BOM Manager](https://github.com/waynegramlich/bom_manager) program.
This plugin basically takes a manufacturer part number and returns
a list of vendors (i.e. distributors) that sell that part.  Included
with the list is the vendor part number, vendor availablity, and vendor
price breaks.


text:
**Delicate双手简谱** 和五线谱完全对应。

_Delicate_ 是美国创作型女歌手Taylor Swift演唱的歌曲，收录于2017年11月10日发行的第6张录音室专辑《Reputation》中。

Taylor唱的歌为她赢得了最大的歌迷群：年轻人。她写歌的习惯也成为捕获年轻人的杀手锏，她以写自己的成长经历闻名，歌曲里都是青春的味道，这一点正好切合了年轻歌迷的心，他们能听懂歌曲的内容，自然就会产生共鸣，从青春期开始，这一路下来，会有一批歌迷跟着她一起成长。她很善于利用她年轻这个优势。

歌词下方是 _Delicate钢琴谱_ ，大家可以免费下载学习。

### Delicate歌词：

This ain't for the best
这不是最好的结果
My reputation's never been worse, so
我从未如此声名狼藉过
You must like me for me…
所以你一定是纯粹地喜欢我这个人
We can't make
我们现在
Any promises now, can we, babe?
不能轻易地许下任何承诺了，不是吗，宝贝
But you can make me a drink
但你可以给我调一杯酒
Dive bar on the East Side, where you at?
“我在东区的潜水酒吧这里，你在哪呢？我从来没见过这么蓝的眼睛
Just think of the fun things we could do
期待下我们待会能干的许多有趣的事情吧
'Cause I like you
因为我喜欢你
This ain't for the best
这不是最好的结果
My reputation's never been worse, so
我从未如此声名狼藉过
You must like me for me…
所以你一定是纯粹地喜欢我这个人
Yeah, I want you
是的，我想要你
We can't make
我们现在
Any promises now, can we, babe?
不能轻易地许下任何承诺了，不是吗，宝贝
But you can make me a drink
但你可以给我调一杯酒
Is it cool that I said all that?
你介意我刚才说了那些情话吗？
Is it chill that you're in my head?
我脑海里全是你，你觉得OK吗？
'Cause I know that it's delicate (delicate)
因为我知道我们之间的感情还很脆弱
Is it cool that I said all that?
你介意我刚才说了那些情话吗？
Is it too soon to do this yet?
我们这样做，你会觉得进展太快吗？
'Cause I know that it's delicate
因为我知道我们之间的感情还很脆弱
Isn't it? Isn't it? Isn't it? Isn't it?
不是吗~不是吗~不是吗~不是吗~
Isn't it? Isn't it? Isn't it?
不是吗~不是吗~不是吗~
Isn't it delicate?
还很脆弱，不是吗？

告诉我，伦敦的女孩们有像我这样抚摸你的吗？

所以你一定是纯粹地喜欢我这个人
Yeah, I want you
是的，我想要你
We can't make
我们现在
Any promises now, can we, babe?
不能轻易地许下任何承诺了，不是吗，宝贝
But you can make me a drink
但你可以给我调一杯酒
Is it cool that I said all that?
你介意我刚才说了那些情话吗？
Is it chill that you're in my head?
我现在脑海里全是你，你觉得OK吗？
'Cause I know that it's delicate (delicate)
因为我知道我们之间的感情还很脆弱
Is it cool that I said all that?
你介意我刚才说了那些情话吗？
Is it too soon to do this yet?
我们这样做，你会觉得进展太快吗？
'Cause I know that it's delicate
因为我知道我们之间的感情还很脆弱
Isn't it? Isn't it? Isn't it? Isn't it?
不是吗~不是吗~不是吗~不是吗~
Isn't it? Isn't it? Isn't it?
不是吗~不是吗~不是吗~
Isn't it delicate?
还很脆弱，不是吗
Sometimes I wonder when you sleep
有时候我想知道当你酣睡时
Are you ever dreaming of me?

你介意我刚才说了那些情话吗？
Is it chill that you're in my head?
我现在脑海里全是你，你觉得OK吗？
'Cause I know that it's delicate (delicate)
因为我知道我们之间的感情还很脆弱
(Yeah, I want you)
是的，我想要你
Is it cool that I said all that?
你介意我刚才说了那些情话吗？
Is it too soon to do this yet?
我们这样做，你会觉得进展太快吗？
'Cause I know that it's delicate (delicate)
因为我知道我们之间的感情还很脆弱
'Cause I like you
因为我很喜欢你
Is it cool that I said all that?
你介意我刚才说了那些情话吗？
Isn't it? Isn't it? Isn't it? Isn't it?
不是吗~不是吗~不是吗~不是吗~
Is it chill that you're in my head?
我现在脑海里全是你，你觉得OK吗？
Isn't it? Isn't it? Isn't it? Isn't it?
不是吗~不是吗~不是吗~不是吗~
'Cause I know that it's delicate
因为我知道我们之间的感情还很脆弱
Isn't it? Isn't it? Isn't it? Isn't it?
不是吗~不是吗~不是吗~不是吗~
(Yeah, I want you)
是的，我想要你
Is it cool that I said all that?
你介意我刚才说了那些情话吗？
Isn't it? Isn't it? Isn't it? Isn't it?
不是吗~不是吗~不是吗~不是吗~
Is it too soon to do this yet?
我们这样做，你会觉得进展太快吗？
Isn't it? Isn't it? Isn't it?
不是吗~不是吗~不是吗~不是吗~
'Cause I know that it's delicate
因为我知道我们之间的感情还很脆弱
Isn't it delicate?
还很脆弱，不是吗？

path: /流行/Delicate-Taylor Swift/README.md


text:
# Bernard_bot
Chatbot App that uses Google Maps API. Powered by Node, Express

This description should match descriptions added for package managers (Gemspec, package.json, etc.)

## Code Example

Show what the library does as concisely as possible, developers should be able to figure out **how** your project solves their problem by looking at the code example. Make sure the API you are showing off is obvious, and that your code is short and concise.

## Motivation

A short description of the motivation behind the creation and maintenance of the project. This should explain **why** the project exists.

## Installation

### Quickstart ###

[Fork/Clone our repository](https://github.com/JustinHenderson88/Bernard_bot)

Download all required dependencies via NPM
```
npm install
```
Install Nodemon - listens for changes in files on the working directory and automatically restarts your Node app
```
npm install -g nodemon
```
Launch the app on terminal
```
npm run start
```
By default, the app can be accessed at: `localhost:7500` on your internet browser

(Add some cool screenshot on startup here)

## Tests

Let's add instructions and tests here

## Contributors

This has been a collaboration project between two guys etc etc.

## License

Some description regarding the licensing, and so on... (MIT, Apache, etc.)


text:
# messages.app

Do interesting things with your local Messages.app-database

## Installation

```
npm install messages.app
```

## WTF?

Apple uses a sqlite-database to save your iMessages. So then you can query it to do interesting things!

## Is this safe to use?

Who knows? Probably not.

## Example

```javascript
var messages = require('./messages')()

messages.query('SELECT count(*) as count FROM message', function (err, rows) {
  console.log('Total messages that I have sent/gotten', rows[0].count)

  messages.query('SELECT count(*) as count, is_from_me FROM message GROUP BY is_from_me ORDER BY is_from_me', function (err, rows) {
    console.log('Out of these I sent', rows[0].count)
    console.log('Out of these I received', rows[1].count)
  })
})
```

## Licence

Copyright (c) 2014 David Björklund & Lisa Övermyr

This software is released under the MIT license:

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

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

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


text:
---
title: Beaches of Puerto Vallarta
date: '2019-01-01 06:00:00'
image: pv_beach_.jpg
tags: puerto vallarta mexico jalisco nayarit banderas bay bahia vacation travel holidays
  winter escape
categories: vandwelling
layout: post
---

[On this luxurious week in Puerto Vallarta](http://reverdecer.annalisagross.com/2018/12/29/my-kind-of-puerto-vallarta/), we've been bumming between Holi Beach (seen above and below)

[![](/images/holi_beach_.jpg){:width="60%"}](/images/holi_beach.jpg)

Playa Destiladeras

[![](/images/moss_beach_.jpg){:width="60%"}](/images/moss_beach.jpg)

and Playa Los Muertos

[![](/images/phil_beach_.jpg){:width="60%"}](/images/phil_beach.jpg)

Couldn't say which is best, because (of course) each have their charms.

**Holi Beach** (used to be a Holiday Inn there) is quiet and at the end of the charming river walk. The waves are rough, the ocean floor is rocky, and there's an undertow. So water play happens more in the river's end and the tide pools. There's a restaurant with public (5 peso) bathrooms) and it's a beautiful play to stroll. All the beaches have food and craft salespeople who come to you.

Since it's a lousy place for weak swimmers, why did we decide to bring the dogs into this stretch of ocean? *Tonto!* They shivered for an hour.

[![](/images/wet_dogs_pv_.jpg){:width="60%"}](/images/wet_dogs_pv.jpg)

**Playa Destiladeras** is the best place for swimming and other water activities, but it's a long drive from the city - 30 min to an hour depending on traffic. There are outdoor showers and a bathroom (don't remember if there was a small fee or free), and of course a restaurant. There are miles of shoreline to stroll. [Read a whole post on Playa Destiladeras.](http://reverdecer.annalisagross.com/2018/12/30/playa-destiladeras/)

| [![](/images/hannah_beach_.jpg)](/images/hannah_beach.jpg) | [![](/images/max_beach_.jpg)](/images/max_beach.jpg) |

**Playa Los Muertos** is the place to be for extroverts, shoppers and party-ers, since it's in Old Town and therefore restaurants, shops and clubs are everywhere.

[![](/images/dogs_beach_.jpg){:width="60%"}](/images/dogs_beach.jpg)

Can't go wrong - all have soft sand, gorgeous rocks, plenty to eat and drink, and friendly folks.

gha_language: CSS


text:
# SparkNetworks Challenge - Backend
### Summary
Backend NodeJs application that provides a profile data API allowing CRUD operations and storing data on a local
NeDB

### Features
The application uses FeathersJS framework to provide a profile REST API. It also provides support
for uploading images to the local filesystem.

Additionally is statically serving .json files (single_choice_attributes.json and cities.json) to
provide attribute and city data to the front end app.

To facilitate testing app is using an embedded database called NeDB which does not need to install
 any separate component. Also is already creating a profile with test information on start which id
  is hardcoded in the Android app.

### Libraries/Dependencies
* [Feathersjs](https://feathersjs.com/) An open source REST and realtime API layer for modern
applications.
* [NeDB](https://github.com/louischatriot/nedb) Embedded persistent or in memory database for
Node.js, 100% JavaScript, no binary dependency
* [Multer](https://github.com/expressjs/multer) Multer is a node.js middleware for handling
multipart/form-data, which is primarily used for uploading files.

### Setup/Run instructions
To run the server you need to install all of the dependencies first using npm.

Make sure you have [NodeJS](https://nodejs.org/) and [npm](https://www.npmjs.com/) installed.

Once installed you should be able to run these commands in a terminal:

 For node `node --version` and npm `npm --version`

Then go to the projects /server folder and:

Install dependencies running : `npm install`

Start the app running : `npm start`

App will start running in port 3030. To make sure is running you can visit with your browser:
`http://localhost:3030/`

### Endpoints
The app exposes the following endpoints:

* GET `http://localhost:3030/profiles` to retrieve a list of available profiles
* GET `http://localhost:3030/profiles/{id}` exchanging {id} for the profile id to retrieve a single
profile
* POST `http://localhost:3030/profiles` to save a new profile, sending the profile json in the body
of the request
* PATCH `http://localhost:3030/profiles` to update an already existing profile, sending the profile
object as json in the body
* DELETE `http://localhost:3030/profiles/{id}` to delete an existing profile exchanging {id} for the
profile id
* POST `http://localhost:3030/upload` to upload a new profile image with the file with multi-part
encoding and the name of the field as "profileImage". The method will return a json object with the
final "fileName" which is the one can be used later to retrieve it from the server
* GET `http://localhost:3030/cities.json` to get a json with the list of cities provided for the exercise
* GET `http://localhost:3030/single_choice_attributes.json` to get a json with the list of single
choice attributes

### Limitations
*  Server does not offer any type security or file upload filtering
*  Because of time constraints I decided not to create additional API endpoints for single choice
attributes and city data as they required specific formatting.

repository: brahyam/editable-profile

repo_name: brahyam/editable-profile


text:
# ALL GET API's

The following GET APIs are used to fetch the data from the respective tables.

## 1. Attribute Type API GET Endpoint

All data from the Attribute Type table will be returned from the endpoint below. You can optionally fetch specific data by including Attribute ID’s and Attribute Types. The Attribute Type endpoint supports pagination.

> Example Of AttributeType GET Endpoint Without Pagination:

```
https: // {tenant}.actsapi.intelex.com/API-develop/v1/AttributeType
```

> Example Of AttributeType GET Endpoint With Pagination and Filter Option:

```
https: // {tenant}.actsapi.intelex.com/API-develop/v1/AttributeType?PageNumber=1&PageSize=500&attributeTypeIDs="int data"&attributeTypes="string data"
```

## 2.Compound API GET Endpoint

All data from the Compound table will be returned from the endpoint below. You can optionally fetch specific data by including compound ID’s, compound Type IDs, compound status IDs, compound Names, external identifiers, or CAS number. The Compound endpoint supports pagination.

> Example Of Compound GET Endpoint Without Pagination:

```
https: // {tenant}.actsapi.intelex.com/API-develop/v1/Compound
```

> Example Of Compound GET Endpoint With Pagination and Filter Option:

```
https: // {tenant}.actsapi.intelex.com/API-develop/v1/Compound? PageNumber=1&PageSize=500&compoundIDs="int data"&compoundTypeIDs="int data"&compoundstatusIDs="int data"&compoundNames="string data"&externalIdentifier="int"&CAS="string data"
```

## 3.Emission Category API GET Endpoint

All data from the Emission Category table will be returned from the endpoint below. You can optionally fetch specific data by including the emission category ID. The Emission Category endpoint supports pagination.

> Example Of EmissionCategory GET Endpoint Without Pagination:

```
https: // {tenant}.actsapi.intelex.com/API-develop/v1/EmissionCategory
```
> Example Of EmissionCategory GET Endpoint With Pagination and Filter Option:

```
https: // {tenant}.actsapi.intelex.com/API-develop/v1/EmissionCategory/{int data – Emission Category ID}
```

## 4.Emission Type API GET Endpoint

All data from the Emission type table will be returned from the endpoint below. You can optionally fetch specific data by including the emission type ID. The Emission Type endpoint supports pagination.

> Example Of EmissionType GET Endpoint Without Pagination:

```
https: // {tenant}.actsapi.intelex.com/API-develop/v1/EmissionType
```

> Example Of EmissionType GET Endpoint With Pagination and Filter Option:

```
https: //{tenant}.actsapi.intelex.com/API-develop/v1/EmissionType?PageNumber=1&PageSize=500&emissionTypeID={int data value}
```

## 5.Equipment API GET Endpoint

All data from the Equipment table will be returned from the endpoint below. You can optionally fetch specific data by including the equipment ID. The Equipment endpoint supports pagination.

> Example Of Equipment GET Endpoint Without Pagination:

```
https: //{tenant}.actsapi.intelex.com/API-develop/v1/Equipment
```

> Example Of Equipment GET Endpoint With Pagination and Filter Option:

```
https: //{tenant}.actsapi.intelex.com/API-develop/v1/Equipment?PageNumber=1&PageSize=500&equipmentID={int data value}
```

## 6.Equipment Status API GET Endpoint

All data from the Equipment Status table will be returned from the endpoint below. You can optionally fetch specific data by including the equipment status ID and equipment status value. The Equipment Status endpoint supports pagination.

> Example Of EquipmentStatus GET Endpoint Without Pagination:

```
https: // {tenant}.actsapi.intelex.com/API-develop/v1/EquipmentStatus
```

> Example Of EquipmentStatus GET Endpoint With Pagination and Filter Option:

```
https: // {tenant}.actsapi.intelex.com/API-develop/v1/EquipmentStatus?PageNumber=1&PageSize=500&EquipmentStatusIDs="int data"&EquipmentStatus="string data"
```

## 7.Equipment Type API GET Endpoint

All data from the Equipment Type table will be returned from the endpoint below. You can optionally fetch specific data by including the equipment type ID and equipment types value. The Equipment type endpoint supports pagination.

> Example Of EquipmentType GET Endpoint Without Pagination:

```
https: // {tenant}.actsapi.intelex.com/API-develop/v1/EquipmentType
```

> Example Of EquipmentType GET Endpoint With Pagination and Filter Option:

```
https: // {tenant}.actsapi.intelex.com/API-develop/v1/EquipmentType?PageNumber=1&PageSize=500&EquipmentTypeIDs="int data"&EquipmentType="string data"
```

## 8.Operation API GET Endpoint

All data from the Operation table will be returned from the endpoint below. You can optionally fetch specific data by including the operation ids, operation type ids, emission type ids, emission category ids, unit ids, equipment ids, last modified start date and last modified end date. The Operation endpoint supports pagination.

> Example Of Operation GET Endpoint Without Pagination:

```
https: // {tenant}.actsapi.intelex.com/API-develop/v1/Operation
```

> Example Of Operation GET Endpoint With Pagination and Filter Option:

```
https: // {tenant}.actsapi.intelex.com/API-develop/v1/ Operation?PageNumber =1&PageSize=500&OperationIDs="int data"&OperationTypeIDs=”string data "&EmissionTypeIDs="int data”&EmissionCategoryIDs="int data”&UnitIDs="int data"&EquipmentIDs="int data"&LastModifiedStartDate=”string format – date time data"&LastModifiedEndDate="string format – date time data"
```

## 9.Unit API GET Endpoint

All data from the Unit table will be returned from the endpoint below. You can optionally fetch specific data by including the unit ids, unit type ids and units. The Unit type endpoint supports pagination.

> Example Of Unit GET Endpoint Without Pagination:

```
https: // {tenant}.actsapi.intelex.com/API-develop/v1/Unit
```

> Example Of Unit GET Endpoint With Pagination and Filter Option:

```
https: // {tenant}.actsapi.intelex.com/API-develop/v1/Unit?PageNumber=1&PageSize=500&UnitIDs="int data"&UnitTypeIDs="int data" &Units="string data"
```

## Sample Result Set Of One Of the API Endpoint

> Example Output Response

```json
{
    "currentPage": 1,
    "totalPages": "int",
    "currentPageSize": 500,
    "maxAPIPageSize": 500,
    "totalCount": "int",
    "hasPrevious": "boolean",
    "hasNext": "boolean",
    "data":
[
    {
        "EquipmentAttributeId": "int",
        "EquipmentId": "int",
        "AttributeTypeId": "int",
		"EquipmentAttribute":"string",
        "DataLockTypeId": "datetime",
        "LastModifiedDate": "datetime",
        "ExternalIdentifier": "string",
		"Comments":"string"
    }

repository: IntelexTechnologies/api-docs

gha_language: JavaScript

gha_license_id: NOASSERTION

repo_name: IntelexTechnologies/api-docs


text:
# How to Create Isolated File Directories For Ubuntu 12.04 Users with Jailkit

### Introduction

Of particular interest to hosting providers, resellers, and those that manage a server for friends & family, the `chroot` (short for “change root directory”) system provides a way of isolating users from other parts of your server – by putting them in (what is commonly referred to as) a jail. In other words, a `chroot` jail can be used to section off, or isolate, a particular user from entire sections of your server’s filesystem. Without a `chroot` jail, nothing would prevent a user with even limited file permissions from being able to navigate up to system-critical, top-level directories.

## The Basic `chroot` Environment

A `chroot` jail is a directory tree that you create within your filesystem, where the user cannot see any directories or files that are outside the `chroot` jail directories. The user is said to be “jailed” in that directory and its subdirectories. If you want a user to be able to do just one task, you can set up a `chroot` jail so that the user is able to only do that one task. The fewer executables you have in a `chroot` jail (and the more their capabilities are limited with strict configurations), the more work a hacker, or malicious worm, needs to break out of the `chroot` jail to move on to your filesystem at large.

Many control panels that reconfigure web servers for shared hosting will automatically create `chroot` directories for user accounts. Even if you trust your users to not intentionally attempt anything malicious, Brute-Force Attacks are an unwelcome reality in today’s IT world and isolating your users’ file directories provides an added layer of defense in the event that a user’s system account should become compromised.

To create a `chroot` jail, simply create a folder that has a replication of the directory structure of a typical Linux server. The difference is that you _only_ copy, in that `chroot` directory, the bare minimum of what is needed by your user. This process can be carried out manually, with several commands, or you can automate the process with Jailkit.

## About Jailkit

Jailkit is a set of utilities that can be used to set up a `chroot`-based, restricted environment where users have limited access to the server’s filesystem and the commands they run. The Jailkit utilities also make it easy to set up a restricted shell or to run services or programs inside such a restricted environment.

> Project website:
> <http://olivier.sessink.nl/jailkit/>

## Scope of this Article

Jailkit is a robust program. This article, however, is limited to the scenario where a server administrator wishes to grant some users shell access, but aims to contain users’ files (e.g. web or app) in a `chroot` jail; so that users can do what they wish with their content, without exposing the rest of the server to the risk of breakage.

As will become evident, as you work through this article, there is _much_ more that one can do with Jailkit. Once you become comfortable with the basic concepts of a `chroot` jail and Jailkit’s utilities, you are encouraged to explore the various HowTos published on the Jailkit website.

## Prerequisites

- This article assumes that you have completed the steps outlined in [Initial Server Setup with Ubuntu 12.04 | DigitalOcean](https://www.digitalocean.com/community/articles/initial-server-setup-with-ubuntu-12-04).

- Jailkit needs to be compiled from source. To install the tools needed for that process, execute the following command in a terminal window:

        sudo apt-get -y install build-essential

## Compile & Install Jailkit

Download the latest version of the Jailkit source files and extract the archive in your server’s `/tmp` directory, by executing the following command:

> **Note:** Check the Jailkit project website to ensure that you are installing the most recent release, i.e.
>
>       http://olivier.sessink.nl/jailkit/jailkit-<VERSION>.tar.gz

    cd /tmp && sudo wget -O - "http://olivier.sessink.nl/jailkit/jailkit-2.16.tar.gz" | tar xzvf -

Next, execute:

    cd jailkit-*

Finally, compile and install Jailkit, by executing:

    ./configure && make && sudo make install

## Jailkit Utilities

Jailkit is comprised of various pre-configured scripts, templates and configuration files that you can mix-and-match, to build the perfect `chroot` jail. If none of the existing Jailkit utilities meet your needs, you can customize them or create new ones. By default, Jailkit installs its utilities in `/usr/sbin/` and its configuration and template files in `/etc/jailkit/`.

**Note:** In some cases, the configuration files must be replicated in the `chroot` directory and edited appropriately (usually done so, automatically, by the `jk_init` utility), because a Jailkit utility that is run within a `chroot` environment is able to read its configuration **only** from within the jailed `chroot` directory. Jailkit’s utilities are prefixed with `jk_`.

    non-root_user@server:/usr/sbin/$
    [...]   jk_addjailuser  jk_chec jk_chrootlaunch jk_chrootsh jk_cp
    jk_init jk_jailuser jk_list jk_lsh  jk_socketd  jk_update   [...]

These utilities include a launcher that can start a daemon in a `chroot` jail; a `chroot` shell tool; a tool to limit binary execution; a tool to update and clean up a jail based on changes already made on the system at large; and more. All of Jailkit’s utilities have `man` pages which contain more information on how to use them; and can be accessed from any directory on your server by executing:

    man jailkit

You may also read more about the utilities not touched on, in this article, on Jailkit’s website.

## Setting up a `chroot` Jail Environment

There needs to be a directory where the entire jail environment will be setup. Jailed users will see this directory as the root directory of the server. You are free to choose whatever directory structure you wish, e.g. `/home/jail/`, `/var/chroot/`, `/jail`, etc.

### The `jk_init` utility

With Jailkit’s `jk_init` utility, you can automate the process of creating a `chroot` jail, while retaining the ability of specifying the jail’s location and what programs you want included in the jail. For example, execute:

> Feel free to substitute `/chroot` with a directory of your choice.

    sudo jk_init -v -j /chroot basicshell editors extendedshell jk_lsh netutils ssh sftp

## Creating & Jailing a User

_Skip down to the **Jail the user** section to add existing users to a `chroot` jail._

To create a new user, execute (substituting `username` with one of your choosing):

    sudo adduser username

Follow the prompts to specify a password and provide the user information requested by the system.

**Note:** This is a normal user that is created and is **_not_** inside the `chroot` jail, yet.

### Jail the user

The `jk_jailuser` utility is a tool that moves an existing user account – the user’s entire home directory and subdirectories – into a `chroot` jail. In the following example, the `-s` option grants the soon-to-be jailed user bash shell access, i.e. `/bin/bash`:

    sudo jk_jailuser -m -s /bin/bash -j /chroot username

> For a more restricted account, leave out `-s /bin/bash` (to create, for example, an SFTP-only user account with no shell access).

Then, copy bash and its libraries into the `chroot` jail using the `jk_cp` utility:

    sudo jk_cp -v -f /chroot /bin/bash

> Bash and its libraries need to be copied into the `chroot` environment, only once; and they’ll be available to future jailed-users to whom you wish to grant shell access.

Finally, edit the SSH configuration file to allow access for the additional user:

    sudo vim /etc/ssh/sshd_config

> Then, tap on the `i` key (on your keyboard) to enter the Vim text editor’s “insert mode.”

and add the jailed user to the following directive:

    [...]
    AllowUsers your_username new_username

> To save your edit, and exit, tap the following keys: `Esc`,`:`, `w`, `q`, `Enter`.

Reload SSH to incorporate the modified setting:

    sudo reload ssh

#### Confirm the transfer of the user account into the `chroot` jail

To confirm that the user was jailed, check the user’s `/etc/passwd` file, by executing:

    cat /etc/passwd

Review the line that pertains to the newly-jailed user and inspect the last two elements to make sure that the user’s:

1.  home directory is now nested inside the `chroot` jail; and
2.  shell is now a special utility named `jk_chrootsh`:

         username:x:[UserID]:[PrimaryGroupID]:[Full Name],,,:/path/to/jail/./home/username:/usr/sbin/jk_chrootsh

In addition to the modifications to the jailed-user’s `/etc/passwd` file, the `jk_jailuser` utility also adds the user to a stripped-down `passwd` file located at `/path/to/jail/etc/passwd` and adds the user’s group(s) to a stripped-down group file located at `/path/to/jail/etc/group`.

### Confirm SSH access

Now, it’s time to verify that the newly-jailed user has SSH access. If you encounter any connection problems, check for errors:

    sudo cat tail /var/log/auth.log

If successful, your user now has a fully-functioning bash shell, but inside the `chroot` jail. Feel free to move around the `chroot` environment. Notice that the root of the jailed-environment appears to be the normal `/`, even though it is `/chroot` on the actual filesystem.

## Maintenance

Refer to the Jailkit [website](http://olivier.sessink.nl/jailkit/jk_update.8.html) to learn about using the `jk_update` utility to update and cleanup a `chroot` jail according to changes, e.g. program software updates, on the main filesystem.

## Security Considerations

The Jailkit Team: >A badly configured jail is a security risk!

The server’s super user (i.e., root), or any process running with root privileges, can always break out of a jail.

#### No directory inside a `chroot` jail, except for a jailed-user’s home or `/tmp`, directories should be writable by the jailed-user. Otherwise, a jailed-user can bypass security checks and gain root privileges.

Refer to the Jailkit website for other security best practices and Jailkit utilities, not discussed in this article, e.g., [jk_check](http://olivier.sessink.nl/jailkit/jk_check.8.html) that can be used to perform some basic checks to verify that a `chroot` jail is secure.

## Conclusion

As you can see, creating and administering `chroot` jails is reduced to a much simpler process with Jailkit. While `chroot` is very useful for basic, preventative security, it is not designed to prevent deliberate attempts to gain root access for purposes of attacking a server. For that threat, there are other security measures you can employ. Nevertheless, `chroot` helps, tremendously, to at least make it more difficult to exploit your virtual private server.

## Additional Resources

- Jailkit-users [mailing list](https://lists.nongnu.org/mailman/listinfo/jailkit-users)
- [Jailkit Docs | FAQs | HowTos](http://olivier.sessink.nl/jailkit/)

As always, if you need help with the steps outlined in this How-To, look to the DigitalOcean Community for assistance by posing your question(s), below.

Article submitted by: [Pablo Carranza](https://plus.google.com/107285164064863645881?rel=author) • December 6, 2013


text:
# belajar-mvvm

This Project was created in attempt to learning about MVVM in iOS using Swift Programming Language

## version on setup
- iOS version: 12
- Target iOS version: 9
- XCode: 10.1 (10B61)
- Swift: 4.2

## Library
- CocoaPods: 1.5.3
- Alamofire: 4.8.0
- Alamofire-SwiftyJSON: 3.0.0
- AlamofireImage: 3.5.0
- SwiftyJSON: 4.0.0

## Version History
- 1.0.3 (3), January 30th, 2019:
    - separate of concern
    - MVVM without binding
- 1.0 (2), January 28th, 2019:
    - Create project on MVC Pattern first
- 1.0 (1), January 27th, 2019:
    - Initiate Project
    - Project Architecture

repository: komangsidhiartha/belajar-mvvm

gha_language: Swift

repo_name: komangsidhiartha/belajar-mvvm


text:
---
layout: project
type: project
image: images/soest_logo.png
title: MESH Lab
permalink: projects/MESHLab
# All dates must be YYYY-MM-DD format!
date: 2019-02-01
labels:
  - Robotics
  - Sensor
  - Research
summary: MESH Lab develops cost efficient marine sensors for enviormental research and as a way to expose the community to STEM.
---
I am responsible for the fabrication of cost effective electronic sensor systems that are utilized to study different marine environments with a focus on Ala Wai Canal and coral reefs. These devices gather temperature, pressure, and light color data which is transmitted through IR communication. To ensure the sensors are safe to deploy they are enclosed within pressurized containers rated for depths up to 300 ft.

A portion of the sensors built in the lab are distributed to local schools who integrate them into their various STEM curriculum. As an engineering assistant, I need be diligent with a high attention to detail and capable of troubleshooting a variety of issues relating to hardware and software. The devices I build change regularly, so I also need to be able to learn and adapt quickly.

One of the most commonly built sensors at the lab are Kiwi Loggers. The components of the Kiwis can be seen in the photos above. Small round printed circuit boards(PCBs) called Breakout Boards (top left photo) contain pressure, temperature, light and color sensors which interface with a Logger (bottom left photo). The Logger recieves and stores data taked from these sensors. Once the Kiwis have been packaged within there pressurized containers the only way to retrive this data is through IR communication. The lab produces an IR Donle (top right photo) that allows connection to a computer through USB.

Dr. Brian Glazer runs MESH Lab and more information about our research can be found on [his website](https://www.soest.hawaii.edu/oceanography/glazer/Brian_T._Glazer/Research.html).


text:
---
layout: post
title: Tacos - Attempt 1
---

This is my first attempt at tacos. Not the most successful meal I made,
but it's something I'm determined to nail.

![Tacos #1](/assets/2018-tacos_1.jpg)

Instead of the typical ground beef, I used ground turkey not because it was
healthier but because that's what I had on hand.

For spice mix, I used [Alton Brown's Taco Potion #19](https://altonbrown.com/taco-potion-19-recipe/).

For preparation I used [Culinary Hill's The Best Turkey Tacos](https://www.culinaryhill.com/saucy-turkey-tacos/) -
which calls for 1 cup of tomato juice.

That latter part is important because I think it's what went wrong that
made the recipe taste more like Sloppy Joes than regular tacos.

As a test, I changed the Taco Potion #19 recipe to replace the cumin
with garam masala. That yielded some delicious mix.


text:
# [![OWASP Logo](../../images/owasp_logo.png) OWASP Amass](https://owasp.org/www-project-amass/)

This example uses Docker Compose (with support for version 3 schemas) to setup an environment with JanusGraph, Scylla/Cassandra and Elasticsearch.

## Installation

If you're running this on a laptop, these servers require a large amount of the system resources. In some cases, OWASP Amass testers needed to give Docker 8 cores, 16GB of memory, and at least 10GB of disk image size.

It is recommended that you copy this directory to another location outside the git repo that can also provide plenty of storage for the servers.

From this directory, execute the following command:

```bash
docker-compose up --build
```

If this is the first time you started up the environment, then you need to run the initialization script as follows:

```bash
docker-compose exec janus ./bin/gremlin.sh -e /workspace/janusgraph/scripts/amass-init.groovy
```

## Thanks

* The [janusgraph-docker](https://github.com/sunsided/janusgraph-docker/) repo, by [Markus Mayer](https://github.com/sunsided), made this much easier for the OWASP Amass Project.

repository: im-prakher/Amass

repo_name: im-prakher/Amass


text:
Do Not Disturb Sync for Wear
============

Android Wear 2.0 removed synchronization of the Do Not Disturb
state between the watch and the phone. This application restores
the Android Wear 1.5 behaviour with minimal or no battery life impact.

Version 1.1 of the app optionally adds support for full bi-directional
sync. To enable phone to watch sync, users need to manually set the app
as a notification listener **on the watch** by running the following commands:

## Wear OS 2.x/3.x instructions (credit to rhaeus on XDA for finding the new command):

```sh
$ adb shell cmd notification allow_listener se.blunden.donotdisturbsync/se.blunden.donotdisturbsync.DNDSyncNotificationService
```

## Android Wear 2.0 instructions:

```sh
$ adb shell

$ settings put secure enabled_notification_listeners com.google.android.wearable.app/com.google.android.clockwork.stream.NotificationCollectorService:se.blunden.donotdisturbsync/se.blunden.donotdisturbsync.DNDSyncNotificationService
```

**NOTE (Only applies to Android Wear):** If you have already manually added other notification listeners
on your watch, you need to instead read the current value and then set it
again with *:se.blunden.donotdisturbsync/se.blunden.donotdisturbsync.DNDSyncNotificationService*
added.

[Play Store](https://play.google.com/store/apps/details?id=se.blunden.donotdisturbsync)

repository: blunden/DoNotDisturbSync

repo_name: blunden/DoNotDisturbSync


text:
# Lichen stictoceros Sm. SPECIES

#### Status
SYNONYM

#### According to
Index Fungorum

#### Published in
Engl. Bot. 19: tab. 1353 (1804)

#### Original name
Lichen stictoceros Sm.

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Ascomycota/Lecanoromycetes/Lecanorales/Parmeliaceae/Evernia/Evernia prunastri/ Syn. Lichen stictoceros/README.md

repo_name: mdoering/backbone


text:
# Problem statement

We need to write code that will query the **meta data** of an instance within **AWS/Azure/GCP** and provide a JSON formatted output. The choice of language and implementation is up to you.

Refer to the documentation of the respective public cloud providers.

## First things first - Why Python?

>The IMDS service of AWS, Azure and GCP are simple rest API's and can be implemented in wide range of programming languages. I have chosen Python to showcase my proficiency in Python

# Approach

I am going to choose AWS here as it is widely used by many enterprises for **IAAS**. There are two API's IMDSv1 and IMDSv2, I am going to use IMDSv1 for this challenge IMDSv2 there is a new requirement to pass a
>**X-aws-ec2-metadata-token** and **X-aws-ec2-metadata-token-ttl-seconds**

  The AWS IMDSv1 has an API

>http://<IP_ADDRESS>/latest/meta-data/

The first call will return the top level Keys and we need to iterate the list of keys with the same API with the key amended at the end. Some of the keys may return another array of keys.

>http://<IP_ADDRESS>/latest/meta-data/{key}

Finally we need to keep track all the keys and the values and build the JSON Object.

To obtain a value for a single key we still might need to retrieve  the entire meta-data and traverse through the JSON tree to find the value for the given key.  For further info refer to [AWS docs](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instancedata-data-retrieval.html)

In **Azure** it is fairly easy to retrieve meta data information. On a linux terminal
>curl -H Metadata:true --noproxy "*"  "http://<IP_ADDRESS>/metadata/instance?api-version=2020-09-01"

Would give the JSON output of metadata

In **GCP** it is again similar to the AWS the first request will return a directory and the users have to make further calls to the api to get the values.

>curl "http://metadata.google.internal/computeMetadata/v1/instance/" -H "Metadata-Flavor: Google"

# Assumptions

- The machine that is running this service is configured with right access keys and permissions in IAM.

# Testing

I am going to use Mocha javascript testing framework to do the unit testing

# Bonus Points

The code allows for a particular data key to be retrieved individually

# Prerequisites

Create an EC2 Linux instance on AWS

SSH into the instance

# Installation

Install Python 3 and git on your instance

>sudo yum install python3 git

Clone this repository

>git clone https://github.com/senthilkm/challenges

Install pipenv

>sudo pip3 install pipenv

Go to directory **challenge2**

>cd challenge2

Install project dependancies

>pipenv install

# Running

Open the src folder

>cd challenges/challenge2/src

Run whichever script you need:

>python3 metadata.py

>python3 querymetadata.py

Examples for the key ami-id or vpc-id


text:
# Firebase v3 Web Auth Complete Working Example

:star: Please star me if you like this! :star:

### Synopsis

A fully functional example of Firebase v3 Web authentication.  Sign in with Facebook, Github, Google, Twitter, password based, and anonymous accounts.  The code is easy to read and follow and is well documented.  The focus is on the fully functional authentication system.

Password based users are sent a validation link.  They can also change their email address and password - both of these events send a verification email as an additional security measure.

Lastly, the difference between authentication, client side authorization, and server side authorization secured via Firebase Realtime Database Security Rules is demonstrated.

### Live Fully Functional Demo

:point_right:  [CLICK FOR LIVE DEMO](http://rack.pub/firebase-auth)  :point_left:

<img src="https://github.com/rhroyston/rhroyston.github.io/blob/master/firebase-auth.jpg" alt="screenshot">

### Motivation

Setting up all 6 types of authentication took me quite a while so I decided to create a template that I could use as a starting point for my Firebase v3 Web applications.  It occurred to me that I could share this with other developers.

### Installation

The easiest way to install this code is to clone or download it.  The following tasks must be done to get it working on your system.

1. **Prerequisites**
    1. A [Firebase Web project](firebase.google.com). :free:
    2. An IDE. What's an IDE?  Try [Cloud9](https://c9.io/). :free:
    3. A Github, Google, Facebook, and Twitter account. :free:
    4. Two email accounts. :free:

2. **Configure Your IDE**
    2. Create an HTML5 project.
    3. Install Firebase Tools.  `npm install -g firebase-tools`
    4. Using Firebase Tools command line, login to your Firebase project.  `firebase login --no-localhost `
    5. Using Firebase Tools command line, setup a Firebase project in the current directory. `firebase init`
    6. Clone this set of files and folders to your IDE. `git clone https://github.com/rhroyston/firebase-auth.git`
    7. Using Firebase Tools command line, push your IDE project to your Firebase project. `firebase deploy`
    8. View Firebase project in your browser.  Any broken images or errors?  Easy fix below.
    8. You may need to update `href`, `src`, and `background: url` in all JS, CSS, and all HTML files depending on your Web hosting folder structure .
        1. Use Find feature to search for both `href` and `src` and update as necessary.
        2. Browser Console will display any remaining incorrect paths errors.
        3. Note script.js line 781 `privateLink.href = "../firebase-auth/private"` the `..` seems to be required.
        4. Once all pages render properly from Firebase Hosting (no broken images or console errors), continue.

3. **Configure Firebase**
    1. Enable all 6 forms of authentication.  Follow the instructions on configuring social media site settings.
    2. Customize the Email Action Handler URL to point to your Firebase Web app URL + '/ack', e.g. `https://my-app-1234/ack`.

4. **Login to Web app**
    1. Login using an oAuth provider.
    2. From the browser command line, use the exposed `demo.update('mynode','myKey','myValue')` method to add secure markup to your Realtime Database.
        1. A success message will show up in your browser console.
        2. You may need to update the `href` path to match your folder structure.
    ```javascript
    demo.update("markup","secureData","<div class=\"mdl-card__title\"> <h1 class=\"mdl-card__title-text mdl-color-text--white\">Secured Data</h1> </div><div class=\"mdl-card__supporting-text mdl-typography--headline\"> <p>This is a secure card. The HTML markup that renders this card is secured in the Realtime Database.  Access is determined server side so no matter what you do with JavaScript on your browser you will not be able to view this card unless you are authorized to.</p><p>Secured data can be markup, JSON, strings, numbers, etc. Your imagination is the limit!</p></div><div class=\"mdl-card__actions mdl-card--border intro-card-actions\"> <a class=\"mdl-button mdl-button--colored mdl-js-button mdl-js-ripple-effect\" href=\"../firebase-auth/\">Home</a></div>");
    ```

### Firebase v3 Authentication and Authorization Demo Walkthrough

1. **Login using each oAuth provider**
    1. Notice that updating email address or password options are not present in your Account page.
    2. Notice any extra links in the side menu drawer?
    3. Try Deleting your account.  What Happens?

2. **Register as a Password based user**
    1. Did you get a verification email?
    2. Can you view private data until you clicked the verification link?
    3. Can you change your password?
    4. Can you change your email address?
    5. Can you undo the email change by clicking the email change notification email revokation link?

3. **Logout**
    1. What links are present in the side menu drawer?
    2. Can you access private data?
    3. Can you view private data?

### Contribute

If you found a bug, have any questions or want to contribute please let me know, [ron@rack.pub](mailto:ron@rack.pub).

### License

Ron Royston, [https://rack.pub](https://rack.pub), [MIT License](https://en.wikipedia.org/wiki/MIT_License)


text:
![GitHub](https://img.shields.io/github/license/fuguefoundation/ff-contracts)

## About the Project

[Fugue Foundation](https://fuguefoundation.org) is a nonprofit dedicated to using open source, decentralized technology to achieve charitable goals rooted in the principles of effective altruism. Read this [blog post](https://blog.fuguefoundation.org/ff-platform-overiew/) to learn more about the use case and architecture of our flagship project, the Fugue Foundation decentralized application.

Ultimately these smart contracts will be incorporated into a decentralized application currently being developed in a [separate repo](https://github.com/fuguefoundation/ff-dapp).

## Setup

1. Install Truffle: `npm install -g truffle` - [Docs](https://www.trufflesuite.com/docs/truffle/quickstart)
2. Clone repo and run `npm install`
3. You will need to connect to a blockchain and Truffle provides different options, such as [Ganache](https://www.trufflesuite.com/docs/ganache/quickstart). **For development on a live testnet** (Goerli, Ropsten, etc.), create an `app.env` file to store private variables (see `truffle-config.js` file).
4. Run `truffle compile`, `truffle migrate` and `truffle test` to compile your contracts, deploy those contracts to the network, and run their associated unit tests. Truffle comes bundled with a local development blockchain server that launches automatically when you invoke the commands  above. You can interact with the contracts with `truffle console`.

## Contributing to the project

This is an open source project. Contributions are welcomed & encouraged! :smile: If you'd like to improve the code base, please see [Contributing Guidelines](CONTRIBUTE.md).

## Change Log

See [CHANGELOG](./CHANGELOG.md) for details.

## References
* [Kudos NFT](https://github.com/gitcoinco/Kudos721Contract)
* [Ethereum](https://ethereum.org/)
* [Truffle](http://truffleframework.com/docs/)
* [Open Zeppelin](https://docs.openzeppelin.com/openzeppelin/)

repository: fuguefoundation/ff-contracts

gha_language: Solidity

repo_name: fuguefoundation/ff-contracts


text:
# Alternative installation methods

> ⚠ This is for advanced users only.

The following examples target Unix-like, macOS, WSL, etc. operating systems.

## Contents

- [Versioned global package](#versioned-global-package)
- [Build from release source](#build-from-release-source)
- [Build from repository source](#build-from-repository-source)

![Divider](../images/divider.png)

## Versioned global package

Install a specific version of the package from npm.

```sh
# List available versions.
npm view ftx-cli versions

# Install package globally. Example version: `1.0.0`.
npm install -g ftx-cli@<version>
```

![Divider](../images/divider.png)

## Build from release source

Download, install, and update the package manually from a [release](https://github.com/dusktrades/ftx-cli/releases). Here's what that may look like:

```sh
# Download release gzipped tarball. Example version: `v1.0.0`.
wget https://github.com/dusktrades/ftx-cli/archive/refs/tags/<version>.tar.gz

# Install package globally.
npm install -g ./<version>.tar.gz
```

![Divider](../images/divider.png)

## Build from repository source

> ⚠ You should not need to install using this method unless you are actively developing. Source code that is not part of an official release may be unstable.

Download, install, and update the package manually directly from the repository. Here's what that may look like:

```sh
# Clone source code.
git clone https://github.com/dusktrades/ftx-cli

# Enter the package directory.
cd ftx-cli

# Install package globally.
npm install -g

# When it's time to update: pull the updated source code and reinstall.
git pull
npm install -g
```


text:
### Building

This entity contains a harmonised description of a Building. This entity is associated with the vertical segments of smart homes, smart cities, industry and related IoT applications.

<Building><Generic Attributes>

| Attribute Name | Attribute Type | Description                                                                   | Mandatory /Optional | May be Null |
|----------------|----------------|-------------------------------------------------------------------------------|--------------------|-------------|
| id             | Text           | Unique id of this instance of this entity.                                    | M                  | N           |
| type           | Text           | Must be equal to "**Building**".                                              | M                  | N           |
| dateCreated    | DateTime       | Entity creation timestamp.                                                    | M                  | N           |
| dateModified   | DateTime       | Timestamp of the last modification of the entity.                             | M                  | Y           |
| source         | Text           | A sequence of characters giving the source of the entity data as a URL.       | M                  | Y           |
| dataProvider   | Text           | A sequence of characters identifying the originator of the harmonised entity. | M                  | Y           |

<Building><Entity Specific Attributes>

| Attribute Name         | Attribute Type                                      | Description                                                                                | Mandatory /Optional | May be Null |
|------------------------|-----------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------|--------------------|-------------|
| refBuildingType        | Reference                                           | Refers to the buildingType that this building is an instance of.                                                                             | M                  | N           |
| category               | Array of Text                                       | One or more categories relevant to the building with choices based on for example <http://wiki.openstreetmap.org/wiki/Map_Features#Building> | O                  | Y           |
| containedInPlace       | geo:json                                            | The geo:json encoded polygon of the building plot in which this building sits.                                                               | O                  | Y           |
| location               | geo:json                                            | The geo:json encoded polygon of this building.                                                                                | M                  | N           |
| address                | PostalAddress                                       | The building PostalAddress encoded as a Schema.org PostalAddress.

 [https://schema.org/PostalAddress](https://schema.org/Address)                                                                                | M                  | Y           |
| owner                  | Array of references to Person(s) or Organization(s) | An array containing a JSON encoded sequence of characters referencing the unique Ids of the owner(s).

 Related to a Schema.org person or organization.

 <https://schema.org/Person>
 <https://schema.org/Organization>                                                                                | M                  | Y           |
| occupier               | Array of references to Person(s) or Organization(s) | An array containing a JSON encoded sequence of characters referencing the unique Ids of the occupiers(s).

 Related to a Schema.org person or organization.

 <https://schema.org/Person>
 <https://schema.org/Organization>                                                                                | M                  | Y           |
| refSubscriptionService | Array of Reference                                  | An array containing a JSON encoded sequence of characters of the unique Ids of the subscription service(s) related to this building.         | O                  | Y           |
| floorsAboveGround      | Number                                              | The number of floors above ground level in this building.                                                                                | O                  | Y           |
| floorsBelowGround      | Number                                              | The number of floors below ground level in this building.                                                                                | O                  | Y           |
| description            | Text                                                | An optional description of the entity.                                                                                | O                  | Y           |
| mapUrl                 | URL                                                 | A URL to a mapping service which shows the location of the building.                                                                         | O                  | Y           |
| notes                  | Array of Text                                       | Free format notes relating to the building e.g. published occupants, opening hours etc.                                                      | O                  | Y           |

#### Building JSON

The JSON code can be downloaded from:

<https://gist.github.com/GSMADeveloper/4994b9f4f6907a9a96bdb499899cc27f>
```json
{
  "id": "f95c06e3-776e-4a57-9b00-a85e3da145c1",
  "type": "Building",
  "dateCreated": {
    "value": "2016-08-08T10:18:16Z",
    "type": "DateTime"
  },
  "dateModified": {
    "value": "2016-08-08T10:18:16Z",
    "type": "DateTime"
  },
  "source": {
    "value": "http://www.example.com",
    "type": "URL"
  },
  "dataProvider": {
    "value": "OperatorA",
    "type": "Text"
  },
  "refBuildingType": {
    "value": "8b1f2bf0-5093-4182-ad4b-224182bb3b9f",
    "type": "Reference"
  },
  "category": [
    "House"
  ],
  "containedInPlace": {
    "value": {
      "type": "Polygon",
      "coordinates": [
        [100,0],
        [101,0],
        [101,1],
        [100,1],
        [100,0]
      ]
    },
    "type": "geo:json"
  },
  "location": {
    "value": {
      "type": "Polygon",
      "coordinates": [
        [100,0],
        [101,0],
        [101,1],
        [100,1],
        [100,0]
      ]
    },
    "type": "geo:json"
  },
  "address": {
    "type": "PostalAddress",
    "value": {
      "addressLocality": "London",
      "postalCode": "EC4N 8AF",
      "streetAddress": "25 Walbrook"
    }
  },
  "owner": [
    "cdfd9cb8-ae2b-47cb-a43a-b9767ffd5c84",
    "1be9cd61-ef59-421f-a326-4b6c84411ad4"
  ],
  "occupier": [
    "9830f692-7677-11e6-838b-4f9fb3dc5a4f"
  ],
  "refSubscriptionService": [
    "b4fb8bff-1a8f-455f-8cc0-ca43c069f865onService1",
    "55c24793-3437-4157-9bda-667c9e1531fc"
  ],
  "floorsAboveGround": {
    "value": 7,
    "type": "Number"
  },
  "floorsBelowGround": {
    "value": 0,
    "type": "Number"
  },
  "description": {
    "value": "Office block",
    "type": "Text"
  },
  "mapUrl": {
    "value": "http://www.example.com",
    "type": "URL"
  },
  "notes": {
    "value": "Intelligent entry barrier system, intelligent air conditioning units",
    "type": "Text"
  }
}
```

repository: sj-doyle/HarmonisedEntityDefinitions

repo_name: sj-doyle/HarmonisedEntityDefinitions


text:
# Appraiser's BFF API

Appraiser's BFF is a web app designed to provide local fair market value estimates (FMV) for homes in LA County, California. The data science portion of the app is a separately hosted Flask app that functions as an API that the backend communicates with to generate FMV estimates.

Inital data exploration, data cleaning, and model training were completed in a Jupyter notebook. The model was then pickled so that it could be deployed with the Flask app. The Flask app reads in JSON data, coverts it to a numpy array, and then feeds it to the model to generate a prediction, which is then returned as JSON. It also makes a request to the Zillow API so that results can be compared.

## Demo video
https://www.youtube.com/watch?v=wup1IUjhlKI

repository: appraisers-bff/ML-API

repo_name: appraisers-bff/ML-API


text:
## Nomad jobs

This folder contains the nomad jobs running on [Nomad](https://nomad.int.xcalar.com)

    $ export NOMAD_ADDR=https://nomad.int.xcalar.com
    $ nomad job run hdfs.nomad
    $ nomad job run hdfs.nomad
        ==> Monitoring evaluation "c133ef4d"
        Evaluation triggered by job "hdfs"
        Evaluation status changed: "pending" -> "complete"
        ==> Evaluation "c133ef4d" finished with status "complete"

repository: varlogtim/xcalar-infra

repo_name: varlogtim/xcalar-infra