#-*- coding: utf-8 -*-
import urllib.request
import urllib.error
import urllib.parse
import json
 
BASE_URL = 'https://kontantanalys.tillvaxtverket.se/test/'
 
def acquire_token(username, password):
    """ Login and acquire a valid token """
    url = BASE_URL + '/Token'
    data = {
        'grant_type': 'password',
        'username': username,
        'password': password
    }
    opener = urllib.request.build_opener()
    response = opener.open(url, urllib.parse.urlencode(data).encode("utf-8"))
 
    if response.getcode() == 200:
        content = response.read()
        data = json.loads(content)
        return data['access_token']
 
    return None
 
def create_provider(provider, token):
    headers = {
        'Authorization': 'Bearer %s' % token,
        'Content-Type': 'application/json',
        'Accept': 'application/json'
    }
    envelope = {
        "data": provider
    }
 
    url = BASE_URL + '/api/providers/'
    data = json.dumps(envelope).encode('utf8')
    req = urllib.request.Request(url, headers=headers)
    try:
        response = urllib.request.urlopen(req, data=data)
        content = response.read()
        new_object = json.loads(content)
        return new_object['data']
    except urllib.error.HTTPError as e:
        content = e.read()
        if content:
            errors = json.loads(content)
            print ('Error (%d) create provider' % e.code)
            for error in errors['errors']:
                print (error)
        else:
            print ('Error (%d) create provider' % e.code)
 
    return None
 
def find_provider(provider_id, token):
    """ Get provider by id """
    opener = urllib.request.build_opener()
    opener.addheaders = [('Authorization', 'Bearer %s' % token)]
    url = BASE_URL + '/api/Providers/%d' % provider_id
    response = opener.open(url)
    content = response.read()
    data = json.loads(content)
    return data['data']
 
def main():
    token = acquire_token('testbanken', 'Sommar&sol2020')
     
    provider = {
        'type': 'provider',
        'attributes': {
            'name': 'INGO Örebro, Adolfsbergsvägen',
            'visitingAddress': 'Adolfsbergsvägen 4',
            'postalCode': '702 27',
            'postTown': 'ÖREBRO',
            'x': 509886.4,
            'y': 6568855.5
        }
    }
    new_provider = create_provider(provider, token)
    if new_provider:
        provider = find_provider(new_provider['id'], token)
        assert provider['attributes']['name'] == new_provider['attributes']['name']
 
if __name__== "__main__":
    main()

using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Web;
using Newtonsoft.Json;

namespace PiPoS.Examples
{
    public class ApiExamples
    {
		static readonly string BASE_URL = "https://kontantanalys.tillvaxtverket.se/test/";

		public static void Main(string[] args)
        {
			var token = AcquireToken("testbanken", "Sommar&sol2020");
            var provider = new Provider {
                Name = "INGO Örebro, Adolfsbergsvägen",
                VisitingAddress = "Adolfsbergsvägen 4",
                PostalCode = "702 27",
                PostTown = "ÖREBRO",
                X = 509886.4,
                Y = 6568855.5
            };
            
            var newProvider = CreateProvider(provider, token);
            provider = FindProvider(newProvider.Id, token);
            System.Diagnostics.Debug.Assert(newProvider.Name == provider.Name);
		}

		static string AcquireToken(string username, string password)
        {
            string token = string.Empty;
            using (var client = new WebClient())
            {
                client.Headers.Add(HttpRequestHeader.ContentType, "application/x-www-form-urlencoded");
                var formData = string.Format("grant_type=password&username={0}&password={1}",
                    HttpUtility.UrlEncode(username),
                    HttpUtility.UrlEncode(password)
                );
                var htmlResult = client.UploadString(BASE_URL + "/Token", formData);
                var json = JsonConvert.DeserializeObject<Dictionary<string, object>>(htmlResult);

                if (json.ContainsKey("access_token"))
                {
                    token = json["access_token"] as string;
                }
            }
            return token;
        }

		static Provider CreateProvider(Provider provider, string token)
        {
            using (var client = new WebClient())
            {
                client.Headers.Add(HttpRequestHeader.Authorization, string.Format("Bearer {0}", token));
                client.Headers.Add(HttpRequestHeader.ContentType, "application/json");
                client.Headers.Add(HttpRequestHeader.Accept, "application/json");
 
                var envelope = new Envelope<Provider>
                {
                    Data = new Data<Provider>
                    {
                        Attributes = provider,
                        Type = "provider"
                    }
                };
                     
                var json = JsonConvert.SerializeObject(envelope);
                var result = string.Empty;

                try
                {
                    result = client.UploadString(BASE_URL + "/api/providers/", json);
                }
                catch (WebException exception)
                {
                    var responseStream = exception.Response?.GetResponseStream();
                    if (responseStream != null)
                    {
                        using (var reader = new StreamReader(responseStream))
                        {
                            var responseText = reader.ReadToEnd();
                            if (!string.IsNullOrEmpty(responseText))
                            {
                                try
                                {
                                    var responseData = JsonConvert.DeserializeObject<Error>(responseText);
                                    foreach (var error in responseData?.Errors)
                                    {
                                        Console.Error.WriteLine($"Error:\t{error}");
                                    }
                                }
                                catch (JsonReaderException)
                                {
                                    Console.Error.WriteLine(responseText);
                                }
                                
                            }
                        }
                    }
                    throw exception;
                }
                                  
                var newProvider = JsonConvert
                    .DeserializeObject<Envelope<Provider>>(result)
                    .Data
                    .Attributes;
                return newProvider;
            }
        }

		static Provider FindProvider(int providerId, string token)
        {
            using (var client = new WebClient())
            {
                client.Headers.Add(HttpRequestHeader.Authorization, string.Format("Bearer {0}", token));
                using (var data = client.OpenRead(BASE_URL + $"/api/providers/{providerId}"))
                using (var reader = new StreamReader(data))
                {
                    var provider = JsonConvert
                        .DeserializeObject<Envelope<Provider>>(reader.ReadToEnd())
                        .Data
                        .Attributes;
                    return provider;
                }
            }
        }

		public class Envelope<TEntity>
        {
            [JsonProperty(PropertyName = "data")]
            public Data<TEntity> Data { get; set; }
        }

        public class Data<TEntity>
        {
            [JsonProperty(PropertyName = "attributes")]
            public TEntity Attributes { get; set; }

            [JsonProperty(PropertyName = "id")]
            public int Id { get; set; }

            [JsonProperty(PropertyName = "type")]
            public string Type { get; set; }
        }

        public class Provider
        {
            [JsonProperty(PropertyName = "id")]
            public int Id { get; set; }

            [JsonProperty(PropertyName = "name")]
            public string Name { get; set; }

            [JsonProperty(PropertyName = "code")]
            public string Code { get; set; }

            [JsonProperty(PropertyName = "x")]
            public double X { get; set; }

            [JsonProperty(PropertyName = "y")]
            public double Y { get; set; }

            [JsonProperty(PropertyName = "visitingAddress")]
            public string VisitingAddress { get; set; }

            [JsonProperty(PropertyName = "postalCode")]
            public string PostalCode { get; set; }

            [JsonProperty(PropertyName = "postTown")]
            public string PostTown { get; set; }

            [JsonIgnore]
            public string TypeName => "provider";
        }

        public class Error
        {
            [JsonProperty(PropertyName = "errors")]
            public List<string> Errors { get; set; }
        }
	}
}