text:
# DSA Turn Helper

This tools helps you manage DSA(Das Schwarze Auge) turn interactions.

## Helps with:

- Participants
- Initiative
- Health

## Requirements

Somewhat modern browser

## Usage

### Online version

- Open https://voultapher.github.io/dsa-turn-helper/src/dsa-turn-helper.html

### Offline version

- Open https://voultapher.github.io/dsa-turn-helper/src/dsa-turn-helper.html and download the static html page, for example via save as.
- Load the static html page in your browser.

### Example

A quick example of how this tool can be used to assist you in managing a fight
in DSA. First in the Party managing section, you'll want to create parties
appropriate to the fight. Note you can prepare this ahead of time, as it does
not require any fight specific information. Feel free to store and load this
with the 'Load' and 'Download' buttons.

Then once the parties are assembled click on 'All New' in the turn simulation Area.
Changes you make now to the party section will only affect the turn simulation
once you click 'All New' again.

Before the turn simulation can begin, you have the opportunity to enter
initiative roll values for each participant. Once you have entered all the
values you want, click on 'Start'. If a 'INI roll' input has never been changed,
then a random d6 value is assigned for that participants initial initiative roll.

Now that the simulation is set up properly, you'll notice it already sorted
the participants by their base initiative. You are already in the first action
of the battle. The cursor on the left of the participants name shows you
who's action it is currently. Play out the action and adjust health and
initiative values as they change in action 1. Initiative can be changed by
applying effects or by entering a manual value to add, negative numbers are
subtracted. Then step into the next action, by clicking the button with the '>'
symbol. Again play out the action and update the health and initiative values,
in the fields marked with 'H:' and 'I:'. Initiative changes apply at the start
of the next round. Repeat until the fight is over.
You can go back any time and see how the values and initiative order changed
over the course of turns and rounds. But the history is immutable.

### Tips

Should multiple participants have the
same initiative, feel free to differentiate them with non integer number,
like 16.1, which is more than just 16. By for example choosing effect 'Manual'
and adding 0.1.

## Contributing

Please respect the [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md) when contributing.

## Versioning

We use [SemVer](http://semver.org/) for versioning. For the versions available,
see the [tags on this repository](https://github.com/Voultapher/once_self_cell/tags).

## Authors

* **Lukas Bergdoll** - *Initial work* - [Voultapher](https://github.com/Voultapher)

See also the list of [contributors](https://github.com/Voultapher/once_self_cell/contributors)
who participated in this project.

## License

This project is licensed under the Apache License, Version 2.0 -
see the [LICENSE.md](LICENSE.md) file for details.

repository: Voultapher/dsa-turn-helper

repo_name: Voultapher/dsa-turn-helper


text:
# KM AUTOMATIC TRANSLATION

### TABLE OF CONTENTS
* [Introduction](#introduction)
* [How does it work?](#how-does-it-work)
* [GOOGLE SERVICES](#google-services)
    * [Billing information](#billing-information)
    * [API Key](#api-key)
    * [Cloud Translation API](#cloud-translation-api)
* [Prepare your Inbenta Instances](#prepare-your-inbenta-instances)
* [Dependencies](#dependencies)

### Introduction
Inbenta supports [42 languages](https://www.inbenta.com/en/languages-supported/#). Multi-language implementations are very popular among our customers. One of the challenges of multi-language projects is to create and maintain contents across multiple languages. To help our customers with this problem, we have created an application to automatically translate (We have used Google Services. You could choose your choice of the translation service) and create contents across multiple language instances when you create one in your base language.

### How does it work?
This auto-translate application uses translation services such as Amazon Translate to create the translations.

A webhook is created to use the Amazon Translate for translation. Multi-language instances are linked together in the settings of the base instance where the content will be created or edited. When content is saved (both new content & edit content) in the base knowledge instance, this Webhook gets triggered and that sends the content to Amazon Translate and creates respective content in other language instances based on the translated text received from Amazon.

The following is the dynamic settings considered for translation.
* Title
* Answer text
* Alternative titles (if exists)
* Answer text for every user type (as long as the user types ID’s exist in target instance)

In addition to the translation of above-mentioned content attributes, this application also considers the data entered in other content attributes of the original content and saves them as is in all the language instances.

Here is the list of additional content attributes considered:
* Publication date
* Expiration date
* Status
* Use for popular
* Related content
* Categories (as long as the ID exist in the target instance)

### GOOGLE SERVICES
* Login to your Google account through the [Developers Console](https://console.developers.google.com/).

![01](img_instructions/01.png)
* If you have projects previously created, choose one. If you don’t, create a new one by clicking on **Select a project** and then **NEW PROJECT**.

![02](img_instructions/02.png)

![03](img_instructions/03.png)
* Enter a **Project name** and click on **CREATE**.

![04](img_instructions/04.png)

#### Billing information
* In order to start using the Translation API, you need to provide the Billing information. Go to **Billing** located on the left-top menu.

![05](img_instructions/05.png)
* Click on **ADD BILLING ACCOUNT**.

![06](img_instructions/06.png)
* On the next screen, select the **Country**, and accept the **Terms of Service**.

![07](img_instructions/07.png)
* Provide the details requested in Step 2:

![08](img_instructions/08.png)
* Add the payment details.

![09](img_instructions/09.png)

#### API Key
* Once the Billing information is added, create an **API Key**. Go to **APIs & Services**, located on the left-up menu, and then to **Credentials**.

![10](img_instructions/10.png)
* Click on **CREATE CREDENTIALS → API key**.

![11](img_instructions/11.png)
* This automatically creates a new API Key.

![12](img_instructions/12.png)
* Restrict your new key or change the name.

![13](img_instructions/13.png)

#### Cloud Translation API
* The final process is to activate the Translation API. Go to  **APIs & Services → Library **

![14](img_instructions/14.png)
* You should see the main screen for the API Library, where you can search for the existing Google APIs services.

![15](img_instructions/15.png)
* Search for “translation” and click on the first result.

![16](img_instructions/16.png)
* Click on **ENABLE**.

![17](img_instructions/17.png)
* Once you have it enable, you should be able to see the metrics.

![18](img_instructions/18.png)

For further information visit the [Cloud Translation documentation](https://cloud.google.com/translate/docs).
___
### Prepare your Inbenta Instances

Reach out to your Inbenta Point of Contact to enable the following for you:

* **Multilanguage Related Instances** settings.
* Webhook that you create for the translation service. In your main instance go to **Settings -> Static -> On save content webhook**, (this is the ```KM_HEADER_KEY```, needed in the .env file). You will share the following details:

```env
    URL: https://automatic_translations_url.com
    Header Name: Apply-Translation
    Header Value: secretKey|en
```
>NOTE: “Header Value” is a string defined by customer, but is mandatory to add at the end a pipe character ( | ) and the language of the primary instance. Example “xxxxx|en”, “xxxxx|es”, “xxxxx|fr”, etc. For this value avoid the use of #.
The “Header Name” must be “Apply-Translation”

* In the .env file, the following configuration needs to be added:
    * Auth URL for the KM API, given by Inbenta.
    * Header key value (previous step).
    * A "User Personal Secret Token" (```KM_UPST```). [Help Center Instructions](https://help.inbenta.com/en/general/administration/managing-credentials-for-developers/managing-your-ups-tokens/).
    * Api Key and Secret (from **Knowledge Editor API**) of every instance (origin and target instances).
    * Google information (key and url).
* Set all values in the **.env** file:
```env
AUTH_URL =
KM_HEADER_KEY =
KM_UPST =
KM_LANG_LIST = ES,EN
KM_API_KEY_ES =
KM_SECRET_ES =
KM_API_KEY_EN =
KM_SECRET_EN =
GOOGLE_KEY =
GOOGLE_URL =
```

### DEPENDENCIES
This application needs 2 dependencies: `guzzlehttp/guzzle` and `vlucas/phpdotenv` as a Composer dependency.

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# Templates Exercise 2

1. Create a Playbook to configure a BGP peering between the nxos hosts. To do so, create a Jinja2 template that, when rendered, looks similar to that show below.

Where XXXX is four random hex digits that you choose
```
interface Ethernet1/4
  ipv6 address 2001:db8:XXXX:200c::1/64
  no shutdown

router bgp 22
  neighbor 2001:db8:XXXX:200c::2 remote-as 22
    address-family ipv6 unicast
```

You can choose any interface from Ethernet1/1 to Ethernet1/4. You should make variables for any of the items that change in the template. These variables should be added into 'host_vars'.

2. Use the "napalm_install_config" module to send the configuration to the devices. To start, set "commit_changes" and "replace_config" to "False". To confirm that this operation would make a change if set to commit changes, output the diffs to a new directory "diffs". Napalm requires a "provider" argument. Craft this variable in your Play vars or in appropriate group vars files. Note that this provider argument must include an argument "optional_args" which is a dictionary -- in this dictionary there must be a key for "port" with a value of 8443. This 8443 is the nxapi port number.

3. Modify your Playbook to include tags representing each task -- config generation and config push/diff operation. Change the "napalm_install_config" task to set "commit_changes" to "True". Run your Playbook. At the end of the configuration push, you should be able to ping IPv6 from nxos1 to nxos2 and you should have a working BGP session between the two switches.

repository: twin-bridges/ansible-ons

repo_name: twin-bridges/ansible-ons


text:
+++
title = "Deploy a Podinfo Pod"
chapter = false
weight = 21
+++

First, let's create a namespace for our application (podinfo) to execute in. In each of the terminal sessions, execute:

```sh
kubectl create namespace podinfo
```

Yes, this can also be accomplished by placing a manifest in your git repository to create the namespace.

You can run:

```sh
kubectl create namespace podinfo --dry-run -o yaml > podinfo-namespace.yaml
```

Or paste this into a new file called `podinfo-namespace.yaml`.

```yaml
apiVersion: v1
kind: Namespace
metadata:
  creationTimestamp: null
  name: podinfo
```

Add, commit, and push this change to your repository. You can call `fluxctl sync --k8s-fwd-ns flux` to get flux to deploy the changes without waiting for the set poll window.

{{% notice tip %}}
We will be creating a number of files in your git repository for these next few steps. You can choose to create all the files first, then commit and push to the repository, or you can commit and push after each file creation. If you commit and push after each file creation, you can execute `kubectl get pods -A` to see what has happened.
{{% /notice %}}

Create a file called **podinfo-deployment.yaml** in your git repository:
```
apiVersion: apps/v1
kind: Deployment
metadata:
  name: podinfo
  namespace: podinfo
spec:
  minReadySeconds: 3
  revisionHistoryLimit: 5
  progressDeadlineSeconds: 60
  strategy:
    rollingUpdate:
      maxUnavailable: 0
    type: RollingUpdate
  selector:
    matchLabels:
      app: podinfo
  template:
    metadata:
      annotations:
        prometheus.io/scrape: "true"
        prometheus.io/port: "9797"
      labels:
        app: podinfo
    spec:
      containers:
      - name: podinfod
        image: stefanprodan/podinfo:3.2.3
        imagePullPolicy: IfNotPresent
        ports:
        - name: http
          containerPort: 9898
          protocol: TCP
        - name: http-metrics
          containerPort: 9797
          protocol: TCP
        - name: grpc
          containerPort: 9999
          protocol: TCP
        command:
        - ./podinfo
        - --port=9898
        - --port-metrics=9797
        - --grpc-port=9999
        - --grpc-service-name=podinfo
        - --level=info
        - --random-delay=false
        - --random-error=false
        env:
        - name: PODINFO_UI_COLOR
          value: "#34577c"
        livenessProbe:
          exec:
            command:
            - podcli
            - check
            - http
            - localhost:9898/healthz
          initialDelaySeconds: 5
          timeoutSeconds: 5
        readinessProbe:
          exec:
            command:
            - podcli
            - check
            - http
            - localhost:9898/readyz
          initialDelaySeconds: 5
          timeoutSeconds: 5
        resources:
          limits:
            cpu: 2000m
            memory: 512Mi
          requests:
            cpu: 100m
            memory: 64Mi
```


text:
# MPU6050_Calibration
Files to calibrate an MPU6050 using Arduino and Python using method outlined in:

J. Rohac, M. Sipos and J. Simanek, "Calibration of low-cost triaxial inertial sensors", IEEE Instrumentation \& Measurement Magazine, vol. 18, no. 6, pp. 32-38, 2015. doi: 10.1109/mim.2015.7335836.

Uses MPU6050 and I2C libraries by Jeff Rowberg at: https://github.com/jrowberg/i2cdevlib

Transformation from uncalibrated to calibrated reading: **a_calibrated** = **NS(a_uncal - b)** see the report for details

Steps to get SEM parameters:

    1. Place the MPU6050 securely in the calibration cube  (design under ./3D)
    2. Connect the MPU6050 to an Arduino UNO using I2C and wait 5 - 15 min for it to warm up
    3. Load the calibration script in Arduino/src/MPU6050_calibrate and open up a serial monitor
    4. Place the cube in a static position
    5. Repeat the previous step for 24 (or more) different rotations
    6. Take down the averaged acceleration vectors and save in a text file called 'calibration.txt' under /Data
    7. Run the Python/accelCalibration.py script
    8. Record the SEM parameters and use it in a transformation on every acceleration reading


text:
Tenor Android Core
==================

- [Introduction](#introduction)
- [Setup](#setup)
  * [Option 1: Embed as a Module](#option-1-embed-as-a-module)
  * [Option 2: Embed as a Library File](#option-2-embed-as-a-library-file)
  * [Additional Required Dependencies](#additional-required-dependencies)
- [Initialize Tenor Core](#initialize-tenor-core)
- [Retrieving GIFs from Tenor](#retrieving-gifs-from-tenor)
  * [Trending GIFs](#trending-gifs)
  * [Searching GIFs by a Specific Search Term](#searching-gifs-by-a-specific-search-term)
- [Displaying GIFs](#displaying-gifs)
- [FAQs](#faqs)

## Introduction
Tenor's API delivers the most relevant GIFs for users anywhere in the world, across more than 30 languages.
The Tenor Android Core provides Android developers with the code necessary to integrate essential Tenor GIF functionality into android mobile apps.

The Tenor Android Core provides all the requisite tools for an easy way to **search for GIFs** and to **display GIFs** - either as a single GIF, or as a single or multi-column list of GIFs.

To add Tenor GIF search to your app, please follow the steps below.

## Setup
The following instructions are based on Android Studio.

### Option 1: Embed as a Module
To embed the `tenor-android-core.aar` file as a module, right-click the project and select `New` -> `Module` -> `Import .JAR/.AAR`, then select the `tenor-android-core.arr`.

Once the file has been imported, you will need to include the `tenor-android-core` module as a dependency of any module that will use the core. Add the following lines to the `build.gradle` files of these modules:
```java
    dependencies {
        compile project(':tenor-android-core')
    }
```

### Option 2: Embed as a Library File
Alternatively, you can copy the `tenor-android-core.aar` into the `libs` folder of your `app` module.

This approach requires some additional setup on the `build.gradle` file of your `app` module, by adding the following lines:
```java
    repositories {
        flatDir{
            dirs 'libs'
        }
    }

    dependencies {
      compile(name: 'tenor-android-core', ext: 'aar') {
          transitive = true
      }
    }
```

### Additional Required Dependencies
For either of the import options used, you will also need to add the following dependencies to every module where `tenor-android-core` has been added, in order to use the full functionality of the Tenor Android Core:
```java
  compile 'com.squareup.retrofit2:converter-gson:2.3.0'
  compile 'com.github.bumptech.glide:glide:3.8.0'
  compile 'com.android.support:support-annotations:26.0.1'
```

## Initialize Tenor Core
**You will need an `API_KEY` from Tenor.**  To request an api key, click [here](https://tenor.com/gifapi#apikey).

On your app's subclass of the `Application` class, add the following lines of code to the `onCreate()` function:
```java
@Override
public void onCreate() {
    super.onCreate();

    // Create a builder for ApiService
    ApiService.IBuilder<IApiClient> builder = new ApiService.Builder<>(this, IApiClient.class)

    // add your tenor API key here
    builder.apiKey("");

    // initialize the Tenor ApiClient
    ApiClient.init(this, builder);
}
```
Alternatively, if you don't have a subclass of `Application`, then you should add these lines into your launcher activity.

## Retrieving GIFs from Tenor
The Tenor API offers robust ways to fetch the most relevant GIFs your application’s users are most likely to share.
The following sections will describe the simplest ways to fetch a stream of GIFs: the `trending` and the `search` API end points.

### Trending GIFs
The `trending` stream fetches whatever the most popular GIFs are at the time of the request, in the order of most popular.
If you wish to display GIFs to a user before a specific search term has been selected or entered, Tenor recommends displaying `trending` GIFs.
To access the `trending` API endpoint, add these lines of code to your application:
```java
    Call<GifsResponse> call = ApiClient.getInstance(getContext()).getTrending(
                    ApiClient.getServiceIds(getContext()),limit, pos);

    call.enqueue(new WeakRefCallback<Activity, GifsResponse>(this) {
        @Override
        public void success(@NonNull Activity activity, @Nullable GifsResponse response) {
            // handle success case
        }

        @Override
        public void failure(@NonNull Activity activity, @Nullable BaseError error) {
            // handle failure case
        }
    });
```
`ApiClient.getServiceIds(getContext())` contains the necessary info for API authentication and accurate content results.
The only additional fields that need to be supplied are `limit` and `pos`:

* `limit` (type `integer`) - Fetch up to a specified number of results (max: 50).
* `pos` (type `string`) - Get results starting at position "value".  Use empty string `""` for the initial pos.

### Searching GIFs by a Specific Search Term
Search is where Tenor's API particularly excels. Our understanding of what daily users search, share, upload, favorite, and collect allows us to continually return with precision the most relevant and shareable GIFs.

`search` uses the same fields as `trending`, but with an additional `q` field that takes a single or multiple words, to return the most precise GIFs possible.
```java
    Call<GifsResponse> call = ApiClient.getInstance(getContext()).search(
                    ApiClient.getServiceIds(getContext()), q, limit, pos);

    call.enqueue(new WeakRefCallback<Activity, GifsResponse>(this) {
        @Override
        public void success(@NonNull Activity activity, @Nullable GifsResponse response) {
            // handle success case
        }

        @Override
        public void failure(@NonNull Activity activity, @Nullable BaseError error) {
            // handle failure case
        }
    });
```

To see a detailed look of the **GIF response JSON object**, click [here](https://tenor.com/gifapi#responseobjects).

## Displaying GIFs
Once the `search` or `trending` response is received, the GIFs can now be loaded into an ImageView.  There are two steps involved in displaying GIFs.

* [Getting the GIF Url](#getting-the-gif-url)
* [Loading the GIF into an `ImageView`](#loading-the-gif-into-an-imageview)

### Getting the GIF Url
For a stream of multiple GIFs being displayed at once, as well as creating smaller bundles used for sharing, Tenor reccommends using `MediaCollectionFormats.GIF_TINY`.  Whereas for full size GIFs, you may use `MediaCollectionFormats.GIF`.

```java
    // using the response variable from the success callback
    Result gif_result_object = response.getResults().get(i); // `i` being the index of the result
    String gif_url = gif_result_object.getMedias().get(i).get(type).getUrl();
```
A full list of available url types may be found in the `MediaCollectionFormats` class.

### Loading the GIF into an `ImageView`
Once you have the url of the GIF, you can load it into an `ImageView`.  There are many content loading libraries available, but Tenor reccomend's [Glide](https://github.com/bumptech/glide), as it offers full support for loading GIFs into an `ImageView`.

We start by constructing a `GlideTaskParams`, which takes full advantage of the Glide library:
```java
    GlideTaskParams<ImageView> params = new GlideTaskParams<>(mImageView, gif_url);
    params.setListener(new WeakRefContentLoaderTaskListener<Context, ImageView>(getContext()) {
            @Override
            public void success(@NonNull Context context, @NonNull ImageView imageView, @Nullable Drawable drawable) {
                // handle the success case
            }

            @Override
            public void failure(@NonNull Context context, @NonNull ImageView imageView, @Nullable Drawable drawable) {
                // handle the success case
            }
        });
```
`mImageView` is the reference to the `ImageView` where the GIF will be displayed, and you can also add a callback for when the gif loading has completed.  For the full list of available loading options, see the `GlideTaskParams` class.

Once the `params` variable is constructed, use the `GifLoader` class to load the GIF:
```java
    GifLoader.loadGif(getContext(), params);
```

Following the instructions above will enable your app to search and display GIFs to your users.
A working demo - which showcases `search`,`trending`, and GIF image loading, as well as other Tenor API features like `tags` and `search suggestions` - can be found [here](https://github.com/Tenor-Inc/tenor-android-demo-search).

For full documentation of the Tenor API, with details on how to further refine and bolster your users' GIF experience, click [here](https://tenor.com/gifapi).

## FAQs

1. Why does my GIF not appear after I call loadGif?
    * Check what the height and width are set to in the ImageView, and its parent widgets. If the ImageView or its parent has WRAP_CONTENT for both the height and width, the GIF rendering may not succeed (and neither callback of the WeakRefLoadImageListener will fire). When this happens, the ImageView will be interpreted as having both a height and width of 0. Check that bounds have been given in either the xml or in the java code. Depending on your view structure, a MATCH_PARENT in either the height or width may be sufficient.

2. I get a gradle error message `Error:Failed to resolve: com.android.support:support-v4:26.0.1`. What is causing this?
    * If your app is building to Android API 26 and up, the following lines are required in order for the Tenor Android Core to build. Add them to your application's root `build.gradle` file.

    ```java
        allprojects {
            repositories {
                maven { url 'https://maven.google.com' }
            }
        }
    ```

repository: ctrl-alt-del/tenor-android-core

gha_language: Java

repo_name: ctrl-alt-del/tenor-android-core


text:
---
sidebar_position: 1
title: Before starting
---

## Content

First read about [Redux](https://redux.js.org/introduction/getting-started) and [Redux ToolKit](https://redux-toolkit.js.org/introduction/getting-started), about what it can do, what they offer and then come back here to move on.

It's important to know about them because they are core components of this template and knowing them can save your time
and eliminate many questions.

## If you don't want to use Redux

You can simply remove it with next following steps:
- Remove it from dependencies and devDependencies:

```shell
npm uninstall @reduxjs/toolkit react-redux redux-persist @types/react-redux
```

- Delete the `src/core/store` folder
- Change `Splash` screen navigation component initialization:

From:

```typescript jsx
  Navigation.registerComponent(
    Pages.splash.name,
    () => gestureHandlerRootHOC(reduxProvider(Splash)),
    () => Splash,
  );
```

To:

```typescript jsx
  Navigation.registerComponent(Pages.splash.name, () => Splash);
```

- Remove usage of `useAppSelector` in `Splash` (but you have to manage now `Onboarding` logic your way):
```typescript jsx
export const Splash: NavigationFunctionComponent = () => {
  useEffect(() => {
    setTabsRoot();
  }, []);

  return <LoadingComponent />;
};
```

- Remove unneeded interfaces from `src/types/index.ts`:
```typescript jsx
export interface RehydrateAppAction extends RehydrateAction {
  payload?: RootState;
}
```

- Remove unneeded `handlePromiseResult` from `src/common/validations/errorValidations.ts`:

```typescript jsx
export function handlePromiseResult(
  promiseAction: Promise<any>,
  successMessage?: string,
  successAction?: () => void,
  processError?: (error: Error) => IErrorResult,
  setError?: (errorMessage: string) => void,
) {
  promiseAction
    .then(unwrapResult)
    .then(() => {
      successMessage && showToast({text: successMessage});
      successAction && successAction();
    })
    .catch((handledError: Error) => {
      processError && handleErrorPostProcessing(processError(handledError), setError);
    });
}
```

That's it, you successfully removed `redux` from project.

repository: shwangson/react-native-template-strong

branch_name: refs/heads/main

repo_name: shwangson/react-native-template-strong


text:
# Personal Website

This is the repository for my personal website, made to collect my musings and tinkerings as a developer.

It is based on the [Indigo](https://github.com/sergiokopplin/indigo) jekyll template by Sergio Kopplin.

## Setup

To test locally on your machine, do the following steps:

1. Install [Jekyll](https://jekyllrb.com) and [Bundler](https://bundler.io/).
2. Clone the forked repo on your machine
3. Enter the cloned folder via terminal and run `bundle install`
4. Then run `bundle exec jekyll serve`
5. Open it in your browser: `http://localhost:4000`
6. Do you want an admin panel to edit your posts? You can install this plugin [jekyll-admin](https://jekyll.github.io/jekyll-admin/).

---
## License

[MIT](https://kopplin.mit-license.org/) License © Sérgio Kopplin


text:
<!-- README.md is generated from README.Rmd. Please edit that file -->

# syslosseval

<!-- badges: start -->
<!-- badges: end -->

The goal of `syslosseval` is to provide the data and R-functions to
support the analysis of the paper “Systemic Loss Evaluation” by Thomas
Breuer, Martin Summer and Branko Urosevic. You can download the paper at
<https://ideas.repec.org/p/onb/oenbwp/235.html#download> The code and
the data published in this repository support the analysis of this
paper.

## Installation

This package is not on CRAN. You can only install the the development
version from [GitHub](https://github.com/) with:

``` r
# install.packages("devtools")
devtools::install_github("Martin-Summer-1090/syslosseval")
```

## Example

When you install the package there will be in total seven datasets
available to you. These datasets are:

| Dataset number | Dataset name                     | Data Description                                         |
|:---------------|:---------------------------------|:---------------------------------------------------------|
| 1              | `eba_exposures_2016`             | Exposure data from the EBA 2016 stress test              |
| 2              | `eba_exposures_2020`             | Exposure data from the EBA 2020 transparency exercises   |
| 3              | `eba_impairments_2016`           | Impairment data from the EBA 2016 stress test            |
| 4              | `eba_impairments_2020`           | Imputed impairments data based on IMF methods            |
| 5              | `sovereign_bond_indices`         | Daily values of sovereign bond indices from 2009-2019    |
| 6              | `average_daily_volume_sovereign` | Average daily volumes of sovereign bonds from 2009 -2019 |
| 7              | `example_multiple_equilibria`    | A toy example, where multiple equilibria occur           |

A detailed description of how the data are compiled is given in the
paper in appendix B. Alternatively you can look at the scripts
`make_balance_sheets_2016.R`, `make_balance_sheets_2020.R`,
`make_price_volume_data.R` and `make_2020_impairment_scenarios.R`, which
are contained in the `syslosseval_raw_data.tar.gz` in the
`data-raw`folder of the project source code.

Here is a basic example where you:
Prepare a dataframe with exposures and impairments under the one year
ahead EBA stress scenario in the EBA 2016 stress test.
Prepare all the matrices and vectors needed to make a systemic loss
evaluation
Compute a fire sale equilibrium for these data.

``` r
library(syslosseval)
## basic example code

stress_data <- make_stress_data(eba_exposures_2016, eba_impairments_2016, 1, 2015)
state_variables <- make_state_variables(stress_data)
fixed_point_computation_function(mat = state_variables, lb = 33, data_idx = sovereign_bond_indices,
                                 data_adv = average_daily_volume_sovereign, base_year = 2015, constant = 1.5)
#> # A tibble: 8 x 7
#>   sec_class       delta_lower iter_lower delta_upper iter_upper delta_max unique
#>   <chr>                 <dbl>      <int>       <dbl>      <int>     <dbl> <lgl>
#> 1 DE                 0.00492          10    0.00492           9  0.0146   TRUE
#> 2 ES                 0.000640         10    0.000640          9  0.0191   TRUE
#> 3 FR                 0.00688          10    0.00688           9  0.0203   TRUE
#> 4 GB                 0.0106           10    0.0106            9  0.0166   TRUE
#> 5 IT                 0.0117           10    0.0117            9  0.0322   TRUE
#> 6 JP                 0.000494         10    0.000494          9  0.000907 TRUE
#> 7 US                 0.00434          10    0.00434           9  0.00908  TRUE
#> 8 Rest_of_the_wo…    0.00132          10    0.00132           9  0.00418  TRUE
```

If you only want to expect particular dataframes, you can do so by
writing them to an object. Say you want to inspect the EBA 2016 exposure
and impairment data you could do the following:

``` r
exposures <- eba_exposures_2016
impairments <- eba_impairments_2016
```

If you are not familiar with R or you prefer to work rather in Python,
Mathematica, Matlab, Excel or any other language you prefer you could
export these data to a csv file by writing by using the `write.csv()`
function (or the `write.csv2()`) depending on the settings of your
system), load them into another program and work from there. In this
case you do not have available the functions which prepare state
variables, compute fixed points etc. If you don’t know how to use
`write.csv()` or `write.csv2()`, please consult the help functions of R
either by using the Help pane in R studio or by typing `?write.csv` at
the R prompt.


text:
## views
```py
from django.views.generic.edit import CreateView
from django.contrib.auth.forms import UserCreationForm
from django.contrib.auth import login
from django.contrib.messages.views import SuccessMessageMixin
from django.urls import reverse_lazy

class RegisterView(SuccessMessageMixin, CreateView):
    template_name = 'users/register.html'
    form_class = UserCreationForm
    success_url = reverse_lazy('my-home')
    success_message = "Your profile was created successfully"

    def form_valid(self, form):
        response = super().form_valid(form)
        login(self.request, self.object)
        return response
```

## form without password2
```py
from django.contrib.auth.forms import UserCreationForm

class UserRegisterForm(UserCreationForm):
    password2 = None

    def clean_password2(self):
        return self.cleaned_data.get("password1")
```

## form with email !!!
[confirmation-mail](https://simpleisbetterthancomplex.com/tutorial/2017/02/18/how-to-create-user-sign-up-view.html#sign-up-with-confirmation-mail)
```py
from django.contrib.auth.models import User
from django.contrib.auth.forms import UserCreationForm, UsernameField
from django.forms import EmailField, EmailInput

class UserRegisterForm(UserCreationForm):
    email = EmailField(
        label=_("Email"),
        max_length=254,
        widget=EmailInput(attrs={'autocomplete': 'email'})
    )

    class Meta:
        model = User
        fields = ('username', 'email', 'first_name',)
        field_classes = {'username': UsernameField}
```

gha_language: CSS

gha_license_id: MIT


text:
# data_broker_garph_view

MARS (Machina Arte Robotum Simulans) is a cross-platform
simulation framework developed at the
[Robotics Innovation Center of the German Research Center for Artificial Intelligence (DFKI-RIC)](http://robotik.dfki-bremen.de/en/startpage.html)
and the [University of Bremen](http://www.informatik.uni-bremen.de/robotik/index_en.php).
It runs on (Ubuntu) Linux, Mac and Windows.

This package provides a graph GUI to manage data connections within the
data_broker.

# General {#general}

The main user documentation of MARS can be found at:
https://github.com/rock-simulation/mars/wiki

## Install

  Either use https://github.com/rock-simulation/pybob

  or ROCK users can simply import the rock-simulation/package_set and execute autoproj build simulation/mars_extensions/data_broker_graph_view

# License {#license}

data_broker_graph_view is distributed under the
[3-clause BSD license](https://opensource.org/licenses/BSD-3-Clause).


text:
# Computer Basics

## Hardware
Input > CPU |  Memory > Output
Only CPU can access the memory. Memory; RAM short term memory. Or long Term hard drive cd-rom.
Motherboard connects everything. Expansion cards are sound cards etc.

A chip is full of transistors. Little switches that can be 1 or 0. Amount of transistors make the chip faster.

Motherboard makes connection between CPU and memory. But most motherboards do alot more. (ports, expansion)

Hardware; parts of the computer
Software; programs that run on the hardware
* Operating System
* Applications

## Binary
There is 'bi' just two things. Binaries are 1 and 0s. Mostly meant to be letters and numbers.
Computers can understand a bit. On top of that we got the byte, 8-bits together. All numbers and letters can be broken down into bytes. Everything you write in JS code can be converted to byte.

## Data size
Bits per second (speed is something different then size) Internet and network speed are two different things.

## Computers
* Super
* Server
* Workstation
* PC

It's not PC or MAC. Both of them are personal computers.

## Network
Data networks.
* lan; small group of computers
* wan; two local networks that are connected rent cable from isp
* vpn; use the internet

Internet can only deliver something to an IP address. Each device has one. IP adress are based on location. Each number in the IP adress is a more specific location.

## Internet
Device > modem > router. Request response to a server (web server)

CDN; Deliver content to the user as fast as possible. CDN's pay ISP for the faster route. Servers across the world.

Routers connect all the devices in a local area. Each router only has to know it's own little network. The information that get sends are called packets.

## Analog vs Digital
Computer measures waves (this is called sampling) and turn them into numbers.

## Source Code
Text document that a programmer creates. The computer needs a way to interpreter that.
* interpreter; browser interpret it
* compiler; product is already compiled (on programmers end)

All documentation and source code can be accessible. This is called open-source.

## Console
Display system messages; tool for debugging.

## Variables
-

Dictionary attacks.


text:
---
title: Tags
category: general
difficulty: medium
---

Tags are a way to grant access, assign restrictions, or attach other kinds of metadata to various to objects e.g. worlds, users and avatars.
These tags are in the form of simple strings, grouped together in a string array, and commonly prefixed with a namespace designating the type of tag.

Tags starting with `admin_` are always assigned to the user manually by a staff. Tags starting with `system_` are automatically assigned by the system.

## User Tags

Tag | Description
----|------------
`admin_avatar_access` | User can upload Avatars without needing the neccesary trust rank
`admin_can_grant_licenses` | User can give out licenses to other users
`admin_canny_access` | User can access Canny without needing the neccesary trust rank
`admin_lock_tags` | User's tags have been locked and cannot be edited by the user
`admin_lock_level` | User's Trust rank has been locked and can no longer be changed automatically
`admin_moderator` | User is part of the VRChat Staff team
`admin_official_thumbnail` | Replaces the users profile picture with the VRChat logo
`admin_scripting_access` and `system_scripting_access` | User can upload user-made scripts (Deprecated)
`admin_world_access` | User can upload Worlds without needing the neccesary trust rank
`show_social_rank` | Toggle whether to show the user's real social rank
(Deprecated: This is now a registry key and sent over Photon)
`show_mod_tag` | Toggle whether to show the [Red](https://user-images.githubusercontent.com/5008081/153017830-bff84210-3868-4ea6-ba52-047932176a56.png) Staff nameplate
`system_avatar_access` | User can upload and publish Avatars
`system_early_adopter` | User bought VRC+ in the early period of it's launch, around December 2020
`system_feedback_access` | User can send Feedback
`system_probable_troll` | User has been reported multiple times and is (probably) a troll
`system_supporter` | User has an active VRC+ subscription
`system_legend` | User is an Experienced player and was active during the Summer of 2018
(Tag removed in 2022-05-05)
`system_troll` | User is a confirmed troll
`system_trust_basic` | User is "New User" (blue) Trust rank
`system_trust_known` | User is "User" (green) Trust rank
`system_trust_trusted` | User is "Known User" (orange) Trust rank
`system_trust_veteran` | User is "Trusted User" (purple) Trust rank
`system_trust_intermediate` | Unknown
(Tag removed in 2022-05-05)
`system_trust_advanced` | Unknown
(Tag removed in 2022-05-05)
`system_trust_legend` | User is "Veteran User" (gold color) Trust rank
(Role was removed in Sep 2018. Tag removed in 2022-05-05)
`system_world_access` | User can upload and publish Worlds

Trust rank tags have an offset of 1 with their name, so `system_trust_trusted` is actually only `Known User` (orange). The arrows in the following picture highlight the offset naming inaccuracy. The naming system is because of legacy reasons. Visistors have no trust rank at all. It is common for people User and above to be missing the tag for New User.

![Trust ranks](https://i.imgur.com/dBoxDVG.png)

## World Tags

Tag | Description
----|------------
`author_tag_*` | Custom tag added by the world author, with the last word being anything; used during searching by tag
`author_tag_avatar` | World will show up in "Avatar Worlds" row
`author_tag_game` | World will show up in the "Games" world row
`admin_featured` | World has been manually selected by staff to appear in the "Featured" world category
`admin_approved` | World has been manually approved by staff
`admin_avatar_world` | World was manually been selected by staff as avatar world (Deprecated)
`admin_community_spotlight` | World has been manually selected by staff to appear in "Spotlight" row
`admin_hidden` | World will always be hidden from search
`admin_hide_active` | World will be hidden from "Active" row
`admin_hide_new` | World will be hidden from "Recently Updated Worlds" row when updated
`admin_hide_popular` | World will be hidden from "Popular Worlds" row
`debug_allowed` | World [Debugging](https://user-images.githubusercontent.com/5008081/136931542-84fe3806-6933-4a0f-b816-d3a8052298a8.png) has been enabled by author, allowing to see state of triggers
`system_approved` | World has been automatically approved through the Community Labs
`system_created_recently` | World was recently created
`system_labs` | World has been submitted to Community Labs
`system_updated_recently` | World has been recently updated and will show up in "Updated Recently" worlds row if also system approved
`content_sex` | World has been uploaded with "Nudity/Sexuality" warning.
`content_violence` | World has been uploaded with "Realistic Violence" warning.
`content_gore` | World has been uploaded with "Blood/Gore" warning.
`content_other` | World has been uploaded with "Other NSFW" warning.

Worlds can also have a range of different event-specific tags such as `admin_vket2021` for the Vket row, `admin_muzzfesst` for the MUZZFEST event, or `admin_halloween_2019` for the 2019 Halloween row. These are not listed because it would be impossible to accurately keep such list up-to-date, and each tag is of little use outside of that specific event.

## Language Tags

Language tags primarily appear on User profiles, with each user being allowed to have at most 3 language tags. Language tags can also appear on Instances, showing the languages the people in that instance speak.

Tag | Description
----|------------
`language_eng` | English / English
`language_kor` | 한국어 / Korean
`language_rus` | Русский / Russian
`language_spa` | Español / Spanish
`language_por` | Português / Portuguese
`language_zho` | 中文 / Chinese
`language_deu` | Deutsch / German
`language_jpn` | 日本語 / Japanese
`language_fra` | Français / French
`language_swe` | Svenska / Swedish
`language_nld` | Nederlands / Dutch
`language_pol` | Polski / Polish
`language_dan` | Dansk / Danish
`language_nor` | Norsk / Norwegian
`language_ita` | Italiano / Italian
`language_tha` | ภาษาไทย / Thai
`language_fin` | Suomi / Finnish
`language_hun` | Magyar / Hungarian
`language_ces` | Čeština / Czech
`language_tur` | Türkçe / Turkish
`language_ara` | العربية / Arabic
`language_ron` | Română / Romanian
`language_vie` | Tiếng Việt / Vietnamese
`language_ase` | American Sign Language
`language_bfi` | British Sign Language
`language_dse` | Dutch Sign Language
`language_fsl` | French Sign Language
`language_kvk` | Korean Sign Language

## Useless tags

Tag | Description
----|------------
`system_neuralink_beta` | Meaningless tag used by Tupper
`system_extremely_cool_guy` | Meaningless tag used by Tupper
`system_stop_being_nosy` | Meaningless tag used by Tupper
`system_notamod` | Meaningless tag used by Tupper
`system_no_seriously_im_not_a_mod_how_many_times_do_i_have_to_tell_people` | Meaningless tag used by Tupper
`system_the_tag_is_just_named_that` | Meaningless tag used by Tupper
`system_haha_you_have_to_document_this_one_too` | Meaningless tag used by Tupper
`system_legen_wait_for_it_dary` | Meaningless tag used by Tupper
`system_UE5_dev_access` | Meaningless tag used by Tupper
`Never gonna give you up` | Meaningless tag used by Fusl
`system_not_cute` | Meaningless tag used by Fusl
`'; DROP DATABASE tags; -- ` | Meaningless tag used by Fusl
`'; DROP TABLE tags; -- ` | Meaningless tag used by Fusl
`¯\\_(ツ)_/¯` | Meaningless tag used by Fusl
`ඞ` | Meaningless tag used by Fusl
`we've been trying to reach you about your car's extended warranty` | Meaningless tag used by Fusl
`system_smart_fridge_beta` | Meaningless tag used by Nyx
`system_hey_mom_look_im_in_a_git_commit` | Meaningless tag used by Nyx
`system_trust_sussy` | Meaningless tag used by Squid
`system_lizard` | Meaningless tag used by Afromana
`system_me_I_read_them` | Meaningless tag used by Afromana
`system_slug` | Meaningless tag used by Slorg

extension: markdown


text:
First import DB in your system then connect DB

Database Connection is .env file , my current Connection :

DB_CONNECTION=mysql
DB_HOST=<IP_ADDRESS>
DB_PORT=3306
DB_DATABASE=workjob
DB_USERNAME=root
DB_PASSWORD=''

create post: http://localhost/workjob/public/posts/create

if you want to add more then tags use comma separator like tag1,tag2.

Delete post: http://localhost/workjob/public/post/delete

All list of posts, then click delete button data will be deleted on related datas.

Show Posts:   http://localhost/workjob/public/posts/10

Edit: http://localhost/workjob/public/posts/10/edit

select all the posts and   count posts:    http://localhost/workjob/public/tags/5

	Here display all posts by tags and count posts by tag.

	For example:

	{"status":200,"post_count":4,

	"response":[{"id":5,"name":"dfgdf","created_at":"2017-02-26 07:36:09","updated_at":"2017-02-26 07:36:09","posts":[{"id":13,"title":"dfgdf","body":"fdgdfg","created_at":"2017-02-26 07:43:55","updated_at":"2017-02-26 07:43:55","pivot":{"tag_id":5,"post_id":13}},{"id":14,"title":"dfgdf","body":"fdgdfg","created_at":"2017-02-26 07:43:56","updated_at":"2017-02-26 07:43:56","pivot":{"tag_id":5,"post_id":14}},{"id":15,"title":"dfgdf","body":"fdgdfg","created_at":"2017-02-26 07:43:57","updated_at":"2017-02-26 07:43:57","pivot":{"tag_id":5,"post_id":15}},{"id":16,"title":"dfgdf","body":"fdgdfg","created_at":"2017-02-26 07:44:01","updated_at":"2017-02-26 07:44:01","pivot":{"tag_id":5,"post_id":16}}]}]}

"post_count":4

1.  After any post created the system send email. but localsystem can't able to send mail so when create new post the system should log information. (path: storage/logs/laravel.txt).

2. Any post has been removed, post title stored in log file  (path: storage/logs/laravel.txt).


text:
---
layout: update
date: 2015-12-04
title: Windows images update on December 4, 2015
---

## What's new

* [#498](https://github.com/appveyor/ci/issues/498) NUnit 3.0
* [#526](https://github.com/appveyor/ci/issues/526) Visual Studio 2015 Update 1
* [#530](https://github.com/appveyor/ci/issues/530) Fixed: Error uploading NuGet package from command line
* [#532](https://github.com/appveyor/ci/issues/532) ASP.NET 5 RC1 Update 1
* [#533](https://github.com/appveyor/ci/issues/533) Azure SDK 2.8.1
* [#534](https://github.com/appveyor/ci/issues/534) TypeScript 1.7.4
* [#535](https://github.com/appveyor/ci/issues/535) Xamarin <IP_ADDRESS>7

## Previous worker images

There are build worker images available from previous deployment. You can use them in case of any issues with the current images:

* `Previous Windows Server 2012 R2`
* `Previous Visual Studio 2015`

You can select build worker image in OS dropdown on Environment tab of project settings or if you use `appveyor.yml`:

```yaml
os: Previous Windows Server 2012 R2
```

repository: appveyor/website

gha_language: HTML

repo_name: appveyor/website


text:
# kotlin-vue

Kotlin wrapper for [VueJs](https://vuejs.org/).

The project uses [Vue Composition API](https://vue-composition-api-rfc.netlify.com/) Vue2 plugin

#### Compiles and reloads for development

```shell script
./gradlew example:browserRun --continuous
```

Served on `http://localhost:8083`

#### Testing

```shell script
./gradlew test
```

### Useful links

[KotlinLang](https://kotlinlang.org/docs/reference/)

[Kotlin VueJs Slack](https://kotlinlang.slack.com/messages/C8CQT4F47)

[VueJs](https://vuejs.org/)

[Vue Composition API](https://vue-composition-api-rfc.netlify.com/)

[Vue RFCs](https://github.com/vuejs/rfcs/tree/master/active-rfcs)

[Vuex](https://vuex.vuejs.org/)

### Background

The plan is to keep up with the RFC through to Vue3 release, at which point the API will need to change a bit, but should also
stabilize shortly there after.

The hope is to have all Vue3 features available.  A [Vuex](https://vuex.vuejs.org/) wrapper is probable, but not knowing
what the future API looks like I'm not focused on it at this point.

There are no current plans to implement a vue2 component api since working with a proxied `this` was outside of my current
kotlin skill set.

The current state of this project is POC so the API can and will change without notice.  There is no polish to anything
nor attempt to do so at this point.  The example app will hopefully have working examples of most if not all the features
available as this develops.

Contributions in the form of playing with it, bug reports, missing features, pull requests and code reviews are welcome
(I wrote this to learn kotlin and support two excellent products).

I've also never hosted/managed an open source project like this so if my zippers down, be a bro and let me know.

repository: eEQK/kotlin-vue

repo_name: eEQK/kotlin-vue


text:
---
title: Whats is a Workbook?
page_title: Whats is a Workbook? | UI for WinForms Documentation
description: Whats is a Workbook?
slug: winforms/spreadprocessing/working-with-workbooks/whats-is-a-workbook?
tags: whats,is,a,workbook?
published: True
position: 0
previous_url: spreadprocessing-working-with-workbooks-what-is-workbook
---

# Whats is a Workbook?

This article will help you get familiar with the concept of a workbook and its features.

## What is a Workbook?

The workbook lays in the core of the RadSpreadProcessing' and RadSpreadsheet document model. It is the primary document that you use to retrieve, manipulate and store data. The workbook can also be viewed as a collection of worksheets, where a worksheet is in turn defined as a collection of cells organized in rows and columns. Each workbook contains at least one worksheet and often holds several sheets with related information.

The workbook is designed to hold together multiple worksheets in order to allow efficient organization and consolidation of data. Typically, a workbook has a single theme and contains worksheets with related data. For example, an annual budget workbook may comprise four worksheets that break down the budget in quarters.

You can create a workbook from scratch or import an existing document. To save a document you can export its contents into a csv, txt or xlsx file. Further information is available in the [Create, Open and Save Workbooks]({%slug winforms/spreadprocessing/working-with-workbooks/create-open-and-save-workbooks%}) article and the [Formats and Conversion]({%slug winforms/spreadprocessing/formats-and-conversion%}) section.

## What is in it?

The workbook has several important characteristics:

* __Collection of Worksheets:__ Each workbook maintains a collection of worksheets that allows you to add and delete worksheets. It also allows you to move worksheets within the workbook or simply iterate through them. More information about worksheets is available in the [What is a Worksheet?]({%slug winforms/spreadprocessing/working-with-worksheets/what-is-a-worksheet?%}) section.

* __Active Worksheet:__ The workbook exposes a property that indicates the active worksheet. Note that there is a single active worksheet in a workbook at a time. The [Activate a Worksheet]({%slug winforms/spreadprocessing/working-with-worksheets/activate-a-worksheet%}) article illustrates how to set the active worksheet.

* __History:__ Each workbook maintains a history stack that records all changes introduced to its content. That said, you can perform undo and redo operations effortlessly, replying on the built-in recorder. Although the tracking of changes  is done automatically, it also allows manual control over the recorded items. The history of the workbook also lets you to group several actions into a one undo step. This feature is very handy, for example, when you replace the contents of multiple cells in a single action. You will be able to find more information about the feature in the [History]({%slug winforms/spreadprocessing/features/history%})article.

* __Names (Named Ranges):__ the Workbook class exposes a Names property that of type NameCollection that allows you to create, update and manage names. More about the feature is available in the [Names]({%slug winforms/spreadprocessing/features/names-(named-ranges)%}) article.

* __Collection of Cell Styles:__ Each workbook contains a collection of cell styles. A cell style is a predefined set of formatting options, such as borders, fonts, fills and number formats, that you can apply to a cell. The concept of cell styles facilitates the process of formatting cells since it allows you to set multiple properties in one step and also serves as means for achieving consistent look. The collection of cell styles allows you to add, retrieve and delete styles. More information on the cell styles is available in the [Cell Styles]({%slug winforms/spreadprocessing/features/styling/cell-styles%}) article.

* __Theme:__ The workbook has a theme that allows you specify colors, fonts and a variety of graphic effect for the whole document. You will be able to find more information on the topic in the [Document Themes]({%slug winforms/spreadprocessing/features/styling/document-themes%}) article.

* __Find and Replace:__ The Workbook class offers friendly API that allows you to find and replace text and numbers in all worksheets it contains. For more information about the feature see the [Find and Replace]({%slug winforms/spreadprocessing/features/find-and-replace%}) article.

* __Protection:__ The feature lets you prevent users from modifying the structure of the workbook: adding, removing, renaming or reordering sheets. You can find more information on the topic in the [Worksheet Protection]({%slug winforms/spreadprocessing/features/protection/worksheet-protection%}) article.

![spreadprocessing-working-with-workbooks-what-is-a-workbook 001](images/spreadprocessing-working-with-workbooks-what-is-a-workbook001.png)


text:
# EasyBuild
---

**Easy Build is a MaNGOS dependency checker and Cmake helper GUI.**

Run this from the win folder of a MaNGOS repository and it will check all the required libraries are installed and all required submodules are cloned correctly.

This ensures that the build process will find them and build correctly.

It also provides a GUI for the Cmake build options.

For Mangos Three *ONLY* - There is a file that needs to be run to make easybuild work:

Patch_Easybuild_Mangos3.cmd

To remove the patch:

Patch_Easybuild_Mangos3_remove.cmd

Once again, only use the patch files on MangosThree

repository: freadblangks/EasyBuild

repo_name: freadblangks/EasyBuild


text:
# react-next-todolist
A simple todolist site build in ReactJs and NextJs consuming an external API

## Installation

Clone the repo and run:

```bash
npm install
```

## Usage

In order to run, use the following script:
```bash
npm run dev
```

## License
[MIT](https://choosealicense.com/licenses/mit/)

repository: JuanFKurucz/react-next-todolist

gha_language: JavaScript

repo_name: JuanFKurucz/react-next-todolist


text:
## How to use rich text formatting in pdf with pdf generator sdk for javascript in Javascript and ByteScout PDF Suite

### This code in Javascript shows how to use rich text formatting in pdf with pdf generator sdk for javascript with this how to tutorial

Sample source code below will display you how to manage a complex task like use rich text formatting in pdf with pdf generator sdk for javascript in Javascript. ByteScout PDF Suite is the bundle that provides six different SDK libraries to work with PDF from generating rich PDF reports to extracting data from PDF documents and converting them to HTML. This bundle includes PDF (Generator) SDK, PDF Renderer SDK, PDF Extractor SDK, PDF to HTML SDK, PDF Viewer SDK and PDF Generator SDK for Javascript. It can use rich text formatting in pdf with pdf generator sdk for javascript in Javascript.

The SDK samples given below describe how to quickly make your application do use rich text formatting in pdf with pdf generator sdk for javascript in Javascript with the help of ByteScout PDF Suite. Follow the instructions from scratch to work and copy the Javascript code. Want to see how it works with your data then code testing will allow the function to be tested and work properly.

ByteScout PDF Suite free trial version is available on our website. Javascript and other programming languages are supported.

## REQUEST FREE TECH SUPPORT

[Click here to get in touch](https://bytescout.zendesk.com/hc/en-us/requests/new?subject=ByteScout%20PDF%20Suite%20Question)

or just send email to [support@bytescout.com](mailto:support@bytescout.com?subject=ByteScout%20PDF%20Suite%20Question)

## ON-PREMISE OFFLINE SDK

[Get Your 60 Day Free Trial](https://bytescout.com/download/web-installer?utm_source=github-readme)
[Explore SDK Docs](https://bytescout.com/documentation/index.html?utm_source=github-readme)
[Sign Up For Online Training](https://academy.bytescout.com/)

## ON-DEMAND REST WEB API

[Get your API key](https://pdf.co/documentation/api?utm_source=github-readme)
[Explore Web API Documentation](https://pdf.co/documentation/api?utm_source=github-readme)
[Explore Web API Samples](https://github.com/bytescout/ByteScout-SDK-SourceCode/tree/master/PDF.co%20Web%20API)

## VIDEO REVIEW

[https://www.youtube.com/watch?v=NEwNs2b9YN8](https://www.youtube.com/watch?v=NEwNs2b9YN8)

<!-- code block begin -->

##### ****checkdatauri.js:**

```
	// checks if we have datauri support in current browser
        // if we have support for datauri support then we can stream generated PDF right into the browser
        // otherwise we should use Downloadify script to allow user to save PDF file
	function CheckDataURISupport(){

	var result = true;
	var checkDataURISupportImage = new Image();

	checkDataURISupportImage.onload = checkDataURISupportImage.onerror = function(){
		if(this.width != 1 || this.height != 1){
			result = false;
		}
	}
	checkDataURISupportImage.src = "data:image/gif;base64,R0lGODlhAQABAAD/ACwAAAAAAQABAAACADs=";
	// check if we have datauri support in current browser - end

		return result;
	}

```

<!-- code block end -->

<!-- code block begin -->

##### ****createpdf.js:**

```
// function that creates BytescoutPDF instance (defined in BytescoutPDF.js script which have to be included into the same page)
// then calls API methods and properties to create PDF document
// and returns created BytescoutPDF object instance
// this CreatePDF() function is called from Sample.html
// IsInternetExplorer8OrLower parameter indicates if we use IE8 or lower so we CAN'T use images (as it requires HTML5 Canvas available in IE9 or higher). Other browsers should be working fine

// IMPORTANT ABOUT IMAGES:
// When using Firefox or IE, pdf generation may fail because images are not accessible when pdf generation works
// the solution for this issue is to preload images in main HTML document before running PDF generation
// to preload images, put them into hidden div block "pdfreportimages" - you can see it in the sample.html right after <body> opening tag

function CreatePDF(IsInternetExplorer8OrLower) {

    // create BytescoutPDF object instance
    var pdf = new BytescoutPDF();

    // set document properties: Title, subject, keywords, author name and creator name
    pdf.propertiesSet("Sample document title", "Sample subject", "keyword1, keyword 2, keyword3", "Document Author Name", "Document Creator Name");

    // add new page
    pdf.pageAdd();

    // draw formatted text
    pdf.textAdd(20, 50, 'You can use HTML tags for text formatting: <b> for <b>bold</b> and <i> for <i>italic</i> or <s> for <s>striked style</s>.');

    // draw formatted text
    pdf.textAdd(10, 100, 'You may also change <font face="Helvetica" size="20" color="#0000ff">font size and</font> <font face="Courier" size="20" color="#ff0000">color</font> and use <u><b>mixed <i>styles</i></b></u>.');

    // draw formatted text
    pdf.textAdd(10, 140, 'Zapf-Dingbats and Symbol fonts:');

    // set zapf dingbats built in font to use
    pdf.fontSetName("zapfDingbats");
    pdf.fontSetSize(25);

    // draw symbols, see map of letters to symbols at https://images.google.com/?q=zapf+dingbats+font+symbols
    pdf.textSetBox(10,150,500,300); // define output rectangle
    pdf.textAddToBox("1234567890!@#$%^&*()ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")

    // set symbol font
    pdf.fontSetName("Symbol");
    pdf.fontSetSize(25);

    // draw symbols, see map of letters to symbols at https://images.google.com/?q=zapf+dingbats+font+symbols
    pdf.textSetBox(10,310,500,800); // define output rectangle
    pdf.textAddToBox("1234567890!@#$%^&*()ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")

    // return BytescoutPDF object instance
    return pdf;
}

```

<!-- code block end -->

url: https://raw.githubusercontent.com/bytescout/ByteScout-SDK-SourceCode/67a20983df78dea26d2a8f25ec98000d3ec81928/PDF Suite/Javascript/Use rich text formatting in pdf with pdf generator sdk for javascript/README.md

repository: bytescout/ByteScout-SDK-SourceCode

repo_name: bytescout/ByteScout-SDK-SourceCode


text:
# Definition

`TopClass.py` is a class that compile the Top number that you want compile

## Params

**path_csv**: File with predictions `type:String`

**path_destiny**: Path to save the file .csv  `type:String`

**number_of_tops**: Number of tops `type:Int`

**number_of_classes**: number of classes in model. `type:Int`

**logger**: logger. `type:Logger`

## Attributes

**path_csv** : Return teh csv path `type:String`

**path_destiny** : Return the path to top file `type:String`

**number_of_tops**: Return the number of top `type:Int`

**number_of_classes**: Return number of classes `type:Int`

**name_file_top_classes**: Name of file `type:String`

**file_name_top_classes**: Path and name of file `type:String`

repository: glaucomunsberg/kootstrap

repo_name: glaucomunsberg/kootstrap


text:
---
title: "Reinterpret Date within other timezone in Rails"
layout: post
date: 2023-01-21 14:51:53 +0900
image: 'assets/img/posts/2023-01-21-reinterpret-date-within-other-timezone-in-rails/catch.jpg'
description:
tag: ['Rails', 'Ruby', 'Web']
blog: true
author: "Kai Sasaki"
---

The [`Date`](https://api.rubyonrails.org/classes/Date.html) type in Rails does not retain the timezone information. The default timezone is consistent with the system Rails provides. But it's implicit, so we should never forget which timezone we use as a Date type.

We can use [`in_time_zone`](https://apidock.com/rails/DateTime/in_time_zone) to be explicit about which timezone we are aware of.

```ruby
pry(main)> d = Date.new(2023, 1, 20)
=> Fri, 20 Jan 2023
pry(main)> d.to_time
=> 2023-01-20 00:00:00 +0000
pry(main)> d.in_time_zone('Asia/Tokyo')
=> Fri, 20 Jan 2023 00:00:00.000000000 JST +09:00
pry(main)> d.in_time_zone('Canada/Eastern')
=> Fri, 20 Jan 2023 00:00:00.000000000 EST -05:00
```

`in_time_zone` returns the [TimeWithZone](https://api.rubyonrails.org/classes/ActiveSupport/TimeWithZone.html) which inherently retains the timezone information. It's useful to pass the timezone identifier in string type without changing the system configuration.

And the book, [Agile Web Development with Rails 6](https://amzn.to/3H3WcIO) will be a more comprehensive guide to understanding the timezone structure in Rails.


text:
---
layout: about
inline: false
group: Doctoral Researchers
group_rank: 3

title: MSc Nafise Eskandani
description: Profile of MSc Nafise Eskandani, Doctoral Researcher at the Programming Group.
lastname: Eskandani
publications: 'author^=*Eskandani'

teaser: >
    I am a PhD student in the Programming Group since May 2019.
    My research interests include Cloud Computing, Software Engineering, and Programming Languages.
    Currently, I am working on programming models for decentralized and resilient systems under the emergenCITY project.

profile:
    name: MSc Nafise Eskandani
    align: right
    image: eskandani-profile.jpg
    role: Doctoral Researcher
    email<EMAIL_ADDRESS>    twitter: NEskandani
    address: >
        Hochschulstr. 10<br />
        64289 Darmstadt, Germany
---

I am a PhD student in the Programming Group since May 2019.
My research interests include Cloud Computing, Software Engineering, and Programming Languages.
Currently, I am working on programming models for decentralized and resilient systems under the [emergenCITY project](https://www.emergencity.de/).


text:
# References & Tech stack choices

This chapter provide the choosen technology stack as referred to goals and constraints in chapter 1. There are few main factor of technology stack to choose:

* Open source, the choosen stack should have open source license to avoid vendor lock.
* Documentation, the choosen stack should provide comprehensive documentation, and actively maintenaned.
* Reliability, the choosen stack should already have real production running proven.
* Developer resources, the choosen stack should already widely used by developers by using github report indicator.
* Easy to scale, the choosen stack should be able to accomodate horizontal scaling without major rewrite or refactor.

## Programming Languages

### Javascript

Javascript has been widely used for multiple platform from frontend to backend using NodeJS. Using javascript to develop the system will be logical reason to faster development. The streaming features for video/audio conferences also makes perfect fit for NodeJS non-blocking features.

## Databases

* MongoDB. it's NoSQL document based database will be fit for current architecture as it support high concurency writes.
* Redis. Redis will act as cache database to improve latency. Any write/update query will be queue to the main database using pub/sub method.

## Frameworks

* NodeJS. NodeJS will be used for all backend related services
* Typesense. Typesense will be used for search features from any services requiring full text search index.

## CI/CD

Since all codebase will be hosted in Github, using Github Action will be fit into the situation

## Mobile Application

Using hybrid mobile app framework such Flutter or React Native for faster development

repository: adisetiawan/lms-architecture-doc

repo_name: adisetiawan/lms-architecture-doc


text:
---
layout: default
---

# 1993-10-21 - Re: Something Silly, Something Serious

## Header Data

From<EMAIL_ADDRESS>(Jamie Dinkelacker)

To<EMAIL_ADDRESS>Message Hash: d9509db3f93eddc89156bdad829d6533878a0ba6c7f9abea715a6db9038dc140

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1993-10-21 06:47:55 UTC

Raw Date: Wed, 20 Oct 93 23:47:55 PDT

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Jamie Dinkelacker)
Date: Wed, 20 Oct 93 23:47:55 PDT
To<EMAIL_ADDRESS>Subject: Re: Something Silly, Something Serious
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Tim May writes (and then Jamie takes a bend toward CypherRapture):

>SOMETHING SERIOUS:
>
>Seriously, I understand L. Dettweiler has asked to be unsubscribed.
>
>For the record, I did not send him any e-mail these past several
>weeks, either under my normal name or under any other names. I rarely
>pseudonyms, and have never--that I recall right now--ever used them in
>2-way communication. And never for the purposed Dettweiller/Boxx alleged.
>
>
>But the cake was taken when he claimed I had invented the nym "Jamie
>Dinkelacker," whom many of you know personally, to slant arguments!
>Done humorously, as several of us have done recently, such a claim
>would be funny (no offense meant, Jamie). But LD showed no awareness
>of the absurdity of his claim.                ^^^^^^^^^^^^^^^^^^^^^^

Tim's got a point. Why would Tim create the nym Jamie Dinkelacker? With so
many names to pick from, why pick one that is already in use and is fairly
visible in other networks (e.g., extropians, nano)? Perhaps LD didn't check
them, but others on the list are aware. Isn't it interesting that when a
writer doesn't know that two persons are different individuals, it's easy
to presume that when they agree in print or simply discuss similar topics,
that this implies nym-hood? Fascinating: This isn't a surface event.

The issue here is a root failing of LD's cognizance and scope to simply
check things out. Readers in the Bay Area or LA may have seen stuff Jamie
Dinkelacker has written in _Microtimes_, or in the _Foresight Update_, or
if you read the academic communication and mass media literature, there as
well. Plus, I'm a fairly voluble fellow speaking at conferences, trade
shows, some local discussion groups and the like. No, Jamie isn't an AI,
nor does he play one on the net. (Maybe someday...)  I've not used net nym.

What struck me about LD's vacuous pleas and S.Boxx's vapid rants was the
essential disturbed and juvenile nature they projected, hoping to ensure a
cause of CypherRapture (following CryptoAnarchy, natch) warranting true
names without ever any spoofing or deception. I have made a standing offer
to take S.Boxx to lunch (provided s/he eats with a fork and isn't already
out to lunch).

But spoofing and deception are not the same: more importantly, neither is
an emergent element of pseudonymity, anonymous remailers, or cypherjocks. I
found Blacknet to be entertaining. It seemed natural this has been going on
for years.  As far as deception, it's a matter of degree. It's common in
nature, sports, business, ... . I'm not advocating it -- but I accept it as
a fact of living in modern times.

This has been a good experience for me, and has raised many issues in the
big Venn of CryptoAnarchy: who owns their name, for how long, does it
matter? ... Who can tell the difference? Which John Smith is that?

... Tim continues ...
>
>Cypherpunks write code. Cyperpunks write essays. Cypherpunks make puns
>and jokes and even spoofs. Cypherpunks have fun.
>

I don't know if there is a Cypherpunk's cause. I doubt there's a movement,
but that's separate from my holding a belief that crypto and nyms and
digital cash and privacy and emergent social structures are crucial to a
preferable form of human survival.

With the net, we have a wonderous tool and opportunity. But the world isn't
a safe place. Every time I put a finger or toe into the lovely pacific
ocean I'm keenly aware of quickly entering the food chain at a much lower
point. These are times of challenge, to develop new tools and fresh
perspectives. But many elements of human nature remain the same.

I thank the Cypherpunks for writing code. I don't (anymore): I write words,
make videos and build organizations. We do need the code. We also need to
push at the edges of our understanding of social dynamics.  One of the brave ones,
s/he isn't. And Cypherpunks' creations even protect the likes of S.Boxx.
Reminiscent of Voltaire, yes?

Thanks for the bandwidth. If anyone would like to continue this, perhaps
moving it to the Extropians list would be reasonable.

James Dinkelacker (True name)
--
................................
Jamie Dinkelacker   Palo Alto CA  (almost a true name)
<EMAIL_ADDRESS>  415.941.4782

{% endraw %}
```

## Thread

+ Return to [October 1993](/archive/1993/10)

+ Return to "[Arthur Chandler <arthurc@crl.com>](/authors/arthur_chandler_arthurc_at_crl_com_)"
+ Return to "[Eli Brandt <ebrandt@jarthur.Claremont.EDU>](/authors/eli_brandt_ebrandt_at_jarthur_claremont_edu_)"
+ Return to<EMAIL_ADDRESS>(Jamie Dinkelacker)](/authors/jamie_at_netcom_com_jamie_dinkelacker_)"

+ 1993-10-21 (Wed, 20 Oct 93 23:47:55 PDT) - Re: Something Silly, Something Serious -<EMAIL_ADDRESS>(Jamie Dinkelacker)_
  + 1993-10-22 (Fri, 22 Oct 93 16:28:19 PDT) - [Anonymity versus Responsibility](/archive/1993/10/bcf83fad15084c433b7311688d58d292e0c64a4bdbe1c0f80f8bc68a09c30df7) - _Arthur Chandler<EMAIL_ADDRESS>    + 1993-10-23 (Fri, 22 Oct 93 17:38:21 PDT) - [Re: Anonymity versus Responsibility](/archive/1993/10/eb2543f9b6b9714a502c59e95eea7e6cf2675620dd98b9f8115ff519acc8f02c) - _Eli Brandt<EMAIL_ADDRESS>


text:
Twitter ~ Playing with Python

Requirements:
* Python
* Scrapy
* BeautifulSoup4

Usage: change to the user_history directory and run:

scrapy crawl user_history_spider -s LOG_FILE=scrapy.log -s LOG_LEVEL='INFO' -o scraped_data.json -a handle=BarackObama

(replace "BarackObama" with the Twitter user handle of interest)

Tweets are returned as best approximating the Twitter tweet format (ref: https://dev.twitter.com/overview/api/tweets) as possible.

Additional fields include:
* created_at_ts: UTC timestamp corresponding to the created_at field
* entities item contains pure array lists of the correpsonding entity, without additional information (i.e. tweet.entities.hashtags is an array of hashtag terms only)
* date_scraped: date and time when the record was scraped ("now")
* url: actual url from which the record was scraped

repository: nutso/twitter

repo_name: nutso/twitter


text:
+++

title = "Other courses"
subtitle = ""
date = "2019-11-27T16:02:46-03:00"

+++
Here are older courses I have taught.

##### [Introduction to Programming](https://www.cin.ufpe.br/~phmb/ip/index.htm)

> An undergraduate level course for first year students, teaching the basics of programming, using Java and object-oriented concepts, but also introducing some aspects of C not available in Java. (Available only in Portuguese.)

##### [Aspect-oriented Programming with AspectJ](https://www.cin.ufpe.br/~phmb/cursoAOP/index.html)

> A graduate level course. (Available only in Portuguese.)

##### [Programming Languages Concepts and Paradigms](http://www.cin.ufpe.br/~in1007)

> A graduate level course discussing and comparing several programming languages concepts, paradigms and design decisions. Java, Standard ML and ADA are used to illustrate the aspects considered during the course. (Available only in Portuguese.)

##### [Specification of Distributed Systems](http://www.cin.ufpe.br/~phmb/CSPZ/)

> A graduate level course on CSP. (Available only in Portuguese.)

##### Rational Unified Process

> An [undergraduate](http://www.cin.ufpe.br/~if570) level course. (Available only in Portuguese.)

> A [graduate](http://www.cin.ufpe.br/~phmb/RUP) level course. (Available only in Portuguese.)

##### [Object Oriented Programming and Java](http://www.cin.ufpe.br/~if101)

> An undergraduate level course teaching the basics of object-oriented programming and Java, but also covering advanced concepts such as Software Contract and Parameterized Programming. (Available only in Portuguese.)

##### [UNIX: Introduction and Administration](https://www.cin.ufpe.br/~phmb/sysadm/programa.html)

> This course introduces the Unix operating system and presents basics aspects of Unix system administration. (Available only in Portuguese.)

repository: pauloborba/academic-kickstart

repo_name: pauloborba/academic-kickstart


text:
# Quick load tests n°2, 16/03/2022

## Context

The aim of this test is to see if we have a problem with jitsi-meet-torture instances, as they seem to shut off after around 30-40 minutes.

## Description of the infrastucture

Specs of the JVB nodepool for this test:
- 1 server
- 4 CPU
- 16 GB of RAM
- 1 pod
- no HPA
- no resource limits on the JVB pod

## Approach

We put 12 people in a conference, 10 with cameras, and we leave it be for 30 minutes to see if they disconnect. We look at resource usage on jitsi-meet-torture at the same time to see if the server is overloaded, etc...

## Results on jvb

Jitsi metrics were gathered with Prometheus and visualized with Grafana.

As shown in the following graph, after 30 minutes, we start to lose a few participants. All participants were added at the same time, so this is not due to end of conference (which was set to 6000 seconds)
![participants](resources/participants.png)

As seen in the following jitsi graphs, all resources were completely constant, there is nothing that could cause a problem after 30 minutes:

| Metric           | Graph                                               | Notes                                                                                |
| ---------------- | --------------------------------------------------- | --------------------------------------------------------------------------------------------- |
| CPU usage       | ![cpu](resources/cpu.png)             | CPU usage of each JVB                                                |
| RAM usage | ![ram](resources/ram.png) | RAM usage of jvb         |
| Receive bandwidth              | ![receive_bw](resources/receive_bw.png)                           | Bandwidth in reception of jvb                           |
| Transmit bandwidth | ![transmit_bw](resources/transmit_bw.png) | Bandwidth in transmission of jvb         |
| Websockets | ![websockets](resources/websockets.png) | Number of open websockets       |
| JVB stress level | ![1_jvb_stresslevel](resources/stresslevel.png) | Stress level of the JVB, defined in the [prometheus exporter](https://github.com/systemli/prometheus-jitsi-meet-exporter)       |
| JVB jitter aggregate | ![jitter_aggregate](resources/2_jitter_aggregate.png) | (Experimental) [Packet delay variation](https://en.wikipedia.org/wiki/Packet_delay_variation)       |

## Results on torture

Jitsi-meet-torture metrics are gathered with htop and docker stats.

At startup, cpu is quite overloaded, but is still ok:
![6-minutes](resources/6-minutes.png)

After 15 minutes, things have cooled down and we are far from limit:
![15-minutes](resources/15-minutes.png)
![15-minutes-docker](resources/15-minutes-docker.png)

After 30 minutes, on one instance, we lose some stats on docker which indicates a problem:
![30-minutes-docker](resources/30-minutes-docker.png)

We already have lost multiple participants at this point.

On another instance, things still seem ok:
![30-minutes](resources/30-minutes.png)

until they do not three minutes later. This instance's cpu becomes overloaded suddenly, as the quality of the camera of some participants becomes very degraded.
![33-minutes](resources/33-minutes.png)

This keeps going going for a few minutes. Then, 38 minutes after the beginning of the conference, one participant gets kicked out and this instance's cpu immediately cools down.
![38-minutes](resources/38-minutes.png).

Only one participant of this instance remained, the other had already been kicked off somewhere in between.

So this shows that what limits the VM is its CPU, but we cannot yet explain why it suddenly becomes overloaded.

## Conclusion

DEV1-S instances are two small for two participants over long conferences with ten cameras. We will use DEV1-M for two participants (or three if tests are conclusive). Previous test results are faulty because of this problem.

Later tests show that 2 participants in DEV1-M can last a long time (over 1 hour) in the same conditions without dropping quality or being kicked out.

repository: openfun/jitsi-meet-torture-rocket

gha_language: HCL

repo_name: openfun/jitsi-meet-torture-rocket


text:
# Stockme-api

This is the (future) backend part of the image upload website [Stockme](http://stockme.fr) (name subject to change).

It's a simple rails 5 api application, developed and tested with Ruby v2.4.0, older versions should probably work but there's no guarantee. (Rails 5 needs at least v2.2.2).

Note: This project is part of my [12 Months / 12 Side Projects](https://blog.1ppm.club/12-months-12-side-projects-are-you-in-c395dbcd648e#.1l5cy0ooh).

### Requirements

* Imagemagick

### Installation

* Clone repository
* Copy `config/database.yml-dist` to `config/database.yml` and configure your database cf [Rails documentation](http://edgeguides.rubyonrails.org/configuring.html#configuring-a-database)
* Copy `config/secrets.yml-dist` to `config/secrets.yml` and change value to something quite unique.
* Copy `config/initializers/cors.rb-dist` to `config/initializers/cors.rb`
* Copy `config/application.rb-dist` to `config/application.rb`
* `./bin/bundle install`
* `./bin/rails db:setup`
* `./bin/rails server`

### Testing

Simply run `./bin/rails test`

repository: Fiaxhs/stockme-api

gha_language: Ruby

repo_name: Fiaxhs/stockme-api


text:
---
layout: post
title: Show Me The TV!
thumbnail-path: "img/show-me/show-me-the-tv.png"
short-description: Show Me The TV! is a web app to search for information on TV Shows and Movies using The Movie Database API
---

{:.center}
![]({{ site.baseurl }}/img/show-me/main.PNG)

## Technologies Used

- NodeJS
- ExpressJS
- Axios
- The Movie Database API
- ES6
- ReactJS
- Material-UI
- Webpack
- Babel
- Jest
- Enzyme
- Supertest
- Amazon Web Services (Elastic Beanstalk)

[Deployed to AWS](http://showmethetv-env.uqrc23xqzq.us-east-2.elasticbeanstalk.com/)

[Click here to view the GitHub repo](https://github.com/tdfranklin/show-me-the-tv)

## Explanation

Show Me The TV is a web application that can be used to search and view information about TV Shows and Movies. It is a Full Stack Javascript web application built with Node/Express on the back end and React on the front end and deployed using AWS Elastic Beanstalk. It queries The Movie Database API using Axios to get information on the shows and it is styled using Material UI (React components that implement Google's Material Design).

## Problem

My first, and by far the biggest, problem was Webpack. It's such a complex tool and has so many various plugins and settings. I probably spent close to half of my time simply trying to get my webpack config set up correctly (and I'm sure there are still many optimizations that could be made).

First, I wanted to make sure there was a clear separation between my back end API and the front end view.  Second, I was having issues making API calls on the front end. Since the front and back were running on separate servers/ports, when I was making calls, it was calling the wrong port.  Lastly, I was using the webpack dev server to run my front end on port 8080 (the default port for WDS) on one terminal and running my back end Express server on port 3000 on another, but was quickly getting frustrated with having to stop both servers, create a build, then restart the servers to see changes made on the back end.

## Solution

I was finally able to get Webpack and the Dev Server working as I wanted after a lot of trial and error, reading the Webpack docs and various articles, and watching several videos on YouTube of developers setting up Webpack.

For my first problem, I discovered that when you export your config file for Webpack, you can send it an array of multiple objects, so I used that to my advantage to have it bundle two files - one for the front end and one for the back end.  As for the API call issue, I had to go implement proxy settings in the webpack config for the dev server and this fixed the port issue.  Finally (and what saved me the most headaches), I was able to resolve the issue. A few minor tweaks to my webpack config, adding nodemon as a dev dependency, and then creating a new start script got everything up and running just how I wanted!

{% highlight javascript %}
//package.json
"scripts": {
    "server": "nodemon ./server/server.js",
    "devstart": "npm run server & webpack-dev-server --mode development --open --hot"
}

//webpack.cofig.js
const path = require('path');
const HtmlWebpackPlugin = require('html-webpack-plugin');
const nodeExternals = require('webpack-node-externals');

const commonModule = {
    rules: [
        {
            test: /\.js$/,
            exclude: /node_modules/,
            use: {
                loader: 'babel-loader'
            },
        },
    ],
};

module.exports = [
    {
        entry: path.resolve(__dirname, 'src', 'index.js'),
        output: {
            path: path.resolve(__dirname, 'public'),
            filename: 'app_bundle.js',
        },
        module: commonModule,
        plugins: [
            new HtmlWebpackPlugin({
                template: './src/index.html'
            })
        ],
        devServer: {
            contentBase: path.join(__dirname, '/public'),
            watchContentBase: true,
            proxy: [
                {
                    context: ['/api'],
                    target: 'http://localhost:3000',
                    secure: false,
                },
            ],
        }
    },
    {
        entry: path.resolve(__dirname, 'server', 'server.js'),
        output: {
            path: path.resolve(__dirname, 'public'),
            filename: 'server_bundle.js',
        },
        module: commonModule,
        target: 'node',
        externals: [nodeExternals()],
    },
];
{% endhighlight %}

## Problem

Next, I was getting compile errors with trying to use ES6 arrow functions (something I thought was supposed to be handled by babel's presets env and react).

## Solution

A quick Google search and I discovered this was resolved by simply adding a plugin (babel-plugin-transform-class-properties) to the .babelrc file:

{% highlight javascript %}
//.babelrc
{
    "presets": ["env", "react"],
    "plugins": [
        "babel-plugin-transform-class-properties"
    ]
}
{% endhighlight %}

## Results

I'm pretty happy with how well the app turned out given the short amount of time I was able to spend on it (~15 hours). In the future, I would like to add a few additional features to the application, like seeing related shows/movies and allowing users to login and save favorites and get recommendations based on favorites.

Home Screen/Popular TV Shows
{:.center}
![]({{ site.baseurl }}/img/show-me/main.PNG)

Searching for TV Shows
{:.center}
![]({{ site.baseurl }}/img/show-me/search.PNG)

More Info (TV Show)
{:.center}
![]({{ site.baseurl }}/img/show-me/tv-modal.PNG)

Popular Movies
{:.center}
![]({{ site.baseurl }}/img/show-me/movies.PNG)

More Info (Movie)
{:.center}
![]({{ site.baseurl }}/img/show-me/movie-modal.PNG)

## Conclusion

One of the biggest lessons I learned is just how much work went into CREATE-REACT-APP and why it is so popular when using React.  Still, I'm glad I took the time to really dive into Webpack and Babel and learn as much about it as I did.  Also, this is my first project using an external API so heavily and I learned quite a lot from that as well.


text:
# omnipay-stripe-checkout

**Stripe (Checkout) driver for the Omnipay PHP payment processing library**

Omnipay implementation of the Stripe payment gateway using their "Checkout" process.

[![Build Status](https://travis-ci.org/digitickets/omnipay-stripe-checkout.png?branch=master)](https://travis-ci.org/digitickets/omnipay-stripe-checkout)
[![Coverage Status](https://coveralls.io/repos/github/digitickets/omnipay-stripe-checkout/badge.svg?branch=master)](https://coveralls.io/github/digitickets/omnipay-stripe-checkout?branch=master)
[![Latest Stable Version](https://poser.pugx.org/digitickets/omnipay-stripe-checkout/version.png)](https://packagist.org/packages/digitickets/omnipay-stripe-checkout)
[![Total Downloads](https://poser.pugx.org/digitickets/omnipay-stripe-checkout/d/total.png)](https://packagist.org/packages/digitickets/omnipay-stripe-checkout)

## Compatibility

There are two versions of this driver; one is compatible with Omnipay v3, the other with Omnipay v2.

If any changes are made to one, please make sure those changes are ported to the other, where appropriate.

### Omnipay v3

This is the master branch, and is released as v3.\*.*

Please note, the maintainers of this package have no (easy) way of testing this version and rely on any contributors testing their changes.

### Omnipay v2

This is the omnipay-v2 branch, and (for historical reasons) is released as v1.\*.*

## Installation

**Important: Driver requires [PHP's Intl extension](http://php.net/manual/en/book.intl.php) and [PHP's SOAP extension](http://php.net/manual/en/book.soap.php) to be installed.**

The Stripe (Checkout) Omnipay driver is installed via [Composer](http://getcomposer.org/). To install, simply add it
to your `composer.json` file:

### Omnipay v3

```json
{
    "require": {
        "digitickets/omnipay-stripe-checkout": "~3.0"
    }
}
```

### Omnipay v2

```json
{
    "require": {
        "digitickets/omnipay-stripe-checkout": "~1.0"
    }
}
```

And run composer to update your dependencies:

    $ curl -s http://getcomposer.org/installer | php
    $ php composer.phar update

## What's Included

This driver handles transactions being processed by the ["Checkout" process of Stripe](https://stripe.com/docs/payments/checkout).

It is [Strong Customer Authentication](https://stripe.com/docs/strong-customer-authentication)\-aware.

It assumes you will use the [redirect method in the browser page](https://stripe.com/docs/payments/checkout/one-time#redirect-checkout) (ie that you will not host the card form yourself).

We have done the minimum necessary to get our system to work. If you need any further functionality, please submit a pull request (or ask us to make the change)

It supports refunds, but currently it only handles refunding the full amount of a transaction.

**Note:** the Stripe API does _not_ support negative- or zero-value items, so this driver filters them out. **Be aware** that the amount the customer pays
is only calculated from that filtered set of items, so if there are deductions, etc in your cart, they will _not_ be taken off the payment amount.
And of course zero-value items will not be shown on the card form.

## What's Not Included

TBC

## Basic Usage

For general Omnipay usage instructions, please see the main [Omnipay](https://github.com/omnipay/omnipay)
repository.

## Support

If you are having general issues with Omnipay, we suggest posting on
[Stack Overflow](http://stackoverflow.com/). Be sure to add the
[omnipay tag](http://stackoverflow.com/questions/tagged/omnipay) so it can be easily found.

If you believe you have found a bug in this driver, please report it using the [GitHub issue tracker](https://github.com/digitickets/omnipay-stripe-checkout/issues),
or better yet, fork the library and submit a pull request.

repository: wired-nick/omnipay-stripe-checkout

repo_name: wired-nick/omnipay-stripe-checkout


text:
# Release Policy

To employ proper [lifecycle](lifecycle.md) management for its components Windsor uses release policy which is tasked with keeping track of components created by Windsor and releasing them when needed.

Its contract is defined by `IReleasePolicy` interface and can be accessed (or changed) via `ReleasePolicy` property of `IKernel`

```csharp
var policy = container.Kernel.ReleasePolicy;
container.Kernel.ReleasePolicy = someOtherPolicy;
```

:warning: **Don't change release policy of working container:** While Windsor allows you to change its release policy, you should never do it after some components were already resolved. If you do, Windsor won't be able to release them properly anymore. If you're changing the policy, do it as one of very first operations on the container, before resolving any components.

## Default policy

By default Windsor will use `LifecycledComponentsReleasePolicy` which keeps track of all components that were created, and upon releasing them, invokes all their decommission lifecycle steps.

:information_source: **Always release components:** When release policy tracks your components Garbage Collector is not able to reclaim them. That's why it's crucial that you always release your components you resolve (either via call to `Resolve`/`ResolveAll` or via a [typed factory](typed-factory-facility.md)), especially ones that don't get released automatically. In particular this statement is true for [transient](lifestyles.md#transient) components, since unless you release them, all their instances will live on until you dispose the container.

## `NoTrackingReleasePolicy`

In cases when you don't want Windsor to track your components, you can resort to `NoTrackingReleasePolicy`. It never tracks the components created, opting out of performing proper component decommission. Its usage is generally discouraged and targeted at limited scenarios of integration with legacy systems or external frameworks that don't allow you to properly release the components.

## See also

* [Lifecycle](lifecycle.md)

## External resources

* [(Feb 19, 2010) Blog post by Davy Brion discussing hybrid release policy for integration with external framework](http://davybrion.com/blog/2010/02/avoiding-memory-leaks-with-nservicebus-and-your-own-castle-windsor-instance/)

repository: DamirAinullin/Windsor

gha_license_id: NOASSERTION

repo_name: DamirAinullin/Windsor


text:
# Ontology Merging Evaluation Datasets

This dataset has been used in the research papers.

# Publication:
* Samira Babalou, Elena Grygorova and Birgitta König-Ries, ''How good is this merged ontology?'', in ESWC2020, Poster and Demo track.
* Samira Babalou, Elena Grygorova and Birgitta König-Ries, ''How good is this merged ontology? Towards a customizable quality evaluation'', submitted to EKAW2020.

repository: fusion-jena/CoMerger

repo_name: fusion-jena/CoMerger


text:
---
page_type: sample
languages:
  - csharp
  - java
  - javascript
  - html
products:
  - azure
  - azure-blockchain-service
description: "This sample contains content and samples in number of areas, including connecting data producers and consumers to the or from the blockchain."
---

![Azure Blockchain Devkit MIT license badge](https://img.shields.io/badge/license-MIT-green.svg)
# Azure Blockchain Development Kit

This repository contains content and samples in number of areas, including:

-   [Connect](https://github.com/Azure-Samples/blockchain-devkit/tree/master/connect) - Connect various data producers and consumers to or from the blockchain
-   [Integrate](https://github.com/Azure-Samples/blockchain-devkit/tree/master/integrate) - Integrate legacy tools, systems and protocols
-   [Accelerators](https://github.com/Azure-Samples/blockchain-devkit/tree/master/accelerators) - Deep dive into End-to-End examples, or solutions to common patterns.
-   [DevOps for smart contracts](https://github.com/Azure-Samples/blockchain-devkit/tree/master/devops) - Bring traditional DevOps practices into a distributed application environment

## Contents

| File/folder       | Description                                                  |
| ----------------- | ------------------------------------------------------------ |
| `accelerators`    | Samples showing common end-to-end application patterns and business scenarios |
| `connect`         | Samples showing how to produce or consume information, sending to and reading from, the blockchain through outside sources |
| `devops`          | A series of patterns and whitepapers of how to integrate traditional software devops into a multi-party, distributed, application environments |
| `integrate`       | Samples showing how to connect to traditional enterprise systems such as SQL databases, FTP, storage, or cloud file and email services |
| `.gitignore`      | Define what to ignore at commit time                         |
| `CHANGELOG.md`    | List of changes to the sample                                |
| `CONTRIBUTING.md` | Guidelines for contributing to the Azure Blockchain Devkit   |
| `README.md`       | This README file                                             |
| `LICENSE`         | The license for the Azure Development Kit samples            |
## Prerequisites
- Where noted, some of the samples in this development kit may need the following

  - [Azure Blockchain Workbench](https://docs.microsoft.com/en-us/azure/blockchain/workbench/deploy#deploy-blockchain-workbench)
- Samples using the Ethereum Logic App connector available on the Azure Marketplace require an Ethereum network with a public RPC endpoint

  - If you wish to use the Azure Blockchain Workbench with the Ethereum Logic App connectors you will need a public RPC endpoint. You may use an existing one, or create a new one.

    - You may create a new endpoint in Azure [here](https://portal.azure.com/?pub_source=email&pub_status=success#create/microsoft-azure-blockchain.azure-blockchain-ethereumethereum-poa-consortium)

    - Once your endpoint is ready, copy the RPC address from the deployment output and deploy Azure Blockchain Workbench to your subscription. In the Azure deployment blade, enter the RPC endpoint in the blade as shown below

      ![](./media/wbdeployment.PNG.jpg)

## Feedback
For general product feedback, please visit our [forum](https://techcommunity.microsoft.com/t5/Blockchain/bd-p/AzureBlockchain&data=02).

To request additional features or samples, visit our [UserVoice site](https://feedback.azure.com/forums/586780-blockchain&data=02).

repository: Dpkkmr/blockchain-devkit

repo_name: Dpkkmr/blockchain-devkit


text:
# IoT Hubby

## Set-up
To set-up IoT Hubby, first ensure Node.js is installed.

## Environment File
In the root of the IoT Hubby directory, create a file named ".env".  Current variables:
```text
IOTHUB=[IoT Hub Connection String]
```

## hubby.json
The hubby.json file provides a place to save often used device queries and device twin json updates.

## Command Line Arguments
- Login
    "-l" or "--login" with IoT Hub Connection String
- List
    "-li" or "--list"
- Device Query
    "-dq" or "--devicequery" with name from hubby.json.

repository: jefferybennett/GBBIoTHackathon

repo_name: jefferybennett/GBBIoTHackathon