Client Examples

C#

namespace GPM.WebClientExample
{
	using System;
	using System.Collections.Generic;
	using System.Linq;
	using System.Net.Http;
	using System.Net.Http.Headers;
	using System.Threading.Tasks;
	class Program
	{
		static string username = "<hidden>";
		static string password = "<hidden>";
		static string webApiURL = "<hidden>";
		static string tokenURL = "api/Account/Token";
		static string plantsURL = "api/Plant";
		static string elementsURL = "api/Plant/{0}/Element";
		static string datasourcesURL = "api/Plant/{0}/Element/{1}/Datasource";
		static string lastDataURL = "api/Plant/{0}/LastData";		
		private static void Main()
		{
			RunAsync().Wait();			
			GetLastDataForPlant(20).Wait();			
			Console.ReadLine();			
		}
		private static async Task RunAsync()
		{
			using (var client = await GetClient())
			{
				var plantsResponse = await client.GetAsync(plantsURL);
				if (plantsResponse.IsSuccessStatusCode)
				{
					var plants = await plantsResponse.Content.ReadAsAsync<IEnumerable<Plant>>();
					foreach (var plant in plants)
					{
						var elementsResponse = await client.GetAsync(string.Format(elementsURL, plant.Id));
						if (!elementsResponse.IsSuccessStatusCode)
						{
							continue;
						}
						var plantElements = await elementsResponse.Content.ReadAsAsync<IEnumerable<Element>>();
						foreach (var plantElement in plantElements)
						{
							var datasourcesResponse = 
							await
							client.GetAsync(string.Format(datasourcesURL, plant.Id, plantElement.Identifier));
							if (!datasourcesResponse.IsSuccessStatusCode)
							{
								continue;
							}
							var elementDatasources = await datasourcesResponse.Content.ReadAsAsync<IEnumerable<Datasource>>();
							foreach (var datasource in elementDatasources)
							{
								Console.WriteLine(
								"{0} - {1} - {2} {3} - {4}",
								plant.Name,
								plantElement.Name,
								datasource.DataSourceName,
								datasource.Units,
								datasource.DataSourceId);
							}
						}
					}
				}
			}
		}
		private static async Task GetLastDataForPlant(int plantId)
		{
			using (var client = await GetClient())
			{
				var lastDataResponse = await client.GetAsync(string.Format(lastDataURL, plantId));
				if (lastDataResponse.IsSuccessStatusCode)
				{
					var lastData = await lastDataResponse.Content.ReadAsAsync<IEnumerable<LastValueResponse>>();
					Console.WriteLine(lastData.Count());
				}
			}
		}
		private static async Task<HttpClient> GetClient()
		{
			var handler = new WebRequestHandler
			{
				ServerCertificateValidationCallback =
				(sender, certificate, chain, errors) => true
			};
			var client = new HttpClient(handler) { BaseAddress = new Uri(webApiURL) };
			client.DefaultRequestHeaders.Accept.Clear();
			client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
			//Token should be obtain once and then reused until it expires
			var payload = new AuthRequestPayload { Username = username, Password = password, };
			var res = await client.PostAsJsonAsync(tokenURL, payload);
			if (!res.IsSuccessStatusCode)
			{
				throw new Exception("could not get token");
			}
			var token = await res.Content.ReadAsAsync<AuthResponse>();
			client.DefaultRequestHeaders.Add("authorization", token.TokenType + " " + token.AccessToken);
			return client;
		}
	}
	public class AuthRequestPayload
	{
		public string Username { get; set; }
		public string Password { get; set; }
	}
	public class AuthResponse
	{
		public string UserName { get; set; }
		public string AccessToken { get; set; }
		public string TokenType { get; set; }
		public string ExpiresIn { get; set; }
	}
	public class Datasource
	{
		public int ElementId { get; set; }
		public int DataSourceId { get; set; }
		public string DataSourceName { get; set; }
		public string Units { get; set; }
	}
	public class Element
	{
		ic int Identifier { get; set; }
		public string Name { get; set; }
		public ELEMENTS_TYPE Type { get; set; }
	}
	public enum ELEMENTS_TYPE : int
	{
		UNDEFINED = -1,
		COUNTER = 0,
		INVERTER = 1,
		WEATHER_STATION = 2,
		TRACKER = 3,
		COMMUNICATIONS_BOARD = 4,
		WIND_METER = 5,
		DAPECOM = 6,
		DIGITAL_INPUTS = 7,
		CUSTOM = 8,
		STRINGS_CONTROL = 9,
		GENERAL_CONTROL = 10,
		INVERTER_ROOM = 11,
		TRANSFORMER = 12,
		WINDING = 13,
		STRING = 14,
		NETWORK_ELEMENT = 15,
		GENERATOR = 16,
		UPS = 17,
		FAN = 18,
		ANALOG_INPUT = 19,
		CABINET_INFORMATION = 20,
		SITE = 21,
		SUBSITE = 22,
		DYNAMICLOOP = 23,
		PHOTOVOLTAIC_CELL = 24,
		PYRANOMETER = 25,
		ANEMOMETER = 26,
		WIND_VANE = 27,
		THERMOMETER = 28,
		PLUVIOMETER = 29,
		HYGROMETER = 30,
		BAROMETER = 31,
		SENSOR = 32,
		METER_SSAA = 33,
		INVERTER_MODULE = 34,
		COMBINER_STRINGBOX = 35,
		DATALOGGER = 40,
		DAM = 41,
		BMD = 42,
		MOXA = 43,
		RTU = 44,
		PLC = 45,
		OPC = 46,
		WEBBOX = 47,
		PPC = 48,
		RING = 49,
		CT = 50,
		CABINE = 51,
		SUBSTATION = 52,
		BATTERY = 54,
		AUXILIARY_SERVICES = 55,
		SWITCH = 56,
		RELAY = 57,
		THYTRONIC = 58,
		SEPAM = 59,
		FUSE = 60,
		COMMUNICATION_ELEMENT = 61,
		INFORMATION_ELEMENT = 62,
		STATE_ELEMENT = 63,
		SECURITY_ELEMENT = 64,
		COMMAND_ELEMENT = 65,
		DIESEL_GENERATOR = 66,
		METER_MT = 67,
		METER_BT = 68,
		CUSTOM_PLANT = 69,
	}
	public class Plant
	{
		public int Id { get; set; }
		public string Name { get; set; }
	}
	public class LastValueResponse
	{
		public int DataSourceId { get; set; }
		public string DataSourceName { get; set; }
		public LastValue LastValue { get; set; }
	}
	public class LastValue
	{
		public int DataSourceId { get; set; }
		public DateTime Date { get; set; }
		public double Value { get; set; }
	}
}

Python

def parse_date(string):
	date = None
	try:
		date = datetime.strptime(string, DATETIME_FORMAT)
	except:
		date = datetime.strptime(string[:-6], DATETIME_FORMAT)
	return date

class ListValueAPI(object):
	"""Wraps data as a python object"""
	def __init__(self, json):
		self.DSId = json['DataSourceId']	
		self.Date = parse_date(json['Date'])
		self.Value = parse_with_units(json['Value'])
	def __str__(self):
		return "%(Date)s %(Value)s" % self.__dict__

def get_list(url, payload):
	"""Generic list query"""
	url = url + "DataList"
	headers = {
		'content-type': 'application/json',
		'accept': 'application/json'
	}
	try:
		r = requests.get(url, params=payload, headers=headers)
		if r.status_code == 200:
			return r.json()
	except:
		return None
		
def get_last(url, dsId):
	"""Last value query"""
	payload = { 'dataSourceId' : dsId }
	json_list = get_list(url, payload)
	res = None
	try:
		res = ListValueAPI(json_list[0]) if json_list is not None and len(json_list) > 0 else _default_list_value()
	except:
		return None
	return res
	
def get_interval(url, dsId, init, end):
	""""Datetime interval query"""
	report_get_interval(url, dsId, init, end)
	payload = {
		'dataSourceId': dsId,
		'startDate': init,
		'endDate': end,
		'aggregationType': 0,
		'grouping': 'day',
	}
	json_list = get_list(url, payload)
	res = None
	try:
		res =[ListValueAPI(j) for j in json_list] if json_list is not None and len(json_list) > 0 else _default_interval()
	except:
		return None
	return res