### Setup Module After Installation

Source: https://docs.clover.com/dev/docs/installing-magento

Run these commands after installing the module to upgrade the Adobe Commerce setup, flush the cache, and clean the cache.

```bash
$ bin/magento setup:upgrade
$ bin/magento cache:flush
$ bin/magento cache:clean
```

--------------------------------

### Install Test App with Script

Source: https://docs.clover.com/dev/docs/setting-up-an-android-emulator

Use this script to install your test Android app on the emulator after initial setup. Ensure the emulator is running and accessible.

```shell
./install_apps.py
Getting installed versions...
Getting current app data...
Updating package: your.package.name from version: ?, to version: 1...
```

--------------------------------

### Get All Authorizations (Node.js)

Source: https://docs.clover.com/dev/reference/paygetauthorizations

This Node.js example demonstrates how to fetch all authorizations for a merchant. It shows how to set up the request and handle the response.

```javascript
const https = require('https');

const options = {
  hostname: 'apisandbox.dev.clover.com',
  port: 443,
  path: '/v3/merchants/{mId}/authorizations',
  method: 'GET',
  headers: {
    'accept': 'application/json',
    'Authorization': 'Bearer YOUR_ACCESS_TOKEN'
  }
};

const req = https.request(options, (res) => {
  console.log('statusCode:', res.statusCode);
  let data = '';
  res.on('data', (chunk) => {
    data += chunk;
  });
  res.on('end', () => {
    console.log(JSON.parse(data));
  });
});

req.on('error', (error) => {
  console.error(error);
});
req.end();
```

--------------------------------

### Get a Single Payment (Node.js)

Source: https://docs.clover.com/dev/reference/paygetpayment

This Node.js example demonstrates how to fetch a single payment using the Clover SDK. Ensure you have the SDK installed and configured with your API credentials.

```javascript
const clover = require('remote-pay-api');

const merchantId = 'YOUR_MERCHANT_ID';
const paymentId = 'YOUR_PAYMENT_ID';

clover.payments.get(merchantId, paymentId, {
  expand: ['tender', 'lineItemPayments']
})
.then(payment => {
  console.log('Payment details:', payment);
})
.catch(error => {
  console.error('Error fetching payment:', error);
});
```

--------------------------------

### Example Activity Setup for Payment Connector

Source: https://docs.clover.com/dev/docs/take-a-payment-with-payment-connector

Initializes the PaymentConnector, sets up the activity layout, and adds a button listener to trigger a sale. Ensure the PaymentConnector is initialized with a listener before use.

```java
public class ExampleActivity extends AppCompatActivity {
	@Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_simple_example);
  
  // Initialize the PaymentConnector with a listener
  final PaymentConnector paymentConnector = initializePaymentConnector();
  
  Button saleButton = findViewById(R.id.saleButton);
  saleButton.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
      // Set up a SaleRequest
      SaleRequest saleRequest = setupSaleRequest();
      paymentConnector.sale(saleRequest);
    }
  });
}
```

--------------------------------

### Get Credit Refunds (Node.js)

Source: https://docs.clover.com/dev/reference/paygetcreditrefunds-3

This Node.js example demonstrates how to fetch credit refunds using the Clover SDK. Ensure you have the SDK installed and configured with your access token.

```javascript
const clover = require('remote-pay-api');

const merchantId = '{mId}';
const accessToken = '<YOUR_ACCESS_TOKEN>';

clover.init({
  clientId: 'YOUR_CLIENT_ID',
  clientSecret: 'YOUR_CLIENT_SECRET'
});

clover.payments.getCreditRefunds(merchantId, accessToken)
  .then(refunds => {
    console.log('Credit Refunds:', refunds);
  })
  .catch(err => {
    console.error('Error fetching credit refunds:', err);
  });

```

--------------------------------

### Initiate Payment from Activity (Java)

Source: https://docs.clover.com/dev/docs/android-payments-api-payment-tutorial

Sets up the activity layout and a button click listener to build and start a payment request. Requires `activity_main.xml` and a `paymentButton` ID.

```Java
@Override
    protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);
       Button payButton = findViewById(R.id.paymentButton);
       payButton.setOnClickListener(new View.OnClickListener() {
           @Override
           public void onClick(View v) {
               Intent intent = buildPaymentRequestIntent();	
               startActivityForResult(intent, PAYMENT_REQUEST_CODE);
           }
       });
    }
```

--------------------------------

### Get Merchant Details (Node.js)

Source: https://docs.clover.com/dev/reference/merchantgetmerchant

This Node.js example demonstrates how to fetch a single merchant's information. Ensure you have the necessary libraries installed and replace placeholders with your actual values.

```javascript
const axios = require('axios');

const merchantId = '{mId}'; // Replace with the actual merchant ID
const accessToken = '<YOUR_ACCESS_TOKEN>'; // Replace with your access token
const userAgent = 'YourAppName'; // Replace with your application name

axios.get(`https://apisandbox.dev.clover.com/v3/merchants/${merchantId}`, {
  headers: {
    'Authorization': `Bearer ${accessToken}`,
    'User-Agent': userAgent
  }
})
.then(response => {
  console.log('Merchant details:', response.data);
})
.catch(error => {
  console.error('Error fetching merchant details:', error);
});
```

--------------------------------

### Initiate Payment from Activity (Kotlin)

Source: https://docs.clover.com/dev/docs/android-payments-api-payment-tutorial

Sets up the activity layout and a button click listener to build and start a payment request. Requires `activity_main.xml` and a `paymentButton` ID.

```Kotlin
override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        val payButton = findViewById<Button>(R.id.paymentButton)
        payButton.setOnClickListener(object : OnClickListener() {
            fun onClick(v: View?) {
                val intent: Intent = buildPaymentRequestIntent()
                startActivityForResult(intent, PAYMENT_REQUEST_CODE)
            }
        })
    }
```

--------------------------------

### Capture Pre-Auth with Custom Tips

Source: https://docs.clover.com/dev/docs/android-pay-capture

Example of creating custom tip options for a pre-auth capture, including fixed amounts and percentages. It also demonstrates preferring on-screen tips.

```Kotlin
val builder = CapturePreAuthRequestIntentBuilder("<posPaymentId>", 1200)

var tipSuggestions = listOf<TipSuggestion>(
   TipSuggestion.Amount("Thanks!", 100),
   TipSuggestion.Amount("Good Job!", 200),
   TipSuggestion.Percentage("Great!", 20)
)
var tipOptions = CapturePreAuthRequestIntentBuilder.TipOptions.PromptCustomer(null, tipSuggestions)

builder.tipAndSignatureOptions(
   tipOptions,
   null, // signature options
   true) // preferOnScreen

val intent = builder.build(context)
```

--------------------------------

### Get Charges Request Example

Source: https://docs.clover.com/dev/docs/get-charges

This example shows how to make a GET request to the charges endpoint using cURL. Ensure you include the correct Authorization header.

```curl
curl --request GET \
     --url https://scl-sandbox.dev.clover.com/v1/charges \
     --header 'Accept: application/json' \
     --header 'Authorization: Bearer ab867xxxx-xxxx-xxxx-xxxx-xxxxxxxxcae2'
```

--------------------------------

### Installment Info Schema

Source: https://docs.clover.com/dev/reference/postorders

Defines the structure for installment information, including payment indicators, invoice numbers, and counts. Use this for recurring or installment payment setups.

```json
{
  "components": {
    "schemas": {
      "installment_info": {
        "description": "Installment information for the transaction.",
        "properties": {
          "bill_pay_indicator": {
            "enum": [
              "Recurring",
              "Installment"
            ],
            "type": "string",
            "description": "Indicates whether the transaction is a recurring or installment payment. \n Values:\n  Installment\n  Recurring - For Canadian merchants, the value must be Recurring"
          },
          "invoice_number": {
            "type": "string",
            "description": "Invoice number of the installment or recurring transaction.\n Length: Max 12 characters"
          },
          "description": {
            "type": "string",
            "description": "Description of the `installment_info` object."
          },
          "total_count": {
            "type": "integer",
            "description": "Total count of the transaction installments as per the cardholder agreement with the merchant.\n All customer-initiated transactions require 3DS authentication. Additionally, `total_count` is required for the following cards and transactions:\n **Discover&reg; cards**, including JCB&reg; (US domestic) and Diners&reg; used for merchant-initiated installments and recurring transactions.\n **India-issued Discover cards** used for merchant-initiated recurring transactions.\n **India-issued Visa&reg; cards** used for recurring transactions.\n Values: 1 to 99; Default: 99"
          },
          "total_amount": {
            "type": "integer",
            "description": "Total installment amount.\n Max 500,000 USD"
          },
          "sequence_number": {
            "type": "integer",
            "description": "Required for Discover card. Sequence of the transactions, displayed in ascending order, when multiple installment payments are submitted.\n Length: 2"
          },
          "amount_type": {
            "type": "string",
            "enum": [
              "Fixed",
              "Variable"
            ],
            "description": "Transaction account type applicable to Discover (including JCB and Diner) and Visa cards. \n All customer-initiated transactions require 3DS authentication. Additionally, `amount_type` is required for the following cards and transactions: \n **Discover cards**, including JCB (US domestic) and Diners are used for merchant-initiated installments and recurring transactions.\n **India-issued Discover cards** are used for merchant-initiated recurring transactions.\n **India-issued Visa cards** are used for recurring transactions.\n Default: Fixed"
          },
          "interval": {
            "type": "string",
            "enum": [
              "DAY",
              "WEEK",
              "MONTH",
              "YEAR",
              "SEMI_MONTH"
            ],
            "description": "Frequency of a recurring or installment or recurring payment.\n This field is required for:\n **Discover card** used for merchant-initiated installment or recurring transactions.\n **India-issued Visa cards** used for recurring transactions."
          },
          "interval_count": {
            "type": "integer",
            "description": "Frequency counts of a installment or recurring payment.\n This field is required for:\n **Discover card** used for merchant-initiated installment or recurring transactions.\n **India-issued Visa cards** used for recurring transactions."
          }
        }
      }
    }
  }
}
```

--------------------------------

### Android App Setup with Clover Go SDK

Source: https://docs.clover.com/dev/docs/android-clover-go-sdk-quick-start

This Java code demonstrates the initial setup for an Android application using the Clover Go SDK. It requests necessary Bluetooth permissions and initiates a scan for available readers.

```java
package com.example.gosdkintro;

import android.Manifest;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.widget.Toast;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.app.ActivityCompat;

import com.clover.sdk.gosdk.GoSdk;
import com.clover.sdk.gosdk.core.domain.model.ReaderInfo;
import com.clover.sdk.gosdk.model.PayRequest;
import com.clover.sdk.gosdk.models.ChargeCardReaderState;
import com.clover.sdk.gosdk.models.GoSdkCallback;
import com.clover.sdk.gosdk.models.PaymentState;
import com.clover.sdk.gosdk.payment.domain.model.CardReaderStatus;

import java.util.ArrayList;
import java.util.Arrays;


public class MainActivity extends AppCompatActivity {
    private GoSdk goSdk;

    private final MainActivity activity = this;

    private final int REQUEST_PERMISSION_CODE = 100;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        goSdk = GoSdkCreatorJava.get(activity);

        String[] requiredPermissions = new String[]{Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION};

        // Get Bluetooth permissions to connect to the reader
        ActivityCompat.requestPermissions(
                this,
                requiredPermissions,
                REQUEST_PERMISSION_CODE
        );
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        ArrayList<String> permissionsList = new ArrayList<>();

        if (requestCode == REQUEST_PERMISSION_CODE && grantResults.length != 0) {
            for (int i = 0; i < permissions.length; i++) {
                if (grantResults[i] == PackageManager.PERMISSION_DENIED) {
                    permissionsList.add(permissions[i]);
                }
            }

            if (permissionsList.size() == 0) {
                permissionsGranted();
            } else {
                boolean showRationale = false;

                for (int i = 0; i < permissionsList.size(); i++) {
                    String permission = permissionsList.get(i);

                    if (ActivityCompat.shouldShowRequestPermissionRationale(activity, permission)) {
                        showRationale = true;
                        break;
                    }
                }

                if (showRationale) {
                    DialogInterface.OnClickListener okListener = (dialogInterface, i) -> {
                        String[] permissionsArray = Arrays.copyOf(permissionsList.toArray(), permissionsList.size(), String[].class);
                        ActivityCompat.requestPermissions(
                                activity,
                                permissionsArray,
                                REQUEST_PERMISSION_CODE
                        );
                    };

                    DialogInterface.OnClickListener cancelListener = (dialogInterface, i) -> permissionsDenied();

                    showAlertDialog(okListener, cancelListener);
                }
            }
        }

        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    }

    private void permissionsGranted() {
        Toast.makeText(this, "Permissions granted!", Toast.LENGTH_SHORT).show();

        goSdk.scanForReaders(activity, new GoSdkCallback<ReaderInfo>() {
            @Override
            public void onNext(ReaderInfo readerInfo) {
                //This callback will hit for every device found
                //Once you found the device you want to connect to, call the line below
                goSdk.connect(readerInfo);
            }

            @Override
            public void onError(@NonNull Throwable throwable) {
                //handle error scenario
            }
        });

        goSdk.observeCardReaderStatus(
                activity,
                new GoSdkCallback<CardReaderStatus>() {
                    @Override
                    public void onNext(CardReaderStatus cardReaderStatus) {
                        // Ready status means the updates are done, if any and we are ready to take the payment
                        if (cardReaderStatus instanceof CardReaderStatus.Ready) {
                            PayRequest request = new PayRequest(10000L, true, true, "pay-id", "invoice num", 10L, 1000L, null);
                            goSdk.chargeCardReader(
                                    activity,
                                    request,
                                    new GoSdkCallback<ChargeCardReaderState>() {
                                        @Override
                                        public void onNext(ChargeCardReaderState result) {

```

--------------------------------

### Get Authorization (C#)

Source: https://docs.clover.com/dev/reference/paygetauthorization

C# code to get a single authorization. This example uses HttpClient to make the API request.

```csharp
using (var client = new HttpClient())
{
    client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
    client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", "YOUR_ACCESS_TOKEN");

    var response = await client.GetAsync("https://apisandbox.dev.clover.com/v3/merchants/{mId}/authorizations/{authId}");
    response.EnsureSuccessStatusCode();

    var responseBody = await response.Content.ReadAsStringAsync();
    Console.WriteLine(responseBody);
}
```

--------------------------------

### Create Discount on Order - C# Example

Source: https://docs.clover.com/dev/reference/ordercreatediscount

This C# code provides an example of how to create a discount for an order using the Clover API. It uses HttpClient to send the POST request. Remember to replace placeholders for authentication and IDs.

```csharp
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

public class DiscountCreator
{
    public static async Task CreateDiscountAsync(string mId, string orderId, string accessToken)
    {
        using (var client = new HttpClient())
        {
            client.BaseAddress = new Uri("https://apisandbox.dev.clover.com");
            client.DefaultRequestHeaders.Add("Authorization", $"Bearer {accessToken}");
            client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));

            var requestBody = new { name = "Employee Discount", amount = 500 };
            var jsonBody = System.Text.Json.JsonSerializer.Serialize(requestBody);

            var response = await client.PostAsync($"/v3/merchants/{mId}/orders/{orderId}/discounts", 
                new StringContent(jsonBody, Encoding.UTF8, "application/json"));

            var responseContent = await response.Content.ReadAsStringAsync();
            Console.WriteLine($"Status Code: {response.StatusCode}");
            Console.WriteLine($"Response: {responseContent}");
        }
    }

    // Example usage:
    // public static async Task Main(string[] args)
    // {
    //     await CreateDiscountAsync("{mId}", "{orderId}", "<YOUR_ACCESS_TOKEN>");
    // }
}
```

--------------------------------

### Java PayRequest Example

Source: https://docs.clover.com/dev/docs/manual-entry-payments

Demonstrates how to construct a PayRequest with KeyedInCard details and initiate a charge using the Go SDK. Handles different ChargeCardReaderState outcomes like progress, completion, and errors.

```java
KeyedInCard keyedInCard = new KeyedInCard(
                "123456789012345",
                "123456",
                "1234",
                false,
                CardType.UNKNOWN, //The CardType class contains the available options
                "1234",
                "1234",
                "Clover Go St",
                "12345"
        );
 
PayRequest request = new PayRequest(
                amount,
                capture,
                isFinal,
                externalPaymentID,
                externalreferenceID,
                taxAmount,
                tipAmount,
                keyedInCard
        );
 
goSdk.chargeCardReader(
        activity,
        request,
        new GoSdkCallback<ChargeCardReaderState>() {
            @Override
            public void onNext(ChargeCardReaderState cardReaderState) {
                if (chargeCardReaderState instanceof ChargeCardReaderState.OnReaderPaymentProgress) {
                    Log.d(TAG, "Payment in progress");
                    updateUI(cardReaderState);
                } else if (chargeCardReaderState instanceof ChargeCardReaderState.OnPaymentComplete) {
                    Log.d(TAG, "Payment successful");
                    updateUI(cardReaderState);
                } else if (chargeCardReaderState instanceof ChargeCardReaderState.OnPaymentError) {
                    Log.d(TAG, "Payment failed");
                    updateUI(cardReaderState);
                } else {
                    //Something unexpected happened
                }
            }

            @Override
            public void onError(@NonNull Throwable e) {
                //handle error scenario
            }
        }
);
```

--------------------------------

### Get a Charge Request Example

Source: https://docs.clover.com/dev/docs/get-a-charge

This cURL command demonstrates how to make a GET request to retrieve a specific charge by its ID.

```curl
curl --request GET \
     --url 'https://scl-sandbox.dev.clover.com/v1/charges/6CK2MJSF87X2M' \
     --header 'Accept: application/json'
```

--------------------------------

### Example Customer Activity Implementation

Source: https://docs.clover.com/dev/docs/using-customer-facing-platform

An example of a custom activity using CloverCFPActivityHelper and CloverCFPCommsHelper to handle messages and set results.

```java
public class CustomerActivity extends Activity {
  private CloverCFPActivityHelper activityHelper;
  private CloverCFPCommsHelper commsHelper;

  @Override protected void onCreate(Bundle savedInstance) {
    super.onCreate(savedInstance);
    setContentView(R.layout.activity_customer);

    activityHelper = new CloverCFPActivityHelper(this);
    commsHelper = new CloverCFPCommsHelper(this, getIntent(), new MessageListener(){
        public void onMessage(String payload) {
            // do something with a message from the RemoteDeviceConnector
    
            // RemoteDeviceConnector is requesting the 
            // CustomActivity finishes itself
            if ("FINISH".equals(message)) {
                setResultAndFinish(RESULT_OK, "{\"action\":\"FINISHING\"}");
            }
        }
    });

    String initialPayload = activityHelper.getInitialPayload();
    // do something with the payload
  }
  
  public void clickYes(View view) {
    try {
      sendMessage("{\"action\":\"YES\"}");
    } catch(Exception e) {
      Toast.makeText(this, e.getMessage(), Toast.LENGTH_SHORT);
    }
  }
  public void clickNo(View view) {
    try {
      sendMessage("{\"action\":\"NO\"}");
    } catch(Exception e) {
      Toast.makeText(this, e.getMessage(), Toast.LENGTH_SHORT);
    }
  }
  public void clickDone(View view) {
    activityHelper.setResultAndFinish(RESULT_OK, "{\"action\":\"DONE\"}");
  }
}
```

--------------------------------

### Get Merchant Properties (C#)

Source: https://docs.clover.com/dev/reference/merchantgetmerchantproperties

C# code to get merchant properties. This example assumes the Clover SDK is properly configured.

```csharp
var merchant = new Merchant("{mId}");
merchant.GetMerchantProperties().ContinueWith(task => {
    if (task.IsFaulted) {
        Console.WriteLine(task.Exception);
    } else {
        Console.WriteLine(task.Result);
    }
});
```

--------------------------------

### Get Employee Shift (C#)

Source: https://docs.clover.com/dev/reference/employeegetemployeeshift

C# code for fetching a single employee shift. This example uses HttpClient to perform the GET request.

```csharp
using System;
using System.Net.Http;
using System.Threading.Tasks;

public class GetEmployeeShift
{
    public static async Task Main(string[] args)
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", "YOUR_ACCESS_TOKEN");
            var response = await client.GetAsync("https://apisandbox.dev.clover.com/v3/merchants/mId/employees/empId/shifts/shiftId");
            var responseString = await response.Content.ReadAsStringAsync();
            Console.WriteLine(responseString);
        }
    }
}
```

--------------------------------

### Get All Inventory Items (C#)

Source: https://docs.clover.com/dev/reference/inventorygetitems

This C# example demonstrates fetching all inventory items for a merchant using `HttpClient`. It includes query parameters for filtering and expanding the response. Remember to replace `YOUR_ACCESS_TOKEN` and `mId` with your specific values.

```csharp
using (var client = new HttpClient())
{
    client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_ACCESS_TOKEN");
    client.DefaultRequestHeaders.Add("Accept", "application/json");
    var response = await client.GetAsync("https://apisandbox.dev.clover.com/v3/merchants/mId/items?filter=lowStock&expand=tags,categories,taxRates,modifierGroups,itemStock,options,ageRestricted&offset=0&limit=1000");
    var responseBody = await response.Content.ReadAsStringAsync();
    Console.WriteLine(responseBody);
}
```

--------------------------------

### Get Client IP Address in Node.js

Source: https://docs.clover.com/dev/docs/new-required-header-for-clover-ecommerce-charge-and-order-pay-requests

This Node.js example uses Express to get the client's IP address from the request socket.

```javascript
const express = require('express');
const app = express();

app.get('/',function(req, res) {
    const ipAddress = req.socket.remoteAddress;
    res.send(ipAddress);
       });
```

--------------------------------

### Get Tip Suggestions (Node.js)

Source: https://docs.clover.com/dev/reference/merchantgettipsuggestions

This Node.js example demonstrates how to fetch tip suggestions for a merchant. Ensure you have the necessary authentication token.

```javascript
const https = require('https');

const options = {
  hostname: 'apisandbox.dev.clover.com',
  port: 443,
  path: '/v3/merchants/{mId}/tip_suggestions',
  method: 'GET',
  headers: {
    'Accept': 'application/json',
    'Authorization': 'Bearer <YOUR_ACCESS_TOKEN>'
  }
};

const req = https.request(options, (res) => {
  console.log('statusCode:', res.statusCode);
  res.on('data', (d) => {
    process.stdout.write(d);
  });
});

req.on('error', (e) => {
  console.error(e);
});

req.end();
```

--------------------------------

### Get Category in Swift

Source: https://docs.clover.com/dev/reference/categorygetcategory

Swift example for making a GET request to fetch category data. This demonstrates basic URLSession usage for API calls.

```swift
import Foundation

let url = URL(string: "https://apisandbox.dev.clover.com/v3/merchants/{mId}/categories/{catId}")
var request = URLRequest(url: url!)
request.httpMethod = "GET"
request.setValue("application/json", forHTTPHeaderField: "accept")
request.setValue("Bearer YOUR_ACCESS_TOKEN", forHTTPHeaderField: "authorization")

let task = URLSession.shared.dataTask(with: request) {
    data, response, error in
    if let data = data {
        let str = String(data: data, encoding: .utf8)
        print(str ?? "")
    } else if let error = error {
        print("Error: \(error.localizedDescription)")
    }
}
task.resume()
```

--------------------------------

### Get Merchant Devices (Java)

Source: https://docs.clover.com/dev/reference/devicegetmerchantdevices

This Java example uses the OkHttp library to fetch merchant devices. Replace `{mId}` and `YOUR_ACCESS_TOKEN` with your specific values.

```java
OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
Request request = new Request.Builder()
  .url("https://apisandbox.dev.clover.com/v3/merchants/{mId}/devices")
  .get()
  .addHeader("accept", "application/json")
  .addHeader("authorization", "Bearer YOUR_ACCESS_TOKEN")
  .build();
Response response = client.newCall(request).execute();
```

--------------------------------

### Create Customer Email Address (Java)

Source: https://docs.clover.com/dev/reference/customerscreatecustomeremailaddress

This Java example demonstrates how to create an email address for a customer using the OkHttp library. Ensure you have OkHttp added to your project dependencies. Replace placeholders with your actual merchant ID, customer ID, and access token.

```java
import okhttp3.*;
import java.io.IOException;

public class CreateCustomerEmailAddress {

    public static void main(String[] args) throws IOException {
        String mId = "YOUR_MERCHANT_ID";
        String customerId = "YOUR_CUSTOMER_ID";
        String accessToken = "YOUR_ACCESS_TOKEN";
        String emailAddress = "test@example.com";

        OkHttpClient client = new OkHttpClient();

        String json = String.format("{\"emailAddress\": \"%s\"}", emailAddress);

        Request request = new Request.Builder()
            .url(String.format("https://apisandbox.dev.clover.com/v3/merchants/%s/customers/%s/email_addresses", mId, customerId))
            .post(RequestBody.create(json, MediaType.get("application/json; charset=utf-8")))
            .addHeader("Authorization", "Bearer " + accessToken)
            .addHeader("Content-Type", "application/json")
            .build();

        try (Response response = client.newCall(request).execute()) {
            if (!response.isSuccessful()) {
                throw new IOException("Unexpected code " + response);
            }
            System.out.println(response.body().string());
        }
    }
}
```

--------------------------------

### Get Merchant Opening Hours (Java)

Source: https://docs.clover.com/dev/reference/merchantgetallmerchantopeninghours

Java code snippet demonstrating how to call the API to get merchant opening hours. This example uses OkHttp.

```java
OkHttpClient client = new OkHttpClient().newBuilder().build();
Request request = new Request.Builder()
  .url("https://apisandbox.dev.clover.com/v3/merchants/{mId}/opening_hours")
  .addHeader("Authorization", "Bearer <YOUR_ACCESS_TOKEN>")
  .method("GET", null)
  .build();
Response response = client.newCall(request).execute();
```

--------------------------------

### Get Merchant Devices (C#)

Source: https://docs.clover.com/dev/reference/devicegetmerchantdevices

This C# example uses `HttpClient` to retrieve a list of devices provisioned to a merchant. Remember to replace placeholders.

```csharp
using (var client = new HttpClient())
{
    client.BaseAddress = new Uri("https://apisandbox.dev.clover.com");
    client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
    client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", "YOUR_ACCESS_TOKEN");

    HttpResponseMessage response = await client.GetAsync($"/v3/merchants/{{mId}}/devices");
    response.EnsureSuccessStatusCode();
    var responseBody = await response.Content.ReadAsStringAsync();
    Console.WriteLine(responseBody);
}
```

--------------------------------

### Configure Go SDK in Kotlin

Source: https://docs.clover.com/dev/docs/android-clover-go-sdk-quick-start

Set up the Go SDK configuration in Kotlin, including API keys, secrets, and environment settings. This singleton class provides access to the Go SDK instance.

```kotlin
object GoSDKCreator {
 
    // App ApiKey and Secret
    private const val API_KEY = YOUR_API_KEY
    private const val API_SECRET = YOUR_API_SECRET      
    private fun buildConfig(context: Context) = GoSdkConfiguration.Builder(
        context = context,
        appId = BuildConfig.APPLICATION_ID,
        appVersion = "1.0.0",
        apiKey = API_KEY,
        apiSecret = API_SECRET,
        oAuthFlowAppSecret = YOUR_OAUTH_FLOW_APP_SECRET,
        oAuthFlowRedirectURI = YOUR_OAUTH_FLOW_REDIRECT_URI,
        oAuthFlowAppID = YOUR_OAUTH_FLOW_APP_ID,
        environment = GoSdkConfiguration.Environment.SANDBOX,//Available environments are PROD, DEV, STAGING and SANDBOX
        reconnectLastConnectedReader = true
    )
    .build()
 
    private lateinit var goSdkInstance: GoSdk
 
    @JvmStatic
    fun get(context: Context): GoSdk {
        if (!GoSDKCreator::goSdkInstance.isInitialized) {
            goSdkInstance = GoSdkCreator.create(buildConfig(context))
        }
        return goSdkInstance
    }
}
```

--------------------------------

### Get Employee Shift (Swift)

Source: https://docs.clover.com/dev/reference/employeegetemployeeshift

Example of how to get a single employee shift using Swift. This code demonstrates making a network request to the Clover API.

```swift
let url = URL(string: "https://apisandbox.dev.clover.com/v3/merchants/mId/employees/empId/shifts/shiftId")!
var request = URLRequest(url: url)
request.httpMethod = "GET"
request.setValue("Bearer YOUR_ACCESS_TOKEN", forHTTPHeaderField: "Authorization")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let error = error {
        print("Error: \(error)")
        return
    }
    if let httpResponse = response as? HTTPURLResponse {
        print("Status code: \(httpResponse.statusCode)")
    }
    if let data = data {
        if let json = try? JSONSerialization.jsonObject(with: data, options: []) as? [String: Any] {
            print(json)
        }
    }
}
task.resume()
```

--------------------------------

### Get All Attributes

Source: https://docs.clover.com/dev/reference/inventorygetattributes

Retrieves item attributes, for example: size and color of a t-shirt.

```APIDOC
## GET /v3/merchants/{mId}/attributes

### Description
Retrieves item attributes, for example: size and color of a t-shirt.

### Method
GET

### Endpoint
/v3/merchants/{mId}/attributes

### Parameters
#### Path Parameters
- **mId** (string) - Required - Merchant identifier.

#### Query Parameters
- **filter** (string) - Optional - Filter fields to display search results: [modifiedTime, name, id, deletedTime, itemGroup.id]
- **offset** (integer) - Optional - Position of the first line item returned in the search results. Indicates the number of line items that are excluded from the search results.
- **limit** (integer) - Optional - Maximum number of line items returned in the search result. Default: 100. Maximum limit: 1000

### Responses
#### Success Response (200)
- **id** (string) - Unique identifier of the attribute.
- **name** (string) - Attribute name.
- **itemGroup** (object) - Reference to an item group.
  - **id** (string) - Unique identifier of the item group.
- **options** (array) - List of variants (options) available within an attribute. For example, an attribute of size can have small, medium, and large options.
  - **id** (string) - Unique identifier of the variant option.
  - **name** (string) - Variant option name.
  - **attribute** (object)
    - **id** (string) - Unique identifier of the attribute.
  - **items** (array) - List of items associated with the attribute.
    - **id** (string) - Unique identifier of the item.
```

--------------------------------

### Create Customer Address (Node.js)

Source: https://docs.clover.com/dev/reference/customerscreatecustomeraddress

This Node.js example demonstrates how to create a customer address. Ensure you have the necessary authentication token and replace placeholder IDs.

```javascript
const axios = require('axios');

const merchantId = 'YOUR_MERCHANT_ID';
const customerId = 'YOUR_CUSTOMER_ID';
const accessToken = 'YOUR_ACCESS_TOKEN';

const addressData = {
  address1: '123 Main St',
  city: 'Anytown',
  country: 'US',
  state: 'CA',
  zip: '90210'
};

axios.post(`https://apisandbox.dev.clover.com/v3/merchants/${merchantId}/customers/${customerId}/addresses`, addressData, {
  headers: {
    'Authorization': `Bearer ${accessToken}`,
    'Content-Type': 'application/json'
  }
})
.then(response => {
  console.log('Address created successfully:', response.data);
})
.catch(error => {
  console.error('Error creating address:', error.response ? error.response.data : error.message);
});
```

--------------------------------

### Get All Tax Rates (JavaScript)

Source: https://docs.clover.com/dev/reference/taxrategettaxrates

This JavaScript example shows how to make a GET request to retrieve all tax rates for a merchant. Replace `{mId}` and `YOUR_ACCESS_TOKEN` with your actual values.

```javascript
fetch('https://apisandbox.dev.clover.com/v3/merchants/{mId}/tax_rates', {
  method: 'GET',
  headers: {
    'accept': 'application/json',
    'Authorization': 'Bearer YOUR_ACCESS_TOKEN'
  }
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));
```