text:
---
title: Continuous Queries

menu:
  influxdb_1_0:
    weight: 40
    parent: query_language
---

## Introduction

Continuous Queries (CQ) are InfluxQL queries that run automatically and
periodically on realtime data and store query results in a
specified measurement.

    Basic Syntax
    Advanced Syntax
    CQ Management

    Examples of Basic Syntax
    Examples of Advanced Syntax
    CQ Use Cases

    Common Issues with Basic Syntax
    Common Issues with Advanced Syntax
    Further Reading

## Syntax

### Basic Syntax

```
CREATE CONTINUOUS QUERY <cq_name> ON <database_name>
BEGIN
  <cq_query>
END
```

#### Description of Basic Syntax

##### The cq_query

The `cq_query` requires a
[function](/influxdb/v1.0/concepts/glossary/#function),
an [`INTO` clause](/influxdb/v1.0/query_language/spec/#clauses),
and a [`GROUP BY time()` clause](/influxdb/v1.0/query_language/spec/#clauses):

```
SELECT <function[s]> INTO <destination_measurement> FROM <measurement> [WHERE <stuff>] GROUP BY time(<interval>)[,<tag_key[s]>]
```

>**Note:** Notice that the `cq_query` does not require a time range in a `WHERE` clause.
InfluxDB automatically generates a time range for the `cq_query` when it executes the CQ.
Any user-specified time ranges in the `cq_query`'s `WHERE` clause will be ignored
by the system.

##### Schedule and Coverage

CQs operate on realtime data.
They use the local server’s timestamp, the `GROUP BY time()` interval, and
InfluxDB's preset time boundaries to determine when to execute and what time
range to cover in the query.

CQs execute at the same interval as the `cq_query`'s `GROUP BY time()` interval,
and they run at the start of InfluxDB's preset time boundaries.
If the `GROUP BY time()` interval is one hour, the CQ executes at the start of
every hour.

When the CQ executes, it runs a single query for the time range between
[`now()`](/influxdb/v1.0/concepts/glossary/#now) and `now()` minus the
`GROUP BY time()` interval.
If the `GROUP BY time()` interval is one hour and the current time is 17:00,
the query's time range is between 16:00 and 16:59.

#### Examples of Basic Syntax

The examples below use the following sample data in the `transportation`
database.
The measurement `bus_data` stores 15-minute resolution data on the number of bus
`passengers` and `complaints`:

```
name: bus_data
--------------
time                   passengers   complaints
2016-08-28T07:00:00Z   5            9
2016-08-28T07:15:00Z   8            9
2016-08-28T07:30:00Z   8            9
2016-08-28T07:45:00Z   7            9
2016-08-28T08:00:00Z   8            9
2016-08-28T08:15:00Z   15           7
2016-08-28T08:30:00Z   15           7
2016-08-28T08:45:00Z   17           7
2016-08-28T09:00:00Z   20           7
```

##### Example 1: Automatically downsample data

Use a simple CQ to automatically downsample data from a single field
and write the results to another measurement in the same database.

```
CREATE CONTINUOUS QUERY "cq_basic" ON "transportation"
BEGIN
  SELECT mean("passengers") INTO "average_passengers" FROM "bus_data" GROUP BY time(1h)
END
```

`cq_basic` calculates the average hourly number of passengers from the
`bus_data` measurement and stores the results in the `average_passengers`
measurement in the `transportation` database.

`cq_basic` executes at one-hour intervals, the same interval as the
`GROUP BY time()` interval.
Every hour, `cq_basic` runs a single query that covers the time range between
`now()` and `now()` minus the `GROUP BY time()` interval, that is, the time
range between `now()` and one hour prior to `now()`.

Annotated log output on the morning of August 28, 2016:

>
At **8:00** `cq_basic` executes a query with the time range `time >= '7:00' AND time < '08:00'`.
`cq_basic` writes one point to the `average_passengers` measurement:
>
    name: average_passengers
    ------------------------
    time                   mean
    2016-08-28T07:00:00Z   7
>
At **9:00** `cq_basic` executes a query with the time range `time >= '8:00' AND time < '9:00'`.
`cq_basic` writes one point to the `average_passengers` measurement:
>
    name: average_passengers
    ------------------------
    time                   mean
    2016-08-28T08:00:00Z   13.75

Results:
```
> SELECT * FROM "average_passengers"
name: average_passengers
------------------------
time                   mean
2016-08-28T07:00:00Z   7
2016-08-28T08:00:00Z   13.75
```

##### Example 2: Automatically downsample data into another retention policy

[Fully qualify](/influxdb/v1.0/query_language/data_exploration/#the-basic-select-statement)
the destination measurement to store the downsampled data in a non-`DEFAULT`
[retention policy](/influxdb/v1.0/concepts/glossary/#retention-policy-rp) (RP).

```
CREATE CONTINUOUS QUERY "cq_basic_rp" ON "transportation"
BEGIN
  SELECT mean("passengers") INTO "transportation"."three_weeks"."average_passengers" FROM "bus_data" GROUP BY time(1h)
END
```

`cq_basic_rp` calculates the average hourly number of passengers from the
`bus_data` measurement and stores the results in the `transportation` database,
the `three_weeks` RP, and the `average_passengers` measurement.

`cq_basic_rp` executes at one-hour intervals, the same interval as the
`GROUP BY time()` interval.
Every hour, `cq_basic_rp` runs a single query that covers the time range between
`now()` and `now()` minus the `GROUP BY time()` interval, that is, the time
range between `now()` and one hour prior to `now()`.

Annotated log output on the morning of August 28, 2016:

>
At **8:00** `cq_basic_rp` executes a query with the time range `time >= '7:00' AND time < '8:00'`.
`cq_basic_rp` writes one point to the `three_weeks` RP and the `average_passengers` measurement:
>
    name: average_passengers
    ------------------------
    time                   mean
    2016-08-28T07:00:00Z   7
>
At **9:00** `cq_basic_rp` executes a query with the time range
`time >= '8:00' AND time < '9:00'`.
`cq_basic_rp` writes one point to the `three_weeks` RP and the `average_passengers` measurement:
>
    name: average_passengers
    ------------------------
    time                   mean
    2016-08-28T08:00:00Z   13.75

Results:
```
> SELECT * FROM "transportation"."three_weeks"."average_passengers"
name: average_passengers
------------------------
time                   mean
2016-08-28T07:00:00Z   7
2016-08-28T08:00:00Z   13.75
```

`cq_basic_rp` uses CQs and retention policies to automatically downsample data
and keep those downsampled data for an alternative length of time.
See the [Downsampling and Data Retention](/influxdb/v1.0/guides/downsampling_and_retention/)
guide for an in-depth discussion about this CQ use case.

##### Example 3: Automatically downsample a database with backreferencing

Use a function with a wildcard (`*`) and `INTO` query's
[backreferencing syntax](/influxdb/v1.0/query_language/data_exploration/#the-into-clause)
to automatically downsample data from all measurements and numerical fields in
a database.

```
CREATE CONTINUOUS QUERY "cq_basic_br" ON "transportation"
BEGIN
  SELECT mean(*) INTO "downsampled_transportation"."autogen".:MEASUREMENT FROM /.*/ GROUP BY time(30m),*
END
```

`cq_basic_br` calculates the 30-minute average of `passengers` and `complaints`
from every measurement in the `transportation` database (in this case, there's only the
`bus_data` measurement).
It stores the results in the `downsampled_transportation` database.

`cq_basic_br` executes at 30 minutes intervals, the same interval as the
`GROUP BY time()` interval.
Every 30 minutes, `cq_basic_br` runs a single query that covers the time range
between `now()` and `now()` minus the `GROUP BY time()` interval, that is,
the time range between `now()` and 30 minutes prior to `now()`.

Annotated log output on the morning of August 28, 2016:

>
At **7:30**, `cq_basic_br` executes a query with the time range `time >= '7:00' AND time < '7:30'`.
`cq_basic_br` writes two points to the `bus_data` measurement in the `downsampled_transportation` database:
>
    name: bus_data
    --------------
    time                   mean_complaints   mean_passengers
    2016-08-28T07:00:00Z   9                 6.5
>
At **8:00**, `cq_basic_br` executes a query with the time range `time >= '7:30' AND time < '8:00'`.
`cq_basic_br` writes two points to the `bus_data` measurement in the `downsampled_transportation` database:
>
    name: bus_data
    --------------
    time                   mean_complaints   mean_passengers
    2016-08-28T07:30:00Z   9                 7.5
>
[...]
>
At **9:00**, `cq_basic_br` executes a query with the time range `time >= '8:30' AND time < '9:00'`.
`cq_basic_br` writes two points to the `bus_data` measurement in the `downsampled_transportation` database:
>
    name: bus_data
    --------------
    time                   mean_complaints   mean_passengers
    2016-08-28T08:30:00Z   7                 16

Results:

```
> SELECT * FROM "downsampled_transportation."autogen"."bus_data"
name: bus_data
--------------
time                   mean_complaints   mean_passengers
2016-08-28T07:00:00Z   9                 6.5
2016-08-28T07:30:00Z   9                 7.5
2016-08-28T08:00:00Z   8                 11.5
2016-08-28T08:30:00Z   7                 16
```

##### Example 4: Automatically downsample data and configure the CQ time boundaries

Use an
[offset interval](/influxdb/v1.0/query_language/data_exploration/#advanced-group-by-time-syntax)
in the `GROUP BY time()` clause to alter both the CQ's default execution time and
preset time boundaries.

```
CREATE CONTINUOUS QUERY "cq_basic_offset" ON "transportation"
BEGIN
  SELECT mean("passengers") INTO "average_passengers" FROM "bus_data" GROUP BY time(1h,15m)
END
```

`cq_basic_offset`calculates the average hourly number of passengers from the
`bus_data` measurement and stores the results in the `average_passengers`
measurement.

`cq_basic_offset` executes at one-hour intervals, the same interval as the
`GROUP BY time()` interval.
The 15 minute offset interval forces the CQ to execute 15 minutes after the
default execution time; `cq_basic_offset` executes at 8:15 instead of 8:00.

Every hour, `cq_basic_offset` runs a single query that covers the time range
between `now()` and `now()` minus the `GROUP BY time()` interval, that is, the
time range between `now()` and one hour prior to `now()`.
The 15 minute offset interval shifts forward the generated preset time boundaries in the
CQ's `WHERE` clause; `cq_basic_offset` queries between 7:15 and 8:14 instead of 7:00 and 7:59 .

Annotated log output on the morning of August 28, 2016:

>
At **8:15** `cq_basic_offset` executes a query with the time range `time >= '7:15' AND time < '8:15'`.
`cq_basic_offset` writes one point to the `average_passengers` measurement:
>
    name: average_passengers
    ------------------------
    time                   mean
    2016-08-28T07:15:00Z   7.75
>
At **9:15** `cq_basic_offset` executes a query with the time range `time >= '8:15' AND time < '9:15'`.
`cq_basic_offset` writes one point to the `average_passengers` measurement:
>
    name: average_passengers
    ------------------------
    time                   mean
    2016-08-28T08:15:00Z   16.75

Results:
```
> SELECT * FROM "average_passengers"
name: average_passengers
------------------------
time                   mean
2016-08-28T07:15:00Z   7.75
2016-08-28T08:15:00Z   16.75
```
Notice that the timestamps are for 7:15 and 8:15 instead of 7:00 and 8:00.

#### Common Issues with Basic Syntax

##### Issue 1: Handling time intervals with no data

CQs do not write any results for a time interval if no data fall within that
time range.

Note that the basic syntax does not support using
[`fill()`](/influxdb/v1.0/query_language/data_exploration/#group-by-time-intervals-and-fill)
to change the value reported for intervals with no data.
Basic syntax CQs ignore `fill()` if it's included in the CQ query.
A possible workaround is to use the
[advanced CQ syntax](#example-4-configure-the-cq-s-time-range-and-fill-empty-results).

##### Issue 2: Resampling previous time intervals

The basic CQ runs a single query that covers the time range between `now()`
and `now()` minus the `GROUP BY time()` interval.
See the [advanced syntax](#advanced-syntax) for how to configure the query's
time range.

##### Issue 3: Backfilling results for older data

CQs operate on realtime data, that is, data with timestamps that occur
relative to [`now()`](/influxdb/v1.0/concepts/glossary/#now).
Use a basic
[`INTO` query](/influxdb/v1.0/query_language/data_exploration/#the-into-clause)
to backfill results for data with older timestamps.

##### Issue 4: Missing tags in the CQ results

By default, all
[`INTO` queries](/influxdb/v1.0/query_language/data_exploration/#the-into-clause)
convert any tags in the source measurement to fields in the destination
measurement.

Include `GROUP BY *` in the CQ to preserve tags in the destination measurement.

### Advanced Syntax

```
CREATE CONTINUOUS QUERY <cq_name> ON <database_name>
RESAMPLE EVERY <interval> FOR <interval>
BEGIN
  <cq_query>
END
```

#### Description of Advanced Syntax

##### The cq_query

See [ Description of Basic Syntax](/influxdb/v1.0/query_language/continuous_queries/#description-of-basic-syntax).

##### Schedule and Coverage

CQs operate on realtime data. With the advanced syntax, CQs use the local
server’s timestamp, the information in the `RESAMPLE` clause, and InfluxDB's
preset time boundaries to determine when to execute and what time range to
cover in the query.

CQs execute at the same interval as the `EVERY` interval in the `RESAMPLE`
clause, and they run at the start of InfluxDB’s preset time boundaries.
If the `EVERY` interval is two hours, InfluxDB executes the CQ at the top of
every other hour.

When the CQ executes, it runs a single query for the time range between
[`now()`](/influxdb/v1.0/concepts/glossary/#now) and `now()` minus the `FOR` interval in the `RESAMPLE` clause.
If the `FOR` interval is two hours and the current time is 17:00, the query's
time range is between 15:00 and 16:59.

Both the `EVERY` interval and the `FOR` interval accept
[duration literals](/influxdb/v1.0/query_language/spec/#durations).
The `RESAMPLE` clause works with either or both of the `EVERY` and `FOR` intervals
configured.
CQs default to the relevant
[basic syntax behavior](/influxdb/v1.0/query_language/continuous_queries/#description-of-basic-syntax)
if the `EVERY` interval or `FOR` interval is not provided (see the first issue in
[Common Issues with Advanced Syntax](/influxdb/v1.0/query_language/continuous_queries/#common-issues-with-advanced-syntax)
for an anomalistic case).

#### Examples of Advanced Syntax

The examples below use the following sample data in the `transportation` database.
The measurement `bus_data` stores 15-minute resolution data on the number of bus
`passengers`:
```
name: bus_data
--------------
time                   passengers
2016-08-28T06:30:00Z   2
2016-08-28T06:45:00Z   4
2016-08-28T07:00:00Z   5
2016-08-28T07:15:00Z   8
2016-08-28T07:30:00Z   8
2016-08-28T07:45:00Z   7
2016-08-28T08:00:00Z   8
2016-08-28T08:15:00Z   15
2016-08-28T08:30:00Z   15
2016-08-28T08:45:00Z   17
2016-08-28T09:00:00Z   20
```

##### Example 1: Configure the execution interval

Use an `EVERY` interval in the `RESAMPLE` clause to specify the CQ's execution
interval.

```
CREATE CONTINUOUS QUERY "cq_advanced_every" ON "transportation"
RESAMPLE EVERY 30m
BEGIN
  SELECT mean("passengers") INTO "average_passengers" FROM "bus_data" GROUP BY time(1h)
END
```

`cq_advanced_every` calculates the one-hour average of `passengers`
from the `bus_data` measurement and stores the results in the
`average_passengers` measurement in the `transportation` database.

`cq_advanced_every` executes at 30-minute intervals, the same interval as the
`EVERY` interval.
Every 30 minutes, `cq_advanced_every` runs a single query that covers the time
range for the current time bucket, that is, the one-hour time bucket that
intersects with `now()`.

Annotated log output on the morning of August 28, 2016:

>
At **8:00**, `cq_advanced_every` executes a query with the time range `WHERE time >= '7:00' AND time < '8:00'`.
`cq_advanced_every` writes one point to the `average_passengers` measurement:
>
    name: average_passengers
    ------------------------
    time                   mean
    2016-08-28T07:00:00Z   7
>
At **8:30**, `cq_advanced_every` executes a query with the time range `WHERE time >= '8:00' AND time < '9:00'`.
`cq_advanced_every` writes one point to the `average_passengers` measurement:
>
    name: average_passengers
    ------------------------
    time                   mean
    2016-08-28T08:00:00Z   12.6667
>
At **9:00**, `cq_advanced_every` executes a query with the time range `WHERE time >= '8:00' AND time < '9:00'`.
`cq_advanced_every` writes one point to the `average_passengers` measurement:
>
    name: average_passengers
    ------------------------
    time                   mean
    2016-08-28T08:00:00Z   13.75

Results:
```
> SELECT * FROM "average_passengers"
name: average_passengers
------------------------
time                   mean
2016-08-28T07:00:00Z   7
2016-08-28T08:00:00Z   13.75
```

Notice that `cq_advanced_every` calculates the result for the 8:00 time interval
twice.
First, it runs at 8:30 and calculates the average for every available data point
between 8:00 and 9:00 (`8`,`15`, and `15`).
Second, it runs at 9:00 and calculates the average for every available data
point between 8:00 and 9:00 (`8`, `15`, `15`, and `17`).
Because of the way InfluxDB
[handles duplicate points](/influxdb/v1.0/troubleshooting/frequently-asked-questions/#how-does-influxdb-handle-duplicate-points)
, the second result simply overwrites the first result.

##### Example 2: Configure the CQ's time range for resampling

Use a `FOR` interval in the `RESAMPLE` clause to specify the length of the CQ's
time range.

```
CREATE CONTINUOUS QUERY "cq_advanced_for" ON "transportation"
RESAMPLE FOR 1h
BEGIN
  SELECT mean("passengers") INTO "average_passengers" FROM "bus_data" GROUP BY time(30m)
END
```

`cq_advanced_for` calculates the 30-minute average of `passengers`
from the `bus_data` measurement and stores the results in the `average_passengers`
measurement in the `transportation` database.

`cq_advanced_for` executes at 30-minute intervals, the same interval as the
`GROUP BY time()` interval.
Every 30 minutes, `cq_advanced_for` runs a single query that covers the time
range between `now()` and `now()` minus the `FOR` interval, that is, the time
range between `now()` and one hour prior to `now()`.

Annotated log output on the morning of August 28, 2016:

>
At **8:00** `cq_advanced_for` executes a query with the time range `WHERE time >= '7:00' AND time < '8:00'`.
`cq_advanced_for` writes two points to the `average_passengers` measurement:
>
    name: average_passengers
    ------------------------
    time                   mean
    2016-08-28T07:00:00Z   6.5
    2016-08-28T07:30:00Z   7.5
>
At **8:30** `cq_advanced_for` executes a query with the time range  `WHERE time >= '7:30' AND time < '8:30'`.
`cq_advanced_for` writes two points to the `average_passengers` measurement:
>
    name: average_passengers
    ------------------------
    time                   mean
    2016-08-28T07:30:00Z   7.5
    2016-08-28T08:00:00Z   11.5
>
At **9:00** `cq_advanced_for` executes a query with the time range `WHERE time >= '8:00' AND time < '9:00'`.
`cq_advanced_for` writes two points to the `average_passengers` measurement:
>
    name: average_passengers
    ------------------------
    time                   mean
    2016-08-28T08:00:00Z   11.5
    2016-08-28T08:30:00Z   16

Notice that `cq_advanced_for` will calculate the result for every time interval
twice.
The CQ calculates the average for the 7:30 time interval at 8:00 and at 8:30,
and it calculates the average for the 8:00 time interval at 8:30 and 9:00.

Results:
```
> SELECT * FROM "average_passengers"
name: average_passengers
------------------------
time                   mean
2016-08-28T07:00:00Z   6.5
2016-08-28T07:30:00Z   7.5
2016-08-28T08:00:00Z   11.5
2016-08-28T08:30:00Z   16
```

##### Example 3: Configure the execution interval and the CQ's time range

Use an `EVERY` interval and `FOR` interval in the `RESAMPLE` clause to specify
the CQ's execution interval and the length of the CQ's time range.

```
CREATE CONTINUOUS QUERY "cq_advanced_every_for" ON "transportation"
RESAMPLE EVERY 1h FOR 90m
BEGIN
  SELECT mean("passengers") INTO "average_passengers" FROM "bus_data" GROUP BY time(30m)
END
```

`cq_advanced_every_for` calculates the 30-minute average of
`passengers` from the `bus_data` measurement and stores the results in the
`average_passengers` measurement in the `transportation` database.

`cq_advanced_every_for` executes at one-hour intervals, the same interval as the
`EVERY` interval.
Every hour, `cq_advanced_every_for` runs a single query that covers the time
range between `now()` and `now()` minus the `FOR` interval, that is, the time
range between `now()` and 90 minutes prior to `now()`.

Annotated log output on the morning of August 28, 2016:

>
At **8:00** `cq_advanced_every_for` executes a query with the time range `WHERE time >= '6:30' AND time < '8:00'`.
`cq_advanced_every_for` writes three points to the `average_passengers` measurement:
>
    name: average_passengers
    ------------------------
    time                   mean
    2016-08-28T06:30:00Z   3
    2016-08-28T07:00:00Z   6.5
    2016-08-28T07:30:00Z   7.5
>
At **9:00** `cq_advanced_every_for` executes a query with the time range `WHERE time >= '7:30' AND time < '9:00'`.
`cq_advanced_every_for` writes three points to the `average_passengers` measurement:
>
    name: average_passengers
    ------------------------
    time                   mean
    2016-08-28T07:30:00Z   7.5
    2016-08-28T08:00:00Z   11.5
    2016-08-28T08:30:00Z   16

Notice that `cq_advanced_every_for` will calculate the result for every time
interval twice.
The CQ calculates the average for the 7:30 interval at 8:00 and 9:00.

Results:
```
> SELECT * FROM "average_passengers"
name: average_passengers
------------------------
time                   mean
2016-08-28T06:30:00Z   3
2016-08-28T07:00:00Z   6.5
2016-08-28T07:30:00Z   7.5
2016-08-28T08:00:00Z   11.5
2016-08-28T08:30:00Z   16
```

##### Example 4: Configure the CQ's time range and fill empty results

Use a `FOR` interval and `fill()` to change the value reported for time
intervals with no data.
Note that at least one data point must fall within the `FOR` interval for `fill()`
to operate.
If no data fall within the `FOR` interval the CQ writes no points to the
destination measurement.

```
CREATE CONTINUOUS QUERY "cq_advanced_for_fill" ON "transportation"
RESAMPLE FOR 2h
BEGIN
  SELECT mean("passengers") INTO "average_passengers" FROM "bus_data" GROUP BY time(1h) fill(1000)
END
```

`cq_advanced_for_fill` calculates the one-hour average of `passengers` from the
`bus_data` measurement and stores the results in the `average_passengers`
measurement in the `transportation` database.
Where possible, it writes the value `1000` for time intervals with no results.

`cq_advanced_for_fill` executes at one-hour intervals, the same interval as the
`GROUP BY time()` interval.
Every hour, `cq_advanced_for_fill` runs a single query that covers the time
range between `now()` and `now()` minus the `FOR` interval, that is, the time
range between `now()` and two hours prior to `now()`.

Annotated log output on the morning of August 28, 2016:

>
At **6:00**, `cq_advanced_for_fill` executes a query with the time range `WHERE time >= '4:00' AND time < '6:00'`.
`cq_advanced_for_fill` writes nothing to `average_passengers`; `bus_data` has no data
that fall within that time range.
>
At **7:00**, `cq_advanced_for_fill` executes a query with the time range `WHERE time >= '5:00' AND time < '7:00'`.
`cq_advanced_for_fill` writes two points to `average_passengers`:
>
    name: average_passengers
    ------------------------
    time                   mean
    2016-08-28T05:00:00Z   1000          <------ fill(1000)
    2016-08-28T06:00:00Z   3             <------ average of 2 and 4
>
[...]
>
At **11:00**, `cq_advanced_for_fill` executes a query with the time range `WHERE time >= '9:00' AND time < '11:00'`.
`cq_advanced_for_fill` writes two points to `average_passengers`:
>
    name: average_passengers
    ------------------------
    2016-08-28T09:00:00Z   20            <------ average of 20
    2016-08-28T10:00:00Z   1000          <------ fill(1000)
>
At **12:00**, `cq_advanced_for_fill` executes a query with the time range `WHERE time >= '10:00' AND time < '12:00'`.
`cq_advanced_for_fill` writes nothing to `average_passengers`; `bus_data` has no data
that fall within that time range.

Results:
```
> SELECT * FROM "average_passengers"
name: average_passengers
------------------------
time                   mean
2016-08-28T05:00:00Z   1000
2016-08-28T06:00:00Z   3
2016-08-28T07:00:00Z   7
2016-08-28T08:00:00Z   13.75
2016-08-28T09:00:00Z   20
2016-08-28T10:00:00Z   1000
```

> **Note:** `fill(previous)` doesn’t fill the result for a time interval if the
previous value is outside the query’s time range.
See [Frequently Asked Questions](/influxdb/v1.0/troubleshooting/frequently-asked-questions/#why-does-fill-previous-return-empty-results)
for more information.

#### Common Issues with Advanced Syntax

##### Issue 1: If the `EVERY` interval is greater than the `GROUP BY time()` interval

If the `EVERY` interval is greater than the `GROUP BY time()` interval, the CQ
executes at the same interval as the `EVERY` interval and runs a single query
that covers the time range between `now()` and `now()` minus the `EVERY`
interval (not between `now()` and `now()` minus the `GROUP BY time()` interval).

For example, if the `GROUP BY time()` interval is `5m` and the `EVERY` interval
is `10m`, the CQ executes every ten minutes.
Every ten minutes, the CQ runs a single query that covers the time range
between `now()` and `now()` minus the `EVERY` interval, that is, the time
range between `now()` and ten minutes prior to `now()`.

This behavior is intentional and prevents the CQ from missing data between
execution times.

##### Issue 2: If the `FOR` interval is less than the execution interval

If the `FOR` interval is less than the `GROUP BY time()` interval or, if
specified, the `EVERY` interval, InfluxDB returns the following error:

```
error parsing query: FOR duration must be >= GROUP BY time duration: must be a minimum of <minimum-allowable-interval> got <user-specified-interval>
```

To avoid missing data between execution times, the `FOR` interval must be equal
to or greater than the `GROUP BY time()` interval or, if specified, the `EVERY`
interval.

Currently, this is the intended behavior.
GitHub Issue [#6963](https://github.com/influxdata/influxdb/issues/6963)
outlines a feature request for CQs to support gaps in data coverage.

## Continuous Query Management

Only admin users are allowed to work with CQs. For more on user privileges, see [Authentication and Authorization](/influxdb/v1.0/query_language/authentication_and_authorization/#user-types-and-their-privileges).

### List CQs

List every CQ on an InfluxDB instance with:
```
SHOW CONTINUOUS QUERIES
```
`SHOW CONTINUOUS QUERIES` groups results by database.
##### Example

The output shows that the `telegraf` and `mydb` databases have CQs:
```
> SHOW CONTINUOUS QUERIES
name: _internal
---------------
name   query

name: telegraf
--------------
name           query
idle_hands     CREATE CONTINUOUS QUERY idle_hands ON telegraf BEGIN SELECT min(usage_idle) INTO telegraf.autogen.min_hourly_cpu FROM telegraf.autogen.cpu GROUP BY time(1h) END
feeling_used   CREATE CONTINUOUS QUERY feeling_used ON telegraf BEGIN SELECT mean(used) INTO downsampled_telegraf.autogen.:MEASUREMENT FROM telegraf.autogen./.*/ GROUP BY time(1h) END

name: downsampled_telegraf
--------------------------
name   query

name: mydb
----------
name      query
vampire   CREATE CONTINUOUS QUERY vampire ON mydb BEGIN SELECT count(dracula) INTO mydb.autogen.all_of_them FROM mydb.autogen.one GROUP BY time(5m) END
```

### Delete CQs

Delete a CQ from a specific database with:
```
DROP CONTINUOUS QUERY <cq_name> ON <database_name>
```
`DROP CONTINUOUS QUERY` returns an empty result.
##### Example

Drop the `idle_hands` CQ from the `telegraf` database:
```
> DROP CONTINUOUS QUERY "idle_hands" ON "telegraf"`
>
```

### Alter CQs

CQs cannot be altered once they're created.
To change a CQ, you must `DROP` and re`CREATE` it with the updated settings.

## Continuous Query Use Cases

### Downsampling and Data Retention

Use CQs with InfluxDB's
[retention policies](/influxdb/v1.0/concepts/glossary/#retention-policy-rp)
(RPs) to mitigate storage concerns.
Combine CQs and RPs to automatically downsample high precision data to a lower
precision and remove the dispensable, high precision data from the database.

See the
[Downsampling and Data Retention](/influxdb/v1.0/guides/downsampling_and_retention/)
guide for a detailed walkthrough of this common use case.

### Pre-calculating Expensive Queries

Shorten query runtimes by pre-calculating expensive queries with CQs.
Use a CQ to automatically downsample commonly-queried, high precision data to a
lower precision.
Queries on lower precision data require fewer resources and return faster.

**Tip:** Pre-calculate queries for your preferred graphing tool to accelerate
the population of graphs and dashboards.

### Substituting for a `HAVING` Clause

InfluxQL does not support [`HAVING` clauses](https://en.wikipedia.org/wiki/Having_(SQL\)).
Get the same functionality by creating a CQ to aggregate the data and querying
the CQ results to apply the `HAVING` clause.

##### Example

InfluxDB does not accept the following query with a `HAVING` clause.
The query calculates the average number of `bees` at `30` minute intervals and
requests averages that are greater than `20`.
```
SELECT mean("bees") FROM "farm" GROUP BY time(30m) HAVING mean("bees") > 20
```

To get the same results:

**1. Create a CQ**

This step performs the `mean("bees")` part of the query above.
Because this step creates CQ you only need to execute it once.

The following CQ automatically calculates the average number of `bees` at
`30` minutes intervals and writes those averages to the `mean_bees` field in the
`aggregate_bees` measurement.

```
CREATE CONTINUOUS QUERY "bee_cq" ON "mydb" BEGIN SELECT mean("bees") AS "mean_bees" INTO "aggregate_bees" FROM "farm" GROUP BY time(30m) END
```

**2. Query the CQ results**

This step performs the `HAVING mean("bees") > 20` part of the query above.

Query the data in the measurement `aggregate_bees` and request values of the `mean_bees` field that are greater than `20` in the `WHERE` clause:

```
SELECT "mean_bees" FROM "aggregate_bees" WHERE "mean_bees" > 20
```

### Substituting for Nested Functions

Some InfluxQL functions
[support nesting](/influxdb/v1.0/troubleshooting/frequently-asked-questions/#which-influxql-functions-support-nesting)
of other functions.
Most do not.
If your function does not support nesting, you can get the same functionality using a CQ to calculate
the inner-most function.
Then simply query the CQ results to calculate the outer-most function.

##### Example

InfluxDB does not accept the following query with a nested function.
The query calculates the number of non-null values
of `bees` at `30` minute intervals and the average of those counts:
```
SELECT mean(count("bees")) FROM "farm" GROUP BY time(30m)
```

To get the same results:

**1. Create a CQ**

This step performs the `count("bees")` part of the nested function above.
Because this step creates a CQ you only need to execute it once.

The following CQ automatically calculates the number of non-null values of `bees` at `30` minute intervals
and writes those counts to the `count_bees` field in the `aggregate_bees` measurement.
```
CREATE CONTINUOUS QUERY "bee_cq" ON "mydb" BEGIN SELECT count("bees") AS "count_bees" INTO "aggregate_bees" FROM "farm" GROUP BY time(30m) END
```

**2. Query the CQ results**

This step performs the `mean([...])` part of the nested function above.

Query the data in the measurement `aggregate_bees` to calculate the average of the
`count_bees` field:
```
SELECT mean("count_bees") FROM "aggregate_bees" WHERE time >= <start_time> AND time <= <end_time>
```

## Further Reading

We recommend visiting the
[Downsampling and Data Retention](/influxdb/v1.0/guides/downsampling_and_retention/)
guide to see how to combine two InfluxDB features, CQs and retention policies,
to periodically downsample data and automatically expire the dispensable high
precision data.

Kapacitor, InfluxData's data processing engine, can do the same work as
InfluxDB's CQs.
Check out the
[Kapacitor documentation](/kapacitor/v1.0/examples/continuous_queries/) for when
to use Kapacitor instead of InfluxDB and how to perform the same CQ
functionality with a TICKscript.

gha_language: Less


text:
# Ch2 Notes

## Inserting data

Commands:
- insertOne()
ex) db.teams.insertOne({"name" : "Trojans"})

- insertMany()

db.teams.insertMany(
  [
    {"name" : "Bruins"},
    {"name" : "SunDevils"},
    {"name" : "WildCats"},
    {"name" : "Buffalo"},
    {"name" : "Utes"}
  ]
)

When inserting, if you don't specify an _id, MongoDB will automatically specify one for you

All _id's must be unique; if not then there will be a "WriteError"

Upserts commands also be used to insert

The _id field:

ObjectId: How is it composed?

Date | Mac Address | PID | Counter --> 12 byte string

## Valid Read queries:

db.teams.find({"team.player": "Test"}) --> You can use dot notation fields

Eqality matches types:
- matches on entire array
- matches based on any element
- matches based on a specific element
- more complex matches using an operator

db.find({"actor": "Jeff Bridges"}) --> find any document containing Jeff Bridges in the array of actors

db.find({"actor.0": "Jeff Bridges"}) --> find any document containing Jeff B. as first element in array of actors

db.collection.find({}) --> returns a cursor with a certain number of documents

Cursors and projection:

db.teams.find({"rated": "PG-13"}, {"title": 1, "_id": 0}) --> returns documents rated PG-13 with only the title without the id

- use 0 to exclude fields at the end
- use 1 to include them

## Comparison Operators examples:

db.movieDetails.find({ runtime: { $gt: 90 } }).count() --> find movies with runtimes greater than 90 minutes

db.movieDetails.find({ runtime: { $gt: 90, $lt: 120 } }).count() --> find movies with runtimes greater than 90 minutes and less than 120 minutes

db.movieDetails.find({ "tomato.meter": { $gte: 95 }, runtime: { $gt: 180 } }) --> find movies with a tomato rating of greater than 95 and a runtime of 180

db.movieDetails.find({ rated: { $ne: "UNRATED" } }).count() --> finding movies that rated because they aren't "UNRATED" and returns count

db.movieDetails.find({ rated: { $in: ["G", "PG"] } }).pretty() --> finding movies that are rated G or PG

db.movieDetails.find({ rated: { $nin: ["PG-13", "R"] } }).pretty() --> finding movies that are NOT rated PG-13 or R

List of comparison operators:
$gte - greater than or equal
$gt - greater than
$lte - less than or equal to
$lt - less than
$eq - equal to these values
$in - in the array
$nin - not in the array

db.teams.find({"tomato.meter": {$exists: true}}) --> retrieve all movie documents containing a tomato meter

db.teams.find({"tomato.meter": {$exists: false}}) --> retrieve all movie documents NOT containing a tomato meter

HW:

db.grades.aggregate([
  {'$group':{'_id':'$student_id', 'average':{$avg:'$score'}}},
  {'$sort':{'average':-1}}, {'$limit':1}
])

db.grades.aggregate([
  {'$match': {'type': 'exam', 'score': {$gte: 65 }}},
  {'$group':{'_id':'$student_id'}},
  {'$sort':{'score':-1}}, {'$limit':1}
])

db.grades.aggregate([
  {'$match': {'type': 'exam', 'score': {$gte: 65 }}},
  {'$group':{'_id':'$student_id'}}
])

 Find all exam scores greater than or equal to 65, and sort those scores from lowest to highest.

 db.grades.aggregate([
   {'$match': {'type': 'exam', 'score': {$gte: 65}}}
   {'$sort':{'score':-1}},
 ])

 db.grades.aggregate([
   {'$match': {'type': 'homework'}},
   {
     $group:
       {
         _id: "$student_id",
         minScore: { $min: "$score" }
       }
   }
])

 Write a program in the language of your choice that will remove the grade of type "homework" with the lowest score for each student from the dataset in the handout. Since each document is one grade, it should remove one document per student. This will use the same data set as the last problem, but if you don't have it, you can download and re-import

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# Oxd Ruby
[![Gem Version](https://badge.fury.io/rb/oxd-ruby.png)](https://badge.fury.io/rb/oxd-ruby)

Ruby Client Library for the [Gluu oxD Server RP - v2.4.4 to v3.0.1](https://www.gluu.org/docs-oxd/).

**oxdruby** is a thin wrapper around the communication protocol of oxD server. This can be used to access the OpenID connect & UMA Authorization end points of the Gluu Server via the oxD RP. This library provides the function calls required by a website to access user information from a OpenID Connect Provider (OP) by using the OxD as the Relying Party (RP).

## Using the Library in your website

> You are now on the `master` branch. If you want to use `oxd-ruby` for production use, switch to the branch of the matching version as the `oxd-server` you are installing.

[oxD RP](https://www.gluu.org/docs-oxd/) has complete information about the Code Authorization flow and the various details about oxD RP configuration. This document provides only documentation about the oxd-ruby library.

### Prerequisites

* Install `gluu-oxd-server`

Oxd-server needs to be running on your machine to connect with OP.

* Enable SSL on your website otherwise this library will not work.

### Installation

To install gem, add this line to your application's Gemfile:

```ruby
gem 'oxd-ruby', '~> 0.1.7'
```

Run bundle command to install it:

```bash
$ bundle install
```

### Configuring
After you installed oxd-ruby, you need to run the generator command to generate the configuration file:

```bash
$ rails generate oxd:config
```

The generator will install `oxd_config.rb` initializer file in `config/initializers` directory which conatins all the global configuration options for oxd-ruby plguin.
The following configurations must be set in config file before the plugin can be used.

1. config.oxd_host_ip
2. config.oxd_host_port
3. config.op_host
4. config.authorization_redirect_uri

## Usage

Add following snippet to your `application_controller.rb` file:

```ruby
require 'oxd-ruby'

before_filter :set_oxd_commands_instance
protected
	def set_oxd_commands_instance
		@oxd_command = Oxd::ClientOxdCommands.new
		@uma_command = Oxd::UMACommands.new
	end
```

The `ClientOxdCommands` class of the library provides all the methods required for the website to communicate with the oxD RP through sockets.
The `UMACommands` class provides commands for UMA Resource Server(UMA RS) and UMA Requesting Party(UMA RP) protocol.

### Website Registration

The website can be registered with the OpenId Provider using the<EMAIL_ADDRESS>call.

### Get Authorization URL

The first step is to generate an authorization url which the user can visit to authorize your application to use the information from the OpenId Provider.

```ruby
authorization_url = @oxd_command.get_authorization_url
```
Using the above url the website can redirect the user for authentication at the OpenId Provider.

### Get access token

The website needs to parse the information from the callback url and pass it on to get the access token for fetching user information.

```ruby
code = params[:code]
state = params[:state]
access_token = @oxd_command.get_tokens_by_code( code,state )
```
The values for code are parsed from the callback url query parameters.

### Get user claims

Claims (user information fields) made availble by the OpenId Provider can be fetched using the access token obtained above.

```ruby
user = @oxd_command.get_user_info(access_token)
```

### Using the claims

Once the user data is obtained, the various claims supported by the OpenId Provider can be used as required.

```ruby
<% user.each do |field,value| %>
	<%= "#{field} : #{value}" %>
<% end %>
```
The availability of various claims are completely dependent on the OpenId Provider.

### Logging out

Once the required work is done the user can be logged out of the system.

```ruby
logout_uri = @oxd_command.get_logout_uri(state, session_state)
```
You can then redirect the user to obtained url to perform logout.

## Using UMA commands

### UMA Protect resources

To protect resources with UMA Resource server, you need to add resources to library using `uma_add_resource(path, *conditions)` method. Then you can call following method to register resources for protection with UMA RS.

```ruby
@uma_command.uma_add_resource(path, *conditions)
@uma_command.uma_rs_protect
```

### UMA Check access for a particular resource
To check wether you have access to a particular resource on UMA Resource Sevrer or not, use following method:

```ruby
@uma_command.uma_rs_check_access(path, http_method)
```
You must first get RPT before calling this method.

### Get Requesting Party Token(RPT)
To gain access to protected resources at the UMA resource server, you must first obtain RPT.

```ruby
@uma_command.uma_rp_get_rpt(force_new)
```

### Authorize RPT
You must first call `uma_rp_get_rpt` and `uma_rs_check_access` methods before authorizing RPT. If you have already obtained the RPT, use `uma_rp_authorize_rpt` method provided by oxd-ruby library to authorize it.

```ruby
@uma_command.uma_rp_authorize_rpt
```

### Get Gluu Access Token(GAT)
To obtain GAT(Gluu Access Token) call following method with scopes as parameter.

```ruby
@uma_command.uma_rp_get_gat(scopes)
```

## Logs
You can find `oxd-ruby.log` file in `rails_app_root/log` folder. It contains all the logs about oxd-server connections, commands/data sent to server, recieved response and all the errors and exceptions raised.

## Demo Site

The **demosite** folder contains a demo Ruby on Rails application which uses the `oxd-ruby` library to demonstrate the usage of the library. The deployment instrctions for the demo site can be found inside the demosite's README file.

repository: stevenhaddox/oxd-ruby

repo_name: stevenhaddox/oxd-ruby


text:
# Laughing Waffle

Laughing Waffle is a helper library for doing bulk insert and upate (read upsert) work with SQL Server. Specifically providing help and code generation around the [MERGE Statement](https://docs.microsoft.com/en-us/sql/t-sql/statements/merge-transact-sql). There wasn't a good open source or free packages that do this kind of work, so this project aims to fill that gap.

It is targeting .NET Standard v1.3 for wide compatibility across the .NET ecosystem.

| Build Status | Activity | MyGet Downloads | NuGet Downloads | License |
|---|---|---|---|---|
| [![Build status](https://ci.appveyor.com/api/projects/status/ux3ashr21fl1kr8b/branch/master?svg=true)](https://ci.appveyor.com/project/fuzzzerd/laughing-waffle/branch/master) | [![GitHub last commit](https://img.shields.io/github/last-commit/fuzzzerd/laughing-waffle.svg?style=flat-square)](https://github.com/fuzzzerd/laughing-waffle/commits/master) | [![MyGet Downloads](https://img.shields.io/myget/laughing-waffle/dt/LaughingWaffle.svg?style=flat-square)](https://www.myget.org/feed/laughing-waffle/package/nuget/LaughingWaffle) | ![NuGet](https://img.shields.io/nuget/dt/LaughingWaffle.svg) | [![license](https://img.shields.io/github/license/fuzzzerd/laughing-waffle.svg?style=flat-square)](https://github.com/fuzzzerd/laughing-waffle/blob/master/LICENSE) |

## What is Laughing Waffle

This library is intended to make Extract, Transform, and Load (ETL) jobs easier. Other tools make both extracting the data easy as well as transforming it from one format to another, but there was no package for helping insert/update on the target side.

## Basic Usage

```csharp
// your collection that needs updated
var toUpsert = new List<YourModel>();

// upsert options
var upsertOptions = new UpsertOptions<YourModel>()
    .AddMatchColumn(p => p.PrimaryKey) // field(s) to match rows on
    .AddMapColumn(p => p.Column1) // columns to update
    .AddMapColumn(p => p.Column2)
    .SetTargetTable("YourModelTable"); // target/destination table

// dapper style use of extension methods on connections
_connection.Upsert(toUpsert, upsertOptions);
```

### Repository Statistics

[![GitHub commit activity the past week, 4 weeks, year](https://img.shields.io/github/commit-activity/y/fuzzzerd/laughing-waffle.svg?style=flat-square)](https://github.com/fuzzzerd/laughing-waffle/commits/master)

[![GitHub issues](https://img.shields.io/github/issues/fuzzzerd/laughing-waffle.svg?style=flat-square)](https://github.com/fuzzzerd/laughing-waffle/issues)

[![GitHub code size in bytes](https://img.shields.io/github/languages/code-size/fuzzzerd/laughing-waffle.svg?style=flat-square)](https://github.com/fuzzzerd/laughing-waffle/commits/master)

[![GitHub language count](https://img.shields.io/github/languages/count/fuzzzerd/laughing-waffle.svg?style=flat-square)](https://github.com/fuzzzerd/laughing-waffle/commits/master)

repository: fuzzzerd/laughing-waffle

gha_language: C#

gha_license_id: MIT

repo_name: fuzzzerd/laughing-waffle


text:
# equals

  compare values of any complexity for equivalence

## Getting Started

_With component_

	$ component install jkroso/equals

_With npm_

	$ npm install jkroso/equals --save

then in your app:

```js
var equals = require('equals')
```

## API

  - [equals()](#equals)

### equals(...)

equals takes as many arguments as you like of any type you like and returns a boolean result. Primitive types are equal if they are equal. While composite types, i.e. Objects and Arrays, are considered equal if they have both the same structure and the same content. Specifically that means the same set of keys each pointing to the same values. Composite structures can be as big as you like and and circular references are perfectly safe.

Same structure:
```js
equals(
  { a : [ 2, 3 ], b : [ 4 ] },
  { a : [ 2, 3 ], b : [ 4 ] }
) // => true
```

Different Structure:
```js
equals(
  { x : 5, y : [6] },
  { x : 5}
) // => false
```

Same structure, different values:

```js
equal(
  { a: [ 1, 2 ], b : [ 4 ]},
  { a: [ 2, 3 ], b : [ 4 ]}
) // => false
```

Primitives:

```js
equal(new Date(0), new Date(0), new Date(1)) // => false
```

Some possible gotchas:
- `null` __is not__ equal to `undefined`.
- `NaN` __is__ equal to `NaN` (normally not the case).
- `-0` __is__ equal to `+0`.
- Strings will __not__ coerce to numbers.
- Non enumerable properties will not be checked. They can't be.
- `arguments.callee` is not considered when comparing arguments

## Running the tests

```bash
$ npm install
$ make
```
Then open your browser to the `./test` directory.

_Note: these commands don't work on windows._

## License

[MIT](License)

repository: jkroso/untar

repo_name: jkroso/untar


text:
# software-raster-sdl2
This example will present a virtual screen in form of a software raster at
the resolution of 320x180 (16:9). In windowed mode it will use that resolution
scaled up to 2 (640x360), and in fullscreen it will present black bars on top and
bottom to prevent stretching if a ratio not as wide as 16:9 is provided.

Ratios wider than 16:9 will not be handled at the moment and thus stretched.

license: Unlicense


text:
# How do I call controller/view methods from the console in Rails?

## Question

When I load `script/console`, some times I want play with the output of a controller or a view helper method.

Are there ways to:

*   simulate a request?
*   call methods from a controller instance on said request?
*   test helper methods, either via said controller instance or another way?

## Answer

To call helpers, use the `helper` object:

    $ ./script/console
    >> helper.number_to_currency('123.45')
    => "R$ 123,45"

If you want to use a helper that's not included by default (say, because you removed `helper :all` from `ApplicationController`), just include the helper.

    >> include BogusHelper
    >> helper.bogus
    => "bogus output"

As for dealing with **controllers**, I quote [Nick's](https://stackoverflow.com/questions/151030/how-do-i-call-controller-view-methods-from-the-console-in-rails/1436342#1436342) answer:

>     > app.get '/posts/1'
>     > response = app.response
>     # you now have a rails response object much like the integration tests
>
>     > response.body            # get you the HTML
>     > response.cookies         # hash of the cookies
>
>     # etc, etc
>

repository: stackflow-io/stackflow

repo_name: stackflow-io/stackflow


text:
## Token-based authentication with Ruby on Rails 5 API
[Reference](https://www.pluralsight.com/guides/ruby-ruby-on-rails/token-based-authentication-with-ruby-on-rails-5-api)

- Benefits
  - CORS/cross-domain. Able to make AJAX calls to any server, on any domain.
  - Stateless. No need to keep a session store since the token is an entity.
  - Decoupling: API can be called from anywhere with a single authenticated command.
  - Mobile ready.
  - CSRF:
  - Performance: Network round trip (finding a session in the database) will take longer than calculating code.
- JWT token contains:
  - Header: Contains the type of token and the type of encryption algorithm encoded in base-64.
  - Payload: Contains information about the user and role.
  - Signature: Identifies the thing.
- They use `simple_command` with the command pattern.

repository: daryllxd/lifelong-learning

gha_language: Elixir

gha_license_id: Unlicense

repo_name: daryllxd/lifelong-learning


text:
# Interaction Sequences

## Startup Sequence

The Game module instantiates Paddles and Ball, and calls the initial functions.

## Movement Initiation

The paddle module takes user input and moves the paddle.

The ball moves left and right unless hit by a paddle.

## One score

If paddles miss, opposite one gets a score, and ball comes back to center.


text:
[x] Have a CLI for interfacing with the application
      CLI prompts user for information. Then fetches information
[x] Pull data from an external source
      Data is pulled from: http://www.house.gov/representatives/#state_ne
[x] Implement both list and detail views
      CLI starts with a list of the districts. A user then selects a district to recieve more information.


text:
# OWASP-ZAP-DOCKER
Docker file for building OWASP ZAP into Windows based Docker image.

A built copy of the Docker images can be found at the Docker Hub at https://hub.docker.com/r/ashleypoole/owasp-zap/

## Dockerfiles
**Windows.ServerCore.Latest.dockerfile** - Uses Latest tag of WindowsServerCore

## Using image
Image can be pulled using: `docker pull ashleypoole/owasp-zap:2-6-0-servercore-latest`

## Building
`docker build -t OWASP-ZAP:2-6-0-servercore-latest -f Windows.ServerCore.Latest.dockerfile .`

repository: AshleyPoole/OWASP-ZAP-DOCKER

repo_name: AshleyPoole/OWASP-ZAP-DOCKER


text:
# `put_rprofile_adapt`

Rprofile

## Description

Add [`engine_adapt()`](#engineadapt()) to `.Rprofile` .

## Usage

```r
put_rprofile_adapt()
```

## Details

This is recommended so anyone contributing to
 the project is guaranteed to be on the correct
 engine.

repository: DivadNojnarg/packer

repo_name: DivadNojnarg/packer


text:
---
number: 44
title: How to Learn New Things Quickly
date:<PHONE_NUMBER>740
url: https://traffic.libsyn.com/syntax/Syntax044.mp3
---

Scott and Wes talk about how they learn new things quickly. Scott also tells a crazy story about his weekend.

## Netlify — Sponsor

[Netlify](https://netlify.com/syntax) is the best way to deploy and host a front-end website. All the features developers need right out of the box: Global CDN, Continuous Deployment, one click HTTPS and more. Hit up [netlify.com/syntax](https://netlify.com/syntax) for more info.

They are also hiring! [netlify.com/careers](https://netlify.com/careers)

## Fluent Conf - Sponsor

Developers, software engineers, designers, and web performance professionals flock to Fluent in pursuit of a common goal: building a better web. That means delivering fast, secure, accessible experiences to users and customers.

[Fluent](https://conferences.oreilly.com/fluent/fl-ca) covers a broad range of technologies and topics to provide web programming professionals with the skills, connections, and inspiration needed to build better online and mobile experiences.

[Fluent](https://conferences.oreilly.com/fluent/fl-ca) is this June 11-14 in San Jose, CA. Save 20% today with code: **SYNTAX**

## Show Notes

2:00

* Scott recounts his crazy story about getting Lymphangitis

8:30

* Know your learning type
* videos, blogs, docs, source
* no right or wrong way

15:00

* Foundational Skills

23:00

* Narrow your focus
* Should you learn Redux with React?
* blurring skills hurts future progress
* don't learn too many things at once

26:00

* Get excited
* try to reclaim your initial excitement
* flow happens when you are excited
* pick projects around hobbies
* Star wars sucks

33:00

* Grind Time
* write code first ask questions later
* break shit
* Submit to yourself that you are going to build this 3-4 times
* iteration driven development
* quality from quantity
* use smarter people
* snippet libs
* style guides

40:00

* Immersion
* follow every kind of media you can
* put things on in the background
* permeate into your brain

## ××× SIIIIICK ××× PIIIICKS ×××

* Wes:[Crushing It Book](https://amzn.to/2FC4PIv)
* Wes:[Crushing It AudioBook](https://amzn.to/2JL8ZQQ)
* Scott: [Popmotion Pose](https://popmotion.io/pose/)

## Shameless Plugs

* [Wes' JavaScript30 Course](https://javascript30.com/)
* [Scott's Headless WordPress course](https://LevelUpTutorials.com/store)

1:00:00

* Scott comes out of nowhere with a story about TEA!

## Tweet us your tasty treats!

* [Scott's Instagram](https://www.instagram.com/stolinski/)
* [LevelUpTutorials Instagram](https://www.instagram.com/LevelUpTutorials/)
* [Wes' Instagram](https://www.instagram.com/wesbos/)
* [Wes' Twitter](https://twitter.com/wesbos)
* [Wes' Facebook](https://www.facebook.com/wesbos.developer)
* [Scott's Twitter](https://twitter.com/stolinski)
* Make sure to include [@SyntaxFM](https://twitter.com/SyntaxFM) in your tweets

repository: mohcinenazrhan/Syntax

path: /shows/044 - Learning.md

filename: 044 - Learning.md

repo_name: mohcinenazrhan/Syntax


text:
# All Javascript demo web site.
# Nodejs, Express, Jade, Socket.io, Angularjs, Karma, Protractor, Gruntjs.

This demo project features both backend and frontend Javascript, as well as testing and running tasks with Javascript.

 [http://www.powerofjavascript.com](http://www.powerofjavascript.com)

## How to run it locally?

Make sure that Nodejs and npm are installed. Download Nodejs from [https://nodejs.org/en/download](https://nodejs.org/en/download) .

After cloning the project, cd to the folder and run in the Terminal

> npm install

Then start the server with:

> npm start

Open your favorite browser and point to:

> localhost: 5001

## How to test it?

Run in the Terminal:

> grunt

It runs JSHint (detecting errors and potential problems in Javascript code), Karma unit tests and Protractor end-to-end tests.

## Why Backend Javascript?

To get number updates every 5 seconds, the application queries the Yahoo Finances API, which allows only 2000 queries per hour. If a few users open the page simultaneously and every browser triggers a request every 5 seconds, this might be quickly exceeded. Socket.io library allows to get the data once and broadcast it to all users.

## Why Angularjs?

Angularjs enables fast UI-oriented front end development.

## Why running tasks with Javascript?

Gruntjs empowers a clean, simple and efficient way to break down and run repetitive and complex series of tasks. There is a huge number of Grunt plugins available to automate standard tasks. No more mess, lost files and time waste with shell scripts!

## License
MIT

repository: calaverastech/powerofjavascript

repo_name: calaverastech/powerofjavascript


text:
# NHM-specimens
Aggregating & linking-up mentions of Natural History Museum, London specimens in the literature to specimen identifiers

Project now more easy to cite thanks to Zenodo, we have a DOI!

[![DOI](https://zenodo.org/badge/doi/10.5281/zenodo.34966.svg)](http://dx.doi.org/10.5281/zenodo.34966)

Suggested citation: Mounce, R. and Rankin, A. (2015) NHM-specimens. Github. DOI: 10.5281/zenodo.34966

repository: rossmounce/NHM-specimens

repo_name: rossmounce/NHM-specimens


text:
---
title: IEM Command-Line Interface Samples
---

Here you find usage samples showing how to run requests on REST API resources from the IEM CLI.

- [Actions](#actions)
- [Advanced Options](#advanced-options)
- [Export Masthead](#export-masthead)
- [Fixlet](#fixlet)
- [LDAP](#ldap)
- [Login](#login)
- [Operators](#operators)
- [DSA Replication](#dsa-replication)
- [Master Server Switch](#master-server-switch)
- [Role](#role)
- [Site](#site)
- [System Options](#system-options)

## Actions
To submit the Fixlet ID 42 in the Master Action Site, on the computer my_computer.my_domain.com, create an XML file as follows:

```xml
<BES xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="BES.xsd">
      <SourcedFixletAction>
        <SourceFixlet>
            <Sitename>ActionSite</Sitename>
            <FixletID>42</FixletID>
            <Action>Action1</Action>
        </SourceFixlet>
        <Target>
            <ComputerName>my_computer.my_domain.com</ComputerName>
        </Target>
      </SourcedFixletAction>
</BES>
```

Use the following command to post the action of submitting the Fixlet on a specific computer:

```
./iem post /BigFix/take_action_site.xml actions
```

## Advanced Options
To get the list of advanced options, run the following command:

```
./iem post /BigFix/take_action_site.xml actions
```

The command returns the list of fields in XML format as follows:

```xml
<?xml version="1.0" encoding="UTF-8"?>
<BESAPI xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="BESAPI.xsd">
            <AdminField Resource="https://my_computer.my_domain.com:52311/api/admin/field/usePre70ClientCompatibleMIME">
                 <Name>usePre70ClientCompatibleMIME</Name>
                 <Value>false</Value>
           </AdminField>
```

To set the admin key disableNmoSiteManagementDialog, create an XML file (besadmin.xml) as follows:

```xml
<?xml version="1.0" encoding="UTF-8"?>
<BESAPI xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="BESAPI.xsd">
           <AdminField Resource="https:/my_computer.my_domain.com:52311/api/admin/field/disableNmoSiteManagementDialog">
                 <Name>disableNmoSiteManagementDialog</Name>
                 <Value>1</Value>
           </AdminField>
</BESAPI>
```

Use the following command to set the appropriate attribute:

```
./iem post /BigFix/besadmin.xml admin/fields
```

## Export Masthead
Use the following command to export the masthead to standard output:

```
./iem get admin/masthead
```

Use the following command to retrieve masthead parameters:

```
./iem get admin/masthead/parameters
```

The command returns the list of parameters in XML format as follows:

```xml
<BESAPI xmlns:xsi="http://www.w3.org/2001
          /XMLSchema-instance" xsi:noNamespaceSchemaLocation="BESAPI.xsd">
            <MastheadParameters Resource="https://my_computer.my_domain.com:52311 /api/admin/masthead/parameters">
                <PortNumber>52311</PortNumber>
                <GatherInterval>Day</GatherInterval>
                <Controller>nobody</Controller>
                <InitialLockState>on</InitialLockState>
                <RequireFIPSCompliantCrypto>false</RequireFIPSCompliantCrypto>
           </MastheadParameters>
</BESAPI>
```

## Fixlet
To get the list of Fixlets in the custom site myfixes, use the following command:

```
./iem get fixlets/custom/myfixes
```

The command returns the list of Fixlets in XML format as follows:

```xml
<?xml version="1.0" encoding="UTF-8"?>
<BESAPI xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="BESAPI.xsd">
      <Fixlet Resource="https://my_computer.my_domain.com:52311/api/fixlet/custom/myfixes/34?" LastModified="Mon, 10 Dec 2012 14:33:36 +0000">
              <Name>myfixes Custom Fixlet</Name>
              <ID>34</ID>
      </Fixlet>
      <Fixlet Resource="https://my_computer.my_domain.com:52311/api/fixlet/custom/myfixes/40?" LastModified="Mon, 10 Dec 2012 16:05:30 +0000">
              <Name>MyFixlet</Name>
              <ID>40</ID>
      </Fixlet>
</BESAPI>
```

## LDAP
To get the list of defined LDAPs, use the following command:

```
./iem get ldapdirectories
```

The command returns the list of LDAP in XML format as follows:

```xml
<?xml version="1.0" encoding="UTF-8"?>
<BESAPI xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="BESAPI.xsd">
    <LDAPDirectory Resource=" https://my_computer.my_domain.com:52311/ldapdirectory/34">
          <ID>34</ID>
          <Name>AD</Name>
          <IsActiveDirectory>true</IsActiveDirectory>
          <IsGlobalCatalog>true</IsGlobalCatalog>
          <UseSSL>false</UseSSL>
          <BaseDN>DC=tem,DC=test,DC=com</BaseDN>
          <UIDAttribute>userPrincipalName</UIDAttribute>
          <UserFilter>(objectCategory=user)</UserFilter>
          <GroupFilter><![CDATA[(&(objectCategory=group) (groupType:1.2.840.1135<IP_ADDRESS>3:=2147483648))]]></GroupFilter>
          <User>BigFix\Administrator</User>
          <Servers>
            <Server>
                <Host><IP_ADDRESS></Host>
                <Port>3268</Port>
                <Priority>0</Priority>
            </Server>
          </Servers>
    </LDAPDirectory>
```

To create a new LDAP, use the same XML syntax as ./iem get ldapdirectories and add the following row after the User row in the XML file:

```
<Password>MyLDAP-Password</Password>
```

Then create the new LDAP with the following command:

```
./iem post MyLDAP.xml ldapdirectories
```

To get the configuration data of a specific LDAP having its ID (in the current example ID=34) run the following command:

```
./iem get ldapdirectory/34
```

The command returns the LDAP configuration in XML format as follows:

```xml
<?xml version="1.0" encoding="UTF-8"?>
<BESAPI xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="BESAPI.xsd">
      <LDAPDirectory Resource="https://my_computer.my_domain.com:52311/ldapdirectory/34">
             <ID>34</ID>
             <Name>AD</Name>
             <IsActiveDirectory>true</IsActiveDirectory>
             <IsGlobalCatalog>true</IsGlobalCatalog>
             <UseSSL>false</UseSSL>
             <BaseDN>DC=tem,DC=test,DC=com</BaseDN>
             <UIDAttribute>userPrincipalName</UIDAttribute>
             <UserFilter>(objectCategory=user)</UserFilter>
             <GroupFilter><![CDATA[(&(objectCategory=group) (groupType:1.2.840.1135<IP_ADDRESS>3:=2147483648))]]></GroupFilter>
             <User>BigFix\Administrator</User>
             <Servers>
                     <Server>
                            <Host><IP_ADDRESS></Host>
                            <Port>3268</Port>
                            <Priority>0</Priority>
                    </Server>
             </Servers>
      </LDAPDirectory>
```

To remove a specific LDAP having its ID (in the current example ID=34) run the following command:

```
./iem delete ldapdirectory/34
```

To convert a local operator into an LDAP operator, run the following command:

```
   BESAdmin.exe /convertToLDAPOperators [/mappingFile:<file>]
```

where `<file>` is the mapping file containing the match between Windows local operators and LDAP operators.
 Each line of the file must contain the name of the user to convert, followed by a tab and the name of the user in
 LDAP or Active Directory. The LDAP name must have the same format used to log into the console, such as domain\user,
 user@domain, or user. If the file is not available, BESAdmin converts all local users assuming their name in LDAP or
 Active Directory is the same as their local user name.

## Login
To log in, run the command:

```
./iem login --server=ServerName:ServerPort --user=master --password=Mypassword
```

To perform an https login:

```
./iem login --server=https://my_computer.my_domain.com:52311 --user=master --password=Mypassword
```

To perform a login using the Windows authentication:

```
iem.exe login --server=mybfserver.mydomain --windowsAuthentication
```

## Operators
To display a list of operators (local and LDAP), run the following command:

```
./iem get operators
```

To get roles associated to an operator, run the following command:

```
./iem get operator/OperatorName/roles
```

To add an operator, use the XML syntax example from ./iem get operators, remove the row <LastLoginTime>. For a local operator, add the row <Password>, and then run the following command:

```
./iem post MyOperator.xml operators
```

To modify an operator, use the XML syntax example from ./iem get operators, and then run the following command:

```
./iem post /tmp/Operator.xml operator/MyOperatorName
```

To remove an operator (local and LDAP), run the following command:

```
./iem delete operator/OperatorName
```

## DSA Replication
You can change the replication interval and the master server of your replication servers by using the command line.

#### Replication interval changes
To change the replication interval, complete the following steps:

1. Start the command line:

   On Windows systems:
```
iem login --server=servername:serverport --user=username --password=password
```
    On Linux systems:
```
./iem login --server=servername:serverport --user=username --password=password
```
2. Retrieve the replication server settings by running the following command:

   On Windows systems:
```
iem get replication/server/0 > c:\temp\replicationServer0.xml
```
   On Linux systems:
```
./iem get replication/server/0 > /appo/replicationServer0.xml
```
3. Edit the following keyword of the replicationServer0.xml file:
```
<ReplicationIntervalSeconds>300</ReplicationIntervalSeconds>
```
   to change the value in seconds of the replication interval. Using longer replication intervals means that the servers replicate data less often, but have more data to transfer each time.

   This is an example of the replicationServer0.xml file:

   ```xml
    <?xml version="1.0" encoding="UTF-8"?>
    <BESAPI xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="BESAPI.xsd">
       <ReplicationServer Resource="http://my_computer.my_domain.com:52311/api/replication/server/0">
               <ServerID>0</ServerID>
               <URL>http://my_computer.my_domain.com:52311</URL>
               <DNS>my_computer.my_domain.com</DNS>
          <ReplicationIntervalSeconds>300</ReplicationIntervalSeconds>
          <ReplicationLink Resource="http://my_computer.my_domain.com:52311/api/replication/server/0/link/3">
                  <SourceServerID>0</SourceServerID>
                  <DestinationServerID>3</DestinationServerID>
                  <Weight>1</Weight>
                  <IsConnected>0</IsConnected>
                  <LastReplication>Fri, 01 Mar 2013 11:17:12 +0000
                  </LastReplication>
                  <LastError>19NoMatchingRecipient - Fri, 01 Mar 2013 11:17:12 +0000
                  </LastError>
          </ReplicationLink>
          <ReplicationLink Resource="http://my_computer.my_domain.com:52311/api/replication/server/3/link/0">
                       <SourceServerID>3</SourceServerID>
                       <DestinationServerID>0</DestinationServerID>
                       <Weight>1</Weight>
                       <IsConnected>1</IsConnected>
                       <LastReplication>Fri, 01 Mar 2013 11:17:18 +0000
                       </LastReplication>
          </ReplicationLink>
       </ReplicationServer>
    </BESAPI>
```
4. Upload the modified file by running the following command:

    On Windows systems:
```
    iem post c:\temp\replicationServer0.xml  replication/server/0
```
    On Linux systems:
```
    ./iem post /appo/replicationServer0.xml  replication/server/0
```

#### Master Server Switch
By default, server 0 (zero) is the master server. To switch the master to another server, set the deployment option masterDatabaseServerID to the other server ID as follows:
1. Start the command line:

    On Windows systems:
```
    iem login --server=servername:serverport --user=username --password=password
```
    On Linux systems:
```
    ./iem login --server=servername:serverport --user=username --password=password
```
2. Retrieve the settings to switch the master server:

    On Windows systems:
```
    iem get admin/fields > c:\temp\switchmaster.xml
```
    On Linux systems:
```
     ./iem get admin/fields > /appo/switchmaster.xml
```
    In the switchmaster.xml file, add or edit the following keyword and its value:
```
      <Name>masterDatabaseServerID<Name>
      <Value>0</Value>
```
    to switch the master server to another master server:
```xml
    <?xml version="1.0" encoding="UTF-8"?>
    <BESAPI xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="BESAPI.xsd">
        <AdminField Resource="http://my_computer.my_domain.com:52311/api/admin/field/masterDatabaseServerID">
           <Name>masterDatabaseServerID</Name>
           <Value>3</Value>
        </AdminField>
    </BESAPI>
```
4. Upload the modified file by running the following command:

   On Windows systems:
```
iem post c:\temp\switchmaster.xml admin/fields
```
    On Linux systems:
```
./iem post /appo/switchmaster.xml admin/fields
```
After the value has successfully replicated to the new server, it become the master server.
If a server has a failure while it is the master, another server must be made the master server
by direct manipulation of the ADMINFIELDS table in the database.

## Role
To get the role configuration, run the following command:
```
./iem get roles
```
The command returns the role configuration in XML format.

To create a new role, run the following command:
```
./iem post Example.xml roles
```
Where Example.xml contains role configuration data in XML format.

## Site
To add a file to a custom site as master operator, run the following command:
```
./iem post /tmp/file.my /api/site/custom/test/file/file.my
```
To add a file to the master action site as master operator, run the following command:
```
iem post /tmp/file.my /api/site/master/file/file.my --force=yes
```
Where the option `--force=yes` allows to override the file it if already exists in the site.
To add a file to the operator site as non master operator, run the following command:
```
iem post /tmp/file.my /api/site/operator/nmo/file/file.my
```
Where the option `--isClient=yes` allows to make the file available for download by Clients.

The options `--force` and `--isClient` apply when running post and put requests against files, both as master and as non master operator. For more details, see [Site](../api/site.html).

## System Options
To display MinimumRefreshSeconds (seconds), and DefaultFixletVisibility (Visible, Hidden) run the following command:
```
./iem get admin/options
```
The command returns the list of options in XML format as follows:
```xml
<?xml version="1.0" encoding="UTF-8"?>
<BESAPI xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="BESAPI.xsd">
        <SystemOptions Resource="https://my_computer.my_domain.com:52311/api/admin/options">
             <MinimumRefreshSeconds>15</MinimumRefreshSeconds>
             <DefaultFixletVisibility>Visible</DefaultFixletVisibility>
       </SystemOptions>
</BESAPI>
```
To set the system option MinimumRefreshSeconds, create an XML file (SystemOptions.xml) as follows:
```xml
<?xml version="1.0" encoding="UTF-8"?>
<BESAPI xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="BESAPI.xsd">
        <SystemOptions Resource="https://my_computer.my_domain.com:52311/api/admin/options">
             <MinimumRefreshSeconds>20</MinimumRefreshSeconds>
             <DefaultFixletVisibility>Hidden</DefaultFixletVisibility>
        </SystemOptions>
</BESAPI>
```
Use the following command to set the appropriate attribute:
```
./iem post /BigFix/SystemOptions.xml admin/options
```

gha_language: JavaScript


text:
### Tiger cake

All starts with a batch of [basic cake](2021-08-Basic.md). Split the batter into two somewhat equal portions for the stripes.

#### Choclate stripe

##### Ingredients

- Basic cake batter (1 portion)
- Dark cocoa powder (3 tbsp)
- Salt ( 1 tsp )
- Buttermilk ( 1 dl )
- Dark chili choclate ( 10-20g )

##### Process

1) Add buttermilk and salt to the batter
2) Carefully mix cocoa powder to the batter
3) Grate chili choclate to the batter and mix lightly

#### Orange stripe

##### Ingredients

- Basic cake batter (1 portion)
- Oranges (2 pcs)

##### Process

1) Grate the skin of the oranges into the batter
2) Squeeze the juice to the batter
3) Mix thoroughly

#### Lemon stripe

##### Ingredients

- Basic cake batter (1 portion)
- Lemons (2 pcs)
- Lemon concentrate (1 tsp)

##### Process

1) Grate the skin of the lemons into the batter
2) Squeeze the juice to the batter
3) Add the lemon concentrate too
4) Mix thoroughly

repository: mgronhol/peters-saucepan

repo_name: mgronhol/peters-saucepan


text:
### [CVE-2013-0795](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2013-0795)
![](https://img.shields.io/static/v1?label=Product&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=n%2Fa&color=brighgreen)

### Description

The System Only Wrapper (SOW) implementation in Mozilla Firefox before 20.0, Firefox ESR 17.x before 17.0.5, Thunderbird before 17.0.5, Thunderbird ESR 17.x before 17.0.5, and SeaMonkey before 2.17 does not prevent use of the cloneNode method for cloning a protected node, which allows remote attackers to bypass the Same Origin Policy or possibly execute arbitrary JavaScript code with chrome privileges via a crafted web site.

### POC

#### Reference
No PoCs from references.

#### Github
- https://github.com/bondhan/xml2json

repository: trickest/cve

branch_name: refs/heads/main

gha_language: HTML

repo_name: trickest/cve


text:
---
title: Touch Repeat Directive
desc: Vue directive which triggers an event at specified intervals of time while the user touches and holds on a component or element.
keys: touch-repeat
examples: TouchRepeat
related:
  - /vue-directives/touch-swipe
  - /vue-directives/touch-pan
  - /vue-directives/touch-hold
---

Quasar offers full-featured Vue directives that can totally replace libraries like Hammerjs: `v-touch-pan`, `v-touch-swipe`, `v-touch-hold` and `v-touch-repeat`.

> **These directives also work with mouse events, not only touch events**, so you are able to build cool functionality for your App on desktops too.

We will be describing `v-touch-repeat` on the lines below.

<doc-api file="TouchRepeat" />

## Usage
Click and hold with your mouse on the area below to see it in action.
Notice that on touch capable devices the scrolling is not blocked.

> The default repeat pattern is 0:600:300 (ms).

<doc-example title="Basic" file="Basic" />

Below is an example configured to also react to `SPACE`, `ENTER` and `h` keys (**focus on it first**), with 0:300:200 (ms) repeat pattern. Hit & hold keys, or click/tap and hold.

<doc-example title="Custom keys" file="Keys" />

Below is an example of applying TouchRepeat to QBtn. Notice how we play with the directive arguments in order to make the blue buttons increment slower than the red ones.

<doc-example title="Applied to QBtn" file="Buttons" />

### Handling Mouse Events
When you want to handle mouse events too, use the `mouse` modifier:

```html
<div v-touch-repeat.mouse="myHandler">...</div>
```

### Handling Key Events
When you want to handle key events too, use [keycodes](https://keycode.info/) as modifiers:

```html
<div v-touch-repeat.65.70="myHandler">...</div>
```

There are some special modifiers that you do not require to write the equivalent keycode: `space`, `tab`, `enter`.

### Inhibiting TouchRepeat
When you want to inhibit TouchRepeat, you can do so by stopping propagation of the `touchstart` / `mousedown` / `keydown` events from the inner content:

```html
<div v-touch-repeat.mouse.enter="userHasHold">
  <!-- ...content -->
  <div @touchstart.stop @mousedown.stop @keydown.stop>
    <!--
      TouchRepeat will not apply here because
      we are calling stopPropagation() on touchstart,
      mousedown and keydown events
    -->
  </div>
  <!-- ...content -->
</div>
```

However, if you are using `capture`, `mouseCapture` or `keyCapture` modifiers then events will first reach the TouchRepeat directive then the inner content, so TouchRepeat will still trigger.

## Note on HMR
Due to performance reasons, not all of the modifiers are reactive. Some require a window/page/component refresh to get updated. Please check the API card for the modifiers which are not marked as reactive.

repository: quasarframework/quasar

branch_name: refs/heads/dev

repo_name: quasarframework/quasar


text:
---
layout: default
---

# 1996-08-29 - Re: There is no Agent Toby Tyler at the FBI [UK Observer St

## Header Data

From: "Peter Trei"<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 27f21f7c2593c0559f4d5bb563ac0e95a13d627cf095c5c0be0aca5766cafdce

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1996-08-29 16:11:37 UTC

Raw Date: Fri, 30 Aug 1996 00:11:37 +0800

## Raw message

```
{% raw  %}From: "Peter Trei"<EMAIL_ADDRESS>Date: Fri, 30 Aug 1996 00:11:37 +0800
To<EMAIL_ADDRESS>Subject: Re: There is no Agent Toby Tyler at the FBI [UK Observer St
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Duncan Frissell<EMAIL_ADDRESS>writes:
> At 03:17 PM 8/28/96 -0700, Richard Charles Graves wrote:
> >...two different sources, both of whom are anonymous because they work for
> >competing newspapers, tell me.
> >
> >Could someone else with contacts/time to kill/attributability please confirm
> >this?
>
> When I first saw the name, I remembered my misspent youth:
> Toby Tyler, or Ten Weeks with a Circus (1960)
> USA 1960 Color
> Produced by Walt Disney Productions

     Which proves little (though it is suggestive). People get names for
a variety of reasons, and before 1960, there would have been little
reason *not* to use the name. Back in the 70's I remember hearing
many reports from a news announcer at the BBC World Service named
Dick Tracy.

Peter Trei
<EMAIL_ADDRESS>

{% endraw %}
```

## Thread

+ Return to [August 1996](/archive/1996/08)

+ Return to "["Peter Trei" <trei@process.com>](/authors/peter_trei_trei_at_process_com_)"

+ 1996-08-29 (Fri, 30 Aug 1996 00:11:37 +0800) - Re: There is no Agent Toby Tyler at the FBI [UK Observer St - _"Peter Trei"<EMAIL_ADDRESS>


text:
0.10.1
------

- Updated to RSpec 3.
- Apply filters to encoded JSON data.

0.10.0
------

- Environments are ignored by default unless explicitly set. To disable
  events it is recommend to unset the SENTRY_DSN value.
- gzip is now the default encoding
- Removed hashie dependency

0.9.0
-----

- Native support for Delayed::Job [pkuczynski, #176]
- Updated to Sentry protocol version 5

0.5.0
-----
- Rails 2 support [sluukonen, #45]
- Controller methods in Rails [jfirebaugh]
- Runs by default in any environment other than test, cucumber, or development. [#81]

repository: flant/raven-ruby

repo_name: flant/raven-ruby


text:
#Project Details: Other Implementations

__Features__

* Gamer control: allows gamers to walk through the mazes using arrow keys
* Scalable mazes for more advanced players (may be easily implemented
  for procedural layers)
* Possible animated graphs or obstacles/challenges to appeal to gamers
* Duo mode: if implemented, allows two players to compete on the same layer.


text:
# Old Slack Emojis

Bring back old emojis to new Slack!

## What is this?
In February 2018, Slack pushed a change making Google emojis used on all platforms except macOS, instead of the older Apple emojis.

On macOS, emojis have been instead switched to the newer iOS 10.2 style, instead of the original iOS 6 style.

### Before change

![](https://i.imgur.com/oQYpzcH.png)

### After change

![](https://i.imgur.com/46NPVv2.png)

This patch reverses this change, and brings back the loveable classic Apple emojis to new Slack clients.

## Installation
Installation varies depending on if you're using the Slack webapp or desktop client. A patch for mobile app versions of Slack is not
within the scope of this project.

### Browser client

For browser clients, install an extension like Stylish ([Firefox](https://addons.mozilla.org/en-US/firefox/addon/stylish/),
[Chrome](https://chrome.google.com/webstore/detail/stylish-custom-themes-for/fjnbnpbmkenffdnngjfgmeleoegfcffe?hl=en)),
and install [this](https://userstyles.org/styles/155342/old-slack-emojis) style.

### Desktop client
#### Linux and Mac
Quick & dirty:

```shell
curl -sSL https://old-slack-emojis.cf | sudo bash
```

Alternatively, you can download and run
[the installation script](https://raw.githubusercontent.com/IvyBits/old-slack-emojis/master/old-slack-emojis.sh) from this repository.

#### Windows
Download and run [the installation script](https://raw.githubusercontent.com/IvyBits/old-slack-emojis/master/old-slack-emojis.bat)
from this repository.

The script won't work with the Windows Store version of the Slack app. The Windows Store version is write-protected and can't be
injected by this script. The version downloaded [from Slack's website](https://slack.com/downloads/windows)
should, however, work.

## Uninstallation
To uninstall, run the appropriate script with `-u` as a flag.

## Updating Slack
old-slack-emojis injects some code into the Slack client, which may be overwritten when Slack updates. If you start seeing the new
emojis, rerunning the installation script should fix things.

## "Cannot find Slack installation"

If you've installed Slack in some exotic place, the script might not find the installation by itself or it might find the
wrong installation. In such cases, you need to specify the location of Slack's `app.asar.unpacked/src/static` folder as a parameter:

```shell
sudo bash old-slack-emojis.sh /My_Apps/Slack.app/Contents/Resources/app.asar.unpacked/src/static
```

```shell
old-slack-emojis.bat E:\My_Apps\slack\app-2.5.1\resources\app.asar.unpacked\src\static
```

## Credits
old-slack-emojis uses the same injection mechanism as [math-with-slack](https://github.com/fsavje/math-with-slack), without which
a lot more time would have gone into figuring out how to get the old spritesheet injected. Thanks!

repository: IvyBits/old-slack-emojis

gha_language: Shell

repo_name: IvyBits/old-slack-emojis


text:
MooXtract
=========

A simple Haskell program for extracting Moodle submissions.

Installation
------------

It should just install with cabal. You will probably want to install
the [Haskell Platform](https://www.haskell.org/platform/).

    cabal install --bindir=/path/to/where/you/want/the/bin

Debian / Ubuntu Install
-----------------------

    git clone https://github.com/Chobbes/MooXtract.git
    cd MooXtract
    sudo apt-get install cabal-install
    cabal update
    cabal install --bindir=/path/to/where/you/want/the/bin

Usage
-----

Currently MooXtract should be used as follows. First download the
giant .zip archive of all of the moodle submissions. Let's say this is
called `submissions.zip`, then in order to extract all of them into
a marking directory you might do:

    mkdir marking
    cd marking
    unzip ~/Downloads/submissions.zip
    MooXtract

MooXtract will list submissions that it could not extract. These
submissions probably did not follow the correct format, but it's a
good idea to double check.

Issues
------

MooXtract will **NOT** handle submissions that have extra periods in
the file name.

repository: Chobbes/MooXtract

gha_language: Haskell

repo_name: Chobbes/MooXtract


text:
# Internationalization

You can configure whether you want this package to attempt to translate texts or not, for example if your project only needs to implement one language and you prefer to simply write texts wherever you need them instead of using the Translator component, please deactivate translations in the configuration:

```php
//config/html.php

return [
    //...
    'translate_texts' => false,
    //...
];
```

But if your project needs to implement more than one language or you want to organize all the texts in one place instead of hardcoding them in the controllers, views, etc. set `'translate_texts'` to `true`.

*Note:* The Field Builder will always attempt to translate texts.

## Translating labels (field builder)

If you want to have a specific label in a field, you can do so by passing it as part of the attribute array:

```blade
{!! Field::text('name', ['label' => 'Full name']) !!}
```

But you can also define it as part of the `attributes` array in the `resources/lang/en/validation.php` file:

 ```php
//resources/lang/en/validation.php

'attributes' => [
    'name' => 'Full name',
],
```

Note that this is also the convention used by the Laravel Validator component, so this way you can have all your label texts in one place.

[Learn more about the field builder](field-builder.md)

## Translating alert messages

If the `'translate_texts'` is set to `true`, this component will assume that all the alert messages are in fact language keys and will try to translate them. This means you can do things like this:

```php
Alert::success('messages.users.updated')
    ->button('messages.users.go_to_profile', url('users/profile'))
```
Of course if the lang key is not found, it will return the literal string (so you can also pass the full message instead of a lang key).

[Learn more about the alert component](alert-messages.md)

## Translating menu items

If the `'translate_texts'` is set to `true`, and you don't specify an explicit title for a menu item; the component will search for a lang key in: `menu.[menu_item_key]` if the key is not found, the package will attempt to convert the menu item key in a title format. For example:

```php
//resources/lang/en/menu.php

return [
    'home' => 'Homepage',
];
```

```php
//config/menu.php

return [
    'items' => [
        'home'  => [],
        'about' => ['title' => 'Who we are'],
        'contact-us' => [],
    ],
];
```

```blade
{!! Menu::make('menu.items') !!}
```

Will return something like:

```html
<ul>
    <li><a href="#">Homepage</a></li>
    <li><a href="#">Who we are</a></li>
    <li><a href="#">Contact us</a></li>
</ul>
```

Note that:

* "Homepage" is taken from the menu key "menu.home".
* "Who we are" is explicit defined (no translation is attempted)
* "Contact us" is generated from the key "contact-us" (since no lang key is provided)

[Learn more about the menu generator](menu-generator.md)

repository: StydeNet/html

gha_language: PHP

repo_name: StydeNet/html


text:
# Attentions. We are working in branches here!

Our wallet managing contracts address here https://rinkeby.etherscan.io/address/0x3be991e63113fa0a404371b5cc83fcdf37497562

## Some of Our branches:

#### [bakend](https://github.com/BANKEX/ethberlin-hackathon/tree/backend) - 60 commits
Our backend written with node.js

#### [ecdsa](https://github.com/BANKEX/ethberlin-hackathon/tree/ecdsa) - 27 commits

Libsnark implementation to proove statistic functions from our voting

Current solution - median. WIP - mean, mode, Variance and something more interesting.

#### [contracts](https://github.com/BANKEX/ethberlin-hackathon/tree/ethereum-bond-contract-truffle) 19 commits

Ethereum smart contracts.

We have here something like TrueBit protocol to save gas on prooving snarks. Publishers posts their proofs with the bond.

#### [pysigner](https://github.com/BANKEX/ethberlin-hackathon/tree/pysigner) 18 commits

Tool for working with special ellipric curve signature

#### [bot](https://github.com/BANKEX/ethberlin-hackathon/tree/vote-telegram-bot) 6 commits

Telegram bot for voting

#### [bakend-bot](https://github.com/BANKEX/ethberlin-hackathon/tree/backend-bot) - 8 commits
Telegram bot api for voting

# We have many branches here!

Documentation and drafts are here:
https://drive.google.com/drive/folders/1A1pFQjBTP7QFCBrSvY7rjzrnLd5Fmden

![snarks](https://raw.githubusercontent.com/BANKEX/ethberlin-hackathon/master/utils/snark.svg?sanitize=true)


text:
# aos-libmysofa-android-builder

A simple shell script to cross-compile libmysofa project for Android targets.

Builds the binaries and libs using dynamic linking.

Typical usage:
```
bash ./build.sh -a $ARCH
```

$ARCH can be either: arm arm64 x86 x86_64

mips and mips64 are untested

Requirements:
- NDK r15
- some dev tools
- free disk space in your tempfolder

repository: courville/aos-libmysofa-android-builder

repo_name: courville/aos-libmysofa-android-builder


text:
Team and repository tags
========================

[![Team and repository tags](http://governance.openstack.org/badges/cookbook-openstack-network.svg)](http://governance.openstack.org/reference/tags/index.html)

<!-- Change things from this point on -->

![Chef OpenStack Logo](https://www.openstack.org/themes/openstack/images/project-mascots/Chef%20OpenStack/OpenStack_Project_Chef_horizontal.png)

Description
===========

This cookbook installs the OpenStack Network service **Neutron** as part of a
Chef reference deployment of OpenStack. The
https://github.com/openstack/openstack-chef contains documentation for using this cookbook in the context of a full OpenStack deployment.

More information about the OpenStack Network service is available
[here](http://docs.openstack.org/mitaka/config-reference/networking.html)

Usage
=====

OpenStack Network's design is modular, with plugins available that handle L2 and
L3 networking for various hardware vendors and standards.

Requirements
============

- Chef 12 or higher
- chefdk 0.9.0 or higher for testing (also includes berkshelf for cookbook
  dependency resolution)

Platform
========

- ubuntu
- redhat
- centos

Cookbooks
=========

The following cookbooks are dependencies:

- 'openstack-common', '>= 14.0.0'
- 'openstack-identity', '>= 14.0.0'
- 'openstackclient', '>= 0.1.0'

Attributes
==========

Please see the extensive inline documentation in `attributes/*.rb` for
descriptions of all the settable attributes for this cookbook.

Note that all attributes are in the `default['openstack']` "namespace"

The usage of attributes to generate the neutron.conf is described in the
openstack-common cookbook.

Recipes
=======

## openstack-network::client
- Install the network client packages

## openstack-network::db_migration
- Migrates the neutron database

## openstack-network::default
- Configures common pieces needed for all neutron services and create the
  neutron.conf

## openstack-network::dhcp_agent
- Installs the DHCP agent

The configuration for neutron-dhcp-agent is generated from the attributes in
using the same template as for the neutron.conf

```
node['openstack']['network_dhcp']['conf']
```

## openstack-network::fwaas
**This is a 'work in progress' recipe and is currently not tested**
- Installs the Firewall as a Service

## openstack-network::identity_registration
- Registers the OpenStack Network API endpoint and service user with Keystone

## openstack-network::l3_agent
- Installs the L3 agent

The configuration for neutron-l3-agent is generated from the attributes in using
the same template as for the neutron.conf

```
node['openstack']['network_l3']['conf']
```

## openstack-network::lbaas
- Installs the Loadbalancer as a Service

The configuration for neutron-lbaas-agent is generated from the attributes in
using the same template as for the neutron.conf

```
node['openstack']['network_lbaas']['conf']
```

## openstack-network::metadata_agent
- Installs the metadata agent

The configuration for neutron-metadata-agent is generated from the attributes in
using the same template as for the neutron.conf

```
node['openstack']['network_metadata']['conf']
```

## openstack-network::metering_agent
- Installs the metering agent

The configuration for neutron-metadata-agent is generated from the attributes in
using the same template as for the neutron.conf

```
node['openstack']['network_metering']['conf']
```

## openstack-network::ml2_core_plugin
- Configure the ml2_core_plugin

## openstack-network::ml2_linuxbridge
- Configure the ml2 linuxbridge plugin

## openstack-network::ml2_openvswitch
- Configure the ml2 openvswitch plugin

## openstack-network::openvswitch
- Installs openvswitch

## openstack-network::openvswitch_agent
- Installs the openvswitch agent

## openstack-network::plugin_config
- Generates all the needed plugin configurations directly from the attributes
  in:

```
node['openstack']['network']['plugins'][myplugin]
```

The final configuration file is generated exactly like all OpenStack service
configuration files (e.g. neutron.conf), but the attribute mentioned above
allows you additionally to define the file name and patch with:

```
# this will also generate the path recursively if not already existent
node['openstack']['network']['plugins'][myplugin]['path']
# this defines the filename for the plugin config (e.g. ml2_conf.ini)
node['openstack']['network']['plugins'][myplugin]['filename']
```
In the examples above, the variable 'myplugin' can be used to generate multiple
plugin configurations with different configs and filenames. Please refer to the
recipe openstack-network::ml2_openvswitch for an full example on the usage of
this attributes.

## openstack-network::server
- Installs the openstack-network API server (currently aka neutron-server)

## openstack-network::vpnaas
This recipe has been removed since it was unmaintained since the pike release
and the vpnaas module got completely removed/refactored during the queens
release. For rocky there seems to be some kind of vpnaas implementation
directly in the l3 agent
(https://docs.openstack.org/neutron/rocky/admin/vpnaas-scenario.html), but
since the documentation about it is quite sparse right now, there is no recipe
for that. If you want to add vpnaas back to this cookbook, please feel free to
push a pull request.

License and Author
==================

|                      |                                                    |
|:---------------------|:---------------------------------------------------|
| **Authors**          |  Alan Meadows<EMAIL_ADDRESS>          |
|                      |  Jay Pipes<EMAIL_ADDRESS>                 |
|                      |  Ionut Artarisi<EMAIL_ADDRESS>             |
|                      |  Salman Baset<EMAIL_ADDRESS>              |
|                      |  Jian Hua Geng<EMAIL_ADDRESS>              |
|                      |  Chen Zhiwei<EMAIL_ADDRESS>              |
|                      |  Mark<EMAIL_ADDRESS>           |
|                      |  Eric<EMAIL_ADDRESS>                 |
|                      |  Jan Klare<EMAIL_ADDRESS>                   |
|                      |  Christoph Albers<EMAIL_ADDRESS>           |
|                      |                                                    |
| **Copyright**        |  Copyright (c) 2013, AT&T Services, Inc.           |
|                      |  Copyright (c) 2013-2014, SUSE Linux GmbH          |
|                      |  Copyright (c) 2012, Rackspace US, Inc.            |
|                      |  Copyright (c) 2013-2014, IBM Corp.                |
|                      |  Copyright (c) 2016, cloudbau GmbH                 |

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

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

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

repository: bvera/openstack-chef

repo_name: bvera/openstack-chef


text:
---
id: 280
title: Batwoman Season 1 Episode 11 Complete Download 480p S01E11 720p
date: 2020-01-27T04:57:02+00:00
author: admin
layout: post
guid: http://4gtvseries.com/?p=3422
permalink: /2020/01/27/batwoman-season-1-episode-11-complete-download-480p-s01e11-720p/
cyberseo_rss_source:
  - http://4gtvseries.com/feed/?paged=52
cyberseo_post_link:
  - http://4gtvseries.com/batwoman-season-1-episode-11-complete-download-480p-s01e11-720p/
categories:
  - Uncategorized
tags:
  - 480p
  - mkv
  - New Episode
---

Genres: Action / Adventure / Crime
Language: English
Quality: 480p HDTV
Format: MKV
Size: 150MB
IMDB Rating: 7.0 out of 10 [23 users]

### **Download Batwoman S01E11 in 480p , Batwoman Season 1 Episode 11 27-January-2020 , **

#### SERVER 1

  1. **Batwoman S01E11 – Download 480p**

* * *

* * *

#### SERVER 2

**Batwoman Season 1 Episode 11 Complete – Download 480p & 720p**

Title :- An Un-Birthday Present

* * *

On the Kane sisters’ birthday, Kate and Alice contend with demons from the past, and an unexpected guest makes a surprise appearance in Gotham.