public static void GetSprite(CroppedImage src,
object obj, Action <object, SpriteInfo> callback)
{
var basename = src.BaseImage.Name;
TextureInfo ti = null;
texture_dict.TryGetValue(basename, out ti);
if (ti == null)
{
var item = new CallbackInfo(src, obj, callback);
List <CallbackInfo> list = null;
if (loading_set.TryGetValue(basename, out list))
{
list.Add(item);
}
else
{
list = new List <CallbackInfo> {
item
};
loading_set.Add(basename, list);
GenericUtils.StartCoroutine(Loading(src.BaseImage));
}
}
else
{
callback(obj, GetSpriteInfo(ti, src));
}
}
async void IDataBaseContextEventCallback.OnDataBasesReset(CallbackInfo callbackInfo, string[] dataBaseNames, DataBaseMetaData[] metaDatas)
{
try
{
await this.callbackEvent.InvokeAsync(callbackInfo.Index, () =>
{
this.Dispatcher.Invoke(() =>
{
var authentication = this.UserContext.Authenticate(callbackInfo.SignatureDate);
var dataBases = new DataBase[dataBaseNames.Length];
for (var i = 0; i < dataBaseNames.Length; i++)
{
var dataBaseName = dataBaseNames[i];
var metaData = metaDatas[i];
var dataBase = this[dataBaseName];
dataBases[i] = dataBase;
dataBase.SetReset(authentication, metaData);
}
//this.InvokeItemsResetEvent(authentication, dataBases, metaData);
});
});
}
catch (Exception e)
{
this.CremaHost.Error(e);
}
}
public void Schedule(System.Action <ISPAnim> callback)
{
//if (!_state.IsPlaying) throw new System.InvalidOperationException("Can only schedule a callback on a playing animation.");
if (callback == null)
{
throw new System.ArgumentNullException("callback");
}
if (_endOfLineCallback == null)
{
_endOfLineCallback = new CallbackInfo()
{
timeout = float.PositiveInfinity
}
}
;
_endOfLineCallback.callback += callback;
if (_waitRoutine == null)
{
_waitRoutine = new RadicalCoroutine(this.DoUpdate()); //RadicalCoroutine.UpdateTicker(this.Update);
}
if (!_waitRoutine.Active)
{
_waitRoutine.Start(_state.Controller);
}
}
async void IDataBaseContextEventCallback.OnDataBasesCreated(CallbackInfo callbackInfo, string[] dataBaseNames, DataBaseInfo[] dataBaseInfos, string comment)
{
try
{
await this.callbackEvent.InvokeAsync(callbackInfo.Index, () =>
{
this.Dispatcher.Invoke(() =>
{
var subscribeToken = this.subscribeToken;
var authentication = this.UserContext.Authenticate(callbackInfo.SignatureDate);
var dataBases = new DataBase[dataBaseNames.Length];
for (var i = 0; i < dataBaseNames.Length; i++)
{
var dataBaseName = dataBaseNames[i];
var dataBaseInfo = dataBaseInfos[i];
var dataBase = new DataBase(this, subscribeToken, dataBaseInfo);
this.AddBase(dataBase.Name, dataBase);
dataBases[i] = dataBase;
}
this.InvokeItemsCreateEvent(authentication, dataBases, comment);
});
});
}
catch (Exception e)
{
this.CremaHost.Error(e);
}
}
private bool ProcessTimer(Guid workflowInstanceId)
{
bool retval = false;
CallbackInfo cs = null;
Guid timerId = Guid.Empty;
lock (locker)
{
Guid expTimerId;
if (HasExpiredTimer(workflowInstanceId, out expTimerId))
{
cs = pendingScheduleRequests.Remove(expTimerId);
}
}
try
{
if (cs != null)
{
WorkflowTrace.Host.TraceEvent(TraceEventType.Information, 0, "ManualWorkflowSchedulerService: Processing timer {0}", timerId);
cs.Callback(cs.InstanceId);
retval = true;
}
}
catch (Exception e)
{
RaiseServicesExceptionNotHandledEvent(e, workflowInstanceId);
}
return(retval);
}
/// <summary>
/// Called when item is updated
/// </summary>
/// <param name="key">key of the item being updated</param>
/// <param name="callbackEntry">callback entry that contains the updated value</param>
private void CustomUpdate(object key, object callbackInfo, EventContext eventContext)
{
if (_client != null)
{
CallbackInfo cbInfo = callbackInfo as CallbackInfo;
if (cbInfo != null && cbInfo.Client == _client.ClientID)
{
//client older then 4.1 sp2 private patch 4 does not support bulk Events
if (_client.ClientVersion >= 4124)
{
Alachisoft.NCache.Common.Protobuf.BulkEventItemResponse eventitem = new Common.Protobuf.BulkEventItemResponse();
eventitem.eventType = Common.Protobuf.BulkEventItemResponse.EventType.ITEM_UPDATED_CALLBACK;
eventitem.ItemUpdatedCallback = EventHelper.GetItemUpdatedCallbackResponse(eventContext, (string)key, (short)cbInfo.Callback, cbInfo.DataFilter);
//To avoid NullReference problem if both evnt and NCache.Dispose are called simultaenously
ClientManager client = _client;
if (client != null)
{
client.ConnectionManager.EnqueueEvent(eventitem, _client.SlaveId);
}
//_client.EnqueueEvent(eventitem);
}
else
{
lock (ConnectionManager.CallbackQueue)
{
ConnectionManager.CallbackQueue.Enqueue(new ItemUpdateCallback((short)cbInfo.Callback, (string)key, cbInfo.Client, eventContext, cbInfo.DataFilter));
Monitor.Pulse(ConnectionManager.CallbackQueue);
}
}
}
}
}
protected override void OnStarted()
{
lock (this.timerQueue)
{
base.OnStarted();
CallbackInfo info = this.timerQueue.Peek();
if (info != null)
{
this.callbackTimer = this.CreateTimerCallback(info);
}
this.running = true;
}
lock (this.waitingQueue)
{
int num = Math.Min(this.maxSimultaneousWorkflows, this.waitingQueue.Count);
for (int i = 0; i < num; i++)
{
if (ThreadPool.QueueUserWorkItem(new WaitCallback(this.QueueWorkerProcess)))
{
this.numCurrentWorkers++;
}
}
}
if ((this.queueCounters == null) && (base.Runtime.PerformanceCounterManager != null))
{
this.queueCounters = base.Runtime.PerformanceCounterManager.CreateCounters(ExecutionStringManager.PerformanceCounterWorkflowsWaitingName);
}
}
public virtual void OnCustomRemoveCallback(string key, object value, CacheItemRemovedReason reason,
BitSet flag, bool notifyAsync, EventCacheItem item)
{
try
{
object[] args = value as object[];
if (args != null)
{
object val = args[0];
CallbackInfo cbInfo = args[1] as CallbackInfo;
if (cbInfo != null)
{
if (_parent._perfStatsCollector != null)
{
_parent._perfStatsCollector.IncrementEventsProcessedPerSec();
}
if (item != null)
{
item.Value = GetObject(item.Value, flag);
}
EventHandle handle = new EventHandle((short)cbInfo.Callback);
_parent.EventManager.RaiseSelectiveCacheNotification(key, EventType.ItemRemoved, item, null,
reason, notifyAsync, handle, cbInfo.DataFilter);
}
}
}
catch
{
}
}
public override void HandleSuccess(CallbackInfo <WebObjects.Facebook.BindOauthResponse> info)
{
if (Debug.isDebugBuild)
{
Debug.Log("binding succeeded");
}
}
async void IDomainContextEventCallback.OnDomainsDeleted(CallbackInfo callbackInfo, Guid[] domainIDs, bool[] isCanceleds, object[] results)
{
try
{
await this.callbackEvent.InvokeAsync(callbackInfo.Index, () =>
{
this.Dispatcher.Invoke(() =>
{
var authentication = this.UserContext.Authenticate(callbackInfo.SignatureDate);
var domainHostList = new List <IDomainHost>(domainIDs.Length);
var domainHostCanceledList = new List <bool>(domainIDs.Length);
var domainHostResultList = new List <object>(domainIDs.Length);
var domainList = new List <Domain>(domainIDs.Length);
var domainCanceledList = new List <bool>(domainIDs.Length);
var domainResultList = new List <object>(domainIDs.Length);
for (var i = 0; i < domainIDs.Length; i++)
{
var domainID = domainIDs[i];
var isCanceled = isCanceleds[i];
var result = results[i];
var domain = this.GetDomain(domainID);
domain.InvokeDeleteAsync(authentication, isCanceled, result);
}
});
});
}
catch (Exception e)
{
this.CremaHost.Error(e);
}
}
public void UnRegisterKeyNotification(string clientId, string key, CallbackInfo updateCallback, CallbackInfo removeCallback)
{
if (clientId == null)
{
return;
}
lock (this)
{
if (!_clients.ContainsKey(clientId))
{
return;
}
if (_clients[clientId].RemoveKey(key))
{
if (_registeredKeys.ContainsKey(key))
{
if (_registeredKeys[key].DecrementRefCount() <= 0)
{
_registeredKeys.Remove(key);
if (_updatedKeys.ContainsKey(key))
{
_updatedKeys.Remove(key);
}
if (_removedKeys.ContainsKey(key))
{
_removedKeys.Remove(key);
}
}
}
}
}
}
public override void HandleSuccess(CallbackInfo <WebObjects.Items.EquipResponse> info)
{
DomainObjects.InventoryItem item = inventory.dataStore.inventory.Get(id);
item.equipped = true;
RoarManager.OnGoodEquipped(new RoarManager.GoodInfo(id, item.ikey, item.label));
}
public static bool CheckCallbackInfo(CallbackInfo info)
{
var keys = info.Data.Keys;
var dict = new Dictionary <string, string>();
foreach (var key in keys)
{
if (key.Equals("sign"))
{
continue;
}
dict[key] = info.Data[key];
}
//string[] keys = new string[] { "appid", "bank_type", "cash_fee", "fee_type", "is_subscribe", "mch_id", "nonce_str", "openid", "out_trade_no", "result_code", "return_code", "time_end", "total_fee", "trade_type", "transaction_id" };
//foreach (var key in keys)
//{
// dict[key] = info.Data[key];
//}
var config = Config.XCX;
string sign = GetSignString(dict, config.mch_secret);
if (sign.Equals(info.Data["sign"], StringComparison.OrdinalIgnoreCase))
{
return(true);
}
return(false);
}
async void IDataBaseContextEventCallback.OnDataBasesAuthenticationLeft(CallbackInfo callbackInfo, string[] dataBaseNames, AuthenticationInfo authenticationInfo)
{
try
{
await this.callbackEvent.InvokeAsync(callbackInfo.Index, () =>
{
this.Dispatcher.Invoke(() =>
{
var authentication = this.UserContext.Authenticate(callbackInfo.SignatureDate);
var dataBases = new DataBase[dataBaseNames.Length];
for (var i = 0; i < dataBaseNames.Length; i++)
{
var dataBaseName = dataBaseNames[i];
var dataBase = this[dataBaseName];
dataBases[i] = dataBase;
dataBase.SetAuthenticationLeft(authentication);
}
});
});
}
catch (Exception e)
{
this.CremaHost.Error(e);
}
}
private void Update()
{
for (int i = 0; i < mCallbackList.Count; i++)
{
float runTime = mCallbackList[i].ignoretimescale ? Time.realtimeSinceStartup : Time.time;
if (mCallbackList[i].call == null)
{
mCallbackList.RemoveAt(i);
i--;
}
else if (runTime >= mCallbackList[i].endTime)
{
CallbackInfo info = mCallbackList[i];
if (mCallbackList[i].times > 1)
{
info.endTime += info.dely;
info.times--;
mCallbackList[i] = info;
}
else
{
mCallbackList.RemoveAt(i);
i--;
}
info.call();
}
}
for (int i = 0; i < m_CallBackUpdateList.Count; ++i)
{
m_CallBackUpdateList[i]();
}
}
public bool DoCallback(NameValueCollection query, NameValueCollection form, string bodydata, Action <CallbackInfo> action)
{
var parameters = new Dictionary <string, string>();
parameters["status"] = query["status"];
parameters["account"] = query["account"];
parameters["order"] = query["order"];
parameters["orders"] = query["orders"];
parameters["paytype"] = query["paytype"];
parameters["money"] = query["money"];
parameters["body"] = query["body"];
parameters["ext"] = query["ext"];
parameters["sign"] = query["sign"];
var callback = new CallbackInfo();
callback.Status = ResultStatus.Fail;
if (!string.IsNullOrEmpty(parameters["order"]) && parameters["status"] == "1" && parameters["account"] == this.appid)
{
callback.Status = ResultStatus.Succ;
callback.OrderNo = parameters["order"];
callback.AttachData = Base64Helper.Base64Decode(parameters["ext"]);
}
action(callback);
if (callback.Status == ResultStatus.Succ)
{
return(true);
}
return(false);
}
public override void HandleSuccess(CallbackInfo <WebObjects.User.NetdriveFetchResponse> info)
{
//TODO: Move this into the ParseXML function in NetdriveFetchResponse
/*
* string value = "";
* string str = null;
*
* IXMLNode nd = info.data.GetNode("roar>0>user>0>netdrive_get>0>netdrive_field>0>data>0");
* if(nd!=null)
* {
* str = nd.Text;
* }
* if (str!=null) value = str;
*
* data.Data_[key] = value;
* info.msg = value;
*
* if ( value==null || value == "")
* {
* data.logger_.DebugLog("[roar] -- No data for key: "+key);
* info.code = IWebAPI.UNKNOWN_ERR;
* info.msg = "No data for key: "+key;
* cbx( new CallbackInfo<string>( null, IWebAPI.UNKNOWN_ERR, "no data for key: "+key ) );
* }
*/
data.Data_[key] = info.data;
cbx(new CallbackInfo <string>(info.data.data, IWebAPI.OK, null));
RoarManager.OnDataLoaded(key, info.data.data);
}
public virtual void OnCustomUpdateCallback(string key, object value, bool notifyAsync, EventCacheItem item,
EventCacheItem oldItem, BitSet flag)
{
try
{
CallbackInfo cbInfo = value as CallbackInfo;
if (cbInfo != null)
{
if (item != null)
{
item.Value = GetObject(item.Value, flag);
}
if (oldItem != null)
{
oldItem.Value = GetObject(oldItem.Value, flag);
}
if (_parent._perfStatsCollector != null)
{
_parent._perfStatsCollector.IncrementEventsProcessedPerSec();
}
EventHandle handle = new EventHandle((short)cbInfo.Callback);
this._eventManager.RaiseSelectiveCacheNotification(key, EventType.ItemUpdated, item, oldItem,
CacheItemRemovedReason.Underused, notifyAsync, handle, cbInfo.DataFilter);
}
}
catch
{
}
}
async void IDataBaseContextEventCallback.OnDataBasesInfoChanged(CallbackInfo callbackInfo, DataBaseInfo[] dataBaseInfos)
{
try
{
await this.callbackEvent.InvokeAsync(callbackInfo.Index, () =>
{
this.Dispatcher.Invoke(() =>
{
var authentication = this.UserContext.Authenticate(callbackInfo.SignatureDate);
var dataBases = new DataBase[dataBaseInfos.Length];
for (var i = 0; i < dataBaseInfos.Length; i++)
{
var dataBaseInfo = dataBaseInfos[i];
var dataBase = this[dataBaseInfo.Name];
dataBase.SetDataBaseInfo(dataBaseInfo);
dataBases[i] = dataBase;
}
this.InvokeItemsInfoChangedEvent(authentication, dataBases);
});
});
}
catch (Exception e)
{
this.CremaHost.Error(e);
}
}
public void RegisterFeatureFlagChangedCallback(string flagName, LdValue valueDefault, Action <LdValue> callback, bool checkAsap)
{
if (!IsInitialized)
{
Debug.LogWarning("LauchDarklyClientBehavior.RegisterBoolFlagCallback called before initialized.");
}
List <CallbackInfo> callbackInfoList = null;
if (flagCallbacks.ContainsKey(flagName))
{
callbackInfoList = flagCallbacks[flagName];
}
else
{
callbackInfoList = new List <CallbackInfo>();
flagCallbacks[flagName] = callbackInfoList;
}
CallbackInfo callbackInfo = new CallbackInfo(valueDefault, callback, checkAsap);
if (callbackInfoList.Contains(callbackInfo))
{
Debug.LogError("LaunchDarklyClientBehavior.RegisterFlagChangedCallback - duplicate callback attempted registration; process ABORTED.");
return;
}
callbackInfoList.Add(callbackInfo);
if (IsInitialized && checkAsap)
{
ExecuteVariationCheck(flagName, callback, ref valueDefault);
}
}
internal void SignalEvent(
HardwareComponentEventHandler callback, ElementComponent componenet)
{
// enqueue the info about the callback for later use
CallbackInfo ci = new CallbackInfo();
ci.callback = callback;
ci.component = componenet;
lock (callbacks)
{
if (!callbacks.Contains(ci))
{
callbacks.Enqueue(ci);
}
}
// if asyncCallbacks are enabled, then go ahead and run them
// on this thread - otherwise they wait for a explicit call to
// PumpEvents() by the user (or the run loop)
if (asyncCallbacks)
{
PumpEvents();
}
else
{
// this signals the Run() loop that there are
// events to be run
eventsReady.Set();
}
}
async void IDataBaseContextEventCallback.OnDataBasesDeleted(CallbackInfo callbackInfo, string[] dataBaseNames)
{
try
{
await this.callbackEvent.InvokeAsync(callbackInfo.Index, () =>
{
this.Dispatcher.Invoke(() =>
{
var authentication = this.UserContext.Authenticate(callbackInfo.SignatureDate);
var dataBases = new DataBase[dataBaseNames.Length];
for (var i = 0; i < dataBaseNames.Length; i++)
{
var dataBaseName = dataBaseNames[i];
var dataBase = this[dataBaseName];
this.RemoveBase(dataBaseName);
dataBases[i] = dataBase;
}
this.InvokeItemsDeletedEvent(authentication, dataBases, dataBaseNames);
});
});
}
catch (Exception e)
{
this.CremaHost.Error(e);
}
}
private void OnTimerCallback(object ignored)
{
CallbackInfo ci = null;
try
{
lock (locker)
{
if (State.Equals(WorkflowRuntimeServiceState.Started))
{
ci = pendingScheduleRequests.Peek();
if (ci != null)
{
if (ci.IsExpired)
{
WorkflowTrace.Host.TraceEvent(TraceEventType.Information, 0, "Timeout occured for timer for instance {0}", ci.InstanceId);
threadRunning = true;
pendingScheduleRequests.Dequeue();
}
else
{
callbackTimer = CreateTimerCallback(ci);
}
}
}
}
if (threadRunning)
{
ci.Callback(ci.InstanceId); // delivers the timer message
RunWorkflow(ci.InstanceId);
}
}
catch (ThreadAbortException e)
{
WorkflowTrace.Host.TraceEvent(TraceEventType.Error, 0, "Timeout for instance, {0} threw exception {1}", ci == null ? Guid.Empty : ci.InstanceId, e.Message);
RaiseServicesExceptionNotHandledEvent(e, ci.InstanceId);
throw;
}
catch (Exception e)
{
WorkflowTrace.Host.TraceEvent(TraceEventType.Error, 0, "Timeout for instance, {0} threw exception {1}", ci == null ? Guid.Empty : ci.InstanceId, e.Message);
RaiseServicesExceptionNotHandledEvent(e, ci.InstanceId);
}
finally
{
lock (locker)
{
if (threadRunning)
{
threadRunning = false;
ci = pendingScheduleRequests.Peek();
if (ci != null)
{
callbackTimer = CreateTimerCallback(ci);
}
}
}
}
}
private void OnTimerCallback(object ignored)
{
CallbackInfo info = null;
try
{
lock (this.locker)
{
if (base.State.Equals(WorkflowRuntimeServiceState.Started))
{
info = this.pendingScheduleRequests.Peek();
if (info != null)
{
if (info.IsExpired)
{
WorkflowTrace.Host.TraceEvent(TraceEventType.Information, 0, "Timeout occured for timer for instance {0}", new object[] { info.InstanceId });
this.threadRunning = true;
this.pendingScheduleRequests.Dequeue();
}
else
{
this.callbackTimer = this.CreateTimerCallback(info);
}
}
}
}
if (this.threadRunning)
{
info.Callback(info.InstanceId);
this.RunWorkflow(info.InstanceId);
}
}
catch (ThreadAbortException exception)
{
WorkflowTrace.Host.TraceEvent(TraceEventType.Error, 0, "Timeout for instance, {0} threw exception {1}", new object[] { (info == null) ? Guid.Empty : info.InstanceId, exception.Message });
base.RaiseServicesExceptionNotHandledEvent(exception, info.InstanceId);
throw;
}
catch (Exception exception2)
{
WorkflowTrace.Host.TraceEvent(TraceEventType.Error, 0, "Timeout for instance, {0} threw exception {1}", new object[] { (info == null) ? Guid.Empty : info.InstanceId, exception2.Message });
base.RaiseServicesExceptionNotHandledEvent(exception2, info.InstanceId);
}
finally
{
lock (this.locker)
{
if (this.threadRunning)
{
this.threadRunning = false;
info = this.pendingScheduleRequests.Peek();
if (info != null)
{
this.callbackTimer = this.CreateTimerCallback(info);
}
}
}
}
}
public override CallbackInfo ProcessCallback(Order order, HttpRequest request, IDictionary <string, string> settings)
{
CallbackInfo callbackInfo = null;
try
{
order.MustNotBeNull("order");
request.MustNotBeNull("request");
settings.MustNotBeNull("settings");
settings.MustContainKey("secretKey", "settings");
//Write data when testing
if (settings.ContainsKey("testMode") && settings["testMode"] == "1")
{
LogRequest <Paynova>(request, logPostData: true);
}
PostbackDigest postbackDigest = new PostbackDigest(settings["secretKey"]);
if (order.CartNumber == request.Form["ORDER_NUMBER"] && postbackDigest.Validate(request.Form))
{
decimal amountAuthorized = decimal.Parse(request.Form["PAYMENT_1_AMOUNT"], CultureInfo.InvariantCulture);
string transaction = request.Form["PAYMENT_1_TRANSACTION_ID"];
string paymentType = request.Form["PAYMENT_1_PAYMENT_METHOD_NAME"];
string paymentIdentifier = request.Form["PAYMENT_1_CARD_LAST_FOUR"];
PaymentState?paymentState = null;
switch (request.Form["PAYMENT_1_STATUS"])
{
case "Pending":
paymentState = PaymentState.PendingExternalSystem;
break;
case "Completed":
case "PartiallyCompleted":
paymentState = PaymentState.Captured;
break;
case "Authorized":
paymentState = PaymentState.Authorized;
break;
}
if (paymentState != null)
{
callbackInfo = new CallbackInfo(amountAuthorized, transaction, paymentState.Value, paymentType, paymentIdentifier);
}
}
else
{
LoggingService.Instance.Warn <Paynova>("Paynova(" + order.CartNumber + ") - digest check failed");
}
}
catch (Exception exp)
{
LoggingService.Instance.Error <Paynova>("Paynova(" + order.CartNumber + ") - Process callback", exp);
}
return(callbackInfo);
}
protected void OnBuyComplete(CallbackInfo <Roar.WebObjects.Shop.BuyResponse> response)
{
isBuying = false;
if (response.code != WebAPI.OK)
{
FlashError(response.msg);
}
}
public override void HandleSuccess(CallbackInfo <WebObjects.Shop.BuyResponse> info)
{
RoarManager.OnGoodBought(
new RoarManager.PurchaseInfo(
ikey,
info.data.buy_response
));
}
public override CallbackInfo ProcessCallback(Order order, HttpRequest request, IDictionary <string, string> settings)
{
CallbackInfo callbackInfo = null;
try
{
order.MustNotBeNull("order");
request.MustNotBeNull("request");
settings.MustNotBeNull("settings");
settings.MustContainKey("md5Key1", "settings");
settings.MustContainKey("md5Key2", "settings");
//Write data when testing
if (settings.ContainsKey("test_mode") && settings["test_mode"] == "true")
{
LogRequest <Payer>(request, logGetData: true);
}
//Check for payer IP addresses
string remoteServerIpAddress = request.ServerVariables["REMOTE_ADDR"];
if (remoteServerIpAddress == "217.151.207.84" || remoteServerIpAddress == "79.136.103.5" || remoteServerIpAddress == "79.136.103.9" || remoteServerIpAddress == "94.140.57.180" || remoteServerIpAddress == "94.140.57.181" || remoteServerIpAddress == "94.140.57.184" || remoteServerIpAddress == "192.168.100.1")
{
string url = request.Url.Scheme + "://" + request.Url.Host + request.ServerVariables["REQUEST_URI"];
string urlExceptMd5Sum = url.Substring(0, url.IndexOf("&md5sum", StringComparison.Ordinal));
string md5CheckValue = GenerateMD5Hash(settings["md5Key1"] + urlExceptMd5Sum + settings["md5Key2"]).ToUpperInvariant();
if (md5CheckValue == request.QueryString["md5sum"])
{
HttpContext.Current.Response.Output.Write("TRUE");
string transaction = request.QueryString["payread_payment_id"];
string paymentType = request.QueryString["payer_payment_type"];
string callbackType = request.QueryString["payer_callback_type"];
PaymentState paymentState = callbackType == "auth" ? PaymentState.Authorized : PaymentState.Captured;
callbackInfo = new CallbackInfo(order.TotalPrice.Value.WithVat, transaction, paymentState, paymentType);
}
else
{
LoggingService.Instance.Warn <Payer>("Payer(" + order.CartNumber + ") - MD5Sum security check failed");
}
}
else
{
LoggingService.Instance.Warn <Payer>("Payer(" + order.CartNumber + ") - IP security check failed - IP: " + remoteServerIpAddress);
}
HttpContext.Current.Response.Output.Write("FALSE");
}
catch (Exception exp)
{
LoggingService.Instance.Error <Payer>("QuickPay(" + order.CartNumber + ") - Process callback", exp);
}
return(callbackInfo);
}
public bool DoCallback(NameValueCollection query, NameValueCollection form, string bodydata, Action <CallbackInfo> action)
{
NameValueCollection Request = new NameValueCollection();
foreach (var key in query.AllKeys)
{
Request[key] = query[key];
}
foreach (var key in form.AllKeys)
{
Request[key] = form[key];
}
string order_id = Request["order_id"];
string pay_state = Request["pay_state"] ?? string.Empty;
string agent_order = Request["agent_order"];
string pay_fee = Request["pay_fee"];
string time = Request["time"];
string remark = Request["remark"];
string additional = Request["additional"];
string attach = Request["attach"];
string sign = Request["sign"] ?? string.Empty;
Hashtable ht = new Hashtable();
ht.Add("order_id", order_id);
ht.Add("pay_state", pay_state);
ht.Add("agent_order", agent_order);
ht.Add("pay_fee", pay_fee);
ht.Add("time", time);
ht.Add("remark", remark);
ht.Add("additional", additional);
ht.Add("attach", attach);
ht.Add("key", this.secret_key);
string md5sign = CreateSign(ht);
var callback = new CallbackInfo();
callback.Status = ResultStatus.Fail;
if (!string.IsNullOrEmpty(agent_order) && pay_state == "10000" && md5sign == sign.ToUpper())
{
callback.Status = ResultStatus.Succ;
callback.OrderNo = agent_order;
callback.AttachData = Base64Helper.Base64Decode(attach);
}
action(callback);
if (callback.Status == ResultStatus.Succ)
{
return(true);
}
return(false);
}
internal bool addCallback <M>(SubscriptionCallbackHelper <M> helper, string md5sum, CallbackQueueInterface queue,
uint queue_size, bool allow_concurrent_callbacks, string topiclol) where M : IRosMessage, new()
{
lock (md5sum_mutex)
{
if (this.md5sum == "*" && md5sum != "*")
{
this.md5sum = md5sum;
}
}
if (md5sum != "*" && md5sum != this.md5sum)
{
return(false);
}
lock (callbacks_mutex)
{
CallbackInfo <M> info = new CallbackInfo <M> {
helper = helper, callback = queue, subscription_queue = new Callback <M>(helper.callback().func, topiclol, queue_size, allow_concurrent_callbacks)
};
//if (!helper.isConst())
//{
++nonconst_callbacks;
//}
callbacks.Add(info);
if (latched_messages.Count > 0)
{
lock (publisher_links_mutex)
{
foreach (PublisherLink link in publisher_links)
{
if (link.Latched)
{
if (latched_messages.ContainsKey(link))
{
LatchInfo latch_info = latched_messages[link];
IMessageDeserializer des = new IMessageDeserializer(helper, latch_info.message,
latch_info.connection_header);
bool was_full = false;
((Callback <M>)info.subscription_queue).push((SubscriptionCallbackHelper <M>)info.helper, (MessageDeserializer <M>)des, true,
ref was_full,
latch_info.receipt_time);
((Callback <M>)info.subscription_queue).topic = topiclol;
if (!was_full)
{
info.callback.addCallback(info.subscription_queue, info.Get());
}
}
}
}
}
}
}
return(true);
}
protected override void InitCallbacks ()
{
ArrayList maps = _typeMap.RelatedMaps;
if (maps != null)
{
foreach (XmlTypeMapping map in maps) {
CallbackInfo info = new CallbackInfo (this, map);
if (map.TypeData.SchemaType == SchemaTypes.Enum) AddWriteCallback(map.TypeData.Type, map.XmlType, map.Namespace, new XmlSerializationWriteCallback (info.WriteEnum));
else AddWriteCallback(map.TypeData.Type, map.XmlType, map.Namespace, new XmlSerializationWriteCallback (info.WriteObject));
}
}
}
private static void ApiRequest(string uri, Action<string> callback)
{
AsyncCallback requestCallback = new AsyncCallback(ProcessApiResult);
HttpWebRequest request = WebRequest.Create(uri) as HttpWebRequest;
CallbackInfo info = new CallbackInfo();
info.request = request;
info.callback = callback;
request.UserAgent = @"http://theasuro.de Maintainer: Till W [email protected]";
request.BeginGetResponse(requestCallback, info);
}
public override void RegisterKeyNotification(string key, CallbackInfo updateCallback, CallbackInfo removeCallback, OperationContext operationContext)
{
Sync.AcquireWriterLock(Timeout.Infinite);
try
{
Internal.RegisterKeyNotification(key, updateCallback, removeCallback, operationContext);
if (_context.CacheImpl.RequiresReplication)
{
string uniqueKey = System.Guid.NewGuid().ToString() + key;
#if !CLIENT
_context.CacheImpl.EnqueueForReplication(null, (int)ClusterCacheBase.OpCodes.RegisterKeyNotification, new object[] { key, updateCallback, removeCallback, operationContext });
#endif
}
}
finally
{
Sync.ReleaseWriterLock();
}
}
public override CallbackInfo ProcessCallback( Order order, HttpRequest request, IDictionary<string, string> settings )
{
CallbackInfo callbackInfo = null;
try {
order.MustNotBeNull( "order" );
request.MustNotBeNull( "request" );
settings.MustNotBeNull( "settings" );
settings.MustContainKey( "TRANSACTION.MODE", "settings" );
//Write data when testing
if ( settings[ "TRANSACTION.MODE" ] != "LIVE" ) {
LogRequest( request, logPostData: true );
}
HttpContext.Current.Response.Clear();
if ( request[ "PROCESSING.RESULT" ] == "ACK" ) {
callbackInfo = new CallbackInfo( decimal.Parse( request.Form[ "PRESENTATION.AMOUNT" ], CultureInfo.InvariantCulture ), request.Form[ "IDENTIFICATION.UNIQUEID" ], request.Form[ "PAYMENT.CODE" ] != "CC.DB" ? PaymentState.Authorized : PaymentState.Captured );
string continueUrl = GetContinueUrl( order, settings );
if ( !continueUrl.StartsWith( "http" ) ) {
Uri baseUrl = new UriBuilder( request.Url.Scheme, request.Url.Host, request.Url.Port ).Uri;
continueUrl = new Uri( baseUrl, continueUrl ).AbsoluteUri;
}
HttpContext.Current.Response.Write( continueUrl );
} else {
LoggingService.Instance.Log( "Axcess(" + order.CartNumber + ") - Process callback - PROCESSING.CODE: " + request[ "PROCESSING.CODE" ] );
string cancelUrl = GetCancelUrl( order, settings );
if ( !cancelUrl.StartsWith( "http" ) ) {
Uri baseUrl = new UriBuilder( request.Url.Scheme, request.Url.Host, request.Url.Port ).Uri;
cancelUrl = new Uri( baseUrl, cancelUrl ).AbsoluteUri;
}
HttpContext.Current.Response.Write( cancelUrl );
}
} catch ( Exception exp ) {
LoggingService.Instance.Log( exp, "Axcess(" + order.CartNumber + ") - Process callback" );
}
return callbackInfo;
}
public override CallbackInfo ProcessCallback( Order order, HttpRequest request, IDictionary<string, string> settings )
{
CallbackInfo callbackInfo = null;
try {
order.MustNotBeNull( "order" );
request.MustNotBeNull( "request" );
settings.MustNotBeNull( "settings" );
settings.MustContainKey( "mode", "settings" );
settings.MustContainKey( settings[ "mode" ] + "_secret_key", "settings" );
// If in test mode, write out the form data to a text file
if ( settings.ContainsKey( "mode" ) && settings[ "mode" ] == "test" ) {
LogRequest( request, logPostData: true );
}
StripeChargeCreateOptions chargeOptions = new StripeChargeCreateOptions {
AmountInCents = (int)( order.TotalPrice.Value.WithVat * 100 ),
Currency = CurrencyService.Instance.Get( order.StoreId, order.CurrencyId ).IsoCode,
TokenId = request.Form[ "stripeToken" ],
Description = order.CartNumber,
Capture = settings.ContainsKey( "capture" ) && ( settings[ "capture" ].TryParse<bool>() ?? false )
};
StripeChargeService chargeService = new StripeChargeService( settings[ settings[ "mode" ] + "_secret_key" ] );
StripeCharge charge = chargeService.Create( chargeOptions );
if ( charge.AmountInCents != null && charge.Paid != null && charge.Paid.Value ) {
callbackInfo = new CallbackInfo( (decimal)charge.AmountInCents.Value / 100, charge.Id, charge.Captured != null && charge.Captured.Value ? PaymentState.Captured : PaymentState.Authorized );
}
} catch ( StripeException e ) {
// Pass through request fields
string requestFields = string.Join( "", request.Form.AllKeys.Select( k => "<input type=\"hidden\" name=\"" + k + "\" value=\"" + request.Form[ k ] + "\" />" ) );
//Add error details from the exception.
requestFields = requestFields + "<input type=\"hidden\" name=\"TransactionFailed\" value=\"true\" />";
requestFields = requestFields + "<input type=\"hidden\" name=\"FailureReason.chargeId\" value=\"" + e.StripeError.ChargeId + "\" />";
requestFields = requestFields + "<input type=\"hidden\" name=\"FailureReason.Code\" value=\"" + e.StripeError.Code + "\" />";
requestFields = requestFields + "<input type=\"hidden\" name=\"FailureReason.Error\" value=\"" + e.StripeError.Error + "\" />";
requestFields = requestFields + "<input type=\"hidden\" name=\"FailureReason.ErrorSubscription\" value=\"" + e.StripeError.ErrorSubscription + "\" />";
requestFields = requestFields + "<input type=\"hidden\" name=\"FailureReason.ErrorType\" value=\"" + e.StripeError.ErrorType + "\" />";
requestFields = requestFields + "<input type=\"hidden\" name=\"FailureReason.Message\" value=\"" + e.StripeError.Message + "\" />";
requestFields = requestFields + "<input type=\"hidden\" name=\"FailureReason.Parameter\" value=\"" + e.StripeError.Parameter + "\" />";
string paymentForm = PaymentMethodService.Instance.Get( order.StoreId, order.PaymentInformation.PaymentMethodId.Value ).GeneratePaymentForm( order, requestFields );
//Force the form to auto submit
paymentForm += "<script type=\"text/javascript\">document.forms[0].submit();</script>";
//Write out the form
HttpContext.Current.Response.Clear();
HttpContext.Current.Response.Write( paymentForm );
HttpContext.Current.Response.End();
} catch ( Exception exp ) {
LoggingService.Instance.Log( exp, "Stripe(" + order.CartNumber + ") - ProcessCallback" );
}
return callbackInfo;
}
public override void UnregisterKeyNotification(string[] keys, CallbackInfo updateCallback, CallbackInfo removeCallback, OperationContext operationContext)
{
if (keys != null)
{
foreach (string key in keys)
UnregisterKeyNotification(key, updateCallback, removeCallback, operationContext);
}
}
public override CallbackInfo ProcessCallback( Order order, HttpRequest request, IDictionary<string, string> settings )
{
CallbackInfo callbackInfo = null;
try {
order.MustNotBeNull( "order" );
request.MustNotBeNull( "request" );
settings.MustNotBeNull( "settings" );
settings.MustContainKey( "SHAOUTPASSPHRASE", "settings" );
//Write data when testing
if ( settings.ContainsKey( "TESTMODE" ) && settings[ "TESTMODE" ] == "1" ) {
LogRequest<Ogone>( request, logGetData: true );
}
Dictionary<string, string> inputFields = new Dictionary<string, string>();
string shaSign = request.QueryString[ "SHASIGN" ];
string strAmount = request.QueryString[ "AMOUNT" ];
string transaction = request.QueryString[ "PAYID" ];
string status = request.QueryString[ "STATUS" ];
string cardType = request.QueryString[ "BRAND" ];
string cardNo = request.QueryString[ "CARDNO" ];
foreach ( string key in request.QueryString.Keys ) {
if ( !key.Equals( "SHASIGN" ) )
inputFields[ key ] = request.QueryString[ key ];
}
string strToHash = string.Join( "", inputFields.OrderBy( i => i.Key ).Select( i => i.Key.ToUpperInvariant() + "=" + i.Value + settings[ "SHAOUTPASSPHRASE" ] ) );
string digest = new SHA512Managed().ComputeHash( Encoding.UTF8.GetBytes( strToHash ) ).ToHex().ToUpperInvariant();
if ( order.CartNumber == request.QueryString[ "ORDERID" ] && digest.Equals( shaSign ) ) {
callbackInfo = new CallbackInfo( decimal.Parse( strAmount, CultureInfo.InvariantCulture ), transaction, status == "5" || status == "51" ? PaymentState.Authorized : PaymentState.Captured, cardType, cardNo );
} else {
LoggingService.Instance.Warn<Ogone>( "Ogone(" + order.CartNumber + ") - SHASIGN check isn't valid - Calculated digest: " + digest + " - Ogone SHASIGN: " + shaSign );
}
} catch ( Exception exp ) {
LoggingService.Instance.Error<Ogone>( "Ogone(" + order.CartNumber + ") - Process callback", exp );
}
return callbackInfo;
}
public override CallbackInfo ProcessCallback( Order order, HttpRequest request, IDictionary<string, string> settings )
{
CallbackInfo callbackInfo = null;
try {
order.MustNotBeNull( "order" );
request.MustNotBeNull( "request" );
settings.MustNotBeNull( "settings" );
settings.MustContainKey( "md5HashKey", "settings" );
settings.MustContainKey( "x_login", "settings" );
//Write data when testing
if ( settings.ContainsKey( "testing" ) && settings[ "testing" ] == "1" ) {
LogRequest( request, logPostData: true );
}
string responseCode = request.Form[ "x_response_code" ];
if ( responseCode == "1" ) {
string amount = request.Form[ "x_amount" ];
string transaction = request.Form[ "x_trans_id" ];
string gatewayMd5Hash = request.Form[ "x_MD5_Hash" ];
MD5CryptoServiceProvider x = new MD5CryptoServiceProvider();
string calculatedMd5Hash = Regex.Replace( BitConverter.ToString( x.ComputeHash( Encoding.ASCII.GetBytes( settings[ "md5HashKey" ] + settings[ "x_login" ] + transaction + amount ) ) ), "-", string.Empty );
if ( gatewayMd5Hash == calculatedMd5Hash ) {
PaymentState paymentState = PaymentState.Authorized;
if ( request.Form[ "x_type" ] == "auth_capture" ) {
paymentState = PaymentState.Captured;
}
string cardType = request.Form[ "x_card_type" ];
string cardNumber = request.Form[ "x_account_number" ];
callbackInfo = new CallbackInfo( decimal.Parse( amount, CultureInfo.InvariantCulture ), transaction, paymentState, cardType, cardNumber );
} else {
LoggingService.Instance.Log( "Authorize.net(" + order.CartNumber + ") - MD5Sum security check failed - " + gatewayMd5Hash + " - " + calculatedMd5Hash + " - " + settings[ "md5HashKey" ] );
}
} else {
LoggingService.Instance.Log( "Authorize.net(" + order.CartNumber + ") - Payment not approved: " + responseCode );
}
} catch ( Exception exp ) {
LoggingService.Instance.Log( exp, "Authorize.net(" + order.CartNumber + ") - Process callback" );
}
return callbackInfo;
}
public override CallbackInfo ProcessCallback( Order order, HttpRequest request, IDictionary<string, string> settings )
{
CallbackInfo callbackInfo = null;
try {
order.MustNotBeNull( "order" );
request.MustNotBeNull( "request" );
settings.MustNotBeNull( "settings" );
settings.MustContainKey( "md5k1", "settings" );
settings.MustContainKey( "md5k2", "settings" );
//Write data when testing
if ( settings.ContainsKey( "test" ) && settings[ "test" ] == "1" ) {
LogRequest( request, logPostData: true );
}
string transaction = request.Form[ "transact" ];
string currencyCode = request.Form[ "currency" ];
string strAmount = request.Form[ "amount" ];
string authkey = request.Form[ "authkey" ];
string capturenow = request.Form[ "capturenow" ];
string fee = request.Form[ "fee" ] ?? "0"; //Is not always in the return data
string paytype = request.Form[ "paytype" ];
string cardnomask = request.Form[ "cardnomask" ];
decimal totalAmount = ( decimal.Parse( strAmount, CultureInfo.InvariantCulture ) + decimal.Parse( fee, CultureInfo.InvariantCulture ) );
bool autoCaptured = capturenow == "1";
string md5CheckValue = string.Empty;
md5CheckValue += settings[ "md5k1" ];
md5CheckValue += "transact=" + transaction;
md5CheckValue += "&amount=" + totalAmount.ToString( "0", CultureInfo.InvariantCulture );
md5CheckValue += "¤cy=" + currencyCode;
//authkey = MD5(k2 + MD5(k1 + "transact=tt&amount=aa¤cy=cc"))
if ( GenerateMD5Hash( settings[ "md5k2" ] + GenerateMD5Hash( md5CheckValue ) ) == authkey ) {
callbackInfo = new CallbackInfo( totalAmount / 100M, transaction, !autoCaptured ? PaymentState.Authorized : PaymentState.Captured, paytype, cardnomask );
} else {
LoggingService.Instance.Log( "DIBS(" + order.CartNumber + ") - MD5Sum security check failed" );
}
} catch ( Exception exp ) {
LoggingService.Instance.Log( exp, "DIBS(" + order.CartNumber + ") - Process callback" );
}
return callbackInfo;
}
public override CallbackInfo ProcessCallback( Order order, HttpRequest request, IDictionary<string, string> settings )
{
CallbackInfo callbackInfo = null;
try {
order.MustNotBeNull( "order" );
request.MustNotBeNull( "request" );
settings.MustNotBeNull( "settings" );
settings.MustContainKey( "md5CallbackSecret", "settings" );
//Write data when testing
if ( settings.ContainsKey( "testmode" ) && settings[ "testmode" ] == "1" ) {
LogRequest( request, logGetData: true );
}
string cartNumber = request.QueryString[ "orderid" ];
string currency = request.QueryString[ "currency" ];
string amount = request.QueryString[ "amount" ];
string cardType = settings.ContainsKey( "cardtype" ) ? settings[ "cardtype" ] : string.Empty;
string md5CheckValue = GenerateMD5Hash( cartNumber + currency + cardType + amount + settings[ "md5CallbackSecret" ] );
if ( order.CartNumber.Replace( StoreService.Instance.Get( order.StoreId ).OrderSettings.CartNumberPrefix, "" ) == cartNumber && md5CheckValue.Equals( request.QueryString[ "checkmd5callback" ] ) ) {
string transaction = request.QueryString[ "transacknum" ];
string cardtype = request.QueryString[ "cardtype" ];
string cardnomask = request.QueryString[ "cardnomask" ];
decimal totalAmount = decimal.Parse( amount, CultureInfo.InvariantCulture );
//Wannafind cant give us info about auto capturing
callbackInfo = new CallbackInfo( totalAmount / 100M, transaction, PaymentState.Authorized, cardtype, cardnomask );
} else {
LoggingService.Instance.Log( "Wannafind(" + order.CartNumber + ") - MD5Sum security check failed" );
}
} catch ( Exception exp ) {
LoggingService.Instance.Log( exp, "Wannafind(" + order.CartNumber + ") - Process callback" );
}
return callbackInfo;
}
public override CallbackInfo ProcessCallback( Order order, HttpRequest request, IDictionary<string, string> settings )
{
CallbackInfo callbackInfo = null;
try {
order.MustNotBeNull( "order" );
request.MustNotBeNull( "request" );
settings.MustNotBeNull( "settings" );
settings.MustContainKey( "secretKey", "settings" );
//Write data when testing
if ( settings.ContainsKey( "testMode" ) && settings[ "testMode" ] == "1" ) {
LogRequest<Paynova>( request, logPostData: true );
}
PostbackDigest postbackDigest = new PostbackDigest( settings[ "secretKey" ] );
if ( order.CartNumber == request.Form[ "ORDER_NUMBER" ] && postbackDigest.Validate( request.Form ) ) {
decimal amountAuthorized = decimal.Parse( request.Form[ "PAYMENT_1_AMOUNT" ], CultureInfo.InvariantCulture );
string transaction = request.Form[ "PAYMENT_1_TRANSACTION_ID" ];
string paymentType = request.Form[ "PAYMENT_1_PAYMENT_METHOD_NAME" ];
string paymentIdentifier = request.Form[ "PAYMENT_1_CARD_LAST_FOUR" ];
PaymentState? paymentState = null;
switch ( request.Form[ "PAYMENT_1_STATUS" ] ) {
case "Pending":
paymentState = PaymentState.PendingExternalSystem;
break;
case "Completed":
case "PartiallyCompleted":
paymentState = PaymentState.Captured;
break;
case "Authorized":
paymentState = PaymentState.Authorized;
break;
}
if ( paymentState != null ) {
callbackInfo = new CallbackInfo( amountAuthorized, transaction, paymentState.Value, paymentType, paymentIdentifier );
}
} else {
LoggingService.Instance.Warn<Paynova>( "Paynova(" + order.CartNumber + ") - digest check failed" );
}
} catch ( Exception exp ) {
LoggingService.Instance.Error<Paynova>( "Paynova(" + order.CartNumber + ") - Process callback", exp );
}
return callbackInfo;
}
public override CallbackInfo ProcessCallback( Order order, HttpRequest request, IDictionary<string, string> settings )
{
CallbackInfo callbackInfo = null;
try {
order.MustNotBeNull( "order" );
request.MustNotBeNull( "request" );
settings.MustNotBeNull( "settings" );
settings.MustContainKey( "sharedSecret", "settings" );
IConnector connector = Connector.Create( settings[ "sharedSecret" ] );
KlarnaOrder klarnaOrder = new KlarnaOrder( connector, new Uri( order.Properties[ "klarnaLocation" ] ) ) {
ContentType = KlarnaApiRequestContentType
};
klarnaOrder.Fetch();
if ( (string)klarnaOrder.GetValue( "status" ) == "checkout_complete" ) {
//We need to populate the order with the information entered into Klarna.
SaveOrderPropertiesFromKlarnaCallback( order, klarnaOrder );
decimal amount = ( (JObject)klarnaOrder.GetValue( "cart" ) )[ "total_price_including_tax" ].Value<decimal>() / 100M;
string klarnaId = klarnaOrder.GetValue( "id" ).ToString();
callbackInfo = new CallbackInfo( amount, klarnaId, PaymentState.Authorized );
klarnaOrder.Update( new Dictionary<string, object>() { { "status", "created" } } );
} else {
throw new Exception( "Trying to process a callback from Klarna with an order that isn't completed" );
}
} catch ( Exception exp ) {
LoggingService.Instance.Error<Klarna>( "Klarna(" + order.CartNumber + ") - Process callback", exp );
}
return callbackInfo;
}
public override void RegisterKeyNotification(string[] keys, CallbackInfo updateCallback,
CallbackInfo removeCallback, OperationContext operationContext)
{
object[] obj = null;
Hashtable targetNodes = null;
Hashtable result = new Hashtable();
ArrayList totalKeys = new ArrayList(keys);
Address targetNode = null;
string[] currentKeys = null;
targetNodes = GetTargetNodes(totalKeys);
if (targetNodes != null && targetNodes.Count != 0)
{
IDictionaryEnumerator ide = targetNodes.GetEnumerator();
Hashtable keyList = null;
while (ide.MoveNext())
{
targetNode = ide.Key as Address;
keyList = (Hashtable) ide.Value;
if (targetNode != null && keyList != null)
{
currentKeys = new string[keyList.Count];
int j = 0;
foreach (object key in keyList.Keys)
{
int index = totalKeys.IndexOf(key);
if (index != -1)
{
currentKeys[j] = (string) totalKeys[index];
j++;
}
}
try
{
obj = new object[] {currentKeys, updateCallback, removeCallback, operationContext};
if (targetNode.Equals(Cluster.LocalAddress))
{
handleRegisterKeyNotification(obj);
}
else
{
Function fun = new Function((byte) OpCodes.RegisterKeyNotification, obj, false);
object rsp = Cluster.SendMessage(targetNode, fun, GetFirstResponse, false);
}
}
catch (Alachisoft.NGroups.SuspectedException se)
{
if (Context.NCacheLog.IsInfoEnabled)
Context.NCacheLog.Info("PartServerCache.RegisterKeyNotification",
targetNode + " left while Registering notification");
throw se;
}
catch (Alachisoft.NCache.Common.Exceptions.TimeoutException te)
{
if (Context.NCacheLog.IsInfoEnabled)
Context.NCacheLog.Info("PartServerCache.RegisterKeyNotification",
targetNode + " operation timed out");
throw te;
}
catch (Alachisoft.NCache.Caching.Exceptions.StateTransferException se)
{
throw se;
}
}
}
}
}
public override void RegisterKeyNotification(string key, CallbackInfo updateCallback,
CallbackInfo removeCallback, OperationContext operationContext)
{
object[] obj = new object[] {key, updateCallback, removeCallback, operationContext};
Address targetNode = null;
do
{
try
{
targetNode = GetNextNode(key);
if (targetNode.Equals(Cluster.LocalAddress))
{
handleRegisterKeyNotification(obj);
}
else
{
Function fun = new Function((byte) OpCodes.RegisterKeyNotification, obj, false);
object results = Cluster.SendMessage(targetNode, fun, GetFirstResponse, false);
}
break;
}
catch (Alachisoft.NGroups.SuspectedException se)
{
if (Context.NCacheLog.IsInfoEnabled)
Context.NCacheLog.Info("PartServerCache.RegisterKeyNotification",
targetNode + " left while Registering notification");
throw se;
}
catch (Alachisoft.NCache.Common.Exceptions.TimeoutException te)
{
if (Context.NCacheLog.IsInfoEnabled)
Context.NCacheLog.Info("PartServerCache.RegisterKeyNotification",
targetNode + " operation timed out");
throw te;
}
catch (Alachisoft.NCache.Caching.Exceptions.StateTransferException se)
{
_distributionMgr.Wait(key);
}
} while (true);
}
private Timer CreateTimerCallback(CallbackInfo info)
{
DateTime utcNow = DateTime.UtcNow;
TimeSpan dueTime = (info.When > utcNow) ? ((TimeSpan) (info.When - utcNow)) : TimeSpan.Zero;
if (dueTime > fiveMinutes)
{
dueTime = fiveMinutes;
}
return new Timer(this.timerCallback, info.State, dueTime, infinite);
}
protected internal override void Schedule(WaitCallback callback, Guid workflowInstanceId, DateTime whenUtc, Guid timerId)
{
WorkflowTrace.Host.TraceEvent(TraceEventType.Information, 0, "Scheduling work for instance {0} on timer ID {1} in {2}", new object[] { workflowInstanceId, timerId, (TimeSpan) (whenUtc - DateTime.UtcNow) });
if (callback == null)
{
throw new ArgumentNullException("callback");
}
if (timerId == Guid.Empty)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentUICulture, ExecutionStringManager.CantBeEmptyGuid, new object[] { "timerId" }));
}
if (workflowInstanceId == Guid.Empty)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentUICulture, ExecutionStringManager.CantBeEmptyGuid, new object[] { "workflowInstanceId" }));
}
CallbackInfo info = new CallbackInfo(this, callback, workflowInstanceId, whenUtc);
lock (this.timerQueue)
{
this.timerQueue.Enqueue(timerId, info, whenUtc);
}
}
public override void UnregisterKeyNotification(string[] keys, CallbackInfo updateCallback, CallbackInfo removeCallback, OperationContext operationContext)
{
bool mirrorReplication = _context.CacheImpl.RequiresReplication;
Sync.AcquireWriterLock(Timeout.Infinite);
try
{
Internal.UnregisterKeyNotification(keys, updateCallback, removeCallback, operationContext);
if (mirrorReplication)
{
for (int i = 0; i < keys.Length; i++)
{
if (mirrorReplication)
{
string uniqueKey = System.Guid.NewGuid().ToString() + keys[i];
#if !CLIENT
_context.CacheImpl.EnqueueForReplication(null, (int)ClusterCacheBase.OpCodes.UnregisterKeyNotification, new object[] { keys[i], updateCallback, removeCallback, operationContext });
#endif
}
}
}
}
finally
{
Sync.ReleaseWriterLock();
}
}
public override CallbackInfo ProcessCallback( Order order, HttpRequest request, IDictionary<string, string> settings )
{
CallbackInfo callbackInfo = null;
try {
order.MustNotBeNull( "order" );
request.MustNotBeNull( "request" );
settings.MustNotBeNull( "settings" );
settings.MustContainKey( "md5secret", "settings" );
//Write data when testing
if ( settings.ContainsKey( "testmode" ) && settings[ "testmode" ] == "1" ) {
LogRequest( request, logPostData: true );
}
string md5CheckValue = string.Empty;
md5CheckValue += request.Form[ "msgtype" ];
md5CheckValue += request.Form[ "ordernumber" ];
md5CheckValue += request.Form[ "amount" ];
md5CheckValue += request.Form[ "currency" ];
md5CheckValue += request.Form[ "time" ];
md5CheckValue += request.Form[ "state" ];
md5CheckValue += request.Form[ "qpstat" ];
md5CheckValue += request.Form[ "qpstatmsg" ];
md5CheckValue += request.Form[ "chstat" ];
md5CheckValue += request.Form[ "chstatmsg" ];
md5CheckValue += request.Form[ "merchant" ];
md5CheckValue += request.Form[ "merchantemail" ];
md5CheckValue += request.Form[ "transaction" ];
md5CheckValue += request.Form[ "cardtype" ];
md5CheckValue += request.Form[ "cardnumber" ];
md5CheckValue += request.Form[ "cardhash" ];
md5CheckValue += request.Form[ "cardexpire" ];
md5CheckValue += request.Form[ "acquirer" ];
md5CheckValue += request.Form[ "splitpayment" ];
md5CheckValue += request.Form[ "fraudprobability" ];
md5CheckValue += request.Form[ "fraudremarks" ];
md5CheckValue += request.Form[ "fraudreport" ];
md5CheckValue += request.Form[ "fee" ];
md5CheckValue += settings[ "md5secret" ];
string orderName = order.CartNumber;
while ( orderName.Length < 4 )
orderName = "0" + orderName;
if ( orderName == request.Form[ "ordernumber" ] && GenerateMD5Hash( md5CheckValue ) == request.Form[ "md5check" ] ) {
string qpstat = request.Form[ "qpstat" ];
if ( qpstat == "000" ) {
decimal amount = decimal.Parse( request.Form[ "amount" ], CultureInfo.InvariantCulture ) / 100M;
string state = request.Form[ "state" ];
string transaction = request.Form[ "transaction" ];
callbackInfo = new CallbackInfo( amount, transaction, state == "1" ? PaymentState.Authorized : PaymentState.Captured, request.Form[ "cardtype" ], request.Form[ "cardnumber" ] );
} else {
LoggingService.Instance.Log( "Quickpay(" + order.CartNumber + ") - Error making API request - error code: " + qpstat + " | error message: " + request.Form[ "qpstatmsg" ] );
}
} else {
LoggingService.Instance.Log( "QuickPay(" + order.CartNumber + ") - MD5Sum security check failed" );
}
} catch ( Exception exp ) {
LoggingService.Instance.Log( exp, "QuickPay(" + order.CartNumber + ") - Process callback" );
}
return callbackInfo;
}
public override CallbackInfo ProcessCallback( Order order, HttpRequest request, IDictionary<string, string> settings )
{
CallbackInfo callbackInfo = null;
try {
order.MustNotBeNull( "order" );
request.MustNotBeNull( "request" );
settings.MustNotBeNull( "settings" );
//Write data when testing
if ( settings.ContainsKey( "testMode" ) && settings[ "testMode" ] == "1" ) {
LogRequest<ePay>( request, logGetData: true );
}
string transaction = request.QueryString[ "txnid" ];
string strAmount = request.QueryString[ "amount" ];
string hash = request.QueryString[ "hash" ];
string md5CheckValue = string.Empty;
foreach ( string k in request.QueryString.Keys ) {
if ( k != "hash" ) {
md5CheckValue += request.QueryString[ k ];
}
}
if ( settings.ContainsKey( "md5securitykey" ) ) {
md5CheckValue += settings[ "md5securitykey" ];
}
if ( order.CartNumber == request.QueryString[ "orderid" ] && GenerateMD5Hash( md5CheckValue ) == hash ) {
string fee = request.QueryString[ "txnfee" ];
string cardid = request.QueryString[ "paymenttype" ];
string cardnopostfix = request.QueryString[ "cardno" ];
decimal totalAmount = ( decimal.Parse( strAmount, CultureInfo.InvariantCulture ) + decimal.Parse( fee, CultureInfo.InvariantCulture ) );
bool autoCaptured = settings.ContainsKey( "instantcapture" ) && settings[ "instantcapture" ] == "1";
callbackInfo = new CallbackInfo( totalAmount / 100M, transaction, !autoCaptured ? PaymentState.Authorized : PaymentState.Captured, cardid, cardnopostfix );
} else {
LoggingService.Instance.Warn<ePay>( "ePay(" + order.CartNumber + ") - MD5Sum security check failed" );
}
} catch ( Exception exp ) {
LoggingService.Instance.Error<ePay>( "ePay(" + order.CartNumber + ") - Process callback", exp );
}
return callbackInfo;
}
public override CallbackInfo ProcessCallback( Order order, HttpRequest request, IDictionary<string, string> settings )
{
CallbackInfo callbackInfo = null;
try {
order.MustNotBeNull( "order" );
request.MustNotBeNull( "request" );
settings.MustNotBeNull( "settings" );
settings.MustContainKey( "secretWord", "settings" );
//Write data when testing
if ( settings.ContainsKey( "demo" ) && settings[ "demo" ] == "Y" ) {
LogRequest( request, logGetData: true );
}
string accountNumber = request.QueryString[ "sid" ];
string transaction = request.QueryString[ "order_number" ];
string strAmount = request.QueryString[ "total" ];
string key = request.QueryString[ "key" ];
string md5CheckValue = string.Empty;
md5CheckValue += settings[ "secretWord" ];
md5CheckValue += accountNumber;
md5CheckValue += settings.ContainsKey( "demo" ) && settings[ "demo" ] == "Y" ? "1" : transaction;
md5CheckValue += strAmount;
string calculatedMd5 = GenerateMD5Hash( md5CheckValue ).ToUpperInvariant();
if ( calculatedMd5 == key ) {
decimal totalAmount = decimal.Parse( strAmount, CultureInfo.InvariantCulture );
callbackInfo = new CallbackInfo( totalAmount, transaction, PaymentState.Authorized );
} else {
LoggingService.Instance.Log( "2CheckOut(" + order.CartNumber + ") - MD5Sum security check failed - key: " + key + " - calculatedMD5: " + calculatedMd5 );
}
} catch ( Exception exp ) {
LoggingService.Instance.Log( exp, "2CheckOut(" + order.CartNumber + ") - Process callback" );
}
return callbackInfo;
}
internal void SignalEvent(
HardwareComponentEventHandler callback, ElementComponent componenet)
{
// enqueue the info about the callback for later use
CallbackInfo ci = new CallbackInfo();
ci.callback = callback;
ci.component = componenet;
lock (callbacks)
{
if(!callbacks.Contains(ci))
{
callbacks.Enqueue(ci);
}
}
// if asyncCallbacks are enabled, then go ahead and run them
// on this thread - otherwise they wait for a explicit call to
// PumpEvents() by the user (or the run loop)
if (asyncCallbacks)
{
PumpEvents();
}
else
{
// this signals the Run() loop that there are
// events to be run
eventsReady.Set();
}
}
public override CallbackInfo ProcessCallback( Order order, HttpRequest request, IDictionary<string, string> settings )
{
CallbackInfo callbackInfo = null;
if ( request != null && !string.IsNullOrEmpty( request.Form[ "StatusCode" ] ) ) {
//First callback from PaymentSense - server to server callback
HttpContext.Current.Response.Clear();
try {
order.MustNotBeNull( "order" );
settings.MustNotBeNull( "settings" );
//Write data when testing
if ( settings.ContainsKey( "Testing" ) && settings[ "Testing" ] == "1" ) {
LogRequest<PaymentSense>( request, logPostData: true );
}
List<string> keysToHash = new List<string>();
keysToHash.Add( "PreSharedKey" );
keysToHash.Add( "MerchantID" );
keysToHash.Add( "Password" );
keysToHash.Add( "StatusCode" );
keysToHash.Add( "Message" );
keysToHash.Add( "PreviousStatusCode" );
keysToHash.Add( "PreviousMessage" );
keysToHash.Add( "CrossReference" );
if ( !string.IsNullOrEmpty( request.Form[ "AddressNumericCheckResult" ] ) ) keysToHash.Add( "AddressNumericCheckResult" );
if ( !string.IsNullOrEmpty( request.Form[ "PostCodeCheckResult" ] ) ) keysToHash.Add( "PostCodeCheckResult" );
if ( !string.IsNullOrEmpty( request.Form[ "CV2CheckResult" ] ) ) keysToHash.Add( "CV2CheckResult" );
if ( !string.IsNullOrEmpty( request.Form[ "ThreeDSecureCheckResult" ] ) ) keysToHash.Add( "ThreeDSecureCheckResult" );
if ( !string.IsNullOrEmpty( request.Form[ "CardType" ] ) ) keysToHash.Add( "CardType" );
if ( !string.IsNullOrEmpty( request.Form[ "CardClass" ] ) ) keysToHash.Add( "CardClass" );
if ( !string.IsNullOrEmpty( request.Form[ "CardIssuer" ] ) ) keysToHash.Add( "CardIssuer" );
if ( !string.IsNullOrEmpty( request.Form[ "CardIssuerCountryCode" ] ) ) keysToHash.Add( "CardIssuerCountryCode" );
keysToHash.Add( "Amount" );
keysToHash.Add( "CurrencyCode" );
keysToHash.Add( "OrderID" );
keysToHash.Add( "TransactionType" );
keysToHash.Add( "TransactionDateTime" );
keysToHash.Add( "OrderDescription" );
keysToHash.Add( "CustomerName" );
keysToHash.Add( "Address1" );
keysToHash.Add( "Address2" );
keysToHash.Add( "Address3" );
keysToHash.Add( "Address4" );
keysToHash.Add( "City" );
keysToHash.Add( "State" );
keysToHash.Add( "PostCode" );
keysToHash.Add( "CountryCode" );
if ( !string.IsNullOrEmpty( request.Form[ "EmailAddress" ] ) ) keysToHash.Add( "EmailAddress" );
if ( !string.IsNullOrEmpty( request.Form[ "PhoneNumber" ] ) ) keysToHash.Add( "PhoneNumber" );
string hashDigest = CreateHashDigest( keysToHash, settings, request.Form.AllKeys.ToDictionary( k => k, k => request.Form[ k ] ) );
if ( order.CartNumber == request.Form[ "OrderID" ] && hashDigest == request.Form[ "HashDigest" ] ) {
if ( request.Form[ "StatusCode" ] == "0" || ( request.Form[ "StatusCode" ] == "20" && request.Form[ "PreviousStatusCode" ] == "0" ) ) {
callbackInfo = new CallbackInfo( decimal.Parse( request.Form[ "Amount" ], CultureInfo.InvariantCulture ) / 100M, request.Form[ "CrossReference" ], request.Form[ "TransactionType" ] != "SALE" ? PaymentState.Authorized : PaymentState.Captured );
HttpContext.Current.Response.Write( "StatusCode=0" );
} else {
HttpContext.Current.Response.Write( "StatusCode=" + request.Form[ "StatusCode" ] + "&Message=" + request.Form[ "Message" ] );
}
} else {
string message = "PaymentSense(" + order.CartNumber + ") - Digest check failed - calculated: " + hashDigest + " PaymentSense: " + request.Form[ "HashDigest" ];
LoggingService.Instance.Warn<PaymentSense>( message );
HttpContext.Current.Response.Write( "StatusCode=30&Message=" + message );
}
} catch ( Exception exp ) {
string message = "PaymentSense(" + order.CartNumber + ") - Process callback failed";
LoggingService.Instance.Error<PaymentSense>( message, exp );
HttpContext.Current.Response.Write( "StatusCode=30&Message=" + message );
}
} else {
//Second callback from PaymentSense - redirect the user to the continue or cancel url
HttpContext.Current.Response.Redirect( order != null && order.IsFinalized ? GetContinueUrl( order, settings ) : GetCancelUrl( order, settings ) );
}
return callbackInfo;
}
public override CallbackInfo ProcessCallback( Order order, HttpRequest request, IDictionary<string, string> settings )
{
CallbackInfo callbackInfo = null;
try {
order.MustNotBeNull( "order" );
request.MustNotBeNull( "request" );
settings.MustNotBeNull( "settings" );
settings.MustContainKey( "Vendor", "settings" );
//Write data when testing
if ( settings.ContainsKey( "testMode" ) && ( settings[ "testMode" ] == "SIMULATOR" || settings[ "testMode" ] == "TEST" ) ) {
LogRequest( request, logPostData: true );
}
string transaction = request.Form[ "VPSTxId" ];
string status = request.Form[ "Status" ];
string cartNumber = request.Form[ "VendorTxCode" ];
string txAuthNo = request.Form[ "TxAuthNo" ];
string cardType = request.Form[ "CardType" ];
string last4Digits = request.Form[ "Last4Digits" ];
string md5CheckValue = string.Empty;
md5CheckValue += transaction;
md5CheckValue += cartNumber;
md5CheckValue += status;
md5CheckValue += txAuthNo;
md5CheckValue += settings[ "Vendor" ].ToLowerInvariant();
md5CheckValue += HttpUtility.UrlDecode( request.Form[ "AVSCV2" ] );
md5CheckValue += order.Properties[ "securityKey" ];
md5CheckValue += HttpUtility.UrlDecode( request.Form[ "AddressResult" ] );
md5CheckValue += HttpUtility.UrlDecode( request.Form[ "PostCodeResult" ] );
md5CheckValue += HttpUtility.UrlDecode( request.Form[ "CV2Result" ] );
md5CheckValue += request.Form[ "GiftAid" ];
md5CheckValue += request.Form[ "3DSecureStatus" ];
md5CheckValue += request.Form[ "CAVV" ];
md5CheckValue += HttpUtility.UrlDecode( request.Form[ "AddressStatus" ] );
md5CheckValue += HttpUtility.UrlDecode( request.Form[ "PayerStatus" ] );
md5CheckValue += cardType;
md5CheckValue += last4Digits;
string calcedMd5Hash = GenerateMD5Hash( md5CheckValue ).ToUpperInvariant();
string vpsSignature = request.Form[ "VPSSignature" ];
if ( order.CartNumber == cartNumber && calcedMd5Hash == vpsSignature ) {
Dictionary<string, string> inputFields = new Dictionary<string, string>();
if ( status == "OK" || status == "AUTHENTICATED" || status == "REGISTERED" ) {
callbackInfo = new CallbackInfo( order.TotalPrice.Value.WithVat, transaction, request.Form[ "TxType" ] != "PAYMENT" ? PaymentState.Authorized : PaymentState.Captured, cardType, last4Digits );
if ( status == "OK" ) {
order.Properties.AddOrUpdate( new CustomProperty( "txAuthNo", txAuthNo ) { ServerSideOnly = true } );
}
order.Properties.AddOrUpdate( new CustomProperty( "vendorTxCode", cartNumber ) { ServerSideOnly = true } );
order.Save();
inputFields[ "Status" ] = "OK";
inputFields[ "RedirectURL" ] = order.Properties[ "teaCommerceContinueUrl" ];
inputFields[ "StatusDetail" ] = "OK";
} else {
LoggingService.Instance.Log( "Sage Pay(" + order.CartNumber + ") - Error in callback - status: " + status + " | status details: " + request.Form[ "StatusDetail" ] );
if ( status == "ERROR" )
inputFields[ "Status" ] = "INVALID";
else
inputFields[ "Status" ] = "OK";
inputFields[ "RedirectURL" ] = order.Properties[ "teaCommerceCancelUrl" ];
inputFields[ "StatusDetail" ] = "Error: " + status;
}
HttpContext.Current.Response.Clear();
HttpContext.Current.Response.Write( string.Join( Environment.NewLine, inputFields.Select( i => string.Format( "{0}={1}", i.Key, i.Value ) ).ToArray() ) );
} else {
LoggingService.Instance.Log( "Sage Pay(" + order.CartNumber + ") - VPSSignature check isn't valid - Calculated signature: " + calcedMd5Hash + " | SagePay VPSSignature: " + vpsSignature );
}
} catch ( Exception exp ) {
LoggingService.Instance.Log( exp, "Sage Pay(" + order.CartNumber + ") - Process callback" );
}
return callbackInfo;
}
public override CallbackInfo ProcessCallback( Order order, HttpRequest request, IDictionary<string, string> settings )
{
CallbackInfo callbackInfo = null;
try {
order.MustNotBeNull( "order" );
request.MustNotBeNull( "request" );
settings.MustNotBeNull( "settings" );
settings.MustContainKey( "privateKey", "settings" );
string orderName = order.CartNumber;
while ( orderName.Length < 4 )
orderName = "0" + orderName;
string checkSum = request.Headers[ "QuickPay-Checksum-Sha256" ];
byte[] bytes = new byte[ request.InputStream.Length ];
request.InputStream.Read( bytes, 0, bytes.Length );
request.InputStream.Position = 0;
string streamContent = Encoding.ASCII.GetString( bytes );
Result result = JsonConvert.DeserializeObject<Result>( streamContent );
if ( orderName == result.OrderId && GetChecksum( streamContent, settings[ "privateKey" ] ) == checkSum ) {
Operation lastAuthorize = result.Operations.LastOrDefault( o => o.Type == "authorize" );
if ( lastAuthorize != null ) {
if ( lastAuthorize.QpStatusCode == "20000" ) {
decimal amount = decimal.Parse( lastAuthorize.Amount, CultureInfo.InvariantCulture ) / 100M;
callbackInfo = new CallbackInfo( amount, result.Id, PaymentState.Authorized, result.Metadata.Type, result.Metadata.Last4 );
} else {
LoggingService.Instance.Warn<QuickPay10>( "Quickpay10(" + order.CartNumber + ") - Error making API request - error code: " + lastAuthorize.QpStatusCode + " | error message: " + lastAuthorize.QpStatusMsg );
}
} else {
LoggingService.Instance.Warn<QuickPay10>( "QuickPay10(" + order.CartNumber + ") - No authorize found" );
}
} else {
LoggingService.Instance.Warn<QuickPay10>( "QuickPay10(" + order.CartNumber + ") - Checksum security check failed" );
}
} catch ( Exception exp ) {
LoggingService.Instance.Error<QuickPay10>( "QuickPay10(" + order.CartNumber + ") - Process callback", exp );
}
return callbackInfo;
}
/// <summary>
/// Registers either an update or remove callback with an existing item.
/// </summary>
/// <param name="key">for which notificatin is to be registered</param>
/// <param name="updateCallback">ItemUpdate callback to be registered.</param>
/// <param name="removeCallback">ItemRemove callback to be registered.</param>
public override void RegisterKeyNotification(string key, CallbackInfo updateCallback, CallbackInfo removeCallback, OperationContext operationContext)
{
CacheEntry entry = Get(key, operationContext);
if (entry != null)
{
entry.AddCallbackInfo(updateCallback, removeCallback);
}
}
public override CallbackInfo ProcessCallback( Order order, HttpRequest request, IDictionary<string, string> settings )
{
CallbackInfo callbackInfo = null;
try {
order.MustNotBeNull( "order" );
request.MustNotBeNull( "request" );
settings.MustNotBeNull( "settings" );
settings.MustContainKey( "paymentResponsePassword", "settings" );
//Write data when testing
if ( settings.ContainsKey( "testMode" ) && settings[ "testMode" ] == "100" ) {
LogRequest<WorldPay>( request, logPostData: true );
}
string paymentResponsePassword = settings[ "paymentResponsePassword" ];
string callbackPw = request.Form[ "callbackPW" ];
if ( callbackPw == paymentResponsePassword ) {
if ( request.Form[ "transStatus" ] == "Y" ) {
decimal totalAmount = decimal.Parse( request.Form[ "authAmount" ], CultureInfo.InvariantCulture );
string transaction = request.Form[ "transId" ];
PaymentState paymentState = request.Form[ "authMode" ] == "E" ? PaymentState.Authorized : PaymentState.Captured;
string cardtype = request.Form[ "cardtype" ];
callbackInfo = new CallbackInfo( totalAmount, transaction, paymentState, cardtype );
} else {
LoggingService.Instance.Warn<WorldPay>( "WorldPay(" + order.CartNumber + ") - Cancelled transaction" );
}
} else {
LoggingService.Instance.Warn<WorldPay>( "WorldPay(" + order.CartNumber + ") - Payment response password check failed - callbackPW: " + callbackPw + " - paymentResponsePassword: "******"WorldPay(" + order.CartNumber + ") - Process callback", exp );
}
return callbackInfo;
}
/// <summary>
/// Unregisters either an update or remove callback with an existing item.
/// </summary>
/// <param name="key">for which notificatin is to be unregistered</param>
/// <param name="updateCallback">ItemUpdate callback to be unregistered.</param>
/// <param name="removeCallback">ItemRemove callback to be unregistered.</param>
public override void UnregisterKeyNotification(string key, CallbackInfo updateCallback, CallbackInfo removeCallback, OperationContext operationContext)
{
try
{
CacheEntry entry = Get(key, operationContext);
if (entry != null)
{
entry.RemoveCallbackInfo(updateCallback, removeCallback);
}
}
catch (StateTransferException)
{
//ignore state transfer expcetion
}
}
public override void UnregisterKeyNotification(string[] keys, CallbackInfo updateCallback, CallbackInfo removeCallback, OperationContext operationContext)
{
object[] obj = new object[] { keys, updateCallback, removeCallback, operationContext };
if (_cluster.Servers.Count > 1)
{
Function fun = new Function((byte)OpCodes.UnregisterKeyNotification, obj, false);
_cluster.BroadcastToMultiple(_cluster.Servers, fun, GroupRequest.GET_ALL, true);
}
else
handleUnregisterKeyNotification(obj);
}
public override CallbackInfo ProcessCallback( Order order, HttpRequest request, IDictionary<string, string> settings )
{
CallbackInfo callbackInfo = null;
try {
order.MustNotBeNull( "order" );
request.MustNotBeNull( "request" );
settings.MustNotBeNull( "settings" );
settings.MustContainKey( "md5Key1", "settings" );
settings.MustContainKey( "md5Key2", "settings" );
//Write data when testing
if ( settings.ContainsKey( "test_mode" ) && settings[ "test_mode" ] == "true" ) {
LogRequest( request, logGetData: true );
}
//Check for payer IP addresses
string remoteServerIpAddress = request.ServerVariables[ "REMOTE_ADDR" ];
if ( remoteServerIpAddress == "217.151.207.84" || remoteServerIpAddress == "79.136.103.5" || remoteServerIpAddress == "79.136.103.9" || remoteServerIpAddress == "94.140.57.180" || remoteServerIpAddress == "94.140.57.181" || remoteServerIpAddress == "94.140.57.184" || remoteServerIpAddress == "192.168.100.1" ) {
string url = request.Url.Scheme + "://" + request.Url.Host + request.ServerVariables[ "REQUEST_URI" ];
string urlExceptMd5Sum = url.Substring( 0, url.IndexOf( "&md5sum", StringComparison.Ordinal ) );
string md5CheckValue = GenerateMD5Hash( settings[ "md5Key1" ] + urlExceptMd5Sum + settings[ "md5Key2" ] ).ToUpperInvariant();
if ( md5CheckValue == request.QueryString[ "md5sum" ] ) {
HttpContext.Current.Response.Output.Write( "TRUE" );
string transaction = request.QueryString[ "payread_payment_id" ];
string paymentType = request.QueryString[ "payer_payment_type" ];
string callbackType = request.QueryString[ "payer_callback_type" ];
PaymentState paymentState = callbackType == "auth" ? PaymentState.Authorized : PaymentState.Captured;
callbackInfo = new CallbackInfo( order.TotalPrice.Value.WithVat, transaction, paymentState, paymentType );
} else {
LoggingService.Instance.Log( "Payer(" + order.CartNumber + ") - MD5Sum security check failed" );
}
} else {
LoggingService.Instance.Log( "Payer(" + order.CartNumber + ") - IP security check failed - IP: " + remoteServerIpAddress );
}
HttpContext.Current.Response.Output.Write( "FALSE" );
} catch ( Exception exp ) {
LoggingService.Instance.Log( exp, "QuickPay(" + order.CartNumber + ") - Process callback" );
}
return callbackInfo;
}
private Timer CreateTimerCallback(CallbackInfo info)
{
DateTime now = DateTime.UtcNow;
TimeSpan span = (info.When > now) ? info.When - now : TimeSpan.Zero;
if (span > fiveMinutes) // never let more than five minutes go by without checking
span = fiveMinutes;
return new Timer(timerCallback, info.State, span, infinite);
}
