text:
## What is HackDroid?

Hackdroid is a collection of pentesting and security related apps for android. The applications are divided into different categories so you can easily download any application from any category and use them for penetration testing and ethical hacking.

- Android Apps: 250+ apps in 20+ categories like wifi, hid, MITM, sniffing, etc.
- OS / Platform: hacking operating system (ROM) and platforms for android.
- Blog: useful articles related to hacking with android.

## Some important things that you should take care of before starting :

- Most applications will require root permissions so you can install Magisk to root your device or you can also search on Google or XDA Forum for how you can root your device.

- Never use your primary device for hacking because it is possible that, the creators of the application or those who modified it have already put malware on it to steal your private data. so you will think that with the help of this application you will hack something, but instead of that, you are being hacked.

- Most apps will be outdated but I try my best to provide the latest version of the application asap.

- I don't have copyright for any application. the copyright of all applications supports their owners.

 I'm sharing all this information keeping in mind the purpose of penetration testing and ethical hacking, not illegal hacking activity so please don't misuse.

## Apps Categories :

 - Anonymity
 - App Store
 - Call & SmS
 - CryptoCurrency
 - Cryptography
 - DDoS
 - Forensics
 - HID Attack
 - Learning
 - MITM
 - Networking
 - Pentesting
 - People & File Search
 - Remote Access
 - Router
 - Scripting
 - Security
 - Sniffing
 - Spy Camera
 - System Apps
 - Terminal
 - Web
 - Whatsapp
 - Wireless

### Download Hackdroid.apk : Coming Soon

***Happy Hacking !!!***

repository: luojunqiang/hackdroid

repo_name: luojunqiang/hackdroid


text:
---
hrs_structure:
  division: '1'
  volume: '7'
  title: '20'
  chapter: '352'
  section: 352-29
type: hrs_section
tags:
  - Government
menu:
  hrs:
    identifier: HRS_0352-0029
    parent: HRS0352
    name: 352-29 Termination of director's right to supervise person
weight: 26170
title: Termination of director's right to supervise person
full_title: 352-29 Termination of director's right to supervise person
---
**§352-29 Termination of director's right to supervise person.** (a) The authority of the director to supervise the conduct of a person who has been committed to the director's care, unless such authority shall be sooner terminated pursuant to this chapter or chapter 571, shall cease:

(1) At the time of sentencing for any subsequent offense for which the committed person has been waived pursuant to section 571**-**22 and has been convicted by a court of competent criminal jurisdiction;

(2) At the expiration date of the order of commitment issued unless the director has, prior to such expiration date, sought and obtained from the court an extension of such order;

(3) Whenever the director, prior to the termination otherwise of such order, determines that the purposes of such order have been achieved in the case of a person under age eighteen; provided that if the commitment order reserves the prior approval of the family court for any discharge before termination, the director shall obtain approval of the court for a discharge; or

(4) Whenever the director, prior to the termination otherwise of such order, determines that the purposes of such order have been achieved in the case of a person committed to a term extending beyond the person's eighteenth birthday and obtains court approval prior to discharge.

(b) The director, in each case described in subsection (a)(2), (3) and (4) of this section, shall immediately notify the person, the court, the police department of the county where the committed person resided before commitment, and, if a minor, the person's parent or guardian of the termination of the director's supervision over such person, provided that in cases covered by subsection (a)(1), the sentencing court shall provide such notification including notice to the director. [L 1980, c 303, pt of §8(1); am L 1981, c 134, §1; am L 1997, c 325, §4]

Revision Note

In subsection (a)(1) and (2), "or" deleted pursuant to §23G-15.

license: MIT

repository: SamMade/BlueAndKrabby

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: SamMade/BlueAndKrabby


text:
# National Cyber Scholarship Competition (NCS) - Spring 2021

* **Category:** Networking Medium 01 (NM01)
* **Points:** 250pts
* **Author:** [Mobmaker](https://github.com/Mobmaker55)

## Challenge

> You are given the address `cfta-nm01.allyourbases.co`, and you are to retrieve data from port `8017`.

## Solution
Step one: communicate with the remote address.
> `netcat cfta-nm01.allyourbases.co 8017`

![](../images/prescript.PNG)\
Seeing this information, we know that we have to do something with those characters.
Those characters are, in fact, escaped unicode characters.\
For example, putting`\x47\x57\x45\x57\x4D\x51` into "escaped unicode to text" gives us `GWEWMQ`.
Putting this back into the `netcat` instance, however, returns an interesting result:\
![](../images/tooslow.PNG)\
From this, it is determined we would need a script.
Python's `socket` utility is quite resourceful for connecting with the server quickly.

Step Two: begin scripting a solution.
```
import socket

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

host = "cfta-nm01.allyourbases.co"
port = 8017

sock.connect((host, port))
print(str(sock.recv(4096)))
```
And we have a connection! The script prints back exactly what we'd want, those escaped unicode characters.
Now, to make these escaped unicode characters not-escaped, you need to use `str.decode()` on the text.\
Python 3 was being difficult, so Python 2 was used instead (this only worked in my favor half of the time).
Using Python 2, the bottom two lines became:
```
sock.connect((host, port))
raw = str(sock.recv(4096))
print(raw)
# This causes issues in Python 3
thaw = raw.decode('unicode-escape')
print(thaw)
sock.send(thaw)
print(str(sock.recv(4096)))
```
At this point, you would think that you are almost done. However, there were a few issues that were left to work out.
Due to how Python 2's implementation of `socket.send` worked, there was no "newline" or `'\n'` on send.\
As I didn't know this, I spent an hour debugging for no gain. After adding a line to fix that, there was one more issue.
The only response I was getting from the server was `'\n'`.\
I thought the game was mocking me, but it turns out there was a different cause.
Server-side communication sends more than one line, with the second line being about half a second later.
To capture both of these, the last two lines became:
```
#Make sure to put this at the top
import time

sock.send(thaw)
sock.send('\n')
print(str(sock.recv(4096)))
time.sleep(0.5)
print(str(sock.recv(4096)))
```
With this new solution, the Flag was obtained successfully! The full script can be found [here](../assets/NM01.py)!\
![](../images/pythonflag.PNG)

```
FLAG: o[hex]=>i[ascii]=:)
```

branch_name: refs/heads/main


text:
Title: Pushl v0.2.13
Tag: pushl
Date: 2019-12-01 21:10:13-08:00
Entry-ID: 711
UUID: 29ecf448-bbfd-5902-9524-900171e78bcf

I've released a new version of [Pushl](https://github.com/PlaidWeb/Pushl).

Changes since the last version:

* Added support for tracking entry URL changes
* Finally got around to adding type annotations and static analysis

.....

There are three ways in which an entry URL may change:

1. The entry item's link in the feed changed, and the old link now redirects

    Previously, Pushl would try retrieving the old URL, would get redirected to the new URL, and then would only send updates for any target URLs which changed, coming from the new URL. It would also see the new URL as a separate entry and send out pings from it. At best, this meant that there would be duplicated pings from the old and new URLs.

    Now, it sees that the source URL has changed and re-sends all of the old pings from the old URL, which lets the endpoint know that the URL has changed and should be updated. (It also sends a fresh set of pings from the new URL, which will at least theoretically be ignored by the endpoint, if it's implemented correctly.)

2. The entry item's link in the feed changed, and the old link now generates an error

    This path hasn't changed at all; Pushl saw the old URL as a deletion, and the new one as an addition, and either way would send out pings for all targets from both URLs.

3. The feed linked to it via a redirection URL (such as a short link or a tracking link), and the redirection changed

    Previously, Pushl would not see this as as change at all in the entry, and would not send out any updates at all for old targets. This causes all sorts of potential failures not worth enumerating.

    Now, it sees that the destination changed, and re-sends all pings from the old target URL, telling the endpoint to update them.

    *However,* this has now introduced a bug which I didn't realize until writing up this explanation: it only works if the old redirected URL also redirects to the new entry URL, in which case it behaves like case 1 above. If the old URL now errors, this will appear as a deletion to the endpoint, and all of the mentions go away -- and Pushl won't ever try to re-send them.

    ~~So, I've already made a [bugfix](https://github.com/PlaidWeb/Pushl/commit/17fd5ac24f4cb50384d3d8289619ea932b680ff2) (which will go out in the next Pushl release, whenever that is) where the pings are always sent from the original URL in the feed. This way, it's up to the endpoint to see that the redirection updated. This puts the onus on the endpoint to be able to track changes in redirections in the source URL, or always use the source URL verbatim even if it's a redirection. Either way, Pushl is trying its hardest to do the right thing in a tricky situation.~~

    ==Update:== I rolled back that bugfix, because it had the much worse effect of breaking `rel="canonical"`. A better solution would be to [re-send the old pings from the old URL](https://github.com/PlaidWeb/Pushl/issues/37) instead. Which is now implemented and tested working.

In an ideal world, case 3 simply wouldn't happen, but unfortunately, a lot of feeds do this for various reasons. Feedburner is particularly egregious about it, but a lot of blogging platforms do it naturally; Tumblr, for example. And, heck, it's easy to configure Publ to do that too (and it always does this for unauthorized posts, as part of the privacy model).

Anyway. Consider this fix my day 1 effort for the [IndieWeb 2019 Challenge](https://beesbuzz.biz/blog/3640-My-IndieWeb-Challenge-2019-aspirations).

repository: PlaidWeb/publ-site

gha_language: JavaScript

gha_license_id: MIT

repo_name: PlaidWeb/publ-site


text:
# TaxJar Sales Tax API for Go

Golang client for Sales Tax API v2. For the REST documentation, please visit [http://developers.taxjar.com/api](http://developers.taxjar.com/api).

Forked from the work done by Matt Drollette [taxjar-go](https://github.com/MDrollette/taxjar-go)

repository: CompleteSet/taxjar-go

repo_name: CompleteSet/taxjar-go


text:
# withState
## Description
Passes two additional props to the base component: a state value, and a function to update that state value.

## API
```
withState(
  propName     : string,
  setterName   : string,
  initialValue : any
) : Function;
```

## Example
```jsx
import {
  linkEvent
} from 'inferno';

import {
  compose,
  withState
} from 'incompose';

const inc = (props) => {
  props.setCount(props.count += 1);
};

const dec = (props) => {
  props.setCount(props.count -= 1);
};

const Counter = (props) => (
  <div>
    <h1>count : {props.count}</h1>
    <button onClick={linkEvent(props, dec)}>-</button>
    <button onClick={linkEvent(props, inc)}>+</button>
  </div>
);

/**
 * with state creates 2 new props on the component props
 * props.count		-	contains the value (1 is set as default value)
 * props.setCount	-	contains the setter function
 */
const withCounterState = withState('count', 'setCount', 1);

/**
 * with compose all the extended functions are composed BEFORE Counter
 * gets rendered. Please not that order matters.
 */
export default compose(
  withCounterState,
)(Counter);
```

repository: ZoltanDalmadi/incompose

repo_name: ZoltanDalmadi/incompose


text:
---
layout: post
title: "`case`"
permalink: "/case/"
tags: [bash]
---

http://ss64.com/bash/case.html

echo -n “Enter the name of an animal: “
read ANIMAL
echo -n “The $ANIMAL has “
case $ANIMAL in
horse | dog | cat) echo -n “four”;;
man | kangaroo ) echo -n “two”;;
*) echo -n “an unknown number of”;;
esac
echo ” legs.”`

Ok, gotta start learning this sweet syntax.


text:
---
title: Generic methods supported
description: Management of generic methods for form fields
extends: _layouts.documentation
section: content
locate: en
folder: fields
---

# Generic methods supported

In this section, we will see the generic methods supported by **Belich**. These methods can be used in most of the form fields (although there are always exceptions).

The generic methods currently supported are:

- `asHtml()`
- `addClass()`
- `autocompleteOff()`
- `autocompleteOn()`
- `autofocus()`
- `data()`
- `defaultValue()`
- `disabled()`
- `displayUsing()`
- `dusk()`
- `help()`
- `info()`
- `id()`
- `maxlength()`
- `name()`
- `pattern()`
- `placeholder()`
- `prefix()`
- `readonly()`
- `resolveUsing()`
- `sortable()`
- `suffix()`
- `textAlign()`

Let's see a complete example:

```php
/**
 * Get the fields displayed by the resource.
 *
 * @param  \Illuminate\Http\Request  $request
 * @return Illuminate\Support\Collection
 */
public function fields(Request $request) {
    return [
        Text::make('Email', 'email')
            ->addClass('text-blue', 'font-bold')
            ->data('url', 'http://url.com')
<EMAIL_ADDRESS>            ->disable()
            ->dusk('dusk-email')
            ->help('Enter a valid email')
            ->info('Important info')
            ->id('email_id')
            ->maxlength(100)
            ->name('email_name')
            ->placeholder('my email')
            ->pattern('[a-z]{1,15}')
            ->readonly()
            ->autocompleteOff()
    ]
}
```

Should show:

```html
<label>Email</label>
    <input type="text" class="text-blue font-bold" data-url="http://url.com<EMAIL_ADDRESS>disabled="disabled" dusk="dusk-email" id="email_id" maxlength="100" name="email_name" placeholder="my email" pattern="[a-z]{1,15}" autocomplete="off" readonly/>
<div class="help">Enter a valid email</div>
```

>**Important**: The `help()` and `info()` fields allow the direct use of `html`, so we could do something like this:

```php
Text::make('Email', 'email')
    ->help('<h1>Use a valid email!</h1>, more info: <a href="http://info.net">more info</a>'),
```

Finally, we would lack the methods: `asHtml()` and `sortable()`.

The first one, allows us to return the results to the views: `index` and `show`as a `HTML`: without escaping, and therefore, executed as `HTML` code.

The second method (`sortable()`), tells us that in the view `index`, the column of the table corresponding to this field can be ordered from highest to lowest or vice versa.

The methods: `sortable()`, `readonly()` and `disabled()`, support Boolean values, that is, we can add conditions to be displayed. Of course, if the value is not Boolean, it will give error.

As an example:

```php
/**
 * Get the fields displayed by the resource.
 *
 * @param  \Illuminate\Http\Request  $request
 * @return Illuminate\Support\Collection
 */
public function fields(Request $request) {
    return [
        Text::make('Email', 'email')
            ->readonly(auth()->user()->isAdmin())
    ]
}
```

We also have a method called: `displayUsing()`, which will allow us to format the value of our field (in the views: `index` and `show`), making a callback and allowing us to manipulate the value of the field.

This method would be used as follows:

```php
/**
 * Get the fields displayed by the resource.
 *
 * @param  \Illuminate\Http\Request  $request
 * @return Illuminate\Support\Collection
 */
public function fields(Request $request) {
    return [
        Text::make('Email', 'email')
            ->displayUsing(function($value) {
                return strtolower($value);
            })
    ]
}
```

Returning the result in lowercase, allowing us to format the result of the field. **In other words, we can access the value of the field and manipulate it**. If what we want is to access to the model, we must use the method: `resolveUsing()`.

The syntax is identical to `displayUsing()`:

```php
/**
 * Get the fields displayed by the resource.
 *
 * @param  \Illuminate\Http\Request  $request
 * @return Illuminate\Support\Collection
 */
public function fields(Request $request) {
    return [
        Text::make('Email', 'email')
            ->resolveUsing(function($model) {
                return $model->relationship->item;
            })
    ]
}
```

The methods `suffix()` and `prefix()`, will allow us to add a prefix or suffix to the value of the field. For example, if the field shows us an amount money, and we want to add the dollar symbol:

```php
/**
 * Get the fields displayed by the resource.
 *
 * @param  \Illuminate\Http\Request  $request
 * @return Illuminate\Support\Collection
 */
public function fields(Request $request) {
    return [
        Text::make('Email', 'email')
            ->suffix('$')
    ]
}
```

Will returns:

```
1298.55$
```

the methods `suffix()` and `prefix()`, support a second value. This field is a Boolean that allows us to indicate if we want a blank space before the suffix or after the prefix.

```php
/**
 * Get the fields displayed by the resource.
 *
 * @param  \Illuminate\Http\Request  $request
 * @return Illuminate\Support\Collection
 */
public function fields(Request $request) {
    return [
        Text::make('Email', 'email')
            ->suffix('$', $space = true)
    ]
}
```

Will returns:

```
1298.55 $
```

>Remember that the methods: `displayUsing()`, `suffix()` and `prefix()` only affect the views: `index` and `show`. The rest of the views are not affected by these methods, and will show them without modifications.

>The method `resolveUsing()`, not seen in form views, only seen in views: `index` and `show`.

There is also a method to align the internal content of a form field. To do this, we will use the method `textAlign()`. The supported values are: `left`, `center`,`right` and `justify`. This method, what it does is add an alignment class to the field:

```php
$field->textAlign('left');
```

Will be shown:

```html
<input class="text-left">
```

Actually, it is an alias of the `addClass()` method, so we would get the same like this:

```php
$field->addClass('text-left');
```

repository: daguilarm/belich-documents

gha_language: HTML

repo_name: daguilarm/belich-documents


text:
# [Examining the Scriptures Daily](http://alexa.amazon.com/#skills/amzn1.echo-sdk-ams.app.6e280a28-a384-46a0-aa00-d7c3e1649183)
![4.6 stars](../../images/ic_star_black_18dp_1x.png)![4.6 stars](../../images/ic_star_black_18dp_1x.png)![4.6 stars](../../images/ic_star_black_18dp_1x.png)![4.6 stars](../../images/ic_star_black_18dp_1x.png)![4.6 stars](../../images/ic_star_half_black_18dp_1x.png) 46

To use the Examining the Scriptures Daily skill, try saying...

* *Alexa, open my daily text for today*

* *Alexa, open my daily text and read me next Monday's text*

* *Alexa, open my daily text for July first two thousand sixteen*

My Daily Text in Alexa is for everyone who wants to start a day the right way.
Many find it advantageous to listen to it in the morning. Then they can reflect on such thoughts throughout the day. Discussing the text as a family is most beneficial.

This skill uses content from the Jehovah's Witnesses website.
http://wol.jw.org/en/wol/h/r1/lp-e (the booklet "Examining the Scriptures 2016 / 2017").
All rights for this content belong to the Watch Tower Bible and Tract Society of Pennsylvania.

This skill is a personal project based on the booklet "Examining the Scriptures 2016 / 2017".
Please accept this version in the spirit of which it was built.

***

### Skill Details

* **Invocation Name:** my daily text
* **Category:** null
* **ID:** amzn1.echo-sdk-ams.app.6e280a28-a384-46a0-aa00-d7c3e1649183
* **ASIN:** B01FB6A31I
* **Author:** Synapse Research Systems
* **Release Date:** May 23, 2016 @ 19:08:35
* **Privacy Policy:** https://www.jwdailytext.com/PrivacyPolicy.txt
* **Terms of Use:** https://www.jwdailytext.com/TermsConditions.txt
* **In-App Purchasing:** No


text:
# recycling-react-carousel

This carousel is designed to handle a large number of slides efficiently. It was originally created for my internal project and I decided to publish it. At the moment it almost fits my needs, but I will try to expand its functionality whenever possible.

Under the hood this component uses 2 awesome libraries: [react-spring](https://github.com/react-spring/react-spring) and [react-use-gesture](https://github.com/pmndrs/react-use-gesture).

### Installation

```bash
npm install recycling-react-carousel
```

### Basic usage

```jsx
import React, { useState } from 'react';
import RCarousel, { useCursor } from 'recycling-react-carousel';

const BasicCarousel = () => {
  const { props, nextBtnProps, backBtnProps } = useCursor();
  const slides = [1, 2, 3, 4, 5, 6].map((data) => <div key={data}>{data}</div>);

  return (
    <div>
      <button {...backBtnProps}>back</button>
      <RCarousel
        displayAtOnce={3}
        style={{ height: 250 }}
        itemWrapperStyle={{ padding: 10 }}
        {...props}
      >
        {slides}
      </RCarousel>
      <button {...nextBtnProps}>next</button>
    </div>
  );
};

export default BasicCarousel;
```

It is up to you how to style it.

repository: demidyuk/recycling-react-carousel

gha_language: TypeScript

repo_name: demidyuk/recycling-react-carousel


text:
---
layout: post
title: 'metcalfe's law, its limitations, and the next wave of facebook exodus'
date: '2017-08-31T07:13:00-04:00'
tags:
- metcalfe's law
- facebook
- capitalism
- networks
---

metcalfe's law "states that the value of a telecommunications network is proportional to the square of the number of connected users of the system (n^2)" [(wiki)](https://en.wikipedia.org/wiki/Metcalfe%27s_law#Limitations). when i first heard about this law on some blog post [curtis](interactioninstitute.org/author/curtis/) wrote, it made intuitive sense to me. later, when looked up the official definition, the image below clarified what my intuition told me.

![phone's in a network illustrating metcalfe's law](https://upload.wikimedia.org/wikipedia/commons/thumb/1/1d/Metcalfe-Network-Effect.svg/476px-Metcalfe-Network-Effect.svg.png)

when i heard about this law, i thought first about cell phones and then about facebook. in the early days of my usage, both of those tools had some coolness factor or basic intrinsic value. over time, though, as more and more friends got them, the experience and utility of each became even better.

however, lately i'm wondering if it's possible to be too connected. i've though this out before and i very much believe it's possible, but it's showing up in a new way right now. right now, i have 2-3 friends a week telling me they're mostly over facebook. several folks have put up statuses saying that they're not going to use it and why. other friends have just told me in person why facebook has become just a timesuck and a tool that drains them more than it brings them happiness or joy from connecting with friends.

![visual of idealized version of metcalfe's law overlaid on a bell curve](http://i.imgur.com/k4bkX3G.jpg)

i feel like facebook, as it is eventually (if not also initially) with all things capitalism touches, is going in a bad direction. it's becoming bloatware (too many features) as well as just falling into the common trap of not thnking through the full implications of what happens when your intervention in society is **too** successful. this is a hard thing to foresee, for sure, but it happens. facebook was great for me when it was a tool i used to connect with the college friends. of course, over time as its userbase grew, it was cool to also connect with teachers and friends from elementary school and conferences/convenings and whatever. but now that original use value has changed.

and that's just one example of how it's changed. i think at this point, it's changed so much that it's not actually clear what value facebook provides for most people.

anyway, i'm rambling. my point is: i think metcalfe's law has some limitations. maybe, like many things, it's actually a bell curve situation. maybe at the beginning the value of the network grows with its square, but eventually it tapers off and even begins to diminsh...

ps - the question is, will i be a part of this exodus?

<!-- hyperlink bank -->

**words / writing / post-processing**
411w / 13min / 7min


text:
# DROP Sample Treasury Futures Package

DROP Sample Treasury Futures demonstrates UST Futures Eligibility Definitions Valuation.

## Class Components

 |     Sample     | Source | Output |
 |----------------|--------|--------|
 | Contract Definitions | [Java](https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/sample/treasuryfutures/ContractDefinitions.java) | [DROP](https://github.com/lakshmiDRIP/DROP/blob/master/drop/org/drip/sample/treasuryfutures/ContractDefinitions.drop) |
 | Contract Eligibility Settlement Definitions | [Java](https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/sample/treasuryfutures/ContractEligibilitySettlementDefinitions.java) | [DROP](https://github.com/lakshmiDRIP/DROP/blob/master/drop/org/drip/sample/treasuryfutures/ContractEligibilitySettlementDefinitions.drop) |
 | Exchange Traded Option Definitions | [Java](https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/sample/treasuryfutures/ExchangeTradedOptionDefinitions.java) | [DROP](https://github.com/lakshmiDRIP/DROP/blob/master/drop/org/drip/sample/treasuryfutures/ExchangeTradedOptionDefinitions.drop) |
 | Expiry Delivery Trading Dates | [Java](https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/sample/treasuryfutures/ExpiryDeliveryTradingDates.java) | [DROP](https://github.com/lakshmiDRIP/DROP/blob/master/drop/org/drip/sample/treasuryfutures/ExpiryDeliveryTradingDates.drop) |
 | UST 02Y | [Java](https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/sample/treasuryfutures/UST02Y.java) | [DROP](https://github.com/lakshmiDRIP/DROP/blob/master/drop/org/drip/sample/treasuryfutures/UST02Y.drop) |
 | UST 05Y | [Java](https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/sample/treasuryfutures/UST05Y.java) | [DROP](https://github.com/lakshmiDRIP/DROP/blob/master/drop/org/drip/sample/treasuryfutures/UST05Y.drop) |
 | UST 10Y | [Java](https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/sample/treasuryfutures/UST10Y.java) | [DROP](https://github.com/lakshmiDRIP/DROP/blob/master/drop/org/drip/sample/treasuryfutures/UST10Y.drop) |
 | UST 30Y | [Java](https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/sample/treasuryfutures/UST30Y.java) | [DROP](https://github.com/lakshmiDRIP/DROP/blob/master/drop/org/drip/sample/treasuryfutures/UST30Y.drop) |
 | UST ULTRA | [Java](https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/sample/treasuryfutures/USTULTRA.java) | [DROP](https://github.com/lakshmiDRIP/DROP/blob/master/drop/org/drip/sample/treasuryfutures/USTULTRA.drop) |

## Hierarchy

Module  = Product Core Module

Library = Fixed Income Analytics

Project = DROP API Construction and Usage

Package = UST Futures Eligibility Definitions Valuation

## DROP Specifications

 * Main                     => https://lakshmidrip.github.io/DROP/
 * Wiki                     => https://github.com/lakshmiDRIP/DROP/wiki
 * GitHub                   => https://github.com/lakshmiDRIP/DROP
 * Repo Layout Taxonomy     => https://github.com/lakshmiDRIP/DROP/blob/master/Taxonomy.md
 * Javadoc                  => https://lakshmidrip.github.io/DROP/Javadoc/index.html
 * Technical Specifications => https://github.com/lakshmiDRIP/DROP/tree/master/Docs/Internal
 * Release Versions         => https://lakshmidrip.github.io/DROP/version.html
 * Community Credits        => https://lakshmidrip.github.io/DROP/credits.html
 * Issues Catalog           => https://github.com/lakshmiDRIP/DROP/issues
 * JUnit                    => https://lakshmidrip.github.io/DROP/junit/index.html
 * Jacoco                   => https://lakshmidrip.github.io/DROP/jacoco/index.html

repository: fairhopeweb/DROP

repo_name: fairhopeweb/DROP


text:
# sa_plugin_demo #
_sa_plugin_demo_ is a demo plugin library for [ShellAnything](https://github.com/end2endzone/ShellAnything). It can be used as a base code for new plugins. This demo provides new validation attributes called `demo1` and `demo2` for showing or enabling menus.

# Usage #

Declare the plugin as the following:
```xml
<plugins>
  <plugin path="${application.path}\sa_plugin_demo.dll"
          conditions="start_time;end_time"
          description="This plugin defines new visibility/validity attributes." />
</plugins>
```

# Building #

This section explains how to compile _sa_plugin_demo_ example.

To build the project, execute the following steps:

1) Open a command prompt and navigate to the plugin source directory.
2) Enter the following commands:

```cmake
mkdir build
cd build
cmake -DCMAKE_GENERATOR_PLATFORM=x64 -DCMAKE_INSTALL_PREFIX="path\to\plugin\installation\directory" -DCMAKE_PREFIX_PATH="path\to\shellanything\installation\directory" ..
cmake --build . --config Release -- -maxcpucount /m
cmake --build . --config Release --target INSTALL
cmake  ..
```

Please refer to [install_shellanything_plugins.bat](https://github.com/end2endzone/ShellAnything/blob/master/ci/windows/install_shellanything_plugins.bat) for details about _sa_time_plugin_ plugin.


text:
# unacceptable_not_found
Re-writes the command_not_found handler in bash and zsh

##You must heed my INSTRUCTIONS!!!!!!!!

Run the addsource.sh script with your preferred shell to source the handler when you login.

Sound works by default on Mac OS X (tested on 10.10 & 10.11).
Sound on Linux requires mpg123.

To install on Debian/Ubuntu:

sudo apt-get install mpg123

For Fedora 22/23:

sudo dnf install mpg123

Results should match the video below on either OS:

https://youtu.be/gfChLvMZkG0

gha_language: Shell


text:
---
templateKey: practice-page
title: backlog filter
subtitle: Identify and action high complexity backlog items in any context.
date: 2022-05-24T05:12:19.659Z
authors:
  - john-remoteaf
tags:
  - validate
  - value
mobiusTag: discovery
icon: /images/remoteaf-backlog-filter.png
whatIs: >-
  The backlog filter is a tool used to surface high risk work items. This canvas
  looks at work through the lens of complexity by focusing on the teams'
  knowledge. Understanding which work items need attention allows managers to
  intervene.

  In most cases, this will lead to identifying and prioritizing the most unknown work higher in the backlog. Doing this will de-risk the backlog and improve predictability for the team. As with all remote:af patterns, the backlog filter is designed to be effective regardless of context and can be used across many types of teams.

  The remote:af backlog filter has been made available to the public for use. All copyright in the canvas is owned by Remote Agility Framework Pty Ltd and used under license.

  Based on the work of Kim Ballestrin and Dr Saeed Shalbafan
whyDo: >-
  Common signals for using the remote:af backlog filter are;

  * the team is exploring new work that has arrived in its backlog

  * the team needs to deliver work outside their regular expertise

  * the team has struggled with forecasting work effectively

  * the team needs to communicate when things are likely to be delivered and/or the risk to delivery forecasts
howTo: >-
  **Preparation:**

  * Download a copy of the remote:af backlog filter using the link provided

  * Upload the template to your preferred virtual whiteboard tool or print it out for in person workshops

  **Filter the backlog:**

  1. Explore the work backlog with the team

  2. Individually and silently map work items in the team backlog to the matrix according to:

     * the involvement required from outside the team
     * how well the team understands how to do the work
  3. Explore any disagreements, if consensus can’t be reached err on the side of caution

  **Actions:**

  * Action the work based on how each item maps to the matrix

  * * Proceed
    * Plan
    * Probe
mediaGallery:
  - link: https://d33wubrfki0l68.cloudfront.net/c4462488f8d5d91a69f6b0b90dc5f0c03139deb0/5724c/static/8ea46e003f93c4ac5392f32fdf32d0dc/27a09/remoteaf-backlog-filter.png
resources:
  - link: https://drive.google.com/file/d/1A22kWVWZJLJPSiYHkChny3anHJb7oeI-/view?usp=sharing
    linkType: web
    description: click here to download your copy of the backlog filter
  - link: https://www.researchgate.net/publication/335491299_A_framework_to_manage_uncertainty_in_early_planning_of_projects_an_ICT_project
    linkType: web
    description: Original paper by Kim Ballestrin and Dr. Saeed Shalbafan
difficulty: easy
participants: []
---

repository: openpracticelibrary/openpracticelibrary

repo_name: openpracticelibrary/openpracticelibrary


text:
![](https://img.shields.io/badge/license-ISC-Green)

# Sample README

## Description
This is a test to produce a sample file.

## Table of Contents
- [Installation](#Installation)
- [Usage](#Usage)
- [Contributing](#Contributing)
- [Test](#Test)
- [License](#License)
- [Questions](#Questions)

## Installation
```node index.js```

Invoke the generator with the above command.

## Usage
Answer all 10 prompts displayed on screen.

## Contributing
I welcome contributions.

## Test
Feel free to feedback.

## License
ISC

## Questions
Follow me on [GitHub: rubybassi](https://github.com/rubybassi)

If you have any additional questions, simply email me at<EMAIL_ADDRESS>and i'll respond as soon as possible.

repository: rubybassi/handy-README-generator

repo_name: rubybassi/handy-README-generator


text:
# Calculation module documentation and guidelines

**requirements:**

- Having GIT command installed on your computer
- Having a Python version >= 3.5
- Having a Gdal version >= 2.0

**Definition** :

A calulation Module (CM) is a plugin for hotmaps toolbox which is able to extend toolbox functionality.

**How to connect a CM into the Hotmaps toolbox?**

```
*Registration and hearthbeat:

_______________________________
│                    │        │      1. Once in the network, CM won't stop trying to register until it get a response from the HTAPI.
│         HTAPI      │ CM DB  │      2. Once registered HTAPI will request the CM in order to know if it's still alive or not.
│                    │        │      3. While alive a CM can be computed from the frontend using the interface GUI it describe on its SIGNATURE.
│____________________│________│
                        │    │
                        │    │
                        │    │    _________
                        │    └── │   CM2  │
                        │        │________│
                        │  __________
                        └─│  CM1    │
                          │________ │

```

The CM can run on its own, but when it is on the same network as the Hotmaps toolbox API (HTAPI), it will be automatically detected.
Using Celery queue to register, HTAPI contains heartbeat that will Check at anytime if a calculation is running or not. That means the achitecture for CMs is working in realtime

**Calculation module regitration**

the HTAPI will retrieve the CM SIGNATURE and modify the frontend to allow the user to use the CM and modify the user interface with the inputs it needs to be ran.

**Retrieving the calculation module base for my CM from git**:

Find bellow the architecture of the CMs. All the CMs inherit from the base calculation module (cm base)

```
*GIT Repository architecture*:

___________
│ CM base │ upstream
│_________│
  │
  │
  │   __________
  └── │   CM1  │ origin
  │   │________│
  │
  │
  │   __________
  └── │   CM2  │ origin
      │________│

```
0. Create a repository on github named name_of_my_module, create a folder on your computer named it "name_of_my_module",
go inside your new folder create. Please let the repository of your new module empty until you retrived the base_calculation_module code.

1. Using git command on your terminal be ready to code:
```bash

git init
git remote add origin https://github.com/HotMaps/name_of_my_module.git # add a remote link to my repository
git remote add upstream https://github.com/HotMaps/base_calculation_module.git # add a remote link to the base calculation module (BCM)# .
git pull upstream master
git add .
git commit -m "first commit" #update changes
git push -u origin master # push the changes (minimum code for run) .

```

2. Start coding, switch branch from master to develop
```bash
git checkout -b develop
```

3. After coding

```bash
git add .
git commit -m "message to describe the changes"
git push origin develop

```

4. Updating code with the base calculation module (BCM) code

```bash
git pull upstream master

```

If you encounter any issue like GIT conflict please contact CREM.

5. Release a version of my CM

After testing your calculation module you can update the release branch(master branch)
```bash
git fetch && git checkout master # retrieved master branch
git merge develop # update the changes from develop to master
git push origin master # push changes on master branch
```
now tag your version then take a snapshot on your current version
```bash
git fetch && git checkout master # retrieved master branch
git merge develop # update the changes from develop to master
git push origin master # push changes on master branch
```

### Application Structure:

```
cm/
├── app/
│   ├── api_v1/
│   │    ├── __init__.py
│   │    ├── calculation_module.py
│   │    ├── errors.py
│   │    └── transactions.py
│   │
│   │
│   │── decorators/
│   │   ├── __init__.py
│   │   ├── caching.py
│   │   ├── json.py
│   │   ├── paginate.py
│   │   └──rate_limit.py
│   │
│   │
│   ├── __init__.py
│   │── constant.py
│   │── logging.conf
│   │── utils.py
│   │
│   │
│   │── config/
│   │      ├── __init__.py
│   │      ├── development.py
│   │      ├── production.py
│   │      └── transactions.py
│   │
│   │── tests/
│   │      ├── __init__.py
│   │      ├── test_client.py
│   │      └── test.py
│   ├── __init__.py
│   ├── aync_consumer.py
│   ├── Dockerfile.py
│   ├── gunicorn-config.py
│   ├── requirements.txt
│   ├── run.py
│   ├── run_cm_services.sh
│   └── test.py
│
├── .gitiginore
├── docker-compose-der.yml
├── LICENCE
└── README.md

*the place of the main function for the calculation module *
```
* `app/requirements.txt` - The list of Python framework  (PyPi) requirements.
* `app/api_v1/calculation_module.py ` - this is the place where the function for the CM belongs
* `app/api_v1/transactions.py ` contains all the requests that allows to interacted with the CM
* `app/constant.py ` contains the constants of the applications the most important constant is the SIGNATURE

***************************************************

*****INPUTS CALCULATION MODULE FIELD*****

In this section it's explain how to handle the differents kind of inputs

**SIGNATURE INPUTS** :

Signature describes the calculation module needed parameters and how to use it. This signature can be found in **constants.py** file. the SIGNATURE must be modified by the developer this signature can be divided into 2 parts,
see bellow:

    INPUTS_CALCULATION_MODULE=  [
        { 'input_name': 'Reduction factor',
          'input_type': 'input',
          'input_parameter_name': 'multiplication_factor',
          'input_value': 1,
          'input_unit': 'none',
          'input_min': 1,
          'input_max': 10
            , 'cm_id': CM_ID
          },
        { 'input_name': 'Blablabla',
          'input_type': 'range',
          'input_parameter_name': 'bla',
          'input_value': 50,
          'input_unit': '',
          'input_min': 10,
          'input_max': 1000,
          'cm_id': CM_ID
          }
    ]

    SIGNATURE = {
        "category": "Buildings",
        "cm_name": CM_NAME,
        "layers_needed": [
            "heat_density_tot"
        ],
        "type_layer_needed": [
                "heat",
            ],
        "cm_url": "",
        "cm_description": "this computation module allows to divide the HDM",
        "cm_id": CM_ID,
        'inputs_calculation_module': INPUTS_CALCULATION_MODULE
    }

***SIGNATURE FIELDS***

The signature contained some parameters that are needed by the main webservice HTAPI for the data exchange:

**category:**

This is the category of the calculation module

**cm name:**

This is the name of the calculation module that will be displayed on the frontend Graphical user interface(GUI)

**layers needed:**

Layers needed to run the calculation module

```bash
    "layers_needed": [
           "heat_density_tot",
           "cdd_curr_tif",
           "gfa_nonres_curr_density",
           "gfa_res_curr_density_lau"
       ],
```
 When HTAPI will be compute a CM, it will send a python dictionnary named  inputs_raster_selection in which there is a key the name of the layer for example heat_curr_density_tot and a value the name of the files generated by HATPI
 by using this value CM can directly retrieve a clipped dataset

 **vectors needed:**

 Vectors needed to run the calculation module
 please find an example input vectors_needed:
 ```bash
     "vectors_needed": [
            "heating_technologies_eu28",

        ],
 ```
  Now if you request "inputs_vector_selection['heating_technologies_eu28']" the output will be

   ```bash

 {"heating_technologies_eu28": [{
                                   "specific_investment_costs": "355",
                                   "total_annual_net_efficiency": "0.93",
                                   "price_index_households_appliances": "0.93",
                                   "incost_cagr": "None",
                                   "datetime": "01.01.2015 00:00",
                                   "year": "2015",
                                   "id": "10",
                                   "labour_cost_index_construction_sector": "0.80",
                                   "type_of_building": "existing SFH",
                                   "fixed_o_and_m_unit": "EUR/kW",
                                   "technical_lifetime": "20",
                                   "k2_fixed_o_and_m": "-0.56",
                                   "k2_specific_investment_costs": "-0.51",
                                   "k1_fixed_o_and_m": "49",
                                   "fixed_o_and_m": "13",
                                   "equipment_cost_share_unit": "%",
                                   "total_annual_net_efficiency_unit": "%",
                                   "k1_specific_investment_costs": "1793",
                                   "specific_investment_costs_unit": "EUR/kW",
                                   "equipment_and_maintenance_index": "0.84",
                                   "nuts0_id": "FR",
                                   "fk_time_id": "179862",
                                   "variable_o_and_m_unit": "EUR/kWh",
                                   "country": "France",
                                   "installation_cost_share": "0.30",
                                   "installation_cost_share_unit": "%",
                                   "variable_o_and_m": "None",
                                   "technical_lifetime_unit": "years",
                                   "fk_nuts_gid": "265",
                                   "nuts_id": "FR",
                                   "equipment_cost_share": "0.70",
                                   "heating_equipment": "Oil boiler"
                                 },
                                 {
                                   "specific_investment_costs": "76",
                                   "total_annual_net_efficiency": "0.92",
                                   "price_index_households_appliances": "0.93",
                                   "incost_cagr": "None",
                                   "datetime": "01.01.2015 00:00",
                                   "year": "2015",
                                   "id": "38",
                                   "labour_cost_index_construction_sector": "0.80",
                                   "type_of_building": "existing MFH",
                                   "fixed_o_and_m_unit": "EUR/kW",
                                   "technical_lifetime": "20",
                                   "k2_fixed_o_and_m": "-0.56",
                                   "k2_specific_investment_costs": "-0.51",
                                   "k1_fixed_o_and_m": "49",
                                   "fixed_o_and_m": "2",
                                   "equipment_cost_share_unit": "%",
                                   "total_annual_net_efficiency_unit": "%",
                                   ...
   ```

  When HTAPI will be compute a CM, it will send a python dictionnary named  inputs_vector_selection in which there is a key the name of the vector requested for example heating_technologies_eu28 and an array of json dictionnary as a value the name of the files generated by HATPI

**type layers needed:**

 this parameter(type_layer_needed) will need the type of information needed as input for instance for the gross_floor_area type the user can choose on the frontend GUI gfa_nonres_curr_density or gfa_res_curr_density
 #TODO: type_layer_needed will replace the layers_needed in the futur
 also it allows to handle symbologie
 here the type different input type
- heat,
- gross_floor_area,
- building_volume,
- solar_optimal_total (for the case of one layer in the project the type will be the name of the layer).
layers type allows to handle custom layer from the user and the ablility to chose from multiple layer with the same type

 **example:**
 ```bash
      clipped_heat =  inputs_raster_selection["heat"]
      clipped_gfa =  inputs_raster_selection["gross_floor_area"]
      clipped_solar_optimal_total=  inputs_raster_selection["gross_floor_area"]

 ```

**cm description:**

Description of purpose of the CM that will be displayed on the frontend GUI.

It aims to compute the photovoltaic energy potential and the financial feasibility of a selected area by considering:
- the installation of new PV systems on a percentage of building footprint
- the financial feasibility of new plants

The output of the module are:

- the total cost of covering the selected area with PV panels [currency]
- the total yearly energy production [MWh/year]
- the Levelized Cost of Energy  [currency/kWh]
- the most suitable roofs for PV energy production

Starting from the available area and the kind of PV technology the module computes the PV energy production under the following assumptions:
-optimal inclination of the PV system
- area of the PV modules equal to the percentage of the building footprint chosen by the user
- unique selected technology for all the installed PV systems
- default system efficiency equal to 0.75

These assumptions have been done in order to consider a planning phase for a region and not the design of a specific PV systems.

The yearly energy output is  derived by considering the spatial distribution of yearly solar radiation on the building footprint.

The PV energy production is computed for a single representative plant as:

with

The most representative installed peak power for a PV system is an input of the module.
Consequently, the surface covered by a single plant is computed as:

with

The default module efficiency at Standard Test Conditions is 0.15.

The total number of plants is computed as:

with

The total energy production of the selected area is equal to:

The most suitable area is computed by considering the roofs with higher energy production.
The energy production of each pixel considers to cover only a fraction of the roofs equal to f_roof. The integral of the energy production of the most suitable area is equal to the total energy production of the selected area.

**cm id:**

Unique identifier that is defined by the WP4 leader

**authorized scale:**

 This parameter will disable all scales not declared in it. Please find bellow the different scales allowed:
   - NUTS 0
   - NUTS 1
   - NUTS 2
   - NUTS 3
   - LAU 2
   - Hectare

  ```bash
        "authorized_scale":["NUTS 2","NUTS 0","Hectare"],

  ```

***CALCULATION MODULE GRAPHIC USER INTERFACE INPUTS***

The purpose of this part is giving the ability to the developer to build is own user interface.
 the JSON payload will be use to modify automatically the user interface. it's an array of inputs. see bellow what is an input object

 **Input name:**

 it is the name of the CM that will be displayed on the frontend (User interface)

 **Input type:**

 The input is the graphical control element that user need to access enter data. There are five possible inputs, see https://getuikit.com/docs/form for more information about the implementation of the frontend GUI
 - input:

 ![alt text][logoinput]

This is a textbox where the user can type a value.
 - select:

 ![alt text][logoselect]

 **exemple:**
 ```python
  {
    'input_name': 'select your input',
    'input_type': 'select',
    'input_parameter_name':'item name' ,
    'input_value': ["List item 1",
                    "List item 2",
                    "List item 3",
                    "List item 4"],
    'input_unit': 'none',
    'input_min': 'none',
    'input_max': 'none', 'cm_id': CM_ID
     },

  ```

 This is a drop down menu that allows the user to choose one value from a list.
 - radio :

   ![alt text][logoradio]

 It allows the user to choose only one of a predefined set of mutually exclusive options.
 - checkbox

 ![alt text][logocheckbox]

 This graphical component allows the user to choose between one of two possible mutually exclusive options

[logocheckbox]: https://upload.wikimedia.org/wikipedia/commons/2/2f/Checkbox2.png   ""
 - range

 ![alt text][logorange]

The range is graphical control element with which a user may set a value by moving an indicator.

[logorange]: https://upload.wikimedia.org/wikipedia/commons/e/ed/Slider_%28computing%29_example.PNG ""

**Input Parameter Name:**

 It's the input parameter name the CM needs to retrieve for calculations

**input value:**

It's a default value for the input that will be displayed on the user interface

**input min & max:**

This is the range of the input value needed, this will prevent from mistake in the calculation

**input priority**

This parameter allows to categorize input in the user inteface. the value needed is an integer from 0-4
- 0 =>imput always visible
- 1 to 4 => the input is on a dropdown menu

```python
             {'input_name': 'Reduction factor',
              'input_type': 'input',
              'input_parameter_name': 'multiplication_factor',
              'input_value': 1,
              'input_priority': 0,
              'input_unit': 'none',
              'input_min': 1,
              'input_max': 10, 'cm_id': CM_ID  # Do no change this value
              },

```

*******************************
***CALCULATION MODULE OUTPUTS:***

The purpose of this part is to give developers the ability to build differents king of output(graphic,layers,indicators).

**example:**

```python
            "result": {
                "indicators": [
                    {"unit": "MWh","name": "Heat demand indicator with a factor divide by 2","value": 281244.5},
                    {"unit": "MWh","name": "Heat demand indicator with a factor divide by 3","value": 187496.3},
                    {"unit": "MWh","name": "Heat demand indicator with a factor divide by 4","value": 140622.25}
                ],
                "name": "test_calculation_module",
                "raster_layers":[
                             {"name": "heat density layer divide by 2","path": output_raster_path_tif_1,"type": "heat"},
                             {"name": "heat density layer divide by 3","path": output_raster_path_tif_2,"type": "heat"},
                             {"name": "gross floor area layer divide by 4","path": output_raster_path_tif_3,"type": "gross_floor_area"},

                             ],
                "vector_layers":[
                                  {"name": "heat density layer divide by 2","path": 'e6caa1dc-e3c0-4968-977a-197c8fe29d32.zip',"type": "heat"},
                                  {"name": "heat density layer divide by 3","path": 'e6caahkiuu-e3c0-4968-977a-197c8fe29d32.zip',"type": "heat"},
                                  {"name": "heat density layer divide by 4","path": 'e6caa1dc-e3c0-4968-977a-hhzthfefe.zip',"type": "heat"},
                                      ],

                "csv_files":[
                            {"name": "heat_load_1","path": output_csv_file_1},
                            {"name": "heat_load_2","path": output_csv_file_2},
                            {"name": "heat_load_1","path": output_csv_file_3},
                                ],
                 "graphics": [{
                         "type": "bar",
                         "data": {
                             "labels": ["Default dataset","FR569","DE562","AT130","FR125"],
                             "datasets": [
                                 {
                                     "label": "Calculation module chart",
                                     "backgroundColor": [ "#3e95cd","#8e5ea2","#3cba9f","#e8c3b9","#c45850" ],
                                     "data": [2478,5267,734,784,433]
                                 }
                             ]
                         }
                     },{
                           "type": "bar",
                           "data": {
                               "labels": ["Default dataset","FR569","DE562","AT130","FR125"],
                               "datasets": [
                                   {
                                       "label": "Calculation module chart",
                                       "backgroundColor": [ "#3e95cd","#8e5ea2","#3cba9f","#e8c3b9","#c45850" ],
                                       "data": [2478,5267,734,784,433]
                                   }
                               ]
                           }
                           },]

            }
```

***INDICATORS OUTPUT:***
---------------------------

In transaction.py file The CM provider can modify the output in order to display as many indicator as he wants on the frontend
this indicators will be displayed on the result panel of the frontend.

**Structure of the indicator output:**
---------------------------------------

- **indicators (Array):** Array of indicators
    - **unit (string):** Unit of the indicator
    - **name (string):** Name of the indicator
    - **value (number):** Value of the indicator

**example:**

```python
            "result": {
                "indicators": [
                    {"unit": "MWh","name": "Heat demand indicator with a factor divide by 2","value": 281244.5},
                    {"unit": "MWh","name": "Heat demand indicator with a factor divide by 3","value": 187496.3},
                    {"unit": "MWh","name": "Heat demand indicator with a factor divide by 4","value": 140622.25}
                ],
                "name": "test_calculation_module"
            }
```
***LAYERS OUTPUT:***
---------------------

 **Structure of raster as output:**
 ---------------------------------

 - **raster_layers (Array):** Array of raster layer
     - **name (string):** Name to be displayed on the frontend
     - **path (string):** path generated of the geotif file
     - **type (string):** this is the type of layer generated

 the path must be generated on the first lines of calculation() function found in calculation_module.py using the function generate_output_file_tif() which need the output directory as an argument
 **exemple:**
  ```python
            output_raster_path_tif_1 = generate_output_file_tif(output_directory)
            output_raster_path_tif_2 = generate_output_file_tif(output_directory)
            output_raster_path_tif_3 = generate_output_file_tif(output_directory)
  ```
  All the layers outputs must be retrieved and added on the *raster_layers* array after they have been created by the calculation module provider functions

 ```python
             "raster_layers":[{"name": "heat density layer divide by 2","path": output_raster_path_tif_1,"type": "heat","symbology": [
                                                                                {"red":50,"green":50,"blue":50,"opacity":0.5,"value":"50","label":"50MWh"},
                                                                                {"red":100,"green":150,"blue":10,"opacity":0.5,"value":"150","label":"150MWh"},
                                                                                {"red":50,"green":50,"blue":50,"opacity":0.5,"value":"200","label":"200MWh"},
                                                                                {"red":50,"green":50,"blue":50,"opacity":0.5,"value":"250","label":"250MWh"}},
                              {"name": "heat density layer divide by 3","path": output_raster_path_tif_2,"type": "heat","symbology": [
                                                                                {"red":50,"green":50,"blue":50,"opacity":0.5,"value":"50","label":"50MWh"},
                                                                                {"red":100,"green":150,"blue":10,"opacity":0.5,"value":"150","label":"150MWh"},
                                                                                {"red":50,"green":50,"blue":50,"opacity":0.5,"value":"200","label":"200MWh"},
                                                                                {"red":50,"green":50,"blue":50,"opacity":0.5,"value":"250","label":"250MWh"}},
                              {"name": "gross floor area layer divide by 4","path": output_raster_path_tif_3,"type": "gross_floor_area"},

 ```
 **Generating a custom symbology**
 --------------------------------
 if an unknown type of layer is generated(layer that is not of type heat,gross_floor_area, building_volume,solar_optimal_tota ) a new field must be created,
 the field **"symbology"** and the raster must be set on type "custom". the field symbology must contains the RGB colors, which are values between 0 - 255, the opacity which are  values between 0 - 1,  the value of range  defined and the label of range  defined

  ```python
              "raster_layers":[
                               {"name": "district heating coherent areas","path": output_raster1, "type": "custom", "symbology": [{"red":250,"green":159,"blue":181,"opacity":0.8,"value":"1","label":"DH Areas"}]}]

  ```

  **Structure of vector as output:**
  ----------------------------------

  - **vector_layers (Array):** Array of vector layer
      - **name (string):** name to be displayed on the frontend
      - **path (string):** path generated of the vector file
      - **type (string):** this is the type of layer generated

  The path must be generated on the first lines of calculation() function found in calculation_module.py using the function generate_output_file_shp() which need the output directory as an argument

 **exemple:**
```python
    output_shp_1 = generate_output_file_shp(output_directory)

```
   Before to send back result to the HTAPI, the CM must generate a zip file, that will be handled by the HTAPI. To do so the CM provider must provide the following function and will write the output on the json array
```python
     output_shp_zipped_1 = create_zip_shapefiles(output_directory, output_shp_1)

```

   All the layers outputs must be retrieved and added on the *vector_layers* array after they have been created by the calculation module provider functions and compress with the function create_zip_shapefiles()

  ```python
              "vector_layers":[
                                {"name": "wwtp_1","path": output_shp_zipped_1,"type": "wwtp"},
                                {"name": "wwtp_2","path": output_shp_zipped_2,"type": "wwtp"},
                                {"name": "hwwtp_3","path": output_shp_zipped_3,"type": "wwtp"},
                                    ],

  ```
 **Structure of csv as output:**
 ---------------------------------

 - **csv_files (Array):** Array of csv layer
     - **name (string):** Name to be displayed on the frontend
     - **path (string):** path generated of the csv file

 the path must be generated on the first lines of calculation() function found in calculation_module.py using the function generate_output_file_csv() which need the output directory as an argument
 **exemple:**
  ```python
            output_csv_path_1 = generate_output_file_csv(output_directory)
            output_csv_path_2 = generate_output_file_csv(output_directory)
            output_csv_path_3 = generate_output_file_csv(output_directory)
  ```
  All the csv outputs must be retrieved and added on the *csv_files* array after they have been created by the calculation module provider functions

 ```python
             "csv_files":[
                              {"name": "csv 1","path": output_csv_path_1},
                              {"name": "csv 2","path": output_csv_path_2},
                              {"name": "csv 3","path": output_csv_path_3}],

 ```
***CHARTS OUTPUT:***
---------------------

In this part it's describes how to create graphics that will be displayed of the frontend

 **Structure of charts as output:**
 ----------------------------------

- **charts (Array):** Array of chart

    - **type (string) :**  this is the type of graphic that will be display Type of chart (possible values: 'bar', 'line', 'radar', 'pie', 'polarArea', 'bubble')

        - **line:** A line chart or line graph is a type of chart which displays information as a series of data points called 'markers' connected by straight line segment

        ![alt text][line]

        - **bar:** A bar chart or bar graph is a chart or graph that presents categorical data with rectangular
   bars with heights or lengths proportional to the values that they represent.
        ![alt text][bar]
        - **radar:** A radar chart is a way of showing multiple data points and the variation between them.
   ![alt text][radar]
        - **pie:** A pie chart is divided into segments, the arc of each segment shows the proportional value of each piece of data..
    ![alt text][pie]

        - **polarArea:** Polar area charts are similar to pie charts, but each segment has the same angle - the radius of the segment differs depending on the value..

    ![alt text][polarArea]

- **xLabel:** Define the text displayed on x-axis,
- **yLabel:** Define the text displayed on y-axis (ex:Heat power(MW)),
- **data:** Contains label and datasets
    - **labels (string[]) :** x axis labels

    -   **datasets (Array):** set of data with there configuration
        -  **label (string) :** Serie's label
        -  **backgroundColor (string[]) :** Background color of each value to display
        -  **data (number[]) :** Each value for the serie

```json

    "charts": [{
        "type": "bar",
         "xLabel": "Horizontal series label",
         "yLabel": "Vertical series label name",
        "data": {
            "labels": ["Default dataset","FR569","DE562","AT130","FR125"],
            "datasets": [
                {
                    "label": "Calculation module chart",
                    "backgroundColor": [ "#3e95cd","#8e5ea2","#3cba9f","#e8c3b9","#c45850" ],
                    "data": [2478,5267,734,784,433]
                }
            ]
        }
    },{
      "type": "bar",
      "data": {
          "labels": ["Default dataset","FR569","DE562","AT130","FR125"],
          "datasets": [
              {
                  "label": "Calculation module chart",
                  "backgroundColor": [ "#3e95cd","#8e5ea2","#3cba9f","#e8c3b9","#c45850" ],
                  "data": [2478,5267,734,784,433]
              }
          ]
              }
          },]

```

******************************************************************************************

***Retriving list of layers available for CM***

please find in the link the list of layers available as input for a  CM (ressource name column):

https://docs.google.com/spreadsheets/d/1cGMRWkgIL8jxghrpjIWy6Xf_kS3Dx6LqGNfrCBLQ_GI/edit#gid=1730959780

*******************************************************************
**Calculation Module development GUIDELINES in local environement**

**1. Install requirements.**

Install all the libraries needed to run the CM
```bash
cd cm
pip install -r requirements.txt
```

**2. Run the CM API:**

run the api in a terminal
```bash
cd cm
python run.py
```

the documentation can be check at http://<IP_ADDRESS>:5001/apidocs/)

**3. Test my CM :**

 before writing writing any line of code test the existing one,
run the test in a new terminal

```bash
cd cm
python test.py
```

**4. Modify constant.py :**

if the test is ran and ok the constants.py file must be changed in order to
- give a CM name
- build  frontend user interface of the CM
- assign a unique CM_ID (please contact the research center of Martigny (CREM))
- modify the SIGNATURE
- etc

**5. Write your code on calculation_module.py :**

the calculation_module.py is a bridge between the CM function and the CM architecture
all the new code must be added on the directory **my_calculation_module_directory**

***Running my CM with docker***:

In the root directory:
```bash
docker-compose up -d --build
```
***Running my CM in my computer(local environment):***

```bash
cd cm
python run.py
```
***Implementing my CM***

1. modify the signature in constant.py to describe your CM

2. modify the input parameter name in transaction.py in the input of calculation() from **calculation_module.py**

3. add main function in calculation() functions (calculation_module.py )

```json

```

[polarArea]: https://i0.wp.com/belajarphp.net/wp-content/uploads/2016/10/chartsJs-pola-area-chart.png?w=810&ssl=1 ""
[pie]: https://i2.wp.com/belajarphp.net/wp-content/uploads/2016/10/chartjs-pie-dognut-charts.png?ssl=1 ""
[radar]: https://i2.wp.com/belajarphp.net/wp-content/uploads/2016/10/chartJs-radar-chart.png?ssl=1 ""
[line]: https://i1.wp.com/belajarphp.net/wp-content/uploads/2016/10/chartJS-line-chart.png?ssl=1 ""
[bar]: https://i0.wp.com/belajarphp.net/wp-content/uploads/2016/10/chartJS-bar-chart-1.png?w=946&ssl=1 ""
[logoinput]: https://upload.wikimedia.org/wikipedia/commons/thumb/2/21/Textbox2.gif/220px-Textbox2.gif ""

[logoselect]: https://upload.wikimedia.org/wikipedia/commons/d/d1/Drop-down_list_example.PNG ""
[logoradio]: https://upload.wikimedia.org/wikipedia/commons/c/cb/Radio_button.png ""

gha_language: Python

gha_license_id: NOASSERTION


text:
# CeejiCommonLibrary

# NOTE: THIS PROJECT IS DISCONTINUED AND READ-ONLY.

A thread-friendly, high-performance .NET common helper library with small submodules, mono support included, production-ready

## Production-ready Libraries

These libraries are production-ready, and can use unconditionly:

* Ceeji.Log.Redis
* Ceeji.Unmanaged
* Ceeji.Win32
* Ceeji.Core (CeejiCommonLibrary, with Log, UI, Data and Network namespace)

**IMPORTANT** Other project is under development, do not use in production environment. Any pull requests are welcome.

Join in our team (Wuhan EasyLearning Co.Ltd) by visit http://www.bzbx.com.cn/jobs/

repository: ceeji/CeejiCommonLibrary

repo_name: ceeji/CeejiCommonLibrary


text:
---
title: Virtual input
---

Virtual input is a high-level input system, built on top of existing **Input** functionality shown earlier. The main difference between the two systems is that virtual input abstracts the concept of buttons and axes into virtual objects, instead of referencing them directly.

This allows the application to use virtual buttons and axes without needing to know actual hardware buttons/axes the user is using. This means same virtual buttons can be used for multiple input devices (e.g. keyboard & gamepad), as well as allow the user to manually re-map keys with no additional gameplay logic.

All virtual input is handled through the @bs::VirtualInput class, accessible through @bs::gVirtualInput(). You'll notice it shares a very similar interface with **Input**, with the only difference being how we represent buttons and axes.

Before we explain individual aspects, lets see a quick working example to give you a rough idea:
~~~~~~~~~~~~~{.cpp}
// Set up input configuration that maps virtual keys to actual hardware keys
SPtr<InputConfiguration> inputConfig = gVirtualInput().getConfiguration();

//// Virtual button named "Forward" maps to W and Up arrow keys
inputConfig->registerButton("Forward", BC_W);
inputConfig->registerButton("Forward", BC_UP);

// (Somewhere else in the app) Use the virtual key
VirtualKey forwardKey("Forward");

if(gVirtualInput().isButtonDown(forwardKey))
	gDebug().logDebug("Moving forward...");
~~~~~~~~~~~~~

# Input configuration
Before we can use the virtual input system, we must first create a set of virtual buttons and axes, name them, and map them to actual hardware keys. To do this we require an @bs::InputConfiguration object, which can be retrieved from **VirtualInput** by calling @bs::VirtualInput::getConfiguration().

~~~~~~~~~~~~~{.cpp}
SPtr<InputConfiguration> inputConfig = gVirtualInput().getConfiguration();
~~~~~~~~~~~~~

# Virtual buttons
## Registration
Virtual buttons can be registered by giving them a unique name, and a hardware button code they map to. Any time a particular hardware button is pressed, the virtual button will be reported as pressed as well. New buttons are registered with @bs::InputConfiguration::registerButton().

~~~~~~~~~~~~~{.cpp}
// Register a virtual button named "Forward" that maps to W and Up arrow keys
inputConfig->registerButton("Forward", BC_W);
inputConfig->registerButton("Forward", BC_UP);
~~~~~~~~~~~~~

You can also unregister an existing button by calling @bs::InputConfiguration::unregisterButton().

~~~~~~~~~~~~~{.cpp}
inputConfig->unregisterButton("Forward");
~~~~~~~~~~~~~

These mappings can be registered/unregistered during runtime, meaning you should use this functionality to provide input remapping for your users.

## Usage
Once your virtual button has been registered you can use it by creating a @bs::VirtualButton object. This object expects the button name you provided when registering the button.

~~~~~~~~~~~~~{.cpp}
VirtualButton forwardKey("Forward");
~~~~~~~~~~~~~

> It is preferable you create virtual buttons during start-up and them save them for later use, instead of creating them every time you use them.

Created button can be used in **VirtualInput** with following events, similar to **Input** events:
 - @bs::VirtualInput::onButtonDown - Triggered whenever a button has been pressed.
 - @bs::VirtualInput::onButtonUp - Triggered whenever a button has been released.
 - @bs::VirtualInput::onButtonHeld - Triggered every frame while a button is being held.

~~~~~~~~~~~~~{.cpp}
Vector3 position(BsZero);

// Callback method that triggers when any virtual button is being held down
auto handleButtonHeld = [&](const VirtualButton& btn, UINT32 deviceIdx)
{
	// If user holds down W or Up arrow, move forward
	if (btn == forwardKey)
		position.z += 5.0f;
};

// Connect the callback to the event
gVirtualInput().onButtonHeld.connect(handleButtonHeld);
~~~~~~~~~~~~~

And you can also use the following polling methods. Again, similar to **Input**:
 - @bs::VirtualInput::isButtonDown - Checks has the button been pressed this frame. Only valid for one frame.
 - @bs::VirtualInput::isButtonHeld - Checks is the button currently being held. This is valid for the first frame the button is pressed, and for any following frame until it is released.
 - @bs::VirtualInput::isButtonUp - Checks has the button been released this frame. Only valid for one frame.

~~~~~~~~~~~~~{.cpp}
Vector3 position(BsZero);

// Move 5 units forward for every frame while W or Up arrow is pressed
if(gVirtualInput().isButtonHeld(forwardKey))
	position.z += 5.0f;
~~~~~~~~~~~~~

# Virtual axes
## Registration
Virtual axes allow you to map hardware axes (e.g. gamepad analog stick or mouse movement) to virtual axes. They are registered similarily to buttons, though **InputConfiguration** by calling @bs::InputConfiguration::registerAxis.

You are required to give it a unique name, and fill out @bs::VIRTUAL_AXIS_DESC structure that describes the axis. The structure allows you to choose which hardware axes to reference, as well as set other properties like sensitivity, inversion or dead zones.

~~~~~~~~~~~~~{.cpp}
// Map gamepad right stick X axis and mouse X axis to a virtual axis for looking left/right
VIRTUAL_AXIS_DESC desc;
desc.type = (int)InputAxis::RightStickX | (int)InputAxis::MouseX;

inputConfig->registerAxis("LookLeftRight", desc);
~~~~~~~~~~~~~

> Note that unlike with buttons you shouldn't call **VirtualInput::registerAxis** multiple times for the same virtual axis. Instead provide all hardware axes in the **VIRTUAL_AXIS_DESC::type** by ORing them together.

Existing virtual axes can be unmapped by calling @bs::InputConfiguration::unregisterAxis.

~~~~~~~~~~~~~{.cpp}
inputConfig->unregisterAxis("LookLeftRight");
~~~~~~~~~~~~~

## Usage
Once you wish to use the virtual axis you construct a @bs::VirtualAxis object by providing it with the name of the axis.
~~~~~~~~~~~~~{.cpp}
VirtualAxis lookLeftRightAxis("LookLeftRight");
~~~~~~~~~~~~~

Then you can use @bs::VirtualInput::getAxisValue() to retrieve the current value of the axis.

~~~~~~~~~~~~~{.cpp}
// Rotate the camera left/right depending on the axis
Degree lookAngle(0.0f);

//...

lookAngle += (Degree)gVirtualInput().getAxisValue(lookLeftRightAxis);
~~~~~~~~~~~~~

repository: cwmagnus/bsf

repo_name: cwmagnus/bsf


text:
# redux-reducer-actions
**Redux-reducer-actions** is a Redux store enhancer which allows action generation in reducer. It is quite useful to concentrate most of logic in reducer rather than split it to effects.
You can use this library in your project to avoid verbose plumber code and make it clean and testable.

The mental model is that a saga is like a separate thread in your application that's solely responsible for side effects. redux-saga is a redux middleware, which means this thread can be started, paused and cancelled from the main application with normal redux actions, it has access to the full redux application state and it can dispatch redux actions as well

# redux-saga flow
```
+------------+       +--------------+
|            |       |              |
|  action    +------>+    reducer   +---------+           +-----+
|            |       |              |         |     +---->+     |
+-----^------+       +--------------+         |     |     +-----+
      |                                +------v-----+----+
      |                                |                 |    +------+
      |                                | saga middleware +---->      |
      |                                |                 |    +------+
+-----+------+        +------------+   +------+-----+----+
|            |        |            |          |     |    +-------+
|    UI      <--------+   store    <----------+     +---->       |
|            |        |            |                     +-------+
+------------+        +------------+

```
# redux-reducer-actions

**redux-reducer-actions** is an Redux store enhancer which allows action generation in reducer. That approach allows to concentrate most logic in one place - reducer.

Due to that fact that reducers are pure functions, it is extremely easy to test this logic and keep code clean and concise.

Actions, processed by **redux-reducer-actions** wouldn't go into the store. Rather they will be dispatched in the next event loop throw the standard Redux flow.

# redux-reducer-actions flow

```
                                    +-------------------------------------------------------+
                                    |                                                       |
                                    |                                                       |
                                    |                                                       |
+---------------+            +------v-------+                     newState: {               |
|               |            |              |                        ...,                   |
|   action      +------------>   reducer    +-----------------+      actions: [actions],    |
|               |            |              |                 |   }                         |
+-------^-------+            +------^-------+                 |                             |
        |                           |                         |                             |
        |                           |             +-----------v-----------+                 |
        |                           |             |                       |                 |
        |                           |             |                       |                 |
        |                           |             |    redux              |        +--------+---------+
        |                           |             |    reducer            |        |                  |
        |                           |             |    actions            |        | dispatch         |
        |                           |             |                       +--------> actions          |
        |                           |             |    enhancer           |        | in new event loop|
        |                           |             |                       |        |                  |
        |                           |             |                       |        +------------------+
        |                           |             |                       |
        |                           |             +-----------+-----------+
        |                           |                         |
        |                           |                         |
+-------+---------+         +-------+-------+                 |    newState: {
|                 |         |               |                 |       ...,
|    UI           <---------+   store       +<----------------+    }
|                 |         |               |
+-----------------+         +---------------+

```

# example task: load extra info from API

## Redux code (common)

```
// action creators
export const GET_ITEM = 'GET_ITEM';
export const GET_ITEM_SUCCESS = GET_ITEM_SUCCESS';

export const getItem = (id) => ({
  type: GET_ITEM,
  request: {
     url: `/api/item/${id}`,
     method: 'GET',
     meta: { id },
  },
})

export const GET_FILE = 'GET_FILE';
export const GET_FILE_SUCCESS = 'GET_FILE_SUCCESS';

export const getFile = (id) => ({
  type: GET_FILE,
  request: {
     url: `/api/file/${id}`,
     method: 'GET',
     meta: { id },
  },
})
```

## redux-saga code

```
// reducer
export const reducer(state, action) {
  switch(action.type) {
     case GET_ITEM_SUCCESS: {
       return {
         ..state,
         item: action.payload,
       };
     }
     case GET_FILE_SUCCESS: {
       return {
         ..state,
         file: action.payload,
       };
     }
     default:
       return state;
  }
}
```

```
// effects

export function* onGetItem(action) {
  const { payload: { fileId } } = action;
  yield put(getFile(fileId));
}

export function* itemSaga() {
  yield takeEvery(GET_ITEM_SUCCESS, onGetItem);
}

// root saga
export function* rootSaga() {
  yield spawn(itemSaga);
}
```

## redux-saga unit tests

```
define('item saga', ()=>{
  const action = {
    type: GET_ITEM_SUCCESS,
    payload: { fileId: 42 },
  };

  it ('should process GET_ITEM_SUCCESS', ()=> {
    const gen = itemSaga();
    const getState = gen.next().value;
    const nextState = fork(takeEvery, GET_ITEM_SUCCESS, onGetItem);
    expect(getState).toEqual(nextState);
  });

  it ('should fire GET_FILE on GET_ITEM_SUCCESS', ()=> {
    const gen = onGetItem(action);
    const getState = gen.next().value;
    const nextState = put(getFile(fileId));
    expect(getState).toEqual(nextState);
  });
});
```

Cons:
* tests are extremely verbose
* tests are state oriented
* tests are on the same abstract layer as the code

## redux-reducer-actions

```
// reducer
export const reducer(state, action) {
  switch(action.type) {
     case GET_ITEM_SUCCESS: {
       const { payload: { fileId } } = action;
       const actions = [getFile(fileId)];
       return {
         ..state,
         item: action.payload,
         actions,
       };
     }
     case GET_FILE_SUCCESS: {
       return {
         ..state,
         file: action.payload,
       };
     }
     default:
       return state;
  }
}
```

```
// unit tests

define('reducer', ()=>{
  const action = {
    type: GET_ITEM_SUCCESS,
    payload: { fileId: 42 },
  }
  it ('should fire GET_FILE on GET_ITEM_SUCCESS', ()=> {
    const state = {};
    const newState = reducer(state, action);
    expect(state.actions).toBeDefined();
    expect(state.actions.length).toBe(1);
    expect(state.actions[0]).toEqual(getFile(42));
  });
});
```

## redux-reducer-actions: attach to store

```
// createStore
const sagaMiddleware = createSagaMiddleware();

const middlewares = [sagaMiddleware];
// additional middlewares
// ...
const enhancer = applyMiddleware(...middlewares);

const actionEnchancer = createActionsEnhancer({});

const store = createStore(rootReducer, compose(actionEnchancer, enhancer));

sagaMiddleware.run(rootSaga);

export default function configureStore() {
  return {
    store: {
      ...store,
      runSaga: sagaMiddleware.run,
    },
  };
}
```

## redux-reducer-actions: options

```
// log
// log will be used to verbose procecced actions
const isDev = process.env.NODE_ENV !== 'production';
const actionEnchancer = createActionsEnhancer({ log: isDev ? console.log.bind(console) : null });

// startActionType
// all actions which was fired before the startAction will be queried
//     and processed AFTER the start action
const actionEnchancer = createActionsEnhancer({ startActionType: AUTH_SUCCESS });

// schedule will be used to fire actions in new event loop
// default is window.setTimeout
const actionEnchancer = createActionsEnhancer({ schedule: window.setTimeout });
```

# Useful redux libs

* combine-section-reducers
* connected-react-router
* redux-persist
* reselect
* redux-saga-requests

## combine-section-reducers: Use root state

```
import combineSectionReducers from 'combine-section-reducers';

export rootReducer =
combineSectionReducers({
  user,
  item,
  //...
});

```

```
// reducer
export const reducer(state, action, rootState) {
  switch(action.type) {
     case GET_ITEM_SUCCESS: {
       const { payload: { fileId } } = action;
       const { user: { language } } = rootState;
       const actions = [getFile(fileId, language)];
       return {
         ..state,
         item: action.payload,
         actions,
       };
     }
     case GET_FILE_SUCCESS: {
       return {
         ..state,
         file: action.payload,
       };
     }
     default:
       return state;
  }
}
```

# Questions?

https://github.com/paullasarev/redux-reducer-actions.git

MIT License

repository: paullasarev/redux-reducer-actions

repo_name: paullasarev/redux-reducer-actions


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

Unspecified vulnerability in db.php in NooMS 1.1 allows remote attackers to conduct brute force attacks against passwords via a username in the g_dbuser parameter and a password in the g_dbpwd parameter, and possibly a "localhost" g_dbhost parameter value, related to a "Mysql Remote Brute Force Vulnerability."

### POC

#### Reference
- http://securityreason.com/securityalert/4289

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

repository: trickest/cve

repo_name: trickest/cve


text:
---
title: VScrollBar
page_title: VScrollBar | WinForms Converter
description: This article explains which standard .NET controls properties are removed and which are replaced with similar equivalents.
slug: winforms/winforms-converter/supported-controls/vscrollbar
tags: covert, winforms, vscrollbar
published: True
position: 1
---

# VScrollBar

The VScrollBar control is changed to [RadVScrollBar]({%slug winforms/track-and-status-controls/scrollbar%}). There are no specific properties that are not converted.

repository: attilaantal/winforms-docs

repo_name: attilaantal/winforms-docs


text:
+++
date = "2016-06-19T21:25:01-07:00"
title = "Sponsor Prospectus"

+++

A new unconference, open space specifically for Open Source Software maintainers. Unlike most conferences, this one will not have any talks. We believe a discussion based conference will have the most benefit to attendees.

We are offering the following sponsorship model which is modeled after that of DevOpsDays:

| Level              | Description                                                                                |
|--------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Host (venue)       | If a company sponsors the venue/food they will be acknowledged as a Host sponsor. Their logo will be directly visible on the main event page, tee-shirts, banners, and badge. |
| Fun (party)        | If a company sponsors a party for the conference they can have their logo on the website, tee-shirts, banners, badges, and everything related to the party itself.            |
| Platinum ($10,000) | 6 included tickets + logo on the website, tee-shirts, banners, and badge.                                                                                |
| Gold ($7,000)      | 4 included tickets + logo on the website, tee-shirts, banners, and badge.                                                                                |
| Silver ($5,000)    | 2 included tickets + logo on the website, tee-shirts, banners, and badge.                                                                                |
| Bronze ($3,000)    | Logo on the website, tee-shirts, banners, and badge.                                                                                |

We are not doing booths because the nature of this event should be the attendee’s not the companies involved. Hopefully the maintainers you send from your company will gain insight into making their daily lives easier which is more valuable than any booth.

Additional à la carte sponsorships are available for lanyard, happy hour, coffee, snacks, and meals and may be purchased in lieu of, or in addition to, the sponsorships above.

If interested in sponsoring please email [organizers@maintainerati.org](mailto:organizers@maintainerati.org).

To get an idea how many people might be interested in this new conference we set up a landing page on https://maintainerati.org and got over 200 submissions over night. In the form we asked (optionally) for people to jot down some ideas on what they wanted to gain from the event. The responses are amazing. Here are some:

> Linux kernel maintainer here, this sounds awesome. topics that I'd like to discuss or learn about:

-	maintainers don't scale, how to fix it: tooling, automation, processes, scaling out, both what works and what's just utter disaster
-	people issues: how to handle assholes, oversized egos, bikeshedding tournaments, burned out maintainer, I-can't-let-go-of-control issues in growing projects and all the other fun stuff
-	scaling out and empowering contributors, without it all crashing down and burning because it's free for all and hey maintainer will catch so I don't have to be careful. various decision processes (committee, benevolent dictator, rough consus, advice process, chaos).

-	how to communicate in issues/PRs when there is an obvious language barrier (a user has difficulty understanding English/French/Chinese/etc)

-	how to say "no" to feature proposals/PRs without hurting people

-	how to moderate discussion on issues

-	how to manage expectations of the users of the project you maintain

-	how to take a "vacation" from maintenance without all users freaking out :(

-	how to gain + onboard new contributors

-	internationalization of the project you maintain

-	how to enforce code/documentation/test standards

-	how to quit being a maintainer without harming your reputation

repository: ghuntley/site

gha_language: CSS

repo_name: ghuntley/site