private void SendBuildingsMap(CallbackRequest callbackrequest)
{
var buildedClient = GetInitializeWebClient(callbackrequest);
buildedClient.QueryString.Add("attachment", "photo-166642622_456239017");
var res = buildedClient.DownloadString(uri);
}
public async Task <Callback> UpdateCallbackAsync(string id, CallbackRequest content)
{
var request = new RestRequest($"/callbacks/{id}", HttpMethod.Put, content);
var response = await SendRequestAsync(Client, request);
return(JsonConvert.DeserializeObject <IDictionary <string, Callback> >(response.Content).Values.First());
}
private void SendPostsFromMisisGroup(CallbackRequest callbackRequest)
{
if (_vkProxy.AccessToken.Equals(String.Empty))
{
_vkProxy.GetPosts(GetInitializeWebClient(callbackRequest), uri, callbackRequest.Object.Body);
}
}
/// <summary>
/// Requests that the following action be completed as soon as reasonably possible.
/// This will either be done immediately, or be queued for the next approriate time.
/// </summary>
/// <param name="callback">action to perform</param>
/// <returns>
/// A cancelation object. Use in a using block.
/// </returns>
public CallbackRequest RequestCallback(Action callback)
{
CallbackRequest request = new CallbackRequest(callback);
lock (m_syncRoot)
{
m_isRequestCallbackMethodProcessing = true;
Thread.MemoryBarrier();
//------------------------------------------
if (m_isSafeToCallback)
{
request.Run();
}
else
{
m_isCallbackWaiting = true;
m_pendingCallbacks.Add(request);
}
//-----------------------------------------
Thread.MemoryBarrier();
m_isRequestCallbackMethodProcessing = false;
}
return(request);
}
public async Task <ServiceResult> Process(string userId, CallbackRequest callbackData)
{
if (!string.IsNullOrEmpty(callbackData.Error))
{
return(ServiceResult.Failed(new[] { ErrorMessages.CallbackStatedAccessDenied }));
}
var accountContext = new AccountAccessContext
{
UserId = userId,
Code = callbackData.Code,
Scopes = callbackData.GetScopes()
};
var exchangeCodeResult = await _authorizationService.ExchangeCode(accountContext);
if (!exchangeCodeResult.Success)
{
return(ServiceResult.Failed(exchangeCodeResult.Errors));
}
await _userDataCachingService.ClearUserData(userId);
return(ServiceResult.Succeeded());
}
private void SendSchedule(CallbackRequest callbackRequest)
{
var buildedClient = GetInitializeWebClient(callbackRequest);
buildedClient.QueryString.Add("attachment", "doc141213476_466619620,doc141213476_466619622,doc141213476_466619680,doc141213476_466619682,doc141213476_466619754,doc141213476_466619783");
var res = buildedClient.DownloadString(uri);
}
private void SendCommunityList(CallbackRequest callbackRequest)
{
var buildedClient = GetInitializeWebClient(callbackRequest);
var message = "Список объединений : \n" +
"Лига разработчиков МИСиС - https://vk.com/lodmisis \n" +
"НИТУ «МИСиС» - https://vk.com/nust_misis \n" +
"ТурКлуб МИСиС - https://vk.com/tk_misis \n" +
"Студенческий совет НИТУ «МИСиС» - https://vk.com/studentmisis \n" +
"Студсовет Общежитий НИТУ \"МИСиС\" - https://vk.com/studac_new \n" +
"Центр карьеры НИТУ \"МИСиС\" - https://vk.com/ck_misis \n " +
"Цитатник МИСиС - https://vk.com/public80799683 \n" +
"СКБ НИТУ \"МИСиС\" - https://vk.com/skbmisis \n" +
"СНО НИТУ «МИСиС» - https://vk.com/sno_misis \n " +
"Lignum | Литературное сообщество НИТУ \"МИСиС\" - https://vk.com/lignummisis \n" +
"КВН МИСиС - https://vk.com/kvn_misis \n" +
"Управление культуры и молодежной политики МИСиС - https://vk.com/ykmp_misis \n" +
"Эндаумент-фонд НИТУ \"МИСиС\" - https://vk.com/ef.misis \n " +
"Лингвистика в МИСиС - https://vk.com/lingvistikavmisis \n" +
"СтудОК НИТУ \"МИСиС\" - https://vk.com/studok_misis \n" +
"Киберспорт НИТУ \"МИСиС\" - https://vk.com/cybersport_nustmisis \n" +
"Волонтерский центр НИТУ \"МИСиС\" - https://vk.com/volunteer_misis \n" +
"Хоккейный клуб НИТУ \"МИСиС\" \"Стальные медведи\" - https://vk.com/fan.steelbears \n" +
"Кейс-движение CUP MISIS CASE - https://vk.com/cupmisiscase \n " +
"Сделано Лигой Разработчиков - https://lod-misis.ru"
;
buildedClient.QueryString.Add("message", message);
var res = buildedClient.DownloadString(uri);
}
public async Task <IActionResult> Get(string userId, [FromQuery] CallbackRequest request)
{
_logger.LogInformation($"Processing new account access for user {userId}");
var result = await _service.Process(userId, request);
return(GenerateResultFromServiceResult(result));
}
public bool Satisfies(CallbackRequest request)
{
SignedValues values = _valueProvider.GetSignedValues(request);
string scriptPath = request.Uri.GetScriptPath();
string signature = Sign(scriptPath, values.Values);
return(signature == values.Signature);
}
public bool Satisfies(CallbackRequest request)
{
SignedValues values = _valueProvider.GetSignedValues(request);
string scriptPath = request.Uri.GetScriptPath();
string signature = Sign(scriptPath, values.Values);
return signature == values.Signature;
}
private WebClient GetInitializeWebClient(CallbackRequest callbackRequest)
{
var uri = new Uri(@"https://api.vk.com/method/messages.send");
var client = new WebClient();
client.QueryString.Add("v", "5.70");
client.QueryString.Add("access_token", AccessToken);
client.QueryString.Add("user_id", callbackRequest.Object.UserId.ToString());
client.QueryString.Add("chat_id", callbackRequest.Object.UserId.ToString());
return(client);
}
public JsonResult Index(CallbackRequest cbdata)
{
var result = new Dictionary <string, object>();
try
{
var dataStr = Convert.ToString(cbdata.Data);
var requestMac = Convert.ToString(cbdata.Mac);
var isValidCallback = ZaloPayHelper.VerifyCallback(dataStr, requestMac);
// kiểm tra callback hợp lệ (đến từ zalopay server)
if (!isValidCallback)
{
// callback không hợp lệ
result["returncode"] = -1;
result["returnmessage"] = "mac not equal";
}
else
{
// thanh toán thành công
// merchant xử lý đơn hàng cho user
var data = JsonConvert.DeserializeObject <Dictionary <string, object> >(dataStr);
var apptransid = data["apptransid"].ToString();
using (var db = new ZaloPayDemoContext())
{
var orderDTO = db.Orders.SingleOrDefault(o => o.Apptransid.Equals(apptransid));
if (orderDTO != null)
{
orderDTO.Zptransid = data["zptransid"].ToString();
orderDTO.Channel = int.Parse(data["channel"].ToString());
orderDTO.Status = 1;
db.SaveChanges();
}
}
result["returncode"] = 1;
result["returnmessage"] = "success";
}
// thông báo kết quả cho zalopay server
return(Json(result));
} catch (Exception ex)
{
result["returncode"] = 0; // ZaloPay sẽ callback lại tối đa 3 lần
result["returnmessage"] = ex.Message;
return(Json(result));
}
}
public void CallbackRequestRendersJsonAs()
{
var request = new CallbackRequest
{
ObjectType = ObjectType.Users,
Description = "Users Callback",
Enabled = true,
Url = "https://httpbin.org/post"
};
var response = JsonConvert.SerializeObject(request);
Assert.Equal(@"{""description"":""Users Callback"",""url"":""https://httpbin.org/post"",""object_type"":""users"",""enabled"":true}", response);
}
private void SendCommandList(CallbackRequest callbackRequest)
{
var buildedClient = GetInitializeWebClient(callbackRequest);
var message = "Список команд : \n" +
"1)hashtag - получение записи по тегу, например tag студент \n" +
"2) объединения - получить список студенческих объединений университета \n" +
"3) расписание - расписание занятий \n" +
"4) карта - карта корпусов \n" +
"Сделано Лигой Разработчиков - https://lod-misis.ru/"
;
buildedClient.QueryString.Add("message", message);
var res = buildedClient.DownloadString(uri);
}
public async Task <ActionResult> Callback(CallbackRequest model, CancellationToken ct)
{
var cardholderId = model?.Data?.AcctId ?? 0;
var entity = new CallbackEntity
{
SharedSecret = GetSharedSecretFromHeaders(),
RequestJson = model.ToJson()
};
await _callbackStorage
.Insert(cardholderId, entity, ct);
return(NoContent());
}
public void approveFortellisActivationRequest(string accessToken, string connectionId, string status)
{
string connectionCallbackURI = String.Format("https://{0}/connections/{1}/callback", Configuration["Fortellis:ConnectionCallbackDomain"], connectionId);
CallbackRequest fortellisCallbackRequest = new CallbackRequest(status);
var http = new RestClient(connectionCallbackURI);
var req = new RestRequest(Method.POST)
.AddHeader("Authorization", $"Bearer {accessToken}")
.AddJsonBody(fortellisCallbackRequest);
var res = http.Execute(req);
if (res.StatusCode != HttpStatusCode.OK)
{
throw new Exception(res.Content.ToString());
}
Console.WriteLine("Connection activation successful.");
}
public SignedValues GetSignedValues(CallbackRequest request)
{
Ensure.ArgumentNotNull(request, nameof(request));
var values = request.QueryString.Cast <string>()
.Where(name => name != SignatureFieldName)
.OrderBy(name => name)
.Select(name => request.QueryString[name])
.ToList();
var signature = request.QueryString[SignatureFieldName];
return(new SignedValues
{
Values = values,
Signature = signature
});
}
public async Task <ActionResult <string> > Callback([FromBody] CallbackRequest request)
{
// Run type specific logic
switch (HttpContext.GetHeader("Twitch-Eventsub-Message-Type"))
{
case "webhook_callback_verification":
return(Ok(request.Challenge));
}
// Is there an event to send?
if (request.Event != null)
{
// Send event to client
await _eventHub.Clients.User(request.Subscription.Condition.UserId).SendAsync(request.Subscription.Type, request.Event);
}
return(Ok());
}
public SignedValues GetSignedValues(CallbackRequest request)
{
Ensure.ArgumentNotNull(request, nameof(request));
var values = request.QueryString.Cast<string>()
.Where(name => name != SignatureFieldName)
.OrderBy(name => name)
.Select(name => request.QueryString[name])
.ToList();
var signature = request.QueryString[SignatureFieldName];
return new SignedValues
{
Values = values,
Signature = signature
};
}
public async Task RegiisterCallBack(CallbackRequest request, EnumCollbackType collbackType)
{
switch (collbackType)
{
case EnumCollbackType.Payment:
await _dbRepository.AddPaymentCallBack(request);
break;
case EnumCollbackType.Refund:
await _dbRepository.AddRefundCallBack(request);
break;
default:
break;
}
}
public static ResultUrlRequest Parse(CallbackRequest callback)
{
Ensure.ArgumentNotNull(callback, nameof(callback));
var resultUrl = new ResultUrlRequest();
resultUrl.Uri = callback.Uri;
resultUrl.OrderId = callback.GetOrDefault("pg_order_id", string.Empty);
resultUrl.PaymentId = callback.Get("pg_payment_id");
resultUrl.Amount = callback.Get <double>("pg_amount");
resultUrl.Currency = callback.Get <PlatronPaymentCurrency>("pg_currency");
resultUrl.NetAmount = callback.Get <double>("pg_net_amount");
resultUrl.PsAmount = callback.Get <double>("pg_ps_amount");
resultUrl.PsFullAmount = callback.Get <double>("pg_ps_full_amount");
resultUrl.PsCurrency = callback.Get <PlatronPaymentCurrency>("pg_ps_currency");
resultUrl.Overpayment = callback.GetOrDefault <double>("pg_overpayment", 0);
resultUrl.PaymentSystem = callback.Get("pg_payment_system");
resultUrl.PaymentDate = callback.GetDate("pg_payment_date");
resultUrl.CanReject = callback.GetOrDefault("pg_can_reject", PaymentRejectType.Unrevokable);
if (callback.Contains("pg_card_brand"))
{
resultUrl.CardBrand = callback.GetOrDefault("pg_card_brand", string.Empty);
resultUrl.CardPan = callback.GetOrDefault("pg_card_pan", string.Empty);
resultUrl.CardHash = callback.GetOrDefault("pg_card_hash", string.Empty);
resultUrl.AuthCode = callback.GetOrDefault("pg_auth_code", string.Empty);
resultUrl.Captured = callback.GetOrDefault("pg_captured", CardClearingBehaviourType.WaitForPlatronWillSend);
}
resultUrl.UserPhone = callback.GetOrDefault("pg_user_phone", string.Empty);
resultUrl.NeedPhoneNotification = callback.GetBool("pg_need_phone_notification", x => x == "1");
resultUrl.UserContactEmail = callback.GetOrDefault("pg_user_contact_email", string.Empty);
resultUrl.NeedEmailNotification = callback.GetBoolOrDefault("pg_need_email_notification", x => x == "1", false);
resultUrl.RecurringProfileId = callback.GetOrDefault("pg_recurring_profile_id", string.Empty);
resultUrl.RecurringProfileExpiryDate = callback.GetDateOrDefault("pg_recurring_profile_expiry_date", DateTime.MinValue);
return(resultUrl);
}
public async void Process_Should_Not_Clear_User_Data_If_ExchangeCode_Fails()
{
var userId = Guid.NewGuid().ToString();
var code = Guid.NewGuid().ToString();
var callbackRequest = new CallbackRequest
{
Code = code,
Scope = $"{Scope.accounts.ToString()} {Scope.offline_access.ToString()}"
};
_mockAuthorizationService
.Setup(x => x.ExchangeCode(It.Is <AccountAccessContext>(context => context.Code == code && context.UserId == userId)))
.ReturnsAsync(ServiceObjectResult <AccountAccessContext> .Failed(null, new List <string>()));
var result = await _callbackService.Process(userId, callbackRequest);
Assert.False(result.Success);
_mockAuthorizationService.Verify(x => x.ExchangeCode(It.Is <AccountAccessContext>(context => context.Code == code && context.UserId == userId)), Times.Once);
_mockUserDataCachingService.Verify(x => x.ClearUserData(It.IsAny <string>()), Times.Never);
}
public void UpdateCallbackSuccessfully()
{
var content = Files.ReadAllText("./Fixtures/callback_edit.json");
var client = GetMockClient(content);
var repo = Get <ICallbackRepository>(client.Object);
const string callbackId = "f92d4ca1-4ee5-43f3-9e34-ca5f759c5e76";
var callback = new Callback
{
Id = callbackId,
ObjectType = ObjectType.Accounts,
Description = "Account Callback",
Enabled = true,
Url = "https://httpbin.org/put",
CreatedAt = DateTime.Now.AddDays(-2),
UpdatedAt = DateTime.Now.AddDays(-1),
Links = new CallbackLinks
{
Self = "",
Responses = ""
}
};
var request = new CallbackRequest
{
ObjectType = ObjectType.Users,
Description = "Users Callback",
Enabled = true,
Url = ""
};
var updatedCallback = repo.UpdateCallbackAsync(callbackId, request).Result;
Assert.NotNull(updatedCallback);
Assert.Equal(callback.Id, updatedCallback.Id);
Assert.Equal(updatedCallback.ObjectType, ObjectType.Users);
Assert.Equal(updatedCallback.Description, "Users Callback");
Assert.Equal(updatedCallback.Enabled, true);
Assert.Equal(updatedCallback.Url, "https://httpbin.org/put");
}
public async void Process_Should_Call_ExchangeCode_With_New_AccessContext()
{
var userId = Guid.NewGuid().ToString();
var code = Guid.NewGuid().ToString();
var callbackRequest = new CallbackRequest
{
Code = code,
Scope = $"{Scope.accounts.ToString()} {Scope.offline_access.ToString()}"
};
_mockAuthorizationService
.Setup(x => x.ExchangeCode(It.Is <AccountAccessContext>(context => context.Code == code && context.UserId == userId)))
.ReturnsAsync(ServiceObjectResult <AccountAccessContext> .Succeeded(new AccountAccessContext
{
Code = code, UserId = userId
}));
var result = await _callbackService.Process(userId, callbackRequest);
Assert.True(result.Success);
_mockAuthorizationService.Verify(x => x.ExchangeCode(It.Is <AccountAccessContext>(context => context.Code == code && context.UserId == userId)), Times.Once);
}
private void TestSendCallBack(string id, string orderId)
{
using (SqlSugarClient db = new DBClient().GetClient())
{
var account = db.Queryable <table_商户账号>().Where(it => it.商户ID == id).First();
var detail = db.Queryable <table_商户明细提款>().Where(it => it.订单号 == orderId).First();
CallbackRequest request = new CallbackRequest()
{
Username = account.商户ID,
Userpassword = account.商户密码,
OrderNumberSite = detail.订单号,
OrderNumberMerchant = detail.商户API订单号,
OrderType = detail.类型,
OrderStatus = detail.状态,
OrderTimeCreation = detail.时间创建.Value.ToString("yyyy-MM-dd HH:mm:ss"),
OrderTimeEnd = detail.时间完成.Value.ToString("yyyy-MM-dd HH:mm:ss"),
OrderMoney = detail.交易金额.Value.ToString()
};
try
{
int statusCode = 0;
using (MD5 md5Hash = MD5.Create())
{
// 商户ID + 商户API密码 + 当前unix时间 + 商户自定义订单号 + 生成订单号 + 类型 + 状态 + 公共密匙(公匙)
long ts = GetTimeStamp();
string unsign = request.Username + request.Userpassword + ts +
request.OrderNumberMerchant + request.OrderNumberSite + request.OrderType + request.OrderStatus + account.公共密匙;
string sign = GetMd5Hash(md5Hash, unsign);
string url = $"{account.API回调}?timeunix={ts}&signature={sign}";
string response = PostResponse(url, JsonConvert.SerializeObject(request), out statusCode);
ShowMessage(response);
}
}
catch (Exception e)
{
ShowMessage(e.Message);
}
}
}
public async Task <IActionResult> Index(CallbackRequest request)
{
_logger.LogDebug("Callback response", request);
var client = new HttpClient();
var response = await client.RequestTokenAsync(new TokenRequest
{
Address = "https://demo.identityserver.io/connect/token",
GrantType = "custom",
ClientId = "client",
ClientSecret = "secret",
Parameters =
{
{ "custom_parameter", "custom value" },
{ "scope", "api1" }
}
});
return(View(request));
}
public void CreateCallbackSuccessfully()
{
var content = Files.ReadAllText("./Fixtures/callback_create.json");
var client = GetMockClient(content);
var repo = Get <ICallbackRepository>(client.Object);
var request = new CallbackRequest
{
ObjectType = ObjectType.Users,
Description = "Users Callback",
Enabled = true,
Url = "https://httpbin.org/post"
};
var response = repo.CreateCallbackAsync(request).Result;
Assert.NotNull(response);
Assert.Equal(request.ObjectType, response.ObjectType);
Assert.Equal(request.Description, response.Description);
Assert.Equal(request.Enabled, response.Enabled);
Assert.Equal(request.Url, response.Url);
}
private string SendMessage(CallbackRequest callbackRequest)
{
var command = callbackRequest.Object.Body;
var toExecute = _commands.SingleOrDefault(pair => pair.Key.Equals(command.Trim().ToLower())).Value;
if (toExecute == null)
{
if (command.Contains("tag"))
{
var crutchCommand = _commands.SingleOrDefault(pair => pair.Key.Equals("tag")).Value;
callbackRequest.Object.Body = callbackRequest.Object.Body.Split(' ')[1];
crutchCommand(callbackRequest);
}
else
{
SendCommandList(callbackRequest);
}
}
else
{
toExecute(callbackRequest);
}
return("ok");
}
public HttpResponseMessage Post([FromBody] CallbackRequest request)
{
var response = new HttpResponseMessage(HttpStatusCode.OK);
if (request.Type == EventType.Сonfirmation)
{
response.Content = new StringContent(
ConfigurationManager.ConnectionStrings["confirm-code"].ConnectionString,
System.Text.Encoding.UTF8, "text/plain");
}
if (request.Type == EventType.MessageNew)
{
var m = request.Object;
Task.Run(() => Bot.NewMessage(m.PeerId, m.Text));
response.Content = new StringContent(
"ok",
System.Text.Encoding.UTF8,
"text/plain");
}
return(response);
}
/// <summary>
/// Called when an asynchronous read operation completes.
/// </summary>
private void OnReadComplete(IAsyncResult result)
{
AsyncReadTransaction transaction = null;
lock (m_lock)
{
// complete the operation.
DataValueCollection results = null;
DiagnosticInfoCollection diagnosticInfos = null;
int serviceError = ResultIds.S_OK;
try
{
m_session.EndRead(
result,
out results,
out diagnosticInfos);
}
catch (Exception)
{
serviceError = ResultIds.E_FAIL;
}
try
{
// check if transaction has been cancelled.
int cancelId = (int)result.AsyncState;
Transaction transaction2 = null;
if (!m_transactions.TryGetValue(cancelId, out transaction2))
{
return;
}
transaction = (AsyncReadTransaction)transaction2;
m_transactions.Remove(cancelId);
// get callback object - nothing more to do if missing.
IOPCDataCallback callback = (IOPCDataCallback)GetCallback(typeof(IOPCDataCallback).GUID);
if (callback == null)
{
return;
}
// process results.
ReadValueIdCollection nodesToRead = transaction.NodesToRead;
List<CallbackValue> callbackValues = new List<CallbackValue>();
for (int ii = 0; ii < nodesToRead.Count; ii++)
{
// get item in originally read.
Item itemToRead = (Item)nodesToRead[ii].Handle;
// process the read result.
object value = null;
short quality = Qualities.OPC_QUALITY_BAD;
DateTime timestamp = DateTime.MinValue;
int error = serviceError;
if (serviceError >= 0)
{
error = ProcessReadResult(
itemToRead.ServerHandle,
itemToRead.ReqType,
results[ii],
out value,
out quality,
out timestamp);
// update the cache.
UpdateCachedValue(itemToRead, results[ii]);
}
CallbackValue callbackValue = new CallbackValue();
callbackValue.ClientHandle = itemToRead.ClientHandle;
callbackValue.Value = value;
callbackValue.Quality = quality;
callbackValue.Timestamp = timestamp;
callbackValue.Error = error;
callbackValues.Add(callbackValue);
}
// queue the callback.
CallbackRequest request = new CallbackRequest();
request.CallbackType = (transaction.IsRefresh)?CallbackType.DataChange:CallbackType.Read;
request.Callback = callback;
request.TransactionId = transaction.TransactionId;
request.GroupHandle = m_clientHandle;
request.ServerHandle = m_serverHandle;
request.Values = callbackValues;
QueueCallbackRequest(request);
}
catch (Exception e)
{
Utils.Trace(e, "Unexpected error processing asynchronous read callback.");
}
}
}
/// <summary>
/// Called when an asynchronous write operation completes.
/// </summary>
private void OnWriteComplete(IAsyncResult result)
{
AsyncWriteTransaction transaction = null;
lock (m_lock)
{
// complete the write operation.
StatusCodeCollection results = null;
DiagnosticInfoCollection diagnosticInfos = null;
int serviceError = ResultIds.S_OK;
try
{
m_session.EndWrite(
result,
out results,
out diagnosticInfos);
}
catch (Exception)
{
serviceError = ResultIds.E_FAIL;
}
try
{
// check if transaction has been cancelled.
int cancelId = (int)result.AsyncState;
Transaction transaction2 = null;
if (!m_transactions.TryGetValue(cancelId, out transaction2))
{
return;
}
transaction = (AsyncWriteTransaction)transaction2;
m_transactions.Remove(cancelId);
// get callback object - nothing more to do if missing.
IOPCDataCallback callback = (IOPCDataCallback)GetCallback(typeof(IOPCDataCallback).GUID);
if (callback == null)
{
return;
}
// process results.
WriteValueCollection valuesToWrite = transaction.ValuesToWrite;
List<CallbackValue> callbackValues = new List<CallbackValue>();
for (int ii = 0; ii < valuesToWrite.Count; ii++)
{
// get item originally written.
Item itemToWrite = (Item)valuesToWrite[ii].Handle;
int error = serviceError;
// get for operation level error.
if (serviceError >= 0)
{
error = Server.MapWriteStatusToErrorCode(results[ii]);
}
CallbackValue callbackValue = new CallbackValue();
callbackValue.ClientHandle = itemToWrite.ClientHandle;
callbackValue.Error = error;
callbackValues.Add(callbackValue);
}
// queue the callback.
CallbackRequest request = new CallbackRequest();
request.CallbackType = CallbackType.Write;
request.Callback = callback;
request.TransactionId = transaction.TransactionId;
request.GroupHandle = m_clientHandle;
request.ServerHandle = m_serverHandle;
request.Values = callbackValues;
QueueCallbackRequest(request);
}
catch (Exception e)
{
Utils.Trace(e, "Unexpected error processing asynchronous write callback.");
}
}
}
/// <summary>
/// IOPCAsyncIO2::Cancel2 - Request that the server cancel an outstanding transaction.
/// </summary>
public void Cancel2(int dwCancelID)
{
lock (m_lock)
{
if (m_subscription == null) throw ComUtils.CreateComException(ResultIds.E_FAIL);
// get callback object - error if missing.
IOPCDataCallback callback = (IOPCDataCallback)GetCallback(typeof(IOPCDataCallback).GUID);
if (callback == null)
{
throw ComUtils.CreateComException(ResultIds.CONNECT_E_NOCONNECTION);
}
try
{
// see if transaction has already completed.
Transaction transaction = null;
if (!m_transactions.TryGetValue(dwCancelID, out transaction))
{
throw ComUtils.CreateComException(ResultIds.E_FAIL);
}
// remove transaction - results will be discarded.
m_transactions.Remove(dwCancelID);
// Utils.Trace(
// "AsyncCancel: GroupHandle={0}, CancelID={1}",
// m_clientHandle,
// dwCancelID);
// queue the callback.
CallbackRequest request = new CallbackRequest();
request.CallbackType = CallbackType.Cancel;
request.Callback = callback;
request.TransactionId = transaction.TransactionId;
request.GroupHandle = m_clientHandle;
request.ServerHandle = m_serverHandle;
QueueCallbackRequest(request);
}
catch (Exception e)
{
throw ComUtils.CreateComException(e);
}
}
}
public IActionResult PostPayment(CallbackRequest data)
{
return(Ok());
}
/// <summary>
/// Queues a callback request. Assigns a worker thread if one is not already assigned.
/// </summary>
private void QueueCallbackRequest(CallbackRequest callback)
{
lock (m_callbacks)
{
if (m_callbacks.Count == 0)
{
ThreadPool.QueueUserWorkItem(OnCallback);
}
m_callbacks.Enqueue(callback);
}
}
/// <summary>
/// Sends a read or datachange callback to the client.
/// </summary>
private void SendReadCallback(CallbackRequest callback)
{
int count = callback.Values.Count;
int masterError = ResultIds.S_OK;
int masterQuality = ResultIds.S_OK;
int[] clientHandles = new int[count];
object[] values = new object[count];
short[] qualities = new short[count];
System.Runtime.InteropServices.ComTypes.FILETIME[] timestamps = new System.Runtime.InteropServices.ComTypes.FILETIME[count];
int[] errors = new int[count];
for (int ii = 0; ii < callback.Values.Count; ii++)
{
CallbackValue change = callback.Values[ii];
clientHandles[ii] = change.ClientHandle;
values[ii] = change.Value;
qualities[ii] = change.Quality;
timestamps[ii] = ComUtils.GetFILETIME(change.Timestamp);
errors[ii] = change.Error;
// check error.
if (change.Error < 0)
{
masterError = ResultIds.S_FALSE;
continue;
}
// set the master quality if any bad qualities are found.
if ((change.Quality & Qualities.OPC_QUALITY_GOOD) != Qualities.OPC_QUALITY_GOOD)
{
masterQuality = ResultIds.S_FALSE;
}
}
//Utils.Trace(
// "DataChange: GroupHandle={0}, Count={1}, ServerHandle={2}, Value={3}",
// callback.ServerHandle,
// callback.Values.Count,
// callback.Values[0].ServerHandle,
// callback.Values[0].Value);
if (callback.CallbackType == CallbackType.DataChange)
{
callback.Callback.OnDataChange(
callback.TransactionId,
callback.GroupHandle,
masterQuality,
masterError,
count,
clientHandles,
values,
qualities,
timestamps,
errors);
m_server.SetLastUpdate();
}
else
{
callback.Callback.OnReadComplete(
callback.TransactionId,
callback.GroupHandle,
masterQuality,
masterError,
count,
clientHandles,
values,
qualities,
timestamps,
errors);
}
}
/// <summary>
/// Sends a write callback to the client.
/// </summary>
private void SendWriteCallback(CallbackRequest callback)
{
int count = callback.Values.Count;
int masterError = ResultIds.S_OK;
int[] clientHandles = new int[count];
int[] errors = new int[count];
for (int ii = 0; ii < callback.Values.Count; ii++)
{
CallbackValue result = callback.Values[ii];
clientHandles[ii] = result.ClientHandle;
errors[ii] = result.Error;
if (result.Error < 0)
{
masterError = ResultIds.S_FALSE;
}
}
// Utils.Trace(
// "WriteComplete: GroupHandle={0}, ServerHandle={1}, Error={2}",
// callback.GroupHandle,
// callback.Values[0].ClientHandle,
// callback.Values[0].Error);
callback.Callback.OnWriteComplete(
callback.TransactionId,
callback.GroupHandle,
masterError,
count,
clientHandles,
errors);
}
/// <summary>
/// Sends a cancel callback to the client.
/// </summary>
private void SendCancelCallback(CallbackRequest callback)
{
// Utils.Trace(
// "CancelComplete: GroupHandle={0}, TransactionId={1}",
// callback.GroupHandle,
// callback.TransactionId);
callback.Callback.OnCancelComplete(callback.TransactionId, callback.GroupHandle);
}
public string Handle(CallbackRequest callbackRequest)
{
var execute = _methods.SingleOrDefault(pair => pair.Key.Equals(callbackRequest.Type)).Value;
return(execute(callbackRequest));
}
/// <summary>
/// IOPCAsyncIO3::WriteVQT - Writes one or more values, qualities and timestamps for the items specified.
/// The results are returned via the client�s IOPCDataCallback connection established
/// through the server�s IConnectionPointContainer.
/// </summary>
public void WriteVQT(
int dwCount,
int[] phServer,
OPCITEMVQT[] pItemVQT,
int dwTransactionID,
out int pdwCancelID,
out System.IntPtr ppErrors)
{
pdwCancelID = 0;
// validate arguments.
if (dwCount == 0 || phServer == null || pItemVQT == null || dwCount != phServer.Length || dwCount != pItemVQT.Length)
{
throw ComUtils.CreateComException(ResultIds.E_INVALIDARG);
}
// get callback object - nothing more to do if missing.
IOPCDataCallback callback = (IOPCDataCallback)GetCallback(typeof(IOPCDataCallback).GUID);
if (callback == null)
{
throw ComUtils.CreateComException(ResultIds.CONNECT_E_NOCONNECTION);
}
try
{
int[] errors = new int[dwCount];
// build list of values to write.
WriteValueCollection valuesToWrite = new WriteValueCollection();
lock (m_lock)
{
if (m_subscription == null) throw ComUtils.CreateComException(ResultIds.E_FAIL);
CallbackValue[] conversionErrors = null;
for (int ii = 0; ii < dwCount; ii++)
{
Item itemToWrite = null;
if (!m_items.TryGetValue(phServer[ii], out itemToWrite))
{
errors[ii] = ResultIds.E_INVALIDHANDLE;
continue;
}
VariableNode variable = itemToWrite.Variable;
WriteValue valueToWrite = new WriteValue();
valueToWrite.NodeId = variable.NodeId;
valueToWrite.IndexRange = null;
valueToWrite.AttributeId = Attributes.Value;
DataValue value = new DataValue();
int error = 0;
value.Value = m_server.VariantValueToValue(variable, pItemVQT[ii].vDataValue, out error);
if (error != ResultIds.S_OK)
{
// only allocate this array when it is needed.
if (conversionErrors == null)
{
conversionErrors = new CallbackValue[dwCount];
}
// create the callback item.
CallbackValue conversionError = new CallbackValue();
conversionError.ClientHandle = itemToWrite.ClientHandle;
conversionError.Error = error;
conversionErrors[ii] = conversionError;
errors[ii] = error;
continue;
}
valueToWrite.Value = value;
if (pItemVQT[ii].bQualitySpecified != 0)
{
value.StatusCode = ComUtils.GetQualityCode(pItemVQT[ii].wQuality);
}
if (pItemVQT[ii].bTimeStampSpecified != 0)
{
value.SourceTimestamp = ComUtils.GetDateTime(pItemVQT[ii].ftTimeStamp);
}
// needed to correlate results to input.
valueToWrite.Handle = itemToWrite;
valuesToWrite.Add(valueToWrite);
}
// create transaction.
if (valuesToWrite.Count > 0 || conversionErrors != null)
{
pdwCancelID = Utils.IncrementIdentifier(ref m_nextHandle);
m_transactions[pdwCancelID] = new AsyncWriteTransaction(dwTransactionID, valuesToWrite);
}
// send conversion errors in the callback if no valid items available (CTT bug workaround).
if (valuesToWrite.Count == 0 && conversionErrors != null)
{
// must return S_OK from this function if sending the errors in the callback.
List<CallbackValue> errorsToSend = new List<CallbackValue>();
for (int ii = 0; ii < conversionErrors.Length; ii++)
{
if (conversionErrors[ii] != null)
{
errors[ii] = ResultIds.S_OK;
errorsToSend.Add(conversionErrors[ii]);
}
}
// queue the request.
CallbackRequest request = new CallbackRequest();
request.CallbackType = CallbackType.Write;
request.Callback = callback;
request.TransactionId = dwTransactionID;
request.GroupHandle = m_clientHandle;
request.ServerHandle = m_serverHandle;
request.Values = errorsToSend;
QueueCallbackRequest(request);
}
}
// write values from server.
if (valuesToWrite.Count > 0)
{
m_session.BeginWrite(
null,
valuesToWrite,
new AsyncCallback(OnWriteComplete),
pdwCancelID);
}
// marshal error codes.
ppErrors = ComUtils.GetInt32s(errors);
}
catch (Exception e)
{
Utils.Trace(e, "Error writing items.");
throw ComUtils.CreateComException(e);
}
}
public Task <ServiceResult> Process(string userId, CallbackRequest callbackData)
{
return(Task.FromResult(GenerateResponse(userId)));
}
/// <summary>
/// Requests that the following action be completed as soon as reasonably possible.
/// This will either be done immediately, or be queued for the next approriate time.
/// </summary>
/// <param name="callback">action to perform</param>
/// <returns>
/// A cancelation object. Use in a using block.
/// </returns>
public CallbackRequest RequestCallback(Action callback)
{
CallbackRequest request = new CallbackRequest(callback);
lock (m_syncRoot)
{
m_isRequestCallbackMethodProcessing = true;
Thread.MemoryBarrier();
//------------------------------------------
if (m_isSafeToCallback)
{
request.Run();
}
else
{
m_isCallbackWaiting = true;
m_pendingCallbacks.Add(request);
}
//-----------------------------------------
Thread.MemoryBarrier();
m_isRequestCallbackMethodProcessing = false;
}
return request;
}
/// <summary>
/// Queues a datachange.
/// </summary>
private void QueueDataChange(bool sendAll)
{
// dequeue values from monitored item caches.
List<CallbackValue> changes = new List<CallbackValue>();
foreach (Item item in this.m_items.Values)
{
IList<DataValue> values = item.MonitoredItem.DequeueValues();
// send the cached value if an update must be sent.
if (sendAll && values.Count == 0)
{
values = new DataValue[1];
// look of value in the publishing cache.
DataValue dataValue = ReadCachedValue(item, Int32.MaxValue);
// create a dummy value if nothing in the cache.
if (dataValue == null)
{
dataValue = new DataValue();
dataValue.ServerTimestamp = DateTime.UtcNow;
dataValue.StatusCode = StatusCodes.BadWaitingForInitialData;
}
values[0] = dataValue;
}
//Utils.Trace(
// "Values Found: Group={0}, Changes={1}",
// m_clientHandle,
// values.Count);
for (int ii = 0; ii < values.Count; ii++)
{
// apply any type conversions.
object value;
short quality;
DateTime timestamp;
int error = ProcessReadResult(
item.ServerHandle,
item.ReqType,
values[ii],
out value,
out quality,
out timestamp);
item.LastValueSent = value;
item.LastQualitySent = quality;
item.LastTimestampSent = timestamp;
// update value in cache.
UpdateCachedValue(item, values[ii]);
// create callback value for active items
if (item.Active && m_active && m_enabled)
{
CallbackValue change = new CallbackValue();
change.ServerHandle = item.ServerHandle;
change.ClientHandle = item.ClientHandle;
change.Value = value;
change.Quality = quality;
change.Timestamp = timestamp;
change.Error = error;
changes.Add(change);
}
}
}
// get callback object - do nothing if missing.
IOPCDataCallback callback = (IOPCDataCallback)GetCallback(typeof(IOPCDataCallback).GUID);
if (callback == null)
{
return;
}
// check if there are changes to send.
if (changes.Count > 0)
{
CallbackRequest request = new CallbackRequest();
request.CallbackType = CallbackType.DataChange;
request.Callback = callback;
request.GroupHandle = m_clientHandle;
request.ServerHandle = m_serverHandle;
request.Values = changes;
//Utils.Trace(
// "Callback Queued: Group={0}, Changes={1}, Value[0]={2}",
// m_clientHandle,
// changes.Count,
// changes[0].Value);
QueueCallbackRequest(request);
}
}
public static ResultUrlRequest Parse(CallbackRequest callback)
{
Ensure.ArgumentNotNull(callback, nameof(callback));
var resultUrl = new ResultUrlRequest();
resultUrl.Uri = callback.Uri;
resultUrl.OrderId = callback.GetOrDefault("pg_order_id", string.Empty);
resultUrl.PaymentId = callback.Get("pg_payment_id");
resultUrl.Amount = callback.Get<double>("pg_amount");
resultUrl.Currency = callback.Get<PlatronPaymentCurrency>("pg_currency");
resultUrl.NetAmount = callback.Get<double>("pg_net_amount");
resultUrl.PsAmount = callback.Get<double>("pg_ps_amount");
resultUrl.PsFullAmount = callback.Get<double>("pg_ps_full_amount");
resultUrl.PsCurrency = callback.Get<PlatronPaymentCurrency>("pg_ps_currency");
resultUrl.Overpayment = callback.GetOrDefault<double>("pg_overpayment", 0);
resultUrl.PaymentSystem = callback.Get("pg_payment_system");
resultUrl.PaymentDate = callback.GetDate("pg_payment_date");
resultUrl.CanReject = callback.GetOrDefault("pg_can_reject", PaymentRejectType.Unrevokable);
if (callback.Contains("pg_card_brand"))
{
resultUrl.CardBrand = callback.GetOrDefault("pg_card_brand", string.Empty);
resultUrl.CardPan = callback.GetOrDefault("pg_card_pan", string.Empty);
resultUrl.CardHash = callback.GetOrDefault("pg_card_hash", string.Empty);
resultUrl.AuthCode = callback.GetOrDefault("pg_auth_code", string.Empty);
resultUrl.Captured = callback.GetOrDefault("pg_captured", CardClearingBehaviourType.WaitForPlatronWillSend);
}
resultUrl.UserPhone = callback.GetOrDefault("pg_user_phone", string.Empty);
resultUrl.NeedPhoneNotification = callback.GetBool("pg_need_phone_notification", x => x == "1");
resultUrl.UserContactEmail = callback.GetOrDefault("pg_user_contact_email", string.Empty);
resultUrl.NeedEmailNotification = callback.GetBoolOrDefault("pg_need_email_notification", x => x == "1", false);
resultUrl.RecurringProfileId = callback.GetOrDefault("pg_recurring_profile_id", string.Empty);
resultUrl.RecurringProfileExpiryDate = callback.GetDateOrDefault("pg_recurring_profile_expiry_date", DateTime.MinValue);
return resultUrl;
}
