private void Button_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
{
ProcessRequest CMDTable = new ProcessRequest();
DataTable dt = ((MainWindow)Application.Current.MainWindow)._1337;
var IPs = (from row in dt.AsEnumerable()
where row.Field <string>("Building").Contains(cbBuilding.SelectedItem.ToString())
where row.Field <string>("Room") == cbRoom.SelectedItem.ToString()
select row["IP"].ToString()).ToList();
string controllerIP = IPs.ElementAt(0);
ControllerGuc.Connect(controllerIP, 8888);
// check if the controller is UDP
var isUDP = (from row in dt.AsEnumerable()
where row.Field <string>("Building").Contains(cbBuilding.SelectedItem.ToString())
where row.Field <string>("Room") == cbRoom.SelectedItem.ToString()
select row["UDP"]).ToList();
if ((bool)isUDP.ElementAt(0))
{
if (((Button)sender).Content.ToString() == "Zoom In" || ((Button)sender).Content.ToString() == "Zoom Out")
{
ControllerGuc.SendCommand("!REQUEST", CMDTable.ProcessRequests["CameraZoomStop"].ToString());
}
else
{
ControllerGuc.SendCommand("!REQUEST", CMDTable.ProcessRequests["CameraPanTiltStop"].ToString());
}
}
else
{
ControllerGuc.SendHTTPCommand(controllerIP, 8888, CMDTable.ProcessRequests["CameraPanTiltStop"].ToString());
}
}
public async Task <IActionResult> ProcessRequest(ProcessRequest processRequest)
{
ProcessRequest pRequest = new ProcessRequest();
ProcessResponse pResponse = new ProcessResponse();
pRequest.IsPriorityRequest = "No";
using (var httpClient = new HttpClient())
{
try
{
//int id = verify.VerificationId;
StringContent content = new StringContent(JsonConvert.SerializeObject(processRequest), Encoding.UTF8, "application/json");
using (var response = await httpClient.PostAsync("http://localhost:34213/api/Process/ProcessRequest", content))
{
string apiResponse = await response.Content.ReadAsStringAsync();
//ViewBag.Result = "Success";
pResponse = JsonConvert.DeserializeObject <ProcessResponse>(apiResponse);
//ViewBag.Result = "Successfully Registered, Please Login.....THANKYOU";
TempData["pResponse"] = JsonConvert.SerializeObject(pResponse);
}
TempData["RequestId"] = pResponse.RequestId;
TempData["PandD"] = JsonConvert.SerializeObject(pResponse.PackagingAndDeliveryCharge);
//TempData["PandD"] = pResponse.PackagingAndDeliveryCharge;
TempData["Processing"] = JsonConvert.SerializeObject(pResponse.ProcessingCharge);
}
catch (Exception)
{
ViewBag.Message = "Component API not Loaded. Please Try Later.";
return(View());
}
}
return(RedirectToAction("ProcessResponse"));
}
/// <inheritdoc/>
public async Task <ProcessResponse> Execute(ProcessRequest <TState> request, ProcessMiddlewareDelegate next, CancellationToken token)
{
var response = await next();
foreach (var message in response.ProcessMessages
.Where(s => !s.IsPublished)
.Select(s => s.Message))
{
var executionResult = await PublishMessageAsync(message);
if (executionResult.Success)
{
await store.MarkMessageAsPublishedAsync(request.Id, message);
}
}
return(response);
Task <IExecutionResult> PublishMessageAsync(IMessage msg) =>
msg switch
{
ICommand cmd => commandBus.PublishAsync(cmd),
Notification notification => notificationBus.PublishAsync(notification),
_ => throw new ArgumentException($"Invalid message type '{msg.GetType()}'."),
};
}
/// <summary>
/// Processes a request through a callback delegate within a try/catch block. Distinguished Entity Framework exceptions from general exceptions.
/// </summary>
/// <param name="callback">A delegate method to call within the try block</param>
/// <param name="title">Title for the panel</param>
/// <param name="successMessage">Text to display as the message if the callback processes without an exception</param>
public void TryRun(ProcessRequest callback, string title, string successMessage)
{
if (TryCatch(callback))
{
ShowInfo(successMessage, title, STR_TITLE_ICON_success, STR_PANEL_success);
}
}
protected void BtnQuery_Click(object sender, EventArgs e)
{
if (TextXiaoqu.Text != "")
{
ProcessRequest process = new ProcessRequest();
if (process.ProcessSqlStr(this.TextXiaoqu.Text) == false)
{
Page.ClientScript.RegisterStartupScript(GetType(), "", "<script>alert('" + GetTran("000873", "编号有误") + "！');</script>");
return;
}
if (QueryInfo.IsNumberExist(this.TextXiaoqu.Text, DropDownQiShu.ExpectNum) == false)
{
Page.ClientScript.RegisterStartupScript(GetType(), "", "<script>alert('" + GetTran("000710", "编号不存在") + "！');</script>");
return;
}
}
//根据用户的选择组合字符串
string sql = GetSqlString();
if (sql.Trim() != "")
{
//保存标准汇率的ID
Session["currency"] = DropCurrency.SelectedValue;
Session["gaojiSql"] = sql;
Response.Redirect("AdvanceQueryView.aspx?CurGrass=" + DropDownQiShu.ExpectNum);
}
}
/// <inheritdoc />
public async Task <ProcessResponse> Execute(ProcessRequest <TState> request, ProcessMiddlewareDelegate next, CancellationToken token)
{
var response = await next();
var correlationId = request.State is IIntegrationEvent @event
? @event.CorrelationId
: Unified.NewCode();
var processMessages = response.ProcessMessages
.Select(m =>
{
m.Message.CorrelationId = correlationId;
EnrichWithUserId(m.Message, options.ActorId);
EnrichWithRoles(m.Message, "[]");
var principal = new Principal
{
IdentityId = options.ActorId,
UserId = options.ActorId,
IsProcessManager = true,
};
m.Message.Actor = principal.AsActor();
if (m.Message is Command cmd)
{
cmd.Principal = principal;
}
return(new ProcessMessage(m.Message, m.IsPublished));
})
.ToArray();
return(new ProcessResponse(response.Id, processMessages, response.IsPersisted));
}
public CommandContext(ProcessRequest request, StringBuilder text, CommandMatch match, Dictionary <string, string> vars)
{
FromRequest = request;
Text = text;
Match = match;
Vars = vars;
}
public string GetRequest(string json)
{
_log4net.Info("GetRequest() called with json input");
RequestObject = JsonConvert.DeserializeObject <ProcessRequest>(json);
RequestObject = new ProcessRequest
{
Name = RequestObject.Name,
ContactNumber = RequestObject.ContactNumber,
CreditCardNumber = RequestObject.CreditCardNumber,
ComponentType = RequestObject.ComponentType,
ComponentName = RequestObject.ComponentName,
Quantity = RequestObject.Quantity,
IsPriorityRequest = RequestObject.IsPriorityRequest
};
int Processing = ProcessId();
ResponseObject = new ProcessResponse
{
RequestId = Processing,
ProcessingCharge = ProcessingCharge(RequestObject.ComponentType),
PackagingAndDeliveryCharge = PackagingDelivery(RequestObject.ComponentType, RequestObject.Quantity),
DateOfDelivery = DeliveryDate()
};
var ResponseString = JsonConvert.SerializeObject(ResponseObject);
return(ResponseString);
}
public void Consume(ProcessRequest processor)
{
try
{
while (true)
{
var data = m_client.Read();
if (data == null)
{
Console.WriteLine("Read empty data");
CleanupClosedConnection();
break;
}
var envelope = Envelope.Parser.ParseFrom(data);
if (envelope.PayloadCase == Envelope.PayloadOneofCase.Heartbeat)
{
Console.WriteLine("Heartbeat");
Send(envelope);
}
else
{
processor(this, envelope);
}
}
}
catch (Exception e)
{
Console.WriteLine("Read error " + e.Message);
CleanupClosedConnection();
}
}
public void ProcessDocumentResourceNames()
{
moq::Mock <DocumentProcessorService.DocumentProcessorServiceClient> mockGrpcClient = new moq::Mock <DocumentProcessorService.DocumentProcessorServiceClient>(moq::MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
ProcessRequest request = new ProcessRequest
{
ProcessorName = ProcessorName.FromProjectLocationProcessor("[PROJECT]", "[LOCATION]", "[PROCESSOR]"),
};
ProcessResponse expectedResponse = new ProcessResponse
{
Document = new Document(),
#pragma warning disable CS0612
HumanReviewOperation = "human_review_operationb1fb7921",
#pragma warning restore CS0612
HumanReviewStatus = new HumanReviewStatus(),
};
mockGrpcClient.Setup(x => x.ProcessDocument(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
DocumentProcessorServiceClient client = new DocumentProcessorServiceClientImpl(mockGrpcClient.Object, null);
ProcessResponse response = client.ProcessDocument(request.ProcessorName);
xunit::Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
/// <summary>
/// List Active Process Requests
/// </summary>
/// <param name="processRequestResults"></param>
/// <returns></returns>
public static List <ProcessRequest> ListUnfinishedRequests()
{
var statusIn = ProcessRequest.StatusValue.STARTED;
List <ProcessRequest> response = ProcessRequest.List(statusIn);
return(response);
}
private IResponse ExecuteRequest(ClientRequest clientRequest, Executor clientExecutor)
{
if (clientRequest.ViewNumber < this.replicaState.ViewNumber)
{
// Old view
Log.Debug("ExecuteRequest: DROP - old view");
return(null);
}
if (clientRequest.ViewNumber > this.replicaState.ViewNumber)
{
// There's a higher view that I'm not in
this.replicaState.ChangeToInitializationState();
return(null);
}
ProcessRequest runProcessRequestProtocol = this.RunProcessRequestProtocol(clientRequest, clientExecutor);
if (runProcessRequestProtocol == ProcessRequest.DROP)
{
return(null);
}
if (runProcessRequestProtocol == ProcessRequest.LAST_EXECUTION)
{
return(this.replicaState.ClientTable[clientRequest.ClientId].Item2);
}
return(null);
}
public string GetRequest(string json)
{
string ComponentType = ""; int ComponentQuantity = 0;
int Processing = 0;
var RequestObject = JsonConvert.DeserializeObject <ProcessRequest>(json);
RequestObject = new ProcessRequest
{
Name = RequestObject.Name,
ContactNumber = RequestObject.ContactNumber,
CreditCardNumber = RequestObject.CreditCardNumber,
ComponentType = RequestObject.ComponentType,
ComponentName = RequestObject.ComponentName,
Quantity = RequestObject.Quantity,
IsPriorityRequest = RequestObject.IsPriorityRequest
};
ComponentType = RequestObject.ComponentType;
ComponentQuantity = RequestObject.Quantity;
Processing = ProcessId();
DateTime date = DateTime.Now;
ResponseObject = new ProcessResponse
{
RequestId = Processing,
ProcessingCharge = ProcessingCharge(RequestObject.ComponentType),
PackagingAndDeliveryCharge = PackagingDelivery(ComponentType, ComponentQuantity),
DateOfDelivery = date
};
string ResponseString = JsonConvert.SerializeObject(ResponseObject);
return(ResponseString);
}
public ActionResult NewRequest(SourceRequestViewModel model)
{
var principal = (ClaimsIdentity)User.Identity;
string EmpNum = principal.FindFirst(ClaimTypes.SerialNumber).Value;
string FullName = principal.FindFirst(ClaimTypes.GivenName).Value;
string Email = principal.FindFirst(ClaimTypes.Email).Value;
if (ModelState.IsValid)
{
model.INITIATOR_NAME = FullName;
model.INITIATOR_NUMBER = EmpNum;
model.INITIATOR_EMAIL = Email;
ProcessRequest.ProcessNewRequest(model, EmpNum);
return(RedirectToAction("RequestHistory"));
}
else
{
SourceRequestViewModel item = new SourceRequestViewModel();
string _dept = principal.FindFirst(ClaimTypes.UserData).Value;
string _deptCode = principal.FindFirst(ClaimTypes.Actor).Value;
string _branch = principal.FindFirst(ClaimTypes.StateOrProvince).Value;
string _branchCode = principal.FindFirst(ClaimTypes.PostalCode).Value;
item.INITIATING_DEPT = _dept;
item.INITIATING_DEPTCODE = _deptCode;
item.INITIATING_BRANCH = _branch;
item.INITIATING_BRANCHCODE = _branchCode;
ViewBag.ItemCategories = Common.GetMainCategory();
ViewBag.Vendors = GetVendors.GetAllVendors();
ViewBag.Error = "An Error Occurred";
return(View(item));
}
}
public JsonResult PendingSourceReqApproval(SourceRequestViewModel model)
{
//check for request id on the request on the request table
var outcome = ProcessRequest.UpdateSourceRequestApproval(model);
return(Json(outcome, JsonRequestBehavior.AllowGet));
}
private void Worker()
{
WaitHandle[] wait = { _ready, _stop };
while (0 == WaitHandle.WaitAny(wait))
{
if (CrashImmediately)
{
CrashImmediately = false;
throw new AggregateException();
}
HttpListenerContext context;
lock (_queue) {
if (_queue.Count > 0)
{
context = _queue.Dequeue();
}
else
{
_ready.Reset();
continue;
}
}
try {
Logger.Log($"Request received; {context.Request.RemoteEndPoint}", 0);
ProcessRequest?.Invoke(context);
}
catch (Exception e) {
Logger.LogWarning($"Server could not process a request; {e.Message}", 0);
}
}
}
public async Task OnMessageRequest(ProcessRequest processRequest)
{
var msgType = typeof(Message).Assembly.GetType(processRequest.MessageType);
var msg = Convert.ChangeType(processRequest.Message, msgType);
var message = msg as Message;
var settings = new JsonSerializerSettings();
settings.ContractResolver = new CamelCasePropertyNamesContractResolver {
};
string msgAsJson = JsonConvert.SerializeObject(msg, Formatting.Indented, settings);
var mpSender = _marktpartnerRepository.GetMarktpartnerById(processRequest.SenderId);
var mpSystem = _marktpartnerRepository.GetSystemMarktpartner();
using (var handler = new HttpClientHandler {
Credentials = new NetworkCredential(mpSystem.UserName, mpSystem.Password)
})
{
using (HttpClient client = new HttpClient(handler))
{
var result = await client.PostAsync(mpSender.ServiceUrl, new StringContent(msgAsJson)).ConfigureAwait(false);
Console.WriteLine(string.Format("Message {0} to {1}: {2}", message.Id, mpSender.ServiceUrl, result));
}
}
}
private static void BackgroundProcessStarter(object sender)
{
DateTime wkCurrPerth = DateTime.UtcNow.AddHours(8);
try
{
// Process any manually submitted jobs (submitted via MSM or other means)
List <JobRequest> jobs = AnyManualJobsRequired();
if (jobs != null && jobs.Count > 0)
{
foreach (JobRequest job in jobs)
{
ProcessRequest manualProcess = new ProcessRequest();
if (CheckRunManualJob(job))
{
manualProcess.RunManualStep(job.Name, job.RequestData);
}
}
}
}
catch (Exception ex)
{
Logger.Info("Manually submitted jobs terminated abnormally " + ex.Message + ex.StackTrace);
}
}
public StringBuilder Run(CommandContext ctx)
{
var filePath = ctx.SiteConfig.GetSourcePathToFile(ctx.Match.Args.ElementAt(0));
var filetext = Processor.Process(ProcessRequest.FromExistingRequest(ctx,
filePath));
var matches = CommandProcessor.GetRegexMatches(filetext.Text.ToString());
ctx.Text = ctx.Text.Replace(ctx.Match.Match.Value, "");
Func <StringBuilder> final = null;
foreach (var m in matches)
{
var info = CommandProcessor.ParseCommandMatches(m);
if (info.CommandName == "placeholder")
{
final = () =>
{
return(filetext.Text.Replace(m.Value, ctx.Text.ToString()));
};
}
}
return(final());
}
private async Task OnMessage(ProcessRequest processRequest)
{
var rawMessage = processRequest.Message as RawMessage;
if (rawMessage == null)
{
Console.WriteLine("NULL");
}
var msg = JsonConvert.DeserializeObject <Message>(rawMessage.Value);
if (msg.Type == "Invoic")
{
InvoicMessage inovicMsg = null;
if (JsonHelper.IsValid <Bill>(rawMessage.Value))
{
inovicMsg = JsonConvert.DeserializeObject <Bill>(rawMessage.Value);
}
else if (JsonHelper.IsValid <Reversal>(rawMessage.Value))
{
inovicMsg = JsonConvert.DeserializeObject <Reversal>(rawMessage.Value);
}
await StartProcess("InvoicRouter", inovicMsg, processRequest.SenderId);
}
else if (msg.Type == "Customer")
{
var customerMsg = JsonConvert.DeserializeObject <Registration>(rawMessage.Value);
await StartProcess("CustomerRouter", customerMsg, processRequest.SenderId);
}
else
{
throw new NotSupportedException(string.Format("Message type {0} is not supported", msg.Type));
}
}
public async Task <ProcessResponse> ProcessPaymentAsync(ProcessRequest processRequest)
{
var paymentId = Guid.NewGuid().ToString();
var bankRequest = new BankRequest(GetBank(processRequest.CardNo), processRequest.CardNo, processRequest.Amount);
var bankResponse = await _bankIntegration.SendtoAcquirerAsync(bankRequest);
var dbResponse = await _operations.AddPaymentAsync(processRequest, bankResponse, paymentId);
if (!dbResponse.Success)
{
_logger.LogError("Failed to log payment to databse for Payment Id {PaymentId}", paymentId);
}
if (bankResponse.Success)
{
return(new ProcessResponse
{
Success = true,
PaymentId = paymentId
});
}
_logger.LogWarning("Acquirer returned error for Payment Id {PaymentId}", paymentId);
return(new ProcessResponse
{
Success = false,
ErrorMessage = bankResponse.Reason,
Message = "Something went wrong with transaction, please contact card issuer.",
PaymentId = paymentId
});
}
/// <summary>
/// List Active Process Requests
/// </summary>
/// <param name="processRequestResults"></param>
/// <returns></returns>
public static List <ProcessRequest> ListActiveRequests()
{
var statusIn = ProcessRequest.StatusValue.OPEN;
List <ProcessRequest> response = ProcessRequest.List(statusIn);
return(response);
}
public async stt::Task ProcessDocumentRequestObjectAsync()
{
moq::Mock <DocumentProcessorService.DocumentProcessorServiceClient> mockGrpcClient = new moq::Mock <DocumentProcessorService.DocumentProcessorServiceClient>(moq::MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
ProcessRequest request = new ProcessRequest
{
ProcessorName = ProcessorName.FromProjectLocationProcessor("[PROJECT]", "[LOCATION]", "[PROCESSOR]"),
SkipHumanReview = true,
InlineDocument = new Document(),
RawDocument = new RawDocument(),
};
ProcessResponse expectedResponse = new ProcessResponse
{
Document = new Document(),
HumanReviewStatus = new HumanReviewStatus(),
};
mockGrpcClient.Setup(x => x.ProcessDocumentAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <ProcessResponse>(stt::Task.FromResult(expectedResponse), null, null, null, null));
DocumentProcessorServiceClient client = new DocumentProcessorServiceClientImpl(mockGrpcClient.Object, null);
ProcessResponse responseCallSettings = await client.ProcessDocumentAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
xunit::Assert.Same(expectedResponse, responseCallSettings);
ProcessResponse responseCancellationToken = await client.ProcessDocumentAsync(request, st::CancellationToken.None);
xunit::Assert.Same(expectedResponse, responseCancellationToken);
mockGrpcClient.VerifyAll();
}
/// <summary>
/// Processes a request through a delegate within a try/catch block
/// </summary>
/// <param name="Mydelegate">A delegate method called within try/catch block</param>
/// <param name="message"> Message to be displayed if MyDelegate executed without raising an exception</param>
public void TryRun(ProcessRequest Mydelegate, string message)
{
if (TryCatch(Mydelegate))
{
ShowInfo(message, STR_ICON_SUCCESS, STR_ALERT_SUCCESS);
}
}
public ApiResponseStatus ProcessRequest(RequestParam requestParam, string token)
{
var processRequest = new ProcessRequest();
return(processRequest.ProcessWebRequest(requestParam.Url, requestParam.RequestType,
requestParam.RequestBody, requestParam.Parameters, token));
}
public void ProcessDocumentRequestObject()
{
moq::Mock <DocumentProcessorService.DocumentProcessorServiceClient> mockGrpcClient = new moq::Mock <DocumentProcessorService.DocumentProcessorServiceClient>(moq::MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
ProcessRequest request = new ProcessRequest
{
ProcessorName = ProcessorName.FromProjectLocationProcessor("[PROJECT]", "[LOCATION]", "[PROCESSOR]"),
SkipHumanReview = true,
InlineDocument = new Document(),
RawDocument = new RawDocument(),
};
ProcessResponse expectedResponse = new ProcessResponse
{
Document = new Document(),
HumanReviewStatus = new HumanReviewStatus(),
};
mockGrpcClient.Setup(x => x.ProcessDocument(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
DocumentProcessorServiceClient client = new DocumentProcessorServiceClientImpl(mockGrpcClient.Object, null);
ProcessResponse response = client.ProcessDocument(request);
xunit::Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public void Multiple_units_can_move_east_in_parallel()
{
const int repetitions = 1;
var movementProcessor = new MovementProcessor();
INewLocationCalculator newLocationCalculator = NewLocationCalculatorFactory.GetNewLocationCalculator(CompassDirection.East);
var requests = new ProcessRequest[repetitions];
for (int i = 0; i < repetitions; i++)
{
requests[i] = new ProcessRequest(Point2.Empty, 2.0f + i);
}
Stopwatch sw = Stopwatch.StartNew();
ProcessResponse[] response = movementProcessor.Process(requests, newLocationCalculator);
sw.Stop();
Console.WriteLine($"Time taken: {sw.ElapsedMilliseconds} ms");
int cnt = 0;
foreach (ProcessResponse item in response)
{
Assert.AreEqual(1.0f + cnt, item.NewMovementPoints, "NewMovementPoints incorrect.");
cnt++;
}
}
public StringBuilder Run(CommandContext ctx)
{
if (ctx.Vars == null)
{
Console.WriteLine("can't process var for {0}", ctx.Match.Match.Value);
return(ctx.Text);
}
var args = ctx.Match.Args.GetArgs().AsDictionary();
//if we need to pull in vars from another file
if (args.ContainsKey("from"))
{
var newVars = new Dictionary <string, string>();
string fileName = ctx.SiteConfig.GetSourcePathToFile(args["from"]);
var processResult = Processor.Process(ProcessRequest.FromExistingRequest(ctx, fileName));
CommandProcessor.GetCommandMatchesFromText(processResult.Text.ToString())
.Where(i => i.CommandName == "var" || i.CommandName == "val")
.Select(i => i.Args.GetArgs().AsDictionary())
.ForEach(d => d.Keys.ForEach(i => newVars[i] = d[i]));
//add in the cached items vars -- if it was cached
// then they would not be in there
newVars.MixIn(processResult.Vars);
return(GetVal(ctx.Match.Args.ElementAt(0), newVars, ctx.Text, ctx.Match.Match.Value));
}
return(GetVal(ctx.Match.Args.ElementAt(0), ctx.Vars, ctx.Text, ctx.Match.Match.Value));
}
public string PackageDeliver(string ComponentType, int count)
{
string deliveryCharge = "";
ProcessRequest processRequest = new ProcessRequest();
processRequest.ComponentType = ComponentType;
processRequest.Quantity = count;
if (ComponentType == "Integral")
{
int amount = 100;
count = Convert.ToInt32(count);
int delcharge = 200;
deliveryCharge = Convert.ToString((amount * count) + delcharge);
}
if (ComponentType == "Accessory")
{
int amount = 50;
count = Convert.ToInt32(count);
int delcharge = 100;
deliveryCharge = Convert.ToString((amount * count) + delcharge);
}
_context.SaveChanges();
return(deliveryCharge);
}
public static BusinessServiceModel FromRequest(ProcessRequest request, bool shouldUpdate = false)
{
var newComDispatch = new BusinessServiceModel
{
TerminalId = request.ProcessKey.TerminalId,
DataAreaId = request.ProcessKey.DataAreaId,
StoreId = request.ProcessKey.StoreId,
OperationId = Guid.Parse(request.ProcessKey.OperationId),
StaffId = request.StaffId,
OperationType = request.OperationType,
EntityId = request.EntityId,
ElementId = request.ElementId,
TransactionId = request.TransactionId,
Barcode = request.Barcode,
};
if (request.BeginTime != 0)
{
newComDispatch.BeginDateTime = DateTime.FromBinary(request.BeginTime);
}
if (request.EndTime != 0)
{
newComDispatch.EndDateTime = DateTime.FromBinary(request.EndTime);
}
return(newComDispatch);
}
private bool TryCatch(ProcessRequest callback)
{
try
{
callback();
return true;
}
catch (DbEntityValidationException ex)
{
HandleException(ex);
}
catch (Exception ex)
{
HandleException(ex);
}
return false;
}
public void TryRun(ProcessRequest callback, bool suppressFeedback)
{
TryCatch(callback);
MessagePanel.Visible = !suppressFeedback;
}
/// <summary>
/// Adds a route - a specific delegate, a HTTP method and a regular
/// expression to which AbsolutePath have to match to run this delegate
/// </summary>
/// <param name="method">A HTTP method - GET, POST, PUT or DELETE (case sensitive)</param>
/// <param name="pathRegExp">Absolute URI path regular expression to be matched for run</param>
/// <param name="processor">A delegate which will be run if path and method matches</param>
public void AddRoute(string method, string pathRegExp, ProcessRequest processor)
{
switch (method)
{
case "GET":
{
routesGet.Add(pathRegExp, processor);
break;
}
case "POST":
{
routesPost.Add(pathRegExp, processor);
break;
}
case "PUT":
{
routesPut.Add(pathRegExp, processor);
break;
}
case "DELETE":
{
routesDelete.Add(pathRegExp, processor);
break;
}
default:
{
break;
}
}
}
/// <summary>
/// Processes a request through a callback delegate within a try/catch block. Distinguished Entity Framework exceptions from general exceptions.
/// </summary>
/// <param name="callback">A delegate method to call within the try block</param>
/// <param name="title">Title for the panel</param>
/// <param name="successMessage">Text to display as the message if the callback processes without an exception</param>
public void TryRun(ProcessRequest callback, string title, string successMessage)
{
if (TryCatch(callback))
ShowInfo(successMessage, title, STR_TITLE_ICON_success, STR_PANEL_success);
}
/// <summary>
/// Processes a request through a callback delegate within a try/catch block. Distinguished Entity Framework exceptions from general exceptions.
/// </summary>
/// <param name="callback">A delegate method to call within the try block</param>
public void TryRun(ProcessRequest callback)
{
TryCatch(callback);
}
/// <summary>
/// Processes the callback in terms of the HttpRequest and extracts either hidden form fields, or querystring parameters
/// that is returned from the payment provider.
/// Determines the payment status and saves that indication for later, could be in session, in db, or other storage.
/// This information is important and used in the GetPaymentStatus().
/// </summary>
/// <param name="paymentSystem">The payment system.</param>
/// <param name="paymentArgs">The payment args.</param>
public override void ProcessCallback([NotNull] PaymentSystem paymentSystem, [NotNull] PaymentArgs paymentArgs)
{
Assert.ArgumentNotNull(paymentSystem, "paymentSystem");
Assert.ArgumentNotNull(paymentArgs, "paymentArgs");
Assert.IsNotNull(paymentArgs.ShoppingCart, "Shopping cart is null");
this.PaymentStatus = PaymentStatus.Failure;
HttpRequest request = HttpContext.Current.Request;
PaymentSettingsReader configuration = new PaymentSettingsReader(paymentSystem);
ITransactionData transactionDataProvider = Context.Entity.Resolve<ITransactionData>();
string operation = configuration.GetSetting("operation");
string transactionId = request.QueryString["transactionId"];
string responseCode = request.QueryString["responseCode"];
if (string.Compare(responseCode, "OK", StringComparison.OrdinalIgnoreCase) == 0)
{
string merchantId = paymentSystem.Username;
string token = paymentSystem.Password;
string orderNumber = paymentArgs.ShoppingCart.OrderNumber;
decimal amount = paymentArgs.ShoppingCart.Totals.TotalPriceIncVat;
string currency = this.Currency(paymentArgs.ShoppingCart.Currency.Code);
Netaxept client = new Netaxept();
ProcessRequest processRequest = new ProcessRequest
{
Operation = operation,
TransactionId = transactionId
};
try
{
ProcessResponse processResponse = client.Process(merchantId, token, processRequest);
if (string.Compare(processResponse.ResponseCode, "OK", StringComparison.OrdinalIgnoreCase) == 0)
{
this.PaymentStatus = PaymentStatus.Succeeded;
transactionDataProvider.SaveCallBackValues(paymentArgs.ShoppingCart.OrderNumber, this.PaymentStatus.ToString(), transactionId, amount.ToString(), currency, string.Empty, string.Empty, string.Empty, string.Empty);
if (string.Compare(operation, this.ReservableTransactionType, StringComparison.OrdinalIgnoreCase) == 0)
{
ReservationTicket reservationTicket = new ReservationTicket
{
Amount = amount,
AuthorizationCode = processResponse.AuthorizationId,
InvoiceNumber = orderNumber,
TransactionNumber = transactionId
};
transactionDataProvider.SavePersistentValue(reservationTicket.InvoiceNumber, PaymentConstants.ReservationTicket, reservationTicket);
}
}
}
catch (Exception exception)
{
Log.Error(exception.Message, exception, this);
}
}
else if (string.Compare(responseCode, "CANCEL", StringComparison.OrdinalIgnoreCase) == 0)
{
this.PaymentStatus = PaymentStatus.Canceled;
}
if (this.PaymentStatus != PaymentStatus.Succeeded)
{
transactionDataProvider.SavePersistentValue(paymentArgs.ShoppingCart.OrderNumber, TransactionConstants.PaymentStatus, this.PaymentStatus.ToString());
}
}
public void AddRoute(string method, string pathRegExp, ProcessRequest processor)
{
routes.Add(new Route() { Method = method, Uri = pathRegExp, Handler = processor });
}
protected ProcessResponse Process([NotNull] PaymentSystem paymentSystem, [NotNull] ReservationTicket reservationTicket, decimal amount, [NotNull] string operation)
{
Assert.ArgumentNotNull(paymentSystem, "paymentSystem");
Assert.ArgumentNotNull(reservationTicket, "reservationTicket");
Assert.ArgumentNotNull(operation, "operation");
string merchantId = paymentSystem.Username;
string token = paymentSystem.Password;
string transactionId = reservationTicket.TransactionNumber;
string transactionAmount = amount.ToCents();
Netaxept client = new Netaxept();
ProcessRequest processRequest = new ProcessRequest
{
Operation = operation,
TransactionId = transactionId,
TransactionAmount = transactionAmount
};
return client.Process(merchantId, token, processRequest);
}