Samuele Locatelli
1215 lines
50 KiB
C#
1215 lines
50 KiB
C#
using EgwProxy.MagMan.DTO;
|
|
using Newtonsoft.Json;
|
|
using NLog;
|
|
using RestSharp;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using System.Net.NetworkInformation;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using System.Web;
|
|
|
|
namespace EgwProxy.MagMan
|
|
{
|
|
public class DataSyncro
|
|
{
|
|
#region Public Constructors
|
|
|
|
/// <summary>
|
|
/// Inizializza la libreria di comunicazione con il token assegnato
|
|
/// </summary>
|
|
/// <param name="serverUrl">URL del server</param>
|
|
/// <param name="authToken">Token di autorizzazione</param>
|
|
public DataSyncro(string serverUrl, string authToken)
|
|
{
|
|
RestToken = authToken;
|
|
servAddr = serverUrl;
|
|
apiUrl = $"https://{servAddr}/api/";
|
|
rcOptions = new RestClientOptions { BaseUrl = new Uri(apiUrl), Timeout = TimeSpan.FromMilliseconds(callTimeout) };
|
|
Log.Info($"DataSyncro initialized | api: {apiUrl} | timeout: {callTimeout}");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Inizializza la libreria di comunicazione con il token assegnato
|
|
/// </summary>
|
|
/// <param name="serverUrl">URL del server</param>
|
|
/// <param name="authToken">Token di autorizzazione</param>
|
|
/// <param name="timeout">Timeout chiamate in ms</param>
|
|
public DataSyncro(string serverUrl, string authToken, int timeout)
|
|
{
|
|
RestToken = authToken;
|
|
servAddr = serverUrl;
|
|
callTimeout = timeout;
|
|
apiUrl = $"https://{servAddr}/api/";
|
|
rcOptions = new RestClientOptions { BaseUrl = new Uri(apiUrl), Timeout = TimeSpan.FromMilliseconds(callTimeout) };
|
|
Log.Info($"DataSyncro initialized | api: {apiUrl} | timeout: {callTimeout}");
|
|
}
|
|
|
|
#endregion Public Constructors
|
|
|
|
#region Public Methods
|
|
|
|
/// <summary>
|
|
/// Test ping x indirizzo indicato
|
|
/// </summary>
|
|
/// <param name="tgtAddr">Indirizzo da pingare</param>
|
|
/// <returns></returns>
|
|
public static IPStatus pingAddress(string tgtAddr)
|
|
{
|
|
IPStatus answ = IPStatus.Unknown;
|
|
IPAddress address;
|
|
PingReply reply;
|
|
using (Ping pingSender = new Ping())
|
|
{
|
|
address = IPAddress.Loopback;
|
|
int pingMsTimeout = 500;
|
|
IPAddress.TryParse(tgtAddr, out address);
|
|
try
|
|
{
|
|
// se != null --> uso tgtAddr...
|
|
if (address != null)
|
|
{
|
|
reply = pingSender.Send(address, pingMsTimeout);
|
|
}
|
|
else
|
|
{
|
|
reply = pingSender.Send(tgtAddr, pingMsTimeout);
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
reply = pingSender.Send(IPAddress.Loopback, pingMsTimeout);
|
|
}
|
|
answ = reply.Status;
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Test ping x indirizzo indicato
|
|
/// </summary>
|
|
/// <param name="tgtAddr">Indirizzo da pingare</param>
|
|
/// <param name="timeout">Timeout chiamata in ms</param>
|
|
/// <returns></returns>
|
|
public static IPStatus pingAddress(string tgtAddr, int timeout)
|
|
{
|
|
IPStatus answ = IPStatus.Unknown;
|
|
IPAddress address;
|
|
PingReply reply;
|
|
using (Ping pingSender = new Ping())
|
|
{
|
|
address = IPAddress.Loopback;
|
|
int pingMsTimeout = timeout;
|
|
IPAddress.TryParse(tgtAddr, out address);
|
|
try
|
|
{
|
|
// se != null --> uso tgtAddr...
|
|
if (address != null && address != IPAddress.Loopback)
|
|
{
|
|
reply = pingSender.Send(address, pingMsTimeout);
|
|
}
|
|
else
|
|
{
|
|
reply = pingSender.Send(tgtAddr, pingMsTimeout);
|
|
}
|
|
answ = reply.Status;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
answ = IPStatus.Unknown;
|
|
Log.Error($"Errore in ping:{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco Alias dato RestToken
|
|
/// </summary>
|
|
public List<AliasDTO> AliasGet()
|
|
{
|
|
List<AliasDTO> answ = new List<AliasDTO>();
|
|
// cerco online
|
|
using (RestClient client = new RestClient(rcOptions))
|
|
{
|
|
string MKeyEnc = HttpUtility.UrlEncode(RestToken);
|
|
var request = new RestRequest($"Alias/{MKeyEnc}", Method.Get);
|
|
var response = client.Get(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == HttpStatusCode.OK)
|
|
{
|
|
// contenuto serializzato
|
|
string rawData = $"{response.Content}";
|
|
answ = JsonConvert.DeserializeObject<List<AliasDTO>>(rawData);
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Versione Async Elenco Alias dato RestToken
|
|
/// </summary>
|
|
public async Task<List<AliasDTO>> AliasGetAsync()
|
|
{
|
|
List<AliasDTO> answ = new List<AliasDTO>();
|
|
// cerco online
|
|
using (RestClient client = new RestClient(rcOptions))
|
|
{
|
|
string MKeyEnc = HttpUtility.UrlEncode(RestToken);
|
|
var request = new RestRequest($"Alias/{MKeyEnc}", Method.Get);
|
|
var response = await client.GetAsync(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == HttpStatusCode.OK)
|
|
{
|
|
// contenuto serializzato
|
|
string rawData = $"{response.Content}";
|
|
answ = JsonConvert.DeserializeObject<List<AliasDTO>>(rawData);
|
|
}
|
|
}
|
|
return await Task.FromResult(answ);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Invio elenco (anche parziale) di Alias, il server farà il merge
|
|
/// </summary>
|
|
public bool AliasSend(List<AliasDTO> List2Merge)
|
|
{
|
|
bool answ = false;
|
|
// cerco online
|
|
using (RestClient client = new RestClient(rcOptions))
|
|
{
|
|
string MKeyEnc = HttpUtility.UrlEncode(RestToken);
|
|
// impacchetto dati x invio...
|
|
RestPayload.Alias newPayload = new RestPayload.Alias()
|
|
{
|
|
AliasList = List2Merge
|
|
};
|
|
var jsonBody = JsonConvert.SerializeObject(newPayload);
|
|
var request = new RestRequest($"Alias/upsert/{MKeyEnc}", Method.Post).AddJsonBody(jsonBody);
|
|
var response = client.Post(request);
|
|
Log.Debug($"AliasSend | Response StatusCode: {response.StatusCode}");
|
|
// controllo risposta
|
|
if (response.StatusCode == HttpStatusCode.OK)
|
|
{
|
|
answ = true;
|
|
}
|
|
else
|
|
{
|
|
Log.Error($"AliasSend | Response StatusCode: {response.StatusCode} | content: {response.Content}");
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Versione async Invio elenco (anche parziale) di Alias, il server farà il merge
|
|
/// </summary>
|
|
public async Task<bool> AliasSendAsync(List<AliasDTO> List2Merge)
|
|
{
|
|
bool answ = false;
|
|
// cerco online
|
|
using (RestClient client = new RestClient(rcOptions))
|
|
{
|
|
string MKeyEnc = HttpUtility.UrlEncode(RestToken);
|
|
// impacchetto dati x invio...
|
|
RestPayload.Alias newPayload = new RestPayload.Alias()
|
|
{
|
|
AliasList = List2Merge
|
|
};
|
|
var jsonBody = JsonConvert.SerializeObject(newPayload);
|
|
var request = new RestRequest($"Alias/upsert/{MKeyEnc}", Method.Post).AddJsonBody(jsonBody);
|
|
var response = await client.PostAsync(request);
|
|
Log.Debug($"AliasSendAsync | Response StatusCode: {response.StatusCode}");
|
|
// controllo risposta
|
|
if (response.StatusCode == HttpStatusCode.OK)
|
|
{
|
|
answ = true;
|
|
}
|
|
else
|
|
{
|
|
Log.Error($"AliasSendAsync | Response StatusCode: {response.StatusCode} | content: {response.Content}");
|
|
}
|
|
}
|
|
return await Task.FromResult(answ);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua chiamata test sul server (ping), se fallisse riprova fino a maxTry volte
|
|
/// </summary>
|
|
/// <param name="maxTry">num tentativi in caso di KO</param>
|
|
/// <param name="waitTime">tempo di attesa medio tra tentativi in ms</param>
|
|
/// <returns></returns>
|
|
public bool CheckRemote(int maxTry = 5, int waitTime = 200)
|
|
{
|
|
bool res = false;
|
|
int numTry = 0;
|
|
IPAddress address = IPAddress.Loopback;
|
|
string srvName = servAddr;
|
|
// tolgo eventuale nome con ":"
|
|
if (servAddr.Contains(":"))
|
|
{
|
|
srvName = servAddr.Substring(0, servAddr.IndexOf(":"));
|
|
}
|
|
// tolgo eventuale nome con "/"
|
|
if (servAddr.Contains("/"))
|
|
{
|
|
srvName = servAddr.Substring(0, servAddr.IndexOf("/"));
|
|
}
|
|
while (!res && numTry < maxTry)
|
|
{
|
|
res = pingAddress(srvName, callTimeout) == IPStatus.Success;
|
|
numTry++;
|
|
if (!res)
|
|
{
|
|
Thread.Sleep(waitTime);
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Inventario per materiale
|
|
/// </summary>
|
|
/// <param name="MatID">Se 0 = tutto</param>
|
|
/// <returns></returns>
|
|
public List<MaterialDTO> InventoryGet(int MatID)
|
|
{
|
|
List<MaterialDTO> answ = new List<MaterialDTO>();
|
|
// cerco online
|
|
using (RestClient client = new RestClient(rcOptions))
|
|
{
|
|
string MKeyEnc = HttpUtility.UrlEncode(RestToken);
|
|
var request = new RestRequest($"Inventory/{MKeyEnc}?MatCloudId={MatID}", Method.Get);
|
|
var response = client.Get(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == HttpStatusCode.OK)
|
|
{
|
|
// contenuto serializzato
|
|
string rawData = $"{response.Content}";
|
|
answ = JsonConvert.DeserializeObject<List<MaterialDTO>>(rawData);
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Versione Async Inventario per materiale
|
|
/// </summary>
|
|
/// <param name="MatID">Se 0 = tutto</param>
|
|
/// <returns></returns>
|
|
public async Task<List<MaterialDTO>> InventoryGetAsync(int MatID)
|
|
{
|
|
List<MaterialDTO> answ = new List<MaterialDTO>();
|
|
// cerco online
|
|
using (RestClient client = new RestClient(rcOptions))
|
|
{
|
|
string MKeyEnc = HttpUtility.UrlEncode(RestToken);
|
|
var request = new RestRequest($"Inventory/{MKeyEnc}?MatCloudId={MatID}", Method.Get);
|
|
var response = await client.GetAsync(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == HttpStatusCode.OK)
|
|
{
|
|
// contenuto serializzato
|
|
string rawData = $"{response.Content}";
|
|
answ = JsonConvert.DeserializeObject<List<MaterialDTO>>(rawData);
|
|
}
|
|
}
|
|
return await Task.FromResult(answ);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Invio elenco di RawItems associati ad un singolo materiale, il server farà il merge
|
|
/// <param name="rec2send">record da inviare</param>
|
|
/// </summary>
|
|
public bool InventorySend(List<ItemDTO> rec2send)
|
|
{
|
|
bool answ = false;
|
|
// cerco online
|
|
using (RestClient client = new RestClient(rcOptions))
|
|
{
|
|
string MKeyEnc = HttpUtility.UrlEncode(RestToken);
|
|
// impacchetto dati x invio...
|
|
RestPayload.Items newPayload = new RestPayload.Items()
|
|
{
|
|
ItemList = rec2send
|
|
};
|
|
var jsonBody = JsonConvert.SerializeObject(newPayload);
|
|
var request = new RestRequest($"Inventory/upsert/{MKeyEnc}", Method.Post).AddJsonBody(jsonBody);
|
|
var response = client.Post(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == HttpStatusCode.OK)
|
|
{
|
|
answ = true;
|
|
}
|
|
else
|
|
{
|
|
Log.Error($"InventorySend | Response StatusCode: {response.StatusCode} | content: {response.Content}");
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Versione Async Invio elenco di RawItems associati ad un singolo materiale, il server
|
|
/// farà il merge <param name="rec2send">record da inviare</param>
|
|
/// </summary>
|
|
public async Task<bool> InventorySendAsync(List<ItemDTO> rec2send)
|
|
{
|
|
bool answ = false;
|
|
// cerco online
|
|
using (RestClient client = new RestClient(rcOptions))
|
|
{
|
|
string MKeyEnc = HttpUtility.UrlEncode(RestToken);
|
|
// impacchetto dati x invio...
|
|
RestPayload.Items newPayload = new RestPayload.Items()
|
|
{
|
|
ItemList = rec2send
|
|
};
|
|
var jsonBody = JsonConvert.SerializeObject(newPayload);
|
|
var request = new RestRequest($"Inventory/upsert/{MKeyEnc}", Method.Post).AddJsonBody(jsonBody);
|
|
var response = await client.PostAsync(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == HttpStatusCode.OK)
|
|
{
|
|
answ = true;
|
|
}
|
|
else
|
|
{
|
|
Log.Error($"InventorySendAsync | Response StatusCode: {response.StatusCode} | content: {response.Content}");
|
|
}
|
|
}
|
|
return await Task.FromResult(answ);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Invio richiesta cancellazione set dati log macchina
|
|
/// </summary>
|
|
/// <param name="dtStart">Data inizio set da eliminare</param>
|
|
/// <param name="dtEnd">Data fine set da eliminare</param>
|
|
/// <returns></returns>
|
|
public bool LogMachineRemoveRange(DateTime dtStart, DateTime dtEnd)
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
// chiamo update online
|
|
using (RestClient client = new RestClient(rcOptions))
|
|
{
|
|
string MKeyEnc = HttpUtility.UrlEncode(RestToken);
|
|
// impacchetto dati x invio...
|
|
RestPayload.PeriodData newPayload = new RestPayload.PeriodData()
|
|
{
|
|
DtEnd = dtEnd,
|
|
DtStart = dtStart
|
|
};
|
|
var jsonBody = JsonConvert.SerializeObject(newPayload);
|
|
var request = new RestRequest($"LogMachine/remove/{MKeyEnc}", Method.Post).AddJsonBody(jsonBody);
|
|
var response = client.Post(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == HttpStatusCode.OK)
|
|
{
|
|
Log.Debug($"LogMachineRemoveRange | Response StatusCode: {response.StatusCode} | content: {response.Content}");
|
|
answ = true;
|
|
}
|
|
else
|
|
{
|
|
Log.Error($"LogMachineRemoveRange | Response StatusCode: {response.StatusCode} | content: {response.Content}");
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"LogMachineRemoveRange | Eccezione {Environment.NewLine}{exc.Message}");
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Invio elenco LogMachine da tab locale
|
|
/// </summary>
|
|
/// <param name="rec2send">record da inviare</param>
|
|
/// <returns></returns>
|
|
public bool LogMachineSend(List<LogMachineDTO> rec2send)
|
|
{
|
|
bool answ = false;
|
|
if (rec2send != null && rec2send.Count > 0)
|
|
{
|
|
try
|
|
{
|
|
// chiamo update online
|
|
using (RestClient client = new RestClient(rcOptions))
|
|
{
|
|
string MKeyEnc = HttpUtility.UrlEncode(RestToken);
|
|
// impacchetto dati x invio...
|
|
RestPayload.LogData newPayload = new RestPayload.LogData()
|
|
{
|
|
LogList = rec2send
|
|
};
|
|
var jsonBody = JsonConvert.SerializeObject(newPayload);
|
|
var request = new RestRequest($"LogMachine/upsert/{MKeyEnc}", Method.Post).AddJsonBody(jsonBody);
|
|
var response = client.Post(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == HttpStatusCode.OK)
|
|
{
|
|
Log.Debug($"LogMachineSend | #rec: {rec2send.Count} | Response StatusCode: {response.StatusCode} | content: {response.Content}");
|
|
answ = true;
|
|
}
|
|
else
|
|
{
|
|
Log.Error($"LogMachineSend | #rec: {rec2send.Count} | Response StatusCode: {response.StatusCode} | content: {response.Content}");
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"LogMachineSend | Eccezione {Environment.NewLine}{exc.Message}");
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Versione async Invio elenco LogMachine da tab locale
|
|
/// </summary>
|
|
/// <param name="rec2send">record da inviare, se consumo Qty deve essere negativa</param>
|
|
/// <returns></returns>
|
|
public async Task<bool> LogMachineSendAsync(List<LogMachineDTO> rec2send)
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
// chiamo update online
|
|
using (RestClient client = new RestClient(rcOptions))
|
|
{
|
|
string MKeyEnc = HttpUtility.UrlEncode(RestToken);
|
|
// impacchetto dati x invio...
|
|
RestPayload.LogData newPayload = new RestPayload.LogData()
|
|
{
|
|
LogList = rec2send
|
|
};
|
|
var jsonBody = JsonConvert.SerializeObject(newPayload);
|
|
var request = new RestRequest($"LogMachine/upsert/{MKeyEnc}", Method.Post).AddJsonBody(jsonBody);
|
|
var response = await client.PostAsync(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == HttpStatusCode.OK)
|
|
{
|
|
Log.Debug($"LogMachineSendAsync | #rec: {rec2send.Count} | Response StatusCode: {response.StatusCode} | content: {response.Content}");
|
|
answ = true;
|
|
}
|
|
else
|
|
{
|
|
Log.Error($"LogMachineSendAsync | #rec: {rec2send.Count} | Response StatusCode: {response.StatusCode} | content: {response.Content}");
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"LogMachineSendAsync | Eccezione {Environment.NewLine}{exc.Message}");
|
|
}
|
|
return await Task.FromResult(answ);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco Materiali dato RestToken
|
|
/// </summary>
|
|
public List<MaterialDTO> MaterialsGet()
|
|
{
|
|
List<MaterialDTO> answ = new List<MaterialDTO>();
|
|
// cerco online
|
|
using (RestClient client = new RestClient(rcOptions))
|
|
{
|
|
string MKeyEnc = HttpUtility.UrlEncode(RestToken);
|
|
var request = new RestRequest($"Materials/{MKeyEnc}", Method.Get);
|
|
var response = client.Get(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == HttpStatusCode.OK)
|
|
{
|
|
// contenuto serializzato
|
|
string rawData = $"{response.Content}";
|
|
answ = JsonConvert.DeserializeObject<List<MaterialDTO>>(rawData);
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Versione Async Elenco Materiali dato RestToken
|
|
/// </summary>
|
|
public async Task<List<MaterialDTO>> MaterialsGetAsync()
|
|
{
|
|
List<MaterialDTO> answ = new List<MaterialDTO>();
|
|
// cerco online
|
|
using (RestClient client = new RestClient(rcOptions))
|
|
{
|
|
string MKeyEnc = HttpUtility.UrlEncode(RestToken);
|
|
var request = new RestRequest($"Materials/{MKeyEnc}", Method.Get);
|
|
var response = await client.GetAsync(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == HttpStatusCode.OK)
|
|
{
|
|
// contenuto serializzato
|
|
string rawData = $"{response.Content}";
|
|
answ = JsonConvert.DeserializeObject<List<MaterialDTO>>(rawData);
|
|
}
|
|
}
|
|
return await Task.FromResult(answ);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Invio elenco (anche parziale) di Materiali, il server farà il merge
|
|
/// </summary>
|
|
public bool MaterialsSend(List<MaterialDTO> List2Merge)
|
|
{
|
|
bool answ = false;
|
|
// cerco online
|
|
using (RestClient client = new RestClient(rcOptions))
|
|
{
|
|
string MKeyEnc = HttpUtility.UrlEncode(RestToken);
|
|
// impacchetto dati x invio...
|
|
RestPayload.Materials newPayload = new RestPayload.Materials()
|
|
{
|
|
MatList = List2Merge
|
|
};
|
|
var jsonBody = JsonConvert.SerializeObject(newPayload);
|
|
var request = new RestRequest($"Materials/upsert/{MKeyEnc}", Method.Post).AddJsonBody(jsonBody);
|
|
var response = client.Post(request);
|
|
Log.Debug($"MaterialsSend | Response StatusCode: {response.StatusCode}");
|
|
// controllo risposta
|
|
if (response.StatusCode == HttpStatusCode.OK)
|
|
{
|
|
answ = true;
|
|
}
|
|
else
|
|
{
|
|
Log.Error($"MaterialsSend | Response StatusCode: {response.StatusCode} | content: {response.Content}");
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Versione async Invio elenco (anche parziale) di Materiali, il server farà il merge
|
|
/// </summary>
|
|
public async Task<bool> MaterialsSendAsync(List<MaterialDTO> List2Merge)
|
|
{
|
|
bool answ = false;
|
|
// cerco online
|
|
using (RestClient client = new RestClient(rcOptions))
|
|
{
|
|
string MKeyEnc = HttpUtility.UrlEncode(RestToken);
|
|
// impacchetto dati x invio...
|
|
RestPayload.Materials newPayload = new RestPayload.Materials()
|
|
{
|
|
MatList = List2Merge
|
|
};
|
|
var jsonBody = JsonConvert.SerializeObject(newPayload);
|
|
var request = new RestRequest($"Materials/upsert/{MKeyEnc}", Method.Post).AddJsonBody(jsonBody);
|
|
var response = await client.PostAsync(request);
|
|
Log.Debug($"MaterialsSendAsync | Response StatusCode: {response.StatusCode}");
|
|
// controllo risposta
|
|
if (response.StatusCode == HttpStatusCode.OK)
|
|
{
|
|
answ = true;
|
|
}
|
|
else
|
|
{
|
|
Log.Error($"MaterialsSendAsync | Response StatusCode: {response.StatusCode} | content: {response.Content}");
|
|
}
|
|
}
|
|
return await Task.FromResult(answ);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Invio dizionario progetti con stato archiviato...
|
|
/// </summary>
|
|
/// <param name="DtLimit">Data limite x recupero record modificati</param>
|
|
/// <returns>Dizionario ProjCloudId / Stato archived</returns>
|
|
public Dictionary<int, bool> ProjectArchGet(DateTime DtLimit)
|
|
{
|
|
RestPayload.ProjStatusData answ = new RestPayload.ProjStatusData();
|
|
// cerco online
|
|
using (RestClient client = new RestClient(rcOptions))
|
|
{
|
|
string MKeyEnc = HttpUtility.UrlEncode(RestToken);
|
|
var request = new RestRequest($"Projects/proj-arch-get/{MKeyEnc}?DtLim={DtLimit:yyyyMMddHHmmss}", Method.Get);
|
|
var response = client.Get(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == HttpStatusCode.OK)
|
|
{
|
|
// contenuto serializzato
|
|
string rawData = $"{response.Content}";
|
|
answ = JsonConvert.DeserializeObject<RestPayload.ProjStatusData>(rawData);
|
|
}
|
|
else
|
|
{
|
|
Log.Error($"ProjectArchGet | Response StatusCode: {response.StatusCode} | content: {response.Content}");
|
|
}
|
|
}
|
|
return answ.ProjStatusList;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Versione async Invio dizionario progetti con stato archiviato...
|
|
/// </summary>
|
|
/// <param name="DtLimit">Data limite x recupero record modificati</param>
|
|
/// <returns>Dizionario ProjCloudId / Stato archived</returns>
|
|
public async Task<Dictionary<int, bool>> ProjectArchGetAsync(DateTime DtLimit)
|
|
{
|
|
RestPayload.ProjStatusData answ = new RestPayload.ProjStatusData();
|
|
// cerco online
|
|
using (RestClient client = new RestClient(rcOptions))
|
|
{
|
|
string MKeyEnc = HttpUtility.UrlEncode(RestToken);
|
|
var request = new RestRequest($"Projects/proj-arch-get/{MKeyEnc}?DtLim={DtLimit:yyyyMMddHHmmss}", Method.Get);
|
|
var response = await client.GetAsync(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == HttpStatusCode.OK)
|
|
{
|
|
// contenuto serializzato
|
|
string rawData = $"{response.Content}";
|
|
answ = JsonConvert.DeserializeObject<RestPayload.ProjStatusData>(rawData);
|
|
}
|
|
else
|
|
{
|
|
Log.Error($"ProjectArchGetAsync | Response StatusCode: {response.StatusCode} | content: {response.Content}");
|
|
}
|
|
}
|
|
return await Task.FromResult(answ.ProjStatusList);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Invio dizionario progetti con stato archiviato...
|
|
/// </summary>
|
|
/// <param name="rec2send">record da inviare come dizionario ProjCloudId / Stato archived</param>
|
|
/// <returns>Esito esecuzione</returns>
|
|
public bool ProjectArchSend(Dictionary<int, bool> rec2send)
|
|
{
|
|
bool answ = false;
|
|
// cerco online
|
|
using (RestClient client = new RestClient(rcOptions))
|
|
{
|
|
string MKeyEnc = HttpUtility.UrlEncode(RestToken);
|
|
// impacchetto dati x invio...
|
|
RestPayload.ProjStatusData newPayload = new RestPayload.ProjStatusData()
|
|
{
|
|
ProjStatusList = rec2send
|
|
};
|
|
var jsonBody = JsonConvert.SerializeObject(newPayload);
|
|
var request = new RestRequest($"Projects/proj-arch-send/{MKeyEnc}", Method.Post).AddJsonBody(jsonBody);
|
|
var response = client.Post(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == HttpStatusCode.OK)
|
|
{
|
|
bool.TryParse(response.Content, out answ);
|
|
}
|
|
else
|
|
{
|
|
Log.Error($"ProjectArchSend | Response StatusCode: {response.StatusCode} | content: {response.Content}");
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Versione async Invio dizionario progetti con stato archiviato...
|
|
/// </summary>
|
|
/// <param name="rec2send">record da inviare come dizionario ProjCloudId / Stato archived</param>
|
|
/// <returns>Esito esecuzione</returns>
|
|
public async Task<bool> ProjectArchSendAsync(Dictionary<int, bool> rec2send)
|
|
{
|
|
bool answ = false;
|
|
// cerco online
|
|
using (RestClient client = new RestClient(rcOptions))
|
|
{
|
|
string MKeyEnc = HttpUtility.UrlEncode(RestToken);
|
|
// impacchetto dati x invio...
|
|
RestPayload.ProjStatusData newPayload = new RestPayload.ProjStatusData()
|
|
{
|
|
ProjStatusList = rec2send
|
|
};
|
|
var jsonBody = JsonConvert.SerializeObject(newPayload);
|
|
var request = new RestRequest($"Projects/proj-arch-send/{MKeyEnc}", Method.Post).AddJsonBody(jsonBody);
|
|
var response = await client.PostAsync(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == HttpStatusCode.OK)
|
|
{
|
|
bool.TryParse(response.Content, out answ);
|
|
}
|
|
else
|
|
{
|
|
Log.Error($"ProjectArchSendAsync | Response StatusCode: {response.StatusCode} | content: {response.Content}");
|
|
}
|
|
}
|
|
return await Task.FromResult(answ);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco progetti associati a chiave
|
|
/// </summary>
|
|
/// <param name="NumKey">Se 0 = tutto</param>
|
|
/// <returns></returns>
|
|
public List<ProjectDTO> ProjectGet(int NumKey)
|
|
{
|
|
List<ProjectDTO> answ = new List<ProjectDTO>();
|
|
// cerco online
|
|
using (RestClient client = new RestClient(rcOptions))
|
|
{
|
|
string MKeyEnc = HttpUtility.UrlEncode(RestToken);
|
|
var request = new RestRequest($"Projects/{MKeyEnc}?KeyNum={NumKey}", Method.Get);
|
|
var response = client.Get(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == HttpStatusCode.OK)
|
|
{
|
|
// contenuto serializzato
|
|
string rawData = $"{response.Content}";
|
|
answ = JsonConvert.DeserializeObject<List<ProjectDTO>>(rawData);
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Versione Async Elenco progetti associati a chiave
|
|
/// </summary>
|
|
/// <param name="MatID">Se 0 = tutto</param>
|
|
/// <returns></returns>
|
|
public async Task<List<ProjectDTO>> ProjectGetAsync(int NumKey)
|
|
{
|
|
List<ProjectDTO> answ = new List<ProjectDTO>();
|
|
// cerco online
|
|
using (RestClient client = new RestClient(rcOptions))
|
|
{
|
|
string MKeyEnc = HttpUtility.UrlEncode(RestToken);
|
|
var request = new RestRequest($"Projects/{MKeyEnc}?KeyNum={NumKey}", Method.Get);
|
|
var response = await client.GetAsync(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == HttpStatusCode.OK)
|
|
{
|
|
// contenuto serializzato
|
|
string rawData = $"{response.Content}";
|
|
answ = JsonConvert.DeserializeObject<List<ProjectDTO>>(rawData);
|
|
}
|
|
}
|
|
return await Task.FromResult(answ);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Record progetto da Key/ID
|
|
/// </summary>
|
|
/// <param name="ProjCloudId">Se 0 = tutto</param>
|
|
/// <returns></returns>
|
|
public ProjectDTO ProjectGetSingle(int ProjCloudId)
|
|
{
|
|
ProjectDTO answ = new ProjectDTO();
|
|
// cerco online
|
|
using (RestClient client = new RestClient(rcOptions))
|
|
{
|
|
string MKeyEnc = HttpUtility.UrlEncode(RestToken);
|
|
var request = new RestRequest($"Projects/single/{MKeyEnc}?ProjCloudId={ProjCloudId}", Method.Get);
|
|
var response = client.Get(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == HttpStatusCode.OK)
|
|
{
|
|
// contenuto serializzato
|
|
string rawData = $"{response.Content}";
|
|
answ = JsonConvert.DeserializeObject<ProjectDTO>(rawData);
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Record progetto da Key/ID
|
|
/// </summary>
|
|
/// <param name="ProjCloudId">Se 0 = tutto</param>
|
|
/// <returns></returns>
|
|
public async Task<ProjectDTO> ProjectGetSingleAsync(int ProjCloudId)
|
|
{
|
|
ProjectDTO answ = new ProjectDTO();
|
|
// cerco online
|
|
using (RestClient client = new RestClient(rcOptions))
|
|
{
|
|
string MKeyEnc = HttpUtility.UrlEncode(RestToken);
|
|
var request = new RestRequest($"Projects/single/{MKeyEnc}?ProjCloudId={ProjCloudId}", Method.Get);
|
|
var response = await client.GetAsync(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == HttpStatusCode.OK)
|
|
{
|
|
// contenuto serializzato
|
|
string rawData = $"{response.Content}";
|
|
answ = JsonConvert.DeserializeObject<ProjectDTO>(rawData);
|
|
}
|
|
}
|
|
return await Task.FromResult(answ);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Invio record ProjProg x aggiornamento stato
|
|
/// </summary>
|
|
/// <param name="rec2send">record da inviare</param>
|
|
/// <returns>ProjCloudId (essitente o nuovo)</returns>
|
|
public bool ProjectProgrSend(ProjectProgrDTO rec2send)
|
|
{
|
|
bool answ = false;
|
|
// cerco online
|
|
using (RestClient client = new RestClient(rcOptions))
|
|
{
|
|
string MKeyEnc = HttpUtility.UrlEncode(RestToken);
|
|
// impacchetto dati x invio...
|
|
RestPayload.ProdInfoData newPayload = new RestPayload.ProdInfoData()
|
|
{
|
|
ProjectProgress = rec2send
|
|
};
|
|
var jsonBody = JsonConvert.SerializeObject(newPayload);
|
|
var request = new RestRequest($"Projects/prod-update/{MKeyEnc}", Method.Post).AddJsonBody(jsonBody);
|
|
var response = client.Post(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == HttpStatusCode.OK)
|
|
{
|
|
bool.TryParse(response.Content, out answ);
|
|
}
|
|
else
|
|
{
|
|
Log.Error($"ProjectProgrSend | Response StatusCode: {response.StatusCode} | content: {response.Content}");
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Versione async Invio record ProjProg x aggiornamento stato
|
|
/// </summary>
|
|
/// <param name="rec2send">record da inviare</param>
|
|
public async Task<bool> ProjectProgrSendAsync(ProjectProgrDTO rec2send)
|
|
{
|
|
bool answ = false;
|
|
// cerco online
|
|
using (RestClient client = new RestClient(rcOptions))
|
|
{
|
|
string MKeyEnc = HttpUtility.UrlEncode(RestToken);
|
|
// impacchetto dati x invio...
|
|
RestPayload.ProdInfoData newPayload = new RestPayload.ProdInfoData()
|
|
{
|
|
ProjectProgress = rec2send
|
|
};
|
|
var jsonBody = JsonConvert.SerializeObject(newPayload);
|
|
var request = new RestRequest($"Projects/prod-update/{MKeyEnc}", Method.Post).AddJsonBody(jsonBody);
|
|
var response = await client.PostAsync(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == HttpStatusCode.OK)
|
|
{
|
|
bool.TryParse(response.Content, out answ);
|
|
}
|
|
else
|
|
{
|
|
Log.Error($"ProjectProgrSendAsync | Response StatusCode: {response.StatusCode} | content: {response.Content}");
|
|
}
|
|
}
|
|
return await Task.FromResult(answ);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Invio record Proj x upsert
|
|
/// </summary>
|
|
/// <param name="rec2send">record da inviare</param>
|
|
/// <returns>ProjCloudId (essitente o nuovo)</returns>
|
|
public int ProjectSend(ProjectDTO rec2send)
|
|
{
|
|
int answ = 0;
|
|
// cerco online
|
|
using (RestClient client = new RestClient(rcOptions))
|
|
{
|
|
string MKeyEnc = HttpUtility.UrlEncode(RestToken);
|
|
// impacchetto dati x invio...
|
|
RestPayload.Projects newPayload = new RestPayload.Projects()
|
|
{
|
|
Project = rec2send
|
|
};
|
|
var jsonBody = JsonConvert.SerializeObject(newPayload);
|
|
var request = new RestRequest($"Projects/upsert/{MKeyEnc}", Method.Post).AddJsonBody(jsonBody);
|
|
var response = client.Post(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == HttpStatusCode.OK)
|
|
{
|
|
int.TryParse(response.Content, out answ);
|
|
}
|
|
else
|
|
{
|
|
Log.Error($"ProjectSend | Response StatusCode: {response.StatusCode} | content: {response.Content}");
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Versione async Invio Proj x upsert
|
|
/// </summary>
|
|
/// <param name="rec2send">record da inviare</param>
|
|
public async Task<int> ProjectSendAsync(ProjectDTO rec2send)
|
|
{
|
|
int answ = 0;
|
|
// cerco online
|
|
using (RestClient client = new RestClient(rcOptions))
|
|
{
|
|
string MKeyEnc = HttpUtility.UrlEncode(RestToken);
|
|
// impacchetto dati x invio...
|
|
RestPayload.Projects newPayload = new RestPayload.Projects()
|
|
{
|
|
Project = rec2send
|
|
};
|
|
var jsonBody = JsonConvert.SerializeObject(newPayload);
|
|
var request = new RestRequest($"Projects/upsert/{MKeyEnc}", Method.Post).AddJsonBody(jsonBody);
|
|
var response = await client.PostAsync(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == HttpStatusCode.OK)
|
|
{
|
|
int.TryParse(response.Content, out answ);
|
|
}
|
|
else
|
|
{
|
|
Log.Error($"ProjectSendAsync | Response StatusCode: {response.StatusCode} | content: {response.Content}");
|
|
}
|
|
}
|
|
return await Task.FromResult(answ);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Verifica elenco di risorse associate ad un progetto
|
|
/// </summary>
|
|
/// <param name="idxProjDbId">DbId del progetto da inviare</param>
|
|
/// <param name="recType">tipo di registrazione da inviare (stima, consumo, ...)</param>
|
|
/// <param name="dtRif">DataOra di riferimento del record</param>
|
|
/// <param name="rec2send">record da inviare, se consumo Qty deve essere negativa</param>
|
|
/// <returns>0 = errore comunicazione / 1 = risorse invariate / 2 = risorse cambiate</returns>
|
|
public int ResourceCheck(int idxProjDbId, ProjResState recType, DateTime dtRif, List<ResourceDTO> rec2send)
|
|
{
|
|
int answ = 0;
|
|
// cerco online
|
|
using (RestClient client = new RestClient(rcOptions))
|
|
{
|
|
string MKeyEnc = HttpUtility.UrlEncode(RestToken);
|
|
// impacchetto dati x invio...
|
|
RestPayload.Resources newPayload = new RestPayload.Resources()
|
|
{
|
|
DtReq = dtRif,
|
|
ProjCloudId = idxProjDbId,
|
|
ReqState = recType,
|
|
ResourceList = rec2send
|
|
};
|
|
var jsonBody = JsonConvert.SerializeObject(newPayload);
|
|
var request = new RestRequest($"Resources/check/{MKeyEnc}", Method.Post).AddJsonBody(jsonBody);
|
|
var response = client.Post(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == HttpStatusCode.OK)
|
|
{
|
|
answ = response.Content == "EQUAL" ? 1 : 2;
|
|
}
|
|
else
|
|
{
|
|
Log.Error($"ResourceCheck | Response StatusCode: {response.StatusCode} | content: {response.Content}");
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Versione async Verifica elenco di risorse associate ad un progetto
|
|
/// </summary>
|
|
/// <param name="idxProjDbId">DbId del progetto da inviare</param>
|
|
/// <param name="recType">tipo di registrazione da inviare (stima, consumo, ...)</param>
|
|
/// <param name="rec2send">record da inviare, se consumo Qty deve essere negativa</param>
|
|
/// <returns>0 = errore comunicazione / 1 = risorse invariate / 2 = risorse cambiate</returns>
|
|
public async Task<int> ResourceCheckAsync(int idxProjDbId, ProjResState recType, List<ResourceDTO> rec2send)
|
|
{
|
|
int answ = 0;
|
|
// cerco online
|
|
using (RestClient client = new RestClient(rcOptions))
|
|
{
|
|
string MKeyEnc = HttpUtility.UrlEncode(RestToken);
|
|
// impacchetto dati x invio...
|
|
RestPayload.Resources newPayload = new RestPayload.Resources()
|
|
{
|
|
ProjCloudId = idxProjDbId,
|
|
ReqState = recType,
|
|
ResourceList = rec2send
|
|
};
|
|
var jsonBody = JsonConvert.SerializeObject(newPayload);
|
|
var request = new RestRequest($"Resources/check/{MKeyEnc}", Method.Post).AddJsonBody(jsonBody);
|
|
var response = await client.PostAsync(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == HttpStatusCode.OK)
|
|
{
|
|
answ = response.Content == "EQUAL" ? 1 : 2;
|
|
}
|
|
else
|
|
{
|
|
Log.Error($"ResourceCheckAsync | Response StatusCode: {response.StatusCode} | content: {response.Content}");
|
|
}
|
|
}
|
|
return await Task.FromResult(answ);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco risorse associate a progetto
|
|
/// </summary>
|
|
/// <param name="projDbId">ID DB del progetto</param>
|
|
/// <param name="isEstim">true = solo stimate/ false = consumi reali</param>
|
|
/// <returns></returns>
|
|
public List<ResourceExpDTO> ResourceGet(int projDbId, bool isEstim)
|
|
{
|
|
List<ResourceExpDTO> answ = new List<ResourceExpDTO>();
|
|
// cerco online
|
|
using (RestClient client = new RestClient(rcOptions))
|
|
{
|
|
string MKeyEnc = HttpUtility.UrlEncode(RestToken);
|
|
var request = new RestRequest($"Resources/{MKeyEnc}?projDbId={projDbId}&isEstim={isEstim}", Method.Get);
|
|
var response = client.Get(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == HttpStatusCode.OK)
|
|
{
|
|
// contenuto serializzato
|
|
string rawData = $"{response.Content}";
|
|
answ = JsonConvert.DeserializeObject<List<ResourceExpDTO>>(rawData);
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Versione async Elenco risorse associate a progetto
|
|
/// </summary>
|
|
/// <param name="projDbId">ID DB del progetto</param>
|
|
/// <param name="isEstim">true = solo stimate/ false = consumi reali</param>
|
|
/// <returns></returns>
|
|
public async Task<List<ResourceExpDTO>> ResourceGetAsync(int projDbId, bool isEstim)
|
|
{
|
|
List<ResourceExpDTO> answ = new List<ResourceExpDTO>();
|
|
// cerco online
|
|
using (RestClient client = new RestClient(rcOptions))
|
|
{
|
|
string MKeyEnc = HttpUtility.UrlEncode(RestToken);
|
|
var request = new RestRequest($"Resources/{MKeyEnc}?projDbId={projDbId}&isEstim={isEstim}", Method.Get);
|
|
var response = await client.GetAsync(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == HttpStatusCode.OK)
|
|
{
|
|
// contenuto serializzato
|
|
string rawData = $"{response.Content}";
|
|
answ = JsonConvert.DeserializeObject<List<ResourceExpDTO>>(rawData);
|
|
}
|
|
}
|
|
return await Task.FromResult(answ);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Invio elenco di risorse associate ad un progetto
|
|
/// </summary>
|
|
/// <param name="idxProjDbId">DbId del progetto da inviare</param>
|
|
/// <param name="recType">tipo di registrazione da inviare (stima, consumo, ...)</param>
|
|
/// <param name="dtRif">DataOra di riferimento del record</param>
|
|
/// <param name="rec2send">record da inviare, se consumo Qty deve essere negativa</param>
|
|
/// <returns></returns>
|
|
public bool ResourceSend(int idxProjDbId, ProjResState recType, DateTime dtRif, List<ResourceDTO> rec2send)
|
|
{
|
|
bool answ = false;
|
|
// cerco online
|
|
using (RestClient client = new RestClient(rcOptions))
|
|
{
|
|
string MKeyEnc = HttpUtility.UrlEncode(RestToken);
|
|
// impacchetto dati x invio...
|
|
RestPayload.Resources newPayload = new RestPayload.Resources()
|
|
{
|
|
DtReq = dtRif,
|
|
ProjCloudId = idxProjDbId,
|
|
ReqState = recType,
|
|
ResourceList = rec2send
|
|
};
|
|
var jsonBody = JsonConvert.SerializeObject(newPayload);
|
|
var request = new RestRequest($"Resources/track/{MKeyEnc}", Method.Post).AddJsonBody(jsonBody);
|
|
var response = client.Post(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == HttpStatusCode.OK)
|
|
{
|
|
answ = true;
|
|
}
|
|
else
|
|
{
|
|
Log.Error($"ResourceSend | Response StatusCode: {response.StatusCode} | content: {response.Content}");
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Versione async Invio elenco di risorse associate ad un progetto
|
|
/// </summary>
|
|
/// <param name="idxProjDbId">DbId del progetto da inviare</param>
|
|
/// <param name="recType">tipo di registrazione da inviare (stima, consumo, ...)</param>
|
|
/// <param name="rec2send">record da inviare, se consumo Qty deve essere negativa</param>
|
|
/// <returns></returns>
|
|
public async Task<bool> ResourceSendAsync(int idxProjDbId, ProjResState recType, List<ResourceDTO> rec2send)
|
|
{
|
|
bool answ = false;
|
|
// cerco online
|
|
using (RestClient client = new RestClient(rcOptions))
|
|
{
|
|
string MKeyEnc = HttpUtility.UrlEncode(RestToken);
|
|
// impacchetto dati x invio...
|
|
RestPayload.Resources newPayload = new RestPayload.Resources()
|
|
{
|
|
ProjCloudId = idxProjDbId,
|
|
ReqState = recType,
|
|
ResourceList = rec2send
|
|
};
|
|
var jsonBody = JsonConvert.SerializeObject(newPayload);
|
|
var request = new RestRequest($"Resources/track/{MKeyEnc}", Method.Post).AddJsonBody(jsonBody);
|
|
var response = await client.PostAsync(request);
|
|
// controllo risposta
|
|
if (response.StatusCode == HttpStatusCode.OK)
|
|
{
|
|
answ = true;
|
|
}
|
|
else
|
|
{
|
|
Log.Error($"ResourceSendAsync | Response StatusCode: {response.StatusCode} | content: {response.Content}");
|
|
}
|
|
}
|
|
return await Task.FromResult(answ);
|
|
}
|
|
|
|
#endregion Public Methods
|
|
|
|
#region Private Fields
|
|
|
|
/// <summary>
|
|
/// Istanza logger
|
|
/// </summary>
|
|
private static Logger Log = LogManager.GetCurrentClassLogger();
|
|
|
|
/// <summary>
|
|
/// URL dell'API x chiamate gestione licenze
|
|
/// </summary>
|
|
private string apiUrl = $"";
|
|
|
|
private int callTimeout = 10000;
|
|
|
|
/// <summary>
|
|
/// Opzioni standard di chiamata
|
|
/// </summary>
|
|
private RestClientOptions rcOptions = new RestClientOptions();
|
|
|
|
/// <summary>
|
|
/// Token di chiamata per l'applicazione
|
|
/// </summary>
|
|
private string RestToken = "";
|
|
|
|
/// <summary>
|
|
/// Indirizzo server (URL con eventuale porta)
|
|
/// </summary>
|
|
private string servAddr = $"";
|
|
|
|
#endregion Private Fields
|
|
}
|
|
} |