public override void OnNotify(string notification, NotificationArgs args)
{
const string NotificationName = "Cart.Loaded";
var myArgs = args as Dynamicweb.Ecommerce.Notifications.Ecommerce.Cart.LoadedArgs;
if (myArgs?.Cart == null ||
myArgs.Cart.OrderLines.Count <= 0 ||
!EnabledAndActive())
{
return;
}
if (Global.EnableCartCommunication(myArgs.Cart.Complete))
{
// load cart when "Keep cart in context after checkout step" is on
// if order is completed and exported to the ERP no need to update again
if (myArgs.Cart.Complete && (myArgs.Cart.IsExported || !string.IsNullOrEmpty(myArgs.Cart.IntegrationOrderId)))
{
return;
}
OrderHandler.UpdateOrder(myArgs.Cart, LiveIntegrationSubmitType.LiveOrderOrCart);
}
else
{
CheckOrderPrices(myArgs.Cart, NotificationName);
}
}
public GetTotalCostForSupplierTypeForStoreCommand(HashSet <Order> orders, Store store, string supplierType)
{
this.orders = orders;
this.store = store;
this.supplierType = supplierType;
orderHandler = new OrderHandler();
}
/// <summary>
/// Method that gets sorting preference of the user for the order history
/// </summary>
/// <param name="history"></param>
/// <returns></returns>
private List <Orders> GetOrderPreference(List <Orders> history)
{
OrderHandler oh = new OrderHandler();
do
{
Console.WriteLine("How would you like the order history to be ordered?");
Console.WriteLine(" [0] Earliest First (Default) \n [1] Latest First \n [2] Cheapest First \n [3] Most Expensive First ");
string input = Console.ReadLine();
switch (input)
{
case "0":
history = oh.EarliestFirst(history);
return(history);
case "1":
history = oh.LatestFirst(history);
return(history);
case "2":
history = oh.CheapestFirst(history);
return(history);
case "3":
history = oh.MostExpensiveFirst(history);
return(history);
default:
Console.WriteLine("Invalid Input");
Log.Error("Invalid Input");
break;
}
} while (true);
}
private void CustomerCashOrderReport_Load(object sender, EventArgs e)
{
var cashOrders = new OrderHandler().GetOrders();
CustomerOrderBindingSource.DataSource = cashOrders;
reportViewer.RefreshReport();
}
public override void OnNotify(string notification, NotificationArgs args)
{
if (Global.IsIntegrationActive && Connector.IsWebServiceConnectionAvailable())
{
//Used to load the cart and apply the discount after the user logged-in and has not empty cart
var myArgs = (Dynamicweb.Notifications.Standard.User.OnExtranetLoginArgs)args;
var order = Dynamicweb.Ecommerce.Common.Context.Cart;
if (myArgs.User != null)
{
UrlHandler.Instance.ClearCachedUrl();
Dynamicweb.Ecommerce.Integration.ErpResponseCache.ClearAllCaches();
PrepareProductInfoProvider.ClearUserCache();
//check if user has updates
CheckUser(myArgs.User);
}
if (order != null && order.IsCart && EnabledAndActive())
{
if (Global.EnableCartCommunication(order.Complete))
{
OrderHandler.UpdateOrder(order, LiveIntegrationSubmitType.LiveOrderOrCart);
}
else
{
CheckOrderPrices(order, "OnExtranetLogin");
}
}
}
}
public GetTotalCostInWeekForStoreCommand(HashSet <Order> orders, Date date, Store store)
{
this.orders = orders;
this.date = date;
this.store = store;
orderHandler = new OrderHandler();
}
public void Settings(string pageTab)
{
var defaults = Defaults;
NewSupplierMessage newSupplierMessage = new NewSupplierMessage();
if (IsPost)
{
((ARDataBinder)Binder).AutoLoad = AutoLoadBehavior.Always;
BindObjectInstance(defaults, ParamStore.Form, "defaults");
if (IsValid(defaults))
{
newSupplierMessage.CreateEmlFile(defaults);
Notify("Сохранено");
RedirectToUrl(Request.UrlReferrer + pageTab);
}
else
{
ActiveRecordMediator.Evict(defaults);
PropertyBag["Defaults"] = defaults;
PropertyBag["Formaters"] = OrderHandler.Formaters();
PropertyBag["Senders"] = OrderHandler.Senders();
}
}
else
{
PropertyBag["Defaults"] = defaults;
PropertyBag["Formaters"] = OrderHandler.Formaters();
PropertyBag["Senders"] = OrderHandler.Senders();
}
}
public void PhysicalProductProcessorTest()
{
OrderHandler orderHandler = new OrderHandler(ProductType.PhysicalProduct, null);
bool isSuccess = orderHandler.HandleOrder();
Assert.True(isSuccess);
}
public OrdersController(IOrderRepository orderRepo, ILocationRepository locationRepo, ICustomerRepository customerRepo)
{
_orderRepo = orderRepo;
_locationRepo = locationRepo;
_customerRepo = customerRepo;
_orderHandler = new OrderHandler(_locationRepo, _orderRepo);
}
// コンストラクタ
public ObjectPool()
{
// デリゲートキャッシュ
// 複雑な処理でないので今回はラムダ式で手抜きしている
this.procHandler = new OrderHandler <T>((obj, no) =>
{
float elapsedTime = this.advanceTime;
// 新規追加されたものは経過時間0sec.
if (no >= this.orderCount)
{
elapsedTime = 0f;
}
if (!obj.Run(no, elapsedTime))
{
this.Sleep(obj);
return(false);
}
return(true);
});
this.clearHandler = new OrderHandler <T>((obj, no) =>
{
this.Sleep(obj);
return(false);
});
}
public GetTotalCostInWeekForSupplierTypeCommand(HashSet <Order> orders, Date date, string supplierType)
{
this.orders = orders;
this.date = date;
this.supplierType = supplierType;
orderHandler = new OrderHandler();
}
public void SetOrderHandler()
{
Oh = new OrderHandler(prevOrder.CustomerId, prevOrder.LocationId);
var ef = new EfData();
List <Pizza2> pizzas = ef.GetPizza2sForOrder(prevOrder.OrderId);
foreach (var pizza in pizzas)
{
Pizza2 p2 = new Pizza2();
p2.CrustId = pizza.CrustId;
p2.SauceId = pizza.SauceId;
p2.Cheese1 = pizza.Cheese1;
p2.Cheese2 = pizza.Cheese2;
p2.Topping1 = pizza.Topping1;
p2.Topping2 = pizza.Topping2;
p2.Topping3 = pizza.Topping3;
p2.Quantity = pizza.Quantity;
p2.TotalPizzaCost = pizza.TotalPizzaCost;
p2.ModifiedDate = DateTime.Now;
Oh.Pizzas.Add(p2);
Oh.TotalOrderValue += p2.TotalPizzaCost.Value * p2.Quantity;
}
}
public void Audit_formatter_changes()
{
var supplier = DataMother.CreateSupplier();
var oldFormat = OrderHandler.Formaters().First();
var rule = new OrderSendRules {
Supplier = supplier,
Formater = oldFormat,
Sender = OrderHandler.Senders().First()
};
supplier.OrderRules.Add(rule);
Save(supplier);
Flush();
Assert.That(rule.Id, Is.Not.EqualTo(0));
var newFormat = OrderHandler.Formaters().Skip(1).First();
rule.Formater = newFormat;
session.Save(rule);
Flush();
Reopen();
var logs = session.Query <AuditRecord>().Where(l => l.ObjectId == supplier.Id && l.Type == LogObjectType.Supplier).ToList();
Assert.That(logs.Count, Is.GreaterThan(0), "нет ни одного сообщения");
Assert.That(logs[0].Message,
Is.EqualTo(String.Format("$$$Изменено 'Форматер' было '{0}' стало '{1}'", oldFormat.ClassName, newFormat.ClassName)));
}
public void BookProcessorTest()
{
OrderHandler orderHandler = new OrderHandler(ProductType.Book, null);
bool isSuccess = orderHandler.HandleOrder();
Assert.True(isSuccess);
}
private int enAwakeSplit = 0; // 接続されるリスト
#endregion
#region MAIN FUNCTION
/// <summary>
/// 初期化
/// </summary>
public void Initialize()
{
this.pool = new TaskSystem <Collision>(POOL_MAX);
this.players = new TaskSystem <Collision>(POOL_PL_MAX);
this.enemies = new TaskSystem <Collision>(POOL_EN_MAX);
this.plBullets = new TaskSystem <Collision> [COL_SPLIT];
this.enBullets = new TaskSystem <Collision> [COL_SPLIT];
for (int i = 0; i < COL_SPLIT; ++i)
{
this.plBullets[i] = new TaskSystem <Collision>(POOL_PBL_MAX);
this.enBullets[i] = new TaskSystem <Collision>(POOL_EBL_MAX);
}
// 味方検査
this.playerHandler = new OrderHandler <Collision>(this.PlayerOrder);
// 敵検査
this.enemyHandler = new OrderHandler <Collision>(this.EnemyOrder);
// 接触判定
this.scanHandler = new MatchHandler <Collision>(this.ScanOrder);
// 接触処理
this.hitHandler = new OrderHandler <Collision>(this.HitOrder);
// 回収処理
this.detachHandler = new OrderHandler <Collision>(this.DetachOrder);
for (int i = 0; i < POOL_MAX; ++i)
{
this.collisions[i] = new Collision();
this.pool.Attach(this.collisions[i]);
}
#if DEBUG
this.InitializeDebug();
#endif
}
public override void OnNotify(string notification, NotificationArgs args)
{
if (args == null ||
!(args is Dynamicweb.Ecommerce.Notifications.Ecommerce.Cart.CheckoutDoneOrderIsCompleteArgs) ||
!Global.IsIntegrationActive ||
!Connector.IsWebServiceConnectionAvailable())
{
return;
}
var myArgs = (Dynamicweb.Ecommerce.Notifications.Ecommerce.Cart.CheckoutDoneOrderIsCompleteArgs)args;
// context not defined with (Authorize.net) checkout handler
if (Global.IntegrationEnabledFor(myArgs.Order.ShopId) &&
Global.EnableCartCommunication(myArgs.Order.Complete))
{
var result = OrderHandler.UpdateOrder(myArgs.Order, LiveIntegrationSubmitType.LiveOrderOrCart);
// clear cached prices to update stock if order is completed with success
if (result.HasValue && result.Value)
{
base.SetProductInformation(myArgs.Order);
}
}
}
public void CreateOrderTest()
{
var controller = new OrderHandler();
Dictionary <long, int> itemAmount = new Dictionary <long, int>();
itemAmount.Add(5, 3);
var order = new Order()
{
ItemsAmount = itemAmount,
TotalPrice = 25,
UserId = 2
};
var countBefore = controller.GetAllUserOrders(2).Count;
controller.CreateOrder(order);
var countAfter = controller.GetAllUserOrders(2).Count;
Assert.AreEqual(countBefore, countAfter - 1);
}
public void StartBatchJob_WithNullOptions_ThrowsArgumentNullException()
{
BatchManager manager = CreateBatchManager();
OrderHandler handler = CreateOrderHandler();
Assert.Throws <ArgumentNullException>(() => manager.StartBatchJob(handler.HandleBatch, null));
}
public override void OnNotify(string notification, NotificationArgs args)
{
if (args == null ||
!(args is Dynamicweb.Ecommerce.Notifications.Ecommerce.Cart.Line.IncreasedArgs) ||
!EnabledAndActive())
{
return;
}
var myArgs = (Dynamicweb.Ecommerce.Notifications.Ecommerce.Cart.Line.IncreasedArgs)args;
if (!base.CantCheckPrice)
{
SetProductInformation(myArgs.IncreasedLine.Product);
}
if (myArgs.Cart != null)
{
if (Global.EnableCartCommunication(myArgs.Cart.Complete))
{
OrderHandler.UpdateOrder(myArgs.Cart, LiveIntegrationSubmitType.LiveOrderOrCart);
}
else
{
CheckOrderPrices(myArgs.Cart, "Line.Increased");
}
}
}
public PaymentController(FoodTruckContext context, AzureSettings azureSettings) : base(context)
{
_handler = new OrderHandler(context, "system");
_azureSettings = azureSettings;
_settingHandler = new SettingHandler(context);
_squareLocations = new SquareLocationHandler(context, "system").GetAll();
}
private CommandDispatcher CreateCommandDispatcher(IDomainRepository domainRepository, IEnumerable <Action <ICommand> > preExecutionPipe, IEnumerable <Action <object> > postExecutionPipe)
{
var commandDispatcher = new CommandDispatcher(domainRepository, preExecutionPipe, postExecutionPipe);
var customerCommandHandler = new CustomerCommandHandler(domainRepository);
commandDispatcher.RegisterHandler <CreateCustomer>(customerCommandHandler);
commandDispatcher.RegisterHandler <MarkCustomerAsPreferred>(customerCommandHandler);
var productCommandHandler = new ProductCommandHandler(domainRepository);
commandDispatcher.RegisterHandler(productCommandHandler);
var basketCommandHandler = new BasketCommandHandler(domainRepository);
commandDispatcher.RegisterHandler <CreateBasket>(basketCommandHandler);
commandDispatcher.RegisterHandler <AddItemToBasket>(basketCommandHandler);
commandDispatcher.RegisterHandler <ProceedToCheckout>(basketCommandHandler);
commandDispatcher.RegisterHandler <CheckoutBasket>(basketCommandHandler);
commandDispatcher.RegisterHandler <MakePayment>(basketCommandHandler);
var orderCommandHanler = new OrderHandler(domainRepository);
commandDispatcher.RegisterHandler <ApproveOrder>(orderCommandHanler);
commandDispatcher.RegisterHandler <StartShippingProcess>(orderCommandHanler);
commandDispatcher.RegisterHandler <CancelOrder>(orderCommandHanler);
commandDispatcher.RegisterHandler <ShipOrder>(orderCommandHanler);
return(commandDispatcher);
}
/// <summary>
/// 条件に合うタスクに対して指令を行う
/// </summary>
/// <param name="match">条件式</param>
/// <param name="order">指令</param>
public void ParticularOrder(MatchHandler <T> match, OrderHandler <T> order)
{
int no = 0;
Task <T> now = null;
for (Task <T> task = this.top; task != null && this.actCount > 0;)
{
// MEMO: 切断されても良い様に最初にノードを更新する
now = task;
task = task.next;
int ret = match(now.item);
// 中断
if (ret < 0)
{
break;
}
// HIT
if (ret > 0)
{
if (!order(now.item, no))
{
this.Detach(now);
}
}
++no;
}
}
public void Order_Must_Be_Sent_Successfully(
string timeOfDay,
int[] inputDishes,
string outputFoods)
{
var command = new CreateOrderCommand
{
TimeOfDay = timeOfDay
};
var dishes = new List <int>();
foreach (var dish in inputDishes)
{
dishes.Add(dish);
}
command.Dishes = dishes;
var handler = new OrderHandler(
new Repository(
new DishRepository(new DishTypeRepository(), new TimeOfDayRepository()),
new TimeOfDayRepository(),
new DishTypeRepository()));
var result = (CommandResult)handler.Handle(command);
Assert.AreEqual(outputFoods, result.Foods);
}
private void ProcessOrders(OrderCollection ordersToSync)
{
Logger.Log(string.Format("The list of order to run: {0}", string.Join(",", ordersToSync)));
foreach (Order order in ordersToSync)
{
string currentOrderId = order.Id;
try
{
// update custom field (if wanted)
if (UpdateCustomField)
{
var fieldA = order.OrderFieldValues.First(of => of.OrderField.SystemName == FieldA);
var fieldB = order.OrderFieldValues.First(of => of.OrderField.SystemName == FieldB);
fieldA.Value = fieldB.Value;
}
// update order state
if (!string.IsNullOrWhiteSpace(NewState))
{
// check if it's needed to force the change state
if (order.StateId == NewState && ForceStateUpdate)
{
order.StateId = "";
}
order.StateId = NewState;
}
// save changes to fire notifications
order.Save();
// send new notification from batch parameters
SendNotification(order);
Logger.Log(string.Format("Order ID {0} done!", currentOrderId));
}
catch (Exception ex)
{
_processError += string.Format("Error in Update. Order ID = {0}, Exception = {1}", currentOrderId, ex.ToString());
Logger.Log(string.Format("Error in Update. Order ID = {0}, Exception = {1}", currentOrderId, ex.ToString()));
}
finally
{
// save capture changes and try to update ERP
if (Configuration.Global.IntegrationEnabledFor(order.ShopId))
{
bool?result = OrderHandler.UpdateOrder(order, LiveIntegrationSubmitType.ScheduledTask);
if (result.HasValue && !result.Value)
{
_processError += string.Format("Order ID {0} Successfully updated but not updated to the ERP.\n"
, currentOrderId);
}
}
}
}
Logger.Log("All orders done!");
}
public OrderModule(OrderHandler handler)
{
Post("/orders/order-item", async ctx =>
{
await RunWithErrorHandling <OrderItem>(ctx,
async cmd =>
{
var orderId = await handler.Handle(cmd);
ctx.Response.StatusCode = (int)HttpStatusCode.Created;
ctx.Response.Headers.Add("Location", GetLocationHeader(ctx.Request, $"orders/{orderId}"));
await ctx.Response.Negotiate(new { OrderId = orderId });
});
});
Post("/orders/select-responsible-person", async ctx =>
{
await RunWithErrorHandling <SelectResponsiblePerson>(ctx,
async cmd =>
{
await handler.Handle(cmd);
ctx.Response.StatusCode = (int)HttpStatusCode.Accepted;
});
});
Post("/orders/remove-item", ctx => RunWithErrorHandlingAndAccept <RemoveItem>(ctx, handler.Handle));
}
public ActionResult detail(int id)
{
Order o = new OrderHandler().GetOrder(id);
OrderModel om = new OrderModel();
om.Id = o.Id;
om.cellno = o.Cellno;
om.City = o.city.Name;
om.orderdate = o.Orderdate;
om.OrderHolder = o.OrderHolder;
om.totalAmount = o.TotalAmount;
om.status = o.status.Name;
foreach (var od in o.Detail)
{
OrderDetailModel odm = new OrderDetailModel();
odm.Id = od.Id;
odm.Quantity = od.Quantity;
odm.jewelry = od.jewelry.Name;
om.detail.Add(odm);
}
ViewBag.order = om;
UserModel currentUser = (UserModel)Session[WebUtil.CURRENT_USER];
if (currentUser != null)
{
User user = new UserHandler().GetUserById(currentUser.Id);
if (user.IsInRole(WebUtil.ADMIN_ROLE))
{
return(PartialView("~/Views/Shared/_OrderDetailView.cshtml", om));
}
}
return(PartialView("~/Views/Shared/_orderdetailuser.cshtml", om));
}
public void TestIsInvalidEveningOrder()
{
OrderHandler oh = new OrderHandler();
string input = "evening,1,2,2,3,3,4";
Assert.AreEqual(false, oh.ValidateOrder(input));
}
public void TestIsValidMorningOrder()
{
OrderHandler oh = new OrderHandler();
string input = "morning,1,2,3,3";
Assert.AreEqual(true, oh.ValidateOrder(input));
}
/// <summary>
/// Main method in ScheduledTask Addin - is run when scheduled Task is run
/// </summary>
/// <returns></returns>
public override bool Run()
{
SetupLogging();
bool result = false;
string error = string.Empty;
try
{
string sql = string.Format(
@"SELECT top {2} *
FROM EcomOrders
WHERE
OrderComplete = 1
AND OrderDeleted = 0
AND (OrderIntegrationOrderID IS NULL OR OrderIntegrationOrderID = '')
And Isnull (OrderIsExported, 0) = 0
And OrderShopID = {0}
And IsNull (OrderIsRecurringOrderTemplate, 0) = {3}
AND OrderCompletedDate < DATEADD(MINUTE, -{1}, GETDATE())
and OrderStateID {4};"
, string.IsNullOrEmpty(ShopId) ? "OrderShopID" : "'" + ShopId + "'", MinutesCompleted, MaxOrdersToProcess
// recurrent order filter
, ExcludeRecurrent ? "0" : "IsNull (OrderIsRecurringOrderTemplate, 0)"
// order states filter
, string.IsNullOrEmpty(OrderStates) ? " = OrderStateID" : "in ('" + OrderStates.Replace(",", "','") + "')");
OrderCollection ordersToSync = Order.GetOrders(sql, true);
foreach (var order in ordersToSync)
{
if (Global.IntegrationEnabledFor(order.ShopId))
{
OrderHandler.UpdateOrder(order, LiveIntegrationSubmitType.ScheduledTask);
}
}
result = true;
}
catch (Exception e)
{
error = e.Message;
}
finally
{
if (error != "")
{
//Sendmail with error
SendMail(error, MessageType.Error);
}
else
{
//Send mail with success
SendMail(Translate.Translate("Scheduled task completed successfully"));
}
}
WriteTaskResultToLog(result);
return(result);
}
public OrderDetailsWindow(Order order)
{
Order = order;
_orderHandler = new OrderHandler();
_orderPaymentHandler = new OrderPaymentHandler();
Order.OrderPayments = _orderPaymentHandler.GetPayments(order.Id);
InitializeComponent();
}
//
// Constructie
//
private DataAccess()
{
sysLog.Info("DataAccess startup");
publicXmlRpcUrl = ConfigurationManager.AppSettings["PUBLIC_XML_RPC_SERVER"];
privateXmlRpcUrl = ConfigurationManager.AppSettings["PRIVATE_XML_RPC_SERVER"];
publicExchangeHandler = HandlerHelper.getPublicExchangeHandler(publicXmlRpcUrl);
publicIndexHandler = HandlerHelper.getPublicIndexHandler(publicXmlRpcUrl);
publicOrderHandler = HandlerHelper.getPublicOrderHandler(publicXmlRpcUrl);
publicPortfolioHandler = HandlerHelper.getPublicPortfolioHandler(publicXmlRpcUrl);
publicSecurityHandler = HandlerHelper.getPublicSecurityHandler(publicXmlRpcUrl);
publicTransactionHandler = HandlerHelper.getPublicTransactionHandler(publicXmlRpcUrl);
publicUserHandler = HandlerHelper.getPublicUserHandler(publicXmlRpcUrl);
publicPointsTransactionHandler = HandlerHelper.getPublicPointsTransactionHandler(publicXmlRpcUrl);
exchangeCache = new Dictionary<string, IExchange>();
}
public void SetUp()
{
_orderHandler = new OrderHandler();
}
