public static List <string[]> getSyncGrid(string uri, string dashboardID)
{
string response;
try
{
List <string[]> result = null;
response = connector.HttpGet(uri, timoutAPI);
Logger.Debug("GET: " + uri + " ok");
if (response != null)
{
result = JsonConvert.DeserializeObject <List <string[]> >(response);
}
else
{
result = new List <string[]>();
}
return(result);
}
catch (Exception ex)
{
APIResponseTime.calculateResponseCount(uri, ex.GetType().ToString());
Logger.Warn("GET: " + uri);
Logger.Warn(ex.ToString());
return(null);
}
}
public static async Task <List <string[]> > getAsyncGrid(string uri, string dashboardID)
{
try
{
string respString = null;
List <string[]> result = null;
using (HttpClient client = new HttpClient())
{
client.Timeout = TimeSpan.FromMilliseconds(timeoutGrid);
var response = await client.GetAsync(uri);
Logger.Debug("GET: " + uri + " " + response.StatusCode.ToString());
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
respString = await response.Content.ReadAsStringAsync();
result = JsonConvert.DeserializeObject <List <string[]> >(respString);
}
else
{
APIResponseTime.calculateResponseCount(uri, response.StatusCode.ToString());
}
}
return(result);
}
catch (Exception ex)
{
APIResponseTime.calculateResponseCount(uri, ex.GetType().ToString());
Logger.Warn("GET: " + uri);
Logger.Warn(ex.ToString());
return(null);
}
}
public static string processGetTile(string uri, string path, bool firstTry)
{
uri = uri.ToLower();
JToken item = null;
JObject jsonObject = null;
jsonObject = (JObject)MemoryCaches.memCache.Get(uri);
try
{
if (jsonObject != null)
{
if (jsonObject.ToString() == "error")
{
return(null);
}
}
else
{
var response = connector.HttpGet(uri, timoutAPI);
Logger.Debug("GET: " + uri + " OK");
jsonObject = JObject.Parse(response);
}
JObject jObject = (JObject)jsonObject;
if (jObject != null)
{
MemoryCaches.memCache.Set(uri, jObject, MemoryCache.InfiniteAbsoluteExpiration);
item = jObject.SelectToken("$." + path);
return(item.ToString());
}
else
{
MemoryCaches.memCache.Set(uri, "error", MemoryCache.InfiniteAbsoluteExpiration);
return(null);
}
}
catch (Exception ex)
{
if (firstTry)
{
Thread.Sleep(retryAPI);
return(processGetTile(uri, path, false));
}
else
{
MemoryCaches.memCache.Set(uri, "error", MemoryCache.InfiniteAbsoluteExpiration);
Logger.Warn("GET: " + uri + " " + path);
APIResponseTime.calculateResponseCount(uri, ex.GetType().ToString());
Logger.Warn(ex.ToString());
return(null);
}
}
}
public static async Task executeStart()
{
try
{
int refreshTime = Convert.ToInt32(ConfigurationSettings.AppSettings["DashCacheRefreshRateSec"].ToString());
string dashBoards = ConfigurationSettings.AppSettings["dashBoards"].ToString();
string thingsURL = ConfigurationSettings.AppSettings["thingsURL"].ToString();
string displayURL = ConfigurationSettings.AppSettings["displayURL"].ToString();
string LastAccessURL = ConfigurationSettings.AppSettings["LastAccessURL"].ToString();
double MaxTimeCache = Convert.ToDouble(ConfigurationSettings.AppSettings["MaxTimeCacheMin"].ToString());
string cacheURlMain = ConfigurationSettings.AppSettings["cacheURl"].ToString();
bool PararellProcessDashboard = Convert.ToBoolean(ConfigurationSettings.AppSettings["PararellProcessDashboard"].ToString());
string server = ConfigurationSettings.AppSettings["server"].ToString();
string cacheURl = ConfigurationSettings.AppSettings["cacheURl"].ToString();
string errorColor = ConfigurationSettings.AppSettings["errorColor"].ToString();
bool PararellProcessTiles = Convert.ToBoolean(ConfigurationSettings.AppSettings["PararellProcessTiles"].ToString());
bool PararellProcessGrid = Convert.ToBoolean(ConfigurationSettings.AppSettings["PararellProcessGrid"].ToString());
mainProcess mProc = new mainProcess(dashBoards, thingsURL, displayURL, LastAccessURL, cacheURlMain, PararellProcessDashboard, MaxTimeCache, server, cacheURl, errorColor, PararellProcessTiles, PararellProcessGrid);
await mProc.ThingsCache();
await mProc.DisplayCache();
await mProc.dashBoardCache();
DateTime lastUpdateCaches = DateTime.Now;
while (true)
{
var starTime = DateTime.Now;
if ((DateTime.Now - lastUpdateCaches) >= TimeSpan.FromSeconds(refreshTime))
{
lastUpdateCaches = DateTime.Now;
Thread updateCacheThread = new Thread(updateCache);
updateCacheThread.Start();
}
var start = DateTime.Now;
await mProc.ProcessAllDashboard();
Logger.Info("=======================================================");
Logger.Info("++++++++++++++++++API " + (DateTime.Now - start) + "++++++++++++++++++");
Logger.Info("=======================================================");
APIResponseTime.writeResponseTime();
APIResponseTime.writeErrorCount();
}
}
catch (Exception ex)
{
Logger.Error(ex.ToString());
}
}
public static async Task <Dictionary <string, string> > getAsyncMessages(string uri, FilterStatus filter, string dashboardID)
{
try
{
string respString = null;
List <JObject> result = null;
Dictionary <string, string> messages = new Dictionary <string, string>();
string URL = uri + "?filter=" + JsonConvert.SerializeObject(filter);
URL = URL.Replace(@"\", string.Empty);
using (HttpClient client = new HttpClient())
{
client.Timeout = TimeSpan.FromMilliseconds(timeoutMesssages);
var response = await client.GetAsync(URL);
Logger.Debug("GET: " + uri + " " + response.StatusCode.ToString());
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
respString = await response.Content.ReadAsStringAsync();
result = JsonConvert.DeserializeObject <List <JObject> >(respString);
}
else
{
APIResponseTime.calculateResponseCount(uri, response.StatusCode.ToString());
return(null);
}
}
JToken thing = null;
JToken item = null;
foreach (var obj in result)
{
thing = obj.SelectToken("$." + "thingId");
if (!messages.ContainsKey(thing.ToString()))
{
item = obj.SelectToken("$." + "status");
messages.Add(thing.ToString(), item.ToString());
}
}
return(messages);
}
catch (Exception ex)
{
APIResponseTime.calculateResponseCount(uri, ex.GetType().ToString());
Logger.Warn(uri);
Logger.Warn(JsonConvert.SerializeObject(filter));
Logger.Warn(ex.ToString());
return(null);
}
}
public async Task <string> getTileValue(Tile tile, string dashboardid, bool PararellProcessTiles)
{
try
{
string url = null;
string result = null;
if (tile.dataSource != null)
{
var startTime = DateTime.Now;
url = server + tile.dataSource.url;
if (tile.dataSource.queryParameters != null)
{
url += "?";
tile.dataSource.queryParameters = tile.dataSource.queryParameters.OrderByDescending(o => o.param).ToList();
for (int i = 0; i < tile.dataSource.queryParameters.Count; i++)
{
url += tile.dataSource.queryParameters[i].param.ToLower() + "=" + tile.dataSource.queryParameters[i].value.ToLower() + "&";
}
}
if (PararellProcessTiles)
{
result = await RequestAPI.processGetTile(url, tile.dataSource.path, true);
APIResponseTime.calculateResponseTime(tile.dataSource.url, DateTime.Now - startTime);
}
else
{
result = RequestAPISync.processGetTile(url, tile.dataSource.path, true);
APIResponseTime.calculateResponseTime(tile.dataSource.url, DateTime.Now - startTime);
}
}
if (result == null)
{
return("Error");
}
else
{
return(result);
};
}
catch (Exception ex)
{
Logger.Warn(ex.ToString());
return("Error");
}
}
public static async Task <Dictionary <string, string> > getAsyncThings(string uri)
{
try
{
string respString = null;
List <JObject> result = null;
Dictionary <string, string> dictResult = new Dictionary <string, string>();
using (HttpClient client = new HttpClient())
{
var response = await client.GetAsync(uri);
Logger.Debug("GET: " + uri + " " + response.StatusCode.ToString());
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
respString = await response.Content.ReadAsStringAsync();
result = JsonConvert.DeserializeObject <List <JObject> >(respString);
}
else
{
APIResponseTime.calculateResponseCount(uri, response.StatusCode.ToString());
return(null);
}
}
JToken item = null;
JToken value = null;
foreach (var obj in result)
{
item = obj.SelectToken("$." + "thingId");
value = obj.SelectToken("$." + "code");
dictResult.Add(item.ToString(), value.ToString());
}
return(dictResult);
}
catch (Exception ex)
{
APIResponseTime.calculateResponseCount(uri, ex.GetType().ToString());
Logger.Warn("GET: " + uri);
Logger.Warn(ex.ToString());
return(null);
}
}
public async Task <List <string[]> > getGridValues(Tile tile, string dashboardID, bool PararellProcessGrid)
{
try
{
string url = null;
List <string[]> result = null;
if (tile.dataSource != null)
{
var startTime = DateTime.Now;
url = server + tile.dataSource.url;
url += "?";
tile.dataSource.queryParameters = tile.dataSource.queryParameters.OrderBy(o => o.param).ToList();
for (int i = 0; i < tile.dataSource.queryParameters.Count; i++)
{
url += tile.dataSource.queryParameters[i].param.ToLower() + "=" + tile.dataSource.queryParameters[i].value.ToLower() + "&";
}
if (PararellProcessGrid)
{
result = await RequestAPI.getAsyncGrid(url, dashboardID);
APIResponseTime.calculateResponseTime(tile.dataSource.url, DateTime.Now - startTime);
}
else
{
result = RequestAPISync.getSyncGrid(url, dashboardID);
APIResponseTime.calculateResponseTime(tile.dataSource.url, DateTime.Now - startTime);
}
}
return(result);;
}
catch (Exception ex)
{
Logger.Warn(ex.ToString());
return(null);
}
}
public async Task <bool?> getTileEmphasys(Tile tile, bool PararellProcessTiles)
{
try
{
string url = null;
string result = null;
if (tile.emphasysSource != null)
{
url = server + tile.emphasysSource.url;
url += "?";
tile.emphasysSource.queryParameters = tile.emphasysSource.queryParameters.OrderBy(o => o.param).ToList();
var startTime = DateTime.Now;
for (int i = 0; i < tile.emphasysSource.queryParameters.Count; i++)
{
url += tile.emphasysSource.queryParameters[i].param.ToLower() + "=" + tile.emphasysSource.queryParameters[i].value.ToLower() + "&";
}
if (PararellProcessTiles)
{
result = await RequestAPI.processGetTile(url, tile.emphasysSource.path, true);
APIResponseTime.calculateResponseTime(tile.emphasysSource.url, DateTime.Now - startTime);
}
else
{
result = RequestAPISync.processGetTile(url, tile.emphasysSource.path, true);
APIResponseTime.calculateResponseTime(tile.emphasysSource.url, DateTime.Now - startTime);
}
}
var boolRes = Convert.ToBoolean(result);
return(boolRes);
}
catch (Exception ex)
{
Logger.Warn(ex.ToString());
return(null);
}
}
public static async Task <string> processGetTile(string uri, string path, bool firstTry)
{
uri = uri.ToLower();
string respString = null;
JToken item = null;
JObject jsonObject = null;
jsonObject = (JObject)MemoryCaches.memCache.Get(uri);
HttpResponseMessage response = null;
var cts = new CancellationTokenSource();
try
{
if (jsonObject != null)
{
if (jsonObject.ToString() == "error")
{
return(null);
}
}
else
{
using (HttpClient client = new HttpClient())
{
//client.Timeout = TimeSpan.FromMilliseconds(timoutAPI);
response = await client.GetAsync(uri);
Logger.Debug("GET: " + uri + " " + response.StatusCode.ToString());
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
respString = await response.Content.ReadAsStringAsync();
jsonObject = JObject.Parse(respString);
}
else
{
respString = await response.Content.ReadAsStringAsync();
APIResponseTime.calculateResponseCount(uri, response.StatusCode.ToString());
}
}
}
JObject jObject = (JObject)jsonObject;
if (jObject != null)
{
MemoryCaches.memCache.Set(uri, jObject, MemoryCache.InfiniteAbsoluteExpiration);
item = jObject.SelectToken("$." + path);
return(item.ToString());
}
else
{
MemoryCaches.memCache.Set(uri, "error", MemoryCache.InfiniteAbsoluteExpiration);
return(null);
}
}
catch (Exception ex)
{
if (firstTry)
{
await Task.Delay(retryAPI);
return(await processGetTile(uri, path, false));
}
else
{
MemoryCaches.memCache.Set(uri, "error", MemoryCache.InfiniteAbsoluteExpiration);
Logger.Warn("GET: " + uri + " " + path);
APIResponseTime.calculateResponseCount(uri, ex.GetType().ToString());
Logger.Warn(ex.ToString());
return(null);
}
}
}
public async Task <List <Message> > getMessages(List <string> things, string DashboardID)
{
if (DashboardID == "223")
{
Console.Write("");
}
List <Message> listMess = new List <Message>();
FilterStatus filter = new FilterStatus();
Dictionary <string, string> messagesForDashboard;
List <string> MessageForAll = new List <string>();
Message defaultMes = new Message();
Dictionary <string, string> localMesssages;
try
{
things = things.Where(x => x != null).ToList();
var startTime = DateTime.Now;
if (things.Count != 0)
{
filter.thingIds = things.Select(int.Parse).ToList();
filter.states = status;
messagesForDashboard = await RequestAPI.getAsyncMessages(server + statesBatchAddress, filter, DashboardID);
if (messagesForDashboard != null)
{
foreach (var message in messagesForDashboard)
{
string thingCode;
lock (MemoryCaches.memThings)
{
if (MemoryCaches.memThings.ContainsKey(message.Key))
{
thingCode = (string)MemoryCaches.memThings[message.Key];
MessageForAll.Add(thingCode + " - " + message.Value.Replace("_", " "));
}
}
}
}
}
MessageForAll.Sort();
APIResponseTime.calculateResponseTime(server + statesBatchAddress, DateTime.Now - startTime);
defaultMes.ip = "default";
if (MessageForAll.Count != 0)
{
defaultMes.messageList = MessageForAll;
}
else
{
defaultMes.messageList = new List <string>();
}
listMess.Add(defaultMes);
lock (MemoryCaches.memMessages)
{
if (MemoryCaches.memMessages != null)
{
localMesssages = new Dictionary <string, string>(MemoryCaches.memMessages);
}
else
{
localMesssages = new Dictionary <string, string>();
}
foreach (var display in localMesssages)
{
Message newMess = new Message();
newMess.ip = display.Key.ToString();
if (MessageForAll.Count != 0)
{
newMess.messageList = new List <string>(MessageForAll);
}
else
{
newMess.messageList = new List <string>();
}
newMess.messageList.Add(display.Value.ToString());
listMess.Add(newMess);
}
}
listMess = await getMessagesfromEndpoints(listMess, DashboardID);
return(listMess);
}
catch (Exception ex)
{
Logger.Error(DashboardID + " " + ex.ToString());
return(null);
}
}
