Unofficial Golang SDK for AppStore Connect API.

# AppStore Connect API SDK GO (Unofficial)
[![Build Status](https://app.travis-ci.com/Kachit/appstore-sdk-go.svg?branch=master)](https://app.travis-ci.com/Kachit/appstore-sdk-go)
[![Codecov](https://codecov.io/gh/Kachit/appstore-sdk-go/branch/master/graph/badge.svg)](https://codecov.io/gh/Kachit/appstore-sdk-go)
[![Go Report Card](https://goreportcard.com/badge/github.com/kachit/appstore-sdk-go)](https://goreportcard.com/report/github.com/kachit/appstore-sdk-go)
[![Version](https://img.shields.io/github/go-mod/go-version/Kachit/appstore-sdk-go)](https://go.dev/doc/go1.14)
[![Release](https://img.shields.io/github/v/release/Kachit/appstore-sdk-go.svg)](https://github.com/Kachit/appstore-sdk-go/releases)
[![License](https://img.shields.io/github/license/mashape/apistatus.svg)](https://github.com/kachit/appstore-sdk-go/blob/master/LICENSE)
[![GoDoc](https://pkg.go.dev/badge/github.com/kachit/appstore-sdk-go)](https://pkg.go.dev/github.com/kachit/appstore-sdk-go)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go#third-party-apis) 

## Description
Unofficial Golang SDK for AppStore Connect API

## API documentation
https://developer.apple.com/documentation/appstoreconnectapi/download_finance_reports

https://developer.apple.com/documentation/appstoreconnectapi/download_sales_and_trends_reports

## Download
```shell
go get -u github.com/kachit/appstore-sdk-go
```

## Usage
```go
package main

import (
    "fmt"
    "time"
    appstore_sdk "github.com/kachit/appstore-sdk-go"
)

func main(){
    cfg := appstore_sdk.NewConfig("Issuer Id", "Key Id", "Vendor No", "path/to/your/private.key")
    client := appstore_sdk.NewClientFromConfig(cfg, nil)
    
    //Build auth token
    err := client.Init()
    if err != nil {
        fmt.Printf("Wrong API client init " + err.Error())
        panic(err)
    }
}
```

### Get sales reports
```go
ctx := context.Background()
date, _ := time.Parse("2006-01-02", "2020-05-05")
filter := appstore_sdk.NewSalesReportsFilter()
filter.SubTypeSummary().Version10().Daily().SetReportDate(date)

result, resp, err := client.SalesReports().GetSalesReports(ctx, filter)
if err != nil {
    fmt.Printf("Wrong API request " + err.Error())
    panic(err)
}

//Dump raw response
fmt.Println(resp)

//Dump result
fmt.Println(result.Data[0].Provider)
fmt.Println(result.Data[0].ProviderCountry)
fmt.Println(result.Data[0].SKU)
fmt.Println(result.Data[0].Developer)
fmt.Println(result.Data[0].Title)
fmt.Println(result.Data[0].Version)
fmt.Println(result.Data[0].ProductTypeIdentifier)
fmt.Println(result.Data[0].Units.Value())
fmt.Println(result.Data[0].AppleIdentifier.Value())
fmt.Println(result.Data[0].DeveloperProceeds.Value())
fmt.Println(result.Data[0].BeginDate.Value().Format(CustomDateFormatDefault))
fmt.Println(result.Data[0].EndDate.Value().Format(CustomDateFormatDefault))
fmt.Println(result.Data[0].CustomerCurrency)
fmt.Println(result.Data[0].CountryCode)
fmt.Println(result.Data[0].CurrencyOfProceeds)
fmt.Println(result.Data[0].AppleIdentifier.Value())
fmt.Println(result.Data[0].CustomerPrice.Value())
fmt.Println(result.Data[0].PromoCode)
fmt.Println(result.Data[0].ParentIdentifier)
fmt.Println(result.Data[0].Subscription)
fmt.Println(result.Data[0].Period)
fmt.Println(result.Data[0].Category)
fmt.Println(result.Data[0].CMB)
fmt.Println(result.Data[0].Device)
fmt.Println(result.Data[0].SupportedPlatforms)
fmt.Println(result.Data[0].ProceedsReason)
fmt.Println(result.Data[0].PreservedPricing)
fmt.Println(result.Data[0].Client)
fmt.Println(result.Data[0].OrderType)
```

### Get subscriptions reports
```go
ctx := context.Background()
date, _ := time.Parse("2006-01-02", "2020-05-05")
filter := appstore_sdk.NewSubscriptionsReportsFilter()
filter.SubTypeSummary().Version12().Daily().SetReportDate(date)

result, resp, err := client.SalesReports().GetSubscriptionsReports(ctx, filter)
if err != nil {
    fmt.Printf("Wrong API request " + err.Error())
    panic(err)
}

//Dump raw response
fmt.Println(resp)

//Dump result
fmt.Println(result.Data[0].AppName)
fmt.Println(result.Data[0].AppAppleID.Value())
fmt.Println(result.Data[0].SubscriptionName)
fmt.Println(result.Data[0].SubscriptionAppleID.Value())
fmt.Println(result.Data[0].SubscriptionGroupID.Value())
fmt.Println(result.Data[0].StandardSubscriptionDuration)
fmt.Println(result.Data[0].PromotionalOfferName)
fmt.Println(result.Data[0].PromotionalOfferID)
fmt.Println(result.Data[0].CustomerPrice.Value())
fmt.Println(result.Data[0].CustomerCurrency)
fmt.Println(result.Data[0].DeveloperProceeds.Value())
fmt.Println(result.Data[0].ProceedsCurrency)
fmt.Println(result.Data[0].PreservedPricing)
fmt.Println(result.Data[0].ProceedsReason)
fmt.Println(result.Data[0].Client)
fmt.Println(result.Data[0].Device)
fmt.Println(result.Data[0].State)
fmt.Println(result.Data[0].Country)
fmt.Println(result.Data[0].ActiveStandardPriceSubscriptions.Value())
fmt.Println(result.Data[0].ActiveFreeTrialIntroductoryOfferSubscriptions.Value())
fmt.Println(result.Data[0].ActivePayUpFrontIntroductoryOfferSubscriptions.Value())
fmt.Println(result.Data[0].ActivePayAsYouGoIntroductoryOfferSubscriptions.Value())
fmt.Println(result.Data[0].FreeTrialPromotionalOfferSubscriptions.Value())
fmt.Println(result.Data[0].PayUpFrontPromotionalOfferSubscriptions.Value())
fmt.Println(result.Data[0].PayAsYouGoPromotionalOfferSubscriptions.Value())
fmt.Println(result.Data[0].MarketingOptIns.Value())
fmt.Println(result.Data[0].BillingRetry.Value())
fmt.Println(result.Data[0].GracePeriod.Value())
```

### Get subscriptions events reports
```go
ctx := context.Background()
date, _ := time.Parse("2006-01-02", "2020-05-05")
filter := appstore_sdk.NewSubscriptionsEventsReportsFilter()
filter.SubTypeSummary().Version12().Daily().SetReportDate(date)

result, resp, err := client.SalesReports().GetSubscriptionsEventsReports(ctx, filter)
if err != nil {
    fmt.Printf("Wrong API request " + err.Error())
    panic(err)
}

//Dump raw response
fmt.Println(resp)

//Dump result
fmt.Println(result.Data[0].EventDate.Value().Format(CustomDateFormatDefault))
fmt.Println(result.Data[0].Event)
fmt.Println(result.Data[0].AppName)
fmt.Println(result.Data[0].AppAppleID.Value())
fmt.Println(result.Data[0].SubscriptionName)
fmt.Println(result.Data[0].SubscriptionAppleID.Value())
fmt.Println(result.Data[0].SubscriptionGroupID.Value())
fmt.Println(result.Data[0].StandardSubscriptionDuration)
fmt.Println(result.Data[0].PromotionalOfferName)
fmt.Println(result.Data[0].PromotionalOfferID)
fmt.Println(result.Data[0].SubscriptionOfferType)
fmt.Println(result.Data[0].SubscriptionOfferDuration)
fmt.Println(result.Data[0].MarketingOptIn)
fmt.Println(result.Data[0].MarketingOptInDuration)
fmt.Println(result.Data[0].PreservedPricing)
fmt.Println(result.Data[0].ProceedsReason)
fmt.Println(result.Data[0].ConsecutivePaidPeriods.Value())
fmt.Println(result.Data[0].OriginalStartDate.Value().Format(CustomDateFormatDefault))
fmt.Println(result.Data[0].Client)
fmt.Println(result.Data[0].Device)
fmt.Println(result.Data[0].State)
fmt.Println(result.Data[0].Country)
fmt.Println(result.Data[0].PreviousSubscriptionName)
fmt.Println(result.Data[0].PreviousSubscriptionAppleID.Value())
fmt.Println(result.Data[0].DaysBeforeCanceling.Value())
fmt.Println(result.Data[0].CancellationReason)
fmt.Println(result.Data[0].DaysCanceled.Value())
fmt.Println(result.Data[0].Quantity.Value())
```

### Get subscribers reports
```go
ctx := context.Background()
date, _ := time.Parse("2006-01-02", "2020-05-05")
filter := appstore_sdk.NewSubscribersReportsFilter()
filter.SubTypeDetailed().Version12().Daily().SetReportDate(date)

result, resp, err := client.SalesReports().GetSubscribersReports(ctx, filter)
if err != nil {
    fmt.Printf("Wrong API request " + err.Error())
    panic(err)
}

//Dump raw response
fmt.Println(resp)

//Dump result
fmt.Println(result.Data[0].EventDate.Value().Format(CustomDateFormatDefault))
fmt.Println(result.Data[0].AppName)
fmt.Println(result.Data[0].AppAppleID.Value())
fmt.Println(result.Data[0].SubscriptionName)
fmt.Println(result.Data[0].SubscriptionAppleID.Value())
fmt.Println(result.Data[0].SubscriptionGroupID.Value())
fmt.Println(result.Data[0].StandardSubscriptionDuration)
fmt.Println(result.Data[0].PromotionalOfferName)
fmt.Println(result.Data[0].PromotionalOfferID)
fmt.Println(result.Data[0].SubscriptionOfferType)
fmt.Println(result.Data[0].SubscriptionOfferDuration)
fmt.Println(result.Data[0].MarketingOptInDuration)
fmt.Println(result.Data[0].CustomerPrice.Value())
fmt.Println(result.Data[0].CustomerCurrency)
fmt.Println(result.Data[0].DeveloperProceeds.Value())
fmt.Println(result.Data[0].ProceedsCurrency)
fmt.Println(result.Data[0].PreservedPricing)
fmt.Println(result.Data[0].ProceedsReason)
fmt.Println(result.Data[0].Client)
fmt.Println(result.Data[0].Country)
fmt.Println(result.Data[0].SubscriberID.Value())
fmt.Println(result.Data[0].SubscriberIDReset)
fmt.Println(result.Data[0].Refund)
fmt.Println(result.Data[0].PurchaseDate.Value())
fmt.Println(result.Data[0].Units.Value())
```

### Get preorders reports
```go
ctx := context.Background()
date, _ := time.Parse("2006-01-02", "2020-05-05")
filter := appstore_sdk.NewPreOrdersReportsFilter()
filter.SubTypeSummary().Version10().Daily().SetReportDate(date)

result, resp, err := client.SalesReports().GetPreOrdersReports(ctx, filter)
if err != nil {
    fmt.Printf("Wrong API request " + err.Error())
    panic(err)
}

//Dump raw response
fmt.Println(resp)

//Dump result
fmt.Println(result.Data[0].Provider)
fmt.Println(result.Data[0].ProviderCountry)
fmt.Println(result.Data[0].Title)
fmt.Println(result.Data[0].SKU)
fmt.Println(result.Data[0].Developer)
fmt.Println(result.Data[0].PreOrderStartDate.Value().Format(CustomDateFormatDefault))
fmt.Println(result.Data[0].PreOrderEndDate.Value().Format(CustomDateFormatDefault))
fmt.Println(result.Data[0].Ordered.Value())
fmt.Println(result.Data[0].Canceled.Value())
fmt.Println(result.Data[0].CumulativeOrdered.Value())
fmt.Println(result.Data[0].CumulativeCanceled.Value())
fmt.Println(result.Data[0].StartDate.Value().Format(CustomDateFormatDefault))
fmt.Println(result.Data[0].EndDate.Value().Format(CustomDateFormatDefault))
fmt.Println(result.Data[0].CountryCode)
fmt.Println(result.Data[0].AppleIdentifier.Value())
fmt.Println(result.Data[0].Category)
fmt.Println(result.Data[0].Device)
fmt.Println(result.Data[0].SupportedPlatforms)
fmt.Println(result.Data[0].Client)
fmt.Println(result.Data[0].ProviderCountry)
```

### Get financial reports
```go
ctx := context.Background()
date, _ := time.Parse("2006-01-02", "2020-05-05")
filter :=  appstore_sdk.NewFinancesReportsFilter()
filter.SetReportDate(date).SetRegionCode("US")

result, resp, err := client.FinancesReports().GetFinancialReports(ctx, filter)
if err != nil {
    fmt.Printf("Wrong API request " + err.Error())
    panic(err)
}

//Dump raw response
fmt.Println(resp)

//Dump result
fmt.Println(result.Data[0].StartDate.Value().Format(CustomDateFormatDefault))
fmt.Println(result.Data[0].EndDate.Value().Format(CustomDateFormatDefault))
fmt.Println(result.Data[0].UPC)
fmt.Println(result.Data[0].ISRCIsbn)
fmt.Println(result.Data[0].VendorIdentifier)
fmt.Println(result.Data[0].Quantity.Value())
fmt.Println(result.Data[0].PartnerShare.Value())
fmt.Println(result.Data[0].ExtendedPartnerShare.Value())
fmt.Println(result.Data[0].PartnerShareCurrency)
fmt.Println(result.Data[0].SaleOrReturn)
fmt.Println(result.Data[0].AppleIdentifier.Value())
fmt.Println(result.Data[0].ArtistShowDeveloperAuthor)
fmt.Println(result.Data[0].Title)
fmt.Println(result.Data[0].LabelStudioNetworkDeveloperPublisher)
fmt.Println(result.Data[0].Grid)
fmt.Println(result.Data[0].ProductTypeIdentifier)
fmt.Println(result.Data[0].ISANOtherIdentifier)
fmt.Println(result.Data[0].CountryOfSale)
fmt.Println(result.Data[0].PreOrderFlag)
fmt.Println(result.Data[0].PromoCode)
fmt.Println(result.Data[0].CustomerPrice.Value())
fmt.Println(result.Data[0].CustomerCurrency)
```

appstore-sdk-go

The official AWS SDK for the Go programming language.

aws-sdk-go

Go library to build Asterisk PBX agi/fastagi applications.

# goagi: Golang library to build agi/fastagi applications

[![Build Status](https://github.com/staskobzar/goagi/actions/workflows/ci.yml/badge.svg)](https://github.com/staskobzar/goagi/actions/workflows/ci.yml)
[![codecov](https://codecov.io/gh/staskobzar/goagi/branch/master/graph/badge.svg)](https://codecov.io/gh/staskobzar/goagi)
[![CodeFactor](https://www.codefactor.io/repository/github/staskobzar/goagi/badge)](https://www.codefactor.io/repository/github/staskobzar/goagi)
[![Scrutinizer Code Quality](https://scrutinizer-ci.com/g/staskobzar/goagi/badges/quality-score.png?b=master)](https://scrutinizer-ci.com/g/staskobzar/goagi/?branch=master)
[![Go Report Card](https://goreportcard.com/badge/github.com/staskobzar/goagi)](https://goreportcard.com/report/github.com/staskobzar/goagi)
![GitHub](https://img.shields.io/github/license/staskobzar/goagi)



Simple library that helps to build AGI scripts or FastAGI servers with Go.
```go
import "github.com/staskobzar/goagi"
```

API local documentation [link is here](docs/api.md) or 
[go.dev generated](https://pkg.go.dev/github.com/staskobzar/goagi) documentation.

## Usage FastAGI

AGI object is created with ```New``` [method](docs/api.md#func-new) with three arguments:
- Reader [interface](docs/api.md#type-reader)
- Writer [interface](docs/api.md#type-response)
- Debugger [interface](docs/api.md#type-debugger)

Debugger interface is required only for debugging and usually ```nil```. See below for more details.

Reader and Writer are interfaces are any objects that implement ```Read```/```Write``` methods
and can be ```net.Conn```, ```tls.Conn```, ```os.Stdin```, ```os.Stdout``` or any other,
for example from packages ```strings```, ```bufio```, ```bytes```.

```New``` method will read AGI session setup environment variables and provides interface
to AGI commands. AGI environment variables and arguments can be accessed with 
methods [```Env```](docs/api.md#func-agi-env) and [```EnvArgs```](docs/api.md#func-agi-envargs).
If AGI channel receives HANGUP message, the session will be marked as hungup. Hangup status
can be checked by method [```IsHungup```](docs/api.md#func-agi-ishungup).

### Usage example for AGI:
```go
	import (
		"github.com/staskobzar/goagi"
		"os"
	)

	agi, err := goagi.New(os.Stdin, os.Stdout, nil)
	if err != nil {
		panic(err)
	}
	agi.Verbose("Hello World!")
```

### Fast AGI example:
```go
	ln, err := net.Listen("tcp", "127.0.0.1:4573")
	if err != nil {
		panic(err)
	}
	for {
		conn, err := ln.Accept()
		if err != nil {
			panic(err)
		}
		go func(conn net.Conn) {
			agi, err := goagi.New(conn, conn, nil)
			if err != nil {
				panic(err)
			}
			agi.Verbose("Hello World!")
		}(conn)
	}
```

See working examples in [examples/] folder.

Index of methods that implements AGI commands [see here.](docs/api.md)

## Commands Response interface

Every AGI command method return interface [```Response```](docs/api.md#type-response).
This is interface that provides access to AGI response values.
Success response example:
```
200 result=1 (speech) endpos=9834523 results=5
```
Fail response example:
```
511 Command Not Permitted on a dead channel or intercept routine
```
There are success  and error responses. 
Response interface implements following methods:

* ```Code() int```: response code: 200, 510 etc.
* ```RawResponse() string```: returns full text of AGI response.
* ```Result() int```: returns value of result= field.
* ```Value() string```: returns response value field that comes in parentheses. For exmpale "(timeout)" in response "200 result=1 (timeout)".
* ```Data() string```: returns text for error responses and dtmf values for command like GetData.
* ```EndPos() int64```: returns value for endpos= field.
* ```Digit() string```: return digit from digit= field.
* ```SResults() int```: return value for results= field.

## Debugger

Interface that provides debugging capabilities with configurable output.

Example of usage:

```go
	dbg := logger.New(os.Stdout, "myagi:", log.Lmicroseconds)
	r, w := net.Pipe()
	agi, err := goagi.New(r, w, dbg)
```


goagi

# goami2: Simple Asterisk Manager Interface (AMI) library

[![Build Status](https://github.com/staskobzar/goami2/actions/workflows/ci.yml/badge.svg)](https://github.com/staskobzar/goami2/actions/workflows/ci.yml)
[![Go Report Card](https://goreportcard.com/badge/github.com/staskobzar/goami2)](https://goreportcard.com/report/github.com/staskobzar/goami2)
[![codecov](https://codecov.io/gh/staskobzar/goami2/branch/master/graph/badge.svg)](https://codecov.io/gh/staskobzar/goami2)
[![GitHub go.mod Go version of a Go module](https://img.shields.io/github/go-mod/go-version/gomods/athens.svg)](https://github.com/staskobzar/goami2)
[![GitHub release](https://img.shields.io/github/release/staskobzar/goami2.svg)](https://github.com/staskobzar/goami2/releases)
[![Go Reference](https://pkg.go.dev/badge/github.com/staskobzar/goami2.svg)](https://pkg.go.dev/github.com/staskobzar/goami2)

Go library that provides interface to Asteris AMI. The library uses given ```net.Conn``` (tcp or tls), login
and starts reading AMI messages from connection and parse them into ```*Message``` object.
Provides simple interface to send messages to AMI.
It uses ```re2c``` to create very fast protocol parser. Run "make bench" for benchmark tests.

Usage example:

```go

import (
	"errors"
	"fmt"
	"log"
	"net"

	"github.com/staskobzar/goami2"
)

func main() {
	conn, err := net.Dial("tcp", "asterisk.host:5038")
	if err != nil {
		log.Fatalln(err)
	}

	// login and create client
	client, err := goami2.NewClient(conn, "admin", "pa55w0rd")
	if err != nil {
		log.Fatalln(err)
	}

	log.Println("client connected and logged in")

	// create AMI Action message and send to the asterisk.host
	msg := goami2.NewAction("CoreStatus")
	msg.AddActionID()
	client.Send(msg.Byte())

	defer client.Close() // close connections and all channels
	for {
		select {
		case msg := <-client.AllMessages():
			log.Printf("Got message: %s\n", msg.JSON())
		case err := <-client.Err():
			// terminate on network closed
			if errors.Is(err, goami2.ErrEOF) {
				log.Fatalf("Connection error: %s", err)
			}
			log.Printf("WARNING: AMI client error: %s", err)
		}
	}
}
```

## Docs
See documentation at [https://pkg.go.dev/github.com/staskobzar/goami2](https://pkg.go.dev/github.com/staskobzar/goami2)


goami2

Golang library providing common and simple database abstractions on top of Google Sheets.

GoFreeDB

# Google APIs Client Library for Go

## Getting Started

```shell
$ go get google.golang.org/api/tasks/v1
$ go get google.golang.org/api/moderator/v1
$ go get google.golang.org/api/urlshortener/v1
... etc ...
```

and using:

```go
package main

import (
        "context"
        "net/http"

        "google.golang.org/api/urlshortener/v1"
)

func main() {
        ctx := context.Background()
        svc, err := urlshortener.NewService(ctx)
        // ...
}
```

* For a longer tutorial, see the [Getting Started guide](https://github.com/google/google-api-go-client/blob/main/GettingStarted.md).
* For examples, see the [examples directory](https://github.com/google/google-api-go-client/tree/main/examples).
* For support, use the [golang-nuts](https://groups.google.com/group/golang-nuts) mailing list.

## Status

[![Go Reference](https://pkg.go.dev/badge/google.golang.org/api.svg)](https://pkg.go.dev/google.golang.org/api)

These are auto-generated Go libraries from the Google Discovery Service's JSON description files.

Due to the auto-generated nature of this collection of libraries they may contain breaking changes from one release to
the next. The generator itself and the code it produces are considered beta for this reason.

These client libraries are officially supported by Google.  However, the libraries are considered complete and are in
maintenance mode. This means that we will address critical bugs and security issues but will not add any new features.

If you're working with Google Cloud Platform APIs such as Datastore or Pub/Sub, please use the
[Cloud Client Libraries for Go](https://github.com/googleapis/google-cloud-go) instead. These are the new and idiomatic
Go libraries targeted specifically at Google Cloud Platform Services.

## Authorization

By default, each API will use [Google Application Default Credentials](https://developers.google.com/identity/protocols/application-default-credentials)
for authorization credentials used in calling the API endpoints. This will allow your application to run in many
environments without requiring explicit configuration.

```go
// import "google.golang.org/api/sheets/v4"
client, err := sheets.NewService(ctx)
```

To authorize using a [JSON key file](https://cloud.google.com/iam/docs/managing-service-account-keys), pass
[`option.WithCredentialsFile`](https://pkg.go.dev/google.golang.org/api/option#WithCredentialsFile) to the `NewService`
function of the desired package. For example:

```go
client, err := sheets.NewService(ctx, option.WithCredentialsFile("path/to/keyfile.json"))
```

You can exert more control over authorization by using the [`golang.org/x/oauth2`](https://pkg.go.dev/golang.org/x/oauth2)
package to create an `oauth2.TokenSource`. Then pass [`option.WithTokenSource`](https://pkg.go.dev/google.golang.org/api/option#WithTokenSource)
to the `NewService` function:

```go
tokenSource := ...
svc, err := sheets.NewService(ctx, option.WithTokenSource(tokenSource))
```

## More information

For some more information related to all of the generated clients please read through our
[package documentation](https://pkg.go.dev/google.golang.org/api#section-documentation).


google

Simple wrapper for easy google analytics reporting.

google-analytics

# Gosip - SharePoint SDK for Go (Golang)

> Authentication, HTTP client & fluent API wrapper

![Build Status](https://koltyakov.visualstudio.com/SPNode/_apis/build/status/gosip?branchName=master)
[![Go Report Card](https://goreportcard.com/badge/github.com/koltyakov/gosip)](https://goreportcard.com/report/github.com/koltyakov/gosip)
[![GoDoc](https://godoc.org/github.com/koltyakov/gosip?status.svg)](https://godoc.org/github.com/koltyakov/gosip)
[![License](https://img.shields.io/github/license/koltyakov/gosip.svg)](https://github.com/koltyakov/gosip/blob/master/LICENSE)
[![codecov](https://codecov.io/gh/koltyakov/gosip/branch/master/graph/badge.svg)](https://codecov.io/gh/koltyakov/gosip)
[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fkoltyakov%2Fgosip.svg?type=shield)](https://app.fossa.io/projects/git%2Bgithub.com%2Fkoltyakov%2Fgosip?ref=badge_shield)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go)


<div align="center">
  <img alt="Gosip" src="https://raw.githubusercontent.com/koltyakov/gosip-docs/master/.gitbook/assets/gosip.png" />
</div>

## Main features

- Unattended authentication using different strategies.
- Fluent API syntax for SharePoint object model.
- Simplified API consumption (REST, CSOM, SOAP).
- SharePoint-aware embedded features (retries, header presets, error handling).

### Supported SharePoint versions

- SharePoint Online (SPO)
- On-Premises (2019/2016/2013)

### Supported auth strategies

- SharePoint Online:

  - Azure Certificate (App Only) [🔗](https://go.spflow.com/auth/strategies/azure-certificate-auth)
  - Azure Username/Password [🔗](https://go.spflow.com/auth/strategies/azure-creds-auth)
  - Azure Device Flow [🔗](https://go.spflow.com/auth/strategies/azure-device-flow)
  - SAML based with user credentials
  - Add-In only permissions
  - ADFS user credentials (automatically detects in SAML strategy)
  - On-Demand auth [🔗](https://github.com/koltyakov/gosip-sandbox/tree/master/strategies/ondemand)

- SharePoint On-Premises 2019/2016/2013:
  - User credentials (NTLM)
  - ADFS user credentials (ADFS, WAP -> Basic/NTLM, WAP -> ADFS)
  - Behind a reverse proxy (Forefront TMG, WAP -> Basic/NTLM, WAP -> ADFS)
  - Form-based authentication (FBA)
  - On-Demand auth [🔗](https://github.com/koltyakov/gosip-sandbox/tree/master/strategies/ondemand)

## Installation

```bash
go get github.com/koltyakov/gosip
```

## Usage insights

1\. Understand SharePoint environment type and authentication strategy.

Let's assume it's SharePoint Online and Add-In Only permissions. Then `strategy "github.com/koltyakov/gosip/auth/addin"` subpackage should be used.

```golang
package main

import (
	"github.com/koltyakov/gosip"
	"github.com/koltyakov/gosip/api"
	strategy "github.com/koltyakov/gosip/auth/addin"
)
```

2\. Initiate an authentication object.

```golang
auth := &strategy.AuthCnfg{
	SiteURL:      os.Getenv("SPAUTH_SITEURL"),
	ClientID:     os.Getenv("SPAUTH_CLIENTID"),
	ClientSecret: os.Getenv("SPAUTH_CLIENTSECRET"),
}
```

AuthCnfg from different strategies contains different options relevant for a specified auth type.

The authentication options can be provided explicitly or can be read from a configuration file.

```golang
configPath := "./config/private.json"
auth := &strategy.AuthCnfg{}

err := auth.ReadConfig(configPath)
if err != nil {
	fmt.Printf("Unable to get config: %v\n", err)
	return
}
```

3\. Bind auth client with Fluent API.

```golang
client := &gosip.SPClient{AuthCnfg: auth}

sp := api.NewSP(client)

res, err := sp.Web().Select("Title").Get()
if err != nil {
	fmt.Println(err)
}

fmt.Printf("%s\n", res.Data().Title)
```

## Usage samples

### Fluent API client

Fluent API gives a simple way of constructing API endpoint calls with IntelliSense and chainable syntax.

![Fluent Sample](https://raw.githubusercontent.com/koltyakov/gosip-docs/master/.gitbook/assets/fluent.gif)

```golang
package main

import (
	"encoding/json"
	"fmt"
	"log"

	"github.com/koltyakov/gosip"
	"github.com/koltyakov/gosip/api"
	strategy "github.com/koltyakov/gosip/auth/addin"
)

func main() {
	// Getting auth params and client
	client, err := getAuthClient()
	if err != nil {
		log.Fatalln(err)
	}

	// Binding SharePoint API
	sp := api.NewSP(client)

	// Custom headers
	headers := map[string]string{
		"Accept": "application/json;odata=minimalmetadata",
		"Accept-Language": "de-DE,de;q=0.9",
	}
	config := &api.RequestConfig{Headers: headers}

	// Chainable request sample
	data, err := sp.Conf(config).Web().Lists().Select("Id,Title").Get()
	if err != nil {
		log.Fatalln(err)
	}

	// Response object unmarshalling (struct depends on OData mode and API method)
	res := &struct {
		Value []struct {
			ID    string `json:"Id"`
			Title string `json:"Title"`
		} `json:"value"`
	}{}

	if err := json.Unmarshal(data, &res); err != nil {
		log.Fatalf("unable to parse the response: %v", err)
	}

	for _, list := range res.Value {
		fmt.Printf("%+v\n", list)
	}

}

func getAuthClient() (*gosip.SPClient, error) {
	configPath := "./config/private.spo-addin.json"
	auth := &strategy.AuthCnfg{}
	if err := auth.ReadConfig(configPath); err != nil {
		return nil, fmt.Errorf("unable to get config: %v", err)
	}
	return &gosip.SPClient{AuthCnfg: auth}, nil
}
```

### Generic HTTP client helper

Provides generic GET/POST helpers for REST operations, reducing the amount of `http.NewRequest` scaffolded code, can be used for custom or not covered with Fluent API endpoints.

```golang
package main

import (
	"fmt"
	"log"

	"github.com/koltyakov/gosip"
	"github.com/koltyakov/gosip/api"
	strategy "github.com/koltyakov/gosip/auth/ntlm"
)

func main() {
	configPath := "./config/private.ntlm.json"
	auth := &strategy.AuthCnfg{}

	if err := auth.ReadConfig(configPath); err != nil {
		log.Fatalf("unable to get config: %v\n", err)
	}

	sp := api.NewHTTPClient(&gosip.SPClient{AuthCnfg: auth})

	endpoint := auth.GetSiteURL() + "/_api/web?$select=Title"

	data, err := sp.Get(endpoint, nil)
	if err != nil {
		log.Fatalf("%v\n", err)
	}

	// sp.Post(endpoint, body, nil) // generic POST
	// sp.Delete(endpoint, nil) // generic DELETE helper crafts "X-Http-Method"="DELETE" header
	// sp.Update(endpoint, nil) // generic UPDATE helper crafts "X-Http-Method"="MERGE" header
	// sp.ProcessQuery(endpoint, body) // CSOM helper (client.svc/ProcessQuery)

	fmt.Printf("response: %s\n", data)
}
```

### Low-level HTTP client usage

Low-lever SharePoint-aware HTTP client from `github.com/koltyakov/gosip` package for custom or not covered with a Fluent API client endpoints with granular control for an HTTP request, response, and http.Client parameters. The client is used internally but rarely required in consumer code.

```golang
client := &gosip.SPClient{AuthCnfg: auth}

var req *http.Request
// Initiate API request
// ...

resp, err := client.Execute(req)
if err != nil {
	fmt.Printf("Unable to request api: %v", err)
	return
}
```

SPClient has `Execute` method which is a wrapper function injecting SharePoint authentication and ending up calling `http.Client`'s `Do` method.

## Authentication strategies

Auth strategy should be selected corresponding to your SharePoint environment and its configuration.

Import path `strategy "github.com/koltyakov/gosip/auth/{strategy}"`. Where `/{strategy}` stands for a strategy auth package.

Azure AD based strategies (recommended production use with SharePoint Online):

| `/{strategy}` | Description                                       | Credentials sample(s)                                                   |
| ------------- | ------------------------------------------------- | ------------------------ |
| `/azurecert`  | Azure AD Certificate authentication               | [details](https://go.spflow.com/auth/strategies/azure-certificate-auth) |
| `/azurecreds` | Azure AD authorization with username and password | [details](https://go.spflow.com/auth/strategies/azure-creds-auth) |
| `/azureenv`   | Azure AD environment-based authentication         | [details](https://go.spflow.com/auth/strategies/azure-environment-auth) |
| `/device`     | Azure AD Device Token authentication              | [details](https://go.spflow.com/auth/strategies/azure-device-flow) |

Other strategies:

| `/{strategy}` | SPO | On-Prem | Credentials sample(s)                                                                                                                                          |
| ------------- | --- | ------- | ------------------ |
| `/saml`       | ✅  | ❌      | [details](https://go.spflow.com/auth/strategies/saml) |
| `/addin`      | ✅  | ❌      | [details](https://go.spflow.com/auth/strategies/addin) |
| `/ntlm`       | ❌  | ✅      | [details](https://go.spflow.com/auth/strategies/ntlm) |
| `/adfs`       | ✅  | ✅      | [details](https://go.spflow.com/auth/strategies/adfs) |
| `/fba`        | ❌  | ✅      | [details](https://go.spflow.com/auth/strategies/fba) |
| `/tmg`        | ❌  | ✅      | [details](https://go.spflow.com/auth/strategies/tmg) |
| `/ondemand`   | ✅  | ✅      | [details](https://go.spflow.com/auth/custom-auth/on-demand) |

Environment should configured for a specific auth strategy. E.g. you won't succeed with `adfs` in SPO if it has not setup properly.

Below are the most commonly authentication methods in more details:

### Azure AD application authentication

Azure AD application authentication is a recommended way for production use with SharePoint Online. It's based on OAuth 2.0 protocol and uses AAD application credentials for authentication.

Depending on an application type, there are different authentication strategies:

- Azure AD Certificate authentication: for headless applications, which are not able to provide user interaction, like a background service or a daemon. It uses a certificate to authenticate an application.
- Azure AD authorization with username and password: for applications which are able to provide user interaction, like a desktop application or CLI with credentials prompt. It uses a username and password to authenticate a user.
- Azure AD device token authentication: for applications which are able to provide user interaction, like a desktop application or CLI. It uses a device code to authenticate a user. It also supports multi-factor authentication.

### SAML Auth (SharePoint Online user credentials authentication)

This authentication option uses Microsoft Online Security Token Service `https://login.microsoftonline.com/extSTS.srf` and SAML tokens in order to obtain an authentication cookie.

```golang
// AuthCnfg - SAML auth config structure
type AuthCnfg struct {
	// SPSite or SPWeb URL, which is the context target for the API calls
	SiteURL string `json:"siteUrl"`
	// Username for SharePoint Online, for example `[user]@[company].onmicrosoft.com`
	Username string `json:"username"`
	// User or App password
	Password string `json:"password"`
}
```

### AddIn Only Auth

This type of authentication uses AddIn Only policy and OAuth bearer tokens for authenticating HTTP requests.

```golang
// AuthCnfg - AddIn Only auth config structure
type AuthCnfg struct {
	// SPSite or SPWeb URL, which is the context target for the API calls
	SiteURL string `json:"siteUrl"`
	// Client ID obtained when registering the AddIn
	ClientID string `json:"clientId"`
	// Client Secret obtained when registering the AddIn
	ClientSecret string `json:"clientSecret"`
	// Your SharePoint Online tenant ID (optional)
	Realm string `json:"realm"`
}
```

Realm can be left empty or filled in, which will add small performance improvement. The easiest way to find the tenant is to open SharePoint Online site collection, click `Site Settings` -> `Site App Permissions`. Taking any random app, the tenant ID (realm) is the GUID part after the `@`.

See more details of [AddIn Configuration and Permissions](https://github.com/s-kainet/node-sp-auth/wiki/SharePoint-Online-addin-only-authentication).

### NTLM Auth (NTLM handshake)

This type of authentication uses an HTTP NTLM handshake to obtain an authentication header.

```golang
// AuthCnfg - NTLM auth config structure
type AuthCnfg struct {
	// SPSite or SPWeb URL, which is the context target for the API calls
	SiteURL  string `json:"siteUrl"`
	Domain   string `json:"domain"`   // AD domain name
	Username string `json:"username"` // AD user name
	Password string `json:"password"` // AD user password
}
```

Gosip uses `github.com/Azure/go-ntlmssp` NTLM negotiator, however, a custom one also can be [provided](https://github.com/koltyakov/gosip/issues/14) in case of demand.

## Secrets encoding

When storing credential in local `private.json` files, which can be handy in local development scenarios, we strongly recommend to encode secrets such as `password` or `clientSecret` using [cpass](./cmd/cpass/README.md). Class converts a secret to an encrypted representation, which can only be decrypted on the same machine where it was generated. That reduces accidental leaks, e.g. together with git commits.

## Reference

Many auth flows have been "copied" from [node-sp-auth](https://github.com/s-kainet/node-sp-auth) library (used as a blueprint), which we intensively use in Node.js ecosystem for years.

Fluent API and wrapper syntax are inspired by [PnPjs](https://github.com/pnp/pnpjs), which is also the first-class citizen on almost all our Node.js and front-end projects with SharePoint involved.

## 📚 [Documentation](https://go.spflow.com)

## 📦 [Samples](https://github.com/koltyakov/gosip-sandbox/tree/master/samples)

## License

[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fkoltyakov%2Fgosip.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2Fkoltyakov%2Fgosip?ref=badge_large)

gosip

GoStorm is a Go library that implements the communications protocol required to write Storm spouts and Bolts in Go that communicate with the Storm shells.

gostorm

Go client for the [Internet Game Database API](https://api.igdb.com/).

igdb

pushover
=========

[![GoDoc](https://godoc.org/github.com/gregdel/pushover?status.svg)](http://godoc.org/github.com/gregdel/pushover)
[![Build Status](https://travis-ci.org/gregdel/pushover.svg?branch=master)](https://travis-ci.org/gregdel/pushover)
[![Coverage Status](https://coveralls.io/repos/gregdel/pushover/badge.svg?branch=master&service=github)](https://coveralls.io/github/gregdel/pushover?branch=master)
[![Go Report Card](https://goreportcard.com/badge/github.com/gregdel/pushover)](https://goreportcard.com/report/github.com/gregdel/pushover)

pushover is a wrapper around the Superblock's Pushover API written in go.
Based on their [documentation](https://pushover.net/api). It's a convenient way to send notifications from a go program with only a few lines of code.

## Messages

### Send a simple message

Here is a simple example for sending a notification to a recipient. A recipient can be a user or a group. There is no real difference, they both use a notification token.

```go
package main

import (
    "log"

    "github.com/gregdel/pushover"
)

func main() {
    // Create a new pushover app with a token
    app := pushover.New("uQiRzpo4DXghDmr9QzzfQu27cmVRsG")

    // Create a new recipient
    recipient := pushover.NewRecipient("gznej3rKEVAvPUxu9vvNnqpmZpokzF")

    // Create the message to send
    message := pushover.NewMessage("Hello !")

    // Send the message to the recipient
    response, err := app.SendMessage(message, recipient)
    if err != nil {
        log.Panic(err)
    }

    // Print the response if you want
    log.Println(response)
}
```

### Send a message with a title

There is a simple way to create a message with a title. Instead of using pushover.NewMessage you can use pushover.NewMessageWithTitle.

```go
message := pushover.NewMessageWithTitle("My awesome message", "My title")
```

### Send a fancy message

If you want a more detailed message you can still do it.

```go
message := &pushover.Message{
    Message:     "My awesome message",
    Title:       "My title",
    Priority:    pushover.PriorityEmergency,
    URL:         "http://google.com",
    URLTitle:    "Google",
    Timestamp:   time.Now().Unix(),
    Retry:       60 * time.Second,
    Expire:      time.Hour,
    DeviceName:  "SuperDevice",
    CallbackURL: "http://yourapp.com/callback",
    Sound:       pushover.SoundCosmic,
}
```

### Send a message with an attachment

You can send an image attachment along with the message.

```go
file, err := os.Open("/some/image.png")
if err != nil {
  panic(err)
}
defer file.Close()

message := pushover.NewMessage("Hello !")
if err := message.AddAttachment(file); err != nil {
  panic(err)
}
```

## Callbacks and receipts

If you're using an emergency notification you'll have to specify a retry period and an expiration delay. You can get the receipt details using the token in the message response.


```go
...
response, err := app.SendMessage(message, recipient)
if err != nil {
    log.Panic(err)
}

receiptDetails, err := app.GetReceiptDetails(response.Receipt)
if err != nil {
    log.Panic(err)
}

fmt.Println("Acknowledged status :", receiptDetails.Acknowledged)
```

You can also cancel an emergency notification before the expiration time.

```go
response, err := app.CancelEmergencyNotification(response.Receipt)
if err != nil {
    log.Panic(err)
}
```

## User verification

If you want to validate that the recipient token is valid.

```go
...
recipientDetails, err := app.GetRecipientDetails(recipient)
if err != nil {
    log.Panic(err)
}

fmt.Println(recipientDetails)
```


pushover

Go library for the [RAWG Video Games Database](https://rawg.io/) API

# RAWG Video Games Database Golang client

[![Build Status](https://travis-ci.org/dimuska139/rawg-sdk-go.svg?branch=master)](https://travis-ci.org/dimuska139/rawg-sdk-go)
[![codecov](https://codecov.io/gh/dimuska139/rawg-sdk-go/branch/master/graph/badge.svg)](https://codecov.io/gh/dimuska139/rawg-sdk-go)
[![Go Report Card](https://goreportcard.com/badge/github.com/dimuska139/rawg-sdk-go)](https://goreportcard.com/report/github.com/dimuska139/rawg-sdk-go)
[![License](https://img.shields.io/github/license/mashape/apistatus.svg)](https://github.com/dimuska139/rawg-sdk-go/blob/master/LICENSE)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go) 

This is unofficial RAWG SDK GO. This library contains methods for interacting with [RAWG API](https://rawg.io/).

## Installation

```shell
go get github.com/dimuska139/rawg-sdk-go
```

## Usage

```go
package main

import (
    "context"
    "fmt"
    "net/http"
    "strings"
    "time"
    "github.com/dimuska139/rawg-sdk-go/v3"
)

func main() {
    config := rawg.Config{
        ApiKey:  "yourapikey", // Your personal API key (see https://rawg.io/apidocs)
        Language: "ru",
        Rps:      5,
    }
    client := rawg.NewClient(http.DefaultClient, &config)
    
    filter := rawg.NewGamesFilter().
        SetSearch("Gta5").
        SetPage(1).
        SetPageSize(10).
        ExcludeCollection(1).
        WithoutParents()
    
    ctx, cancel := context.WithTimeout(context.Background(), time.Duration(time.Millisecond*500))
    defer cancel()
    data, total, err := client.GetGames(ctx, filter)

    ...
}
```

The tests should be considered a part of the documentation. Also you can read [official docs](https://rawg.io/apidocs).

## API limitations

Only 5 requests per second allowed from one IP. The "Rps" parameter in configuration performs this limitation. 
So you don't worry about it.

## License

RAWG SDK GO is released under the
[MIT License](http://www.opensource.org/licenses/MIT).

rawg-sdk-go

Go Library to access statdns.com API, which is in turn RRDA API. DNS Queries over HTTP.

The Best Go Libraries For Third-party APIs - Libraries for accessing third party APIs. (13)