text:
# Robo-AR
Anmol Parande, Jay Monga, Eashaan Katiyar, Ankit Agrawal

## Overview
Our goal is to control Romi using AR. The basic idea is that the user will be able to “draw” a path by setting waypoints in an AR environment using a smartphone app, and the robot will drive from waypoint to waypoint.
![Project Concept](Images/ui.png)

## Goals
Our goals for this project are as follows.
1. Implement BLE communication between the robot and the phone.
2. Implement closed-loop feedback control to make sure the robot stays on the drawn path and rejects disturbances.
3. While the phone application is under development, we will test our robot control and the networking commands in a simulation environment.
4. We will combine robot sensor data with localization data provided by the AR to understand where the robot is localized in the environment and how it is oriented.

For more concrete implementation details, see the “Approach” section.

Beyond our main goals, we have additional features we could potentially implement if we have enough time and find ourselves ahead of schedule:
1. Allow the user to draw more interesting trajectories beyond straight lines between waypoints, such as following curves using cubic spline interpolation.
2. Implementing a control system where if the robot deviates from the path, the phone can detect and correct the robot. This could be accomplished by placing visual feature tags on Romi such as ArUco markers.
3. Develop advanced state estimation of the Romi through methods such as Kalman filtering or robot localization in ROS by combining encoders, acceleration, and gyroscope sensor data.
4. More interesting control (formalize state and input cost for MPC or optimal control over piecewise trajectory)
5. Allowing for obstacle avoidance so when the robot encounters an obstacle on the drawn path, it can navigate around the obstacle and then return to the original path

## Approach
Our mobile application will be an iOS app written in Swift, and the AR component will be handled by ARKit. ARKit will provide the real-world coordinates of the waypoints as well as the distances between them. The app will connect with the Romi via BLE and transmit a series of (x, y) coordinates representing the waypoints in the 2D plane the robot travels in. When the “start” instruction is received from the app, the robot will start following the waypoints.

To keep the robot on the trajectory, we will use a closed-loop PID controller on the wheel velocities. We drive our robot in open loop and use Least Squares to fit our model of the system that we can then control. While the robot is driving, we will also use the encoders and gyroscope with basic filtering to maintain an understanding of where the robot is localized in space.

To test the controls to our robot, we will develop the controls and response to BLE commands in a Gazebo simulation requirement. We will design an API for the BLE connection so we can test the robot’s response to simulated bluetooth messages as well.

For assumptions we will make through the project, see the assumptions section.

## Assumptions:
1. The robots dynamics will be constant throughout the entire duration
2. Differential-drive modeled robot (Romi)

![Romi Model](Images/model.png)

3. Affine motor model with respect to input

![Motor model](Images/state_eq.png)

![Left Motor](Images/vl.png)

![Right Motor](Images/vr.png)

4. Robot receives full knowledge of trajectory before moving
5. Static environment (obstacles won’t appear/disappear after initial plan is made)

## Resources

We plan to use a lot of the existing hardware available to us for this project. In terms of the Robot, we intend to utilize the Romi’s gyro, accelerometer, and motor encoders in order to provide strong robot localization. Furthermore, we will use its BLE capabilities in order to interface with a mobile device. We will be using Apple Iphones as that mobile device, which come with AR (augmented reality) features. We will implement our AR app using Apple’s ARKit API.

### Potentially Relevant Tutorials
- [Drawing in the Air with Bare Fingers](https://www.toptal.com/swift/ios-arkit-tutorial-drawing-in-air-with-fingers)
- [Measure Distance Between Two Points on a Horizontal Plane in Augmented Reality](https://mobile-ar.reality.news/how-to/arkit-101-measure-distance-between-two-points-horizontal-plane-augmented-reality-0185297/)
- [Understanding World Tracking in ARKit](https://developer.apple.com/documentation/arkit/world_tracking/understanding_world_tracking)
- [Visualizing and interacting with a reconstructed scene in ARKit](https://developer.apple.com/documentation/arkit/world_tracking/visualizing_and_interacting_with_a_reconstructed_scene)
- BLE Technology (Lab 9)
- [Bluetooth Development on iOS](https://www.novelbits.io/intro-ble-mobile-development-ios/)
- [Recognizing and Labeling Arbitrary Objects](https://developer.apple.com/documentation/arkit/recognizing_and_labeling_arbitrary_objects)
- [Detecting Images in an AR Experience](https://developer.apple.com/documentation/arkit/detecting_images_in_an_ar_experience)
- [Tracking and Altering Images](https://developer.apple.com/documentation/arkit/tracking_and_altering_images)

## Schedule
Due Date     | Task          | Assignee  |  Goal
------------ | ------------- | --------- | ----
Nov 6        | Determine the requirements and capabilities of the AR-Kit | Anmol + Ankit | Get a barebones app running on iOS and understand what information we can get from points in AR.
Nov 6        | Do networking lab (Lab 9) + understand how to use the BLE technology for this project | Jay + Eashaan | Complete and understand complexity surrounding BLE technology and how it relates to our project
Nov 6        | Architecture Drawing | All of Us | Complete architecture drawing for our robot system
Nov 15       | Have closed loop controls, auto-calibration, and basic filtering implemented for every important sensor in simulations. | Jay + Eashaan | Be able to run the robot in simulation and mock sensor data.
Nov 15       | Have an app which sets waypoints and stores their real-world coordinates | Anmol | Be able to draw and send waypoints on an app -- shouldn’t be too much else to do with this app.
Nov 15       | Set up interface for bluetooth in hardware and mock up in simulation     | Ankit | Be able to send bluetooth commands to the robot in simulation.
Nov 22       | Transition all controls to hardware | All of Us | Romi should be able to run consistently with correct feedback.
Nov 29       | Integration of BLE with controls and AR. | All of Us | Start testing our system in the real world.
Dec 6        | Debugging + Testing + Stretch Goals + Spillover | All of Us | Finalize implementation.
Dec 15       | Project Poster/Expo Creation. Create a video demo. | All of us | Present our project to the class and GSI’s.
Dec 18       | Final Report | All of us | Complete the Final Report summarizing the project result

## Risks
A major risk we face is our heavy reliance on ARKit for a variety of functions, ranging from path creation to object detection. Thus, our robot’s success for this project will likely be dependent on the technological limits of ARKit.

Another thing to consider is the noise and drift experienced by the sensors, which could lead to difficulty in reliably following the desired trajectory. Further issues with the networking component of the Romi may arise, as we do not currently understand. Thus, bluetooth communication may not be able to adequately send information about trajectory

Lastly, as we near the end of our project, we may experience mismatch in behaviour between the simulated Kobuki and physical Romi device. Furthermore, the requisite integration of various modules for our system, which includes networking, Romi control, augmented reality -- each of which has its own complexities and idiosyncrasies -- may fail to work nicely together. These issues could prove fatal to the execution of our project at a very late stage in the semester.

repository: aparande/Robo-AR

repo_name: aparande/Robo-AR


text:
# Changelog

This file lists the meaningful changes between released versions.

## Format

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).

Entries should have the imperative form, just like commit messages. Start each entry with words like
add, fix, increase, force, etc.. Not added, fixed, increased, forced, etc..

Line wrap the file at 100 characters. That is over here: ------------------------------------------|

### Categories each change falls into

- **Added**: for new features.
- **Changed**: for changes in existing functionality.
- **Deprecated**: for soon-to-be removed features.
- **Removed**: for now removed features.
- **Fixed**: for any bug fixes.
- **Security**: in case of vulnerabilities.

## [Unreleased]
### Fixed
- Fix `FromJava` derivation not working when a field is named "source".

## [0.5.0] - 2022-09-14
### Fixed
- Fix broken derivation of `FromJava` for enums with only unit variants.

### Changed
- Upgrade `jni` to `0.19`.

## [0.4.0] - 2021-02-17
### Added
- Allow using a `#[jnix(bounds = "T: my.package.MyClass")]` attribute to specify the underlying
  erased type used for a generic type parameter.

### Changed
- Derivation of `FromJava` for unnamed fields (i.e., tuple structs and tuple variants) now assumes
  that each field with index N has a `component{N+1}` getter method instead of the previously
  assumed `get{N}` method. This makes it easier to interface with Kotlin data classes, because it
  automatically generates these `component{N+1}` getter methods for a `data class`.
- Derivation of `IntoJava` for the unit variants of non-generic enums (i.e., the variants that have
  no fields) now assume that the Java representation is a singleton class that has its instance
  stored in a `INSTANCE` field. This allows Kotlin `object` variants to be used as the sub-classes
  to represent the variants in a `sealed class`. Note that this does not change the assumption that
  an enum that only has unit variants is represented as an `enum class`.

## [0.3.0] - 2020-11-27
### Added
- Implement `FromJava` for `Option<i32>`.

### Changed
- Implementation of `FromJava<JValue>` for `i32` now expects an `int` Java primitive instead of a
  boxed `Integer` object, this means that when deriving `FromJava` for custom types, `i32` fields
  must now have a respective `int` field in the respective Java class. If `Integer` object fields
  are desired, the Rust field type should be `Option<i32>`.

### Removed
- Implementation of `FromJava<JObject>` for `i32`. If conversion from `Integer` objects is needed,
  it's possible to use `Option<i32>` as the target Rust type.

## [0.2.4] - 2020-11-17
### Added
- Implement `FromJava` for `Vec<T>`.
- Implement `FromJava` for `IpAddr`, `Ipv4Addr` and `Ipv6Addr`.
- Implement `FromJava<JValue>` for `bool` so that it can be used in structs that derive `FromJava`.

## [0.2.3] - 2020-05-07
### Added
- Implement `IntoJava` for `i64`.

## [0.2.2] - 2020-03-23
### Added
- Implement `FromJava<JObject>` for `i32` to convert from a boxed `Integer` object.
- Implement `IntoJava` for `Option<i32>` to convert to a boxed `Integer` object.

## [0.2.1] - 2020-03-10
### Added
- Implement `IntoJava` for `Option<bool>` to convert to a boxed `Boolean` object.

## [0.2.0] - 2020-02-05
### Added
- Added `FromJava` trait.
- Added derive macro for `FromJava`.

## [0.1.2] - 2020-01-22
### Fixed
- Fix another instance of a local reference leak when calling `.into_java(env)` on an `IpAddr`,
  `Ipv4Addr` or `Ipv6Addr`.

## [0.1.1] - 2020-01-15
### Fixed
- Fix skipping fields in tuple structs and tuple enum variants when deriving `IntoJava`.
- Fix local reference leak when calling `.into_java(env)` on an `IpAddr`, `Ipv4Addr` or `Ipv6Addr`.

repository: mullvad/jnix

branch_name: refs/heads/main

extension: md

gha_language: Rust

license_type: permissive

repo_name: mullvad/jnix


text:
SortOrder: 4
# Integrating with coupons

Read this if you want to integrate a new vertical into using coupons

Topics:
1. Decide on scopes, consult with coupons team
2. Implement a plugin controller - TODO link - Avital
3. Call calculate cart using the scopes - https://wixplorer.wixpress.com/coupons/reference/using-coupons/.wix.coupons.api.v2.-coupons-v2.-calculate-cart
4, Call increase usage once payment is confirmed - https://wixplorer.wixpress.com/coupons/reference/using-coupons/.wix.coupons.api.v2.-coupons-v2.-increase-usage
5, Go to RPC and add the controller - TODO link - Avital
6, Update enums in EDM - TODO link - Zeev
7. Ask technical writers to update the DB driver documentation - https://support.wix.com/en/article/wix-code-wix-marketing-coupons-collection-fields with the new scope values
8. Ask technical writers to update the EDM documentation (link doesn’t exist yet)
9. update validScopeValues.md

Need to turn this draft into actual documentation

license: MIT

repository: wix-incubator/wix-rest-docs

branch_name: refs/heads/master

gha_license_id: MIT

repo_name: wix-incubator/wix-rest-docs


text:
# Contributing

**Welcome to deepTools GitHub repository! Please check the following instructions
for contributing to the repository :**

## Adding features or fixing bugs

* Fork the repo
* Check out a feature or bug branch the you want to work on (for adding new
    features, use the develop branch)
* Add your changes
* Update README when needed
* Submit a pull request to upstream repo
* Add description of your changes
* Ensure tests are passing
* Ensure branch is mergable

## Testing

* Please make sure that travis tests are passing

repository: bgruening/deepTools

gha_language: Python

gha_license_id: NOASSERTION

repo_name: bgruening/deepTools


text:
---
title: Frictionless Data Community Call May 2023
date: 2023-06-05
tags: ['events', 'community-hangout']
category: events
image: /img/blog/Augustos-presentation-FastETL.png
description: At our last community call Augusto Herrmann presented FastETL, a free and open source software library for Apache Airflow that makes it easier to integrate heterogeneous data sources and to publish open data...
author: Sara Petti
---
At our last community call on May 25th Augusto Herrmann presented FastETL, a free and open source software library for Apache Airflow that makes it easier to integrate heterogeneous data sources and to publish open data (e.g. to CKAN data portals) using Apache Airflow.

Augusto told us how the data engineering team at the Secretariat for Management and Innovation in the Brazilian federal government has been using FastETL in combination with the Frictionless Framework, and Tabular Data Packages for processing data pipelines and to publish open data.

Augusto and his team have developed FastETL, among other things, to be able to periodically synchronise data sources in the data lake, publish open data on open data portals, and be notified about publications in the official gazette.

Some of the things that you can do with FastETL are:
* Full or incremental replication of tables in SQL Server, and Postgres databases (and MySQL sources).
* Load data from GSheets and from spreadsheets on Samba/Windows networks.
* Extract CSVs from SQL.
* Query the Brazilian National Official Gazette's API, and get a notification when there is a new publication in the Official Gazette.
* Use CKAN or dados.gov.br's API to update dataset metadata.
* Use Frictionless Tabular Data Packages to write data dictionaries in OpenDocument Text format.

Would you like to know more? You can have a look at Augusto’s slides on [his website here](https://herrmann.tech/slide-decks/2023/05/integrating-data-sources-and-publishing-open-data-with-fastetl-airflow-and-frictionless), or check out the [FastETL GitHub Repository](https://github.com/gestaogovbr/FastETL).
And if you want to better understand how to use FastETL, have a look at Augusto’s presentation, with some great data pipeline examples:

# Join us next month!
Next community call is on June 29th, and it will be a hands-on session on strange datasets and how to describe them! Jesper Zedlitz from the German federal state of  Schleswig-Holstein will be bringing one. Let us know if you would also like to bring a dataset to this call, by emailing Sara Petti sara.petti[at]okfn.org.

Do you have something you would like to present to the community at one of the upcoming calls? Let us know via [this form](https://forms.gle/AWpbxyiGESNSUFK2A), or come and tell us on our [community chat on Slack](https://join.slack.com/t/frictionlessdata/shared_invite/zt-17kpbffnm-tRfDW_wJgOw8tJVLvZTrBg) (also accessible via a [Matrix bridge](https://matrix.to/#/#frictionlessdata:matrix.okfn.org) if you prefer to use an open protocol) .

You can sign up for the call already [here](https://docs.google.com/forms/d/e/1FAIpQLSeuNCopxXauMkrWvF6VHqOyHMcy54SfNDOseVXfWRQZWkvqjQ/viewform?usp=sf_link). Do you want to share something with the community? Let us know when you sign up.

# Call Recording
On a final note, here is the recording of the full call:

gha_language: Vue


text:
#SVG Dash Meter

A no dependency SVG/JS widget. So small that once minified it has a size measured in negative kb.

SVG can make some really nice graphical UI elements but almost every library that uses SVG has a dependency of either D3, Raphael or Velocity. Whilst  all of these libraries are great I often don't want to include them for the sake of a simple UI element.

So here's the first of what I hope will be more no dependency SVG widgets.

Demo: http://codepen.io/MadeByMike/full/472b4b25c0ca707430e68dd2801fe822/

##Basic usage

```
var meter = svg_meter(elm, options);
```
###Example
```
var elm = document.getElementById('container');
var meter = svg_meter(elm, {
	value: 65,
	target: 75
});
```

##Update values

Once created you can update values without creating a new instance of the dash meter. The meter will animate from its current position to the new value.

```
setInterval(function(){
	meter.update(Math.random() * 100);
}, 4000);
```

##Options
```
{
	target: 75,
	show_target: false,
	value: 1,
	min:0,
	max:100,
	width: 160,
	duration: 1000,
	gradient: [
		{r:0,g:200,b:0},
		{r:240,g:240,b:0},
		{r:200,g:0,b:0}
	],
	stops: [60, 75, 90]
}
```

Note: If you specify a `target` option the `target_shown` option will automatically be set to true. If not specified gradient stops will be set 15% either side of the target.

repository: MadeByMike/svg-dash-meter

repo_name: MadeByMike/svg-dash-meter


text:
#HW9 instructions

Write a class IntegerArithmetic that has static functions add, subtract, multiply and divide. The functions should take as arguments two objects: op1 and op2. If op1 is of type Integer or Long, extract the integer value into a long named l1. If op1 is of type Integer or Long, extract the integer value into a long named l2. If either op1 or op2 is not an Integer or a Long, throw an exception. The methods will return their solution as a Long object.

The divide method will perform the operation l1 / l2. If l2 has the value of zero, throw an exception, different from the one above.

The code:

```
if (obj instanceof C) {
//your code
}
```

can be used to test the type of the object.

*Turn in your code as a zip file.*


text:
# Seal Subscriptions Merchant API client in PHP

This repository contains the Seal Subscriptions Merchant API client, which allows you to make API calls to the Seal Subscriptions app.
https://apps.shopify.com/seal-subscriptions

The full Seal Subscriptions Merchant API documentation is accessible on the following URL:
https://www.sealsubscriptions.com/articles/merchant-api-documentation

This repository contains a demo-api-call.php file which allows you to easily start using the API. The file contains a few sample API calls.
Before using it, **make sure to replace the SEAL_API_TOKEN and SEAL_API_SECRET with your shop's token and secret.**

The demo-webhook-endpoint.php contains a sample webhook endpoint, showcasing how you can read the webhook data sent from the Seal Subscriptions server to your endpoint.
You can use the webhooks to get notified when a new subscription is created in the shop or when a subscription is edited.


text:
This library is a port of the HSL Java Travel Card SDK (https://github.com/hsldevcom/hsl-card-java),
which is Apache 2.0 licensed. The full text of the original library's license is included below:

Copyright (C) 2012 HSL/HRT (Helsingin seudun liikenne/ Helsinki Region Transport)
 *
 * 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.

As required by the Apache 2.0 license, this file includes a short description of the changes made in this library.
 - Ported to C#. Much of the actual logic, especially in TravelCard and CardOperations was retained,
 but the underlying data structures were largely rewritten.


text:
# Introduction

This is a simple spam detector which currently detect only keyheld down and invalid keyword.
This is just a package for the spam system created by Jeffrey Way in its Lets Build Forum Series at Laracast, [Let's Build a forum with Laravel](https://laracasts.com/series/lets-build-a-forum-with-laravel)

[![Software License](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat-square)](LICENSE.md)
[![Travis](https://img.shields.io/travis/bitfumes/spam-free.svg?style=flat-square)]()
[![Total Downloads](https://img.shields.io/packagist/dt/bitfumes/spam-free.svg?style=flat-square)](https://packagist.org/packages/bitfumes/spam-free)

## Install

`composer require bitfumes/spamfree`

# Usage

Once you have the package in your project then you just need to use this in your request validation.Like if you want to protect body then

`'body' : ['required',new Spamfree]`

Use Bitfumes\Spamfree\Rules\Spamfree at the top where you have your validation.

## Testing

Run the tests with:

```bash
vendor/bin/phpunit
```

## Credits

Based on work originally created by Jeffrey Way: <https://github.com/JeffreyWay>

## Contributing

Please see [CONTRIBUTING](CONTRIBUTING.md) for details.

## Security

If you discover any security-related issues, please email<EMAIL_ADDRESS>instead of using the issue tracker.

## License

The MIT License (MIT). Please see [License File](/LICENSE.md) for more information.

repository: bitfumes/spamfree

repo_name: bitfumes/spamfree


text:
# CARS 2019 Tutorial

Hands on tutorial for SlicerIGT at CARS 2019. SlicerIGT home page: http://www.slicerigt.org/wp/

## Todo

- Mark: build PLUS package for Linux and Mac with Webcam support
- Rebecca: make setup script that installs Jupyter too
- Tamas: Write jupyter notebook for training
- David: Build custom module that logs events in csv file

## Useful info

Rebecca's ImageClassification repository: https://github.com/RebeccaHisey/ImageClassification


text:
# Prohibits using hardcoded passwords.

Passwords should be passed via configuraion mechanism to provide multi-environment support.

## Rule Details

The following pattern is considered a warning:

```js
const password = 'DEFAULT_PASSWORD';

const variable = {
    password                : 'DEFAULT_PASSWORD',
    'password'              : 'DEFAULT_PASSWORD',
    [`${variable}password`] : 'DEFAULT_PASSWORD'
};
```

The following pattern is not considered a warning:

```js
const password = config.password;
```

repository: WebbyLab/eslint-plugin-more

gha_language: JavaScript

repo_name: WebbyLab/eslint-plugin-more


text:
# insist

**insist** retries commands until they succeed.

I'm frequently travelling with the train where the internet connection is
spotty. Commands like `git push` run into a timeout and I have to restart them,
without any changes to the command line. Computers are much better suited for
menial tasks like this.

**Example:**

```
octo:~/collectd$ ~/go/bin/insist -- git remote update github
2019/02/13 09:03:25 Attempt 0 ...
Fetching github
```

By default, *insist* launches the program and waits for it to finish. If the
program exits with a non-zero exit status, an exponential back-off is applied
and then the program is restarted. You can limit the number of attempts and
provide a timeout via command line options.

If `STDIN` is not a terminal, *insist* copies it into a buffer and passes the
buffer to the program on each attempt. This allows piping data into a retried
program. Run interactive programs with *insist* will not work, because the
program will only be executed once all the input is read.

## License

*insist* is free software. It is licensed under the
[ISC License](https://opensource.org/licenses/ISC).

license: ISC

repository: octo/insist

repo_name: octo/insist


text:
# Link Property Prediction - ogbl-biokg
This code includes implementation of many KG models with OGB evaluator. It is based on this [repository](https://github.com/DeepGraphLearning/KnowledgeGraphEmbedding).

Authors: Arshjot Singh Khehra and Srihari Sridharan

The repository contains working implementation for the following models:
- TransE (same as reference repository)
- DistMult (same as reference repository)
- ComplEx (same as reference repository)
- RotatE (same as reference repository)
- ConvE (use branch `1-to-N` as it contains implementation with 1-N scoring)
- NormConvKB (ConvKB with Lp normalization instead of Batch Normalization)
- TransM (RESCAL)
- HolE
- RelConv
- QuatE
- ConvFM (Our custom model)
- ConEx
- ConvQuatE (Our custom model)
- OctonionE

### Results
The top scoring results (only for models implemented in addition to the reference) have been summarized below:

| Model Architecture        | Details | Valid MRR | Test MRR
|:-------------------------:|:-------:|:-------------------------:|:-----------------------:|
| HolE  | Effective batch size = 1024, starting lr = 0.001 | 0.81384 | 0.81374
| QuatE  | Effective batch size = 1024, starting lr = 0.0005 | 0.81169 | 0.81104
| OctonionE  | Effective batch size = 1024, starting lr = 0.0005 | 0.81218 | 0.81058
| NormConvKB  | Effective batch size = 1024, starting lr = 0.0005 | 0.76682 | 0.76697

### For training the HolE, OctonionE, and QuatE models, run:
```bash
bash examples.sh
```

## References
- [PyKEEN Library](https://github.com/pykeen/pykeen)
- [Reference implementation for ogbl-kg](https://github.com/DeepGraphLearning/KnowledgeGraphEmbedding)

repository: arshjot/knowledge-graphs

repo_name: arshjot/knowledge-graphs


text:
---
title: Announcing Istio 1.12.1
linktitle: 1.12.1
subtitle: Patch Release
description: Istio 1.12.1 patch release.
publishdate: 2021-12-07
release: 1.12.1
aliases:
    - /news/announcing-1.12.1
---

This release contains bug fixes to improve robustness. This release note describes what’s different between Istio 1.12.0 and Istio 1.12.1

{{< relnote >}}

## Changes

- **Added** istiod deployment respect `values.pilot.nodeSelector`.
  ([Issue #36110](https://github.com/istio/istio/issues/36110))

- **Added** an option to disable a number of nonstandard kubeconfig authentication methods when using multicluster secret by configuring the `PILOT_INSECURE_MULTICLUSTER_KUBECONFIG_OPTIONS` environment variable in Istiod. By default, this option is configured to allow all methods; future versions will restrict this by default.

- **Fixed** the `--duration` flag never gets used in the `istioctl bug-report` command.

- **Fixed** using flags in `istioctl bug-report` results in errors.
  ([Issue #36103](https://github.com/istio/istio/issues/36103))

- **Fixed** `DeploymentConfig`/`ReplicationController` workload name doesn't work correctly.

- **Fixed** some control plane messages may be omitted in the bug-report.

- **Fixed** webhook analyzer throwing nil pointer error when the `NamespaceSelector` field is empty.

- **Fixed** workload name metric labels are not correctly populated for `CronJob` at k8s 1.21+.
  ([Issue #35563](https://github.com/istio/istio/issues/35563))

- **Fixed** an issue where `EnvoyFilter` with ANY patch context will skip adding new clusters and listeners at gateway.

- **Fixed** an issue where `EnvoyFilter` patches on `virtualOutbound-blackhole` could cause memory leaks.

gha_language: HTML


text:
# tsoubsd

Sysadmin tool for OpenBSD for -stable and -current systems.

## Obsolete: use syspatch and sysupgrade!

Before syspatch(8) and sysupgrade(8), tsoubsd was quite useful.

repository: tsouanas/tsoubsd

repo_name: tsouanas/tsoubsd


text:
## Description
status of existing connection

**Command**

```sh
cleos net status
```
**Output**

```console
Usage: cleos net status host

Positionals:
  host TEXT                   The hostname:port to query status of connection
```

repository: eosforce/eosforce

repo_name: eosforce/eosforce


text:
Bowling Challenge
=================

## Current Status

- [X] Player bowl ball
- [X] When a player has bowled twice or has a strike, a new frame is generated
- [X] The Game can return a score
- [X] A strike applies a bonus score
- [X] A strike applies a bonus score
- [X] A Strike Bonus is removed once to bonus has been added
- [X] A game is complete after 10 frames
- [X] Interactive animated display
- [X] Game shows when complete
- [x] ESLint setup
- [X] Spares and Strikes displayed Visually
- [X] Player can only knock over available pins
- [X] Game can be restarted

![bowling](process/images/bowling.gif)
# Features I would like to add

- [ ] The 10th Frame allows for bonus rolls
- [ ] A gutter game is declared
- [ ] a perfect score is declared
- [ ] Travis set up
- [ ] Player can choose names
- [ ] Player can record high scores
- [ ] Multiple Players can be added
- [ ] Scores stored in database
- [ ] Leaderboard shows history of high scores

## The Task

**THIS IS NOT A BOWLING GAME, IT IS A BOWLING SCORECARD. DO NOT GENERATE RANDOM ROLLS. THE USER INPUTS THE ROLLS.**

Count and sum the scores of a bowling game for one player (in JavaScript).

A bowling game consists of 10 frames in which the player tries to knock down the 10 pins. In every frame the player can roll one or two times. The actual number depends on strikes and spares. The score of a frame is the number of knocked down pins plus bonuses for strikes and spares. After every frame the 10 pins are reset.

### Optional Extras

In any order you like:

* Create a nice interactive animated interface with jQuery.
* Set up [Travis CI](https://travis-ci.org) to run your tests.
* Add [ESLint](http://eslint.org/) to your codebase and make your code conform.

## Bowling — how does it work?

### Strikes

The player has a strike if he knocks down all 10 pins with the first roll in a frame. The frame ends immediately (since there are no pins left for a second roll). The bonus for that frame is the number of pins knocked down by the next two rolls. That would be the next frame, unless the player rolls another strike.

### Spares

The player has a spare if the knocks down all 10 pins with the two rolls of a frame. The bonus for that frame is the number of pins knocked down by the next roll (first roll of next frame).

### 10th frame

If the player rolls a strike or spare in the 10th frame they can roll the additional balls for the bonus. But they can never roll more than 3 balls in the 10th frame. The additional rolls only count for the bonus not for the regular frame count.

    10, 10, 10 in the 10th frame gives 30 points (10 points for the regular first strike and 20 points for the bonus).
    1, 9, 10 in the 10th frame gives 20 points (10 points for the regular spare and 10 points for the bonus).

### Gutter Game

A Gutter Game is when the player never hits a pin (20 zero scores).

### Perfect Game

A Perfect Game is when the player rolls 12 strikes (10 regular strikes and 2 strikes for the bonus in the 10th frame). The Perfect Game scores 300 points.

repository: FayeCarter/bowling-challenge

repo_name: FayeCarter/bowling-challenge


text:
  Recipe Book

  Last Updated: January 11th, 2021

# ℹ Description

A MVC web app to help you keep track of recipes. Users can input recipes, ingredients and modify exiting entries.

# 🧑💻 Contributers

| Name | GitHub Profile |
|------|----------------|
|[Ben McFarland](https://www.linkedin.com/in/benjamin-mcf/)|[Harzulu](https://github.com/harzulu)|
|[Jerrod Styrk](https://www.linkedin.com/in/styrk-jerrodm/)|[SJerrod](https://github.com/SJerrod)|

# 📗 User Stories

  Click to View

    Scenario 01

    Behavior
    As the factory manager, I need to be able to see a list of all engineers, and I need to be able to see a list of all machines.

    Input
    Click on "Engineers" or "Machines" link

    Output
    Display page with list of names being links to all engineers or machines

    Completion
    ✅

    Scenario 02

    Behavior
    As the factory manager, I need to be able to select a engineer, see their details, and see a list of all machines that engineer is licensed to repair. I also need to be able to select a machine, see its details, and see a list of all engineers licensed to repair it.

    Input
    Click link of specific engineer or machine

    Output
    Display page with all given engineer or machine info and all connected engineers/machines

    Completion
    ✅

# 📊 SQL Schema

# ⚙ Technologies Used

  Expand Tech/tools

* Microsoft Visual Studio Code
* Git/GitHub
* C#
* .NET Core
* REPL
* APS.NET Razor
* ASP.NET MVC
* CSS
* Bootstrap
* EF Core
* MySQL/My SQL Workbench
* MySQL Designer

# 💾 Installation Requirements

## For Both  Mac & Windows systems

* Once you have Git installed on your computer, go to this GitHub repository, click the "Fork" button in the upper right hand corner of the page, and clone this application with the following command:

 `git clone https://github.com/harzulu/Factory.Solution`.

## 📁 Installing C#, .NET, dotnet script, & MySQL

### **This program requires C# and the .NET Framework to be installed on your machine:**

## For Mac 
 * Download this .NET Core SDK (Software Development Kit). Clicking this link will prompt a .pkg file download from Microsoft.
* Open the .pkg file. This will launch an installer which will walk you through installation steps. Use the default settings the installer suggests.
* Confirm the installation is successful by opening your terminal and running the command `$ dotnet --version`, which should return something like: `2.2.105`.

## For Windows (10+)

* Download this 64-bit .NET Core SDK (Software Development Kit). Clicking these links will prompt a .exe file download from Microsoft.
* Open the file and follow the steps provided by the installer for your OS.
* Confirm the installation is successful by opening a new Windows PowerShell window and running the command `dotnet --version`. You should see something a response like this: `2.2.105`.

## For Mac & Windows Operating Systems

* Install dotnet script with the following terminal command:

 `dotnet tool install -g dotnet-script`.

# 🖥 Opening the Project on your Local System

* Once the project has been cloned to your computer and you have all the necessary items on your local computer, open the project in the application of your choice (Visual Code Studio was used and is recommended by the application builder)

### AppSettings.json File

You will need to create an `appsettings.json` file in the `Factory` folder.

Once you have the file made, put in this code:

```
{
  "ConnectionStrings": {
    "DefaultConnection": "Server=localhost;Port=3306;database=first_last;uid=root;pwd=PASSWORD;"
  }
}
```
**Make sure to have a MySQL server up and running on your machine on port 3306**

**Replace `PASSWORD` with the password to your server created for this project**

### MySQL Database Setup

* First, using your terminal or command line, navgate to the HotelCRM folder in HotelCRM.Solution: `/Factory.Soulution/Factory`.
* Next, run the command: `dotnet ef database update`.
* You should have your database created for this project.

### Opening The Project
* Finally, run the command `dotnet build` to get bin/ and obj/ folders downloaded, then `dotnet run` to run the application. The program should be connected to a localhost port, most likely 5000. Your terminal or command line should specify which port it is on.
* Type into your web browser `http://localhost:[PORT_NUMBER]/` to view the project.

# ☎ Support / Contact Details

* Ben McFarland<EMAIL_ADDRESS>* Jerrod Styrk<EMAIL_ADDRESS>
# 🪲 Bugs / Issues

No known bugs or issues

# © License & Copyright

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

Copyright (c) 2021 *_Ben McFarland_, _Jerrod Styrk_*


text:
An Interface is an abstract type that includes a certain
set of fields that a concrete type must include to implement the interface.

GraphQLBundle use PHP interfaces to accomplish
this feature with the special annotation `@GraphQL\InterfaceType`

### Example:
````php
namespace App\Model;

use Ynlo\GraphQLBundle\Annotation as GraphQL;

/**
 * Use this interface in all entities that you need to automatically
 * set a timestamp on creation or update.
 *
 * @GraphQL\InterfaceType()
 */
interface TimestampableInterface
{
    /**
     * Get creation time.
     *
     * @return \DateTime
     *
     * @GraphQL\Field(type="datetime!")
     */
    public function getCreatedAt(): \DateTime;

    /**
     * Get the time of last update.
     *
     * @return \DateTime
     *
     * @GraphQL\Field(type="datetime!")
     */
    public function getUpdatedAt(): \DateTime;

    /**
     * Set creation time.
     *
     * @param \DateTime $createdAt
     *
     * @return TimestampableInterface
     */
    public function setCreatedAt(\DateTime $createdAt): TimestampableInterface;

    /**
     * Set the time of last update.
     *
     * @param \DateTime $updatedAt
     *
     * @return TimestampableInterface
     */
    public function setUpdatedAt(\DateTime $updatedAt): TimestampableInterface;
}
````
The above interface publish `createdAt` and `updatedAt` fields.
The `Field` annotation must be used on every required method to expose in the interface.

>>> Setters method should not be exposed on interfaces, because interfaces are only used for **reading** purposes.

repository: ynloultratech/graphql-bundle-docs

repo_name: ynloultratech/graphql-bundle-docs


text:
[![Cult Of Martians](http://cultofmartians.com/assets/badges/badge.svg)](http://cultofmartians.com)
[![Gem Version](https://badge.fury.io/rb/logidze.svg)](https://rubygems.org/gems/logidze)
[![Build](https://github.com/palkan/logidze/workflows/Build/badge.svg)](https://github.com/palkan/logidze/actions)
[![Open Source Helpers](https://www.codetriage.com/palkan/logidze/badges/users.svg)](https://www.codetriage.com/palkan/logidze)

# Logidze

Logidze provides tools for logging DB records changes when using PostgreSQL. Just like [audited](https://github.com/collectiveidea/audited) and [paper_trail](https://github.com/airblade/paper_trail) do (but [faster](bench/performance)).

Logidze allows you to create a DB-level log (using triggers) and gives you an API to browse this log.
The log is stored with the record itself in JSONB column. No additional tables required.

🤔 [How is Logidze pronounced?](https://github.com/palkan/logidze/issues/73)

Other requirements:

- Ruby ~> 2.7
- Rails >= 6.0 (for Rails 4.2 use version <=0.12.0, for Rails 5.x use version <= 1.2.3)
- PostgreSQL >= 10.0

## Links

- [Logidze 1.0: Active Record, Postgres, Rails, and time travel](https://evilmartians.com/chronicles/logidze-1-0-active-record-postgresql-rails-and-time-travel?utm_source=logidze)
- [Logidze: for all those tired of versioning data](https://evilmartians.com/chronicles/introducing-logidze?utm_source=logidze)

## Table of contents

- [Installation & Configuration](#installation)
  - [Using with schema.rb](#using-with-schemarb)
  - [Configuring models](#configuring-models)
  - [Backfill data](#backfill-data)
  - [Log size limits](#log-size-limits)
  - [Tracking only selected columns](#tracking-only-selected-columns)
  - [Logs timestamps](#logs-timestamps)
  - [Undoing a Generated Invocation](#undoing-a-generated-invocation)
  - [Using with partitioned tables](#using-with-partitioned-tables)
- [Usage](#usage)
  - [Basic API](#basic-api)
  - [Track meta information](#track-meta-information)
  - [Track responsibility](#track-responsibility)
  - [Disable logging temporary](#disable-logging-temporary)
  - [Reset log](#reset-log)
  - [Creating full snapshot instead of diffs](#full-snapshots)
  - [Associations versioning](#associations-versioning)
- [Dealing with large logs](#dealing-with-large-logs)
- [Handling records deletion](#handling-records-deletion)
- [Handling PG exceptions](#handling-pg-exceptions)
- [Upgrading](#upgrading)
- [Log format](#log-format)
- [Troubleshooting 🚨](#troubleshooting)
- [Development](#development)

## Installation

Add Logidze to your application's Gemfile:

```ruby
gem "logidze", "~> 1.1"
```

Install required DB extensions and create trigger function:

```sh
bundle exec rails generate logidze:install
```

This creates a migration for adding trigger function and enabling the hstore extension.

Run migrations:

```sh
bundle exec rails db:migrate
```

**NOTE:** Logidze uses DB functions and triggers, hence you need to use SQL format for a schema dump:

```ruby
# application.rb
config.active_record.schema_format = :sql
```

### Using with schema.rb

Logidze seamlessly integrates with [fx][] gem to make it possible to continue using `schema.rb` for the database schema dump.

Add `fx` gem to your Gemfile and run the same Logidze generators: `rails g logidze:install` or `rails g logidze:model`.

If for some reason Logidze couldn't detect the presence of Fx in your bundle, you can enforce it by passing `--fx` option to generators.

On the other hand, if you have `fx` gem but don't want Logidze to use it—pass `--no-fx` option.

### Configuring models

Run the following migration to enable changes tracking for an Active Record model and adding a `log_data::jsonb` column to the table:

```sh
bundle exec rails generate logidze:model Post
bundle exec rails db:migrate
```

This also adds `has_logidze` line to your model, which adds methods for working with logs.

By default, Logidze tries to infer the path to the model file from the model name and may fail, for example, if you have unconventional project structure. In that case, you should specify the path explicitly:

```sh
bundle exec rails generate logidze:model Post --path "app/models/custom/post.rb"
```

### Backfill data

To backfill table data (i.e., create initial snapshots) add `backfill` option to the generator:

```sh
bundle exec rails generate logidze:model Post --backfill
```

Now your migration should contain and `UPDATE ...` statement to populate the `log_data` column with the current state.

Otherwise a full snapshot will be created the first time the record is updated.

You can create a snapshot manually by performing the following query:

```sql
UPDATE <my_table> as t
SET log_data = logidze_snapshot(to_jsonb(t))
```

Or by using the following methods:

```ruby
Model.create_logidze_snapshot

# specify the timestamp column to use for the initial version (by default the current time is used)
Model.create_logidze_snapshot(timestamp: :created_at)

# filter columns
Model.create_logidze_snapshot(only: %w[name])
Model.create_logidze_snapshot(except: %w[password])

# or call a similar method (but with !) on a record

my_model = Model.find(params[:id])
my_model.create_logidze_snapshot!(timestamp: :created_at)
```

A snapshot is only created if `log_data` is null.

### Log size limits

You can provide the `limit` option to `generate` to limit the size of the log (by default it's unlimited):

```sh
bundle exec rails generate logidze:model Post --limit=10
```

### Tracking only selected columns

You can log only particular columns changes. There are mutually exclusive `except` and `only` options for this:

```sh
# track all columns, except `created_at` and `active`
bundle exec  rails generate logidze:model Post --except=created_at,active
# track only `title` and `body` columns
bundle exec rails generate logidze:model Post --only=title,body
```

### Logs timestamps

By default, Logidze tries to get a timestamp for a version from record's `updated_at` field whenever appropriate. If
your model does not have that column, Logidze will gracefully fall back to `statement_timestamp()`.

To change the column name or disable this feature completely, you can use the `timestamp_column` option:

```sh
# will try to get the timestamp value from `time` column
bundle exec rails generate logidze:model Post --timestamp_column time
# will always set version timestamp to `statement_timestamp()`
bundle exec rails generate logidze:model Post --timestamp_column nil # "null" and "false" will also work
```

### Undoing a Generated Invocation

If you would like to re-do your `rails generate` anew, as with other generators you can use `rails destroy` to revert it, which will delete the migration file and undo the injection of `has_logidze` into the model file:

```sh
bundle exec rails destroy logidze:model Post
```

**IMPORTANT**: If you use non-UTC time zone for Active Record (`config.active_record.default_timezone`), you MUST always infer log timestamps from a timestamp column (e.g., when back-filling data); otherwise, you may end up with inconsistent logs ([#199](https://github.com/palkan/logidze/issues/199)). In general, we recommend using UTC as the database time unless there is a very strong reason not to.

### Using with partitioned tables

Logidze supports partitioned tables for PostgreSQL 13+ without any additional configuration. For PostgreSQL 11/12, you should use _after_ triggers. To do that, provide the `--after-trigger` option to the migration:

```sh
bundle exec rails generate logidze:model Post --after-trigger
```

**NOTE:** Record changes are written as a full snapshot if the partition has changed during the update.

**IMPORTANT:** Using Logidze for partitioned tables in PostgreSQL 10 is not supported.

## Usage

### Basic API

Your model now has `log_data` column, which stores changes log.

To retrieve record version at a given time use `#at` or `#at!` methods:

```ruby
post = Post.find(27)

# Show current version
post.log_version #=> 3

# Show log size (number of versions)
post.log_size #=> 3

# Get copy of a record at a given time
post.at(time: 2.days.ago)

# or revert the record itself to the previous state (without committing to DB)
post.at!(time: "2018-04-15 12:00:00")

# If no version found
post.at(time: "1945-05-09 09:00:00") #=> nil
```

You can also get revision by version number:

```ruby
post.at(version: 2)
```

**NOTE:** If `log_data` is nil, `#at(time:)` returns self and `#at(version:)` returns `nil`.
You can opt-in to return `nil` for time-based `#at` as well by setting `Logidze.return_self_if_log_data_is_empty = false`.

It is also possible to get version for relations:

```ruby
Post.where(active: true).at(time: 1.month.ago)
```

You can also get diff from specified time:

```ruby
post.diff_from(time: 1.hour.ago)
#=> { "id" => 27, "changes" => { "title" => { "old" => "Logidze sucks!", "new" => "Logidze rulz!" } } }

# the same for relations
Post.where(created_at: Time.zone.today.all_day).diff_from(time: 1.hour.ago)
```

**NOTE:** If `log_data` is nil, `#diff_from` returns an empty Hash as `"changes"`.

Also, it is possible to retrieve list of model's `versions`:

```ruby
post.versions # => Enumerator

# you can use Enumerator's #take to return all
post.versions.take

# or you take a few or call any Enumerable method
post.versions.take(2)
post.versions.find do
  _1.title == "old title"
end

# we can also add options
post.versions(reverse: true) # from older to newer
post.versions(include_self: true) # returns self as the first one (default) or the last one record (if reverse: true)
```

There are also `#undo!` and `#redo!` options (and more general `#switch_to!`):

```ruby
# Revert record to the previous state (and stores this state in DB)
post.undo!

# You can now user redo! to revert back
post.redo!

# More generally you can revert record to arbitrary version
post.switch_to!(2)
```

You can initiate reloading of `log_data` from the DB:

```ruby
post.reload_log_data # => returns the latest log data value
```

Typically, if you update record after `#undo!` or `#switch_to!` you lose all "future" versions and `#redo!` is no
longer possible. However, you can provide an `append: true` option to `#undo!` or `#switch_to!`, which will
create a new version with old data. Caveat: when switching to a newer version, `append` will have no effect.

```ruby
post = Post.create!(title: "first post") # v1
post.update!(title: "new title") # v2
post.undo!(append: true) # v3 (with same attributes as v1)
```

Note that `redo!` will not work after `undo!(append: true)` because the latter will create a new version
instead of rolling back to an old one.
Alternatively, you can configure Logidze always to default to `append: true`.

```ruby
Logidze.append_on_undo = true
```

### Track meta information

You can store any meta information you want inside your version (it could be IP address, user agent, etc.). To add it you should wrap your code with a block:

```ruby
Logidze.with_meta({ip: request.ip}) do
  post.save!
end
```

**NOTE:** You should pass metadata as a Hash; passing keyword arguments doesn't work in Ruby 3.0+.

Meta expects a hash to be passed so you won't need to encode and decode JSON manually.

By default `.with_meta` wraps the block into a DB transaction. That could lead to an unexpected behavior, especially, when using `.with_meta` within an around_action. To avoid wrapping the block into a DB transaction use `transactional: false` option.

```ruby
Logidze.with_meta({ip: request.ip}, transactional: false) do
  post.save!
end
```

**Important:** If you use connection pooling (e.g., PgBouncer), using `.with_meta` without a transaction may lead to unexpected results (since meta is set for a connection). Without a transaction, we cannot guarantee that the same connection will be used for queries (including metadata cleanup).

### Track responsibility

A special application of meta information is storing the author of the change, which is called _Responsible ID_. There is more likely that you would like to store the `current_user.id` that way.

To provide `responsible_id` you should wrap your code in a block:

```ruby
Logidze.with_responsible(user.id) do
  post.save!
end
```

And then to retrieve `responsible_id`:

```ruby
post.log_data.responsible_id
```

Logidze does not require `responsible_id` to be `SomeModel` ID. It can be anything. Thus Logidze does not provide methods for retrieving the corresponding object. However, you can easily write it yourself:

```ruby
class Post < ActiveRecord::Base
  has_logidze

  def whodunnit
    id = log_data.responsible_id
    User.find(id) if id.present?
  end
end
```

And in your controller:

```ruby
class ApplicationController < ActionController::Base
  around_action :use_logidze_responsible, only: %i[create update]

  def use_logidze_responsible(&block)
    Logidze.with_responsible(current_user&.id, &block)
  end
end
```

By default `.with_responsible` wraps the block into a DB transaction. That could lead to an unexpected behavior, especially, when using `.with_responsible` within an around_action. To avoid wrapping the block into a DB transaction use `transactional: false` option.

```ruby
Logidze.with_responsible(user.id, transactional: false) do
  post.save!
end
```

### Disable logging temporary

If you want to make update without logging (e.g., mass update), you can turn it off the following way:

```ruby
Logidze.without_logging { Post.update_all(seen: true) }

# or

Post.without_logging { Post.update_all(seen: true) }
```

### Reset log

Reset the history for a record (or records):

```ruby
# for a single record
record.reset_log_data

# for relation
User.where(active: true).reset_log_data
```

### Full snapshots

You can instruct Logidze to create a full snapshot instead of a diff for a particular log entry.

It could be useful in combination with `.without_logging`: first, you perform multiple updates without logging, then
you want to create a log entry with the current state. To do that, you should use the `Logidze.with_full_snapshot` method:

```ruby
record = Model.find(params[:id])

Logidze.without_logging do
  # perform multiple write operations with record
end

Logidze.with_full_snapshot do
  record.touch
end
```

### Associations versioning

Logidze also supports associations versioning. This feature is disabled by default (due to the number of edge cases). You can learn more
in the [wiki](https://github.com/palkan/logidze/wiki/Associations-versioning).

## Dealing with large logs

By default, Active Record _selects_ all the table columns when no explicit `select` statement specified.

That could slow down queries execution if you have field values which exceed the size of the data block (typically 8KB). PostgreSQL turns on its [TOAST](https://wiki.postgresql.org/wiki/TOAST) mechanism), which requires reading from multiple physical locations for fetching the row's data.

If you do not use compaction (`generate logidze:model ... --limit N`) for `log_data`, you're likely to face this problem.

Logidze provides a way to avoid loading `log_data` by default (and load it on demand):

```ruby
class User < ActiveRecord::Base
  # Add `ignore_log_data` option to macros
  has_logidze ignore_log_data: true
end
```

If you want Logidze to behave this way by default, configure the global option:

```ruby
# config/initializers/logidze.rb
Logidze.ignore_log_data_by_default = true

# or

# config/application.rb
config.logidze.ignore_log_data_by_default = true
```

However, you can override it by explicitly passing `ignore_log_data: false` to the `ignore_log_data`.
You can also enforce loading `log_data` in-place by using the `.with_log_data` scope, e.g. `User.all.with_log_data` loads all
the _users_ with `log_data` included.

The chart below shows the difference in PG query time before and after turning `ignore_log_data` on. (Special thanks to [@aderyabin](https://github.com/aderyabin) for sharing it.)

![](./assets/pg_log_data_chart.png)

If you try to call `#log_data` on the model loaded in such way, you'll get `nil`. If you want to fetch log data (e.g., during the console debugging)–use **`user.reload_log_data`**, which forces loading this column from the DB.

## Handling records deletion

Unlike, for example, PaperTrail, Logidze is designed to **only track changes**. If the record has been deleted, **everything is lost**.

If you want to keep changes history after records deletion as well, consider using specialized tools for soft-delete, such as, [Discard](https://github.com/jhawthorn/discard) or [Paranoia](https://github.com/rubysherpas/paranoia).

See also the discussion: [#61](https://github.com/palkan/logidze/issues/61).

## Handling PG exceptions

By default, Logidze raises an exception which causes the entire transaction to fail.
To change this behavior, it's now possible to override `logidze_capture_exception(error_data jsonb)` function.

For example, you may want to raise a warning instead of an exception and complete the transaction without updating log_data.

Related issues: [#193](https://github.com/palkan/logidze/issues/193)

## Upgrading

We try to make an upgrade process as simple as possible. For now, the only required action is to create and run a migration:

```sh
bundle exec rails generate logidze:install --update
```

This updates core `logdize_logger` DB function. No need to update tables or triggers.

**NOTE:** When using `fx`, you can omit the `--update` flag. The migration containing only the updated functions would be created.

If you want to update Logidze settings for the model, run migration with `--update` flag:

```sh
bundle exec rails generate logidze:model Post --update --only=title,body,rating
```

You can also use the `--name` option to specify the migration name to avoid duplicate migration names:

```sh
$ bundle exec rails generate logidze:model Post --update --only=title,body,rating --name add_only_filter_to_posts_log_data

    create db/migrate/20202309142344_add_only_filter_to_posts_log_data.rb
```

### Pending upgrade check [Experimental]

Logidze can check for a pending upgrade. Use `Logidze.on_pending_upgrade = :warn` to be notified by warning, or `Logidze.on_pending_upgrade = :raise` if you want Logidze to raise an error.

### Upgrading from 0.x to 1.0 (edge)

#### Schema and migrations

Most SQL function definitions have changed without backward compatibility.
Perform the following steps to upgrade:

1. Re-install Logidze: `bundle exec rails generate logidze:install --update`.

1. Re-install Logidze triggers **for all models**: `bundle exec rails generate logidze:model <model> --update`.

   **NOTE:** If you had previously specified whitelist/blacklist attributes, you will need to include the `--only`/`--except` [option](#tracking-only-selected-columns) as appropriate. You can easily copy these column lists from the previous logidze migration for the model.

1. Remove the `include Logidze::Migration` line from the old migration files (if any)—this module has been removed.

Rewrite legacy logidze migrations to not use the `#current_setting(name)` and `#current_setting_missing_supported?` methods, or copy them from the latest [0.x release](https://github.com/palkan/logidze/blob/0-stable/lib/logidze/migration.rb).

#### API changes

The deprecated `time` positional argument has been removed from `#at` and `#diff_from` methods. Now you need to use keyword arguments, i.e., `model.at(some_tome) -> model.at(time: some_time)`.

## Log format

The `log_data` column has the following format:

```js
{
  "v": 2, // current record version,
  "h": // list of changes
    [
      {
        "v": 1,  // change number
        "ts":<PHONE_NUMBER>352, // change timestamp in milliseconds
        "c": {
            "attr": "new value",  // updated fields with new values
            "attr2": "new value"
            },
        "r": 42, // Resposibility ID (if provided), not in use since 0.7.0
        "m": {
          "_r": 42 // Resposibility ID (if provided), in use since 0.7.0
          // any other meta information provided, please see Track meta information section for the details
        }
      }
    ]
}
```

If you specify the limit in the trigger definition, then log size will not exceed the specified size. When a new change occurs, and there is no more room for it, the two oldest changes will be merged.

## Troubleshooting

### `log_data` is nil when using Rails fixtures

Rails fixtures are populated with triggers disabled. Thus, `log_data` is null initially for all records.
You can use `#create_logidze_snapshot` manually to build initial snapshots.

### How to make this work with Apartment 🤔

First, read [Apartment docs](https://github.com/influitive/apartment#installing-extensions-into-persistent-schemas) on installing PostgreSQL extensions. You need to use the described approach to install Hstore (and drop the migration provided by Logidze during installation).

Secondly, set `config.use_sql = true` in the Apartment configuration.

Finally, when using `fx` along with `schema.rb`, you might face a problem with duplicate trigger definitions (for different schemas).
Here is a patch to fix this: [dump_triggers.rake](etc/dump_triggers.rake).

Related issues: [#50](https://github.com/palkan/logidze/issues/50).

### `PG::UntranslatableCharacter: ERROR`

That could happen when your row data contain null bytes. You should sanitize the data before writing to the database.
From the [PostgreSQL docs](https://www.postgresql.org/docs/current/datatype-json.html): `jsonb type also rejects \u0000 (because that cannot be represented in PostgreSQL's text type)`.

Related issues: [#155](https://github.com/palkan/logidze/issues/155).

### `pg_restore` fails to restore a dump

First, when restoring data dumps you should consider using `--disable-triggers` option (unless you have a strong reason to invoke the triggers).

When restoring data dumps for a particular PostgreSQL schema (e.g., when using Apartment), you may encounter the issue with non-existent Logidze functions. That happens because `pg_dump` adds `SELECT pg_catalog.set_config('search_path', '', false);`, and, thus, breaks our existing triggers/functions, because they live either in "public" or in a tenant's namespace (see [this thread](https://postgrespro.com/list/thread-id/2448092)).

### `PG::NumericValueOutOfRange: ERROR: value overflows numeric format`

Due to the usage of `hstore_to_jsonb_loose` under the hood, there could be a situation when you have a string representing a number in the scientific notation (e.g., "557236406134e62000323100"). Postgres would try to convert it to a number (a pretty big one, for sure) and fail with the exception.

Related issues: [#69](https://github.com/palkan/logidze/issues/69).

## Development

This project requires a PostgreSQL instance running with the following setup:

```sh
# For testing
createdb -h postgres -U postgres logidze_test

# For benchmarks
createdb -h postgres -U postgres logidze_bench
createdb -h postgres -U postgres logidze_perf_bench
psql -d logidze_bench -c 'CREATE EXTENSION IF NOT EXISTS hstore;'
```

This project is compatible with [Reusable Docker environment](https://evilmartians.com/chronicles/reusable-development-containers-with-docker-compose-and-dip) setup.

## Contributing

Bug reports and pull requests are welcome on GitHub at [https://github.com/palkan/logidze](https://github.com/palkan/logidze).

## License

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

[fx]: https://github.com/teoljungberg/fx

repository: palkan/logidze

gha_language: Ruby

repo_name: palkan/logidze


text:
# Configuration Service

## REST API
The API is fully documented in openapi 2.0 (Swagger) format within [openapi.yaml](../scripts/deployment/openapi/openapi.yaml).
It can be visually inspected with the [Swagger editor](https://editor.swagger.io/)

All responses will include a JSON payload including at least UUID corresponding to that specific request.
All error responses will include an error message indicating the reason for the error.

A `correlation-uuid` header may be provided. If no value is provided, one will be generated and returned by the server.

### Authentication
Operations are authenticated with JWTs included as a request header, like:
`Authorization: Bearer <token>`.

### Retention Rules
CRUD operations are supported on Retention Rules.

---

#### Create Retention Rule: `POST /retentionrules`
##### Fields and Validation
JSON Body Params:

`type`: A string matching `GLOBAL`, `DATASET` or `DEFAULT`. `DATASET` and `DEFAULT` rules require a `projectId` and `dataStorageName`.

`dataStorageName`: A string indicating where this rule will take effect. It must begin with the storage prefix `gs://` and containing at least one segment indicating the bucket name. Segments are separated using `/`.

`projectId`: A string indicating the project where this rule will take effect. This is the GCP project name.

`retentionPeriod`: A number indicating the number of days to retain objects. Must be between 0 and 1095.

`retentionPeriodUnit`: Optional. A string indicating retention period unit. `DAY` or `MONTH`.

`dataSetName`: Optional. A name for the dataset covered by this rule.

##### Errors
`400`:
* No more than one retention rule can be created with the same `type`, `dataStorageName`, and `projectId`.
* Validation errors

---

#### Read Retention Rule: `GET /retentionrules?{params}`
##### Fields and Validation
Query Params:

`type`: The `type` of the requested rule.

`projectId`: The `projectId` of the requested rule.

`dataStorageName`: The `dataStorageName` of the requested rule.

##### Errors
`400`:
* Validation errors

`404`:
* No rule exists matching the provided values.

---

#### Update Retention Rule: `PUT /retentionrules/{ruleId}`
##### Fields and Validation
JSON Body Params:

`ruleId`: A number indicating the id of the rule to update.

`retentionPeriod`: The new retention period.

##### Errors
`400`:
* Validation errors
* No rule exists with the specified id.

---

#### Delete Retention Rule: `DELETE /retentionrules?{params}`
##### Fields and Validation
Query Params:

`type`: The `type` of the requested rule.

`projectId`: The `projectId` of the requested rule.

`dataStorageName`: The `dataStorageName` of the requested rule.

##### Errors
`400`:
* Validation errors

`404`:
* No rule exists matching the provided values.

---

repository: GoogleCloudPlatform/storage-sdrs

gha_language: Java

repo_name: GoogleCloudPlatform/storage-sdrs


text:
# language-html-swig

This is a conversion of the original [Swig.tmbundle](https://github.com/paularmstrong/Swig.tmbundle).
It also includes all the snippets of the original.

## Preview
![Preview](https://raw.githubusercontent.com/screeny05/language-html-swig/master/preview.png)

## Contributors
Thanks to all the awesome Contributors improving this package!
If you want to help, too, just submit a pull-request.

A full list of contributors can be found [here](https://github.com/screeny05/language-html-swig/graphs/contributors).

## License
Copyright (c) 2011 Paul Armstrong, Paul Armstrong Designs

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

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

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

gha_language: CoffeeScript


text:
# vscode-ripgrep

This is an npm module for using [ripgrep](https://github.com/BurntSushi/ripgrep) in a Node project. It's used by VS Code.

## How it works

- Ripgrep is built in [microsoft/ripgrep-prebuilt](https://github.com/microsoft/ripgrep-prebuilt) and published to releases for each tag in that repo.
- In this module's postinstall task, it determines which platform it is being installed on and downloads the correct binary from ripgrep-prebuilt for the platform.
- The path to the ripgrep binary is exported as `rgPath`.

### Usage example

```js
const { rgPath } = require('vscode-ripgrep');

// child_process.spawn(rgPath, ...)
```

### Dev note

Runtime dependencies are not allowed in this project. This code runs on postinstall, and any dependencies would only be needed for postinstall, but they would have to be declared as `dependencies`, not `devDependencies`. Then if they were not cleaned up manually, they would end up being included in any project that uses this. I allow `https-proxy-agent` as an exception because we already ship that in VS Code, and `proxy-from-env` because it's very small and much easier to use it than reimplement it.

### GitHub API Limit note

You can produce an API key, set the GITHUB_TOKEN environment var to it, and vscode-ripgrep will use it when downloading from GitHub. This increases your API limit.


text:
## CloudFoundry PHP example application: TinyQueries

This is an example application which can be run on CloudFoundry using the [PHP Build Pack].

This is an out-of-the-box implementation of [TinyQueries PHP-libs v<IP_ADDRESS>] and is meant to be used together with the TinyQueries compile service to build a REST-api by only defining queries.

### Usage

1. Clone the app (i.e. this repo).

  ```bash
  git clone https://github.com/wdiesveld/cf-ex-tinyqueries
  cd cf-ex-tinyqueries
  ```

1. If you don't have one already, create a MySQL service. With Pivotal Web Services, the following command will create a free MySQL database through [ClearDb]. Note that a [sample database] will be installed so it's best to use an empty database.

  ```bash
  cf create-service cleardb spark my-test-mysql-db
  ```

1. If you don't have one already, create a TinyQueries project. With Pivotal Web Services, the following command will create a free TinyQueries project through [TinyQueries].

  ```bash
  cf create-service tinyqueries free my-test-tinyqueries-project
  ```

1. Edit the manifest.yml file.  Change the 'host' attribute to something unique. Then under "services:" change "my-test-mysql-db" to the name of your MySQL service. This is the name of the service that will be bound to your application and thus available to this application. Do the same for "my-test-tinyqueries-project"

1. Push it to CloudFoundry.

  ```bash
  cf push
  ```

1. After the application is deployed you can access your application URL in the browser. You will find further instructions how to use TinyQueries from there.

### How It Works

When you push the application here's what happens.

1. The local bits are pushed to your target. It includes the changes we made and a build pack extension for TinyQueries.
1. The server downloads the [PHP Build Pack] and runs it.  This installs HTTPD and PHP.
1. The build pack sees the extension that we pushed and runs it.  The extension downloads the stock TinyQueries file from GitHub, unzips it and installs it into the `htdocs` directory.  It then copies the rest of the files that we pushed and replaces the default TinyQueries files with them.
1. At this point, the build pack is done and CF runs our droplet.

[TinyQueries PHP-libs v<IP_ADDRESS>]:https://github.com/wdiesveld/tiny-queries-php-api/releases/tag/v<IP_ADDRESS>
[TinyQueries]:http://www.tinyqueries.com
[PHP Build Pack]:https://github.com/dmikusa-pivotal/cf-php-build-pack
[ClearDb]:https://www.cleardb.com/
[sample database]:http://www.mysqltutorial.org/mysql-sample-database.aspx

repository: wdiesveld/cf-ex-tinyqueries

repo_name: wdiesveld/cf-ex-tinyqueries


text:
---
layout: post
title: Codegate CTF 2017 Prequalification Writeup
draft: false
---

[Codegate Prequal CTF](http://ctf.codegate.org/) was a very tough competition, the first one I have seen with almost exclusive emphasis on Reverse Engineering. Still, it was a great learning experience, which highlighted what areas of RE I need to read up on and practice.

Here's the writeup for the challenge that I completed:

**[BabyMISC]({{ site.baseurl }}/ctfs/codegate2017/babymisc)**


text:
# ums
Spring Boot Microservice for User Management System using spring security basic auth and JWT

Clone the repository 'common-utils', which is used as common code accross all project

Steps to build the project
    Go to common-utils directory, run mvn clean install

    Go to ums, execute the db script from db/query.sql file in your database

    Go to cmd and run mvn clean package and deploy the war file to the server.

repository: nssaga/ums

repo_name: nssaga/ums


text:
---
id: 4753
title: Eiichiro Oda
date: 2021-04-06T17:37:27+00:00
author: Laima
layout: post
guid: https://ukdataservers.com/eiichiro-oda/
permalink: /04/06/eiichiro-oda/
---

* some text
{: toc}

## Who is Eiichiro Oda

Popular Japanese manga artist who was best known for his work on the One Piece series, which became the highest-selling manga series of all time, with more than 470 million copies sold. He was voted the fifth most popular manga artist in Japan.

## Prior to Popularity

He spent his childhood watching the animated series Vicky the Viking, which inspired him to draw pirates. He was heavily influenced by Akira Toriyama of Dragon Ball fame.

## Random data

He and Toriyama collaborated on the crossover Cross Epoch, which featured Dragon Ball and One Piece characters.

## Family & Everyday Life of Eiichiro Oda

He stated that he knew he wanted to become a manga artist from the age of four. He married Chiaki Inaba in 2005.

## People Related With Eiichiro Oda

His series was turned into a long-running anime series featuring Caitlin Glass as a voice actor in the American dubs.


text:
# Domain Driven Design + Clean Architecture
# Domain-Driven Design with ASP.NET Core Microservices @SoftUni - August 2020

![Home](https://i.imgur.com/W4xqEl0.jpg)

## Project description

Simple pet clinic application for managing appointments and operations.
There are two roles: Client and Doctor.
Four bounded contexts:
- Identity
- Adoptions
- Appointments
- MedicalRecords

Identity context contains the doctor/client registrations.

Adoptions context has the following functionality:
- All pets available for adoption
- Details
- Add new pet
- Adopt pet (which is available only for clients)

Appointments has:
- List of all for the current member
- Make new as client
- Make new as doctor
- Update date
- Remove

Medical records bounded context consists of:
- List of all clients
- List of all doctors
- Client details
- Doctor details
- Add diagnose - for pets
- Add new pet (to client)

### Technologies and tools used:
- ASP.NET Core + EF Core 3.1
- FluentValidation
- MediatR + CQRS
- AutoMapper
- Bogus
- FakeItEasy
- Fluent Assertions
- JwtBearer
- Scrutor
- Swagger
- Moq
- Shouldly


text:
## Created by: Aditya Mahimkar
📫 [**Mail<EMAIL_ADDRESS>
# Corner Detection in OpenCV
Corner Detection is detecting corner points in an image. Basically the popular algorithms in OpenCV are as follows:
1. **Harris Corner Detection**
2. **Shi-Tomasi Corner Detection**

**Let's see the basic intution behind corner detection:**

In the animation below, there is a kernel or window which moves in particular alignment on the image. The image contains the shape on which the corners are to be detected.

![Animation1](Aditya_pics/Animation1.gif)

Here when the kernel moves we can see the intensity change in the kernel but in a particular axis either x-axis or y-axis. Here we can say that its an edge.

![Animation2](Aditya_pics/Animation2.gif)

As the kernel moves towards the corner, the intensity change is in different axes. Thus a corner is detected.

![Animation3](Aditya_pics/Animation3.gif)

## Harris Corner Detection
- Let's see the mathematical approach:

The kernel is a matrix which can be formulated as:

![Harris_eqn1](Aditya_pics/Harris_eqn1.PNG)

Now on calculating the eigen values of the matrix M, lets determine the score of that matrix 'R':

![Harris_eqn2](Aditya_pics/Harris_eqn2.PNG)

here,
- det(M) = λ1λ2
- trace(M) = λ1 + λ2
- k is free constant which varies between 0.04 to 0.06
- λ1 and λ2 are the eigen values of matrix M

Conditions to be considered:
1. When λ1 and λ2 are small, the region is **flat**.
2. When λ1 << λ2 or λ1 >> λ2 ie, there is a huge difference in the two values then the region is **edge**.
3. When λ1 and λ2 are large and are almost equal λ1 ~ λ2 then the region is **corner**.

- How the function looks like:
```python
detect = cv2.cornerHarris(img=gray, blocksize=5, ksize=5, k=0.04)
```
where,
  - **img**: the image to be provided to process, specifically grayscale.
  - **blocksize**: size of corner highlights. Higher the value, thicker the corners will shaded.
  - **ksize**: aperture parameter and should be odd value lying between 0 and 31. Higher values increases the accuracy.
  - **k**: it is a free constant which lies between 0.04 and 0.06.
  - **detect**: the function returns the image.

> one important point is cornerHarris function accepts **float32 value**.

**Output**:

![Harris_output](Aditya_pics/Harris_output.PNG)

## Shi-Tomasi Corner Detection

The intution of this algorithm is quite similar to Harris Corner algorithm but the mathematical approach is bit different. We consider the minimum eigen value as the R score.

![Shi_tomasi_eqn2](Aditya_pics/Shi_tomasi_eqn2.PNG)

> Again over here the conditions related to R score and eigen values are similar.

- Shi-Tomasi is actually named as goodFeaturesToTrack function:
```python
corners = cv2.goodFeaturesToTrack(img=gray, maxCorners=23, qualityLevel=0.01, minDistance=15)
```
where,
  - **img**: the image to be provided to process, specifically grayscale.
  - **maxCorners**: the maximum number of corners to be displayed based on their score. To display all corners give 0 as argument.
  - **qualityLevel**: the quality level below which that corner points will be rejected.
  - **minDistance**: the minimum distance between two corners. So if two points have a distance less than this value one of them will be removed based on score.
  - **corners**: the function returns an array of cordinates of those corners to be displayed.

**Output**:

![Shi_tomasi_output](Aditya_pics/Shi_tomasi_output.PNG)

### What are the difference between two algorithms:

- When we compare the output images of both algorithms, it is found in Harris corner method that some reduntant points have been detected which in Shi Tomasi method are not being detected. This implies some **inefficiency in the Harris Corner algorithm**.
- We can control the number of corners to be displayed in Shi Tomasi method.

### Applications of Corner Detection
- Object Recognition
- Motion Tracking
- 3D Reconstruction
- Image Alignment and Stitching


text:
Vinyl is a general solution to the records problem in Haskell using type level strings and other modern GHC features, featuring static structural typing (with a subtyping relation), and automatic row-polymorphic lenses. All this is possible without Template Haskell.

First, install Vinyl from [Hackage](http://hackage.haskell.org/package/vinyl):

    cabal update
    cabal install vinyl

To learn more, [try this tutorial](https://github.com/VinylRecords/Vinyl/blob/master/tests/Intro.lhs).

## Performance Scaling
Vinyl is an approach to records in Haskell based on a heterogeneous list type: a list where each element may have a different type. Since it is a list, accessing any individual field of a Vinyl record seems as though it should have *O(n)* complexity, with *n* the size of the record. Sure enough, pattern matching on a Vinyl record works just as with a list: we peel off the head element until we reach the one we are looking for. But we have an option to change these asymptotics.

If we anticipate frequent `get` operations on a record, we can use the function `toARec :: Rec f ts -> ARec f ts` to produce an *array-backed `Rec`* that offers constant-time field access. We can consider a [benchmark](https://github.com/VinylRecords/Vinyl/blob/master/benchmarks/AccessorsBench.hs) of getting specific fields from different varieties of Vinyl records.

This benchmark suggests the trends we should expect

* Getting a field deeper in a Vinyl record takes more time than getting one earlier (i.e. it appears to the left, or under fewer `:&` constructors) in the record
* Getting a field of an `ARec` (or `AFieldRec`, which is an `ARec` with named fields) array-backed record does not depend on where in the record that field lies

The x-axis of this graph should be labeled as *nanoseconds*.

![Accessors benchmark plot](/images/accessors.png)

repository: VinylRecords/Vinyl

extension: markdown

gha_language: Haskell

repo_name: VinylRecords/Vinyl


text:
# Nginx Cookbook Changelog

# 1.1.0

ENHANCEMENT:
- Added zero downtime support through reload

# 1.0.0

BREAKING CHANGES:
- Website configurations must be in /etc/nginx/conf.d not in the main nginx.conf

# 0.1.1

- Integrated with TravisCI

# 0.1.0

- Initial development

repository: gauthier-delmee/nginx

repo_name: gauthier-delmee/nginx


text:
# ESP Ra. De. (international ver) Free Play patch
2018 Michael Moffitt
<EMAIL_ADDRESS>
This patch adds a Free Play option to the game's configuration screen,
replacing the 3 coins / 1 play option that is rarely used in a home or
presentation environment.

A forced-reset feature is also added, where holding both start buttons
for three seconds resets the game, allowing a player to start fresh.

Presently only the international version of the game has been patched.
Support for either Japanese release can be done, it would just require
a little more work.

Place dumps of the original international version's U41 and U42 ROMs
in the same directory, and assemble with Macro Assembler. Burn the
resulting u41.bin and u42.bin files in the out/ directory to a pair of
27C040 EPROM / 29F040 FLASH chips and install on the PCB.

repository: Mikejmoffitt/esprade-freeplay

repo_name: Mikejmoffitt/esprade-freeplay


text:
# Module 0 Environment setup

**Time**: 10 minutes

This section outlines the prerequisites to complete the workshop and instructions for launching a Cloud9 IDE environment that you will use throughout the remaining modules.

## Setup your AWS Cloud9 IDE

To setup your environment please expand **one** of the following dropdown sections (depending on how you're doing this workshop) and follow the instructions:

??? info  "Click here if you're at an AWS event where Event Engine is being used:"

	1. Navigate to the Event Engine dashboard
	2. Enter the **team hash** code that was distributed to you by the instructors.
	3. Click **AWS Console**.  The CloudFormation template for this round has already been prerun.

??? info  "Click here if you're running this individually in your own AWS Account:"
    **Launch the AWS CloudFormation Stack**

    In this section you will launch a CloudFormation stack that will create a a new [Amazon VPC](https://aws.amazon.com/vpc/) environment and a [Cloud9 IDE](https://aws.amazon.com/cloud9/) Instance that you will use for the rest of the workshop.

    Region| Deploy
    ------|-----
     N. Virginia (us-east-1) | ![Launch Cloud9 in us-east-1](./images/deploy-to-aws.png)
     Ohio (us-east-2) | ![Launch Cloud9 in us-east-2](./images/deploy-to-aws.png)
     Oregon (us-west-2) | ![Launch Cloud9 in us-west-2](./images/deploy-to-aws.png)

    1. Click the **Deploy to AWS** button above.  This will automatically take you to the console to run the template.

    2. The **Specify an Amazon S3 template URL** is already selected and the template URL is automatically added.  Click **Next**.

    3. On the **Specify Details** click **Next** (leave defaults).

    4. On the **Options** click **Next** \(leave everything on this page as the default\).

    5. On the Review page click the checkbox to **acknowledge IAM capabilities** and then click **Create stack**.
    6. Choose the **Stack Info** tab to go to the overall stack status page and wait until the stack is fully launched and shows a status of *CREATE_COMPLETE*. Click the refresh icon periodically to see progress update.  The stack will take a couple minutes to complete.

## Browse to your AWS Cloud9 IDE

AWS Cloud9 is a cloud-based integrated development environment (IDE) that lets you write, run, and debug your code with just a browser. It includes a code editor, debugger, and terminal. Cloud9 comes pre-packaged with essential tools for popular programming languages and the AWS Command Line Interface (CLI) pre-installed so you don’t need to install files or configure your laptop for this workshop.

1. Open the AWS Cloud9 console.

2. Click **Open IDE** on the **serverless-idm-wksp-ide** environment.

!!! warning "Keep your AWS Cloud9 IDE opened in a tab"
    You will be using your IDE throughout the entirety of this workshop so be sure to always have a tab open.

## Create a scratch pad
Keep a scratch pad in Cloud9 or a text editor on your local computer for notes.  When the step-by-step directions tell you to note something such as an ID or Amazon Resource Name (ARN), copy and paste that into the scratch pad tab.

1. Within Cloud9, click the **+** symbol and choose to create **New File**. You will use this new blank editor tab as a scratchpad for various resource names and variables.

    ![Cloud9 Create Scratchpad Tab](./images/cloud9-createscratchpadtab.png)

## Download your workshop code

1. Run the following command to download your application code:

```
git clone https://github.com/aws-samples/amazon-cognito-identity-management-workshop.git
```

## Initialize your developer workspace

Run the following commands to install the yarn package manager and website dependencies:

```
npm install -g yarn
cd ~/environment/amazon-cognito-identity-management-workshop/website/
yarn install
```

## Run the website locally

1. Run the following command to start the local web server:

    ```
    yarn start
    ```

    !!! warning "Wait for the development server to start"
         You can ignore any message saying *Compiled with warnings* as we will resolve these warnings as we add our functionality to the application."

2. Now that the development server has started, click **Preview Running Application** in the top of the screen next to the Run button.

    ![Cloud9 Preview](./images/cloud9-local-preview.png)

3. The web application will load in a small window next to the terminal at the bottom of the Cloud9 IDE. Click the **re-size button** next to the word **Browser** to open this window in a new tab.

    ![Cloud9 Preview Re-size](./images/cloud9-resize-live-preview.png)

   As you make changes to the web application, this tab will automatically refresh to reflect your changes. Leave this tab open and return to the Cloud9 IDE tab to continue the workshop.

!!! warning "Website is not fully functional yet"
    Though the Wild Rydes website may look functional, there is currently no integration for sign-up or sign-in requests to go anywhere.

---

After you have successfully setup your environment, you can proceed to the next module.


text:
[img-dashboard]:    ../../images/user-guides/dashboard/dashboard-scanner.png

[doc-events-tab]:           ../events/check-attack.md
[doc-scanner-overview]:     ../scanner/intro.md
[doc-explore-vulns]:        ../vulnerabilities/check-vuln.md

#   The “Scanner” Dashboard

This dashboard provides you with information about vulnerabilities detected by the scanner.

When working with this dashboard, you can choose the date range you are interested in (default choice: one month prior to the current date). This choice influences all information on the dashboard.

![!The “Scanner” dashboard][img-dashboard]

Available statistics are:
*   the number of vulnerabilities of all risk levels in the current month
*   the number of vulnerabilities of all risk levels that were not fixed by the end of the chosen date range
*   changes in the numbers of vulnerabilities of all risk levels for the whole chosen date range

Click one of the pie charts with a vulnerabilities number on the right to be redirected to the [*Events* tab][doc-events-tab]. The table on this tab will contain unfixed vulnerabilities of the chosen risk level in the selected time range.

repository: vgartvich-wallarm/product-docs-en

repo_name: vgartvich-wallarm/product-docs-en


text:
# TaskManagenment
Demo Project for AWS , EC2, Jenkins, Maven, CI/CD, nginx,ubuntu, spring boot, Restfull, Hibernate/JPA

# miniproject-GAIKWAD-BHAGYESHREE

#Github Commands

#git log
commit 3dc5148592c61bfd94452a37b29739f225defea4 (HEAD -> master, origin/master, origin/HEAD)

#git status
trck the files I added 1 file git track only files

#git add filename
#git styles(folder name) filename

#git status
#git log
#git commit

#git commit -m "message"

#pushing something to github :
#git branch
#git push origin master  (its calling delta :)

#modified
git add index.html
git status

#git log --oneline

#git remote -v

#push local to remote
#pull means remote to a local what others are done

git pull origin

pull request (used for : )

Done working on module we want to review my code someone else PR(Pull Request )Code Reviews

Telling bring all changes assign someone else in commnet it is meeting business requirenments we can merge the code we can merge sign in to master always create a PR

create pull request signin feature description reviewer assign here

repository: bhagyeshree/TaskManagenment

repo_name: bhagyeshree/TaskManagenment


text:
# Prime Multiplication Table

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

A command-line tool that prints a multiplication table of the first N prime numbers.

## Installation

There are two ways to install Prime Multiplication Table, either straight from RubyGems or from the repository.

### Installing from RubyGems

```
gem install pmt
```

### Installing from repository

Clone the repository:

```
git clone https://github.com/SebastianCoetzee/pmt.git
```

Change into the directory:

```
cd pmt
```

Build the gem:

```
gem build pmt.gemspec
```

Install the gem (replace `x` with the version number of the gem):

```
gem install pmt-x.x.x.gem
```

## Usage

Run the tool with the following command, which prints a multiplication table of the first 10 prime numbers:

```
pmt
```

Output:

```
+----+----+----+-----+-----+-----+-----+-----+-----+-----+-----+
|    | 2  | 3  | 5   | 7   | 11  | 13  | 17  | 19  | 23  | 29  |
+----+----+----+-----+-----+-----+-----+-----+-----+-----+-----+
| 2  | 4  | 6  | 10  | 14  | 22  | 26  | 34  | 38  | 46  | 58  |
+----+----+----+-----+-----+-----+-----+-----+-----+-----+-----+
| 3  | 6  | 9  | 15  | 21  | 33  | 39  | 51  | 57  | 69  | 87  |
+----+----+----+-----+-----+-----+-----+-----+-----+-----+-----+
| 5  | 10 | 15 | 25  | 35  | 55  | 65  | 85  | 95  | 115 | 145 |
+----+----+----+-----+-----+-----+-----+-----+-----+-----+-----+
| 7  | 14 | 21 | 35  | 49  | 77  | 91  | 119 | 133 | 161 | 203 |
+----+----+----+-----+-----+-----+-----+-----+-----+-----+-----+
| 11 | 22 | 33 | 55  | 77  | 121 | 143 | 187 | 209 | 253 | 319 |
+----+----+----+-----+-----+-----+-----+-----+-----+-----+-----+
| 13 | 26 | 39 | 65  | 91  | 143 | 169 | 221 | 247 | 299 | 377 |
+----+----+----+-----+-----+-----+-----+-----+-----+-----+-----+
| 17 | 34 | 51 | 85  | 119 | 187 | 221 | 289 | 323 | 391 | 493 |
+----+----+----+-----+-----+-----+-----+-----+-----+-----+-----+
| 19 | 38 | 57 | 95  | 133 | 209 | 247 | 323 | 361 | 437 | 551 |
+----+----+----+-----+-----+-----+-----+-----+-----+-----+-----+
| 23 | 46 | 69 | 115 | 161 | 253 | 299 | 391 | 437 | 529 | 667 |
+----+----+----+-----+-----+-----+-----+-----+-----+-----+-----+
| 29 | 58 | 87 | 145 | 203 | 319 | 377 | 493 | 551 | 667 | 841 |
+----+----+----+-----+-----+-----+-----+-----+-----+-----+-----+
```

You can specify the number of prime numbers:

```
pmt --count 5
```

Output:

```
+----+----+----+----+----+-----+
|    | 2  | 3  | 5  | 7  | 11  |
+----+----+----+----+----+-----+
| 2  | 4  | 6  | 10 | 14 | 22  |
+----+----+----+----+----+-----+
| 3  | 6  | 9  | 15 | 21 | 33  |
+----+----+----+----+----+-----+
| 5  | 10 | 15 | 25 | 35 | 55  |
+----+----+----+----+----+-----+
| 7  | 14 | 21 | 35 | 49 | 77  |
+----+----+----+----+----+-----+
| 11 | 22 | 33 | 55 | 77 | 121 |
+----+----+----+----+----+-----+
```

To see an explanation of the command line interface, use the help function:

```
pmt --help
```

# Testing

After cloning the repository as explained above, from the root of the repository, run the following:

```
gem install bundler
```

Then install the dependencies:

```
bundle install
```

After the dependencies are installed, run the following command to run the test suite:

```
rspec
```

# External Dependencies

- [commander](https://github.com/commander-rb/commander) for parsing command line arguments
- [terminal-table](https://github.com/tj/terminal-table) for formatting the table to STDOUT

# License

MIT

repository: sebcoetzee/pmt

repo_name: sebcoetzee/pmt


text:
---
title: "Overview"
description: "Examples of data modeling with AWS DynamoDB"
slug: "data-modeling-overview"
lesson: 1
chapter: 6
date: "01/01/2018"
type: "lesson"
---

I'd like to add data modeling examples for common use cases including one-to-one relationships, one-to-many, many-to-many, graphs, and more.

Are there particular use cases you'd like to see? [Hit me<EMAIL_ADDRESS>and let me know!


text:
Debugger for GitHub actions

## Usage

Add action to workflow file:
```yaml
---
name: Debugger
on: push
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
      with:
        fetch-depth: '20'
    - name: Run a one-line script
      uses: g4s8/debugger-action@master
      with:
        payload: "true"
        gitlog: "true"
        env: "true"
 ```

 Parameters:
  - `payload` - show events payload
  - `gitlog` - show git log
  - `env` - show environment variables


text:
# Importing code

Typically, code will be imported and the last path element will serve as a
qualifier to access exported identifiers.

There are a few variants:

* normal/default
* aliasing
* period (.)
* blank (for side effects)

```
import   "lib/math"         math.Sin
import m "lib/math"         m.Sin
import . "lib/math"         Sin

import(
  "image"
  "image/jpeg"   // direct access
  _ "image/png"  // allow to read png
  _ "image/gif"  // allow to read gif
)
```

> Decoding any particular image format requires the prior registration of a
> decoder function. Registration is typically automatic as a side effect of
> initializing that format's package.

## Naming conventions

* Why is a package like `https://github.com/json-iterator/go` imported as `jsoniter`.
* What about versioning, e.g. https://github.com/googleapis/google-api-go-client

For youtube, the package declaration reads like:

* https://github.com/googleapis/google-api-go-client/blob/master/youtube/v3/youtube-gen.go

```go
// See https://godoc.org/google.golang.org/api/option/ for details on options.
package youtube // import "google.golang.org/api/youtube/v3"
...
```

We see comment behind the package name; this is a vanity URL package and the
comment enforces the use of one name (via vanity URL).

## Vanity

```
$ sudo nc -l 80
GET /?go-get=1 HTTP/1.1
Host: <IP_ADDRESS>
User-Agent: Go-http-client/1.1
Accept-Encoding: gzip

----

$ GOINSECURE=<IP_ADDRESS> GOPROXY="" go get <IP_ADDRESS>/foo
```

For the youtube example:

```
$ curl -sL "google.golang.org/api/youtube/v3/?go-get=1" | grep "meta"
<meta name="go-import" content="google.golang.org/api git https://github.com/googleapis/google-api-go-client">
<meta name="go-source" content="google.golang.org/api https://github.com/googleapis/google-api-go-client https://github.com/googleapis/google-api-go-client/tree/master{/dir} https://github.com/googleapis/google-api-go-client/tree/master{/dir}/{file}#L{line}">
<meta http-equiv="refresh" content="0; url=https://pkg.go.dev/google.golang.org/api/youtube/v3/">
```

> In go, it is convention that the directory match the package name but this
> doesn't have to be the case, and often it is not with 3rd party packages. The
> stdlib does do a good job of sticking to this convention.

## Example

* https://github.com/miku/demo/cmd/impv

repository: miku/gonotes

repo_name: miku/gonotes


text:
# CSV binders for Play [![test](https://github.com/lloydmeta/play-csv/actions/workflows/test.yml/badge.svg)](https://github.com/lloydmeta/play-csv/actions/workflows/test.yml)

If you're reading this, you probably know what you want: CSV path, query and form binders for
your Play-based application.

You know why you want it:

- Smaller URLS
- Guaranteed ordering
- You want to

## SBT

### for play 2.8.x

```scala
libraryDependencies ++= Seq(
    "com.beachape" %% "play-csv" % "1.6"
)
```

### for play 2.7.x

```scala
libraryDependencies ++= Seq(
    "com.beachape" %% "play-csv" % "1.5"
)
```

### for play 2.6.x

```scala
libraryDependencies ++= Seq(
    "com.beachape" %% "play-csv" % "1.4"
)
```

### for play 2.5.x

```scala
libraryDependencies ++= Seq(
    "com.beachape" %% "play-csv" % "1.3"
)
```

### for play 2.4.x

```scala
libraryDependencies ++= Seq(
    "com.beachape" %% "play-csv" % "1.2"
)
```

### for play 2.3.x

```scala
libraryDependencies ++= Seq(
    "com.beachape" %% "play-csv" % "1.1"
)
```

## How-to

To use `Csv` in your routes file, simply add the following to your `build.sbt` or `Build.scala`

```scala
routesImport += "com.beachape.play.Csv"
```

Then in your routes file, add routes that use `Csv`

```
GET        /                    controllers.Application.index(ids: Csv[Int])
GET        /:ids                controllers.Application.hello(ids: Csv[Int])
```

For more information, check out the project in the `sample` directory.

## Licence

The MIT License (MIT)

Copyright (c) 2015 by Lloyd Chan

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

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

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

repository: lloydmeta/play-csv

gha_language: Scala

repo_name: lloydmeta/play-csv