text:
# Rollbar.NET Notifier SDK

A .NET Rollbar Client/Notifier that can be used in any application built on the following .NET versions: .NET Core 2.0+, .NET Standard 2.0+, .NET Full Framework 4.5+, Mono, Xamarin, and, in general, any implementation of the .NET Standard 2.0+.
It simplifies building data payloads based on exception data, tracing data, informational messages and telemetry data and sends the payloads to the Rollbar API for remote monitoring and analysis of the hosting application's behavior.'

It also includes a collection of Rollbar.NET plug-ins into most popular .NET logging and exception handling libraries/frameworks, like:
*   Serilog
*   log4net
*   NLog
*   Microsoft Enterprise Library's Exception Handling block
*   etc.
*   as well as RollbarTraceListener and ASP.NET Core Rollbar middleware.

These plug-ins simplify integration of the Rollbar.NET Notifier into codebases that are already using any of these libraries/frameworks using the libraries' native extensions mechanisms.

## Codebase status (code quality and CI build)

### [Rollbar.NET](https://github.com/rollbar/Rollbar.NET) repo
[![Codacy Badge](https://api.codacy.com/project/badge/Grade/badd7f93cd7b4dc8b2c4261e7b23c880)](https://www.codacy.com/app/akornich/Rollbar.NET?utm_source=github.com&utm_medium=referral&utm_content=rollbar/Rollbar.NET&utm_campaign=Badge_Grade)[![Build Status](https://dev.azure.com/rollbar/Rollbar.NET/_apis/build/status/rollbar.Rollbar.NET?branchName=master)](https://dev.azure.com/rollbar/Rollbar.NET/_build/latest?definitionId=1&branchName=master)

### [Rollbar.NET @ Wide Spectrum Computing](https://github.com/WideSpectrumComputing/Rollbar.NET) repo (primary development fork)
[![Codacy Badge](https://api.codacy.com/project/badge/Grade/9adf26abd5694ebb8fecf6d4925f1da7)](https://www.codacy.com/app/WideSpectrumComputing/WideSpectrumComputing-Rollbar.NET?utm_source=github.com&utm_medium=referral&utm_content=WideSpectrumComputing/Rollbar.NET&utm_campaign=Badge_Grade)[![Build Status](https://dev.azure.com/wsc0610/wsc/_apis/build/status/WideSpectrumComputing.Rollbar.NET?branchName=master)](https://dev.azure.com/wsc0610/wsc/_build/latest?definitionId=1?branchName=master)

## Install

Using Nuget Package Manager:

    ```Install-Package Rollbar```

## Blocking vs Non-Blocking Use

The SDK is designed to have as little impact on the hosting system or application as possible. It takes an async "fire and forget" approach to logging. Normally, you want to use fully asynchronous logging, since it has virtually no instrumentational overhead on your application execution performance at runtime (especially when running on a multi-core/multi-processor system).

In v1.x.x versions of the SDK, the asynchronous logging calls were still performing some of their data processing functions (like packaging the data objects to log into a proper Rollbar Payload DTO instance) on the calling thread before asynchronously placing the payloads into a transmission queue. Hence, the duration of the logging method calls was proportional to the size and complexity of the data object to package and log.

In v2.x.x versions of the SDK, we moved the packaging of the data-to-log one level deeper and now it is handled in a context of a worker thread that is responsible for packaging of a proper payload DTO and queuing it for transmission to the Rollbar API Server.
As the result, the logging method calls are extremely quick now (under 20 microseconds) regardless of complexity and size of the data-to-log. All the methods now return a `Task` instance (instead of an `ILogger` instance as in v1.x.x) that could be either ignored in true "fire-and-forget" logging scenarios or could be waited (or awaited) to complete packaging and queuing of the payloads in some scenarios.

However, in some specific situations (such as while logging right before exiting an application), you may want to use a logger fully synchronously so that the application does not quit before the logging completes (including subsequent delivery of the corresponding payload to the Rollbar API).

That is why every instance of the Rollbar asynchronous logger (implementing `IAsyncLogger` interface) defines the `AsBlockingLogger(TimeSpan timeout)` method that returns a fully synchronous implementation of the `ILogger` interface that defines signatures of its logging methods that are very similar to the `IAsyncLogger`'s logging methods but returning the same `ILogger` instance instead os a `Task`. This approach allows for easier code refactoring when switching between asynchronous and synchronous uses of the logger.

Therefore, this call will perform the quickest possible asynchronous logging (true "fire-and-forget" logging):

```csharp
RollbarLocator.RollbarInstance.Log(ErrorLevel.Error, "test message");
```

while the following call will perform somewhat quick asynchronous logging (only having its payload packaging and queuing complete by the end of the call):

```csharp
RollbarLocator.RollbarInstance.Log(ErrorLevel.Error, "test message").Wait();
```

while next call will perform fully blocking/synchronous logging with a timeout of 5 seconds (including the payload delivery to the Rollbar API either complete or failed due to the timeout by the end of the call):

```csharp
RollbarLocator.RollbarInstance.AsBlockingLogger(TimeSpan.FromSeconds(5)).Log(ErrorLevel.Error, "test message");
```

In case of a timeout, all the blocking log methods throw `System.TimeoutException` instead of gracefully completing the call. Therefore you might want to make all the blocking log calls within a try-catch block while catching `System.TimeoutException` specifically to handle a timeout case.

## Basic Usage

*   Configure Rollbar with `RollbarLocator.RollbarInstance.Configure(new RollbarConfig("POST_SERVER_ITEM_ACCESS_TOKEN"))`
*   Send errors (asynchronously) to Rollbar with `RollbarLocator.RollbarInstance.Error(Exception)`
*   Send messages (synchronously) to Rollbar with `RollbarLocator.RollbarInstance.AsBlockingLogger(TimeSpan.FromSeconds(5)).Info(string)`

## Upgrading to v2.x.x from v1.x.x versions

All Rollbar notifier instances of `IRollbar` (that used to be expanding `ILogger` in v1.x.x versions) now implement `IAsyncLogger` instead of `ILogger`. As the result of this change, the rollbar instances lost support of fluent API, hence, they can not be cascaded like so:

```csharp
RollbarLocator.RollbarInstance.Log(ErrorLevel.Error, "error message")
                              .Log(ErrorLevel.Info, "info message")
                              .Log(ErrorLevel.Debug, "debug message");
```

and now have to be reworked as:

```csharp
RollbarLocator.RollbarInstance.Log(ErrorLevel.Error, "error message");
RollbarLocator.RollbarInstance.Log(ErrorLevel.Info, "info message");
RollbarLocator.RollbarInstance.Log(ErrorLevel.Debug, "debug message");
```

while the instance of the blocking Rollbar logger are still capable of supporting the fluent/cascading calls.

We think that convenience of the fluent APIs is less important than an ability to support completely "fire-and-forget" logging calls that could be waited upon if needed.

One more significant change in v2.x.x SDK API that should be fully backward compatible with the v1.x.x SDK API (hence, should not require any client code changes) but is important enough to be mentioned here:

You will notice that the `ILogger` interface was significantly simplified by getting rid of a large amount of logging methods' overloads based on types of the data-to-log (an `Exception` vs a `String` vs an `Object` vs a `Data` DTO, etc). Now, we only have the overloads that take in an `Object` (a good enough reason for backward compatibility of the latest API). The newly introduced `IAsyncLogger` interface defines the same set of methods as `ILogger` with the only difference between the equivalent method signatures - method return type: `IAsyncLogger`'s methods return `Task` while `ILogger`'s methods return `ILogger`.

## Upgrading to v1.x.x from earlier versions

In order to upgrade to v1.0.0+ from an earlier version, you should change your config from the old version

```csharp
Rollbar.Init(new RollbarConfig("POST_SERVER_ITEM_ACCESS_TOKEN"));
```

to

```csharp
    const string postServerItemAccessToken = "POST_SERVER_ITEM_ACCESS_TOKEN";
    RollbarLocator.RollbarInstance.Configure(
        new RollbarConfig(postServerItemAccessToken) { Environment = "proxyTest" }
        ) ;
```

Additionally, anywhere in your code that you were sending error reports via `Rollbar.Report(Exception)` or `Rollbar.Report(string)` will need to be replaced with either something like `RollbarLocator.RollbarInstance.Error(new Exception("trying out the TraceChain", new NullReferenceException()))` or `RollbarLocator.RollbarInstance.Info("Basic info log example.")`.

## Rollbar Plug-ins

We are adding extra projects to the Rollbar.sln solution that simplify integration of Rollbar services with existing popular .NET logging and tracing libraries like Serilog, log4net, NLog, etc.
These plug-in projects are named using following pattern `Rollbar.PlugIns.<LoggingLibraryToIntegrateWith>` and implement similarly named namespaces for the plug-ins.
Each plug-in maintains its own versioning schema and is distributed as its own NuGet package using the naming pattern mentioned above.

## More Information about the SDK

More detailed information about Rollbar.NET usage and API reference are available at [https://docs.rollbar.com/docs/dotnet](https://docs.rollbar.com/docs/dotnet)

## Where you can find the SDK performance benchmarking results

The benchmarking results are stored within the [Rollbar.Benchmarks folder](https://github.com/rollbar/Rollbar.NET/tree/master/Rollbar.Benchmarks) in a subfolder per an SDK release.
You,probably, want to start by reviewing the result/Rollbar.Benchmarker.RollbarLoggerBenchmark-report.html file within each of the subfolders and, then, to drill down for more details within the rest of the
BenchmarkDotNet generated artifacts.

## Help / Support

If you run into any issues, please email us at [support<EMAIL_ADDRESS>
For bug reports, please [open an issue on GitHub](https://github.com/rollbar/Rollbar.NET/issues/new).

## Contributing

1.  [Fork it](https://github.com/rollbar/Rollbar.NET)
2.  Create your feature branch (```git checkout -b my-new-feature```).
3.  Commit your changes (```git commit -am 'Added some feature'```)
4.  Push to the branch (```git push origin my-new-feature```)
5.  Create new Pull Request

gha_language: C#


text:
---
layout: post
title: March 29th - Extreme Love...is giving.
categories: [Verse of the Day]
alias: [/VerseOfTheDay/2010/03/29/]
---

_I John 3:17
But whoso hath this world's good, and seeth his brother have need,
and shutteth up his bowels of compassion from him, how dwelleth the
love of God in him?_

Need a smile? Consider this quote from The Matchmaker: "Money is
like manure; it's not worth a thing unless it's spread around
encouraging young things to grow." When you give to others, you are
helping the love of God to grow in your life and the lives of others.
Are you smiling? Spread God's love around, it grows everywhere!

 --

Jesus Every Day is a ministry of Rodgers Baptist Church in Garland, Texas.

license: MIT

branch_name: refs/heads/master

extension: markdown

gha_language: JavaScript

license_type: permissive


text:
/**
 * Checkout behavior flags
 *
 * In libgit2, checkout is used to update the working directory and index
 * to match a target tree.  Unlike git checkout, it does not move the HEAD
 * commit for you - use `git_repository_set_head` or the like to do that.
 *
 * Checkout looks at (up to) four things: the "target" tree you want to
 * check out, the "baseline" tree of what was checked out previously, the
 * working directory for actual files, and the index for staged changes.
 *
 * You give checkout one of three strategies for update:
 *
 * - `GIT_CHECKOUT_NONE` is a dry-run strategy that checks for conflicts,
 *   etc., but doesn't make any actual changes.
 *
 * - `GIT_CHECKOUT_FORCE` is at the opposite extreme, taking any action to
 *   make the working directory match the target (including potentially
 *   discarding modified files).
 *
 * - `GIT_CHECKOUT_SAFE` is between these two options, it will only make
 *   modifications that will not lose changes.
 *
 *                         |  target == baseline   |  target != baseline  |
 *    ---------------------|-----------------------|----------------------|
 *     workdir == baseline |       no action       |  create, update, or  |
 *                         |                       |     delete file      |
 *    ---------------------|-----------------------|----------------------|
 *     workdir exists and  |       no action       |   conflict (notify   |
 *       is != baseline    | notify dirty MODIFIED | and cancel checkout) |
 *    ---------------------|-----------------------|----------------------|
 *      workdir missing,   | notify dirty DELETED  |     create file      |
 *      baseline present   |                       |                      |
 *    ---------------------|-----------------------|----------------------|
 *
 * To emulate `git checkout`, use `GIT_CHECKOUT_SAFE` with a checkout
 * notification callback (see below) that displays information about dirty
 * files.  The default behavior will cancel checkout on conflicts.
 *
 * To emulate `git checkout-index`, use `GIT_CHECKOUT_SAFE` with a
 * notification callback that cancels the operation if a dirty-but-existing
 * file is found in the working directory.  This core git command isn't
 * quite "force" but is sensitive about some types of changes.
 *
 * To emulate `git checkout -f`, use `GIT_CHECKOUT_FORCE`.
 *
 *
 * There are some additional flags to modified the behavior of checkout:
 *
 * - GIT_CHECKOUT_ALLOW_CONFLICTS makes SAFE mode apply safe file updates
 *   even if there are conflicts (instead of cancelling the checkout).
 *
 * - GIT_CHECKOUT_REMOVE_UNTRACKED means remove untracked files (i.e. not
 *   in target, baseline, or index, and not ignored) from the working dir.
 *
 * - GIT_CHECKOUT_REMOVE_IGNORED means remove ignored files (that are also
 *   untracked) from the working directory as well.
 *
 * - GIT_CHECKOUT_UPDATE_ONLY means to only update the content of files that
 *   already exist.  Files will not be created nor deleted.  This just skips
 *   applying adds, deletes, and typechanges.
 *
 * - GIT_CHECKOUT_DONT_UPDATE_INDEX prevents checkout from writing the
 *   updated files' information to the index.
 *
 * - Normally, checkout will reload the index and git attributes from disk
 *   before any operations.  GIT_CHECKOUT_NO_REFRESH prevents this reload.
 *
 * - Unmerged index entries are conflicts.  GIT_CHECKOUT_SKIP_UNMERGED skips
 *   files with unmerged index entries instead.  GIT_CHECKOUT_USE_OURS and
 *   GIT_CHECKOUT_USE_THEIRS to proceed with the checkout using either the
 *   stage 2 ("ours") or stage 3 ("theirs") version of files in the index.
 *
 * - GIT_CHECKOUT_DONT_OVERWRITE_IGNORED prevents ignored files from being
 *   overwritten.  Normally, files that are ignored in the working directory
 *   are not considered "precious" and may be overwritten if the checkout
 *   target contains that file.
 *
 * - GIT_CHECKOUT_DONT_REMOVE_EXISTING prevents checkout from removing
 *   files or folders that fold to the same name on case insensitive
 *   filesystems.  This can cause files to retain their existing names
 *   and write through existing symbolic links.
 */

repository: guillep/pharo

extension: md

gha_language: Smalltalk

gha_license_id: MIT

repo_name: guillep/pharo


text:
---
breadcrumbs:
- - /developers
  - For Developers
- - /developers/tools-we-use-in-chromium
  - Tools we use in Chromium
- - /developers/tools-we-use-in-chromium/grit
  - GRIT
page_name: grit-design-overview
title: GRIT Design Overview
---

# Introduction

This document is intended as a rough overview of the design of GRIT.

Before reading this, you should probably read the [GRIT user's
guide](/developers/tools-we-use-in-chromium/grit/grit-users-guide) for
background.

# Design Overview

The source of truth in GRIT is the .grd file (an XML formatted file). This file
format is only an input format for GRIT; it is not a resource format in and of
itself. For some good examples of what .grd files look like, see the [various
such
files](https://cs.chromium.org/search/?q=file:%5C.grd&sq=package:chromium&type=cs)
in the Chromium project.

The structure and semantics of the .grd file are encoded in the various
sub-classes of grit.node.Base.

From the .grd file and various files it may reference, GRIT builds up an
in-memory representation of all of the "source" resources, most often the
resources as they are designed in English, although a different source language
than English may be specified.

Through the <outputs> section, the .grd file also specifies which
languages to output, and in which formats.

GRIT uses the idea that identical messages (translation units) should receive
identical translations, to avoid translators having to translate the same
message multiple times. To enable multiple identical messages to have different
meanings (e.g. "open" as a noun vs. "open" as a verb) GRIT adds the ability to
specify a *meaning* attribute that allows the messages to be translated
differently.

The .grd file may contain various types of resources:

*   Non-translatable resources such as images, that should get output by
            GRIT to whatever resource format is being used. This is what the
            <include> node is for.
*   Single mesages (translation units) using the <message> node.
            Non-translatable parts of messages may be demarcated with <ph>
            nodes (short for "placeholder").
*   Structured resource formats, that GRIT can break down into multiple
            messages. Examples are HTML files and things such as dialog box or
            menu definitions from Windows .rc files. The <structure> node
            is used to reference these formats, and always points to a file
            external to the .grd file.

A *formatter* is something that knows how to take a .grd file and turn it into
the resource format (e.g. Windows .rc files, Chromium .pak files, Android
resource files, etc.) in each of the different languages specified in the
<outputs> section.

The various formatters available are in the grit.format package.

A *gatherer* is something that knows how to break a structured resource
(<structure> node) into messages, and how to create a translated version
of the structured resource file.

The various gatherers available are in the grit.gather package.

A *tool* is something you invoke from the command line. Tools live in the
grit.tool package and are invoked as grit xyz where xyz is the name of the tool,
and the binding from name to package is specified in the grit.grit_runner
module.

GRIT is meant as a tool that, given a set of input files in the source language,
and a set of translations, can produce resource files in all target languages
(by default, using pseudo-translations for messages that do not have available
translations). It has basic features for packaging messages for delivery to
translators, and for receiving translations back from translators. Its formats
for this are the .xmb format (generated by the grit xmb tool) and the .xtb
format (referenced by the <translation> node in the .grd file). These are
very basic formats that contain the messages, with placeholders and with any
descriptions provided to give the translators context. The assumption is that
there is some other system that reads the .xmb format, provides translators with
another format or a UI that lets them translate more easily, then takes what it
receives back from translators and packages it back up into the .xtb format.

repository: iridium-browser/iridium-browser

repo_name: iridium-browser/iridium-browser


text:
# Laravel Base

This is starter base using the latest Laravel 5.2.22. Setup include Auth scaffold, Permission using Entrust, Boostrap 3, Laracasts generator, PHP to Vars and Easy Flash.

# How to install

1. git clone https://github.com/cyberfly/laravelbase.git yourfoldername
2. cd yourfoldername
3. composer install
4. composer update
5. cp .env.example .env
6. php artisan key:generate
7. update the db configuration in .env
8. php artisan migrate
9. php artisan db:seed

Thats all!

## Laravel PHP Framework 5.2.22

Laravel is a web application framework with expressive, elegant syntax. We believe development must be an enjoyable, creative experience to be truly fulfilling. Laravel attempts to take the pain out of development by easing common tasks used in the majority of web projects, such as authentication, routing, sessions, queueing, and caching.

## Official Documentation

Documentation for the framework can be found on the [Laravel website](http://laravel.com/docs).

## Contributing

Thank you for considering contributing to the Laravel framework! The contribution guide can be found in the [Laravel documentation](http://laravel.com/docs/contributions).

## Security Vulnerabilities

If you discover a security vulnerability within Laravel, please send an e-mail to Taylor Otwell at<EMAIL_ADDRESS>All security vulnerabilities will be promptly addressed.

## License

The Laravel framework is open-sourced software licensed under the [MIT license](http://opensource.org/licenses/MIT)

repository: cyberfly/laravelbaseold

repo_name: cyberfly/laravelbaseold


text:
# Fafnir-SSO
Fafnir-SSO is an SSO provider, which provides a Single Sign On functionality based on industry standards and best
practices, using 3rd party providers Fafnir generates JWT's which can be used uniformly by web applications in a
distributed cloud based setup.

Fafnir-IAM is the IAM module for the Hazelcast provider. It gives the ability to create individual user/pass users,
and configure claims for each of those users.

## Authentication Providers
Fafnir-SSO supports the following Authentication providers.
* Apple
* Economic customers
* Facebook
* Google
* Hazelcast (Username/Password)
* LinkedIn
* Microsoft Identity
* MitID
* SAML 2.0
* Unilogin
* Testing

## Authentication Tokens
Fafnir-SSO issues JWT RSA-512 tokens, which can be validated using the exposed public key (available on the
`/public-key` route). The fields populated are:
* sub: The subjects name, as provided by the Authentication provider.
* iss: The issuer, which will be `fafnir-<provider>`, where provider is the name of the Authentication provider. (E.g.
`fafnir-google` for the Google provider).
* iat: The time the JWT was issued at.
* name: The full name, as provided by the Authentication provider.

### Special Fields
There are however some special fields for some of the Authentication providers:

#### Hazelcast
The Hazelcast provider will also populate the `role` field on the JWT with the claims from IAM. This field is an array
of strings.

#### SAML
The SAML provider will populate the `role` field which each attribute from the SAML IdP. The `role` field is an array of
strings. Each attribute will be an element in the role field, where the attribute is a string of `key=value`.

This could look like this:
```JSON
{
  "role": [
    "firstName=Acto",
    "company=Acto ApS"
  ]
}
```

## Usage
This documents the v3.x releases, for previous versions see the [v2 README](https://github.com/actoaps/fafnir-sso/blob/master/README-v2.md).

From version 2 onward, configuration has been handled through individual environment variables. Environment variables
marked with :heavy_check_mark: are **required** if you want to enable that Authentication provider.

### Provider Configuration
These are only present on Fafnir-SSO. Fafnir-IAM does not support individual provider configuration.
* Apple
  * APPLE_AID - The Apple Application ID :heavy_check_mark:
  * APPLE_SECRET - The Apple Secret :heavy_check_mark:
* Economic customers
  * ECONOMIC_AST - The E-conomic Application Secret Token :heavy_check_mark:
  * ECONOMIC_AGT - The E-conomic Application Grant Token :heavy_check_mark:
* Facebook
  * FACEBOOK_AID - The Facebook Application ID :heavy_check_mark:
  * FACEBOOK_SECRET - The Facebook Secret :heavy_check_mark:
* Google
  * GOOGLE_AID - The Google Application ID :heavy_check_mark:
  * GOOGLE_SECRET - The Google Secret :heavy_check_mark:
* Hazelcast (Username/Password)
  * HAZELCAST_USERNAME_IS_EMAIL - Determines if usernames are stored in lowercase only, so that look ups can be performed case-insensitively, default is false.
  * HAZELCAST_PASSWORD_IS_ENCRYPTED - Determines if passwords are encrypted using RSA encryption, or hashed with bcrypt, default is false.
  * HAZELCAST_MAP_NAME - The name of the Hazelcast Map to use for storing user data. Default is fafnir-users
  * HAZELCAST_TCP_IP_ADDRESS - Makes Fafnir connect to hazelcast using TCP/IP instead of Multicast, to the specified address.
* LinkedIn
  * LINKED_IN_AID - The LinkedIn Application ID :heavy_check_mark:
  * LINKED_IN_SECRET - The LinkedIn Secret :heavy_check_mark:
* Microsoft Identity
As Fafnir is using OpenID Connect to authenticate, you need to check the "ID tokens" box under "Implicit grant and
hybrid flows" in the Authentication menu. If this box is not checked, you will receive an error upon authentication.
  * MSID_AID - The Azure App Application ID :heavy_check_mark:
  * MSID_SECRET - The Azure App Client Secret :heavy_check_mark:
  * MSID_TENANT - THe Azure App's chosen [tenancy](https://learn.microsoft.com/en-us/azure/active-directory/develop/active-directory-v2-protocols#endpoints)
:heavy_check_mark:
* MitID
  * MITID_AID - The MitID ClientID :heavy_check_mark:
  * MITID_SECRET - The MitID Client-Secret :heavy_check_mark:
  * MITID_AUTHORITY_URL - The URL to the MitID broker authority (for example `https://brokertest.signaturgruppen.dk/op`) :heavy_check_mark:
Do note, if Fafnir-SSO has test mode enabled, the MitID provider will use the `mitid_demo` scope instead of `mitid`.
Fafnir uses the `ssn` scope in order to add the users name to the resulting JWT.
* SAML 2.0
SAML can only be configured through FAFNIR IAM.
* Unilogin
  * UL_AID - The Unilogin Application ID
  * UL_SECRET - The Unilogin Secret :heavy_check_mark:
  * UL_WS_USER - Your Unilogin WebService username :heavy_check_mark:
  * UL_WS_PASS - Your Unilogin WebService password :heavy_check_mark:
  * UL_SSO - Whether to use Unilogin in Single Sign On mode, default is false.
* Testing
  * TEST_ENABLED - enables the `/test` endpoint which will always return a valid JWT for a test user.

### Fafnir Configuration
Fafnir-SSO and Fafnir-IAM also have some configuration options:

* Fafnir-SSO
  * FAFNIR_URL - The URL used to access this instance of Fafnir-SSO, default is `http://localhost:8080`.
  * FAFNIR_SUCCESS - The URL used to access this instance of Fafnir-SSO, default is `http://localhost:8080/loginredirect`.
  * FAFNIR_FAILURE - The URL used to access this instance of Fafnir-SSO, default is `http://localhost:8080/loginerror`.
  * HAZELCAST_TCP_IP_ADDRESS - The Hazelcast instance URI. By default it will run an embedded instance. (The embedded
instance will try connect to other instances on the same network).
  * KEYTSTORE_PASS - The [keystore password](#persistent-key-storage).
  * KEY_PASS - The [key password](#persistent-key-storage).
  * PROVIDER_LOWERCASE_SUBJECT - If set to true, it will transform all subjects returned from the providers to lowercase,
default is `false`. Hazelcast is seperate, see Hazelcast specific configuration.

* Fafnir-IAM
  * FAFNIR_URL - The URL used to get the public key from the SSO instance, default is `http://localhost`
  * FAFNIR_PORT - The PORT for the Fafnir-SSO instance, default is `8080`.
  * HAZELCAST_TCP_IP_ADDRESS - The Hazelcast instance URI. By default it will run an embedded instance. (The embedded
    instance will try connect to other instances on the same network).
  * IAM_ADMIN_SUBECT - The subject to generate for the `FAFNIR_ADMIN` user, default is `ADMIN`.
  * IAM_ADMIN_PASSWORD - If this is present, IAM will autogenerate a Hazelcast user with the claim `FAFNIR_ADMIN` which
gives access to the IAM dashboard.

## Persistent Key Storage
In some cases you may want to store the generated keypair (or use one you generated manually). In this case you should
mount a docker volume on `/var/lib/fafnir` and add the `KEYSTORE_PASS` and `KEY_PASS` environment variables.

If one does not already exists, Fafnir-SSO will generate a keystore in the directory, with the name `fafnir.jks`.
(Meaning it will be located on `/var/lib/fafnir/fafnir.jks`).

The keystore is a standard JKS format, the key alias is "FAFNIR".

## Fafnir Client
We also provide a Java library for interacting with Fafnir-SSO. It is called the
[fafnir-client](https://mvnrepository.com/artifact/dk.acto/fafnir-client). And can be installed with Maven or Gradle.

## Building from Source
Ensure that you have JDK 17 and Docker installed. Now, to build you need to run:
```Bash
.\gradlew build
```
This will build the whole project. Now to run both IAM & SSO, you can run the Compose project:
```Bash
docker compose up -d --build
```
You should now be able to access the project. The default compose project includes the `IAM_ADMIN_PASSWORD` environment
variable. This will give you access to IAM via the credentials: `ADMIN:pass`. You can now just open the
[Hazelcast provider](http://localhost:8080/hazelcast/login) and login with those credentials. From there you should get
redirected to the IAM dashboard.

repository: actoaps/fafnir-sso

gha_language: Java

repo_name: actoaps/fafnir-sso


text:
## RNA-seq

Preprocessing of RNA-seq has never been easier!

### Workflow overview (simplified)

An example quality control report can be [viewed here](https://vanheeringen-lab.github.io/seq2science/_static/rna_seq_multiqc.html).

#### Downloading of sample(s)

Depending on whether the samples you start seq2science with is your own data, public data, or a mix, the pipeline might start with downloading samples.
The downloading of samples is integrated into each workflow, so you don't have to start a download workflow first.
You control which samples are used in the [samples.tsv](#filling-out-the-samples-tsv).
Background on public data can be found [here](./download_fastq.html#download-sra-file).

#### Downloading and indexing of assembly(s)

Depending on whether the assembly and its index you align your samples against already exist seq2science will start with downloading of the assembly through [genomepy](https://github.com/vanheeringen-lab/genomepy).

#### Read trimming

The pipeline starts by trimming the reads with Trim Galore! or Fastp (the default).
The trimmer will automatically trim the low quality 3' ends of reads, and removes short reads.
During quality trimming it automatically detects which sequencing adapter was used (if it wasn't trimmed off yet), and then trims this as well.
Trimming parameters for the pipeline can be set in the configuration, for example:
```
trimmer:
  fastp:
    trimoptions: --trim_front1 3 --trim_front2 14 --trim_poly_x
```

#### Alignment

Reads are aligned using `HISAT2` or `STAR` (the default).
Sensible defaults have been set, but can be overwritten for either (or both) the indexing and alignment by specifying them in the `config.yaml`.

After trimming the reads are aligned against an assembly. Currently we support *bowtie2*, *bwa*, *bwa-mem2*, *hisat2*, *minimap2* and *STAR* as aligners. Choosing which aligner is as easy as setting the *aligner* variable in the `config.yaml`, for example: `aligner: bwa`. Sensible defaults have been set for every aligner, but can be overwritten for either (or both) the indexing and alignment by specifying them in the `config.yaml`:

```
aligner:
  bwa-mem:
    index: '-a bwtsw'
    align: '-M'
```

The pipeline will check if the assembly you specified is present in the *genome_dir*, and otherwise will download it for you through [genomepy](https://github.com/vanheeringen-lab/genomepy).
All these aligners require an index to be formed first for each assembly, but don't worry, the pipeline does this for you.

#### Bam sieving

After aligning the bam you can choose to remove unmapped reads, low quality mappings, duplicates, and multimappers.
Again, sensible defaults have been set, but can be overwritten.

#### Strandedness

Most sequencing protocols at present are strand-specific.
This specificity can be used to help identify pseudogenes originating from antisense DNA, or genes with overlapping regions on opposite strands without ambiguity.
Strandedness is inferred automatically for all RNA-seq samples.
For aligners it is inferred by RSeQC, the results of which can be reviewed in the MultiQC.
RSeQC inference can be overwritten by column `strandedness` in the samples.tsv.
This column may contain identifiers `no`, `forward` or `reverse`.
If strandedness is unknown (for some samples), fields may be left blank or filled with `nan`.
Setting `ignore_strandedness` in the config.yaml will resulting in gene counting to assume all reads are unstranded.

#### Gene quantification methods

RNA-seq can be performed using gene counting or abundance estimation methods.
Gene counting methods require BAM files, which are generated and processed in the Alignment, Bam sieving and Strandedness steps.
Gene abundances require trimmed fastqs, and are therefore not influenced by the aforementioned steps.

##### Gene counts  (with HTSeq/featureCounts)

Gene counts are obtained from the filtered BAM files using either `HTSeq` or `featureCounts` (default `HTSeq`).
These counts are then combined into a count matrix per assembly for use in downstream analyses.

##### Gene abundances (with Salmon)

Gene abundances can be estimated using `Salmon`.
Reads are aligned against the transcriptome to obtain transcript abundances (sequence strandedness is inferred automatically by Salmon), then summarized to gene-level using tximeta.
The Gene-level counts matrix are output similar to the gene counts method.
Additionally, `Salmon` generates a gene-level TPM matrix and a SingleCellExperiment object which can be opened in *R*, containing the transcript- and gene-level summaries.

#### Differential gene expression analysis

Seq2science outputs gene counts matrices for each assembly.
Additionally, it can perform differential expression analysis automatically.
See the [Differential gene/peak analysis page](../DESeq2.html) for more information!

#### Differential transcript usage

Quantifying with `Salmon`, the transcript-level summaries in the SingleCellExperiment object *should* be usable for differential transcript analysis with `DEXseq`, as described [in this vignette](http://www.bioconductor.org/packages/devel/workflows/vignettes/rnaseqDTU/inst/doc/rnaseqDTU.html#dexseq).

#### Differential exon usage

Differential exon analysis by [DEXseq](https://bioconductor.org/packages/release/bioc/html/DEXSeq.html) can be automatically prepared by setting `dexseq: True` in the config.yaml.
This will let seq2science to output an exon counts matrix per assembly, which can be loaded directly into `DEXSeqDataSet()`.

Note: this utilizes scripts implemented by DEXseq, which are [built for Ensembl genomes](https://bioconductor.org/packages/devel/bioc/vignettes/DEXSeq/inst/doc/DEXSeq.html#24_Preparing_the_annotation).

#### Trackhub

A UCSC compatible trackhub can be generated for this workflow.
See the [trackhub page](../results.html#trackhub) for more information!

### Filling out the samples.tsv

Before running a workflow you will have to specify which samples you want to run the workflow on.
Each workflow starts with a `samples.tsv` as an example, and you should adapt it to your specific needs.
As an example, the `samples.tsv` could look something like this:
```
sample    assembly    technical_replicates    descriptive_name
GSM123    GRCh38      heart_1      heart_merged        GSM234
GSM321    GRCh38      heart_1      heart_merged        GSM234
GSMabc    GRCh38      heart_2      heart_not_merged    GSM234
GSMxzy    danRer11    stage_8      stage_8             GSM234
GSM890    danRer11    stage_9      stage_9             GSM234
```

#### Sample column

If you use the pipeline on **public data** this should be the name of the accession (e.g. GSM2837484).
Accepted formats start with "GSM", "SRR", "SRX", "DRR", "DRX", "ERR" or "ERX".

If you use the pipeline on **local data** this should be the *basename* of the file without the *extension(s)*.
For example:
- `/home/user/myfastqs/sample1.fastq.gz` -------> `sample1` for single-ended data
- `/home/user/myfastqs/sample2_R1.fastq.gz` ┬> `sample2` for paired-ended data
 `/home/user/myfastqs/sample2_R2.fastq.gz` ┘

For **local data**, some fastq files may have slightly different naming formats.
For instance, Illumina may produce a sample named `sample3_S1_L001_R1_001.fastq.gz` (and the `R2` fastq).
Seq2science will attempt to recognize these files based on the sample name `sample3`.

For **both local and public data**, identifiers used to recognize fastq files are the fastq read extensions (`R1` and `R2` by default) and the fastq suffix (`fastq` by default).
The directory where seq2science will store (or look for) fastqs is determined by the `fastq_dir` config option.
In the example above, the `fastq_dir` should be set to `/home/user/myfastqs`.
These setting can be changed in the `config.yaml`.

#### Assembly column

Here you simply add the name of the assembly you want your samples aligned against and the workflow will download it for you.

#### Descriptive_name column

The descriptive\_name column is used for the trackhub and multiqc report.
In the trackhub your tracks will be called after the descriptive name, and in the multiqc report there will be a button to rename your samples after this column.
The descriptive name can not contain '-' characters, but underscores '\_' are allowed.

#### technical_replicates column

Technical replicates, or any fastq file you may wish to merge on the fastq level, are set using the `technical_replicates` column in the samples.tsv file.
All samples with the same name in the `technical_replicates` column will be concatenated into one file with the replicate name.

Example `samples.tsv` utilizing replicate merging:
```
sample    assembly    technical_replicates
GSM123    GRCh38      heart
GSMabc    GRCh38      heart
GSMxzy    GRCh38      stage8
GSM890    GRCh38
```

Using this file in the alignment workflow will output *heart.bam*, *stage8.bam* and *GSM890.bam*.
The MultiQC will inform you of the trimming steps performed on all samples, and subsequent information of the 'replicate' files (of which only *heart* is merged).

Note: If you are working with multiple assemblies in one workflow, replicate names have to be unique between assemblies (you will receive a warning if names overlap).

##### keep

Replicate merging is turned on by default.
It can be turned off by setting `technical_replicates` in the `config.yaml` to `keep`.

#### Colors column

If you are producing a UCSC trackhub, seq2science will assign an alternating color gradient to your samples to distinguish them.
You can optionally specify the colors of each track by adding this column.
Colors can be added by name (google "matplotlib colors" for the options), or RGB values.
Empty fields are considered black.

### Filling out the config.yaml

Every workflow has many configurable options, and can be set in the `config.yaml` file.
In each `config.yaml` we highlighted a couple options that we think are relevant for that specific workflow, and set (we think) **reasonable default** values.

When a workflow starts it prints the configuration variables influencing the workflow, and (almost) all these values can be added in the `config.yaml` and changed to your liking.
You can see the complete set of configurable options in the [extensive docs](../schemas.html).

### Best practices

#### Genome assembly and gene annotation

The choice of genome assembly and gene annotation is of significant influence to the downstream analysis.
To explore available options, you could use [genomepy](https://github.com/vanheeringen-lab/genomepy), which comes installed in the seq2science conda environment.
Installing the desired genome and gene annotation in the {genomes_dir} will cause seq2science to use these files.

If the genome/annotation is missing from the {genomes_dir}, seq2science will attempt to download the named assembly from Ensembl, UCSC and the NCBI (in that order).

#### Aligners: STAR vs HISAT2

Both aligners have been found to perform well.
Selection should be dependent on familiarity and configuration options.

#### Quantifier: counts vs quantification

Both methods have been found valid for differential gene expression analysis, although results vary somewhat.
Caution is advised for the genes found by only one of the two methods.

#### Genome/Aligner/Quantifier

The most significant choice to be made is the genome assembly and gene annotation.

#### Reviewing the results

Unless configured not to, Seq2science makes several assumptions on your data which may be incorrect:
- that strandedness of each sample can be determined automatically.
- that duplicate reads are mostly caused by natural overexpression, not by library artifacts.

These assumptions can be tested by inspecting the MultiQC.
Should the results be disappointing, they can be overwritten using the `strandedness` column in the `samples.tsv` and the `markduplicates` variable in the `config.yaml` respectively.

gha_language: Python


text:
# Factory

Factories are tasked with creating instances of their corresponding Entity and managing the internal cache for that Entity type. So, for example, the Security Token Factory is tasked with fetching necessary data to instance a Security Token, as well as fetching/refreshing the internal Security Token cache

## Type parameters

▪ **EntityType**: [_Entity_](_entities_entity_.entity.md)_‹T›_

▪ **T**: _any_

▪ **U**: _any_

## Hierarchy

* **Factory**

  ↳ [Erc20TokenBalanceFactory](_entities_factories_erc20tokenbalancefactory_.erc20tokenbalancefactory.md)

  ↳ [InvestmentFactory](_entities_factories_investmentfactory_.investmentfactory.md)

  ↳ [SimpleStoFactory](_entities_factories_simplestofactory_.simplestofactory.md)

  ↳ [TieredStoFactory](_entities_factories_tieredstofactory_.tieredstofactory.md)

  ↳ [TokenholderFactory](_entities_factories_tokenholderfactory_.tokenholderfactory.md)

  ↳ [TaxWithholdingFactory](_entities_factories_taxwithholdingfactory_.taxwithholdingfactory.md)

  ↳ [WalletFactory](_entities_factories_walletfactory_.walletfactory.md)

## Index

### Constructors

* [constructor](_entities_factories_factory_.factory.md#constructor)

### Properties

* [Entity](_entities_factories_factory_.factory.md#entity)
* [cache](_entities_factories_factory_.factory.md#cache)
* [context](_entities_factories_factory_.factory.md#context)

### Methods

* [create](_entities_factories_factory_.factory.md#create)
* [fetch](_entities_factories_factory_.factory.md#fetch)
* [refresh](_entities_factories_factory_.factory.md#refresh)
* [update](_entities_factories_factory_.factory.md#update)

## Constructors

### constructor

+ **new Factory**\(`eClass`: [EntityClass](../interfaces/_entities_factories_factory_.entityclass.md)‹T, U›, `context`: [Context](_context_.context.md)\): [_Factory_](_entities_factories_factory_.factory.md)

_Defined in_ [_src/entities/factories/Factory.ts:42_](https://github.com/PolymathNetwork/polymath-sdk/blob/e8bbc1e/src/entities/factories/Factory.ts#L42)

Create a factory that can generate an entity

**Parameters:**

| Name | Type |
| :--- | :--- |
| `eClass` | [EntityClass](../interfaces/_entities_factories_factory_.entityclass.md)‹T, U› |
| `context` | [Context](_context_.context.md) |

**Returns:** [_Factory_](_entities_factories_factory_.factory.md)

## Properties

### Entity

• **Entity**: [_EntityClass_](../interfaces/_entities_factories_factory_.entityclass.md)_‹T, U›_

_Defined in_ [_src/entities/factories/Factory.ts:37_](https://github.com/PolymathNetwork/polymath-sdk/blob/e8bbc1e/src/entities/factories/Factory.ts#L37)

entity class that this Factory is in charge of generating and caching

### cache

• **cache**: _object_

_Defined in_ [_src/entities/factories/Factory.ts:28_](https://github.com/PolymathNetwork/polymath-sdk/blob/e8bbc1e/src/entities/factories/Factory.ts#L28)

#### Type declaration:

* \[ **key**: _string_\]: EntityType \| undefined

### context

• **context**: [_Context_](_context_.context.md)

_Defined in_ [_src/entities/factories/Factory.ts:32_](https://github.com/PolymathNetwork/polymath-sdk/blob/e8bbc1e/src/entities/factories/Factory.ts#L32)

## Methods

### create

▸ **create**\(`uid`: string, `params`: T\): _EntityType_

_Defined in_ [_src/entities/factories/Factory.ts:87_](https://github.com/PolymathNetwork/polymath-sdk/blob/e8bbc1e/src/entities/factories/Factory.ts#L87)

Get an entity from the cache. Creates it if it isn't cached, updates it if it is

**Parameters:**

| Name | Type | Description |
| :--- | :--- | :--- |
| `uid` | string | unique identifier for the entity |
| `params` | T | constructor data for the entity |

**Returns:** _EntityType_

### fetch

▸ **fetch**\(`uid`: string\): _Promise‹EntityType›_

_Defined in_ [_src/entities/factories/Factory.ts:57_](https://github.com/PolymathNetwork/polymath-sdk/blob/e8bbc1e/src/entities/factories/Factory.ts#L57)

Get an entity from the cache. Fetches the necessary data to create it if it isn't cached, refreshes it if it is

**Parameters:**

| Name | Type | Description |
| :--- | :--- | :--- |
| `uid` | string | unique identifier for the entity |

**Returns:** _Promise‹EntityType›_

### refresh

▸ **refresh**\(`uid`: string\): _Promise‹void›_

_Defined in_ [_src/entities/factories/Factory.ts:108_](https://github.com/PolymathNetwork/polymath-sdk/blob/e8bbc1e/src/entities/factories/Factory.ts#L108)

Fetch the data for an entity and updates its properties

**Parameters:**

| Name | Type | Description |
| :--- | :--- | :--- |
| `uid` | string | unique identifier for the entity |

**Returns:** _Promise‹void›_

### update

▸ **update**\(`uid`: string, `params`: Partial‹T›\): _Promise‹void›_

_Defined in_ [_src/entities/factories/Factory.ts:126_](https://github.com/PolymathNetwork/polymath-sdk/blob/e8bbc1e/src/entities/factories/Factory.ts#L126)

Update an entity's properties in place

**Parameters:**

| Name | Type | Description |
| :--- | :--- | :--- |
| `uid` | string | unique identifier for the entity |
| `params` | Partial‹T› | properties that should be updated |

**Returns:** _Promise‹void›_

repository: ishii-ryo-t/polymath-sdk

repo_name: ishii-ryo-t/polymath-sdk


text:
[![PyPi Version](https://img.shields.io/pypi/v/modlunky2.svg)](https://pypi.python.org/pypi/modlunky2/)

# modlunky2

Repository for modding interface for Spelunky 2.

# Credits

Special thanks to  `SciresM`, `Cloppershy`, `iojonmbnmb`, and `Dregu` for all of the help
in making this tool a reality.

## Installation

[Download the latest version](https://github.com/spelunky-fyi/modlunky2/releases) of modlunky2.exe to your Spelunky 2 installation directory.

## Usage

Follow the instructions in the [Modlunky 2 Wiki](https://github.com/spelunky-fyi/modlunky2/wiki).

## Disclaimer
You are strongly discouraged from using any modding tools in your actual online Steam installation as to prevent unlocking achievements, corrupting your savefile and cheating in the leaderboards. You should make a copy of your game somewhere else and install [Mr. Goldbergs Steam Emulator](https://gitlab.com/Mr_Goldberg/goldberg_emulator/-/releases) in the game directory. (TL;DR: Copy the steam_api64.dll from the zip to the offline game directory and create steam_appid.txt with the text `418530` in it.) Also block the modded installation in your firewall. If you break anything using this tool you get to keep both pieces. Do not report modding related bugs to Blitworks.

## Development

If you'd like to contribute to `modlunky2` here are some steps to setup your environment.

### VirtualEnv

*While not required, a virtualenv is a nice way to keep this projects dependencies isolated from the rest of your system. This step is optional but recommended*

In the root directory you can make a virtualenv. It will be excluded from commits by default

```console
python -m venv venv
```
Whenever developing the project you'll want to activate the virtualenv in your terminal. This is platform dependent and there are more comprehensive docs available here: https://docs.python.org/3/library/venv.html

> :warning: If you're using PowerShell on Windows you might need to run `Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser`. More information on execution policy is available in the link above.

| Platform | Shell           | Command to activate virtual environment |
|----------|-----------------|-----------------------------------------|
| POSIX    | bash/zsh        | $ source <venv>/bin/activate            |
|          | fish            | $ source <venv>/bin/activate.fish       |
|          | csh/tcsh        | $ source <venv>/bin/activate.csh        |
|          | PowerShell Core | $ <venv>/bin/Activate.ps1               |
| Windows  | cmd.exe         | C:\> <venv>\Scripts\activate.bat        |
|          | PowerShell      | PS C:\> <venv>\Scripts\Activate.ps1     |

### Setup

Once you have your virtual environment setup and activated you'll want to finish setting up the development environment.

```console
> git clone https://github.com/spelunky-fyi/modlunky2/
> cd modlunky2
> pip install -r requirements.txt
> python setup.py develop
```

This will install any dependencies as well as setting up links on your path to your local source files. Once this is done
you'll be able to execute the binaries right from your path after any changes to the source without the need to build or
install anything. If you add new source files you may have to run `python setup.py develop` again to make sure they're linked.

### Running Locally

```
modlunky2 --install-dir="C:\Program Files (x86)\Steam\steamapps\common\Spelunky 2"
```

### Building Distributions

#### PyPI
```
python setup.py sdist
python -m twine upload .\dist\modlunky2-$VERSION.tar.gz
```

#### EXE
```
pyinstaller.exe --clean .\pyinstaller-cli.py --add-data "src/modlunky2/tilecodes.txt;." --add-data "VERSION;." --add-data "src/modlunky2/static;static" --name modlunky2 --onefile --noconsole --icon=.\src\modlunky2\static\images\icon.ico
```

branch_name: refs/heads/main


text:
---
hrs_structure:
  division: '1'
  volume: '7'
  title: '20'
  chapter: '368'
  section: 368-3
type: hrs_section
tags:
  - Government
menu:
  hrs:
    identifier: HRS_0368-0003
    parent: HRS0368
    name: 368-3 Powers and functions of commission
weight: 57020
title: Powers and functions of commission
full_title: 368-3 Powers and functions of commission
---
**§368-3 Powers and functions of commission.** The commission shall have the following powers and functions:

(1) To receive, investigate, and conciliate complaints alleging any unlawful discriminatory practice under part I of chapter 489, chapter 515, and part I of chapter 378, and complaints filed under this chapter, and conduct proceedings on complaints alleging unlawful practices where conciliatory efforts are inappropriate or unsuccessful;

(2) To hold hearings and make inquiries, as it deems necessary, to carry out properly its functions and powers, and for the purpose of these hearings and inquiries, to administer oaths and affirmations, conduct depositions, compel the attendance of parties and witnesses and the production of documents by the issuance of subpoenas, examine parties and witnesses under oath, require answers to interrogatories, and delegate these powers to any member of the commission or any person appointed by the commission for the performance of its functions;

(3) To commence civil action in circuit court to seek appropriate relief, including the enforcement of any commission order, conciliation agreement, or predetermination settlement;

(4) To issue the right to sue to a complainant;

(5) To order appropriate legal and equitable relief or affirmative action when a violation is found;

(6) To issue publications and results of investigations and research that, in its judgment, will tend to promote goodwill and minimize or eliminate discrimination in employment, housing, and public accommodations;

(7) To submit annually to the governor and the legislature a written report of its activities and recommendations for administrative or statutory changes required to further the purposes of this chapter;

(8) To appoint an executive director, deputy executive director, attorneys, and hearings examiners who shall be exempt from chapter 76, and investigators and other necessary support personnel who shall be subject to chapter 76\. Section 28-8.3 notwithstanding, an attorney employed by the commission as a full-time staff member may represent the commission in litigation, draft legal documents for the commission, provide other necessary legal services to the commission, and shall not be deemed to be a deputy attorney general; and

(9) To adopt rules under chapter 91\. [L 1988, c 219, pt of §1; am L 1989, c 386, §6; am L 1991, c 80, §1 and c 252, §2; am L Sp 1993, c 8, §53; am L 2000, c 253, §150; am L 2001, c 55, §17(1)]

Case Notes

Claim for negligent and/or intentional infliction of emotional distress against Hawaii civil rights commission not barred under §662-15(1), as acts of investigating complaint, instituting suit based on finding of reasonable cause, and sending demand letter were part of routine operations of commission and did not involve broad policy considerations encompassed within the discretionary function exception. 88 H. 85, 962 P.2d 344 (1998).

The discretionary function exception in §662-15(1) is limited to situations in which a government agent is engaged in the effectuation of "broad public policy"; the investigation of a complaint by the Hawaii civil rights commission, in and of itself, does not involve such considerations; thus, a counterclaim for negligence in the performance of an investigation is not barred by sovereign immunity. 88 H. 85, 962 P.2d 344 (1998).

repository: SamMade/BlueAndKrabby

repo_name: SamMade/BlueAndKrabby


text:
# Features

CSS Modules defines a bunch of great features, and `modular-css` supports the best of them in a straightforward and consistent way.

- [Values](#values)
  - [Namespaces](#namespaces)
- [Scoped Selectors](#scoped-selectors)
- [Composition](#composition)
  - [Overriding Styles](#overriding-styles)

## Values

Values are useful in CSS, they're coming to the spec soon. Use them now because it'll make your life easier!

```css
/* values.css */
@value alert: #F00;
@value small: (max-width: 600px);

@media small {
    .alert { color: alert; }
}

/* will be output as */

@media (max-width: 600px) {
    .alert { color: #F00; }
}
```

### Namespaces

`modular-css` also supports value namespaces as a convenient shorthand way to access a bunch of shared values from a file.

```css
/* Specific values being imported */
@value vbox, hbox, centered from "./layout.css";

.content {
    composes: vbox, centered;
}

/* Namespace to collect all imports */
@value * as layout from "./layout.css";

.content {
    composes: layout.vbox, layout.centered;
}
```

## Scoped Selectors

By default all CSS selectors live in the global scope of the page and are chosen based on specificity rules. This has proven to be a model that makes it difficult to succeed and incredibly easy to blow off your own foot. `modular-css` scopes all selectors to the local file by default, ensuring that your CSS is always exactly as specific as it should be.

```css
.wooga { color: red; }

/* Becomes */

.f5507abd_wooga { color: red; }
```

By default the selector scoping is based off hashing the contents of the file but you can also provide your own custom function.

Using these now-mangled selectors would be problematic, if `modular-css` didn't give you the tools required to use them easily. When using the browserify transform any `require()` calls for CSS files will instead return an object where the keys match the classes/ids defined in the requested CSS file.

```js
var css = require("./styles.css");

// css is:
/*
{
    wooga : "f5507abd3_wooga",
    ...
}
*/

// so mithril code (or any templating code!) can do the following
m("div", { class : css.wooga });
// which would output
// <div class="f5507abd_wooga"></div>
```

These arrays of selectors can then be applied to elements using the much more nicely-named object keys and you're off to the races.

You can opt out of selector scoping by wrapping your classes/ids in the `:global()` pseudo-class, this will prevent them from being renamed but they will still be available in the module's exported object.

```css
/* styles.css */
:global(.global) { color: red; }
```
```js
var css = require("./styles.css");

// css is:
/*
{
    global : "global"
}
*/
```

Selector scoping is **only** done on simple classes/ids, any selectors containing tags or pseudo-selectors won't be exported.

## Composition

Selector limitations mean that it's difficult to use complicated selectors, so to enable building anything of complexity you can compose selectors. These compositions can be within a file or even pull in classes defined in other files.

```css
/* styles.css */
.single {
    composes: other from "./other.css";
    color: red;
}

.multiple {
    composes: more, than, one from "./multiple.css";
    /*
    Since .multiple doesn't declare any rules other than composes
    aggregate styles from other rules it will be stripped from the output
    */
}

.local {
    composes: single;
}
```

When this file is required the JS object will contain the expected keys, but the arrays will now contain more values.

```js
var css = require("./styles.css");

// css is:
/*
{
    single   : "dafdfcc_other aeacf0c_single",
    // Since .multiple is only a singular composes: declaration there's no need
    // for it to be rewritten, it's left out of the output
    multiple : "dafdfcc_more f5507abd_than aeacf0c_one",
    local    : "dafdfcc_other aeacf0c_single"
}
*/
```

If you're going to be doing a lot of composition with another file you can store the filename into a value for ease of referencing.

```css
@value guide: "../style-guide.css";

.head {
    composes: heading from guide;
    font-size: 120%;
}

.body {
    composes: body from guide;
    padding: 10px;
}
```

You can also get access to variables defined in other files for simple sharing of useful information.

```css
@value first, second from "./somewhere-else.css";
```

### Overriding Styles

Sometimes a component will need some customization for use in a specific location/design, but you don't want to bake that customization into the component.`:external(...)` helps you solve that problem.

In this case we've got an `input` component that is normally 100% of the width of its container, but when it's within the `fieldset` component it should only be half as wide.

```css
/* input.css */
.input {
    width: 100%;
}

/* fieldset.css */
.fieldset :external(input from "./input.css") {
    width: 50%;
}
```

repository: darthmaim/modular-css

repo_name: darthmaim/modular-css


text:
---
layout: post
title: [Samsung SW - Famous 7 Princesses]
date: 2020-5-29
description: txt to markdown
thumbnail: breakfast-orange-lemon-oranges-large.jpg
categories: Algorithm

# Information for the author block
author : Loui
---

```cpp

{% raw %}

	[200. [SAMSUNG SW – Famous 7 Princesses]
	- Wow, I have to say it was quite hard and difficult.
	- I thought it was a simulation problem, so if I had used DFS or BFS, I could’ve solved this problem.
	- but it was a combination problem. since although I used DFS or BFS, I wasn’t able to search like crossroad.
	- Therefore, I had to choose 7 people first using combination. After that, I had to check the member included at least 4 “S” member and if Yes, I also had to check the people were connected each other.
	- To determine they were connected, I used DFS.
	- see the code.
	#include<iostream>
	#include<vector>
	#include<set>
	using namespace std;
	vector<vector<char>> table(5, vector<char>(5, 0));
	vector<vector<bool>> visit;
	vector<vector<int>> temp_table;
	vector<pair<int, int>> s_pos;
	vector<pair<int, int>> cur_com;
	int dir[4][2] = { {-1,0},{0,-1},{1,0},{0,1} };
	int res = 0;
	int conneceted_size;

	void DFS(int x, int y) {
		conneceted_size++;
		for (int i = 0; i < 4; i++) {
			int nx = x + dir[i][0]; int ny = y + dir[i][1];
			if (nx >= 0 && ny >= 0 && nx < 5 && ny < 5 && temp_table[nx][ny] == 1 && visit[nx][ny] == false) {
				visit[nx][ny] = true;
				DFS(nx, ny);
			}
		}
	}
	bool isConnected() {
		conneceted_size = 0;
		temp_table.assign(5, vector<int>(5, 0));
		visit.assign(5, vector<bool>(5, false));
		for (int i = 0; i < 7; i++) temp_table[cur_com[i].first][cur_com[i].second] = 1;
		visit[cur_com[0].first][cur_com[0].second] = true;
		DFS(cur_com[0].first, cur_com[0].second);
		if (conneceted_size == 7) return true;
		return false;
	}

	void Combination(int start_x, int start_y, int cnt, int member) {
		if (cnt == 7 ) {
			if (member >= 4) {
				if (isConnected()) res += 1;
				return;
			}
			return;
		}
		for (int i = start_x; i < 5; i++) {
			for (int j = start_y; j < 5; j++) {
				cur_com.emplace_back(make_pair(i, j));
				bool S_member=false;
				if (table[i][j] == 'S') S_member = true;
				if (j == 4) {
					Combination(i + 1, 0, cnt + 1, member + S_member);
					start_y = 0;
				}
				else Combination(i, j + 1, cnt + 1, member + S_member);
				cur_com.pop_back();
			}
		}

	}

	int main() {
		ios_base::sync_with_stdio(false);
		cin.tie(NULL); cout.tie(NULL);

		//get input
		string input;
		for (int i = 0; i < 5; i++) {
			cin >> input;
			for (int j = 0; j < 5; j++) {
				table[i][j] = input[j];
				if (input[j] == 'S') {
					s_pos.emplace_back(make_pair(i, j));
				}
			}
		}

		//algorithm part
		Combination(0, 0, 0, 0);
		cout << res;
		return 0;
	}

{% endraw %}
```

url: https://raw.githubusercontent.com/suyeony0/suyeony0.github.io/d8fcd81d2cb5b2f8e663c9435c36a709c40470ac/_posts/2020-5-29-[Samsung SW - Famous 7 Princesses].markdown


text:
# Connect to switch #
ssh<EMAIL_ADDRESS>
pwd perched1234!@#*$
## Enter privileged mode ##
enable

configure termial

## Setup dhcp ##
ip dhcp excluded-address <IP_ADDRESS> <IP_ADDRESS>

ip dhcp pool SG30

network <IP_ADDRESS> <IP_ADDRESS>

default-router <IP_ADDRESS>

dns-server <IP_ADDRESS>

exit

## Setup vlans

vlans 30

name SG30

state active

exit

## Add interfaces

interface GigabitEthernet 1/0/x

switchport

switchport access vlan SG30

no shutdown

exit

interface vlan no shu30

ip address <IP_ADDRESS> <IP_ADDRESS>

no shutdown

exit

## Enable static route

ip routing

ip route <IP_ADDRESS> <IP_ADDRESS> <IP_ADDRESS>

exit

# pfSense Instalation
ESC-enter BIOS setup

F11 -boot menu

## Initial Install
A accept

I-install (OK)

-default US keymap

Auto-Guided Disk Setup

....install runs...

reboot

## Install Config

### 1-) Assign Interfaces

|  LAN4  |  LAN3  | LAN2  |  LAN1  |  COM  |
|--------|--------|-------|--------|-------|
|  em3   |  em2   |  em1  |  em0   | local |

1-Assign interface

n-skip vlan setup

em0-WAN interface

em1-LAN interface

(nothing to finish) y-proceed

reloading.....

### 2) Set Interface IPs

1-WAN interface

y-dhcp

n-dhcp6

blank for "none"  y-http webconfig protocol

2-LLAN int

<IP_ADDRESS>/24

<ENTER> for none

<ENTER> for none-disable ipv6

y-enbale DHCP

<IP_ADDRESS>-range start

<IP_ADDRESS>-range end

y-hhtp webconfig protocol

## Finshing Up (wizard)

in order to access the the router, complete the following

1. set you lab machine to static ip <IP_ADDRESS>

2. plug into the LAN interface (LAN on format face) and browse to <IP_ADDRESS>

3. complete first login to web GUI

default creds:

admin / pfsense

## Wizard>Pfsense Setup > General Information

set hostname sg30 pfsense locationdomain==lacal.lan

primary dns

uncheck block private networks

LAN ip address -<IP_ADDRESS>.1

subnet mask-24

set (and document) new admin password

### log back in

dashboard overview

top rigth + and add

service status

traffic graph

### Firewall> rules

secure out the box default  deny behavior

firewall > rules > wan > add

pass, proto=all, source=any, dest=any

firewall > rules > lan > add

pass, proto=all, source=any, dest=any

now disable NAT firewall . nat > outbound: disable radio button

## Configure Remaining Interfaces

assign

interfaces > assignments

add em2 (OPT1)

add em3 (OPT2)

save

enable

click interfaces name in list e.g OPT1

enable interface

ipv4 config type-none

ipv6 config type-none

save

check for double-gateway issue

system > routing:

make sure there is not more than one gateway entry

# Centos Networking

ifconfig depricated

ip replace

ip a (addr)

review information displayed

ip-4 addr - only show ipv4

UP, LOWER_UP, state Up

ip link set enp3847 down/up

## ip cheatsheet

ip addr

    ip a show dev enp0s3

    ip a add x.x.x.x/24 dev xxx

    ip a del x.x.x.x/24 dev xxx

 ip link

   ip link show dev enp0s3

   ip -s link

   ip link set dev xxx up

   ip link set dev xxx down

   ip link set empxxxx promisc on

ip route

ip neigh

  ip neigh show dev enp0s3

Manual Netork Setting

config file for each network interface:

ll /etc/sysconfig/network-scripts

## Use DHCP

edit the cofig file for desired interface:

sudo vi enp0s3

set BOOTPROTO=DHCP

remove ADDR / PREFIX / GATEWAY info (in any)

verify: restart networking and test

## Use Static

edit the config file for desired interface

sudo vi enp0s3

set BOOTPROTO=none ( chage to none)   ONBOOT (change to yes)

set IPADDR= <ip>

set PREFIX=24

set GATEWAY= <IP_ADDRESS>cd /

set DNS1=<dnsip>

set DNS2 =<secondary>

verify: restart networking and test

## Disable IPv6

sysctl.conf

edit the config file to disable IPv6 on all interfaces

sudo vi /etc/sysctl.conf

net.ipv6.conf.all.disable_ipv6 = 1

net.ipv6.conf.default.disable_ipv6 = 1

net.ipv6.conf.lo.disable_ipv6 = 1

load change from /etc/sysctl.conf file

sudo systctl -p

### host file

edit host file to remove the ipv6 entry ::1

sudo vi /etc/hosts

## Firewalld - Basic Usage

### open / allow traffic

sudo firewall-cmd --zone=public --add-port = ####/tcp --permanent

sudo firewall-cmd --reload

## Close/deny traffic

sudo firewall-cmd --zone=public --remove-port=####/tcp --permanent

sudo forewall-cmd --reload

### commit all running firewall rules into the startup rules

sudo firewall-cmd --runtime-to-permanent

### list all firewalld zones

list all firewall-cmd --list-all-zones

### Monitoring Activity

what's a socket?

 ip / port / protocol defined to provide a connection or services

 ss    is the new hotness

 ss -lnt   shows all listening

repository: pababou/NSM

repo_name: pababou/NSM


text:
# Description

## **=== WARNING === This plugin has been deprecated and is no longer supported. Please use the [salesforcecli/plugin-dev](https://github.com/salesforcecli/plugin-dev) plugin instead.**

This is the generator plugin for building plugins for the Salesforce CLI. The generated sfdx plugin and command are built on top of the [oclif cli framework](https://github.com/oclif/oclif). A plug-in adds functionality to Salesforce CLI. Some plug-ins are provided by Salesforce and are installed by default when you install the CLI. Some plug-ins, built by Salesforce and others, you install. When you have a requirement that an existing plug-in doesn’t meet, you can build your own using Node.js.

**Note:** As of<EMAIL_ADDRESS>if you want to override the static usage property you must use a getter. For consistency, we recommend keeping the standard behavior rather than overriding the usage property.

# Usage

## Check Your Salesforce CLI Version

Starting with Salesforce CLI version 6.8.2, the plug-in generator is offered as a core plugin and can be used out of the box. To check your Salesforce CLI version:

```
$ sfdx --version
sfdx-cli/6.42.0-ae478b3cb8 (darwin-x64) node-v8.9.4
```

## Generate a Salesforce CLI Plugin

Follow the **[Salesforce CLI Plug-In Developer Guide](https://developer.salesforce.com/docs/atlas.en-us.sfdx_cli_plugins.meta/sfdx_cli_plugins/cli_plugins.htm) **to create and update your plug-in. In the guide you will discover how to develop your own plug-ins for Salesforce CLI. Explore the Salesforce CLI architecture. Learn how to generate a plug-in using Salesforce Plug-In Generator, how to use Salesforce’s libraries to add functionality to your plug-in, and how to debug issues. Learn about our suggested style guidelines for naming and messages, and about our recommended best practices for plug-ins. And, peruse useful resources.

# Related Docs and Repositories

- [@forcedotcom/cli-packages](https://github.com/forcedotcom/cli-packages) - Lerna repository containing Salesforce CLI command api.
- [@forcedotcom/sfdx-core](https://github.com/forcedotcom/sfdx-core) - API for working with a Salesforce DX project and managing Salesforce orgs
- [@oclif/command](https://github.com/oclif/command) - Base command for oclif; this can be used directly without the generator
- [@oclif/config](https://github.com/oclif/config) - Most of the core setup for oclif lives here
- [@oclif/errors](https://github.com/oclif/errors) - Renders and logs errors from commands
- [@oclif/cli-ux](https://github.com/oclif/cli-ux) - Library for common CLI UI utilities
- [@oclif/test](https://github.com/oclif/test) - Test helper for oclif

repository: forcedotcom/sfdx-plugin-generate

gha_language: TypeScript

repo_name: forcedotcom/sfdx-plugin-generate


text:
# GameSoundEngine

## About
A simple, easy to use sound engine written in Swift, designed for iOS games. It supports playing background music and multiple simultaneous sound effects. To help ensure sonic variety, sound effects can be played with random pitch and volume levels, as well as randomly from a group of sound effects.

## Installation
The GameSoundEngine framework can be installed using CocoaPods. Add the following line to your project pod file and the run "pod install".

```text
	pod 'GameSoundEngine', '~> 1.2'
```

## Using GameSoundEngine

#### Importing the framework
All Swift source files that reference the GameSoundEngine framework will need the following import statement:

```swift
	import GameSoundEngine
```

#### Sound Engine Initialization
The Sound Engine needs to be initialized once per app session so that it can configure and setup its background music player and sound effect players. This should be done in your App Delegate didFinishLaunchingWithOptions method before any UI is displayed:

```swift
	SoundEngine.shared.startEngine()
```

or

```swift
	SoundEngine.shared.startEngine(numSFXPlayers: 20)
```

The optional numSFXPlayers parameter allows you to specify the number of sound effect players configured by the sound engine. The default value is 20 which should be sufficient for most games. But if your game needs to play large numbers of sounds simultaneously you may need to increase this number. The sound engine will let you know if numSFXPlayers needs to be increased by displaying the following message in the console:

```text
	All sfx players are busy. Increase numSFXPlayers in startEngine call
```

In addition to configuring sound and music players, the startEngine call also configures your app's audio session using AVAudioSession. It also creates notification listeners so that it can pause and resume sounds as needed when events such as a phone call, or Siri occur. The audio session is configured to have the following behavior as recommended by Apple's audio guidelines for game apps:

  - Silenced by the Ring/Silent switch and by screen locking
  - Pauses all audio when an audio interruption (e.g. phone call, Siri, etc.) occurs
  - Resumes audio when the audio interruption has ended
  - Play sound effects while allowing another app’s audio (i.e. the Music app) to play.
  - Play background music when other audio is not playing, otherwise allow the previous audio to play.

#### Setting Overall Volume
The master volume for background music and the master volume for all sound effects are controlled through two properties on SoundEngine object:

```swift
	SoundEngine.shared.backgroundMusicVolume = 1.0
	SoundEngine.shared.sfxVolume = 1.0
```

Valid values for the volume properties are 0.0 - 1.0, with 0.0 being no volume and 1.0 full volume.

#### Background Music
Background music can be played by calling the playBackgroundMusic method on the SoundEngine object:

```swift
	SoundEngine.shared.playBackgroundMusic("backgroundMusic.m4a", loop: true)
```

The loop parameter is optional and defaults to true when not present.

To stop the background music call stopBackgroundMusic:

```swift
	SoundEngine.shared.stopBackgroundMusic(fadeOut: true)
```

The fadeOut parameter is optional and defaults to true.

Note that only one background music file can be played at a time. Calling playBackgroundMusic while background music is already playing will stop the current music before starting the new background music.

GameSoundEngine can also play a random selection from an array of background music files.

```swift
	SoundEngine.shared.playRandomBackgroundMusic(["music1.m4a", "music2.m4a", "music3.m4a"], loop: true)
```

If the loop parameter is set to true, each loop will play a different random selection from the array of music files.

#### Sound Effects
To play a sound effect you first need to create an instance of the SoundSFX class specifying the name of the sound file resource in the initializer:

```swift
	let fireworkSound = SoundSFX("fireworkA.caf")
```

When the SoundSFX object is created, its initializer will preload the sound data from the resource file and load it into a data buffer so it is ready to play (the preloading is done on a background thread). The buffer will be released when the SoundSFX object goes out of scope and is released. This ensures low latency when playing the sound as the data is already loaded into memory before it is played. The best practice is to create your SoundSFX objects when your scene or view is initialized and then release the objects when the scene is released and the sounds are no longer needed.

To play a SoundSFX, simply call the play method on SoundSFX object:

```swift
	fireworkSound.play()
```

The volume for each SoundSFX can be set using an optional parameter in the initializer. The default value is 1.0.

```swift
	let fireworkSound = SoundSFX("fireworkA.caf", volume: 1.0)
```

#### Sound Effect Sonic Variety
Sound effects that are repeated over and over during a game can become very repetitive to users. To help solve this problem SoundSFX objects can be configured to allow the sound engine to randomly set a different volume and pitch for the SoundSFX each time it is played. This will help prevent the sounds from becoming too repetitive. The amount the volume and pitch can randomly vary is controlled through optional parameters in the SoundSFX initializer:

```swift
	let fireworkSound = SoundSFX("fireworkA.caf", volume: 1.0, volumeVary: 2.0, pitchVary: 100.0)
```

The volumeVary value is specified in dbs. A value of 2.0 indicates that the volume can randomly vary +/- 2 dbs from the base volume specified in the volume parameter. The pitchVary is specified in cents (1 musical semitone = 100 cents, 1 octave = 1200 cents). A value of 100.0 indicates that the pitch can very +/- 100 cents.

The framework contains some predefined constants that contain recommended values for the volumeVary and pitchVary values. These are good starting points, but any value can be specified.

```swift
	public let kVolumeVaryLow: Float = 1       // 1 db
	public let kVolumeVaryMedium: Float = 2    // 2 db
	public let kVolumeVaryLarge: Float = 3     // 3 db

	public let kPitchVaryLow: Float = 100      // 1 semitone
	public let kPitchVaryMedium: Float = 200   // 2 semitone
	public let kPitchVaryLarge: Float = 300    // 3 semitone
```

GameSoundEngine also supports randomly playing different variations of the same sound affect for even more sonic variety. For example if I have 3 different variations of the firework sound I can have the sound engine randomly pick one of the three different variations each time the effect is played. To accomplish this create an instance the RandomSoundSFX class and specify an array of SoundSFX objects:

```swift
    let fireworkSound = RandomSoundSFX([
        SoundSFX("fireworkA.caf", volume: 1.0, volumeVary: kVolumeVaryLarge, pitchVary:kPitchVaryLow),
        SoundSFX("fireworkB.caf", volume: 1.0, volumeVary: kVolumeVaryLarge, pitchVary:kPitchVaryLow),
        SoundSFX("fireworkC.caf", volume: 0.3, volumeVary: kVolumeVaryLarge, pitchVary:kPitchVaryLarge)
    ])
```

Now every time `fireworkSound.play()` is called the sound engine will randomly play either fireworkA.caf, fireworkB.caf, or fireworkC.caf. Note that the volume and pitch are also randomly varied as specified in the SoundSFX vary parameters. The overall effect creates a lot of sonic variety.

#### Playing Sound Effects as SpriteKit Actions
The framework also includes an extension to SpriteKit SKAction to allow playing SoundSFX objects as an SKAction. This makes it easier to synchronization the SoundSFX with animations in SKAction sequences and groups.

```swift
	let fireWorkSoundAction = SKAction.playSoundSFX(fireworkSound)
```

The parameter for the playSoundSFX method can be either a SoundSFX or a RandomSoundSFX object. Whenever the action is run, the sound effect will play.

#### Sound File Formats
Because the GameSoundEngine framework uses AVAudioEngine it can support any file format supported by Core Audio. However the following formats are generally recognized as good formats for iOS games due to their efficient decoding, low CPU impact and good sound quality:

For background music: MPEG 4 Audio format, AAC. To convert a file to this format use the `afconvert` console command:

```text
	afconvert -f m4af -d aac input_file
```

For sound effects: CAF format, linear PCM, little-endian, 16-bit. To convert a file to this format use the `afconvert` console command:

```text
	afconvert -f caff -d LEI16 input_file
```

For best performance use the same file format for all sound effects. Playing sounds with different file formats will require GameSoundEngine to dynamically reconfigure its playback nodes to match the different file format. If all files are the same format, no reconfiguration of the playback nodes is necessary giving better performance.

## License
Copyright 2016 Endless Wave Software LLC

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

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

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

repository: troy-lamerton/GameSoundEngine

repo_name: troy-lamerton/GameSoundEngine


text:
# cwe-collector templates

Alert Logic Amazon Web Services (AWS) CloudWatch Events (CWE) Collector CloudFormation templates.

# Overview

This folder contains CloudFormation templates (CFT) for deploying
a CWE collector in AWS account which will collect and forward CW events to the Alert Logic CloudInsight
backend services.

# Contents

[Amazon GuardDuty findings collection](./README-GD.md)

# Known Issues/ Open Questions

- TBD.

# Useful Links

- [Alert Logic AIMs service API](https://console.cloudinsight.alertlogic.com/api/aims/)
- [How to monitor AWS Lambda functions](http://docs.aws.amazon.com/lambda/latest/dg/monitoring-functions.html)

repository: alertlogic/cwe-collector

branch_name: refs/heads/integration

repo_name: alertlogic/cwe-collector


text:
Pure OCaml implementation of the FAT filesystem
===============================================

This library has two purposes:
  1. primary: to allow the easy preparation of bootable disk images
     containing [Mirage](http://openmirage.org/) kernels
  2. secondary: to provide a simple key=value store for Mirage
     applications

Note that "filesystems" are inherently legacy systems which modern
Mirage applications will not use directly. The most likely use for this
library is in booting a Mirage application via some kind of disk image.

Known limitations
-----------------

- can only make FAT16 filesystems
- no VFAT support
- no exFAT support (see #78)
- corrupts under concurrent writes

PRs welcome to address any of these limitations!

license: ISC

repository: mirage/ocaml-fat

gha_language: OCaml

gha_license_id: ISC

repo_name: mirage/ocaml-fat


text:
---
layout: docs
title: Disable
---

# Disable

_Since 0.5.0_

This rule reports errors when a "disallowed" symbol is referenced.

Example:

```scala
MyCode.scala:7: error: [DisallowSymbol.asInstanceOf] asInstanceOf is disabled.
  myValue.asInstanceOf[String]
          ^
```

## Configuration

By default, this rule does allows all symbols. To disallow a symbol:

```scala
Disable.symbols = [
  "scala.Option.get"
  "scala.Any.asInstanceOf"
]
```


text:
=================
Django Unchained!
=================

Django-Backend support for Couchbase 2.0, utilising CouchbaseKit (Couchbase Python wrapper for Doc Validation)

Because we all know, NoSQL is the future, and some of us want Non-relational data in our Django apps!

Inspired by Django-nonrel, Powered by CouchbaseKit and the Couchbase Python SDK.

UNFINISHED AND FAR FROM PRODUCTION READY! DO NOT USE YET!

Couchbase & CouchbaseKit
========================

You can get detailed information about couchbase itself from
http://www.couchbase.com/ and about its Python driver form
http://www.couchbase.com/develop/python/next.

Documentation: https://couchbasekit.readthedocs.org/en/latest/

Quick Start
===========
UNFINISHED.

    from couchbasekit import Connection

    # you should do this in your base settings.py:
    Connection.auth('myusername', 'p@ssword')

Then define your model document.

**models.py**::

    from django.db import models
    from django.utils.translation import ugettext_lazy as _
    from couchbasekit import Document
    couchbasekit.fields import EmailField, ChoiceField

    class Author(Document):
        __bucket_name__ = 'default'
        __key_field__ = 'slug' # optional
        doc_type = 'user'
        structure = {
            'slug': unicode,
            'first_name': unicode,
            'last_name': unicode,

repository: rbin/Django-Unchained

repo_name: rbin/Django-Unchained


text:
```text
SPDX-License-Identifier: Apache-2.0
Copyright (c) 2021 Intel Corporation
```

## firewall

---

1. Role `firewall_prepare` must be included before any port openings in a playbook.
The `use_firewall=true` variable needs to be specified to include firewall usage. By default firewall will **not** be used.

2. If the firewall is in use, roles should not open ports directly. The `firewall_open_ports` role should be called instead.
Ports that need to be open must be declared as list of ports and named `fw_open_ports`.

Examples:

```yaml
file_path: role_name/vars/main.yml

---
fw_open_ports:
  - 10250/tcp
  - 30000:32767/tcp # open range of ports
  - 8285/udp
  - 8472/udp # open single port
```

or

```yaml
file_path: role_name/vars/main.yml

---
list_of_ports:
  node_selector:
    - PORT:PORT/PROTOCOL  # open range of ports
    - PORT/PROTOCOL  # open single port
```

```yaml
- name: open required ports
  include_role:
    name: infrastructure/firewall_open_ports
  when: use_firewall | default(false)
  vars:
    fw_open_ports: "{{ list_of_ports['node_selector'] }}"
```


text:
---
title: Modals
layout: variation
section: components
secondary_section: null
status: Beta
description: >-
  Modal windows (also known as dialog boxes or lightboxes) are “pop-up” elements
  that appear in front of a web page, blocking the main page below. Similar to
  popup windows or system alerts, modals are unique because they prevent
  interaction with the page underneath.
variation_groups:
  - variations:
      - variation_code_snippet: ''
        variation_description: |-
          ![Example of modal](/design-system/images/uploads/formexpiring.png)

          ![Example of modal](/design-system/images/uploads/savesearch.png)
        variation_name: Default modal
use_cases: >-
  Modals help draw attention to an alert or a focused task by preventing
  interactions with anything on the web page other than the modal itself. Due to
  their disruptive nature, modal windows should only be used in very specific
  cases outlined below.

  ##### Feedback or correction

  Modals can be effective for communicating a warning or alert outside the main
  web page. They can be triggered by a user interaction (like pressing a button
  to “save”) or without an interaction (like a timeout warning after a period of
  inactivity).

  ##### Interruption

  Use modals to force the user to complete a task or make a decision that
  requires their full attention outside of the main workflow. A critical piece
  of this scenario is that you need the workflow to be interrupted to be
  effective. If not, explore other UI elements to accomplish the goal.

  ##### Examples of when to use modals

  * Confirm an action that can’t be undone, such as “Are you sure you want to
  delete this?

  * Display a warning that something is about to expire or timeout

  * Save a form that requires inputs separate from the main workflow, like
  entering a “Save as” file name

  * Focus attention on the need to accept or acknowledge something before the
  user can proceed
content_guidelines: >-
  ##### Heading

  Modal windows should have a clear heading at the top of the window. This
  heading should clearly state what is happening or what action a modal is
  prompting the user for. For instance, if a modal appears due to inactivity,
  the heading should clearly state the action that is about to take place due to
  that inactivity.

  ##### Supporting text

  Any copy underneath the heading should include clear instructions about what
  the user needs to do.

  ##### Form fields

  If form fields are included in a modal, they should follow standard form field
  design guidelines.

  ##### Modal window box

  * Alignment: centered horizontally and vertically on top of lightbox

  * Background: White (#ffffff)

  * Background lightbox: Gray 80 (#75787b), 70% opacity

  * Padding: 30px

  * Top border: 3px, CFPB Green (#20aa3f)

  * Heading: Avenir Next Regular, 22 px, Black (#101820)

  * Supporting text: Avenir Next Regular, 16px, Black (#101820)

  ##### Close area

  * Minicon: “close-round”

  * Minicon color: Pacific (#0072ce)

  * Minicon size: 16px

  * Font: Avenir Next Regular, 16px, Pacific (#0072ce)

  ##### Gray action bar

  * Background: Gray 5 (#f7f8f9)

  * Padding right/left: 30px

  * Padding top/bottom: 10px

  * Primary action: left aligned button

  ##### Maximum width

  * 270px for small screens

  * 630px for medium and large screens

  ##### Inactive window

  * Set page to fixed
behavior: >-
  ##### Opening a modal

  Modals can be triggered by links, buttons, or even inactivity on a site. When
  a modal opens, set the focus to the first element users need to interact with.
  This could be either the first form field in the modal window or the primary
  action button.

  ##### Scrolling within a modal

  Modal windows should not scroll. If a modal contains enough information to
  require scrolling, use an alternative method of displaying content, such as a
  different UI element or another content page.

  ##### Closing a modal

  Actions inside modals should be clearly marked. There should be a clear path
  forward (“continue”) and back (“cancel”), in addition to a clearly labeled way
  to close the modal without taking any action at all. When a modal window is
  closed, return focus to the last active element on the page behind the modal.

  Modal windows are always closable by clicking or tapping:

  * A delete minicon or label in the upper right corner

  * The next action button or link

  * Anywhere outside the modal window

  * ESC key on a keyboard

  ##### Creating accessible behaviors

  Keyboard access should be limited to only interacting with the modal dialog
  once it is visible.

  * The close minicon needs to be accessible from a keyboard.

  * The escape key should also close the modal.

  * The enter key should should be mapped to any submission forms in the modal.

  Provide separate focus and hover states for the close minicon and any “next”
  action buttons.

  The find function (ctrl+F) will not search information contained within a
  modal window.

  Include offscreen instructions that describe the modal dialog and how to
  interact with it.

  #### Specific development directions

  * Modal windows should be marked with aria-hidden=”true” and toggled to false
  when visible and given the role=dialog ARIA role.

  * When the modal dialog is displayed, the main content of the page should be
  marked with aria-hidden=”true” to prevent screen readers from interacting with
  it.

  * Add role=”alertdialog” to the modal window.

  * Code the close minicon using a button element for more semantic markup.

  * The heading of the modal dialog should use an H1 tag.

  * Offscreen interaction instructions should use aria-labelledby attribute.
accessibility: ''
research: ''
last_updated: 2020-01-29T19:07:36.411Z
---

repository: cfpb-sandbox/design-system

gha_language: HTML

repo_name: cfpb-sandbox/design-system


text:
# Disaster Recovery

You can use `argocd-util` can be used to import and export all Argo CD data.

Make sure you have `~/.kube/config` pointing to your Argo CD cluster.

Figure out what version of Argo CD you're running:

```bash
argocd version | grep server
# ...
export VERSION=v1.0.1
```

Export to a backup:

```bash
docker run -v ~/.kube:/home/argocd/.kube --rm argoproj/argocd:$VERSION argocd-util export > backup.yaml
```

Import from a backup:

```bash
docker run -v ~/.kube:/home/argocd/.kube --rm argoproj/argocd:$VERSION argocd-util import - < backup.yaml
```

repository: devtronlabs/devtron

repo_name: devtronlabs/devtron


text:
StylableDateTimePicker
======================

A styleable version of the date/time picker for Android 4.0+ with embedding support (using as normal fragment)

![Styled DatePicker](/../screenshots/screenshots/screenshot.png?raw=true "Example Theme")

Declare your style:

```java
<style name="DateTimePicker">
    <item name="headerBackgroundColor">...</item>
    <item name="hightlightedTextColor">...</item>
    <item name="buttonBackground">...</item>
    <item name="buttonTextColor">...</item>
    <item name="circleHighlightColor">...</item>
    <item name="defaultTextColor">...</item>
    <item name="selectedDayTextSize">...</item>
    <item name="selectedMonthTextSize">...</item>
    <item name="selectedYearTextSize">...</item>
</style>
```

Create the DatePicker/TimePicker with

```java
DatePickerDialog dialog = DatePickerDialog.newInstance(callBack, year, monthOfYear, dayOfMonth, R.style.DateTimePicker);
```
You can also add the pickers as content in your view hierarchy:

```java
DatePickerDialog picker = DatePickerDialog.newInstance(...);
FragmentTransaction ft = getFragmentManager().beginTransaction();
ft.add(R.id.picker_wrapper, picker);
ft.commit();
```

## Installation
At the moment you have to install the library "by hand" (I will release it for using with gradle soon):

copy the library to your "libs" folder. Then include the following line in your "settings.gradle":

```gradle
include ':libs:datetimepicker'
```
then add the following lines to your "build.gradle":

```gradle
repositories {
    mavenCentral()
    flatDir {            <--- add this
        dirs 'libs'      <---
    }                    <---
}

dependencies {
    compile project(':libs:datetimepicker')  <-- add this line
...
```

## License

    Copyright 2014 Artjom König

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

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

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

repository: wstever/MyApplication

repo_name: wstever/MyApplication


text:
## Description

[Nest](https://github.com/nestjs/nest) framework TypeScript starter repository.

## Installation

```bash
$ yarn install
```
## Launch the datatbase

Launch the mongoDB database with
 ```bash
 $ mongod
 ```
With Robo3T or Studio 3T
Create 4 collection:

`category`
`users`
`videos`

Then add all the scripts in the `scripts` section of this application to Robo3T
 `
## Running the app

```bash
# development
$ yarn run start

# watch mode
$ yarn run start:dev

# production mode
$ yarn run build
$ yarn run start:prod
```
Or

`Add Configuration` or `Edit configuration` on the top right, press the `+` on the top left then add a new npm. Keep the `run` thing and select `start:dev`  in the script field.

repository: tameII/NWT-Projet-Back

repo_name: tameII/NWT-Projet-Back


text:
# Page view dot indicator

This lib draws a simple dot indicator for page views with a simple API. Right now it is able to draw
dots with custom size, colors, spacing and duration. Besides that it also handles overflow by fading
the edges if there are more dots than the width of the page allows.

<img src="https://user-images.githubusercontent.com/1608564/111876654-7f539200-897e-11eb-9d1e-7a9ceb820ec7.gif" width="50%"/>

## Getting Started

Add `page_view_dot_indicator` to your pubspec.yaml:

```yml
dependencies:
  page_view_dot_indicator: ^1.0.0
```

import `package:page_view_dot_indicator/page_view_dot_indicator.dart`

## Most basic dot indicator

```dart
PageViewDotIndicator(
  currentItem: selectedPage,
  count: pageCount,
  unselectedColor: Colors.black26,
  selectedColor: Colors.blue,
)
```

## But you can also customise other parameters, such as:

```dart
PageViewDotIndicator(
  currentItem: selectedPage,
  count: pageCount,
  unselectedColor: Colors.black26,
  selectedColor: Colors.blue,
  size = const Size(12, 12),
  unselectedSize = const Size(8, 8),
  duration = const Duration(milliseconds: 200),
  margin = const EdgeInsets.symmetric(horizontal: 8),
)
```


text:
# update

Update data artifacts imported from other DVC repositories.

## Synopsis

```usage
usage: dvc update [-h] [-q | -v] targets [targets ...]

positional arguments:
  targets        DVC-files to update.
```

## Description

After creating import stages ([DVC-files](/doc/user-guide/dvc-file-format)) with
`dvc import`, the external data source can change. `dvc update` can be used to
bring the imported data artifact up to date. This is the only
command that does so with locked stages, and import stages are locked by
default.

> Using `dvc update` on a locked stage is equivalent to running `dvc unlock`,
> then `dvc repro`, and `dvc lock` again on an import stage.

To indicate which import stages to update, specify the corresponding DVC-file
`targets` as command arguments.

Note that by default, import stages created with `dvc import` are locked in
their DVC-files (via fields `lock: true` and `rev_lock`). For a locked stage,
`dvc update` does `dvc unlock` + `dvc repro` + `dvc lock`, basically.

## Options

- `-h`, `--help` - prints the usage/help message, and exit.

- `-q`, `--quiet` - do not write anything to standard output. Exit with 0 if no
  problems arise, otherwise 1.

- `-v`, `--verbose` - displays detailed tracing information.


text:
CreditsRoll
===========

![This is not the library you were looking for.](img/obiwan.jpg)

The **CreditsRoll** library allows you to have **Star Wars-like credits rolls** in your app. It's compatible with
_all_ API levels. Yes, this is API 1+!

![Demo image](img/scroll.gif)

### Why?

Because a), freaking _Star Wars_, and b), why not.

### No seriously, why?

This is an example of custom View, that uses a few interesting tricks to achieve the end result:

* Custom text measuring and laying out, using a
[`StaticLayout`](http://developer.android.com/reference/android/text/StaticLayout.html)
* 3D view transform on a [`Canvas`](http://developer.android.com/reference/android/graphics/Canvas.html)
using a [`Camera`](http://developer.android.com/reference/android/graphics/Camera.html)
* Custom view attributes handling
* Rickroll

### License
This library is released under the Apache 2 License. Please take a look at the [`NOTICE`](NOTICE) file for details.

### Third party libraries
The demo app uses the amazing [NineOldAndroids](http://nineoldandroids.com) library by Jake Wharton to support
using Honeycomb-style animations on API level 1+.

repository: xiangyunwan/CreditsRoll-master

repo_name: xiangyunwan/CreditsRoll-master