public List <DTOOrder> GetOrders()
{
var orders = new List <DTOOrder>();
using (_dbCon.Open())
{
string query = "SELECT * FROM [dbi431200].[dbo].[CartItems]";
//using, closes the connection at the end for you.
// ||
// \/
using (SqlCommand command = new SqlCommand(query, _dbCon.connection))
{
var reader = command.ExecuteReader();
while (reader.Read())
{
DTOOrder OrderDTO = new DTOOrder
{
CartID = reader.GetString(0),
DrinkID = reader.GetInt32(1),
Quantity = reader.GetInt32(2),
};
orders.Add(OrderDTO);
}
}
}
return(orders);
}
public CheckResult Check(DTOOrder order,
IList <ListingOrderDTO> orderItems)
{
if (order.Id == 0)
{
throw new ArgumentOutOfRangeException("order.Id", "Should be non zero");
}
if (order.OrderStatus == OrderStatusEnumEx.Pending)
{
throw new ArgumentException("order.OrderStatus", "Not supported status Pending");
}
CheckResult result = new CheckResult()
{
IsSuccess = false
};
var removeSignConfirmationByBuyer = false;
var buyer = _db.Buyers.GetByEmailAsDto(order.BuyerEmail);
if (buyer != null)
{
removeSignConfirmationByBuyer = buyer.RemoveSignConfirmation;
}
result = new CheckResult()
{
IsSuccess = removeSignConfirmationByBuyer
};
return(result);
}
public static void SetReviewedStatus(IUnitOfWork db,
long emailId,
bool newReviewedStatus,
IOrderHistoryService orderHistorySerivce,
string orderNumber,
DateTime when,
long?by)
{
var email = db.Emails.Get(emailId);
var fromReviwedStatus = email.IsReviewed;
email.IsReviewed = newReviewedStatus;
db.Commit();
DTOOrder order = null;
if (!String.IsNullOrEmpty(orderNumber))
{
order = db.Orders.GetByOrderIdAsDto(orderNumber);
}
orderHistorySerivce.AddRecord(order?.Id ?? 0,
OrderHistoryHelper.EmailReviewedStatusChangedKey,
fromReviwedStatus,
email.Id.ToString(),
email.IsReviewed,
null,
by);
}
public CustomerViewModel(DTOOrder blDto)
{
if (blDto == null)
{
return;
}
Id = blDto.Id;
CreateDate = blDto.CreateDate;
CreateDate = blDto.OrderDate;
BuyerName = blDto.BuyerName;
BuyerEmail = blDto.BuyerEmail;
AmazonEmail = blDto.AmazonEmail;
PersonName = blDto.PersonName;
ShippingCountry = blDto.ShippingCountry;
ShippingAddress1 = blDto.ShippingAddress1;
ShippingAddress2 = blDto.ShippingAddress2;
ShippingCity = blDto.ShippingCity;
ShippingState = blDto.ShippingState;
ShippingZip = blDto.ShippingZip;
ShippingZipAddon = blDto.ShippingZipAddon;
ShippingPhone = blDto.ShippingPhone;
}
public void Check()
{
var warningPeriod = DateTime.Now.Subtract(TimeSpan.FromHours(48));
var minDate = DateTime.Now.AddMonths(-3);
var messages = new List <string>();
using (var db = _dbFactory.GetRWDb())
{
var actions = db.SystemActions.GetAllAsDto()
.Where(a => a.Type == (int)SystemActionType.UpdateOnMarketReturnOrder
//&& (a.Status == (int) SystemActionStatus.Fail //NOTE: all statuses, in case some of action isn't process
&& a.Status != (int)SystemActionStatus.Done &&
a.CreateDate <warningPeriod &&
a.CreateDate> minDate)
.ToList();
foreach (var action in actions)
{
var data = JsonConvert.DeserializeObject <ReturnOrderInput>(action.InputData);
DTOOrder order = null;
if (data.OrderId > 0)
{
order = db.Orders.GetAllAsDto().FirstOrDefault(o => o.Id == data.OrderId);
}
if (order == null)
{
order = db.Orders.GetAllAsDto().FirstOrDefault(o => o.OrderId == data.OrderNumber);
}
if (order == null)
{
_log.Info("Unable to find order: orderId=" + data.OrderId + ", orderNumber=" + data.OrderNumber);
continue;
}
var requestedAmount = data.Items.Sum(i => i.RefundItemPrice
+ (data.IncludeShipping ? i.RefundShippingPrice : 0)
- (data.DeductShipping ? i.DeductShippingPrice : 0)
- (data.IsDeductPrepaidLabelCost ? i.DeductPrepaidLabelCost : 0));
messages.Add("Order #: " + order.OrderId
+ ", market: " + MarketHelper.GetMarketName(order.Market, order.MarketplaceId)
+ ", status: " + SystemActionHelper.GetName((SystemActionStatus)action.Status)
+ ", amount: " + requestedAmount
+ ", create date: " + action.CreateDate);
}
}
if (messages.Any())
{
_log.Info(String.Join("\r\n", messages));
_emailService.SendSystemEmailToAdmin("Support Notification: " + Name + " - To Review (" + messages.Count() + ")",
"Unprocessed refunds:<br/>" + String.Join("<br/>", messages));
}
else
{
_emailService.SendSystemEmailToAdmin("Support Notification: " + Name + " - Success", "");
}
}
public static void CreateOrder(DTOOrder dTOOrder)
{
//Validation
if (dTOOrder.Name.Trim().Length == 0)
{
throw new Exception("Name is required.");
}
if (dTOOrder.Address.Trim().Length == 0)
{
throw new Exception("Address is required.");
}
if (dTOOrder.Zip.Trim().Length == 0)
{
throw new Exception("Zip is required.");
}
if (dTOOrder.Phone.Trim().Length == 0)
{
throw new Exception("Phone is required.");
}
dTOOrder.OrderId = Guid.NewGuid();
dTOOrder.TotalCost = PizzaPriceManager.CalculateCost(dTOOrder);
Persistence.OrdersRepository.CreateOrder(dTOOrder);
}
public CheckResult Check(DTOOrder order,
IList <ListingOrderDTO> orderItems)
{
if (order.Id == 0)
{
throw new ArgumentOutOfRangeException("order.Id", "Should be non zero");
}
if (order.OrderStatus == OrderStatusEnumEx.Pending)
{
throw new ArgumentException("order.OrderStatus", "Not supported status Pending");
}
CheckResult result = new CheckResult()
{
IsSuccess = false
};
var serviceType = order.InitialServiceType;
if (ShippingUtils.IsServiceTwoDays(serviceType) ||
ShippingUtils.IsServiceNextDay(serviceType))
{
result = new CheckResult()
{
IsSuccess = true
};
}
return(result);
}
public static void CreateOrder(DTOOrder dtoOrder)
{
var db = new PapaBobsDbEntities();
var order = convertToEntity(dtoOrder);
db.Orders.Add(order);
db.SaveChanges();
}
public static OrderChangeViewModel BuildCreateOrderChange(DTOOrder order)
{
return(new Orders.OrderChangeViewModel()
{
ChangeType = OrderChangeTypes.Create,
ChangeDate = order.CreateDate
});
}
public virtual ActionResult ResetShippings(string orderId)
{
LogI("ResetShippings begin, orderid=" + orderId);
var result = MessageResult.Error("Undefined");
if (!string.IsNullOrEmpty(orderId))
{
var syncInfo = new EmptySyncInformer(LogService, SyncType.Orders);
var rateProviders = ServiceFactory.GetShipmentProviders(LogService,
Time,
DbFactory,
WeightService,
AccessManager.Company.ShipmentProviderInfoList,
null,
null,
null,
null);
DTOOrder dtoOrder = Db.ItemOrderMappings.GetOrderWithItems(WeightService, orderId, unmaskReferenceStyle: false, includeSourceItems: true);
if (dtoOrder != null)
{
dtoOrder.OrderStatus = OrderStatusEnumEx.Unshipped;
var synchronizer = new AmazonOrdersSynchronizer(LogService,
AccessManager.Company,
syncInfo,
rateProviders,
CompanyAddress,
Time,
WeightService,
MessageService);
if (synchronizer.UIUpdate(Db, dtoOrder, true, false, keepCustomShipping: false, switchToMethodId: null))
{
var dbOrder = Db.Orders.Get(dtoOrder.Id);
dbOrder.OrderStatus = OrderStatusEnum.Unshipped.ToString();
dbOrder.UpgradeLevel = null;
Db.Commit();
result = MessageResult.Success("Success updates");
}
}
else
{
result = MessageResult.Error("Not found OrderId: " + orderId);
}
}
else
{
result = MessageResult.Error("OrderId is empty");
}
return(new JsonResult {
Data = result, JsonRequestBehavior = JsonRequestBehavior.AllowGet
});
}
/// <summary>
/// DTOOrder is connected only to one DTOCommand
/// Order can be connected to many DTOCommands
/// Order
/// </summary>
/// <param name="o"></param>
/// <returns></returns>
public static IEnumerable <DTOOrder> OrderToDTOOrders(this IEnumerable <Order> orders)
{
using (var dc = new WMSContext())
{
string destination = "";
int counter = 0;
IEnumerable <string> targets = null;
foreach (Order o in orders)
{
if (o.Destination != destination)
{
targets =
dc.PlaceIds
.Where(prop => prop.ID.StartsWith(o.Destination) && prop.DimensionClass != -1)
.Select(prop => prop.ID)
.ToList();
destination = o.Destination;
if (dc.Parameters.Find($"Counter[{o.Destination}]") == null)
{
dc.Parameters.Add(new Parameter {
Name = $"Counter[{o.Destination}]", Value = Convert.ToString(0)
});
dc.SaveChanges();
}
counter = Convert.ToInt16(dc.Parameters.Find($"Counter[{o.Destination}]").Value);
}
_counterLast = counter;
_destinationLast = destination;
double defQty = dc.SKU_IDs.Find(o.SKU_ID).DefaultQty;
int fullTUs = (int)(o.SKU_Qty / defQty);
double partialQty = o.SKU_Qty - fullTUs * defQty;
for (int i = 0; i < fullTUs; i++)
{
DTOOrder dtoOrder = new DTOOrder(o);
dtoOrder.Destination = targets.ElementAt(counter % targets.Count());
// alternatively
// dtoOrder.Destination = targets.ElementAt((counter / 12) % targets.Count());
dtoOrder.SKU_Qty = defQty;
counter++;
yield return(dtoOrder);
}
if (partialQty > 0)
{
DTOOrder dtoOrder = new DTOOrder(o);
dtoOrder.Destination = targets.ElementAt(counter % targets.Count());
dtoOrder.SKU_Qty = partialQty;
counter++;
yield return(dtoOrder);
}
o.Status = Order.OrderStatus.Active;
dc.Parameters.Find($"Counter[{o.Destination}]").Value = Convert.ToString(counter);
}
dc.SaveChanges();
}
}
private static decimal calculateToppings(DTOOrder order, DTO.PizzaPriceDTO prices)
{
decimal cost = 0.0M;
cost += (order.Sausage) ? prices.SausageCost : 0M;
cost += (order.Pepperoni) ? prices.PepperoniCost : 0M;
cost += (order.Onions) ? prices.OnionsCost : 0M;
cost += (order.GreenPeppers) ? prices.GreenPeppersCost : 0M;
return(cost);
}
protected override void PrepareOrderInfo(DTOOrder marketOrder, IList <ListingOrderDTO> orderItems)
{
if (orderItems.Any(oi => oi.OnMarketTemplateName == AmazonTemplateHelper.OversizeTemplate))
{
if (marketOrder.Market == (int)MarketType.Amazon &&
marketOrder.InitialServiceType == ShippingUtils.StandardServiceName)
{
marketOrder.InitialServiceType = ShippingUtils.ExpeditedServiceName;
}
}
}
public void Create(CartItemModel cartItemModel, string ID)
{
var _dto = new DTOOrder()
{
CartID = ID,
DrinkID = cartItemModel.DrinkID,
Quantity = cartItemModel.Quantity
};
CartItemFactory.orderConnectionHandler.CreateOrder(_dto);
}
public void ProcessResult(CheckResult result,
Order dbOrder,
DTOOrder order,
IList <ListingOrderDTO> orderItems)
{
if (result.IsSuccess)
{
_log.Debug("Enable SignConfirmation by CheckNeedSignConfirmationByServiceType");
dbOrder.IsSignConfirmation = true;
}
}
private static Decimal determineSausage(DTOOrder order, PizzaPrice pizzaprices)
{
if (order.Sausage)
{
return(pizzaprices.SausagePrice);
}
else
{
return(0);
}
}
private static Decimal determineOnions(DTOOrder order, PizzaPrice pizzaprices)
{
if (order.Onions)
{
return(pizzaprices.OnionsPrice);
}
else
{
return(0);
}
}
private static Decimal determinePepperoni(DTOOrder order, PizzaPrice pizzaprices)
{
if (order.Pepperoni)
{
return(pizzaprices.PepperoniPrice);
}
else
{
return(0);
}
}
public JsonResult GetOrderData(DataTableFilter dtFilter, OrderFilter filter)
{
var data = DTOOrder.MapToDTO(new OrderRepository().GetData(dtFilter, filter));
return(Json(new
{
recordsTotal = data.Count,
recordsFiltered = data.Count,
data = data.Data
}, JsonRequestBehavior.AllowGet));
}
private static Decimal determineGreenPeppers(DTOOrder order, PizzaPrice pizzaprices)
{
if (order.GreenPeppers)
{
return(pizzaprices.GreenPeppersPrice);
}
else
{
return(0);
}
}
public void Update(CartItemModel cartItems)
{
var _dto = new DTOOrder()
{
CartID = cartItems.CartID,
DrinkID = cartItems.DrinkID,
Quantity = cartItems.Quantity,
};
CartItemFactory.orderConnectionHandler.UpdateOrder(_dto);
}
private Orders GetOrder(DTOOrder order)
{
return(new Orders {
fio = order.fio,
phoneNumber = order.phoneNumber,
payment = order.payment,
city = order.city,
delivery = order.delivery,
deliveryAddress = order.deliveryAddress,
comment = order.comment
});
}
public CallResult UpdateShipments(DTOOrder order)
{
var baseLog = LogManager.GetLogger("RequestLogger");
var log = new FileLogService(baseLog, null);
var dbFactory = new DbFactory();
var time = new TimeService(dbFactory);
var actionService = new SystemActionService(log, time);
var orderHistory = new OrderHistoryService(log, time, dbFactory);
var dsService = new DropShipperApiService(log, time, dbFactory, actionService, orderHistory);
return(dsService.UpdateShipments(order));
}
public void SaveOrder(DTOOrder _order)
{
Orders order = GetOrder(_order);
orderRepository.CreateEntity(order);
OrdersDetails[] ordersDetails = GetOrdersDetails(_order, order.order_id);
for (int i = 0; i < ordersDetails.Length; i++)
{
ordersDetailsRepository.CreateEntity(ordersDetails[i]);
}
}
/// <summary>
/// Phương thức cập nhật một Order xuống csdl theo id
/// </summary>
/// <returns>true: thêm mới thành công, false: thêm mới thất bại</returns>
public bool UpdateOrder(DTOOrder dtoOrder)
{
try
{
DataExecute.Instance.createSqlCmd("sp_EditOrder" /*Truyen vao storeprocedure*/, new object[9] {
dtoOrder.orderID, dtoOrder.customerID, dtoOrder.staffID, dtoOrder.orderOfDate, dtoOrder.numberOfPeople, dtoOrder.estimate, dtoOrder.deposit, dtoOrder.total, dtoOrder.orderStatus
});
return(DataExecute.Instance.updateData(DataConnection.Instance.m_cmd) > 0);
}
catch (SqlException)
{
throw;
}
}
public void ProcessResult(CheckResult result,
Order dbOrder,
DTOOrder order,
IList <ListingOrderDTO> orderItems)
{
if (result.IsSuccess)
{
_log.Info("Send sign confirmation request order email, orderId=" + order.Id);
var alreadySend = _db.OrderEmailNotifies.IsExist(order.OrderId,
OrderEmailNotifyType.OutputSignConfirmationEmail);
if (alreadySend)
{
return;
}
var emailInfo = new SignConfirmationRequestEmailInfo(_emailService.AddressService,
null,
order.OrderId,
(MarketType)order.Market,
orderItems,
//NOTE: make sense only express or not
ShippingUtils.IsServiceNextDay(order.InitialServiceType) ? ShippingTypeCode.PriorityExpress : ShippingTypeCode.Standard,
order.BuyerName,
order.BuyerEmail);
_emailService.SendEmail(emailInfo, CallSource.Service);
_db.OrderEmailNotifies.Add(new OrderEmailNotify()
{
OrderNumber = order.OrderId,
Reason = "System emailed, request signconfirmation",
Type = (int)OrderEmailNotifyType.OutputSignConfirmationEmail,
CreateDate = _time.GetUtcTime(),
});
_db.OrderComments.Add(new OrderComment()
{
OrderId = order.Id,
Message = "[System] Sign Confirmation email sent",
Type = (int)CommentType.Address,
CreateDate = _time.GetAppNowTime(),
UpdateDate = _time.GetAppNowTime()
});
_db.Commit();
}
}
public static Decimal CalculateTotalCost(DTOOrder order)
{
var db = new PapaBobsPizzaEntities();
var pizzaprices = db.PizzaPrices.FirstOrDefault();
var crust = determineCrust(order, pizzaprices);
var size = determineSize(order, pizzaprices);
var sausage = determineSausage(order, pizzaprices);
var pepperoni = determinePepperoni(order, pizzaprices);
var onions = determineOnions(order, pizzaprices);
var greenPeppers = determineGreenPeppers(order, pizzaprices);
var TotalCost = crust + size + sausage + pepperoni + onions + greenPeppers;
return(TotalCost);
}
public void CreateOrder(DTOOrder O1)
{
using (_dbCon.Open())
{
string query = "INSERT INTO CartItems (CartID, DrinkID, Quantity) VALUES (@CartID, @DrinkID, @Quantity);";
using (SqlCommand command = new SqlCommand(query, _dbCon.connection))
{
command.Parameters.AddWithValue("@CartID", O1.CartID);
command.Parameters.AddWithValue("@DrinkID", O1.DrinkID);
command.Parameters.AddWithValue("@Quantity", O1.Quantity);
command.ExecuteNonQuery();
}
}
}
public void UpdateOrder(DTOOrder UO1)
{
using (_dbCon.Open())
{
string query = "UPDATE CartItems Set DrinkID = @DrinkID, Quantity = @Quantity WHERE CartID = @CartID;";
using (SqlCommand command = new SqlCommand(query, _dbCon.connection))
{
command.Parameters.AddWithValue("@CartID", UO1.CartID);
command.Parameters.AddWithValue("@DrinkID", UO1.DrinkID);
command.Parameters.AddWithValue("@Quantity", UO1.Quantity);
command.ExecuteNonQuery();
}
}
}
private OrdersDetails[] GetOrdersDetails(DTOOrder order, int order_id)
{
OrdersDetails[] result = new OrdersDetails[order.ordersDetails.Length];
for (int i = 0; i < order.ordersDetails.Length; i++)
{
result[i] = new OrdersDetails {
product_id = order.ordersDetails[i].product_id,
price = order.ordersDetails[i].price,
quantity = order.ordersDetails[i].quantity,
order_id = order_id
};
}
return(result);
}
/// <summary>
/// Phương thức cập nhật một Order xuống csdl theo id
/// </summary>
/// <returns>true: thêm mới thành công, false: thêm mới thất bại</returns>
public bool UpdateOrder(DTOOrder dtoOrder)
{
return orderDAO.UpdateOrder(dtoOrder);
}
/// <summary>
/// Phương thức thêm mới một Order vào csdl
/// </summary>
/// <returns>true: thêm mới thành công, false: thêm mới thất bại</returns>
public bool InsertOrder(DTOOrder dtoOrder)
{
return orderDAO.InsertOrder(dtoOrder);
}
