text:
# Xendit API Node.js Client

![Code Linting Badge](https://github.com/xendit/xendit-node/workflows/Code%20Linting/badge.svg)
![Integration Tests Badge](https://github.com/xendit/xendit-node/workflows/Integration%20Tests/badge.svg)
[![Coverage Status](https://coveralls.io/repos/github/xendit/xendit-node/badge.svg)](https://coveralls.io/github/xendit/xendit-node)

This library is the abstraction of Xendit API for access from applications written with server-side Javascript.

[![NPM](https://nodei.co/npm/xendit-node.png)](https://nodei.co/npm/xendit-node/)

**Note**: This library is only meant for usage from server-side with Xendit secret API key.
For PCI compliance to be maintained, tokenization of credit cards info should be done on client side with [Xendit.js](https://docs.xendit.co/credit-cards/integrations/tokenization).

<!-- toc -->

- [API Documentation](#api-documentation)
- [Installation](#installation)
- [Usage](#usage)
  - [Card Services](#card-services)
    - [Create charge](#create-charge)
    - [Capture charge](#capture-charge)
    - [Get charge](#get-charge)
    - [Create authorization](#create-authorization)
    - [Reverse authorization](#reverse-authorization)
    - [Create refund](#create-refund)
    - [Create promotion](#create-promotion)
  - [Virtual Account Services](#virtual-account-services)
    - [Get banks with available virtual account service](#get-banks-with-available-virtual-account-service)
    - [Create a fixed virtual account](#create-a-fixed-virtual-account)
    - [Get details of your fixed virtual account](#get-details-of-your-fixed-virtual-account)
    - [Update details of your fixed virtual account](#update-details-of-your-fixed-virtual-account)
    - [Get details of a VA payment](#get-details-of-a-va-payment)
  - [Disbursement Services](#disbursement-services)
    - [Get banks with available disbursement service](#get-banks-with-available-disbursement-service)
    - [Create a disbursement](#create-a-disbursement)
    - [Create a batch of disbursements](#create-a-batch-of-disbursements)
    - [Get a disbursement by ID](#get-a-disbursement-by-id)
  - [Invoice Services](#invoice-services)
    - [Create an invoice](#create-an-invoice)
    - [Get an invoice](#get-an-invoice)
    - [Expire an invoice](#expire-an-invoice)
    - [Get all invoices](#get-all-invoices)
  - [Recurring Payments Services](#recurring-payments-services)
    - [Create recurring payment](#create-recurring-payment)
    - [Get recurring payment](#get-recurring-payment)
    - [Edit recurring payment](#edit-recurring-payment)
    - [Stop recurring payment](#stop-recurring-payment)
    - [Pause recurring payment](#pause-recurring-payment)
    - [Resume recurring payment](#resume-recurring-payment)
  - [Recurring Services](#recurring-services)
    - [Create recurring schedule](#create-recurring-schedule)
    - [Edit recurring schedule](#edit-recurring-schedule)
    - [Get recurring schedule](#get-recurring-schedule)
    - [Create recurring plan](#create-recurring-plan)
    - [Create recurring plan with schedule](#create-recurring-plan-with-schedule)
    - [Edit recurring plan](#edit-recurring-plan)
    - [Get recurring plan](#get-recurring-plan)
    - [Deactivate recurring plan](#deactivate-recurring-plan)
    - [Edit recurring cycle](#edit-recurring-cycle)
    - [Get recurring cycle](#get-recurring-cycle)
    - [Get all recurring cycles](#get-all-recurring-cycles)
    - [Cancel recurring cycle](#cancel-recurring-cycle)
  - [Payout Services](#payout-services)
    - [Create a payout](#create-a-payout)
    - [Get a payout](#get-a-payout)
    - [Void a payout](#void-a-payout)
  - [EWallet Services](#ewallet-services)
    - [Create payment](#create-payment)
    - [Get payment](#get-payment)
    - [Create an ewallet charge](#create-an-ewallet-charge)
    - [Get an ewallet charge status](#get-an-ewallet-charge-status)
    - [Void an ewallet charge](#void-an-ewallet-charge)
    - [Initialize tokenization](#initialize-tokenization)
    - [Unlink tokenization](#unlink-tokenization)
    - [Create payment method (E-Wallet)](#create-payment-method-e-wallet)
    - [Get payment methods by customer ID (E-Wallet)](#get-payment-methods-by-customer-id-e-wallet)
  - [Balance Services](#balance-services)
    - [Get balance](#get-balance)
  - [Retail Outlet Services](#retail-outlet-services)
    - [Create fixed payment code](#create-fixed-payment-code)
    - [Get fixed payment code](#get-fixed-payment-code)
    - [Get payments by fixed payment code ID](#get-payments-by-fixed-payment-code-id)
    - [Update fixed payment code](#update-fixed-payment-code)
    - [Simulate payment for RO (only in dev mode)](#simulate-payment-for-ro-only-in-dev-mode)
  - [QR Code Services](#qr-code-services)
    - [Create code](#create-code)
    - [Get code](#get-code)
    - [Simulate payment for QR (only in dev mode)](#simulate-payment-for-qr-only-in-dev-mode)
    - [Get payments by external ID](#get-payments-by-external-id)
  - [Customer services](#customer-services)
    - [Create customer](#create-customer)
    - [Get customer](#get-customer)
    - [Get customer by reference ID](#get-customer-by-reference-id)
    - [Update customer](#update-customer)
  - [Direct debit services](#direct-debit-services)
    - [Initialize linked account tokenization](#initialize-linked-account-tokenization)
    - [Validate OTP for Linked Account Token](#validate-otp-for-linked-account-token)
    - [Retrieve accessible accounts by linked account token](#retrieve-accessible-accounts-by-linked-account-token)
    - [Create payment method (Direct Debit)](#create-payment-method-direct-debit)
    - [Get payment methods by customer ID (Direct Debit)](#get-payment-methods-by-customer-id-direct-debit)
    - [Create direct debit payment](#create-direct-debit-payment)
    - [Validate OTP for direct debit payment](#validate-otp-for-direct-debit-payment)
    - [Get direct debit payment status by ID](#get-direct-debit-payment-status-by-id)
    - [Get direct debit payment status by reference ID](#get-direct-debit-payment-status-by-reference-id)
  - [Report Service](#report-service)
    - [Generate Report](#generate-report)
    - [Get Report](#get-report)
  - [Transaction Service](#transaction-service)
    - [Get Transaction](#get-transaction)
    - [List Transactions](#list-transactions)
  - [XenPlatform Service](#xenplatform-service)
    - [Create sub-account](#create-sub-account)
    - [Create sub-account using V2](#create-sub-account-using-v2)
    - [Get sub-account by ID](#get-sub-account-by-id)
    - [Update sub-account](#update-sub-account)
    - [Set Callback URL](#set-callback-url)
    - [Create transfers](#create-transfers)
    - [Create fee rules](#create-fee-rules)
  - [Payment Request](#payment-request)
    - [Create payment request](#create-payment-request)
    - [List payment requests](#list-payment-requests)
    - [Get payment request details by ID](#get-payment-request-details-by-id)
    - [confirm payment request](#confirm-payment-request)
    - [resend auth for payment request](#resend-auth-for-payment-request)
  - [Payment Method](#payment-method)
    - [Create payment method](#create-payment-method)
    - [List payment methods](#list-payment-methods)
    - [Get payment method details by ID](#get-payment-method-details-by-id)
    - [Authorize Payment method](#authorize-payment-method)
    - [Update Payment method](#update-payment-method)
    - [Expire Payment method](#expire-payment-method)
    - [List payments by payment method id](#list-payments-by-payment-method-id)
  - [Refund Services](#refund-services)
    - [Create refund](#create-refund-1)
    - [List refunds](#list-refunds)
    - [Get refund details by ID](#get-refund-details-by-id)
- [Contributing](#contributing)

<!-- tocstop -->

## API Documentation

Please check [Xendit API Reference](https://xendit.github.io/apireference/).

## Installation

```bash
npm install --save xendit-node
```

## Usage

Configure package with your account's **secret key** obtained from your [Xendit Dashboard](https://dashboard.xendit.co/settings/developers#api-keys).

```js
const Xendit = require('xendit-node');
const x = new Xendit({
  secretKey: 'xnd_...',
});
```

Usage examples:

- With promises, please check [here](./examples/with_promises)
- With async/await, please check [here](./examples/with_async)

### Card Services

Instanitiate Card service using constructor that has been injected with Xendit keys

```js
const { Card } = x;
const cardSpecificOptions = {};
const card = new Card(cardSpecificOptions);
```

Example: Capturing a charge

```js
card
  .captureCharge({
    chargeID: 'charge-id-from-create-charge-endpoint',
    externalID: 'your-system-tracking-id',
  })
  .then(({ id }) => {
    console.log(`Charge created with ID: ${id}`);
  })
  .catch(e => {
    console.error(`Charge creation failed with message: ${e.message}`);
  });
```

Refer to [Xendit API Reference](https://developers.xendit.co/api-reference/#credit-cards) for more info about methods' parameters

#### Create charge

```ts
card.createCharge(data: {
  tokenID: string;
  externalID: string;
  amount?: number;
  authID?: string;
  cardCVN?: string;
  capture?: boolean;
  descriptor?: string;
  currency?: string;
  midLabel?: string;
  billingDetails?: object;
  promotion?: object;
  installment?: object;
  forUserID?: string;
  metadata?: object;
  isRecurring?: boolean;
})
```

#### Capture charge

```ts
card.captureCharge(data: {
  chargeID: string;
  amount: number;
  forUserID?: string;
})
```

#### Get charge

```ts
card.getCharge(data: { chargeID: string; forUserID?: string })
```

#### Create authorization

```ts
card.createAuthorization(data: {
  tokenID: string;
  externalID: string;
  amount?: number;
  authID?: string;
  cardCVN?: string;
  descriptor?: string;
  currency?: string;
  midLabel?: string;
  billingDetails?: object;
  promotion?: object;
  installment?: object;
  forUserID?: string;
})
```

#### Reverse authorization

```ts
card.reverseAuthorization(data: {
  chargeID: string;
  externalID: string;
  forUserID?: string;
})
```

#### Create refund

```ts
card.createRefund(data: {
  chargeID: string;
  amount: number;
  externalID: string;
  xIdempotencyKey?: string;
  forUserID?: string;
})
```

#### Create promotion

```ts
card.createPromotion(data: {
  referenceId: string;
  description: string;
  promoCode?: string;
  binList?: string[];
  channelCode?: string;
  discountPercent?: number;
  discountAmount?: number;
  currency: string;
  startTime: Date;
  endTime: Date;
  minOriginalAmount?: number;
  maxDiscountAmount?: number;
})
```

### Virtual Account Services

Instantiate VA service using constructor that has been injected with Xendit keys

```js
const { VirtualAcc } = x;
const vaSpecificOptions = {};
const va = new VirtualAcc(vaSpecificOptions);
```

Example: Create a fixed virtual account

```js
va.createFixedVA({
  externalID: 'your-external-id',
  bankCode: 'BCA',
  name: 'Stanley Nguyen',
})
  .then(({ id }) => {
    console.log(`Fixed VA created with ID: ${id}`);
  })
  .catch(e => {
    console.error(`VA creation failed with message: ${e.message}`);
  });
```

Refer to [Xendit API Reference](https://developers.xendit.co/api-reference/#virtual-accounts) for more info about methods' parameters

#### Get banks with available virtual account service

```ts
va.getVABanks(data?: {
  forUserID?: string;
});
```

#### Create a fixed virtual account

```ts
va.createFixedVA(data: {
  externalID: string;
  bankCode: string;
  name: string;
  virtualAccNumber?: string;
  suggestedAmt?: number;
  isClosed?: boolean;
  expectedAmt?: number;
  expirationDate?:  Date;
  isSingleUse?: boolean;
  description?: string;
  forUserID?: string;
})
```

#### Get details of a VA payment

```ts
va.getVAPayment(data: {
  paymentID: string;
  forUserID?: string;
})
```

`paymentID`: ID of the payment that you obtained from your callback

### Disbursement Services

Instanitiate Disbursement service using constructor that has been injected with Xendit keys

```js
const { Disbursement } = x;
const disbursementSpecificOptions = {};
const d = new Disbursement(disbursementSpecificOptions);
```

Example: Create a disbursement

```js
d.create({
  externalID: 'your-external-tracking-ID',
  bankCode: 'BCA',
  accountHolderName: 'Stan',
  accountNumber: '1234567890',
  description: 'Payment for nasi padang',
  amount: 10000,
})
  .then(({ id }) => {
    console.log(`Disbursement created with ID: ${id}`);
  })
  .catch(e => {
    console.error(`Disbursement creation failed with message: ${e.message}`);
  });
```

Refer to [Xendit API Reference](https://developers.xendit.co/api-reference/#disbursements) for more info about methods' parameters

#### Get banks with available disbursement service

```ts
d.getBanks();
```

#### Create a disbursement

```ts
d.create(data: {
  externalID: string;
  bankCode: string;
  accountHolderName: string;
  accountNumber: string;
  description: string;
  amount: number;
  emailTo?: string[];
  emailCC?: string[];
  emailBCC?: string[];
  xIdempotencyKey?: string;
  forUserID?: string;
  withFeeRule?: string;
})
```

#### Create a batch of disbursements

```ts
d.createBatch(data: {
  reference: string;
  disbursements: Array<{
    externalID: string;
    bankCode: string;
    accountHolderName: string;
    accountNumber: string;
    description: string;
    amount: number;
    emailTo?: string[];
    emailCC?: string[];
    emailBCC?: string[];
    forUserID?: string;
    withFeeRule?: string;
  }>;
  xIdempotencyKey?: string;
})
```

#### Get a disbursement by ID

```ts
d.getByID(data: { disbursementID: string })
```

- Get a disbursement by external ID

```ts
d.getByExtID(data: { externalID: string })
```

### Invoice Services

Instanitiate Invoice service using constructor that has been injected with Xendit keys

```js
const { Invoice } = x;
const invoiceSpecificOptions = {};
const i = new Invoice(invoiceSpecificOptions);
```

Example: Create an invoice

```js
i.createInvoice({
  externalID: 'your-external-id',
  payerEmail<EMAIL_ADDRESS>  description: 'Invoice for Shoes Purchase',
  amount: 100000,
}).then(({ id }) => {
  console.log(`Invoice created with ID: ${id}`);
});
```

Refer to [Xendit API Reference](https://developers.xendit.co/api-reference/#invoices) for more info about methods' parameters

#### Create an invoice

```ts
i.createInvoice(data: {
  externalID: string;
  payerEmail: string;
  description: string;
  amount: number;
  shouldSendEmail?: boolean;
  callbackVirtualAccountID?: string;
  invoiceDuration?: number;
  successRedirectURL?: string;
  failureRedirectURL?: string;
  paymentMethods?: string[];
  currency?: string;
  midLabel?: string;
  forUserID?: string;
})
```

#### Get an invoice

```ts
i.getInvoice(data: { invoiceID: string; forUserID?: string })
```

#### Expire an invoice

```ts
i.expireInvoice(data: {
  invoiceID: string;
  forUserID?: string;
})
```

#### Get all invoices

```ts
i.getAllInvoices(data?: {
  statuses?: string[];
  limit?: number;
  createdAfter?: Date;
  createdBefore?: Date;
  paidAfter?: Date;
  paidBefore?: Date;
  expiredAfter?: Date;
  expiredBefore?: Date;
  lastInvoiceID?: string;
  clientTypes?: string[];
  paymentChannels?: string[];
  onDemandLink?: string;
  recurringPaymentID?: string;
  forUserID?: string;
})
```

### Recurring Payments Services

Instanitiate Recurring Payments service using constructor that has been injected with Xendit keys

```js
const { RecurringPayment } = x;
const rpSpecificOptions = {};
const rp = new RecurringPayment(rpSpecificOptions);
```

Example: Create a recurring payment

```js
rp.createPayment({
  externalID: '123',
  payerEmail<EMAIL_ADDRESS>  description: 'Payment for something',
  amount: 10000,
  interval: RecurringPayment.Interval.Month,
  intervalCount: 1,
})
  .then(({ id }) => {
    console.log(`Recurring payment created with ID: ${id}`);
  })
  .catch(e => {
    console.error(
      `Recurring payment creation failed with message: ${e.message}`,
    );
  });
```

Refer to [Xendit API Reference](https://developers.xendit.co/api-reference/#recurring-payments) for more info about methods' parameters

#### Create recurring payment

```ts
rp.createPayment(data: {
  externalID: string;
  payerEmail?: string;
  description?: string;
  amount: number;
  interval: Interval;
  intervalCount: number;
  totalRecurrence?: number;
  invoiceDuration?: number;
  shouldSendEmail?: boolean;
  missedPaymentAction?: Action;
  creditCardToken?: string;
  startDate?: Date;
  successRedirectURL?: string;
  failureRedirectURL?: string;
  recharge?: boolean;
  chargeImmediately?: boolean;
  currency?: string;
  rescheduleAt?:  Interval;
  intervalCount?: number;
  shouldSendEmail?: boolean;
  invoiceDuration?: number;
  missedPaymentAction?: Action;
  rescheduleAt?: Date;
  customerId?: string;
  reminderTimeUnit?: string;
  reminderTime?: number;
  paymentMethodId?: string;
})
```

#### Stop recurring payment

```ts
rp.stopPayment(data: { id: string })
```

#### Pause recurring payment

```ts
rp.pausePayment(data: { id: string })
```

#### Resume recurring payment

```ts
rp.resumePayment(data: { id: string })
```

### Recurring Services

Instantiate Recurring service using constructor that has been injected with Xendit keys

```js
const { Recurring } = x;
const rSpecificOptions = {};
const r = new Recurring(rSpecificOptions);
```

Example: Create a recurring plan

```js
r.createPlan({
  businessId: '6066ebf68204c740b61aa3c6',
  referenceId: 'ref-123',
  customerId: 'cus-123',
  recurringAction: 'PAYMENT',
  currency: 'IDR',
  amount: 1000,
  paymentMethods: [
    { paymentMethodId: 'pm-123', rank: 1 },
  ],
  scheduleId: 'resc-123',
  immediateActionType: 'FULL_AMOUNT',
  notificationConfig: {
    recurringCreated: ['EMAIL'],
    recurringSucceeded: ['SMS'],
    recurringFailed: ['WHATSAPP']
  },
  failedCycleAction: 'RESUME'
})
  .then(({ id }) => {
    console.log(`Recurring plan created with ID: ${id}`);
  })
  .catch(e => {
    console.error(
      `Recurring plan creation failed with message: ${e.message}`,
    );
  });
```

Refer to [Xendit API Reference](https://developers.xendit.co/api-reference/#recurring-plans) for more info about methods' parameters

#### Create recurring schedule

```ts
r.createSchedule(data: {
  referenceId: string;
  businessId: string;
  interval: string;
  intervalCount: number;
  totalRecurrence?: number;
  anchorDate?: string;
  retryInterval?: string;
  retryIntervalCount?: number;
  totalRetry?: number;
  failedAttemptNotifications?: number[];
});
```

#### Edit recurring schedule

```ts
r.editSchedule(data: {
  id: string;
  businessId: string;
  interval: string;
  intervalCount: number;
  totalRecurrence?: number;
  anchorDate?: string;
  retryInterval?: string;
  updateScheduledCycle?: boolean;
  retryIntervalCount?: number;
  totalRetry?: number;
  failedAttemptNotifications?: number[];
});
```

#### Get recurring schedule

```ts
r.getSchedule(data: {
  id: string;
  businessId: string;
});
```

#### Create recurring plan

```ts
r.createPlan(data: {
  businessId: string;
  referenceId: string;
  customerId: string;
  recurringAction: RecurringAction;
  currency: Currency;
  amount: number;
  paymentMethods?: Array<PaymentMethodIdRanked>;
  scheduleId: string;
  immediateActionType?: ImmediateActionType | null;
  notificationConfig?: NotificationConfig | null;
  failedCycleAction?: FailingCycleAction;
  metadata?: object | null;
})
```

#### Create recurring plan with schedule

```ts
r.createPlan(data: {
  businessId: string;
  referenceId: string;
  customerId: string;
  recurringAction: RecurringAction;
  currency: Currency;
  amount: number;
  paymentMethods?: Array<PaymentMethodIdRanked>;
  schedule: RecurringSchedule;
  immediateActionType?: ImmediateActionType | null;
  notificationConfig?: NotificationConfig | null;
  failedCycleAction?: FailingCycleAction;
  metadata?: object | null;
})
```

#### Edit recurring plan

```ts
r.editPlan(data: {
  businessId: string;
  customerId?: string;
  currency?: Currency;
  amount?: number;
  paymentMethods?: Array<PaymentMethodIdRanked>;
  notificationConfig?:  CycleDashboardSearchType;
  searchValue?: string;
})
```

#### Cancel recurring cycle

```ts
r.cancelCycle(data: {
  id: string;
  planId: string;
  businessId: string;
})
```

### Payout Services

Instantiate Payout service using constructor that has been injected with Xendit keys

```js
const { Payout } = x;
const payoutSpecificOptions = {};
const p = new Payout(payoutSpecificOptions);
```

Example: Create a payout

```js
p.createPayout({
  externalID: 'your-external-id',
  amount: 100000,
  email<EMAIL_ADDRESS>}).then(({ id }) => {
  console.log(`Invoice created with ID: ${id}`);
});
```

Refer to [Xendit API Reference](https://developers.xendit.co/api-reference/#payouts) for more info about methods' parameters

#### Create a payout

```ts
p.createPayout(data: {
  externalID: string;
  amount: string;
  email: string;
})
```

#### Get a payout

```ts
p.getPayout(data: { id: string })
```

#### Void a payout

```ts
p.voidPayout(data: { id: string })
```

### EWallet Services

Instanitiate EWallet service using constructor that has been injected with Xendit keys

```js
const { EWallet } = x;
const ewalletSpecificOptions = {};
const ew = new EWallet(ewalletSpecificOptions);
```

Example: Create an ewallet charge

```js
ew.createEWalletCharge({
  referenceID: 'test-reference-id',
  currency: 'IDR',
  amount: 50000,
  checkoutMethod: 'ONE_TIME_PAYMENT',
  channelCode: 'ID_OVO',
  channelProperties: {
    mobileNumber: '+6281234567890',
  },
}).then(r => {
  console.log('created ewallet payment charge:', r);
  return r;
});
```

Refer to [Xendit API Reference](https://developers.xendit.co/api-reference/#ewallets) for more info about methods' parameters

#### Create payment

```ts
ew.createPayment(data: {
  externalID: string;
  amount: number;
  phone?: string;
  expirationDate?: Date;
  callbackURL?: string;
  redirectURL?: string;
  items?:  ChannelCode;
  channelProperties?: ChannelProps;
  paymentMethodId?: string;
  customerID?: string;
  basket?:  OnlineBankingAccessProperties;
  metadata?: object;
})
```

#### Unlink tokenization

```ts
ew.unlinkTokenization(data: {
  linkedAccTokenID: string;
})
```

#### Create payment method (E-Wallet)

```ts
ew.createPaymentMethod(data: {
  customerID: string;
  type: PaymentMethodType;
  properties: PaymentMethodProperties;
  metadata?: object;
})
```

#### Get payment methods by customer ID (E-Wallet)

```ts
ew.getPaymentMethodsByCustomerID(data: {
    customerID: string;
})
```

### Balance Services

Instanitiate Balance service using constructor that has been injected with Xendit keys

```js
const { Balance } = x;
const balanceSpecificOptions = {};
const i = new Balance(balanceSpecificOptions);
```

Example: Get balance of holding account

```js
b.getBalance({
  accountType: Balance.AccountType.Holding,
}).then(({ balance }) => {
  console.log('Holding balance amount:', balance);
});
```

Refer to [Xendit API Reference](https://developers.xendit.co/api-reference/#balances) for more info about methods' parameters

#### Get balance

```ts
b.getBalance(data: {
  accountType: AccountType;
  forUserID?: string;
})
```

### Retail Outlet Services

Instanitiate Retail outlet service using constructor that has been injected with Xendit keys

```js
const { RetailOutlet } = x;
const retailOutletSpecificOptions = {};
const ro = new RetailOutlet(retailOutletSpecificOptions);
```

Example: Example: Create a fixed payment code

```js
ro.createFixedPaymentCode({
  externalID: '123',
  retailOutletName: 'ALFAMART',
  name: 'Ervan Adetya',
  expectedAmt: 10000,
}).then(({ id }) => {
  console.log(`Fixed Payment Code created with ID: ${id}`);
});
```

Refer to [Xendit API Reference](https://developers.xendit.co/api-reference/#retail-outlets) for more info about methods' parameters

#### Create fixed payment code

```ts
ro.createFixedPaymentCode(data: {
  externalID: string;
  retailOutletName: string;
  name: string;
  expectedAmt: number;
  paymentCode?: string;
  expirationDate?: Date;
  isSingleUse?: boolean;
})
```

#### Get fixed payment code

```ts
ro.getFixedPaymentCode(data: { id: string })
```

#### Get payments by fixed payment code ID

```ts
ro.getPaymentsByFixedPaymentCodeId(data: { id: string })
```

#### Update fixed payment code

```ts
ro.updateFixedPaymentCode(data: {
  id: string
  name?: string;
  expectedAmt?: number;
  expirationDate?: Date;
})
```

#### Simulate payment for RO (only in dev mode)

```ts
ro.simulatePayment(data: {
  retailOutletName: string;
  paymentCode: string;
  transferAmount: number;
})
```

### QR Code Services

Instanitiate QR Code service using constructor that has been injected with Xendit keys

```js
const { QrCode } = x;
const qrcodeSpecificOptions = {};
const q = new QrCode(qrcodeSpecificOptions);
```

Example: create a QR code

```js
q.createCode({
  externalID: 'your-system-tracking-id',
  amount: 10000,
  type: QrCode.Type.Dynamic,
  callback_url: 'https://yourwebsite/callback',
})
  .then(({ id }) => {
    console.log(`QR code created with ID: ${id}`);
  })
  .catch(e => {
    console.error(`QR code creation failed with message: ${e.message}`);
  });
```

Refer to [Xendit API Reference](https://developers.xendit.co/api-reference/#qr-codes) for more info about methods' parameters

#### Create code

```ts
q.createCode(data: {
  externalID: string;
  type: QrCodeTypes;
  callbackURL: string;
  amount?: number;
});
```

#### Get code

```ts
q.getCode(data: { externalID: string });
```

#### Simulate payment for QR (only in dev mode)

```ts
q.simulate(data: { externalID: string; amount?: number });
```

#### Get payments by external ID

```ts
q.getPayments(data: {
  externalID: string;
  from?: string;
  to?: string;
  limit?: number;
});
```

### Customer services

Instanitiate customer service using constructor that has been injected with Xendit keys

```js
const { Customer } = x;
const customerSpecificOptions = {};
const c = new Customer(customerSpecificOptions);
```

Example: create a customer

```js
c.createCustomer({
  referenceID: 'ref-id-example-1',
  givenNames: 'customer 1',
  email<EMAIL_ADDRESS>  mobileNumber: '+6281212345678',
  description: 'dummy customer',
  middleName: 'middle',
  surname: 'surname',
  addresses: [],
})
  .then(({ id }) => {
    console.log(`Customer created with ID: ${id}`);
  })
  .catch(e => {
    console.error(`Customer creation failed with message: ${e.message}`);
  });
```

Refer to [Xendit API Reference](https://developers.xendit.co/api-reference/#customers) for more info about methods' parameters

#### Create customer

```ts
c.createCustomer(data: {
  referenceID: string;
  mobileNumber?: string;
  email?: string;
  givenNames: string;
  middleName?: string;
  surname?: string;
  description?: string;
  phoneNumber?: string;
  nationality?: string;
  addresses?: Address[];
  dateOfBirth?: string;
  metadata?: object;
});
```

#### Get customer

```ts
c.getCustomer(data: { id: string });
```

#### Get customer by reference ID

```ts
c.getCustomerByReferenceID(data: { referenceID: string });
```

#### Update customer

```ts
c.updateCustomer(data: {
  id: string;
  referenceID?: string;
  givenNames?: string;
  mobileNumber?: string;
  addresses?: Address[];
  description?: string;
  middleName?: string;
  surname?: string;
  phoneNumber?: string;
  nationality?: string;
  dateOfBirth?: string;
  metadata?: object;
  })
```

### Direct debit services

Instanitiate direct debit service using constructor that has been injected with Xendit keys

```js
const { DirectDebit } = x;
const directDebitSpecificOptions = {};
const dd = new DirectDebit(directDebitSpecificOptions);
```

Example: create a direct debit payment

```js
dd.createDirectDebitPayment({
  idempotencyKey: '7960e3fd-9a1d-469d-8b3e-2f88df139c50',
  referenceID: 'merchant-ref-id-ex-1',
  paymentMethodID: 'pm-8c09656d-09fe-4bdd-bd8d-87495a71d231',
  currency: 'IDR',
  amount: 15000,
  callbackURL: 'https://payment-callback-listener/',
  enableOTP: true,
})
  .then(({ id }) => {
    console.log(`Direct debit payment created with ID: ${id}`);
  })
  .catch(e => {
    console.error(`Direct debit creation failed with message: ${e.message}`);
  });
```

Refer to [Xendit API Reference](https://developers.xendit.co/api-reference/#direct-debit) for more info about methods' parameters

#### Initialize linked account tokenization

```ts
dd.initializeTokenization(data: {
  customerID: string;
  channelCode: ChannelCode;
  properties?: DebitCardProperties | OnlineBankingAccessProperties;
  device?: object;
  metadata?: object;
});
```

#### Validate OTP for Linked Account Token

```ts
dd.validateOTPforLinkedAccount(data: {
  tokenID: string;
  otpCode: string;
});
```

#### Retrieve accessible accounts by linked account token

```ts
dd.retrieveAccountsByTokenID(data: {
  tokenID: string;
});
```

#### Create payment method (Direct Debit)

```ts
dd.createPaymentMethod(data: {
  customerID: string;
  type: PaymentMethodType;
  properties: PaymentMethodProperties;
  metadata?: object;
});
```

#### Get payment methods by customer ID (Direct Debit)

```ts
dd.getPaymentMethodsByCustomerID(data: {
  customerID: string;
});
```

#### Create direct debit payment

```ts
dd.createDirectDebitPayment(data: {
  idempotencyKey: string;
  apiVersion?: string;
  referenceID: string;
  paymentMethodID: string;
  currency: string;
  amount: number;
  callbackURL: string;
  enableOTP?: boolean;
  description?: string;
  basket?: Basket[];
  device?: object;
  metadata?: object;
  successRedirectUrl?: string;
  failureRedirectUrl?: string;
});
```

#### Validate OTP for direct debit payment

```ts
dd.validateOTPforPayment(data: {
  directDebitID: string;
  otpCode: string;
  apiVersion?: string;
})
```

#### Get direct debit payment status by ID

```ts
dd.getDirectDebitPaymentStatusByID(data: {
  directDebitID: string;
});
```

#### Get direct debit payment status by reference ID

```ts
dd.getDirectDebitPaymentStatusByReferenceID(data: {
  referenceID: string;
```

### Report Service

Instantiate the Report service using a constructor which has been injected with Xendit keys.

```js
const { Report } = x;
const reportSpecificOptions = {};
const r = new Report(reportSpecificOptions);
```

Example: Generating a report

```js
r.generateReport({
  type: 'BALANCE_HISTORY',
  filterDateFrom: new Date(new Date().getTime() - 24 * 60 * 60 * 1000), // Yesterday's Date
  filterDateTo: new Date(),
  format: 'CSV',
  currency: 'IDR',
})
  .then(res => {
    console.log('Generated report:', res);
  })
  .catch(e => {
    console.error(`Generate Report Failed with Error: ${e.message}`);
  });
```

#### Generate Report

```ts
r.generateReport(data: {
  type: reportTypes;
  filterDateFrom?: Date;
  filterDateTo?: Date;
  format?: formatTypes;
  currency?: currencyTypes;
})
```

#### Get Report

```ts
r.getReport(data: {
  id: string
})
```

### Transaction Service

Instantiate the Transaction service using a constructor which has been injected with Xendit keys.

```js
const { Transaction } = x;
const transactionSpecificOptions = {};
const t = new Transaction(transactionSpecificOptions);
```

Example: Getting a transaction

```js
t.getTransaction({
  id: 'txn_123',
})
  .then(res => {
    console.log('Get Transaction:', res);
  })
  .catch(e => {
    console.error(`Get Transaction Failed with Error: ${e.message}`);
  });
```

#### Get Transaction

```ts
t.getTransaction(data: {
  id: string;
})
```

#### List Transactions

```ts
t.listTransactions(data: {
  types?: Array<string>;
  statuses?: Array<string>;
  channelCategories?: Array<string>;
  referenceId?: string;
  productId?: string;
  accountIdentifier?: string;
  currency?: string;
  amount?: number;
  limit?: number;
  afterId?: string;
  beforeId?: string;
  createdDateFrom?: Date;
  createdDateTo?: Date;
  updatedDateFrom?: Date;
  updatedDateTo?: Date;
})
```

### XenPlatform Service

Instanitiate Platform service using constructor that has been injected with Xendit keys

```js
const { Platform } = x;
const platformSpecificOptions = {};
const p = new Platform(platformSpecificOptions);
```

Example: Creating a sub-account

```js
p.createAccount({
  accountEmail<EMAIL_ADDRESS>  type: 'MANAGED',
})
  .then(({ user_id }) => {
    console.log(`Account created with ID: ${user_id}`);
  })
  .catch(e => {
    console.error(`Account creation failed with message: ${e.message}`);
  });
```

Refer to [Xendit API Reference](https://developers.xendit.co/api-reference/#xenplatform) for more info about methods' parameters

#### Create sub-account

```ts
p.createAccount(data: {
  accountEmail: string;
  type: AccountTypes;
  businessProfile?: {
    businessName: string;
  };
})
```

#### Create sub-account using V2

```ts
p.createV2Account(data: {
  email: string;
  type: string;
  publicProfile?: {
    businessName: string;
  };
})
```

#### Get sub-account by ID

```ts
p.getAccountByID(data: {
  id: string;
})
```

#### Update sub-account

```ts
p.updateAccount(data: {
  id: string;
  email: string;
  publicProfile?: {
    businessName: string;
  };
})
```

#### Set Callback URL

```ts
p.setCallbackURL(data: {
  type: string;
  url: string;
  forUserID?: string;
})
```

#### Create transfers

```ts
p.createTransfer(data: {
  reference: string;
  amount: number;
  sourceUserID: string;
  destinationUserID: string;
})
```

#### Create fee rules

```ts
p.createFeeRule(data: {
  name: string;
  description?: string;
  routes: Array<{
    unit: string;
    amount: number;
    currency: string;
  }>;
})

```
### Payment Request

Instanitiate Payment Request using constructor that has been injected with Xendit keys

```js
const { PaymentRequest } = x;
const r = new PaymentRequest();
```

Example: Create a Payment Request

```js

r.createPaymentRequest({
      amount: 1500,
      currency: 'PHP',
      payment_method: {
        type: 'EWALLET',
        ewallet: {
          channel_code: 'GRABPAY',
          channel_properties: {
            success_return_url: 'https://redirect.me/goodstuff',
            failure_return_url: 'https://redirect.me/badstuff',
          },
        },
        reusability: 'ONE_TIME_USE',
      }
}).then(({ id }) => {
  console.log(`payment request created with ID: ${id}`);
});
```

Refer to [Xendit API Reference](https://developers.xendit.co/api-reference/#payment-requests) for more info about methods' parameters

#### Create payment request

```ts
r.createPaymentRequest(data: {
    currency: PaymentRequestCurrencies;
    amount: number;
    reference_id?: string;
    customer_id?: string;
    country: PaymentRequestCountries;
    description?: string;
    payment_method: object;
    channel_properties?: PaymentRequestChannelProperties;
    metadata?: object;
    payment_method_id?: string;
    shipping_information?: object;
    initiator?: PaymentRequestInitiator;
    capture_method?: PaymentRequestCaptureMethod;
    idempotency_key?: string;
    for_user_id?: string;
})
```

#### List payment requests

```ts
r.listpaymentrequests(data: {
    id?: string;
    reference_id?: string;
    customer_id?: string;
    type?: PaymentRequestType;
    channel_code?: string;
    status?: PaymentRequestStatuses;
    limit?: number;
    after_id?: string;
    before_id?: string;
    for_user_id?: string;
})
```

#### Get payment request details by ID

```ts
r.getPaymentRequestByID(data: {
    id: string;
    for_user_id?: string;
})
```

#### confirm payment request

```ts
r.confirmPaymentRequest(data: {
    id: string;
    auth_code: string;
    idempotency_key?: string;
    for_user_id?: string;
})
```

#### resend auth for payment request

```ts
r.resendAuthForPaymentRequest(data: {
    id: string;
    idempotency_key?: string;
    for_user_id?: string;
})
```

### Payment Method

Instanitiate Payment Method using constructor that has been injected with Xendit keys

```js
const { PaymentMethod } = x;
const r = new PaymentMethod();
```

Example: Create a Payment Method

```js
r.createPaymentMethod({
      type: 'DIRECT_DEBIT',
      reusability: 'ONE_TIME_USE',
      customer_id: '16f72571-9b3a-43dc-b241-5b71f470202f',
      country: 'ID',
      direct_debit: {
        channel_code: 'BRI',
        channel_properties: {
          mobile_number: '+6281299640904',
          card_last_four: '8888',
          card_expiry: '10/29',
          email<EMAIL_ADDRESS>        },
      },
}).then(({ id }) => {
  console.log(`payment method created with ID: ${id}`);
});
```

Refer to [Xendit API Reference](https://developers.xendit.co/api-reference/#payment-methods) for more info about methods' parameters

#### Create payment method

```ts
r.createPaymentMethodV2(data: {
  type: PaymentMethodV2Types;
  reusability: PaymentMethodV2Reusabilities;
  reference_id?: string;
  customer_id?: string;
  country?: CreatePaymentMethodV2Countries;
  description?: string;
  billing_information?: BillingInformationItems;
  metadata?: object;
  ewallet?: EwalletItems;
  direct_debit?: DirectDebitItems;
  card?: CardItems;
  over_the_counter?: OverTheCounterItems;
  virtual_account?: VirtualAccountItems;
  qr_code?: QRISItems;
  for_user_id?: string;
  idempotency_key?: string;
})
```

#### List payment methods

```ts
r.listPaymentMethodV2(data: {
  payment_method_id?: string;
  payment_method_type?: string;
  channel_code?: string;
  limit?: number;
  after_id?: string;
  before_id?: string;
  for_user_id?: string;
})
```

#### Get payment method details by ID

```ts
r.getPaymentMethodByIdV2(data: {
    id: string;
    for_user_id?: string;
})
```

#### Authorize Payment method

```ts
r.authorizePaymentMethodV2(data: {
    id: string;
    auth_code: string;
    for_user_id?: string;
    idempotency_key?: string;
})
```

#### Update Payment method

```ts
r.updatePaymentMethodV2(data: {
    id: string;
    reference_id?: string;
    description?: string;
    metadata?: object;
    status?: string;
    reusability?: PaymentMethodV2Reusabilities;
    over_the_counter?: UpdateOverTheCounterItems;
    virtual_account?: UpdateVirtualAccountItems;
    for_user_id?: string;
})
```

#### Expire Payment method

```ts
r.expirePaymentMethodV2(data: {
    id: string;
    for_user_id?: string;
    idempotency_key?: string;
})
```

#### List payments by payment method id

```ts
r.listPaymentsByPaymentMethodIdV2(data: {
    id: string;
    payment_request_id?: string;
    reference_id?: string;
    status?: ListPaymentMethodV2StatusItems;
    limit?: number;
    after_id?: string;
    before_id?: string;
    created?: string;
    updated?: string;
    for_user_id?: string;
})
```

### Refund Services

Instanitiate Refund service using constructor that has been injected with Xendit keys

```js
const { Refund } = x;
const r = new Refund();
```

Example: Create a refund

```js
r.createRefund({
      invoice_id: 'your-invoice-id',
      reason: 'FRAUDULENT',
      amount: 1000,
}).then(({ id }) => {
  console.log(`refund created with ID: ${id}`);
});
```

Refer to [Xendit API Reference](https://developers.xendit.co/api-reference/#refunds) for more info about methods' parameters

#### Create refund

```ts
r.createRefund(data: {
  payment_request_id?: string;
  reference_id?: string;
  invoice_id?: string;
  currency?: string;
  amount?: number;
  reason: RefundReasons;
  metadata?: object;
  idempotency_key?: string;
  for_user_id?: string;
})
```

#### List refunds

```ts
r.listRefunds(data: {
  payment_request_id?: string;
  invoice_id?: string;
  payment_method_type?: string;
  channel_code?: string;
  limit?: number;
  after_id?: string;
  before_id?: string;
  for_user_id?: string;
})
```

#### Get refund details by ID

```ts
r.getRefundById(data: {
  id: string;
})
```

## Contributing

Running test suite

```bash
npm install
npm run test
```

Running examples

```bash
cp .env.sample .env # then fill in required environment variables
node examples/card.js # or whichever example you would like to run
```

There are a commit hook to run linting and formatting and push hook to run all tests.
Please make sure they pass before making commits/pushes.

For any requests, bug or comments, please [open an issue](https://github.com/xendit/xendit-node/issues) or [submit a pull request](https://github.com/xendit/xendit-node/pulls).

repository: xendit/xendit-node

repo_name: xendit/xendit-node


text:
# Change Log

## [0.1.1](https://github.com/sue445/goprecure/tree/0.1.1) (2015-12-07)
[Full Changelog](https://github.com/sue445/goprecure/compare/0.1.0...0.1.1)

**Merged pull requests:**

- Add go vet [\#4](https://github.com/sue445/goprecure/pull/4) ([sue445](https://github.com/sue445))
- fix typo [\#3](https://github.com/sue445/goprecure/pull/3) ([sue445](https://github.com/sue445))

## [0.1.0](https://github.com/sue445/goprecure/tree/0.1.0) (2015-12-06)
**Merged pull requests:**

- Setup coveralls [\#2](https://github.com/sue445/goprecure/pull/2) ([sue445](https://github.com/sue445))
- Setup travis [\#1](https://github.com/sue445/goprecure/pull/1) ([sue445](https://github.com/sue445))

\* *This Change Log was automatically generated by [github_changelog_generator](https://github.com/skywinder/Github-Changelog-Generator)*

license: MIT

branch_name: refs/heads/master

extension: md

gha_language: Go

license_type: permissive


text:
# BackUp DataBase SQL Dump

Backup database dump with Git control

- [x] Create folder for backup when not exists
- [x] Make ```git init```
- [x] Create SQL dump
- [x] Create commit with understandable comment
- [ ] Push to remote server(s)
- [x] Write log file
- [x] Test on server

repository: BrunIF/backup-db-git

repo_name: BrunIF/backup-db-git


text:
# Changelog

## [1.0.7](https://github.com/onimur/handle-path-oz/tree/1.0.7) (29-07-20)

[Full Changelog](https://github.com/onimur/handle-path-oz/compare/1.0.6...1.0.7)

**Implemented enhancements:**

- Single file Uri without list [\#1](https://github.com/onimur/handle-path-oz/issues/1)
- Close \#1 Single uri [\#2](https://github.com/onimur/handle-path-oz/pull/2) ([onimur](https://github.com/onimur))

**Merged pull requests:**

- Developer - changes from sdcard [\#3](https://github.com/onimur/handle-path-oz/pull/3) ([onimur](https://github.com/onimur))

## [1.0.6](https://github.com/onimur/handle-path-oz/tree/1.0.6) (30-06-20)

[Full Changelog](https://github.com/onimur/handle-path-oz/compare/1.0.4...1.0.6)

## [1.0.4](https://github.com/onimur/handle-path-oz/tree/1.0.4) (30-06-20)

[Full Changelog](https://github.com/onimur/handle-path-oz/compare/1.0.3...1.0.4)

## [1.0.3](https://github.com/onimur/handle-path-oz/tree/1.0.3) (23-06-20)

[Full Changelog](https://github.com/onimur/handle-path-oz/compare/1.0.2...1.0.3)

## [1.0.2](https://github.com/onimur/handle-path-oz/tree/1.0.2) (23-06-20)

[Full Changelog](https://github.com/onimur/handle-path-oz/compare/1.0.1...1.0.2)

## [1.0.1](https://github.com/onimur/handle-path-oz/tree/1.0.1) (22-06-20)

[Full Changelog](https://github.com/onimur/handle-path-oz/compare/75101f51a2d66e31a7f76f82e5c7891c4ac6c0b3...1.0.1)

\* *This Changelog was automatically generated by [circleci Github Changelog Generator](https://github.com/onimur/circleci-github-changelog-generator) Orb*

repository: lingarajsankaravelu/handle-path-oz

repo_name: lingarajsankaravelu/handle-path-oz


text:
## 0.13.7
 * Widen dependency constraint on `package:http`.

## 0.13.6

* Require Dart 2.19.
* Setup `dbService` to do retries for failed requests.

## 0.13.5

* Added topics to `pubspec.yaml`.

## 0.13.4

* Implement `onConnectionStateChanged` to sync `grpc: 3.1.0`

## 0.13.3

* Populate the pubspec `repository` field.
* Update the readme to add experimental verbiage.

## 0.13.2
 * Gracefully handle cases where logging fails.

## 0.13.1
 * Fix dependency on `package:gcloud` to version `0.8.0`.

## 0.13.0
**WARNING**: Version `0.13.0` is broken, use `0.13.1`.

 * Migrated to _null-safety_ and `package:gcloud` version `0.8.0`.

## 0.12.1
 * Setup default `authClient` in `package:gcloud`, fixing regression from
   introduction of _Application Default Credentials_ in `0.12.0`.

## 0.12.0
 * **Breaking**, now using the environment variable `GOOGLE_CLOUD_PROJECT`
    instead of `GCLOUD_PROJECT` for project name.
 * **Breaking**, now using
   [Application Default Credentials](https://cloud.google.com/docs/authentication/production)
   instead of using the environment variable `GCLOUD_KEY`.
   This allows authentication by specifying an _exported service account key_
   in `GOOGLE_APPLICATION_CREDENTIALS`, or running
   `gcloud auth application-default login` on your local machine.

## 0.11.0

 * Upgrade `gcloud` to `0.7.0` with breaking changes in datastore keys.

## 0.10.5

 * Handle duplicate `user-agent` headers.

## 0.10.4

 * Added `Logging.reportError` to the `logging interface, for reporting errors
   to [Stackdriver Error Reporting](https://cloud.google.com/error-reporting/)
   when running in AppEngine.
 * Report errors logged through the `package:logging` adapter to
   `Logging.reportError` (for reporting to Stackdriver Error Reporting).
 * Updated protobuf source files.
 * Reduced number of unnecessarily generated protos.

## 0.10.3

 * Update Protobuf to v1.0.0
 * Add client library identification header
 * Fix `grpc/datastore` tests

## 0.10.2

 * Update gRPC version dependency

## 0.10.1

 * Update gRPC API protos

## 0.10.0

 * Revert `0.9.0`

## 0.9.0

 * Instantiate new `DatastoreDB` instances for each request.

## 0.8.1

 * Detect dev mode when running behind a proxy.

## 0.8.0

 * Add `applicationContext` getter to `ClientContext`

## 0.7.3

 * Add `onAcceptingConnections` callback to `runAppEngine()`

## 0.7.2

 * Update the generated protobufs.

## 0.7.1

 * Update to use `package:grpc` version 2.0

## 0.7.0

 * Refactored to use `package:grpc` to talk to Logging and Datastore backends.

## 0.6.1

 * Added `isCronJonRequest` as a helper method for determining if a request
   originates from the AppEngine cronjob scheduler.

## 0.6.0

**Breaking changes:**
 * Removed poorly documented assets support with broken tests.
 * Removed memcache as the service was never made it past alpha.

Users of memcache should consider using
[Cloud Memorystore](https://cloud.google.com/memorystore/) instead. This comes
with a redis interface for which there are multiple packages available on pub.
Serving assets is just a matter of sending a file from disk. This is easy to do
without the logic that this package used to contain.

## 0.5.1+1

* Support latest `pkg:http` and `pkg:http2`.

## 0.5.1

* Correct root path for serving assets.

## 0.5.0

* Support for Dart 2.0 constants and updated gcloud.

## 0.4.4+2

* Fix race condition in gRPC client between `http2Connection.isOpen` and
  `http2Connection.makeRequest`.

## 0.4.4+1

* Delay http/2 connection dialer by 20 ms to give client enough time to receive
  server settings.

## 0.4.4

* Improve output logging when memcache connections fail.
* Fix Dart 2 runtime issues.

## 0.4.3+1

* When logging requests, the `appengine.googleapis.com/trace_id` label
  is populated.

## 0.4.3

* When logging, the following `protoPayload` values are now populated:
  * `instanceId`
  * `referrer`
  * `traceId` via the `X-Cloud-Trace-Context` request header.

* The `appengine.googleapis.com/instance_name` label is also populated for
  all log entries.

* `traceId` was also added to the `ClientContext` class.

## 0.4.2

* Add support for connecting to memcache instance defined by environment
  variables `GAE_MEMCACHE_HOST` and `GAE_MEMCACHE_PORT`.

## 0.4.1

* Add `shared` option to `runAppEngine` to enable multi-threaded operation
  with isolates.

## 0.4.0+3

* Fix an issue where models with un-indexed list properties could not be
  committed.

## 0.4.0+2

* Be less verbose in request logs printed during local development

## 0.4.0

Switch from Managed VMs to Flexible environment:

* Removed `UsersService` api.
* Removed `ModulesService` api.
* Removed `RemoteApi` api (was already deprecated).
* Introduce new GCLOUD\_PROJECT and GCLOUD\_KEY environment variables.
* Remove STORAGE\_SERVICE\_ACCOUNT\_FILE environment variable.
* To prevent duplicate logging of errors, `runAppEngine` will no longer log
  request-specific errors on stdout if they got already logged via the
  request-specific log.

## 0.3.3+1

* Support `gcloud` package version `0.3.0`.

## 0.3.3

* Work around dev\_appserver.py issue (it doesn't drain stdout we therefore avoid
  printing anything).

## 0.3.2

* Require `protobuf` package `^0.5.0`
* Support the lastest release of `fixnum` package.

## 0.3.1+1

* Improved output of `Logger.root` with `useLoggingPackageAdaptor`.

## 0.3.1

* Added optional `port` argument to `runAppEngine`.
* Removed the call to `/bin/hostname`.

## 0.3.0+1

* Widen dependency constraint on `package:logging`.

## 0.3.0

* Pass the memcache expiration time to the memcache service. Before the
  expiration argument to Memcache.set and Memcache.setAll was ignored.

* Removed the expiration argument to Memcache.clear. It is not supported by
  the App Engine memcache API.

## 0.2.6+3

* Update dependencies to allow gcloud 0.2.0 with Cloud Pub/Sub support.

## 0.2.6+2

* Do not close `authClient`, since `registerStorageService` does it
  automatically.

## 0.2.6+1

* Correctly handling `x-appengine-https` header.
* Turn logging of for Level.OFF

## 0.2.6

* Added adaptor for `package:logging` via `useLoggingPackageAdaptor()`.
* Added workaround for incorrect `requestedUri` comming from 'dart:io'.

## 0.2.5

* Added withAppEngineServices() function which allows running arbitrary code
  using AppEngine services via a service scope.

## 0.2.4+1

* Change the service scope keys keys to non-private symbols.

## 0.2.4

* Run request handlers inside a service scope
(see `package:gcloud/service_scope.dart`).
* Insert an authenticated HTTP client into the service scope.
* Insert a `memcacheService` into the service scope.
* Added `isDevelopmentServer` and `isProductionEnvironment` getter to client
context.
* Make hostnames returned from modules service use -dot- naming to support
HTTPS.
* Mark `package:appengine/remote_api.dart` as deprecated.

## 0.2.3

* Small bugfix in the lowlevel memcache API implementation.

## 0.2.2

* Updated `README.md`
* Widen googleapis_auth constraint to include version 0.2.0

## 0.2.1

* Small bugfix in storage API implementation
* respect DART_PUB_SERVE url only in developer mode
* sync db/datastore tests to the ones used in gcloud

## 0.2.0

* Use datastore/db APIs from package:gcloud
    * simplified annotation system
    * paging-based query API
* Added module service
* Some bugfixes

## 0.1.0

* Alpha release

repository: dart-lang/appengine

gha_language: Dart

repo_name: dart-lang/appengine


text:
# Collective to Collective donations

If you have a Collective with funds in its balance, you may use that as a payment method when contributing to another Collective within the same [Fiscal Host](https://github.com/opencollective/documentation/tree/7991781321e21c71705dddaf37775eeb78dbe972/financial-contributors/hosts/README.md). There are no fees for this method of donating.

We are working on the functionality to enable Collectives to give directly to Collective in a different host. As a workaround for now, the Collective you want to give to can submit an expense for your donation.

To donate using your Collective balance, simply make a contribution and select it as your payment method during checkout.

gha_license_id: MIT


text:
---
layout: data
title: Number of bonds by year
"chart-title": Number of city issued bonds by year
category: "Financing-and-Development"
data: "financing-and-development/bonds_by_year.csv"
type: bar
"axisType": ""
column: Year
published: true
source: "Mayor's Office of Housing and Community Development."
"policy-link": "http://jasonlally.com/housing-policy-hub/policies/inclusionary-housing/"
scale: "5"
colors: YlGn
yLabel: Bonds
xLabel: Year
---

The chart below shows the number of bonds the city has issued by year. The money raised by the bonds is used to provide loans to developers of affordable housing.

repository: DataSF/housing-data-hub

branch_name: refs/heads/gh-pages

gha_language: HTML

repo_name: DataSF/housing-data-hub


text:
# Sentry Process

[![LICENSE](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
[![pipeline status](https://gitlab.com/dsferruzza/sentry-process/badges/master/pipeline.svg)](https://gitlab.com/dsferruzza/sentry-process/commits/master)
[![Crates.io Version](https://img.shields.io/crates/v/sentry-process.svg)](https://crates.io/crates/sentry-process)
[![Minimum rustc version](https://img.shields.io/badge/rustc-1.54+-lightgray.svg)](#rust-version-requirements)
[![Get help on Codementor](https://cdn.codementor.io/badges/get_help_github.svg)](https://www.codementor.io/dsferruzza?utm_source=github&utm_medium=button&utm_term=dsferruzza&utm_campaign=github)

Report failed processes/scripts to Sentry.

⚠ _Main repository is here: https://gitlab.com/dsferruzza/sentry-process_ ⚠

## Motivation

[Sentry](https://sentry.io) is a cool system that helps developers to aggregate, monitor and fix errors/exceptions in their own apps. It has integrations for many technologies so that reported errors can contain relevant informations.

But sometimes it can be desirable to plug Sentry to an arbitrary process. Such process can be a binary that was built without Sentry support, or a Bash script that runs every night on a server, for example.

With **Sentry Process** it is now easy to launch a process that will send an event to a Sentry instance whenever it fails!

## How to use

- compile or install the project
- set the `SENTRY_DSN` environment variable (use the URL given in `Your project > Settings > Client Keys (DSN)` in Sentry)
- run `sentry-process COMMAND [ARGUMENTS]...` _(wrap your process call like you would do with `sudo`)_

If running `COMMAND [ARGUMENTS]...` results in an exit code that is not `0`, Sentry Process considers it as a failure and reports. For example, `sentry-process false` will report whereas `sentry-process true` will not.

The exit code, standard output and standard error of `COMMAND [ARGUMENTS]...` are re-emmited by `sentry-process COMMAND [ARGUMENTS]...`, so that it can be piped or used by other programs. In fact, standard output and standard error are streamed so you can run (for example) `sentry-process wget https://somebigfileurl` and see the progress just like if you had run `wget https://somebigfileurl`.

## Rust Version Requirements

Sentry Process needs Rust 1.54+ to be compiled.

## Limitations

- The process you want to run must terminate eventually. It may not make sense to use Sentry Process with processes that are designed to never die (like servers).
- You will **not** get much details on _what_ failed (i.e. no stacktraces). This is the tradeoff here.
- Sentry Process will send to your Sentry instance both standard output (`stdout`) and standard error (`stderr`) of the process you want to run (if it fails). Your Sentry instance might reject the report if this data is more than 200 kB (see [Sentry's documentation](https://docs.sentry.io/platforms/rust/enriching-events/context/)), so Sentry Process uses a circular buffer to ensure that this limit cannot be reached and the most recent outputs are sent with the report.

## License

MIT License Copyright (c) 2019 David Sferruzza

repository: dsferruzza/sentry-process

gha_language: Rust

repo_name: dsferruzza/sentry-process


text:
# Running MYOW on CIFAR10 dataset

This page walks through the steps required to run MYOW on the CIFAR10 dataset.

## Running training
Training is parallalised using `DistributedDataParallel`. The pool of candidate views during mining is shared across
all instances.

To start training run:

```bash
CUDA_VISIBLE_DEVICES=0,1 python3 scripts/cifar-train.py \
    --lr 2.0 \
    --mm 0.98 \
    --weight_decay 5e-5 \
    --optimizer sgd \
    --lr_warmup_epochs 30 \
    --batch_size 256 \
    --port 12354 \
    --logdir myow-cifar \
    --ckptpath myow-cifar
```

## Running evaluation

Evaluation can be done simultaneously or after training on a separate GPU instance. The eval script will automatically
run evaluation each time a new checkpoint is saved to `ckptpath`. It is also possible to start evaluation only after
a certain number of epoch using the `resume_eval` argument.

```bash
CUDA_VISIBLE_DEVICES=2 python3 scripts/cifar-eval.py \
    --lr 0.04 \
    --resume_eval 0 \
    --logdir runs-cifar \
    --ckptpath myow-cifar
```

## Running tensorboard

```bash
tensorboard --logdir=runs-cifar
```

branch_name: refs/heads/main


text:
# Todoey - The Simple TODO app

This is the code used in the Section 16 of Angela Yu's wonderful [course on Udemy](https://www.udemy.com/course/flutter-bootcamp-with-dart/).
Features have been added to the code in the course:smiley:. The main changes are:
1. Slide left/right on task to delete it.
2. Ability to undo the deleted task.

# --------------------------Old Readme--------------------------
# todoey_flutter

A TODO application.

## Getting Started

This project is a starting point for a Flutter application.

A few resources to get you started if this is your first Flutter project:

- [Lab: Write your first Flutter app](https://flutter.dev/docs/get-started/codelab)
- [Cookbook: Useful Flutter samples](https://flutter.dev/docs/cookbook)

For help getting started with Flutter, view our
[online documentation](https://flutter.dev/docs), which offers tutorials,
samples, guidance on mobile development, and a full API reference.

repository: kiranscaria/Flutter-Projects

repo_name: kiranscaria/Flutter-Projects


text:
# qjDom
jquery like lightweight javascript lib
---

qjDom is a small, static ECMA 6 JavaScript class that imitates some basic functions of jQuery.

## Use cases
On small html files like formulars or simple HTML Websites with less animations you doesn't want to use jQuery cause you only use a small amount of features of it. This JavaScript lib is written for this cases.

## Requirements
None

## Browser Support
With normal qjdom.min.js it should work on all modern browsers. If the compatiblity file qjdom.comp.min.js is included instead it should work on old pre ECMA 5 browsers (IE9 etc.) too.

## Documentation
Like jQuery you can use $ for the methods.

### Selectors
|Name|Return Value|Description|Example|
|----|------------|-----------|-------|
|$.id(id)| HTMLElement| Returns a HTMLElement by Id| $.id('test')|
|$.cl(cl)| HTMLCollectionOf<Element>| Returns HTMLElements by Class| $.cl('btn')|
|$.tag(tag)| HTMLCollectionOf<any>| Returns elements by tag| $.tag('input')|
|$.sel(selector)|any| dynamic selector, detects '#id', '.class' or 'tag' selector and returns one HTMLElement or a collection|

### Event Handler
**Information**: Eventhandler selectors can be '#id', '.class' or 'tag' selectors

|Name|Description|
|----|-----------|
|$.ready(func = (e) => {})| Waits until the document is fully loaded|
|$.resize(func = (e) => {}| Wrapper for window.onresize = function |
|$.on(selector = '', handler = '', lambda = () => {})| For dynamic content like jQuery.on event|
|$.handle(selector = '', handler = '', lambda = () => {})| Global handler which could be used for all diffrent JavaScript event handler types. All other event handler are syntastic sugar of $.handle|
|$.click(selector, func = (e) => {})| Click event handler|
|$.dblclick(selector, func = (e) => {})| Double click event handler|
|$.hover(selector, func = (e) => {})| Mouse over event handler|
|$.change(selector, func = (e) => {})| Change event handler|
|$.select(selector, func = (e) => {})| Select event handler|
|$.input(selector, func = (e) => {})| Input change event handler|
|$.submit(selector, func = (e) => {})| Submit event handler for forms|

### Iterator
|Name|Description|
|----|-----------|
|$.each(selector, func = (elem) => {})| Iterates over each element with specific query selector|

### UI
|Name|Description|
|----|-----------|
|$.hide(selector)| Hides element(s) |
|$.show(selector, display = 'block')| Shows element, default setting is display: block |

### AJAX
**Information**: Ajax methods use the XMLHttpRequest class.

|Name|Description|
|----|-----------|
|$.post({url: '', data: {}, success: (respone) => {}, error: (response) => {}})| Sends POST data in content type application/x-www-form-urlencoded. The response can be handled with success and error lambda functions|
|$.get({url: '', responseType = 'text', success: (respone) => {}, error: (response) => {}})| Gets requestet data as text or other response type. The response can be handled with success and error lambda functions|

## Examples
I recommend to have a look on the index.php file.

## License
MIT

repository: Shadowsith/qjDom

repo_name: Shadowsith/qjDom


text:
# Contributing Guidelines

Feel free to contribute.  Fork the repo, make some changes, open a pull request and I'll check it out.

Please try to keep changes small and well-organized, so that I have an easier time reviewing them.

Also feel free to open an issue if something isn't right.

## Code Style

Use Prettier for formatting. This project uses the default settings, with one exception: `trailingCommas` is set to `all`.

You can run it [from your code editor](https://prettier.io/docs/en/editors.html), or from the command line:

```console
npx prettier --write
```

Consistent code style is good.  Automatically enforced code style is even better.

repository: alterae/discord-bot

repo_name: alterae/discord-bot


text:
---
path: "/post-six"
cover: "./react.jpg"
date: "2018-10-20"
title: "React.js"
tags: ['gatsby', 'tutorial']
published: true
---

React is an open-source JavaScript library for building user interfaces. It is maintained by Facebook and a community of individual developers and companies. React can be used as a base in the development of single-page or mobile applications.

What you will learn

- Drive your company’s Return on Investment (ROI) with analytics-based marketing strategies.
- Apply analytics tools and techniques to real-world problems and scenarios.
- Practical applications in price and promotion analytics.
- Analysis of competitive trends.
- Distribution and sales performance.
- Competitive Analysis and Market Segmentation.
- Budgets for multiple campaigns.
- Advanced programming languages.
- Conjoint analysis, decision trees.
- Brick and mortar vs. e-commerce channels.
- Exclusive for Verified students: Practical application of R, the industry standard for data analysis, to critical and common marketing questions.

repository: marktefftech/learnify-static

gha_language: JavaScript

repo_name: marktefftech/learnify-static


text:
# mo-wire

````
  l
   l
    l
mo-wire
````

Is alternative for js promises.
Wire defined outside of function and then passed into.

Purpose:

1. allows to trace rejections (analog of `throw` in sync code)
1. reduces code of async functions (no need to define promises)
1. metaphor of "thrown wire" is easier for understanding,
than "chaining" which becomes a bit complicated at points,
when promises returned to error/success handlers and passed to following ones.

## Install

````
npm i mo-wire --save
````

# Examples

## Parallel

Wire:

![Wire example](https://cloud.githubusercontent.com/assets/2452269/10575034/772343bc-7662-11e5-9523-174ce6e9a792.jpg)

Promises:
````
Enthusiasts are welcomed to write this example using promises
````

Async:
````
Enthusiasts are welcomed to write this example using async
````

## Pretty agile usage of branches

Notes:
- you can predefine full list of branches with `branches` method.
This will ensure, that `success` won't trigger before all of them resolved.
- once you created some branch - you can access it later at any point
either with `l.branch('some')` or `l['some']`

````js
var l = new Wire();
l.branches('article', 'comments');

posts.getPostFromCacheOrDB(postId, l['article']);

bonds.getPostComments(postId, function (err, rows) {
    var processedComments = rows.map(function (r) { ... });
    l['comments'].resolve(processedComments);
});

l.success(...);
````

## mediator

````js
function getDataFromUrl(l, url) {
    download(l.mediator(formatResult), url);
    function formatResult(result) {
         l.resolve(body.title + ': ' + body.description);
    }
}
````

- All rejections which may happen inside of download() - will be thrown to `l`

## mapInSeries

````js
var l = new Wire();
l.mapInSeries(postIds, function(postId) {
    posts.doHeavyCalculationOfRating(postId, someOptions, l);
});
l.success(function(results) {
    // [] Array with result of each call
});
````

## Wire instance - is function

You can call wire instance itself - it is a function. This is equal:
````js
l()
l.resolve()
````
So you can pass wire to functions, which awaits for traditional callback - and it will work.

## Wire methods

- `resolve(...)` - triggers `success`, with any amount of arguments
- `reject(...)` - triggers `failure`, with any amount of arguments
- `branch(name, options)` - creates new Wire, which translates failure to parent immediately
or accumulates resolutions of all branches to single parent's success. Second argument is options for this new wire. Both arguments are optional.
- `branches('branch1', 'branch2', ...)` - to predefine list of branches at one step
- `mediator(callback, options)` - creates new Wire, which translates failure to parent immediately
or calls callback on success. Options are optional.
- `success(function() {})`
- `failure(function() {})`

- `push(func, arg1, arg2, ...)` - add task to the end of series queue. Queue will be launched once you set success(..) callback
- `mapInSeries`

`resolve` and `reject` will trigger corresponding callback only once.

If `reject` already called, `resolve` won't do anything.
But you can call `reject` after `resolve`, for example:

````js
var l = new Wire();

doSomethingAsync(l);

l.success(function(result){
    if (isCrap(result))
        return l.reject(result);

    ...
});

l.failure(function(data){
    washOff(data);
});
````

## Constructor options:

Constructor has optinal parameter: `new Wire(options)`

options {}:
- `branches`: list of branch names to predefine
- `resultArg`: 1 - Will take only argument with index 1 from `resolve(...)` as result
- `outputFailures`: 'none' / 'uncaught' (default) / 'all'
- `name`: Wire name - very useful for debug of deeply thrown rejections

`options` - can be a string, then it will be treated as `options.name`

## Wire.defaults = to set global default options

For example, when architecture of project uses
such callbacks: `function (err, result)` - we are able to omit passing `branch('bla', { resultArg: 1 })` for each branch,
and just set for whole library to await argument from exact place:
````js
require('mo-wire').defaults = {
    resultArg: 1
};
````

## Rejections tracing

If you set names to wire points, it will throw failure() where last argument will be object, e.g.:

````js
var l = Wire('Parsing test');

checkSite(l.mediator(formatResult, 'checkSite'), 'site.com');

function parse(l, domain) {
    getAlexaRank(l.branch('get alexa rank'), domain);
    getIndexPage(l.branch('get index page'), domain);
}

// If site.com index page inaccessible, we may get:
'statusCode=500', { trace: ['get index page', 'checkSite', 'Parsing test'] }
````

# ToDo

Enthusiasts are welcomed to participate project:

## options

- .errorArg - to set reaction to callback(err, ...)
- .branches - list of branch names to predefine - this is not implemented actually

## Multi-callbacks

Array of failure / success handlers instead of single var

## map

- let barnch() without arguments to create new sequential branches
and use it in map iterations - it will be safe for cases,
when some iterator would call callback 2 times.
Right now it will push wrong data to results.
- Docs for map & next()

## Promise wrappers

For convenient attaching to promise-based code

## Tests

Would be nice to cover code with tests

# License

The MIT License (MIT)
Copyright (c) 2015 garmoshka-mo

repository: garmoshka-mo/mo-wire

repo_name: garmoshka-mo/mo-wire


text:
Neovim
=============

[Neovim][1] Vim-fork focused on extensibility and usability

Authors
-------

*The authors of this module should be contacted via the [issue tracker][2].*

- [@roalcantara](https://github.com/roalcantara)

[1]: [https://github.com/neovim/neovim](https://github.com/neovim/neovim)
[2]: [https://github.com/roalcantara/](https://github.com/roalcantara/prezto)

repository: roalcantara/prezto

gha_language: Shell

repo_name: roalcantara/prezto


text:
# WearSunshine - Watch face for Android Wear

<img src="https://user-images.githubusercontent.com/15446842/32187439-fe126028-bd9c-11e7-9296-276f6c4a3d9e.png"/>

WearSunshine is wearable app companion for weather app [Sunshine](https://github.com/udacity/ud851-Sunshine) that runs on Android Wear devices. To tell more than time, the app takes advantage of Android Wear 2.0 API and the addition of customizable complications. It offers three complication slots to display additional information on the watch face, such as weather data provided by the mobile app.

**Watch Face Features:**
* Custom analog watch face that works on both round and square watch faces
* Offers range, short text and icon complications slots and by default shows:
  - High and low temperatures
  - Current weather icon
  - Humidity level
* Allows user to tap on complications launches mobile app
* Uses `Data Layer API` to synchronize data between devices
* Optimised for ambient and low bit ambient modes

**Mobile App Features:**
* Uses `ComplicationsProviderService` to expose Sunshine data
* Shows notifications on wearable device

## Try it out
To install the app on a connected device or running emulator, run:

```gradle
git clone https://github.com/mattwiduch/WearSunshine.git
cd WearSunshine
./gradlew installDebug
```

## License
```
Copyright (C) 2016 Mateusz Widuch

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: mattwiduch/WearSunshine

repo_name: mattwiduch/WearSunshine


text:
# Fotocollector

Helper to generate metadata about foto collections to not copy image files again and again :-)
This metadata is supposed to be used to recreate collections of files.

## Status

GHA [![Github Action master branch status](https://github.com/ottlinger/fotocollector/actions/workflows/gradle.yml/badge.svg?branch=master)](https://github.com/ottlinger/fotocollector/actions)

Travis [![Build Status](https://api.travis-ci.org/ottlinger/fotocollector.svg?branch=master)](https://api.travis-ci.org/ottlinger/fotocollector)

[![codecov](https://codecov.io/gh/ottlinger/fotocollector/branch/master/graph/badge.svg)](https://codecov.io/gh/ottlinger/fotocollector)

[![Language grade: Java](https://img.shields.io/lgtm/grade/java/g/ottlinger/fotocollector.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/ottlinger/fotocollector/context:java)

[![Codacy Badge](https://app.codacy.com/project/badge/Grade/331a0467219c44a8978d79de617ad7e4)](https://www.codacy.com/gh/ottlinger/fotocollector/dashboard)

[![Known Vulnerabilities](https://snyk.io/test/github/ottlinger/fotocollector/badge.svg)](https://snyk.io/test/github/ottlinger/fotocollector)

https://github.com/users/ottlinger/projects/3

## Howtos

### Build yourself

The tool can easily be built via gradle. It's main goal is clean install, so just run:
```
$ gradle
$ ./gradlew - to use the wrapper
```
after having checked out.

In case you are using the wrapper, the following [wrapper version](./gradle/wrapper/gradle-wrapper.properties) is used.

### Run the tool

Since the tool is still in development there's no command-line at the moment.

#### UberJAR

The application is generated as a shadow-JAR, that may be launched in the following way:
```
$ ./gradlew
$ java -jar build/libs/fotocollector-0.0.2-SNAPSHOT-all.jar
```

## Releases
### 0.0.2-SNAPSHOT

Currently: work in progress :-D

### 0.0.1 - 20160329

This [first release](https://github.com/ottlinger/fotocollector/tree/0.0.1) contains some Tika experiments and a basic skeleton for JSON and HTML generation.
Furthermore I experienced the ease of releasing with gradle, it nails down to a
```
$ gradle release
```

## History
### 2015-11

Project idea grew when I wanted to generate some Xmas-related image collections.

### 2016-02

The idea is to scan for images and generate a JSON file structure with a collection's title and the list of image names.
These names can later be used to scan a certain directory and copy the image to a before mentioned directory in order to restore a collection without keeping dozens of copies of the original images.

### 2016-03

The output should be available as JSON and HTML.

## License

This tool is licensed under [Apache License v2.0](https://www.apache.org/licenses/).

repository: ottlinger/fotocollector

gha_language: Java

repo_name: ottlinger/fotocollector


text:
---
title: Utah Highway 12 and Zebra Slot Canyon
date: "2020-03-16T04:12:02.344Z"
description: ""
---

It was a nice respite from the gloom and doom to drive on Utah Highway 12 from Torrey to Bryce, through winter wonderland of snow-covered aspen groves dotting pristine snow fields near the mountain top, and through the incredibly colorful and expansive rocky landscape of Grand Staircase-Escalante National Monument.

We stopped for a hike to the Zebra Slot Canyon, just north of Escalate off the unpaved Hole-in-the-Rock road. I was a bit concerned about the unpaved road condition after the rain yesterday, but it turned out okay. We had just a tantalizing glimpse of the "Zebra" part of the slot canyon - the water level in the slot canyon was high, and we turned back about 50 ft beyond the canyon entrance, after wading through above-waist-high cold muddy water. Would love to come back and explore further, when the water level gets low enough so swimming is not required!

![](./DSC00854.jpg)

repository: xinluh/where-am-i

repo_name: xinluh/where-am-i


text:
# LocalNotification-iOS10
Local Notification with Timer

An example Xcode project showing implementation of iOS Local Notifications using UserNotifications framework with Timer and also supoort in iOS 10.

![N|Solid](https://github.com/VishalNandoriya/LocalNotification-iOS10/blob/master/Simulator%20Screen%20Shot%2028-Apr-2017%2C%205.31.35%20PM.png)
![N|Solid](https://github.com/VishalNandoriya/LocalNotification-iOS10/blob/master/Simulator%20Screen%20Shot%2028-Apr-2017%2C%205.25.01%20PM.png)


text:
# IntersightClient::CloudCustomAttributesAllOf

## Properties

| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **class_id** | **String** | The fully-qualified name of the instantiated, concrete type. This property is used as a discriminator to identify the type of the payload when marshaling and unmarshaling data. | [default to 'cloud.CustomAttributes'] |
| **object_type** | **String** | The fully-qualified name of the instantiated, concrete type. The value should be the same as the 'ClassId' property. | [default to 'cloud.CustomAttributes'] |
| **attribute_name** | **String** | The name of an attribute. If used as a key-value pair then this field represents the key. | [optional] |
| **attribute_type** | **String** | The data type for attributeValue. For e.g. string, int, float. | [optional] |
| **attribute_value** | **String** | The attribute value. If used as a key-value pair then this field represents the value. | [optional] |

## Example

```ruby
require 'intersight_client'

instance = IntersightClient::CloudCustomAttributesAllOf.new(
  class_id: null,
  object_type: null,
  attribute_name: null,
  attribute_type: null,
  attribute_value: null
)
```

repository: xlab-si/intersight-sdk-ruby

gha_language: Ruby

repo_name: xlab-si/intersight-sdk-ruby


text:
## CHANGELOG
### 0.7.2
Update to use prop-types [#19](https://github.com/souporserious/react-midnight/pull/19)

### 0.7.1
Fix interpolation in return value [#17](https://github.com/souporserious/react-midnight/pull/17)

### 0.7.0
Renamed to `react-midnight`

API revamp, now uses Higher Order Components to decorate Components with calendar props

### 0.6.1
Fixed `NavigateMonth` utility where month would be skipped.

### 0.6.0
API has been abstracted into a `Dately` component to allow custom calendars to be built.

Bower package is now exported as `ReactDately`

Changed weird API for disabling dates. Now use the prop `disabledRules` to apply a rule that will be treated as disabled with all events removed.

### <0.5.3
I'm lazy and forgot to add changes. Will do someday, maybe.

license: ISC

repository: souporserious/react-midnight

gha_license_id: ISC

repo_name: souporserious/react-midnight


text:
# My Blog

`Blog` uses a lightweight mvc framework [Blade](https://github.com/biezhi/blade) for development, the default theme using a beautiful [pinghsu](https://github.com/chakhsu/pinghsu), if you think this project is good, please support it [star]((https://github.com/otale/tale/stargazers)).

demo website：<IP_ADDRESS>

[![License](https://img.shields.io/badge/license-MIT-4EB1BA.svg?style=flat-square)](https://github.com/lijie8778708/blog/blob/master/LICENSE)

## Tech:
+ Java 1.8
+ Blade MVC
+ SQLite
+ Markdown
+ Lombok
+ Junit

## Feature

+ Simple design, beautiful interface
+ Markdown article published
+ Custom article links
+ Support multiple themes
+ Support plugin extension
+ Support Emoji
+ Support Netease cloud music player
+ Support for attachments and database backups
+ Deployment is simple, do not rely on Tomcat
+ No database, sqlite embedded

## Interface Preview

![blog1](https://i.ibb.co/k37TS1s/Screen-Shot-2020-08-26-at-11-32-33-AM.png)
![blog2](https://i.ibb.co/WKwJnfN/Screen-Shot-2020-08-26-at-11-32-46-AM.png)
![blog3](https://i.ibb.co/xg6dF1h/Screen-Shot-2020-08-26-at-11-32-57-AM.png)
![blog4](https://i.ibb.co/DRPZh2P/Screen-Shot-2020-08-26-at-11-33-26-AM.png)
![blog5](https://i.ibb.co/9nMhzgt/Screen-Shot-2020-08-26-at-11-34-06-AM.png)
![blog6](https://i.ibb.co/nMTFZBg/Screen-Shot-2020-08-26-at-11-34-19-AM.png)

## OpenSource Agreement

[MIT](LICENSE)


text:
# whack-package-python-virtualenv-env

[Whack](https://github.com/mwilliamson/whack) package for Python virtualenvs.
Allows reloctable virtualenvs to be created using whack.

Run `whack deploy ${env_path} --in-place` after installing additional scripts
to create appropriate scripts under `${env_path}/bin`.

This package is compatible with Whack 0.6 and 0.7.

## Example

```
$ whack install \
    git+https://github.com/mwilliamson/whack-package-python-virtualenv-env.git \
    venv
$ venv/bin/pip install glances
(Snipping pip output)
$ whack deploy venv --in-place
$ # Now we can copy the virtualenv to any other path,
$ # and it will continue to work
$ mv venv venv2
$ venv2/bin/glances -v
Glances version 1.7.1 with PsUtil 1.0.1
```

Compared to attempting to move the virtualenv without Whack:

```
$ virtualenv venv
$ venv/bin/pip install glances
(Snipping pip output)
$ mv venv venv2
$ venv2/bin/glances -v
bash: venv2/bin/glances: /tmp/venv/bin/python: bad interpreter: No such file or directory
```

## Alternatives

virtualenv itself supports a `--relocatable` argument.
However, to quote from the package itself:

> The --relocatable option currently has a number of issues, and is not guaranteed to work in all circumstances. It is possible that the option will be deprecated in a future version of virtualenv.


text:
# 09. Actors

## Goals

- Understand what the actor model is
- Realize that an interpreted machine is an actor!
- Know how to "invoke" an actor in XState
- Know how to "spawn" an actor in XState
- Understand the difference between invoking and spawning actors in XState
- Know how to send and receive events from actors
- Visualize actor communication and hierarchy (sequence diagrams)

## Exercises

Invoke actors for loading a song and playing the audio. Make the `playAudio` and `pauseAudio` actions actually send events to the invoked audio actor.


text:
tk64
====

tk64 is a small little utility for generating string
tokens based off of 64 bit integers and converting
them back again.

You can define whatever alphabet you would like when
generating these tokens.


text:
# MDB_Squish

 *_MongoDB Parallel Compaction Tool_*

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

## Overview

 MDB Squish is a tool that can be pointed at a MongoDB database to run collection
compaction in parallel for any or all collections.  It will also keep statistics on
how much space compaction is saving and crude estimates of completion / run time.

## Requirements

- Python 2.7 or 3.5 _it may work with other versions, but this is what's tested_
- Mongo >= 3.2 _it may work with other versions, but this is waht's testsed_

## Installation

- `pip install git+https://github.com/phil-hildebrand/mdb_squish.git@{release}` (_IE: v0.1.1_)

  *_or_*

- `pip install git+https://github.com/phil-hildebrand/mdb_squish.git`  (_for latest release_)

## Usage

```
usage: mdb_squish [-h] [-v] [-s SERVER] [-p PORT] [-d DATABASE [DATABASE ...]]
                  [--collections COLLECTIONS [COLLECTIONS ...]]
                  [-c CONCURRENCY] [--log-dir LOG_DIR] [--stats-dir STATS_DIR]

optional arguments:
  -h, --help            show this help message and exit
  -v, --verbose         increase output verbosity
  -s SERVER, --server SERVER
                        MongoDB Host Server Name (short name only)
  -p PORT, --port PORT  MongoDB Port (default=27017)
  -d DATABASE [DATABASE ...], --database DATABASE [DATABASE ...]
                        limit stats to database X (default=all)
  --collections COLLECTIONS [COLLECTIONS ...]
                        limit compaction to these collections
  -c CONCURRENCY, --concurrency CONCURRENCY
                        # of compaction threads (default=3)
  -r RATE, --rate RATE  update stats file after x compcations (default=2)
  --log-dir LOG_DIR     MongoDB Get compaction log file location
                        (default=/var/log)
  --stats-dir STATS_DIR
                        MongoDB compaction stats dump file location
                        (default=/tmp/)
```

### Statistics

 MDB Squish will dump a stats file per database in the stats-dir.
By default, the stats-dir is /tmp.  Each stat file is json output and
named `mdb_squish_<dbname>_stats.json`.

 Example Data:
```
{
    "mongo_collection": {
        "compacted": 1,
        "compacted_size": 125,
        "duration": 0.0009090900421142578,
        "initial_size": 75,
        "name": "mongo_collection",
        "saved": -4096
    },
    "mongo_collection_one": {
        "compacted": 1,
        "compacted_size": 125,
        "duration": 0.005066871643066406,
        "initial_size": 75,
        "name": "mongo_collection_one",
        "saved": 0
    },
    "mongo_collection_two": {
        "compacted": 1,
        "compacted_size": 125,
        "duration": 0.0020208358764648438,
        "initial_size": 75,
        "name": "mongo_collection_two",
        "saved": 86016
    }
}
```

## Known Issues

- Currently it does not support auth based access for Mongo
- Current version does not have a feature to ignore/skip collections that were
   recently compacted

gha_language: Python


text:
# music.operator

[![Build Status](https://travis-ci.org/danigb/music.operator.svg?branch=master)](https://travis-ci.org/danigb/music.operator)
[![Code Climate](https://codeclimate.com/github/danigb/music.operator/badges/gpa.svg)](https://codeclimate.com/github/danigb/music.operator)
[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat)](https://github.com/feross/standard)
[![npm version](https://img.shields.io/npm/v/music.operator.svg)](https://www.npmjs.com/package/music.operator)
[![license](https://img.shields.io/npm/l/music.operator.svg)](https://www.npmjs.com/package/music.operator)
[![music.kit](https://img.shields.io/badge/music-kit-yellow.svg)](https://github.com/danigb/music.kit)

Your javascript music operator. Cooming soon.

# License

MIT License


text:
---
title: Configuring dynamic content
description: Understand the different types of dynamic content and learn how create and apply personalization blocks and conditional statements to a delivery.
feature: Personalization, Email
jira: KT-6824
thumbnail: 329936.jpg
doc-type: feature video
activity: use
team: WWFRE
role: User
level: Beginner
exl-id: a649e71c-1866-4596-88cf-0ede861c8845
---
# Configuring dynamic content

Understand the different types of dynamic content and learn how create and apply personalization blocks and conditional statements to a delivery.

>[!VIDEO](https://video.tv.adobe.com/v/329936?quality=12&learn=on)

For more information please see the [product documentation](https://experienceleague.adobe.com/docs/campaign-classic/using/sending-messages/personalizing-deliveries/conditional-content.html?lang=en).


text:
---
layout: study--link
title: >-
  Table Column Alignment with Variable Transforms
link: 'https://meyerweb.com/eric/thoughts/2022/08/15/table-column-alignment-with-variable-transforms/'
link_title: >-
  Table Column Alignment with Variable Transforms
date: 2022-08-16T15:03:15Z
published: true
---
Neat exploration of _very precise_ table numeral formatting (e.g., aligned around a decimal) with pure CSS. A few times through I thought, “Why bother? Why not just do default CSS alignment?” But this is part of [a labour of love to recreate a book with near perfect accuracy](https://meyerweb.com/eric/thoughts/2022/08/09/recreating-the-effects-of-nuclear-weapons-for-the-web/), and I think it’s perfectly fine to ask _yourself_ for “pixel” perfection—even if we’re (hopefully) largely past that in the professional web design and dev work (though maybe that’s wishful thinking from someone only indirectly in the industry these days).

I also loved Eric’s nod to [a _24-year-old_ bug in Firefox related to an unimplemented portion of the CSS2 spec for the `text-align` property](https://bugzilla.mozilla.org/show_bug.cgi?id=2212). The web is so fun.


text:
---
header: fetchLazy
example: View.fetchLazy()
---

*Client-side only* Set the `lazy` option to true to lazy-load a view.

var view = new View({
  'lazy': true,
  'fetch_params': { id: 1 },
  'model_name': 'TestModel'
});

View options for enabling lazy loading:

- `lazy` - Set this to true to stop the server from trying to render the HTML server-side
- `fetch_params` - An object of parameters to send to the API for the model or collection. In practice, you'll want to `JSON.stringify()` the parameters because of client / server differences.  This will automatically be parsed to JSON in the fetch request.
- `model_name` - This is used to make the fetch request for a model with the given parameters
- `collection_name` - If you're requesting a collection, this is the name of the collection for the view

When the request begins, the `loading` class is added to the view, the `loading` event is triggered, and [preRender](#preRender) is invoked before the fetch request to the server.  Once the data is retrieved from the server, if the view is still attached to the DOM, it will parse the results and [render](#render) the view.

gha_language: CSS


text:
<!-- Do not edit this file. It is automatically generated by API Documenter. -->

[Home](./index.md) > [matrix-scan](./matrix-scan.md) > [Matrix](./matrix-scan.matrix.md) > [fullArrayLength](./matrix-scan.matrix.fullarraylength.md)

## Matrix.fullArrayLength property

The full array length for this matrix. Can not be set directly. calculated based on the width and height of the matrix. (beta)

<b>Signature:</b>

```typescript
get fullArrayLength(): number;
```

repository: aogriffiths/matrix-scan

repo_name: aogriffiths/matrix-scan


text:
# `snyk-iac-rules` SDK
---

[![CircleCI](https://circleci.com/gh/snyk/snyk-iac-rules/tree/develop.svg?style=svg&circle-token=5597b9f0189554f754f38400cbe9d8f8b334c72a)](https://circleci.com/gh/snyk/snyk-iac-rules/tree/develop)
[![Shellspec Tests](https://github.com/snyk/snyk-iac-rules/actions/workflows/main.yml/badge.svg)](https://github.com/snyk/snyk-iac-rules/actions/workflows/main.yml)
[![Golang Version](https://img.shields.io/github/go-mod/go-version/snyk/snyk-iac-rules)](https://github.com/snyk/snyk-iac-rules)

`snyk-iac-rules` is a Golang SDK that provides flags for writing, debugging, testing, and bundling custom rules for the [Snyk IaC CLI](https://github.com/snyk/snyk/).

---

# About
The SDK is a tool for writing, debugging, testing, and bundling custom rules for [Snyk Infrastructure as Code](https://snyk.io/product/infrastructure-as-code-security/). See our [Custom Rules documentation](https://docs.snyk.io/products/snyk-infrastructure-as-code/custom-rules) to learn more.

# Install
The SDK can be installed through multiple channels.

## Install with npm or Yarn

[snyk-iac-rules available as an npm package](https://www.npmjs.com/package/snyk-iac-rules). If you have Node.js installed locally, you can install it by running:

```bash
npm install snyk-iac-rules@latest -g
```

or if you are using Yarn:

```bash
yarn global add snyk-iac-rules
```
## More installation methods

  Standalone executables (macOS, Linux, Windows)

### Standalone executables

Use [GitHub Releases](https://github.com/snyk/snyk-iac-rules/releases) to download a standalone executable of Snyk CLI for your platform.

For example, to download and run the latest SDK on macOS, you could run:

```bash
wget https://github.com/snyk/snyk-iac-rules/releases/download/v0.1.0/snyk-iac-rules_0.1.0_Darwin_x86_64.tar.gz
chmod +x ./snyk-iac-rules
mv ./snyk-iac-rules /usr/local/bin/
```

Drawback of this method is, that you will have to manually keep the SDK up to date.

  Install with Homebrew (macOS, Linux)

### Homebrew

Install the SDK from [Snyk tap](https://github.com/snyk/homebrew-tap) with [Homebrew](https://brew.sh) by running:

```bash
brew tap snyk/tap
brew install snyk-iac-rules
```

  Scoop (Windows)

### Scoop

Install the SDK from our [Snyk bucket](https://github.com/snyk/scoop-snyk) with [Scoop](https://scoop.sh) on Windows:

```
scoop bucket add snyk https://github.com/snyk/scoop-snyk
scoop install snyk-iac-rules
```

---

# Getting started with snyk-iac-rules

Once you installed the `snyk-iac-rules` SDK, you can verify it's working by running

```bash
snyk-iac-rules --help
```

For more help, read the documentation about [Snyk Infrastructure as Code](https://docs.snyk.io/snyk-infrastructure-as-code).

# Getting support

We recommend reaching out via the [support<EMAIL_ADDRESS>email whenever you need help with the SDK or Snyk in general.

* See [DEVELOPMENT.md](DEVELOPMENT.md) for how to setup the environment, add a new command, run the code locally, and run the tests.
* See [RELEASE.md](RELEASE.md) for how to release a new version of the SDK.

---

# Contributing

This project is open source but we don't encourage outside contributors.

repository: rharp/snyk-iac-rules

repo_name: rharp/snyk-iac-rules


text:
# Multer Storage Cloudinary
A multer storage engine for Cloudinary. Also consult the [Cloudinary API](https://github.com/cloudinary/cloudinary_npm).

## Installation

```sh
npm install --save multer-storage-cloudinary
```

## Usage

```javascript
var cloudinary = require('cloudinary');
var cloudinaryStorage = require('multer-storage-cloudinary');
var express = require('express');
var multer = require('multer');

var app = express();

var storage = cloudinaryStorage({
  cloudinary: cloudinary,
  folder: 'folder-name',
  allowedFormats: ['jpg', 'png'],
  filename: function (req, file, cb) {
    cb(undefined, 'my-file-name');
  }
});

var parser = multer({ storage: storage });

app.post('/upload', parser.array('images', 10), function (req, res) {
  console.log(req.files);
});
```

### File properties

File objects will expose (at least) the following properties provided by the [Cloudinary API](https://github.com/cloudinary/cloudinary_npm#upload):

Key | Description
--- | ---
`public_id` | Name of the file
`format` | Extension of the stored file
`url` | A URL for fetching the file
`secure_url` | A secure URL for fetching the file
`resource_type` | The type of the file
`bytes` | Size of the file
*NOTE: Many properties depend on the file type, to find out about the other exposed properties please check the Cloudinary API reference.*

### Options

Upload parameters can be configured using the options object passed to the `multer-storage-cloudinary` function call.

```javascript
var cloudinaryStorage = require('multer-storage-cloudinary');

var storage = cloudinaryStorage({
  // configuration options
});
```

All parameters are optional except the configured Cloudinary API object:

Parameter | Description | Type
--- | --- | ---
`options.cloudinary` | A Cloudinary API object
The API must be configured by the user | `object`
**required**
`options.filename` | The name of the file to be uploaded | `function`
`options.folder` | The name of the Cloudinary folder to upload into | `string` or `function`
`options.transformation` | Transformations to be applied - [Cloudinary API](https://github.com/cloudinary/cloudinary_npm#additional-resources) | `array` or `function`
`options.type` | Storage mode | `string` or `function`
`options.format` | The format to convert the file into | `string` or `function`
`options.allowedFormats` | A formats filter | `array` or `function`
`options.params` | An overriding object to directly supply all parameters | `object` or `function`
*NOTE: For further guidance on all parameters: consult the Cloudinary documentation.*

Functional parameters are called on every request and can be used in the following way:

```javascript
var cloudinary = require('cloudinary');
var cloudinaryStorage = require('multer-storage-cloudinary');

var storage = cloudinaryStorage({
  cloudinary: cloudinary,
  folder: function(request, file, callback) {
    callback(undefined, 'my-value');
  }
});
```
#### options.params
All Cloudinary upload parameters can be configured altogether using this. If a non-null value is provided(either directly or through the callback) all other options will be overriden.

Example:
```javascript
var cloudinary = require('cloudinary');
var cloudinaryStorage = require('multer-storage-cloudinary');

var storage = cloudinaryStorage({
  cloudinary: cloudinary,
  folder: 'folder', // will not be used
  format: 'jpg', // will not be used
  params: {
    folder: 'foo',
    format: 'png'
  }
});

var anotherStorage = cloudinaryStorage({
  cloudinary: cloudinary,
  folder: 'folder',
  format: 'jpg',
  params: function(req, file, cb) {
    var foo = undefined;
    cb(undefined, foo); // other options will not be overriden
                        // as long as foo is null
  }
});
```

## Testing

The Cloudinary API must be configured using the `CLOUDINARY_URL` environment variable in order to run the tests.
All test files are stored in a seperate Cloudinary folder, which is deleted after tests finish.

```sh
npm test
```

repository: funmiayinde/node-api-backend

repo_name: funmiayinde/node-api-backend


text:
### always

> ```a → (* → a)```

Returns a function that always returns the given value. Note that for non-primitives the value returned is a reference to the original value.

This function is known as const, constant, or `K (for K combinator)` in other languages and libraries.

`Example`

```js
const t = R.always('Tee');

t(); //=> 'Tee'
```


text:
# Change Log
A crude change log that starts at 4.0.0.
Version scheme follow the [capture-lib](https://github.com/cansat-icarus/capture-lib) version (but sometimes features and patches are added to the wrapper only, leading the version to not match it).
If you want to really see what changes in the stations, the [capture-lib change log](https://github.com/cansat-icarus/capture-lib/blob/develop/CHANGELOG.md) is the place to go.

## [v4.0.3] - 2017-05-02
No changes to code, only to CI configuration.

## [v4.0.3] - 2017-05-02
No changes to code, only to CI configuration.

There are no binaries available for this release.
Windows build failed.

## [v4.0.2] - 2017-05-02
No changes to code, only to CI configuration.

There are no binaries available for this release.
macOS and Windows builds failed.

## [v4.0.1] - 2017-05-02
No changes to code, only to CI configuration.

There are no binaries available for this release.
macOS and Windows builds failed.

## v4.0.0 - 2017-05-01
Due to CI configuration error, we have no binaries for this release. All builds have failed.

What we have now:
- capture-lib v4.0.0
- UI to visualize incoming packets, serial port status, backend connection (+ replicator) status and station score
- Log viewer
- Protocol routine runner: Automatically executes tasks present in protocols to make the life of a station operator easier.
- Automatic notifications for capture-lib errors
- Critical control locking mechanism, to prevent accidentally stopping data reception. Automatically activated in the protocol routine for opening the station.

[v4.0.4]: https://github.com/cansat-icarus/capture-wrapper-desktop/compare/v4.0.3...v4.0.4
[v4.0.3]: https://github.com/cansat-icarus/capture-wrapper-desktop/compare/v4.0.2...v4.0.3
[v4.0.2]: https://github.com/cansat-icarus/capture-wrapper-desktop/compare/v4.0.1...v4.0.2
[v4.0.1]: https://github.com/cansat-icarus/capture-wrapper-desktop/compare/v4.0.0...v4.0.1

repository: cansat-icarus/capture-wrapper-desktop

repo_name: cansat-icarus/capture-wrapper-desktop