INTRODUCTION

{
  "title": "User ",
  "type": "object",
  "properties": {
    "custom_name": {
      "type": "string",
      "pattern": "^[a-zA-Z\\s\\d]{0,35}$",
      "description": "Only characters, numbers, spaces and max length 35"
    }
  },
  "additionalProperties": false,
  "description": "additionalProperties means that no new property can be created .... Data updated as whole object will overwrite whole set in database. Required property needs to be specified. Pattern is pattern in regex"
}

const API = {
    async getFetch(params) {
      const method = params.method
      const body = params.body
      const public_key = "YOUR-PUBLIC-KEY";
      const private_key = "YOUR-PRIVATE-KEY";
      const baseurl = "https://api.fieldclimate.com/v2";
      const timestamp = new Date().toUTCString(); 
      const content_to_sign = params.method + params.request + timestamp + public_key;
      const signature = CryptoJS.HmacSHA256(content_to_sign, private_key);
      const hmac_str = 'hmac ' + public_key + ':' + signature;
      const url = baseurl + params.request;
      const parameters = {
          headers:{
              "Accept":"application/json",
              "Authorization": hmac_str,
              "Request-Date": timestamp,
          },
          method,
          body
      };
  
      return await fetch(url, parameters)
          .then(data => { return data.json() })
          .then((resp) => {
              return resp;
          })
          .catch(error => console.log(error))
    },
      getStations() {
          let params = {
              "method" : "GET",
              "request": "/user/"
          }
          API.getFetch(params)
          .then((result) => {
              result.map((userData, key) => {
                  console.log(userData);
              })
          })
      },
  }
  

package com.company;

import org.apache.commons.codec.binary.Hex;
import org.apache.http.HttpEntity;
import org.apache.http.HttpHeaders;
import org.apache.http.HttpHost;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.client.methods.RequestBuilder;
import org.apache.http.client.utils.DateUtils;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.ConnectTimeoutException;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.TrustSelfSignedStrategy;
import org.apache.http.conn.ssl.TrustStrategy;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.protocol.HttpContext;
import org.apache.http.ssl.SSLContextBuilder;
import org.apache.http.ssl.SSLContexts;
import org.apache.http.util.EntityUtils;

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocket;
import javax.net.ssl.SSLSocketFactory;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.InvocationTargetException;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.security.GeneralSecurityException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.Date;

    public class HMacExample {

        public static void main(String[] args) throws IOException, GeneralSecurityException {

            String publicKey = "YOUR PUBLIC HMAC KEY";
            String privateKey = "YOUR PRIVATE HMAC KEY";

            SSLContextBuilder builder = new SSLContextBuilder();
            builder.loadTrustMaterial(null, new TrustStrategy() {
                    @Override
                    public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException {
                    return true;
                }
            });

            SSLConnectionSocketFactory sslSF = new SSLConnectionSocketFactory(builder.build(),
            SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);

            HttpClient client = HttpClients.custom().setSSLSocketFactory(sslSF).build();

            String method = "GET";
            String path = "/data/SPECIFY YOUR STATION ID/raw/last/5";
            // Creating date in appropriate format (RFC 1123) that is accepted by http header; apache http client library is used
            String date = DateUtils.formatDate(new Date(System.currentTimeMillis()));

            String contentToSign = method + path + date + publicKey;

            String signature = generateHmacSHA256Signature(contentToSign, privateKey);
            String authorizationString = "hmac " + publicKey + ":" + signature;

            // Creating request by using RequestBuilder from apache http client library; headers are set in this step as well
            HttpUriRequest request = RequestBuilder.get().setUri("https://api.fieldclimate.com/THIS-VERSION" + path)
            .setHeader(HttpHeaders.ACCEPT, "application/json")
            .setHeader(HttpHeaders.AUTHORIZATION, authorizationString)
            .setHeader(HttpHeaders.DATE, date).build();

            HttpResponse response = client.execute(request);
            HttpEntity entity = response.getEntity();
            System.out.println(response.getStatusLine());

            //EntityUtils.consume(entity);
            String responseString = EntityUtils.toString(entity, "UTF-8");
            System.out.println(responseString);
    }

    // Static method that generates HmacSHA256 signiture as a hexademical string
    public static String generateHmacSHA256Signature(String data, String key) throws GeneralSecurityException {
        byte[] hmacData = null;

        try
        {
            SecretKeySpec secretKey = new SecretKeySpec(key.getBytes("UTF-8"), "HmacSHA256");
            Mac mac = Mac.getInstance("HmacSHA256");
            mac.init(secretKey);
            return Hex.encodeHexString(mac.doFinal(data.getBytes("UTF-8")));

        } catch (UnsupportedEncodingException e) {
            throw new GeneralSecurityException(e);
        }
    }
}

import requests
from requests.auth import AuthBase
from Crypto.Hash import HMAC
from Crypto.Hash import SHA256
from datetime import datetime,
from dateutil.tz import tzlocal


# Class to perform HMAC encoding
class AuthHmacMetosGet(AuthBase):
    # Creates HMAC authorization header for Metos REST service GET request.
    def __init__(self, apiRoute, publicKey, privateKey):
        self._publicKey = publicKey
        self._privateKey = privateKey
        self._method = 'GET'
        self._apiRoute = apiRoute

    def __call__(self, request):
        dateStamp = datetime.utcnow().strftime('%a, %d %b %Y %H:%M:%S GMT')
        print("timestamp: ", dateStamp)
        request.headers['Date'] = dateStamp
        msg = (self._method + self._apiRoute + dateStamp + self._publicKey).encode(encoding='utf-8')
        h = HMAC.new(self._privateKey.encode(encoding='utf-8'), msg, SHA256)
        signature = h.hexdigest()
        request.headers['Authorization'] = 'hmac ' + self._publicKey + ':' + signature
        return request


# Endpoint of the API, version for example: v1
apiURI = 'https://api.fieldclimate.com/ENTER-VERSION'

# HMAC Authentication credentials
publicKey = 'PROVIDED BY SERVICE PROVIDER'
privateKey = 'PROVIDED BY SERVICE PROVIDER'

# Service/Route that you wish to call
apiRoute = '/user'

auth = AuthHmacMetosGet(apiRoute, publicKey, privateKey)
response = requests.get(apiURI+apiRoute, headers={'Accept': 'application/json'}, auth=auth)
print(response.json())

Tested and working with following:
- Python 2.7
- Python 3.5

python-dateutil==2.7.2
pycrypto==2.6.1
requests==2.18.4

require 'net/http'
require 'digest/hmac'
require 'time'

# User public and private key
public_key = 'PROVIDED BY SERVICE PROVIDER';
private_key = 'PROVIDED BY SERVICE PROVIDER';

# Define the request parameters
method = 'GET';
call = '/data/{STATION-ID}/raw/last/5';
now = Time.now.httpdate # Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

# Concatenate the request into single string
content_to_sign = method + call + now + public_key

# Calc
ulate signature
signature = Digest::HMAC.hexdigest(content_to_sign, private_key, Digest::SHA256)

# Prepare and make http request
url = URI.parse('https://api.fieldclimate.com/THIS-VERSION' + call)
request = Net::HTTP::Get.new(url.to_s)

# Add required headers
request['Accept'] = 'application/json'

# Authorization: hmac public_key:signature
# Date: Wed, 25 Nov 2014 12:45:26 GMT
request['Authorization'] = 'hmac ' + public_key + ':' + signature
request['Date'] = now

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE
response = http.request(request)

# Parse response as json and work on it
# ...
# ...

# output response
puts response.body

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using System.Threading.Tasks;


namespace Demo.Metos.API
{
    internal class Program
    {
        /// 

        /// Just executes the async function and waits until ready
        /// 
        /// 
        private static void Main(string[] args)
        {
            RunAsync().Wait();
        }

        /// 

        /// The asynchronous function prepares the HTTP client hander, 
        /// calls the API and processes the response.
        /// 
        /// Task
        private static async Task RunAsync()
        {
            var httpHandler = new MetosHttpHandler(new HttpClientHandler());
            httpHandler.PublicKey = "ENTER YOUR public HMAC key";
            httpHandler.PrivateKey = "ENTER YOUR private HMAC key";
            var httpClient = new HttpClient(httpHandler) { BaseAddress = httpHandler.ApiUri };
            httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
            
            var response = await httpClient.GetAsync("/user/stations");
 
            Console.WriteLine("Status {0}:{1} \n", response.StatusCode, await response.Content.ReadAsStringAsync());
        }
    }

    /// 

    /// Custom HTTP handler with required setters
    /// 
    public class MetosHttpHandler : DelegatingHandler
    {
        private static readonly CultureInfo _enUsCulture = new CultureInfo("en-us");
        private static readonly Uri _apiBaseAddress = new Uri("https://api.fieldclimate.com/v1");

        /// 

        /// FieldClimate account: public HMAC key to access METOS station data and services 
        /// 
        public string PublicKey { get; set; }

        /// 

        /// FieldClimate account: private HMAC key to access METOS station data and services 
        /// 
        public string PrivateKey { get; set; }

        /// 

        /// Defaults to https://api.fieldclimate.com/v1
        /// 
        public Uri ApiUri { get; set; }

        /// 

        /// Default initialization
        /// 
        /// 
        public MetosHttpHandler(HttpMessageHandler handler)
        {
            base.InnerHandler = handler;
            ApiUri = _apiBaseAddress;
        }

        /// 

        /// Provides custom HTTP header modification
        /// 
        /// 
        /// 
        /// 
        protected override async Task SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            HttpResponseMessage response = null;

            // recover missing version part (e.g. /v1)
            var requestRoute = request.RequestUri.AbsolutePath;
            string combinedPath = ApiUri.AbsolutePath + requestRoute;
            request.RequestUri = new Uri(ApiUri, combinedPath);
            // adjust HTTP authorization header
            var requestHttpMethod = request.Method.Method;
            var date = DateTimeOffset.UtcNow;
            request.Headers.Date = date;
            var requestTimeStamp = date.ToString("ddd, dd MMM yyyy HH:mm:ss 'GMT'", _enUsCulture);
            var signatureRawData = $"{requestHttpMethod}{requestRoute}{requestTimeStamp}{PublicKey}";
            var privateKeyByteArray = Encoding.UTF8.GetBytes(PrivateKey);
            var signature = Encoding.UTF8.GetBytes(signatureRawData);
            using (var hmac = new HMACSHA256(privateKeyByteArray))
            {
                var signatureBytes = hmac.ComputeHash(signature);
                var requestSignatureString = ByteArrayToString(signatureBytes);
                request.Headers.Authorization = new AuthenticationHeaderValue("hmac",
                    $"{PublicKey}:{requestSignatureString}");
            }

            response = await base.SendAsync(request, cancellationToken);
            return response;
        }

        /// 

        /// Helper function to produce a hex string
        /// 
        /// 
        /// 
        private static string ByteArrayToString(IReadOnlyCollection ba)
        {
            var hex = new StringBuilder(ba.Count * 2);
            foreach (var b in ba)
                hex.AppendFormat("{0:x2}", b);
            return hex.ToString();
        }
    }
}

import 'dart:async';
import 'dart:convert';

import 'package:http/http.dart' as http;
import 'package:crypto/crypto.dart';
import 'package:intl/intl.dart';

void main() {
    String publicKey = "YOUR-PUBLIC-KEY";
    String privateKey = "YOUR-PRIVATE-KEY";
    String method = "GET";
    String path = "/user";
    var f = DateFormat('EEE, dd MMM yyyy HH:mm:ss');
    var date = "${f.format(DateTime.now().toUtc())} GMT";
    String contentToSign = '$method$path$date$publicKey';
    var key = utf8.encode(privateKey);
    var bytesG = utf8.encode(contentToSign);
    var hmacSha256 = Hmac(sha256, key);
    var digest = hmacSha256.convert(bytesG);
    var signature = digest;
 
    String authorizationString = "hmac $publicKey:$signature";
    fetchAlbum(authorizationString, date);
}

Future fetchAlbum(authorizationString, date) async {
  String collection;
  Map headers = {
    "Content-type": "application/json",
    "Accept": "application/json",
    "Authorization": authorizationString,
    "Request-Date": date
    };
  // CONNECT WITH USER ENDPOINT
  var request = await http.Request('GET',Uri.parse('https://api.fieldclimate.com/v2/user'));
  request.headers.addAll(headers);
 
  http.StreamedResponse streamedResponse = await request.send();
  var response = await http.Response.fromStream(streamedResponse);
  print(response.body);
}

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/system/status";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/system/sensors";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/system/groups";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/system/group/sensors";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/system/types";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/system/countries";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/system/timezones";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/system/diseases";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/user";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

{
  "title": "User Update",
  "description" : "Update user information",
  "type": "object",
  "properties": {
    "username": {
      "type": "string",
      "pattern": "(*UTF8)^[[:alnum:]]+(?:[-_ ]?[[:alnum:]]+)*$",
      "description": "Chars, Numbers, space, _, - but no other special chars"
    },
    "password": {
      "type": "string",
      "description": "Password"
    },
    "info.name": {
      "type": "string"
    },
    "info.lastname": {
      "type": "string"
    },
    "info.title": {
      "type": "string"
    },
    "info.email": {
      "type": "string"
    },
    "info.phone": {
      "type": "string"
    },
    "info.cellphone": {
      "type": "string"
    },
    "info.fax": {
      "type": "string"
    },
    "company": {
      "type": "object",
      "properties": {
        "name": {
          "type": "string"
        },
        "profession": {
          "type": "string"
        },
        "department": {
          "type": "string"
        },
        "customer_id": {
          "type": "integer"
        },
        "vat_id": {
          "type": "string"
        }
      },
      "required": [
        "name"
      ],
      "additionalProperties": false,
      "description": "Data updated as whole object will overwrite whole set in database"
    },
    "address.street": {
      "type": "string"
    },
    "address.city": {
      "type": "string"
    },
    "address.district": {
      "type": "string"
    },
    "address.zip": {
      "type": "string"
    },
    "address.country": {
      "type": "string"
    },
    "settings.language": {
      "type": "string",
      "pattern": "^[a-z]{2,2}$",
      "description": "Language has to be in ISO 639-1 format"
    },
    "settings.newsletter": {
      "type": "boolean",
      "description": "Wanna receive newsletter"
    },
    "settings.unit_system": {
      "type": "string",
      "enum": ["metric", "imperial"],
      "description": "Must be one of metric, imperial"
    }
  },
  "additionalProperties": false
}

{
    "username" :"",
    "password" : "",
    "info.name" : "",
    "info.lastname": "",
    "info.title": "",
    "info.email": "",
    "info.phone": "",
    "info.cellphone": "",
    "info.fax": "",
    "company": {
        "name": "",
        "profession": "",
        "department": "",
        "customer_id": "",
        "vat_id": ""
    },
    "address.street": "",
    "address.city": "",
    "address.district": "",
    "address.zip": "",
    "address.country": "",
    "settings.unit_system" : ""
    "settings.language": "",
    "settings.newsletter": "",
    "settings.unit_system": "",
}

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/user/stations";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/user/licenses";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
"Accept: application/json",
"Authorization: hmac {$public_key}:{$signature}",
"Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/station/{{STATION-ID}}";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

{
  "title": "Station Update",
  "description" : "Update station configuration",
  "type": "object",
  "properties": {
    "name": {
      "type": "string"
    },
    "position": {
      "type": "object",
      "properties": {
        "geo": {
          "type": "object",
          "properties": {
            "coordinates": {
              "type": "array",
              "items": {
                "type": "number"
              },
              "minItems": 2,
              "maxItems": 2
            }
          },
          "required": [
            "coordinates"
          ]
        },
        "altitude": {
          "type": "number"
        },
        "timezoneCode": {
          "type": "string",
          "description": "Timezone code, has priority over timezone offset as it is more informative and can be used for DST auto-adjust"
        }
      },
      "required": [
        "geo",
        "altitude"
      ]
    },
    "config.timezone": {
      "type": "integer",
      "minimum": -720,
      "maximum": 840,
      "description": "Timezone in minutes. GMT + 1 = 60"
    },
    "config.precision_reduction": {
      "type": "number",
      "description": "Precision reduction (0.1, 0.2, 0.5, 1). Rain gauge resolution."
    },
    "config.activity_mode": {
      "type": "integer",
      "minimum": 0,
      "maximum": 2,
      "description": "0 = Station is gathering and sending data, 1 = Station is gathering but not sending data, 2 = Station is not gathering and not sending data"
    },
    "config.monitor.water_level": {
      "type": "integer",
      "minimum": 0,
      "maximum": 1,
      "description": "Water level monitoring 0 (Off), 1(On)"
    },
    "config.monitor.rain": {
      "type": "integer",
      "minimum": 0,
      "maximum": 1,
      "description": "Rain monitoring 0 (Off), 1 (On)"
    },
    "config.interval.logging": {
      "type": "integer",
      "minimum": 15,
      "maximum": 120,
      "description": "Logging interval (Intervals  = 15,30,60,120 minutes). Used for data grouping and aggregations."
    },
    "config.interval.measurement": {
      "type": "object",
      "patternProperties": {
        "^[0-9]\\d*$": {
          "type": "integer",
          "minimum": 1,
          "maximum": 60
        }
      },
      "additionalProperties": false,
      "description": "Measurement interval (sampling) 5 min by default for all stations. Per chain measurement interval only for EcoD3 and Metos 3.3 stations ( intervals are 5, 15, 30, 60 minutes but need to be less then logging interval)."
    },
    "config.upload.scheduler": {
      "type": "string",
      "description": "Schedule transfer data to server. 24h schedule format = 100000000000000000000001 (0 = Not sending, 1 = Sending). Example is transferring data at 01:00 and 24:00."
    },
    "config.upload.transfer_fixed": {
      "type": "integer",
      "description": "Only for iMetos 3.3, iMetos Eco D3 and iMetos Eco D2 fixed transfer interval 15 min. 0 (Off) or 1 (On)."
    },
    "config.cam1.active": {
      "type": "integer",
      "description": "Only for CropVIEW stations - Camera On/Off switch (1/0)"
    },
    "config.cam2.active": {
      "type": "integer",
      "description": "Only for CropVIEW stations - Camera On/Off switch (1/0)"
    },
    "config.cam1.auto_exposure": {
      "type": "integer",
      "description": "Only for CropVIEW stations - Automatic/Manual exposure (1/0)"
    },
    "config.cam2.auto_exposure": {
      "type": "integer",
      "description": "Only for CropVIEW stations - - Automatic/Manual exposure (1/0)"
    },
    "config.cam1.brightness_ref": {
      "type": "integer",
      "description": "Only for CropVIEW stations - Brightness reference for automatic exposure (default: 750)"
    },
    "config.cam2.brightness_ref": {
      "type": "integer",
      "description": "Only for CropVIEW stations - Brightness reference for automatic exposure (default: 750)"
    },
    "config.cam1.global_gain": {
      "type": "integer",
      "description": "Only for CropVIEW stations - Global gain for manual exposure (default: 6208)"
    },
    "config.cam2.global_gain": {
      "type": "integer",
      "description": "Only for CropVIEW stations - Global gain for manual exposure (default: 6208)"
    },
    "config.cam1.integration_time": {
      "type": "integer",
      "description": "Only for CropVIEW stations - Integration time for manual exposure (default: 1000)"
    },
    "config.cam2.integration_time": {
      "type": "integer",
      "description": "Only for CropVIEW stations - Integration time for manual exposure (default: 1000)"
    },
    "config.cam1.max_integration_time": {
      "type": "integer",
      "description": "Only for CropVIEW stations - Maximal integration time for automatic exposure (default: 2300)"
    },
    "config.cam2.max_integration_time": {
      "type": "integer",
      "description": "Only for CropVIEW stations - Maximal integration time for automatic exposure (default: 2300)"
    },
    "config.cam1.square_spots": {
      "type": "integer",
      "description": "Only for CropVIEW stations - 8 bit converted to dec (8 bits = 8 measure points)"
    },
    "config.cam2.square_spots": {
      "type": "integer",
      "description": "Only for CropVIEW stations - 8 bit converted to dec (8 bits = 8 measure points)"
    },
    "warnings.sms_numbers": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "num": {
            "type": "string"
          },
          "name": {
            "type": "string"
          },
          "active": {
            "type": "boolean"
          }
        }
      },
      "description": "List of phone numbers that receive a text message upon warning alert (if a phone number is not active it will not receive the warning message)."
    },
    "warnings.sensors": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Warning sensors values: array of strings => 'sensor channel, sensor code, minmax(0/1), value'"
    }
  },
  "additionalProperties": false
}

{
  "name" : "",
  "position": {
    "geo": {
      "coordinates": [
		11.030232,
		45.480726
      ]
    },
    "altitude": 84
  },
  "config.timezone" : 120,
  "config.precision_reduction" : 0.2,
  "config.activity" : 0,
  "config.monitor.water_level" : 0,
  "config.monitor.rain" : 0,
  "config.interval.logging" : 60,
  "config.interval.measurement" : {
    "0": 5,
    "1" : 5,
    "2" : 5
  },
  "config.upload.scheduler" : "111111111111111111111111",
  "config.upload.transfer_fixed" : 0,
  "warnings.sensors" : [
	"1,143,0,5.6",
	"2,600,0,105.80",...
  ]
}

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/station/{{STATION-ID}}/sensors";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

{
  "title": "Station sensor update",
  "description" : "Update specific sensor of a station",
  "type": "object",
  "properties": {
    "name": {
      "type": "string"
    },
    "channel": {
      "type": "integer"
    },
    "code": {
      "type": "integer"
    },
    "color": {
      "type": "string",
      "description": "Format has to be in HEX"
    },
    "unit": {
      "type": "string"
    }
  },
  "required": [
    "channel",
    "code",
    "unit",
    "color"
  ],
  "additionalProperties": false
}

{
    "name"  : "New sensor name",
    "channel" : "SENSOR-CHANNEL",
    "code" : "SENSOR-CODE",
    "color" : "#000"
}

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/station/{{STATION-ID}}/nodes";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

{
  "title": "Node update",
  "description": "Update the name of a node. Node is wireless device connected to base station.",
  "type": "object",
  "properties": {
    "name": {
      "type": "string"
    },
    "mac": {
      "type": "string",
      "description": "MAC address or Station ID as X (X indicates default station)"
    }
  },
  "required": [
    "name",
    "mac"
  ],
  "additionalProperties": false
}

{
    "name" : "New node name",
    "mac"  : "MAC-ADDRESS-OF-A-NODE"
}

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/station/{{STATION-ID}}/serials";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

{
  "title": "Sensor serial update",
  "description" : "Update sensor serial",
  "type": "object",
  "properties": {
    "name": {
      "type": "string"
    },
    "serial": {
      "type": "string",
      "description": "If there is none put X"
    }
  },
  "required": [
    "name",
    "serial"
  ],
  "additionalProperties": false
}

{
 "name": "New serial name",
 "serial" : "SENSOR-SERIAL"
}

{
  "title": "User station insert",
  "description" : "Add a station to an user",
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "pattern": "^[a-zA-Z\\s\\d]{0,35}$",
      "description": "Only characters, numbers, spaces and max length 35"
    }
  },
  "additionalProperties": false
}

{
    "name" : "Custom name of a station"
}

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/station/{{STATION-ID}}/proximity/{{RADIUS}}";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/station/{{STATION-ID}}/events/last/{{AMOUNT}}/{{SORT}}";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/station/{{STATION-ID}}/events/from/{{FROM-UNIX-TIMESTAMP}}/to/{{TO-UNIX-TIMESTAMP}}/{{SORT}}";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/station/{{STATION-ID}}/history/{{FILTER}}/last/{{AMOUNT}}/{{SORT}}";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;
s
// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/station/{{STATION-ID}}/history/{{FILTER}}/from/{{FROM-UNIX-TIMESTAMP}}/to/{{TO-UNIX-TIMESTAMP}}/{{SORT}}";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;
s
// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/station/{{STATION-ID}}/licenses";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/station/{{STATION-ID}}/nodes";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

{
  "properties": {
    "description": "Pre-defined, combined or custom name",
    "name": {
      "type": "string"
    },
    "sensors": {
      "properties": {
        "filter": {
          "description": "Filter by group, sensor, mac or serial and optionally specify aggregation",
          "properties": {
            "group-7": {
              "items": {
                "type": "string"
              },
              "type": "array",
              "enum": [
                "avg",
                "min",
                "max",
                "sum",
                "time",
                "last",
                "user"
              ]
            },
            "mac-MAC_ADDRESS": {
              "type": "boolean"
            },
            "sensor-506": {
              "items": {
                "type": "string"
              },
              "type": "array",
              "enum": [
                "avg",
                "min",
                "max",
                "sum",
                "time",
                "last",
                "user"
              ]
            },
            "serial-SERIAL": {
              "type": "boolean"
            }
          },
          "type": "object"
        },
        "settings": {
          "description": "Configure sensor output",
          "properties": {
            "group-7": {
               "unit": "Custom unit",
               "type": "string"
            },
            "sensor-506": {
               "unit": "Custom unit",
               "type": "string"
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "data": {
      "properties": {
        "model": {
          "description": "Disease model name",
          "type": "string"
        },
        "sunrise_sunset": {
          "description": "Get sunrise and sunset dates for specified period",
          "type": "boolean"
        },
        "unit_system": {
          "type": "string",
          "description": "One of",
          "enum": [
            "imperial",
            "metric"
          ]
        }
      },
      "type": "object"
    }
  },
  "type": "object"
}

{
  # VIEW NAME: Pre-Defined, Combined, Custom
  "name": "PRE-DEFINED, COMBINED OR CUSTOM ... NAME,
  "sensors": {
    "filter": {
      # Filter out specific sensor
      "sensor-506": 1,
      # Filter out specific sensor and its aggregation
      "sensor-506": [
        "avg"
      ],
      # Filter out specific sensors of a group
      "group-7": 1,
      # Filter out specific sensors of a group and its aggragation
      "group-7": [
        "avg"
      ],
      # Filter out sensors on MAC
      "mac-MAC_ADDRESS": true,
      # Filter out sensors with Serial
      "serial-SERIAL": true
    },
    "settings" : {
       # Configure output of a sensor, by changing the unit manually
       "sensor-506": [
            "unit" : "sec"
       ],
       # Configure output of a sensor group, by changing the unit manually
       "group-7": [
            "unit" : "sec"
       ]
    }
  },
  "data": {
    # UNIT SYSTEM: matric, imperial
    "unit_system": "imperial",
    # Sunrise and sunset dates
    "sunrise_sunset" : true,
    # DISEASE MODEL DATA
    "model": "DISEASE-MODEL"
  }
}

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/data/{{STATION-ID}}";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

# OPTIMIZED - Recommended
# Data can come in several aggravations inside the sensor information AGGR
# Dates come separated from the data but are in the same order
# All other information is sensor related information
# We recommend this format because of its simplicity and output size is smaller then normal one
# 1_X_X_143 tag is = CH_MAC_SERIAL_CODE
{
    "dates": [
        "2017-07-21 05:00:00",
        "2017-07-21 05:15:00",
        "2017-07-21 05:30:00",
        "2017-07-21 05:45:00",
        "2017-07-21 06:00:00"
    ],
    "data": {
        "1_X_X_143": {
            "name": "Wind direction",
            "name_custom": false,
            "decimals": 0,
            "unit": "deg",
            "ch": 1,
            "code": 143,
            "group": 16,
            "serial": "X",
            "mac": "X",
            "vals": {
                "min": 0,
                "max": 360
            },
            "aggr": {
                "avg": [
                    39,
                    117,
                    85,
                    74,
                    74
                ],
                "last": [
                    39,
                    117,
                    85,
                    74,
                    74
                ]
            },
            "registered": "2017-06-30 18:00:00"
        },
        "2_X_X_600": {
            "name": "Solar radiation",
            "name_custom": false,
            "decimals": 0,
            "unit": "W/m2",
            "ch": 2,
            "code": 600,
            "group": 4,
            "serial": "X",
            "mac": "X",
            "vals": {
                "min": 0,
                "max": 32767
            },
            "aggr": {
                "avg": [
                    0,
                    0,
                    0,
                    0,
                    0
                ]
            },
            "registered": "2017-06-30 18:00:00"
        },...
}

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/data/{{FORMAT}}/{{STATION-ID}}/{{DATA-GROUP}}/last/{{TIME-PERIOD}}";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

# OPTIMIZED - Recommended
# Data can come in several aggravations inside the sensor information AGGR
# Dates come separated from the data but are in the same order
# All other information is sensor related information
# We recommend this format because of its simplicity and output size is smaller then normal one
# 1_X_X_143 tag is = CH_MAC_SERIAL_CODE
{
    "dates": [
        "2017-07-21 05:00:00",
        "2017-07-21 05:15:00",
        "2017-07-21 05:30:00",
        "2017-07-21 05:45:00",
        "2017-07-21 06:00:00"
    ],
    "data": {
        "1_X_X_143": {
            "name": "Wind direction",
            "name_custom": false,
            "decimals": 0,
            "unit": "deg",
            "ch": 1,
            "code": 143,
            "group": 16,
            "serial": "X",
            "mac": "X",
            "vals": {
                "min": 0,
                "max": 360
            },
            "aggr": {
                "avg": [
                    39,
                    117,
                    85,
                    74,
                    74
                ],
                "last": [
                    39,
                    117,
                    85,
                    74,
                    74
                ]
            },
            "registered": "2017-06-30 18:00:00"
        },
        "2_X_X_600": {
            "name": "Solar radiation",
            "name_custom": false,
            "decimals": 0,
            "unit": "W/m2",
            "ch": 2,
            "code": 600,
            "group": 4,
            "serial": "X",
            "mac": "X",
            "vals": {
                "min": 0,
                "max": 32767
            },
            "aggr": {
                "avg": [
                    0,
                    0,
                    0,
                    0,
                    0
                ]
            },
            "registered": "2017-06-30 18:00:00"
        },...
}

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/data/{{FORMAT}}/{{STATION-ID}}/{{DATA-GROUP}}/from/{{FROM-UNIX-TIMESTAMP}}/to/{{TO-UNIX-TIMESTAMP}}";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

# OPTIMIZED - Recommended
# Data can come in several aggravations inside the sensor information AGGR
# Dates come separated from the data but are in the same order
# All other information is sensor related information
# We recommend this format because of its simplicity and output size is smaller then normal one
# 1_X_X_143 tag is = CH_MAC_SERIAL_CODE
{
    "dates": [
        "2017-07-21 05:00:00",
        "2017-07-21 05:15:00",
        "2017-07-21 05:30:00",
        "2017-07-21 05:45:00",
        "2017-07-21 06:00:00"
    ],
    "data": {
        "1_X_X_143": {
            "name": "Wind direction",
            "name_custom": false,
            "decimals": 0,
            "unit": "deg",
            "ch": 1,
            "code": 143,
            "group": 16,
            "serial": "X",
            "mac": "X",
            "vals": {
                "min": 0,
                "max": 360
            },
            "aggr": {
                "avg": [
                    39,
                    117,
                    85,
                    74,
                    74
                ],
                "last": [
                    39,
                    117,
                    85,
                    74,
                    74
                ]
            },
            "registered": "2017-06-30 18:00:00"
        },
        "2_X_X_600": {
            "name": "Solar radiation",
            "name_custom": false,
            "decimals": 0,
            "unit": "W/m2",
            "ch": 2,
            "code": 600,
            "group": 4,
            "serial": "X",
            "mac": "X",
            "vals": {
                "min": 0,
                "max": 32767
            },
            "aggr": {
                "avg": [
                    0,
                    0,
                    0,
                    0,
                    0
                ]
            },
            "registered": "2017-06-30 18:00:00"
        },...
}

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method  = "POST";
$request = "/data/{{FORMAT}}/{{STATION-ID}}/{{DATA-GROUP}}/last/{{TIME-PERIOD}}";

// Body that you send needs to be JSON schema validated
$body    = [
    "sensors" => [
        "filter" => [
            "sensor-506" => TRUE
        ]
    ]
];
$body = json_encode( $body );

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt( $ch, CURLOPT_POST, TRUE );
curl_setopt( $ch, CURLOPT_POSTFIELDS, $body );

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

{
  "properties": {
    "description": "Pre-defined, combined or custom name",
    "name": {
      "type": "string"
    },
    "sensors": {
      "properties": {
        "filter": {
          "description": "Filter by group, sensor, mac or serial and optionally specify aggregation",
          "properties": {
            "group-7": {
              "items": {
                "type": "string"
              },
              "type": "array",
              "enum": [
                "avg",
                "min",
                "max",
                "sum",
                "time",
                "last",
                "user"
              ]
            },
            "mac-MAC_ADDRESS": {
              "type": "boolean"
            },
            "sensor-506": {
              "items": {
                "type": "string"
              },
              "type": "array",
              "enum": [
                "avg",
                "min",
                "max",
                "sum",
                "time",
                "last",
                "user"
              ]
            },
            "serial-SERIAL": {
              "type": "boolean"
            }
          },
          "type": "object"
        },
        "settings": {
          "description": "Configure sensor output",
          "properties": {
            "group-7": {
               "unit": "Custom unit",
               "type": "string"
            },
            "sensor-506": {
               "unit": "Custom unit",
               "type": "string"
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "data": {
      "properties": {
        "model": {
          "description": "Disease model name",
          "type": "string"
        },
        "sunrise_sunset": {
          "description": "Get sunrise and sunset dates for specified period",
          "type": "boolean"
        },
        "unit_system": {
          "type": "string",
          "description": "One of",
          "enum": [
            "imperial",
            "metric"
          ]
        }
      },
      "type": "object"
    }
  },
  "type": "object"
}

{
  # VIEW NAME: Pre-Defined, Combined, Custom
  "name": "PRE-DEFINED, COMBINED OR CUSTOM ... NAME,
  "sensors": {
    "filter": {
      # Filter out specific sensor
      "sensor-506": 1,
      # Filter out specific sensor and its aggregation
      "sensor-506": [
        "avg"
      ],
      # Filter out specific sensors of a group
      "group-7": 1,
      # Filter out specific sensors of a group and its aggragation
      "group-7": [
        "avg"
      ],
      # Filter out sensors on MAC
      "mac-MAC_ADDRESS": true,
      # Filter out sensors with Serial
      "serial-SERIAL": true
    },
    "settings" : {
       # Configure output of a sensor, by changing the unit manually
       "sensor-506": [
            "unit" : "sec"
       ],
       # Configure output of a sensor group, by changing the unit manually
       "group-7": [
            "unit" : "sec"
       ]
    }
  },
  "data": {
    # UNIT SYSTEM: matric, imperial
    "unit_system": "imperial",
    # Sunrise and sunset dates
    "sunrise_sunset" : true,
    # DISEASE MODEL DATA
    "model": "DISEASE-MODEL"
  }
}

# OPTIMIZED - Recommended
# Data can come in several aggravations inside the sensor information AGGR
# Dates come separated from the data but are in the same order
# All other information is sensor related information
# We recommend this format because of its simplicity and output size is smaller then normal one
# 1_X_X_143 tag is = CH_MAC_SERIAL_CODE
{
    "dates": [
        "2017-07-21 05:00:00",
        "2017-07-21 05:15:00",
        "2017-07-21 05:30:00",
        "2017-07-21 05:45:00",
        "2017-07-21 06:00:00"
    ],
    "data": {
        "1_X_X_143": {
            "name": "Wind direction",
            "name_custom": false,
            "decimals": 0,
            "unit": "deg",
            "ch": 1,
            "code": 143,
            "group": 16,
            "serial": "X",
            "mac": "X",
            "vals": {
                "min": 0,
                "max": 360
            },
            "aggr": {
                "avg": [
                    39,
                    117,
                    85,
                    74,
                    74
                ],
                "last": [
                    39,
                    117,
                    85,
                    74,
                    74
                ]
            },
            "registered": "2017-06-30 18:00:00"
        },
        "2_X_X_600": {
            "name": "Solar radiation",
            "name_custom": false,
            "decimals": 0,
            "unit": "W/m2",
            "ch": 2,
            "code": 600,
            "group": 4,
            "serial": "X",
            "mac": "X",
            "vals": {
                "min": 0,
                "max": 32767
            },
            "aggr": {
                "avg": [
                    0,
                    0,
                    0,
                    0,
                    0
                ]
            },
            "registered": "2017-06-30 18:00:00"
        },...
}

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method  = "POST";
$request = "/data/{{FORMAT}}/{{STATION-ID}}/{{DATA-GROUP}}/from/{{FROM-UNIX-TIMESTAMP}}/to/{{TO-UNIX-TIMESTAMP}}";

// Body that you send needs to be JSON schema validated
$body    = [
    "sensors" => [
        "filter" => [
            "sensor-506" => TRUE
        ]
    ]
];
$body = json_encode( $body );

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt( $ch, CURLOPT_POST, TRUE );
curl_setopt( $ch, CURLOPT_POSTFIELDS, $body );

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

{
  "properties": {
    "description": "Pre-defined, combined or custom name",
    "name": {
      "type": "string"
    },
    "sensors": {
      "properties": {
        "filter": {
          "description": "Filter by group, sensor, mac or serial and optionally specify aggregation",
          "properties": {
            "group-7": {
              "items": {
                "type": "string"
              },
              "type": "array",
              "enum": [
                "avg",
                "min",
                "max",
                "sum",
                "time",
                "last",
                "user"
              ]
            },
            "mac-MAC_ADDRESS": {
              "type": "boolean"
            },
            "sensor-506": {
              "items": {
                "type": "string"
              },
              "type": "array",
              "enum": [
                "avg",
                "min",
                "max",
                "sum",
                "time",
                "last",
                "user"
              ]
            },
            "serial-SERIAL": {
              "type": "boolean"
            }
          },
          "type": "object"
        },
        "settings": {
          "description": "Configure sensor output",
          "properties": {
            "group-7": {
               "unit": "Custom unit",
               "type": "string"
            },
            "sensor-506": {
               "unit": "Custom unit",
               "type": "string"
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "data": {
      "properties": {
        "model": {
          "description": "Disease model name",
          "type": "string"
        },
        "sunrise_sunset": {
          "description": "Get sunrise and sunset dates for specified period",
          "type": "boolean"
        },
        "unit_system": {
          "type": "string",
          "description": "One of",
          "enum": [
            "imperial",
            "metric"
          ]
        }
      },
      "type": "object"
    }
  },
  "type": "object"
}

{
  # VIEW NAME: Pre-Defined, Combined, Custom
  "name": "PRE-DEFINED, COMBINED OR CUSTOM ... NAME,
  "sensors": {
    "filter": {
      # Filter out specific sensor
      "sensor-506": 1,
      # Filter out specific sensor and its aggregation
      "sensor-506": [
        "avg"
      ],
      # Filter out specific sensors of a group
      "group-7": 1,
      # Filter out specific sensors of a group and its aggragation
      "group-7": [
        "avg"
      ],
      # Filter out sensors on MAC
      "mac-MAC_ADDRESS": true,
      # Filter out sensors with Serial
      "serial-SERIAL": true
    },
    "settings" : {
       # Configure output of a sensor, by changing the unit manually
       "sensor-506": [
            "unit" : "sec"
       ],
       # Configure output of a sensor group, by changing the unit manually
       "group-7": [
            "unit" : "sec"
       ]
    }
  },
  "data": {
    # UNIT SYSTEM: matric, imperial
    "unit_system": "imperial",
    # Sunrise and sunset dates
    "sunrise_sunset" : true,
    # DISEASE MODEL DATA
    "model": "DISEASE-MODEL"
  }
}

{
  "properties": {
    "description": "Pre-defined, combined or custom name",
    "name": {
      "type": "string"
    },
    "sensors": {
      "properties": {
        "filter": {
          "description": "Filter by group, sensor, mac or serial and optionally specify aggregation",
          "properties": {
            "group-7": {
              "items": {
                "type": "string"
              },
              "type": "array",
              "enum": [
                "avg",
                "min",
                "max",
                "sum",
                "time",
                "last",
                "user"
              ]
            },
            "mac-MAC_ADDRESS": {
              "type": "boolean"
            },
            "sensor-506": {
              "items": {
                "type": "string"
              },
              "type": "array",
              "enum": [
                "avg",
                "min",
                "max",
                "sum",
                "time",
                "last",
                "user"
              ]
            },
            "serial-SERIAL": {
              "type": "boolean"
            }
          },
          "type": "object"
        },
        "settings": {
          "description": "Configure sensor output",
          "properties": {
            "group-7": {
               "unit": "Custom unit",
               "type": "string"
            },
            "sensor-506": {
               "unit": "Custom unit",
               "type": "string"
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "data": {
      "properties": {
        "model": {
          "description": "Disease model name",
          "type": "string"
        },
        "sunrise_sunset": {
          "description": "Get sunrise and sunset dates for specified period",
          "type": "boolean"
        },
        "unit_system": {
          "type": "string",
          "description": "One of",
          "enum": [
            "imperial",
            "metric"
          ]
        }
      },
      "type": "object"
    }
  },
  "type": "object"
}

{
  # VIEW NAME: Pre-Defined, Combined, Custom
  "name": "PRE-DEFINED, COMBINED OR CUSTOM ... NAME,
  "sensors": {
    "filter": {
      # Filter out specific sensor
      "sensor-506": 1,
      # Filter out specific sensor and its aggregation
      "sensor-506": [
        "avg"
      ],
      # Filter out specific sensors of a group
      "group-7": 1,
      # Filter out specific sensors of a group and its aggragation
      "group-7": [
        "avg"
      ],
      # Filter out sensors on MAC
      "mac-MAC_ADDRESS": true,
      # Filter out sensors with Serial
      "serial-SERIAL": true
    },
    "settings" : {
       # Configure output of a sensor, by changing the unit manually
       "sensor-506": [
            "unit" : "sec"
       ],
       # Configure output of a sensor group, by changing the unit manually
       "group-7": [
            "unit" : "sec"
       ]
    }
  },
  "data": {
    # UNIT SYSTEM: matric, imperial
    "unit_system": "imperial",
    # Sunrise and sunset dates
    "sunrise_sunset" : true,
    # DISEASE MODEL DATA
    "model": "DISEASE-MODEL"
  }
}

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/chart/{{TYPE}}/{{STATION-ID}}/{{DATA-GROUP}}/last/{{TIME-PERIOD}}";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/chart/{{TYPE}}/{{STATION-ID}}/{{DATA-GROUP}}/from/{{FROM-UNIX-TIMESTAMP}}/to/{{TO-UNIX-TIMESTAMP}}";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method  = "POST";
$request = "/chart/{{TYPE}}/{{STATION-ID}}/{{DATA-GROUP}}/last/{{TIME-PERIOD}}";

// Body that you send needs to be JSON schema validated
$body    = [
    "sensors" => [
        "filter" => [
            "sensor-506" => TRUE
        ]
    ]
];
$body = json_encode( $body );

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt( $ch, CURLOPT_POST, TRUE );
curl_setopt( $ch, CURLOPT_POSTFIELDS, $body );

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method  = "POST";
$request = "/chart/{{TYPE}}/{{STATION-ID}}/{{DATA-GROUP}}/from/{{FROM-UNIX-TIMESTAMP}}/to/{{TO-UNIX-TIMESTAMP }}";

// Body that you send needs to be JSON schema validated
$body    = [
    "sensors" => [
        "filter" => [
            "sensor-506" => TRUE
        ]
    ]
];
$body = json_encode( $body );

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt( $ch, CURLOPT_POST, TRUE );
curl_setopt( $ch, CURLOPT_POSTFIELDS, $body );

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/camera/YOUR-CAMERA-STATION/photos/info";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/camera/{{STATION-ID}}/photos/last/{{AMOUNT}}/{{CAMERA}}";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/camera/{{STATION-ID}}/photos/from/{{FROM-UNIX-TIMESTAMP}}/to/{{TO-UNIX-TIMESTAMP}}/{{CAMERA}}";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/farms";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/farms/{{FARM-ID}}";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

{
  "title": "Farm Update Schema",
  "type": "object",
  "additionalProperties": false,
  "properties": {
    "name": {
      "type": "string",
      "maxLength": 50,
      "minLength": 3
    }
  }
}

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "POST";
$request = "/farms";
// Body that you send needs to be JSON schema validated
$body    = [
    "name" => "farm_name"
];
$body = json_encode( $body );

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt( $ch, CURLOPT_POST, TRUE );
curl_setopt( $ch, CURLOPT_POSTFIELDS, $body );

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

{
  "title": "Farm Update Schema",
  "type": "object",
  "additionalProperties": false,
  "properties": {
    "name": {
      "type": "string",
      "maxLength": 50,
      "minLength": 3
    }
  }
}

{
    "name": "farm_name"
}

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/fields";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/farms/{{FARM-ID}}/fields";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

{
  "title": "Field Insert Schema",
  "type": "object",
  "additionalProperties": false,
  "required": [
    "name"
  ],
  "properties": {
    "name": {
      "type": "string",
      "maxLength": 50,
      "minLength": 3
    }
  }
}

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "POST";
$request = "/farms/{{FARM-ID}}/fields";
// Body that you send needs to be JSON schema validated
$body    = [
    "name" => "field_name"
];
$body = json_encode( $body );

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt( $ch, CURLOPT_POST, TRUE );
curl_setopt( $ch, CURLOPT_POSTFIELDS, $body );

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

{
  "title": "Field Update Schema",
  "type": "object",
  "additionalProperties": false,
  "properties": {
    "name": {
      "type": "string",
      "maxLength": 50,
      "minLength": 3
    }
  }
}

{
    "name": "field_name"
}

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/crop-zones";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/crop-zones/{{CROPZONE-ID}}";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "GET";
$request = "/farms/{{FARM-ID}}/fields/{{FIELD-ID}}/crop-zones";

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

{
  "title": "CropZone Insert Schema",
  "type": "object",
  "additionalProperties": false,
  "required": [
    "name",
    "from",
    "to",
    "crop_name",
    "boundary",
    "soil",
    "crop",
    "rain_efficacies",
    "data_sources",
    "irrigation_events"
  ],
  "properties": {
    "product_key": {
      "type": "string"
    },
    "name": {
      "type": "string",
      "maxLength": 50,
      "minLength": 3
    },
    "from": {
      "type": "string",
      "format": "date-time"
    },
    "to": {
      "type": "string",
      "format": "date-time"
    },
    "crop_name": {
      "type": "string",
      "maxLength": 50,
      "minLength": 3
    },
    "boundary": {
      "oneOf": [
        {
        "type": "null"
        },
        {
          "$ref": "Polygon.json"
        }
      ]
    },
    "soil": {
      "oneOf": [
        {
          "type": "null"
        },
        {
          "$ref": "CropZoneSoil.json"
        }
      ]
    },
    "crop": {
      "oneOf": [
        {
          "type": "null"
        },
        {
          "$ref": "CropZoneCrop.json"
        }
      ]
    },
    "rain_efficacies":  {
      "type": "array",
      "items": {
        "$ref": "CropZoneRainEfficacy.json"
      }
    },
    "data_sources": {
      "type": "array",
      "items": {
        "$ref": "CropZoneDataSource.json"
      }
    },
    "irrigation_events": {
      "type": "array",
      "items": {
        "$ref": "CropZoneIrrigationEvent.json"
      }
    },
    "yield_prediction": {
      "type": "array",
      "items": {
        "$ref": "CropZoneYieldPrediction.json"
      }
    }
  }
}

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "POST";
$request = "/farms/{{FARM-ID}}/fields/{{FIELD-ID}}/crop-zones";
// Body that you send needs to be JSON schema validated
$body    = [
    "name" => "farm_name",
    "from" => "2023-05-15T22:00:00.000Z",
    "to" => "2024-05-15T22:00:00.000Z",
    "boundary" => null,
    "crop" => null,
    "crop_name" => "barley",
    "data_sources" => [],
    "irrigation_events" => [],
    "product_key" => "976b7154-1950-43c3-b962-xxxxxxxxxxxx",
    "rain_efficacies" => [],
    "soil" => null
];
$body = json_encode( $body );

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt( $ch, CURLOPT_POST, TRUE );
curl_setopt( $ch, CURLOPT_POSTFIELDS, $body );

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

{
  "title": "CropZone update Schema",
  "type": "object",
  "additionalProperties": false,
  "properties": {
    "product_key": {
      "type": "string"
    },
    "name": {
      "type": "string",
      "maxLength": 50,
      "minLength": 3
    },
    "from": {
      "type": "string",
      "format": "date-time"
    },
    "to": {
      "type": "string",
      "format": "date-time"
    },
    "crop_name": {
      "type": "string",
      "maxLength": 50,
      "minLength": 3
    },
    "boundary": {
      "oneOf": [
        {
          "type": "null"
        },
        {
          "$ref": "Polygon.json"
        }
      ]
    },
    "soil": {
      "oneOf": [
        {
          "type": "null"
        },
        {
          "$ref": "CropZoneSoil.json"
        }
      ]
    },
    "crop": {
      "oneOf": [
        {
          "type": "null"
        },
        {
          "$ref": "CropZoneCrop.json"
        }
      ]
    },
    "rain_efficacies":  {
      "type": "array",
      "items": {
        "$ref": "CropZoneRainEfficacy.json"
      }
    },
    "data_sources": {
      "type": "array",
      "items": {
        "$ref": "CropZoneDataSource.json"
      }
    },
    "irrigation_events": {
      "type": "array",
      "items": {
        "$ref": "CropZoneIrrigationEvent.json"
      }
    },
    "yield_prediction": {
      "type": "array",
      "items": {
        "$ref": "CropZoneYieldPrediction.json"
      }
    },
    "distance": {
      "type": "number"
    }
  }
}

{
    "product_key": "976b7154-1950-43c3-b962-xxxxxxxxxxxx",
    "name": "new_cropzone_name",
    "from": "2023-05-15T22:00:00+00:00",
    "to": "2024-05-15T22:00:00+00:00",
    "crop_name": "barley",
    "boundary": null,
    "crop": null,
    "soil": null,
    "rain_efficacies": [],
    "data_sources": [],
    "irrigation_events": [],
    "yield_prediction": [],
    "distance": 30000
}

{
    "title": "Sentinel statistics request Schema",
    "type": "object",
    "additionalProperties": false,
    "required": [
      "resolution",
      "type"
    ],
    "properties": {
      "resolution": {
        "type": "number",
        "minimum": 0,
        "maximum": 500
      },
      "type": {
        "oneOf": [
            {
                "type": "string",
                "enum": [ "LAI", "lai", "NDVI", "ndvi" ]
            }
        ]
        
      }
    }
}

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "POST";
$request = "/crop-zones/{{CROPZONE-ID}}/sentinel-statistics";
// Body that you send needs to be JSON schema validated
$body    = [
    "resolution" => 30,
    "type" => "LAI"
];
$body = json_encode( $body );

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt( $ch, CURLOPT_POST, TRUE );
curl_setopt( $ch, CURLOPT_POSTFIELDS, $body );

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

{
    "title": "Fitting Curve Schema",
    "type": "object",
    "additionalProperties": false,
    "required": [
      "data",
      "type"
    ],
    "properties": {
      "data": {
        "type": "array",
        "items": {
          "type": "object",
          "properties": {
            "cloud": {
              "type": "object",
              "properties": {
                "min": {
                  "type": "number"
                },
                "max": {
                  "type": "number"
                },
                "mean": {
                  "type": "number"
                },
                "stDev": {
                  "type": "number"
                }
              }
            },
            "date": {
              "format": "date"
            },
            "lai": {
              "type": "object",
              "properties": {
                "min": {
                  "type": "number"
                },
                "max": {
                  "type": "number"
                },
                "mean": {
                  "type": "number"
                },
                "stDev": {
                  "type": "number"
                }
              },
              "required": ["min", "max", "mean", "stDev"],
              "dependencies": {
                "ndvi": {
                  "not": {
                    "required": ["lai"]
                  }
                }
              }
            },
            "ndvi": {
              "type": "object",
              "properties": {
                "min": {
                  "type": "number"
                },
                "max": {
                  "type": "number"
                },
                "mean": {
                  "type": "number"
                },
                "stDev": {
                  "type": "number"
                }
              },
              "required": ["min", "max", "mean", "stDev"],
              "dependencies": {
                "lai": {
                  "not": {
                    "required": ["ndvi"]
                  }
                }
              }
            }
          },
          "oneOf": [
            {
              "required": ["lai"],
              "not": {
                "required": ["ndvi"]
              }
            },
            {
              "required": ["ndvi"],
              "not": {
                "required": ["lai"]
              }
            }
          ],
          "required": ["cloud", "date"]
        }
      },
      "type": {
        "type": "string",
        "enum": ["LAI", "lai", "NDVI", "ndvi"]
      }
    }
  }
  

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "POST";
$request = "/crop-zones/{{CROPZONE-ID}}/fitting-curve";
// Body that you send needs to be JSON schema validated
$body    = [
    "data" => [
        [
            "cloud" => [
                "min" => 0,
                "max" => 0,
                "mean" => 0,
                "stDev" => 0
            ],
            "date" => "2023-05-07",
            "ndvi" => [
                "min" => 0.8203737139701843,
                "max" => 4.738396644592285,
                "mean" => 1.6806123194694513,
                "stDev" => 0.5278388234312482
            ]
        ],
        [
            "cloud" => [
                "min" => 0,
                "max" => 0,
                "mean" => 0,
                "stDev" => 0
            ],
            "date" => "2023-05-05",
            "ndvi" => [
                "min" => 0.7168576121330261,
                "max" => 4.701280117034912,
                "mean" => 1.9682491116523742,
                "stDev" => 0.4608035214462633
            ]
        ],
        [
            "cloud" => [
                "min" => 0,
                "max" => 0,
                "mean" => 0,
                "stDev" => 0
            ],
            "date" => "2023-04-27",
            "ndvi" => [
                "min" => 0.6236867308616638,
                "max" => 3.54347825050354,
                "mean" => 1.356145232200622,
                "stDev" => 0.3287475461504505
            ]
        ],
        [
            "cloud" => [
                "min" => 0,
                "max" => 0,
                "mean" => 0,
                "stDev" => 0
            ],
            "date" => "2023-04-20",
            "ndvi" => [
                "min" => 0.5432727336883545,
                "max" => 4.080946445465088,
                "mean" => 1.5180718364715575,
                "stDev" => 0.48235261291138143
            ]
        ],
        [
            "cloud" => [
                "min" => 0,
                "max" => 0,
                "mean" => 0,
                "stDev" => 0
            ],
            "date" => "2023-04-07",
            "ndvi" => [
                "min" => 0.34423547983169556,
                "max" => 0.5037468671798706,
                "mean" => 0.4272834968566893,
                "stDev" => 0.029341276465697286
            ]
        ],
        [
            "cloud" => [
                "min" => 0,
                "max" => 0,
                "mean" => 0,
                "stDev" => 0
            ],
            "date" => "2023-04-05",
            "ndvi" => [
                "min" => 0.5129870176315308,
                "max" => 3.1946473121643066,
                "mean" => 1.463275423049926,
                "stDev" => 0.38614863473463307
            ]
        ],
        [
            "cloud" => [
                "min" => 0,
                "max" => 0,
                "mean" => 0,
                "stDev" => 0
            ],
            "date" => "2023-03-18",
            "ndvi" => [
                "min" => 0.35564854741096497,
                "max" => 1.8071495294570923,
                "mean" => 0.8426461148262027,
                "stDev" => 0.1980161228848823
            ]
        ],
        [
            "cloud" => [
                "min" => 0,
                "max" => 0,
                "mean" => 0,
                "stDev" => 0
            ],
            "date" => "2023-03-16",
            "ndvi" => [
                "min" => 0.43110236525535583,
                "max" => 2.160433053970337,
                "mean" => 1.0767034132480624,
                "stDev" => 0.24976066545097986
            ]
        ],
        [
            "cloud" => [
                "min" => 0,
                "max" => 0,
                "mean" => 0,
                "stDev" => 0
            ],
            "date" => "2023-03-13"",
            "ndvi" => [
                "min" => 0.3871999979019165,
                "max" => 1.418410062789917,
                "mean" => 0.6944776844978335,
                "stDev" => 0.13765869336954994
            ]
        ],
        [
            "cloud" => [
                "min" => 0,
                "max" => 0,
                "mean" => 0,
                "stDev" => 0
            ],
            "date" => "2023-03-11"",
            "ndvi" => [
                "min" => 0.241590216755867,
                "max" => 0.6233023405075073,
                "mean" => 0.4905939499139787,
                "stDev" => 0.05163162621348635
            ]
        ],
        [
            "cloud" => [
                "min" => 0,
                "max" => 0,
                "mean" => 0,
                "stDev" => 0
            ],
            "date" => "2023-03-03"",
            "ndvi" => [
                "min" => 0.16855429112911224,
                "max" => 0.46921443939208984,
                "mean" => 0.2685050587654113,
                "stDev" => 0.0550561746999114
            ]
        ],
        [
            "cloud" => [
                "min" => 0,
                "max" => 0,
                "mean" => 0,
                "stDev" => 0
            ],
            "date" => "2023-02-24"",
            "ndvi" => [
                "min" => 0.26081082224845886,
                "max" => 0.46561750769615173,
                "mean" => 0.3462496666908264,
                "stDev" => 0.02782796554263813
            ]
        ],
        [
            "cloud" => [
                "min" => 0,
                "max" => 0,
                "mean" => 0,
                "stDev" => 0
            ],
            "date" => "2023-02-21"",
            "ndvi" => [
                "min" => 0.3144981265068054,
                "max" => 0.5865257382392883,
                "mean" => 0.43720595288276676,
                "stDev" => 0.03107848066279827
            ]
        ],
        [
            "cloud" => [
                "min" => 0,
                "max" => 0,
                "mean" => 0,
                "stDev" => 0
            ],
            "date" => "2023-02-19"",
            "ndvi" => [
                "min" => 0.22007721662521362,
                "max" => 0.6000000238418579,
                "mean" => 0.4428697912693021,
                "stDev" => 0.03941568041029631
            ]
        ]
    ],
    "type" => "NDVI"
];
$body = json_encode( $body );

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt( $ch, CURLOPT_POST, TRUE );
curl_setopt( $ch, CURLOPT_POSTFIELDS, $body );

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;

{
    "title": "Sentinel statistics body Schema",
    "type": "object",
    "additionalProperties": false,
    "required": [
      "dates",
      "getBestResolution",
      "resolution",
      "type"
    ],
    "properties": {
      "dates": {
        "type": "array",
        "items": {
            "format": "date"
        }
      },
      "getBestResolution": {
        "type": "boolean"
      },
      "resolution": {
        "type": "number",
        "minimum": 0,
        "maximum": 500
      },
      "type": {
        "oneOf": [
            {
                "type": "string",
                "enum": [ "LAI", "lai", "NDVI", "ndvi" ]
            }
        ]
        
      }
    }
}

// Clients public and private key provided by service provider
$public_key = "PROVIDED BY SERVICE PROVIDER";
$private_key = "PROVIDED BY SERVICE PROVIDER";

// Define the request parameter's
$method = "POST";
$request = "/crop-zones/{{CROPZONE-ID}}/sentinel-values";
// Body that you send needs to be JSON schema validated
$body    = [
    "dates" => 
    "resolution" => 30,
    "type" => "LAI"
];
$body = json_encode( $body );

$timestamp = gmdate('D, d M Y H:i:s T'); // Date as per RFC2616 - Wed, 25 Nov 2014 12:45:26 GMT

// Creating content to sign with private key
$content_to_sign = $method.$request.$timestamp.$public_key;

// Hash content to sign into HMAC signature
$signature = hash_hmac("sha256", $content_to_sign, $private_key);

// Add required headers
// Authorization: hmac public_key:signature
// Date: Wed, 25 Nov 2014 12:45:26 GMT
$headers = [
    "Accept: application/json",
    "Authorization: hmac {$public_key}:{$signature}",
    "Date: {$timestamp}"
];

// Prepare and make https request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.fieldclimate.com/THIS-VERSION" . $request);
// SSL important
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, FALSE );
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt( $ch, CURLOPT_POST, TRUE );
curl_setopt( $ch, CURLOPT_POSTFIELDS, $body );

$output = curl_exec($ch);
curl_close($ch);

// Parse response as json and work on it ..
echo $output. PHP_EOL;