private int FindVersionWithLabel( ClientInstance client, VaultClientFile file, string label )
{
string token;
int inheritedRowCount;
int recursiveRowCount;
client.BeginLabelQuery( file.FullPath, file.ID, false, true, true, true, VaultClientHelper.MaxQuerySize, out inheritedRowCount, out recursiveRowCount, out token );
if( inheritedRowCount < 1 )
{
client.EndLabelQuery( token );
return -1;
}
VaultLabelItemX[] items;
client.GetLabelQueryItems_Main( token, 0, inheritedRowCount, out items );
client.EndLabelQuery( token );
foreach( VaultLabelItemX x in items )
{
if( x.Label == label )
{
return (int) x.Version;
}
}
return -1;
}
public void Dispose()
{
if( vaultClient != null )
{
vaultClient.Logout( );
vaultClient = null;
}
}
private static ClientInstance Login( VaultRepositoryAuthSettings connectionSettings )
{
ClientInstance myClient = new ClientInstance();
myClient.Init( VaultClientNetLib.VaultConnection.AccessLevelType.Client );
myClient.Login( connectionSettings.Url, connectionSettings.User, connectionSettings.Password );
FindRepository( myClient, connectionSettings.Repository );
return myClient;
}
protected void EstablishConnection()
{
if (server.StartsWith("http://") == false)
server = "http://" + server;
if (server.EndsWith("/VaultService") == false)
server += "/VaultService";
ClientInstance myClient = new ClientInstance();
myClient.Init(VaultClientNetLib.VaultConnection.AccessLevelType.Client);
myClient.Login(server, username, password);
FindRepository(myClient, repository);
client = myClient;
root = Client.TreeCache.Repository.Root;
}
/// <summary>
/// This is a helper function that works around a deficiency in the
/// Vault Client API. In the API, there is no method that lets you set the active repository
/// for a ClientInstance based only on the repository name. This means that (for now) every
/// program that uses the API will need to do something like this.
/// </summary>
/// <param name="client">A Client Instance that has already had Init and Login called on it.</param>
/// <param name="repositoryName">The name of the repository to find and connect to.</param>
private static void FindRepository( ClientInstance client, string repositoryName )
{
VaultRepositoryInfo[] reps = null;
//List all the repositories on the server.
client.ListRepositories(ref reps);
//Search for the one that we want.
foreach (VaultRepositoryInfo r in reps)
{
if (String.Compare(r.RepName,repositoryName, true) == 0)
{
//This will load up the client side cache files and refresh the repository structure.
//See http://support.sourcegear.com/viewtopic.php?t=6 for more on client side cache files.
client.SetActiveRepositoryID(r.RepID, client.Connection.Username, r.UniqueRepID, true, true);
break;
}
}
if (client.ActiveRepositoryID == -1)
throw new Exception(string.Format("Repository {0} not found", repositoryName));
}
/// <summary>
/// Criar novo boleto de fatura - Create New Invoice Boleto
/// </summary>
/// <param name="body"></param>
/// <param name="id">ID da fatura</param>
/// <returns></returns>
public async Task <RetentativeResponse> CreateNewInvoiceBoleto(RetentativeRequest body, string id)
{
StringContent stringContent = new StringContent(JsonConvert.SerializeObject(body), Encoding.UTF8, "application/json");
HttpResponseMessage response = await ClientInstance.PostAsync($"assinaturas/v1/invoices/{id}/boletos", stringContent);
if (!response.IsSuccessStatusCode)
{
string content = await response.Content.ReadAsStringAsync();
WirecardException.WirecardError wirecardException = WirecardException.DeserializeObject(content);
throw new WirecardException(wirecardException, "HTTP Response Not Success", content, (int)response.StatusCode);
}
try
{
return(JsonConvert.DeserializeObject <RetentativeResponse>(await response.Content.ReadAsStringAsync()));
}
catch (System.Exception ex)
{
throw ex;
}
}
/// <summary>
/// Ativar ou Inativar Cupon - Enable or Disable Coupon
/// </summary>
/// <param name="code">Código do Cupom</param>
/// <param name="active_or_inactive">Escolha active para Ativar um Cupom e inactive para desativar</param>
/// <returns></returns>
public async Task <CouponResponse> EnableOrDisableCoupon(string code, string active_or_inactive)
{
StringContent stringContent = new StringContent(JsonConvert.SerializeObject(null), Encoding.UTF8, "application/json");
HttpResponseMessage response = await ClientInstance.PutAsync($"assinaturas/v1/coupons/{code}/{active_or_inactive}", stringContent);
if (!response.IsSuccessStatusCode)
{
string content = await response.Content.ReadAsStringAsync();
WirecardException.WirecardError wirecardException = WirecardException.DeserializeObject(content);
throw new WirecardException(wirecardException, "HTTP Response Not Success", content, (int)response.StatusCode);
}
try
{
return(JsonConvert.DeserializeObject <CouponResponse>(await response.Content.ReadAsStringAsync()));
}
catch (System.Exception ex)
{
throw ex;
}
}
/// <summary>
/// Associar Cupom para Assinatura Existente - Associate Coupon For Existing Signature
/// </summary>
/// <returns></returns>
public async Task <CouponResponse> AssociateCouponForExistingSignature(CouponRequest body, string code)
{
StringContent stringContent = new StringContent(JsonConvert.SerializeObject(body), Encoding.UTF8, "application/json");
HttpResponseMessage response = await ClientInstance.PutAsync($"assinaturas/v1/subscriptions/{code}", stringContent);
if (!response.IsSuccessStatusCode)
{
string content = await response.Content.ReadAsStringAsync();
WirecardException.WirecardError wirecardException = WirecardException.DeserializeObject(content);
throw new WirecardException(wirecardException, "HTTP Response Not Success", content, (int)response.StatusCode);
}
try
{
return(JsonConvert.DeserializeObject <CouponResponse>(await response.Content.ReadAsStringAsync()));
}
catch (System.Exception ex)
{
throw ex;
}
}
private void ClientHandler(IAsyncResult ar)
{
var client = _listener.EndAcceptTcpClient(ar);
TcpClientConnected.Set();
var ci = new ClientInstance(client);
CancellationTokenSource source = ci.tokensrc = new CancellationTokenSource();
logic.UserJoined(ci);
WriteQueues.Add(ci.InstanceId, new BlockingCollection <IPacket>());
try
{
Read(ci);
ci.writeTask = Task.Run(() => WriteAction(ci), source.Token);
}
catch (StackOverflowException e)
{
Console.Error.WriteLine(e.ToString());
}
}
public void RefreshData(bool showAllRecords)
{
if (records.SelectedItem != null)
{
currentGUID = ((LeaveItem)records.SelectedItem).LeaveInfo.PKLeaveInfoID;
}
if (mPage == CARSPage.ApplyLeave || mPage == CARSPage.PersonalInfo)
{
ClientInstance.ShowSpinner("Loading Leaves");
ClientInstance.Get().GetMyLeavesAsync(mUserRunAs.Employee.PKEmployeeID.ToString());
}
else if (mPage == CARSPage.ApproveLeave)
{
ClientInstance.ShowSpinner("Loading Leaves");
ClientInstance.Get().GetMyTeamLeavesAsync(mUserRunAs.Employee.PKEmployeeID.ToString(), showAllRecords);
}
else if (mPage == CARSPage.LeaveHistory)
{
records.ItemsSource = null;
}
}
/// <summary>
/// Criar Pagamento - Create Payment
/// </summary>
/// <param name="body"></param>
/// <param name="order_id">Código identificador do pedido. Exemplo: ORD-9BAYAVM87YHE</param>
/// <returns></returns>
public async Task <PaymentResponse> Create(PaymentRequest body, string order_id)
{
StringContent stringContent = new StringContent(JsonConvert.SerializeObject(body), Encoding.UTF8, "application/json");
HttpResponseMessage response = await ClientInstance.PostAsync($"v2/orders/{order_id}/payments", stringContent);
if (!response.IsSuccessStatusCode)
{
string content = await response.Content.ReadAsStringAsync();
WirecardException.WirecardError wirecardException = WirecardException.DeserializeObject(content);
throw new WirecardException(wirecardException, "HTTP Response Not Success", content, (int)response.StatusCode);
}
try
{
return(JsonConvert.DeserializeObject <PaymentResponse>(await response.Content.ReadAsStringAsync()));
}
catch (System.Exception ex)
{
throw ex;
}
}
/// <summary>
/// Retrieves the specified file.
/// </summary>
/// <exception>Exception</exception>
private void GetFile(string fileName)
{
if (IsVaultFolder(fileName))
{
VaultClientFolder vaultClientFolder = ClientInstance.TreeCache.Repository.Root.FindFolderRecursive(fileName);
if (Destination.Length == 0)
{
if (!String.IsNullOrEmpty(WorkingFolder))
{
ClientInstance.TreeCache.SetWorkingFolder(vaultClientFolder.FullPath, WorkingFolder);
}
ClientInstance.Get(vaultClientFolder, true, true, MakeWritableType.MakeAllFilesWritable, SetFileTimeType.Current, MergeType.OverwriteWorkingCopy, null);
}
else
{
ClientInstance.GetToNonWorkingFolder(vaultClientFolder, true, true, true, MakeWritableType.MakeAllFilesWritable, SetFileTimeType.Current, Destination, null);
}
}
if (IsVaultFile(fileName))
{
VaultClientFile vaultClientFile = ClientInstance.TreeCache.Repository.Root.FindFileRecursive(fileName);
if (Destination.Length == 0)
{
if (!String.IsNullOrEmpty(WorkingFolder))
{
ClientInstance.TreeCache.SetWorkingFolder(vaultClientFile.Parent.FullPath, WorkingFolder);
}
ClientInstance.Get(vaultClientFile, true, MakeWritableType.MakeAllFilesWritable, SetFileTimeType.Current, MergeType.OverwriteWorkingCopy, null);
}
else
{
ClientInstance.GetToNonWorkingFolder(vaultClientFile, true, true, MakeWritableType.MakeAllFilesWritable, SetFileTimeType.Current, vaultClientFile.Parent.FullPath, Destination, null);
}
}
}
/// <summary>
/// TODO: type endpoint description here
/// </summary>
/// <return>Returns the bool response from the API call</return>
public async Task <bool> GetBooleanAsync()
{
//the base uri for api requestss
string _baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/response/boolean");
//validate and preprocess url
string _queryUrl = APIHelper.CleanUrl(_queryBuilder);
//append request with appropriate headers and parameters
var _headers = new Dictionary <string, string>()
{
{ "user-agent", "Stamplay SDK" }
};
//prepare the API call request to fetch the response
HttpRequest _request = ClientInstance.Get(_queryUrl, _headers);
//invoke request and get response
HttpStringResponse _response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(_request);
HttpContext _context = new HttpContext(_request, _response);
//handle errors defined at the API level
base.ValidateResponse(_response, _context);
try
{
return(bool.Parse(_response.Body));
}
catch (Exception _ex)
{
throw new APIException("Failed to parse the response: " + _ex.Message, _context);
}
}
public LeavePreview(User pUser, LeaveItem item, string warning)
{
InitializeComponent();
ClientInstance.Get().ApplyLeaveCompleted += new EventHandler <ApplyLeaveCompletedEventArgs>(client_ApplyLeaveCompleted);
SetLeaveValue(item);
if (warning != "")
{
warningInfo.Height = double.NaN;
warningInfo.Visibility = System.Windows.Visibility.Visible;
warningInfo.Text = warning;
}
else
{
warningInfo.Height = 0;
warningInfo.Visibility = System.Windows.Visibility.Collapsed;
}
user = pUser;
leaveItem = item;
}
public Main(RemoteHooking.IContext InContext, string serverName)
{
mySocketReady = false;
myRecvFilter = new bool[256];
mySendFilter = new bool[256];
mySocket = 0;
myRecvDelegate = new dSendRecv(ReceiveHook);
mySendDelegate = new dSendRecv(SendHook);
mySocketDelegate = new dSocket(SocketHook);
myCloseSocketDelegate = new dCloseSocket(SocketCloseHook);
myClientSendLock = new object();
myPID = RemoteHooking.GetCurrentProcessId();
myThreadID = RemoteHooking.GetCurrentThreadId();
myDateStamp = GetDateStamp();
if (myDateStamp >= 1183740939)
{
myNewStylePackets = true;
}
else
{
myNewStylePackets = false;
}
myServerSendBuffer = Marshal.AllocHGlobal(65536);
myClientSendBuffer = Marshal.AllocHGlobal(65536);
myServerBufferAddress = BitConverter.GetBytes(myServerSendBuffer.ToInt32());
myClientBufferAddress = BitConverter.GetBytes(myClientSendBuffer.ToInt32());
myClientInstance = new ClientInstance(serverName, true);
myClientInstance.SendCommand(Command.ClientID, myPID);
myClientInstance.SendPacketEvent += new dSendPacket(myClientInstance_sendPacketEvent);
myClientInstance.PingEvent += new dPing(myClientInstance_pingEvent);
myClientInstance.AddRecvFilterEvent += new dAddRecvFilter(myClientInstance_addRecvFilterEvent);
myClientInstance.AddSendFilterEvent += new dAddSendFilter(myClientInstance_addSendFilterEvent);
myClientInstance.RemoveRecvFilterEvent += new dRemoveRecvFilter(myClientInstance_removeRecvFilterEvent);
myClientInstance.RemoveSendFilterEvent += new dRemoveSendFilter(myClientInstance_removeSendFilterEvent);
myClientInstance.ClearRecvFilterEvent += new dClearRecvFilter(myClientInstance_clearRecvFilterEvent);
myClientInstance.ClearSendFilterEvent += new dClearSendFilter(myClientInstance_clearSendFilterEvent);
BuildDefaultPacketFilters();
}
/// <summary>
/// Add Single API Event Call
/// </summary>
/// <param name="body">Required parameter: Example: </param>
/// <return>Returns the void response from the API call</return>
public async Task <Dictionary <string, string> > CreateEventAsync(EventModel body)
{
//the base uri for api requestss
string _baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/v1/events");
//validate and preprocess url
string _queryUrl = ApiHelper.CleanUrl(_queryBuilder);
//append request with appropriate headers and parameters
var _headers = new Dictionary <string, string>()
{
{ "content-type", "application/json; charset=utf-8" }
};
_headers.Add("X-Moesif-Application-Id", Configuration.ApplicationId);
//append body params
var _body = ApiHelper.JsonSerialize(body);
//prepare the API call request to fetch the response
HttpRequest _request = ClientInstance.PostBody(_queryUrl, _headers, _body);
//invoke request and get response
HttpStringResponse _response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(_request);
HttpContext _context = new HttpContext(_request, _response);
//handle errors defined at the API level
base.ValidateResponse(_response, _context);
// Return response headers
return(_response.Headers);
}
/// <summary>
/// This is a helper function that works around a deficiency in the
/// Vault Client API. In the API, there is no method that lets you set the active repository
/// for a ClientInstance based only on the repository name. This means that (for now) every
/// program that uses the API will need to do something like this.
/// </summary>
/// <param name="client">A Client Instance that has already had Init and Login called on it.</param>
/// <param name="repositoryName">The name of the repository to find and connect to.</param>
private static void FindRepository(ClientInstance client, string repositoryName)
{
VaultRepositoryInfo[] reps = null;
//List all the repositories on the server.
client.ListRepositories(ref reps);
//Search for the one that we want.
foreach (VaultRepositoryInfo r in reps)
{
if (String.Compare(r.RepName, repositoryName, true) == 0)
{
//This will load up the client side cache files and refresh the repository structure.
//See http://support.sourcegear.com/viewtopic.php?t=6 for more on client side cache files.
client.SetActiveRepositoryID(r.RepID, client.Connection.Username, r.UniqueRepID, true, true);
break;
}
}
if (client.ActiveRepositoryID == -1)
{
throw new Exception(string.Format("Repository {0} not found", repositoryName));
}
}
/// <summary>
/// Brand names associated with the product 573-5613789
/// </summary>
/// <param name="authToken">Required parameter: Example: </param>
/// <param name="xid">Required parameter: Example: </param>
/// <return>Returns the void response from the API call</return>
public async Task GETASIProductAsync(string authToken, string xid)
{
//the base uri for api requestss
string _baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/product/{Xid}");
//process optional template parameters
APIHelper.AppendUrlWithTemplateParameters(_queryBuilder, new Dictionary <string, object>()
{
{ "Xid", xid }
});
//validate and preprocess url
string _queryUrl = APIHelper.CleanUrl(_queryBuilder);
//append request with appropriate headers and parameters
var _headers = new Dictionary <string, string>()
{
{ "user-agent", "APIMATIC 2.0" },
{ "AuthToken", authToken }
};
//prepare the API call request to fetch the response
HttpRequest _request = ClientInstance.Get(_queryUrl, _headers);
//invoke request and get response
HttpStringResponse _response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(_request).ConfigureAwait(false);
HttpContext _context = new HttpContext(_request, _response);
//handle errors defined at the API level
base.ValidateResponse(_response, _context);
}
/// <summary>
/// Gets all transfers
/// </summary>
/// <return>Returns the Models.ListTransfers response from the API call</return>
public async Task<Models.ListTransfers> GetTransfersAsync()
{
//the base uri for api requests
string _baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/transfers");
//validate and preprocess url
string _queryUrl = APIHelper.CleanUrl(_queryBuilder);
//append request with appropriate headers and parameters
var _headers = new Dictionary<string,string>()
{
{ "user-agent", "MundiSDK - DotNet 0.16.21" },
{ "accept", "application/json" }
};
//prepare the API call request to fetch the response
HttpRequest _request = ClientInstance.Get(_queryUrl,_headers, Configuration.BasicAuthUserName, Configuration.BasicAuthPassword);
//invoke request and get response
HttpStringResponse _response = (HttpStringResponse) await ClientInstance.ExecuteAsStringAsync(_request).ConfigureAwait(false);
HttpContext _context = new HttpContext(_request,_response);
//handle errors defined at the API level
base.ValidateResponse(_response, _context);
try
{
return APIHelper.JsonDeserialize<Models.ListTransfers>(_response.Body);
}
catch (Exception _ex)
{
throw new APIException("Failed to parse the response: " + _ex.Message, _context);
}
}
public async Task <Models.EscrowResponse> ReleaseEscrowAsync(string escrowId)
{
string _baseUri = Configuration.GetBaseURI();
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/escrows/{escrow-id}/release");
APIHelper.AppendUrlWithTemplateParameters(_queryBuilder, new Dictionary <string, object>()
{
{ "escrow-id", escrowId }
});
dynamic body = "";
var _body = APIHelper.JsonSerialize(body);
string _queryUrl = APIHelper.CleanUrl(_queryBuilder);
var _headers = Utilities.APIHelper.GetHeader();
HttpRequest _request = ClientInstance.PostBody(_queryUrl, _headers, _body);
HttpStringResponse _response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(_request).ConfigureAwait(false);
HttpContext _context = new HttpContext(_request, _response);
base.ValidateResponse(_response, _context);
try
{
return(APIHelper.JsonDeserialize <Models.EscrowResponse>(_response.Body));
}
catch (Exception _ex)
{
throw new APIException("Failed to parse the response: " + _ex.Message, _context);
}
}
protected void EstablishConnection()
{
if (server.StartsWith("http://") == false)
{
server = "http://" + server;
}
if (server.EndsWith("/VaultService") == false)
{
server += "/VaultService";
}
ClientInstance myClient = new ClientInstance();
myClient.Init(VaultClientNetLib.VaultConnection.AccessLevelType.Client);
myClient.Login(server, username, password);
FindRepository(myClient, repository);
client = myClient;
root = Client.TreeCache.Repository.Root;
}
public async Task <Models.AccountResponse> GetAccountAsync(string accountId)
{
string _queryUrl = Utilities.APIHelper.GetBuiltUrl("account", accountId);
var _headers = Utilities.APIHelper.GetHeader();
HttpRequest _request = ClientInstance.Get(_queryUrl, _headers);
HttpStringResponse _response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(_request).ConfigureAwait(false);
HttpContext _context = new HttpContext(_request, _response);
base.ValidateResponse(_response, _context);
try
{
return(APIHelper.JsonDeserialize <Models.AccountResponse>(_response.Body));
}
catch (Exception _ex)
{
throw new APIException("Failed to parse the response: " + _ex.Message, _context);
}
}
public ApplyControl(CARSPage page, User pUser)
{
InitializeComponent();
if (pUser != null)
{
mUser = mUserRunAs = pUser;
}
mPage = page;
this.recallButton.Visibility = System.Windows.Visibility.Collapsed; // by default, hide this button
ClientInstance.Get().GetAnnualLeaveEarnedHoursCompleted += new EventHandler <GetAnnualLeaveEarnedHoursCompletedEventArgs>(client_GetAnnualLeaveEarnedHoursCompleted);
ClientInstance.Get().GetAnnualLeaveUsedHoursCompleted += new EventHandler <GetAnnualLeaveUsedHoursCompletedEventArgs>(client_GetAnnualLeaveUsedHoursCompleted);
ClientInstance.Get().GetSickLeaveUsedHoursCompleted += new EventHandler <GetSickLeaveUsedHoursCompletedEventArgs>(client_GetSickLeaveUsedHoursCompleted);
ClientInstance.Get().ApproveLeaveCompleted += new EventHandler <ApproveLeaveCompletedEventArgs>(client_ApproveLeaveCompleted);
ClientInstance.Get().GetLeaveTypesCompleted += new EventHandler <GetLeaveTypesCompletedEventArgs>(client_GetLeaveTypesCompleted);
ClientInstance.Get().GetFrozenDateCompleted += new EventHandler <GetFrozenDateCompletedEventArgs>(ApplyControl_GetFrozenDateCompleted);
ClientInstance.Get().RecallLeaveCompleted += ApplyControl_RecallLeaveCompleted;
ClientInstance.Get().GetLeaveTypesAsync();
ClientInstance.Get().GetFrozenDateAsync();
}
/// <summary>
/// this has been created to do challenge 5.
/// </summary>
/// <return>Returns the void response from the API call</return>
public async Task Challenge5Async()
{
//the base uri for api requests
string _baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/challenge5");
//process optional query parameters
APIHelper.AppendUrlWithQueryParameters(_queryBuilder, new Dictionary <string, object>()
{
{ "key", Configuration.Key }
}, ArrayDeserializationFormat, ParameterSeparator);
//validate and preprocess url
string _queryUrl = APIHelper.CleanUrl(_queryBuilder);
//append request with appropriate headers and parameters
var _headers = new Dictionary <string, string>()
{
{ "user-agent", "APIMATIC 2.0" }
};
//prepare the API call request to fetch the response
HttpRequest _request = ClientInstance.Get(_queryUrl, _headers);
//invoke request and get response
HttpStringResponse _response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(_request).ConfigureAwait(false);
HttpContext _context = new HttpContext(_request, _response);
//handle errors defined at the API level
base.ValidateResponse(_response, _context);
}
/// <summary>
/// Fetch product subscription details for an account holder
/// </summary>
/// <return>Returns the Models.AccountHolderSubscription response from the API call</return>
public async Task <AccountHolderSubscription> GetAccountHolderSubscriptionAsync()
{
//the base uri for api requests
var baseUri = Configuration.GetBaseURI();
//prepare query string for API call
var queryBuilder = new StringBuilder(baseUri);
queryBuilder.Append("/api/v2/subscriptions");
//validate and preprocess url
var queryUrl = APIHelper.CleanUrl(queryBuilder);
//append request with appropriate headers and parameters
var headers = APIHelper.GetRequestHeaders();
//prepare the API call request to fetch the response
var request = ClientInstance.Get(queryUrl, headers);
//invoke request and get response
var response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(request).ConfigureAwait(false);
var context = new HTTPContext(request, response);
//handle errors defined at the API level
ValidateResponse(response, context);
try
{
return(APIHelper.JsonDeserialize <AccountHolderSubscription>(response.Body));
}
catch (Exception ex)
{
throw new APIException("Failed to parse the response: " + ex.Message, context);
}
}
/// <summary>
/// Update an individual account holder's email address
/// </summary>
/// <param name="body">Required parameter: Example: </param>
/// <return>Returns the void response from the API call</return>
public async Task UpdateEmailAsync(UpdateEmailRequest body)
{
//validating required parameters
if (null == body)
{
throw new ArgumentNullException(nameof(body), "The parameter \"body\" is a required parameter and cannot be null.");
}
//the base uri for api requests
var baseUri = Configuration.GetBaseURI();
//prepare query string for API call
var queryBuilder = new StringBuilder(baseUri);
queryBuilder.Append("/api/v2/account-holder/individual/email");
//validate and preprocess url
var queryUrl = APIHelper.CleanUrl(queryBuilder);
//append request with appropriate headers and parameters
var headers = APIHelper.GetContentRequestHeaders();
//append body params
var serializedBody = APIHelper.JsonSerialize(body);
//prepare the API call request to fetch the response
var request = ClientInstance.PutBody(queryUrl, headers, serializedBody);
//invoke request and get response
var response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(request).ConfigureAwait(false);
var context = new HTTPContext(request, response);
//handle errors
ValidateResponse(response, context);
}
void Update()
{
LogText.text = LogString;
RevText.text = RevString;
foreach (var itemClient in SocketServerBase.Clients)
{
if (SocketClients.Contains(itemClient))
{
continue;
}
SocketClients.Add(itemClient);
ClientInstance newClientInstance = Instantiate(client, Clients.transform);
newClientInstance.ClientInfo = itemClient.ClientInfo;
newClientInstance.HostId = 100;
_clientObjects = Clients.GetComponentsInChildren <ClientInstance>();
}
foreach (var itemClient in SocketClients)
{
if (SocketServerBase.Clients.Contains(itemClient))
{
return;
}
for (int i = 0; i < _clientObjects.Length; i++)
{
if (SocketClients[i].ClientInfo != itemClient.ClientInfo)
{
continue;
}
if (SocketClients[i].ClientInfo == itemClient.ClientInfo)
{
Destroy(_clientObjects[i].gameObject);
}
}
SocketClients.Remove(itemClient);
}
}
/// <summary>
/// Check account balance
/// </summary>
/// <return>Returns the void response from the API call</return>
public async Task GetBalanceAsync()
{
//the base uri for api requests
string _baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/balance");
//validate and preprocess url
string _queryUrl = APIHelper.CleanUrl(_queryBuilder);
//append request with appropriate headers and parameters
var _headers = new Dictionary <string, string>()
{
{ "user-agent", "D7SDK 1.0" }
};
//prepare the API call request to fetch the response
HttpRequest _request = ClientInstance.Get(_queryUrl, _headers, Configuration.APIUsername, Configuration.APIPassword);
//invoke request and get response
HttpStringResponse _response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(_request).ConfigureAwait(false);
HttpContext _context = new HttpContext(_request, _response);
//Error handling using HTTP status codes
if (_response.StatusCode == 500)
{
throw new APIException(@"Internal Server Error", _context);
}
//handle errors defined at the API level
base.ValidateResponse(_response, _context);
}
void NotifyChatEvent(Operation op, ClientInstance clientInst, ClientObj clientDestination)
{
if (chatEvent != null)
{
Delegate[] invkList = chatEvent.GetInvocationList();
foreach (ChatDelegate handler in invkList)
{
new Thread(() =>
{
try
{
handler(op, clientInst, clientDestination);
Console.WriteLine("Invoking event handler (NotifyChatEvent)");
}
catch (Exception)
{
chatEvent -= handler;
Console.WriteLine("Exception: Removed an event handler (NotifyChatEvent)");
}
}).Start();
}
}
}
/// <summary>
/// Send Bulk SMS to multiple recipients using D7 SMS Gateway
/// </summary>
/// <param name="body">Required parameter: Message Body</param>
/// <param name="contentType">Required parameter: Example: </param>
/// <param name="accept">Required parameter: Example: </param>
/// <return>Returns the void response from the API call</return>
public async Task CreateBulkSMSAsync(Models.BulkSMSRequest body, string contentType, string accept)
{
//the base uri for api requests
string _baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/sendbatch");
//validate and preprocess url
string _queryUrl = APIHelper.CleanUrl(_queryBuilder);
//append request with appropriate headers and parameters
var _headers = new Dictionary <string, string>()
{
{ "user-agent", "D7SDK 1.0" },
{ "Content-Type", contentType },
{ "Accept", accept }
};
//append body params
var _body = APIHelper.JsonSerialize(body);
//prepare the API call request to fetch the response
HttpRequest _request = ClientInstance.PostBody(_queryUrl, _headers, _body, Configuration.APIUsername, Configuration.APIPassword);
//invoke request and get response
HttpStringResponse _response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(_request).ConfigureAwait(false);
HttpContext _context = new HttpContext(_request, _response);
//handle errors defined at the API level
base.ValidateResponse(_response, _context);
}
/*
* Notificar clientes de um evento
*/
void NotifyClients(Operation op, ClientInstance clientInst)
{
if (alterEvent != null)
{
Delegate[] invkList = alterEvent.GetInvocationList();
foreach (AlterDelegate handler in invkList)
{
new Thread(() =>
{
try
{
handler(op, clientInst);
Console.WriteLine("Invoking event handler (NotifyClients)");
}
catch (Exception)
{
alterEvent -= handler;
Console.WriteLine("Exception: Removed an event handler (NotifyClients)");
}
}).Start();
}
}
}
public async Task <Models.RefundBankAccountResponse> CreatePaymentBankAccounttAsync(string paymentId, Models.RefundBankAccountRequest body)
{
string _baseUri = Configuration.GetBaseURI();
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/orders/{payment-id}/refunds");
APIHelper.AppendUrlWithTemplateParameters(_queryBuilder, new Dictionary <string, object>()
{
{ "payment-id", paymentId }
});
string _queryUrl = APIHelper.CleanUrl(_queryBuilder);
var _headers = APIHelper.GetHeader();
var _body = APIHelper.JsonSerialize(body);
HttpRequest _request = ClientInstance.PostBody(_queryUrl, _headers, _body);
HttpStringResponse _response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(_request).ConfigureAwait(false);
HttpContext _context = new HttpContext(_request, _response);
base.ValidateResponse(_response, _context);
try
{
return(APIHelper.JsonDeserialize <Models.RefundBankAccountResponse>(_response.Body));
}
catch (Exception _ex)
{
throw new APIException("Failed to parse the response: " + _ex.Message, _context);
}
}
internal static ClientInstance TryParse(HtmlNode[] cells)
{
if (cells.Length == 8) // should only be this many cells
{
var name = cells[0].InnerText.Trim();
var status = cells[1].InnerText.Trim();
var connectedSince = cells[2].InnerText.Trim();
var localAddress = cells[3].InnerText.Trim();
var virtualAddress = cells[4].InnerText.Trim();
var remoteHost = cells[5].InnerText.Trim();
var txrxStats = cells[6].InnerText.Trim();
var instance = new ClientInstance();
instance.Name = name;
instance.TunnelStatus = parseTunnelStatus(status);
instance.ConnectedTime = parseConnectedSince(connectedSince);
instance.LocalAddress = parseLocalAddress(localAddress);
instance.VirtualAddress = parseVirtualAddress(virtualAddress);
instance.RemoteHost = parseRemoteHost(remoteHost);
if (tryParseTxRxBytes(txrxStats, out long rxBytes, out long txBytes))
{
instance.BytesReceived = rxBytes;
instance.BytesSent = txBytes;
}
instance.ServiceStatus = parseServiceStatus(cells[7]);
return(instance);
}
else
{
return(null);
}
}
void sc_ClickSearchButton(object sender, EventArgs e)
{
string typeID = string.Empty;
if (sc.leaveType.SelectedIndex != 0)
{
typeID = ((LeaveTypeValue)sc.leaveType.SelectedItem).TypeValue.PKLeaveTypeID.ToString();
}
string status = ((ComboBoxItem)sc.leaveStatus.SelectedItem).Content.ToString();
DateTime start = sc.start.SelectedDate.HasValue ? sc.start.SelectedDate.Value : DateTime.MinValue;
DateTime end = sc.end.SelectedDate.HasValue ? sc.end.SelectedDate.Value : DateTime.MaxValue;
if (end != DateTime.MaxValue)
{
end = end.AddDays(1);
}
ClientInstance.ShowSpinner("Finding");
string supervisor = ((User)sc.supervisor.SelectedItem).UserName == "" ? "" : ((User)sc.supervisor.SelectedItem).PKEmployeeID.ToString();
string applicant = ((User)sc.applicant.SelectedItem).UserName == "" ? "" : ((User)sc.applicant.SelectedItem).PKEmployeeID.ToString();
ClientInstance.Get().FindLeavesAsync(supervisor, applicant, typeID, status, start, end, sc.SupervisorsID);
}
/// <summary>
/// Excluir Cupom de Assinatura - Delete Signature Coupon
/// </summary>
/// <param name="code">Código da Assinatura</param>
/// <returns></returns>
public async Task <CouponResponse> DeleteSignatureCoupon(string code)
{
HttpRequestMessage httpRequest = new HttpRequestMessage(HttpMethod.Delete, ClientInstance.BaseAddress + $"assinaturas/v1/subscriptions/{code}/coupon")
{
Content = new StringContent(string.Empty, Encoding.UTF8, "application/json")
};
HttpResponseMessage response = await ClientInstance.SendAsync(httpRequest);
if (!response.IsSuccessStatusCode)
{
string content = await response.Content.ReadAsStringAsync();
WirecardException.WirecardError wirecardException = WirecardException.DeserializeObject(content);
throw new WirecardException(wirecardException, "HTTP Response Not Success", content, (int)response.StatusCode);
}
try
{
return(JsonConvert.DeserializeObject <CouponResponse>(await response.Content.ReadAsStringAsync()));
}
catch (System.Exception ex)
{
throw ex;
}
}
public VaultClientHelper( VaultRepositoryAuthSettings connectionSettings )
{
vaultClient = Login( connectionSettings );
}
