public OrderValidatorService(
ILogService log,
IDbFactory dbFactory,
IEmailService emailService,
ISettingsService settings,
IOrderHistoryService orderHistory,
ISystemActionService actionService,
IPriceService priceService,
IHtmlScraperService htmlScraper,
IAddressService addressService,
AddressDTO returnAddress,
IShipmentApi stampsRateApi,
ITime time,
CompanyDTO company)
{
_log = log;
_dbFactory = dbFactory;
_time = time;
_emailService = emailService;
_settings = settings;
_orderHistory = orderHistory;
_actionService = actionService;
_priceService = priceService;
_htmlScraper = htmlScraper;
_addressService = addressService;
_returnAddress = returnAddress;
_stampsRateApi = stampsRateApi;
_company = company;
}
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 static void SetIsOversold(IUnitOfWork db,
IOrderHistoryService orderHistorySerivce,
long id,
bool isOversold,
DateTime when,
long?by)
{
var oversoldNotify = db.OrderNotifies.GetAll().FirstOrDefault(n => (n.Type == (int)OrderNotifyType.OversoldItem ||
n.Type == (int)OrderNotifyType.OversoldOnHoldItem) &&
n.OrderId == id);
if (oversoldNotify != null)
{
db.OrderNotifies.Remove(oversoldNotify);
}
else
{
db.OrderNotifies.Add(new OrderNotify()
{
OrderId = id,
Type = (int)OrderNotifyType.OversoldItem,
Message = "Manually from order edit",
Status = 1,
CreateDate = when
});
}
db.Commit();
}
public WooCommerceOrdersSynchronizer(ILogService log,
IMarketApi api,
CompanyDTO company,
ISettingsService settings,
ISyncInformer syncInfo,
IList <IShipmentApi> rateProviders,
IQuantityManager quantityManager,
IEmailService emailService,
IOrderValidatorService validatorService,
IOrderHistoryService orderHistoryService,
ICacheService cacheService,
ISystemActionService systemAction,
ICompanyAddressService companyAddress,
ITime time,
IWeightService weightService,
ISystemMessageService messageService) : base(log,
api,
company,
settings,
syncInfo,
rateProviders,
quantityManager,
emailService,
validatorService,
orderHistoryService,
cacheService,
systemAction,
companyAddress,
time,
weightService,
messageService)
{
}
public ShoppingCartViewModel()
{
Title = "Shopping Cart";
CartTotal = "$0.00";
_orderHistoryService = DependencyService.Get <IOrderHistoryService>();
_shoppingCartService = DependencyService.Get <IShoppingCartService>();
Items = new ObservableCollection <CartItem>();
LoadItemsCommand = new Command(async() => await ExecuteLoadItemsCommand());
}
public UserOrderUpdater(UserOrderApi api,
IOrderHistoryService orderHistory,
ILogService log,
ITime time)
{
_log = log;
_time = time;
_api = api;
_orderHistory = orderHistory;
}
public BatchManager(ILogService log,
ITime time,
IOrderHistoryService orderHistoryService,
IWeightService weightService)
{
_log = log;
_time = time;
_weightService = weightService;
_orderHistoryService = orderHistoryService;
}
public DropShipperApiService(ILogService log,
ITime time,
IDbFactory dbFactory,
ISystemActionService actionService,
IOrderHistoryService orderHistoryService)
{
_log = log;
_time = time;
_dbFactory = dbFactory;
_actionService = actionService;
_orderHistoryService = orderHistoryService;
}
public AddressChecker(
ILogService log,
IDbFactory dbFactory,
IAddressService addressService,
IOrderHistoryService orderHistoryService,
ITime time)
{
_log = log;
_time = time;
_dbFactory = dbFactory;
_addressService = addressService;
_orderHistoryService = orderHistoryService;
}
public static void SetRefundLocked(IUnitOfWork db,
IOrderHistoryService orderHistorySerivce,
long id,
bool onRefundLockedStatus,
DateTime when,
long?by)
{
var order = db.Orders.GetById(id);
orderHistorySerivce.AddRecord(id, OrderHistoryHelper.OnRefundLockedKey, order.IsRefundLocked, onRefundLockedStatus, by);
order.IsRefundLocked = onRefundLockedStatus;
//order.IsRefundLockedDate = when;
db.Commit();
}
public static void SetOnHold(IUnitOfWork db,
IOrderHistoryService orderHistorySerivce,
long id,
bool onHoldStatus,
DateTime when,
long?by)
{
var order = db.Orders.GetById(id);
orderHistorySerivce.AddRecord(id, OrderHistoryHelper.OnHoldKey, order.OnHold, onHoldStatus, by);
order.OnHold = onHoldStatus;
order.OnHoldUpdateDate = when;
db.Commit();
}
public List <MessageString> ProcessApplyResult(ApplyOrderResult applyResult,
IUnitOfWork db,
ILogService log,
ITime time,
IOrderSynchronizer synchronizer,
AddressChecker addressChecker,
IOrderHistoryService orderHistoryService,
IWeightService weightService,
long?by)
{
var results = new List <MessageString>();
if (applyResult.RateRecalcRequested)
{
var dtoOrder = db.ItemOrderMappings.GetOrderWithItems(weightService, OrderId, unmaskReferenceStyle: false, includeSourceItems: true);
try
{
RetryHelper.ActionWithRetries(() => synchronizer.UIUpdate(db,
dtoOrder,
isForceOverride: false,
keepActiveShipping: true,
keepCustomShipping: applyResult.ShipmentProviderChanged ? false : true,
switchToMethodId: null),
log,
2,
300,
RetryModeType.Normal,
true);
orderHistoryService.AddRecord(dtoOrder.Id, OrderHistoryHelper.RecalculateRatesKey, null, true, by);
}
catch (Exception ex)
{
results.Add(MessageString.Error("", "An unexpected error has occurred. Please try again. Detail: " + ex.Message));
}
}
if (applyResult.AddressValidationRequested)
{
addressChecker.UpdateOrderAddressValidationStatus(db, EntityId, null);
}
return(results);
}
public static void CancelOrder(IUnitOfWork db,
ILogService log,
ITime time,
ISystemActionService actionService,
IOrderHistoryService orderHistoryService,
long orderId,
long?by)
{
var dbOrder = db.Orders.Get(orderId);
if (dbOrder != null)
{
var orderItems = db.OrderItemSources.GetWithListingInfo().Where(oi => oi.OrderId == orderId).ToList();
var itemIdList = orderItems.Where(oi => !String.IsNullOrEmpty(oi.SourceMarketId))
.Select(oi => oi.SourceMarketId)
.ToList();
log.Info("Items to cancel: " + String.Join(";", itemIdList));
db.OrderNotifies.Add(new OrderNotify()
{
OrderId = dbOrder.Id,
Type = (int)OrderNotifyType.CancellationRequest,
Status = 1,
Message = "Email cancelation from web page",
CreateDate = time.GetAppNowTime(),
});
db.Commit();
orderHistoryService.AddRecord(dbOrder.Id, OrderHistoryHelper.CancellationRequestKey, null, true, by);
SystemActionHelper.AddCancelationActionSequences(db,
actionService,
dbOrder.Id,
dbOrder.AmazonIdentifier,
String.Join(";", itemIdList),
null,
null,
null,
null,
by,
CancelReasonType.Manually);
}
}
public static MessageResult RemoveFromBatch(IUnitOfWork db,
ILogService log,
ISystemActionService systemAction,
IOrderHistoryService orderHistoryService,
IBatchManager batchManager,
long batchId,
long orderId,
long?by)
{
var batch = db.OrderBatches.GetAsDto(batchId);
var order = db.Orders.GetAll().FirstOrDefault(o => o.Id == orderId);
if (batch.IsClosed && !batchManager.CanBeRemovedFromBatch(order))
{
if (!AccessManager.IsAdmin)
{
return(MessageResult.Error("Batch was closed"));
}
}
if (batch.IsLocked)
{
if (!AccessManager.IsAdmin)
{
return(MessageResult.Error("Batch was locked"));
}
}
if (order != null)
{
var previoudBatchId = order.BatchId;
order.BatchId = null;
batchManager.CheckRemovedOrder(db, log, systemAction, order, null, by);
db.Commit();
orderHistoryService.AddRecord(order.Id, OrderHistoryHelper.AddToBatchKey, previoudBatchId, batch.Name, null, null, by);
return(MessageResult.Success());
}
return(MessageResult.Error("No order"));
}
public static ValueResult <long> AddOrdersToBatch(IUnitOfWork db,
IOrderHistoryService orderHistoryService,
long?batchId,
string orderIds,
DateTime when,
long?by)
{
if (!string.IsNullOrEmpty(orderIds) && batchId.HasValue)
{
var batch = db.OrderBatches.GetAsDto(batchId.Value);
if (batch.IsClosed)
{
if (!AccessManager.IsSuperAdmin)
{
return(ValueResult <long> .Error("Batch was closed", batchId.Value));
}
}
if (batch.IsLocked)
{
if (!AccessManager.IsAdmin)
{
return(ValueResult <long> .Error("Batch was locked", batchId.Value));
}
}
var stringOrderIdList = orderIds.Split(", ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
var orderIdList = stringOrderIdList.Select(long.Parse).ToList();
db.OrderBatches.AddOrdersToBatch(batchId.Value, orderIdList, when, by);
foreach (var orderId in orderIdList)
{
orderHistoryService.AddRecord(orderId, OrderHistoryHelper.AddToBatchKey, null, null, batchId, batch.Name, by);
}
return(ValueResult <long> .Success("Batch was created", batchId.Value));
}
return(ValueResult <long> .Error("Order list is empty"));
}
public LabelBatchService(IDbFactory dbFactory,
ISystemActionService actionService,
ILogService log,
ITime time,
IWeightService weightService,
IServiceFactory serviceFactory,
IEmailService emailService,
IBatchManager batchManager,
IFileMaker pdfMaker,
IAddressService addressService,
IOrderHistoryService orderHistoryService,
string defaultCustomType,
string labelDirectory,
string reserveDirectory,
string templateDirectory,
Config config,
bool isSampleMode)
{
_dbFactory = dbFactory;
_actionService = actionService;
_log = log;
_time = time;
_weightService = weightService;
_serviceFactory = serviceFactory;
_emailService = emailService;
_batchManager = batchManager;
_pdfMaker = pdfMaker;
_addressService = addressService;
_orderHistoryService = orderHistoryService;
_defaultCustomType = defaultCustomType;
_labelDirectory = labelDirectory;
_reserveDirectory = reserveDirectory;
_templateDirectory = templateDirectory;
_config = config;
_isSampleMode = isSampleMode;
}
public MilkOrderViewModel()
{
Title = "Milk Order";
Items = new ObservableCollection <Day>();
LoadItemsCommand = new Command(async() => await ExecuteLoadItemsCommand());
ItemTapped = new Command <Item>(OnItemSelected);
AddItemCommand = new Command(OnAddItem);
_orderCalendarService = DependencyService.Get <IOrderCalendarService>();
_orderHistoryService = DependencyService.Get <IOrderHistoryService>();
Kids = new List <string>();
if (UserProfileService.Instance.CurrentUserProfile.Kids.Count == 0)
{
Kids.Add("My Child");
}
else
{
Kids = UserProfileService.Instance.CurrentUserProfile.Kids;
}
OnPropertyChanged("Kids");
}
public IOrderSynchronizer GetForMarket(IMarketApi api,
ILogService log,
CompanyDTO company,
ISettingsService settings,
ISyncInformer syncInfo,
IList <IShipmentApi> rateProviders,
IQuantityManager quantityManager,
IEmailService emailService,
IOrderValidatorService validatorService,
IOrderHistoryService orderHistoryService,
ICacheService cacheService,
ISystemActionService systemAction,
ICompanyAddressService companyAddress,
ITime time,
IWeightService weightService,
ISystemMessageService messageService)
{
IOrderSynchronizer synchronizer = null;
switch (api.Market)
{
case MarketType.Amazon:
case MarketType.AmazonEU:
case MarketType.AmazonAU:
synchronizer = new AmazonOrdersSynchronizer(log,
api,
company,
settings,
syncInfo,
rateProviders,
quantityManager,
emailService,
validatorService,
orderHistoryService,
cacheService,
systemAction,
companyAddress,
time,
weightService,
messageService);
break;
case MarketType.eBay:
synchronizer = new EBayOrdersSynchronizer(log,
api,
company,
settings,
syncInfo,
rateProviders,
quantityManager,
emailService,
validatorService,
orderHistoryService,
cacheService,
systemAction,
companyAddress,
time,
weightService,
messageService);
break;
case MarketType.Magento:
synchronizer = new MagentoOrdersSynchronizer(log,
api,
company,
settings,
syncInfo,
rateProviders,
quantityManager,
emailService,
validatorService,
orderHistoryService,
cacheService,
systemAction,
companyAddress,
time,
weightService,
messageService);
break;
case MarketType.Groupon:
synchronizer = new GrouponOrdersSynchronizer(log,
api,
company,
settings,
syncInfo,
rateProviders,
quantityManager,
emailService,
validatorService,
orderHistoryService,
cacheService,
systemAction,
companyAddress,
time,
weightService,
messageService);
break;
case MarketType.Shopify:
synchronizer = new ShopifyOrdersSynchronizer(log,
api,
company,
settings,
syncInfo,
rateProviders,
quantityManager,
emailService,
validatorService,
orderHistoryService,
cacheService,
systemAction,
companyAddress,
time,
weightService,
messageService);
break;
case MarketType.WooCommerce:
synchronizer = new WooCommerceOrdersSynchronizer(log,
api,
company,
settings,
syncInfo,
rateProviders,
quantityManager,
emailService,
validatorService,
orderHistoryService,
cacheService,
systemAction,
companyAddress,
time,
weightService,
messageService);
break;
case MarketType.Walmart:
case MarketType.WalmartCA:
synchronizer = new WalmartOrdersSynchronizer(log,
api,
company,
settings,
syncInfo,
rateProviders,
quantityManager,
emailService,
validatorService,
orderHistoryService,
cacheService,
systemAction,
companyAddress,
time,
weightService,
messageService);
break;
case MarketType.Jet:
synchronizer = new JetOrdersSynchronizer(log,
api,
company,
settings,
syncInfo,
rateProviders,
quantityManager,
emailService,
validatorService,
orderHistoryService,
cacheService,
systemAction,
companyAddress,
time,
weightService,
messageService);
break;
case MarketType.DropShipper:
synchronizer = new DSOrdersSynchronizer(log,
api,
company,
settings,
syncInfo,
rateProviders,
quantityManager,
emailService,
validatorService,
orderHistoryService,
cacheService,
systemAction,
companyAddress,
time,
weightService,
messageService);
break;
case MarketType.OverStock:
synchronizer = new SupplierOasisOrdersSynchronizer(log,
api,
company,
settings,
syncInfo,
rateProviders,
quantityManager,
emailService,
validatorService,
orderHistoryService,
cacheService,
systemAction,
companyAddress,
time,
weightService,
messageService);
break;
case MarketType.OfflineOrders:
synchronizer = new UserOrdersSynchronizer(log,
api,
company,
settings,
syncInfo,
rateProviders,
quantityManager,
emailService,
validatorService,
orderHistoryService,
cacheService,
systemAction,
companyAddress,
time,
weightService,
messageService);
break;
default:
throw new NotImplementedException("MarketType not supported=" + api.Market.ToString());
break;
}
return(synchronizer);
}
public OrderHistoryController(IOrderHistoryService services)
{
_services = services;
}
public ApplyOrderResult Apply(ILogService log,
IUnitOfWork db,
IOrderHistoryService orderHistoryService,
IQuantityManager quantityManager,
DateTime when,
long?by)
{
var dbOrder = db.Orders.GetById(EntityId);
var addressChanged = false;
var shipmentProviderChanged = false;
var shouldRecalcRates = dbOrder.IsInsured != IsInsured ||
dbOrder.IsSignConfirmation != IsSignConfirmation;
var manuallyAddress = ComposeAddressDto();
//NOTE: empty when fields was readonly
if (!AddressHelper.IsEmptyManually(manuallyAddress))
{
var originalAddress = dbOrder.GetAddressDto();
addressChanged = AddressHelper.CompareWithManuallyAllFields(originalAddress, manuallyAddress);
shouldRecalcRates = shouldRecalcRates || AddressHelper.CompareWithManuallyBigChanges(originalAddress, manuallyAddress);
if (addressChanged)
{
orderHistoryService.AddRecord(dbOrder.Id, OrderHistoryHelper.ManuallyPersonNameKey, dbOrder.IsManuallyUpdated ? dbOrder.ManuallyPersonName : dbOrder.PersonName, ManuallyPersonName, by);
dbOrder.ManuallyPersonName = ManuallyPersonName;
orderHistoryService.AddRecord(dbOrder.Id, OrderHistoryHelper.ManuallyShippingAddress1Key, dbOrder.IsManuallyUpdated ? dbOrder.ManuallyShippingAddress1 : dbOrder.ShippingAddress1, ManuallyShippingAddress1, by);
dbOrder.ManuallyShippingAddress1 = ManuallyShippingAddress1;
orderHistoryService.AddRecord(dbOrder.Id, OrderHistoryHelper.ManuallyShippingAddress2Key, dbOrder.IsManuallyUpdated ? dbOrder.ManuallyShippingAddress2 : dbOrder.ShippingAddress2, ManuallyShippingAddress2, by);
dbOrder.ManuallyShippingAddress2 = ManuallyShippingAddress2;
orderHistoryService.AddRecord(dbOrder.Id, OrderHistoryHelper.ManuallyShippingCityKey, dbOrder.IsManuallyUpdated ? dbOrder.ManuallyShippingCity : dbOrder.ShippingCity, ManuallyShippingCity, by);
dbOrder.ManuallyShippingCity = ManuallyShippingCity;
orderHistoryService.AddRecord(dbOrder.Id, OrderHistoryHelper.ManuallyShippingCountryKey, dbOrder.IsManuallyUpdated ? dbOrder.ManuallyShippingCountry : dbOrder.ShippingCountry, ManuallyShippingCountry, by);
dbOrder.ManuallyShippingCountry = ManuallyShippingCountry;
dbOrder.ManuallyShippingState = !ShippingUtils.IsInternational(dbOrder.ManuallyShippingCountry)
// == "US"
? ManuallyShippingUSState
: ManuallyShippingState;
orderHistoryService.AddRecord(dbOrder.Id, OrderHistoryHelper.ManuallyShippingZipKey, dbOrder.IsManuallyUpdated ? dbOrder.ManuallyShippingZip : dbOrder.ShippingZip, ManuallyShippingZip, by);
dbOrder.ManuallyShippingZip = StringHelper.TrimWhitespace(ManuallyShippingZip);
orderHistoryService.AddRecord(dbOrder.Id, OrderHistoryHelper.ManuallyShippingZipAddonKey, dbOrder.IsManuallyUpdated ? dbOrder.ManuallyShippingZipAddon : dbOrder.ShippingZipAddon, ManuallyShippingZipAddon, by);
dbOrder.ManuallyShippingZipAddon = StringHelper.TrimWhitespace(ManuallyShippingZipAddon);
orderHistoryService.AddRecord(dbOrder.Id, OrderHistoryHelper.ManuallyShippingPhoneKey, dbOrder.IsManuallyUpdated ? dbOrder.ManuallyShippingPhone : dbOrder.ShippingPhone, ManuallyShippingPhone, by);
dbOrder.ManuallyShippingPhone = ManuallyShippingPhone;
dbOrder.IsManuallyUpdated = true;
}
else
{
dbOrder.ManuallyPersonName = String.Empty;
dbOrder.ManuallyShippingAddress1 = String.Empty;
dbOrder.ManuallyShippingAddress2 = String.Empty;
dbOrder.ManuallyShippingCity = String.Empty;
dbOrder.ManuallyShippingCountry = String.Empty;
dbOrder.ManuallyShippingState = String.Empty;
dbOrder.ManuallyShippingZip = String.Empty;
dbOrder.ManuallyShippingZipAddon = String.Empty;
dbOrder.ManuallyShippingPhone = String.Empty;
dbOrder.IsManuallyUpdated = false;
}
}
dbOrder.InsuredValue = InsuredValue;
orderHistoryService.AddRecord(dbOrder.Id, OrderHistoryHelper.IsInsuredKey, dbOrder.IsInsured, IsInsured, by);
dbOrder.IsInsured = IsInsured;
orderHistoryService.AddRecord(dbOrder.Id, OrderHistoryHelper.IsSignConfirmationKey, dbOrder.IsSignConfirmation, IsSignConfirmation, by);
dbOrder.IsSignConfirmation = IsSignConfirmation;
if (ManuallyShipmentProviderType.HasValue)
{
if (dbOrder.ShipmentProviderType != ManuallyShipmentProviderType.Value)
{
shipmentProviderChanged = true;
shouldRecalcRates = true;
}
orderHistoryService.AddRecord(dbOrder.Id, OrderHistoryHelper.ShipmentProviderTypeKey, dbOrder.ShipmentProviderType, ManuallyShipmentProviderType, by);
dbOrder.ShipmentProviderType = ManuallyShipmentProviderType.Value;
}
//dbOrder.OnHold = OnHold;
dbOrder.UpdateDate = when;
dbOrder.UpdatedBy = by;
if (Items.All(i => i.NewListingId > 0)) //NOTE: only when enabled items edit
{
var changeNotes = "";
var itemSizeWasChanged = false;
var joinItems = JoinItems(Items);
var dbOrderItems = db.OrderItems.GetAll().Where(i => i.OrderId == dbOrder.Id).ToList();
var orderItemSources = db.OrderItemSources.GetAllAsDto().Where(i => i.OrderId == dbOrder.Id).ToList();
foreach (var item in joinItems)
{
var dbOrderItem = dbOrderItems.FirstOrDefault(im => im.ItemOrderIdentifier == item.ItemOrderId);
//NOTE: Get source info for set proprotionally ItemPrice etc.
var sourceItemOrderId = item.SourceItemOrderId;
var sourceItemMapping = orderItemSources.FirstOrDefault(i => i.ItemOrderIdentifier == sourceItemOrderId);
if (dbOrderItem != null)
{
log.Info("Updated orderItemId=" + item.ItemOrderId + ", qty=" + item.Quantity);
}
else
{
log.Info("Added orderItemId=" + item.ItemOrderId + ", qty=" + item.Quantity);
dbOrderItem = db.OrderItemSources.CreateItemFromSourceDto(sourceItemMapping);
dbOrderItem.CreateDate = when;
db.OrderItems.Add(dbOrderItem);
}
dbOrderItem.ItemOrderIdentifier = item.ItemOrderId;
dbOrderItem.QuantityOrdered = item.Quantity;
dbOrderItem.ListingId = item.NewListingId;
dbOrderItem.SourceListingId = sourceItemMapping.ListingId;
dbOrderItem.SourceItemOrderIdentifier = sourceItemMapping.ItemOrderIdentifier;
var newListing = db.Listings.GetViewListingsAsDto(withUnmaskedStyles: false)
.FirstOrDefault(l => l.Id == item.NewListingId);
var keepListingUpdateOnlyStyle = newListing.StyleItemId != dbOrderItem.StyleItemId;
if (dbOrderItem.Id == 0 ||
item.NewListingId != item.ListingId ||
keepListingUpdateOnlyStyle)
{
var oldListing = db.Listings.GetViewListingsAsDto(withUnmaskedStyles: false)
.FirstOrDefault(l => l.Id == sourceItemMapping.ListingId);
if (newListing != null && oldListing != null)
{
itemSizeWasChanged = newListing.StyleItemId != oldListing.StyleItemId;
if (itemSizeWasChanged)
{
var isStyleChanged = newListing.StyleString != oldListing.StyleString;
changeNotes += (isStyleChanged ? "Order item" : "Size") + " was changed from: " +
(isStyleChanged ? oldListing.StyleString + " - " : " ") +
SizeHelper.ToVariation(oldListing.StyleSize, oldListing.StyleColor)
+ " to: " + (isStyleChanged ? newListing.StyleString + " - " : "") +
SizeHelper.ToVariation(newListing.StyleSize, newListing.StyleColor);
dbOrderItem.ReplaceType = (int)ItemReplaceTypes.Change;
dbOrderItem.ReplaceDate = when;
orderHistoryService.AddRecord(dbOrder.Id, OrderHistoryHelper.ReplaceItemKey, dbOrderItem.StyleItemId, dbOrderItem.Id.ToString(), newListing.StyleItemId, null, by);
var quantityOperation = new QuantityOperationDTO()
{
Type = (int)QuantityOperationType.Lost,
QuantityChanges = new List <QuantityChangeDTO>()
{
new QuantityChangeDTO()
{
StyleId = oldListing.StyleId.Value,
StyleItemId = oldListing.StyleItemId.Value,
Quantity = dbOrderItem.QuantityOrdered,
//NOTE: W/o sign means that the qty will be substracted
}
},
Comment = "Order edit, change style/size",
};
quantityManager.AddQuantityOperation(db,
quantityOperation,
when,
by);
}
//NOTE: Actualize current style info
dbOrderItem.StyleId = newListing.StyleId;
dbOrderItem.StyleItemId = newListing.StyleItemId;
dbOrderItem.StyleString = newListing.StyleString;
dbOrderItem.SourceStyleString = oldListing.StyleString;
dbOrderItem.SourceStyleItemId = oldListing.StyleItemId;
dbOrderItem.SourceStyleSize = oldListing.StyleSize;
dbOrderItem.SourceStyleColor = oldListing.StyleColor;
}
}
if (dbOrderItem.ItemOrderIdentifier != dbOrderItem.SourceItemOrderIdentifier)
{
var portionCoef = dbOrderItem.QuantityOrdered / (decimal)sourceItemMapping.QuantityOrdered;
dbOrderItem.ItemPrice = sourceItemMapping.ItemPrice * portionCoef;
dbOrderItem.ItemPriceInUSD = sourceItemMapping.ItemPriceInUSD * portionCoef;
dbOrderItem.ShippingPrice = sourceItemMapping.ShippingPrice * portionCoef;
dbOrderItem.ShippingPriceInUSD = sourceItemMapping.ShippingPriceInUSD * portionCoef;
dbOrderItem.ShippingDiscount = sourceItemMapping.ShippingDiscount * portionCoef;
dbOrderItem.ShippingDiscountInUSD = sourceItemMapping.ShippingDiscountInUSD * portionCoef;
}
else //NOTE: m.b. no needed, for now no cases, but can be found in future
{
dbOrderItem.ItemPrice = sourceItemMapping.ItemPrice;
dbOrderItem.ItemPriceInUSD = sourceItemMapping.ItemPriceInUSD;
dbOrderItem.ShippingPrice = sourceItemMapping.ShippingPrice;
dbOrderItem.ShippingPriceInUSD = sourceItemMapping.ShippingPriceInUSD;
dbOrderItem.ShippingDiscount = sourceItemMapping.ShippingDiscount;
dbOrderItem.ShippingDiscountInUSD = sourceItemMapping.ShippingDiscountInUSD;
}
}
db.Commit();
var toRemoveOrderItems = dbOrderItems.Where(oi => joinItems.All(i => i.ItemOrderId != oi.ItemOrderIdentifier) &&
oi.QuantityOrdered > 0).ToList(); //Keeping cancelled items with qty = 0
foreach (var toRemove in toRemoveOrderItems)
{
log.Info("Remove orderItem, ordrItemId=" + toRemove.ItemOrderIdentifier
+ ", qty=" + toRemove.QuantityOrdered);
db.OrderItems.Remove(toRemove);
itemSizeWasChanged = true;
}
db.Commit();
if (itemSizeWasChanged)
{
shouldRecalcRates = true;
Comments.Add(new CommentViewModel()
{
Comment = changeNotes,
Type = (int)CommentType.ReturnExchange
});
}
}
if (!string.IsNullOrEmpty(ManuallyShippingGroupId))
{
var groupId = int.Parse(ManuallyShippingGroupId);
var shippings = db.OrderShippingInfos.GetByOrderId(EntityId).ToList();
var previousIsActiveMethodIds = String.Join(";", shippings.Where(sh => sh.IsActive).Select(sh => sh.ShippingMethodId).ToList());
var hasDropdown = shippings.Where(sh => sh.IsVisible).GroupBy(sh => sh.ShippingMethodId).Count() > 1;
if (shippings.Any(sh => sh.ShippingGroupId == groupId))
{
foreach (var shipping in shippings)
{
shipping.IsActive = shipping.ShippingGroupId == groupId;
if (hasDropdown) //Keep is visible
{
shipping.IsVisible = shipping.IsVisible || shipping.ShippingGroupId == groupId;
}
else
{
shipping.IsVisible = shipping.ShippingGroupId == groupId;
}
}
var newIsActiveMethodIds = String.Join(";", shippings.Where(sh => sh.IsActive).Select(sh => sh.ShippingMethodId).ToList());
orderHistoryService.AddRecord(dbOrder.Id, OrderHistoryHelper.ShippingMethodKey, previousIsActiveMethodIds, newIsActiveMethodIds, by);
}
else
{
//Can't change active shipping to not exists
}
}
db.Commit();
//Update Package Sizes
var activeShippings = db.OrderShippingInfos.GetByOrderId(EntityId)
.Where(sh => sh.IsActive)
.OrderBy(sh => sh.Id)
.ToList();
for (var i = 0; i < activeShippings.Count; i++)
{
if (Packages != null && i < Packages.Count)
{
if (activeShippings[i].PackageLength != Packages[i].PackageLength)
{
log.Info("Changed length: " + activeShippings[i].PackageLength + "=>" + Packages[i].PackageLength);
activeShippings[i].PackageLength = Packages[i].PackageLength;
shouldRecalcRates = true;
}
if (activeShippings[i].PackageWidth != Packages[i].PackageWidth)
{
log.Info("Changed width: " + activeShippings[i].PackageWidth + "=>" + Packages[i].PackageWidth);
activeShippings[i].PackageWidth = Packages[i].PackageWidth;
shouldRecalcRates = true;
}
if (activeShippings[i].PackageHeight != Packages[i].PackageHeight)
{
log.Info("Changed height: " + activeShippings[i].PackageHeight + "=>" + Packages[i].PackageHeight);
activeShippings[i].PackageHeight = Packages[i].PackageHeight;
shouldRecalcRates = true;
}
}
}
db.Commit();
foreach (var comment in Comments)
{
if (comment.Id == 0)
{
log.Info("New comment: " + comment.Comment);
}
}
db.OrderComments.AddComments(
Comments.Select(c => new CommentDTO()
{
Id = c.Id,
Message = c.Comment,
Type = c.Type,
}).ToList(),
EntityId,
when,
by);
return(new ApplyOrderResult()
{
RateRecalcRequested = shouldRecalcRates,
AddressValidationRequested = addressChanged ||
dbOrder.AddressValidationStatus == (int)Core.Models.AddressValidationStatus.ExceptionCommunication ||
dbOrder.AddressValidationStatus == (int)Core.Models.AddressValidationStatus.Exception,
ShipmentProviderChanged = shipmentProviderChanged
});
}
public OrderHistoryController(IOrderHistoryService service)
{
_service = service;
}
public APIConsumer(IOrderHistoryService orderHistoryService)
{
_orderHistoryService = orderHistoryService;
}
public OrderHistoryController(IOrderHistoryService orderHistoryService, IMapper mapper)
{
_orderHistoryService = orderHistoryService;
_mapper = mapper;
}
public ShoppingCartService(IOrderHistoryService orderHistoryService)
{
_products = new List <Product>();
CartItems = new List <CartItem>();
_orderHistoryService = orderHistoryService;
}
public void Create(ILogService log,
ITime time,
IQuantityManager quantityManager,
IDbFactory dbFactory,
IWeightService weightService,
IShippingService shippingService,
IAutoCreateListingService createListingService,
ISettingsService settingService,
IEmailService emailService,
ISystemActionService actionService,
IHtmlScraperService htmlScraper,
IOrderHistoryService orderHistory,
IPriceService priceService,
CompanyDTO company,
DateTime when,
long?by)
{
var syncInfo = new EmptySyncInformer(log, SyncType.Orders);
var market = (int)MarketType.OfflineOrders;
var marketplaceId = MarketplaceKeeper.ManuallyCreated;
var orderItems = new List <ListingOrderDTO>();
using (var db = dbFactory.GetRWDb())
{
var index = 1;
foreach (var item in Items)
{
var dbItem = db.Items.GetAll().FirstOrDefault(i => i.Market == market &&
i.MarketplaceId == marketplaceId &&
i.StyleItemId == item.StyleItemId);
if (dbItem == null)
{
var itemPrice = item.ItemPrice; // db.Items.GetAllViewActual()
//.FirstOrDefault(i => i.Market == (int)MarketType.Amazon
// && i.MarketplaceId == MarketplaceKeeper.AmazonComMarketplaceId)?.CurrentPrice;
log.Info("Request create listing, market=" + market
+ ", marketplaceId=" + marketplaceId);
IList <MessageString> messages = new List <MessageString>();
//Create New
var model = createListingService.CreateFromStyle(db,
item.StyleId.Value,
(MarketType)market,
marketplaceId,
out messages);
model.Variations.ForEach(v => v.CurrentPrice = itemPrice);
createListingService.Save(model,
"",
db,
when,
by);
dbItem = db.Items.GetAll().FirstOrDefault(i => i.Market == market &&
i.MarketplaceId == marketplaceId &&
i.StyleItemId == item.StyleItemId);
}
var dbListing = db.Listings.GetAll().FirstOrDefault(l => l.Market == market &&
l.MarketplaceId == marketplaceId &&
l.ItemId == dbItem.Id);
orderItems.Add(new ListingOrderDTO()
{
ASIN = dbItem.ASIN,
SKU = dbListing.SKU,
ItemPaid = item.ItemPrice,
ItemPrice = item.ItemPrice,
ItemGrandPrice = item.ItemPrice,
StyleId = dbItem.StyleId,
StyleID = dbItem.StyleString,
StyleItemId = dbItem.StyleItemId,
Market = dbItem.Market,
MarketplaceId = dbItem.MarketplaceId,
QuantityOrdered = item.Quantity,
ItemOrderId = index.ToString(),
SourceListingId = dbListing.Id,
});
index++;
}
OrderNumber = db.Orders.GetAll()
.Where(o => o.Market == (int)market &&
o.MarketplaceId == marketplaceId)
.OrderByDescending(o => o.Id).FirstOrDefault()?.AmazonIdentifier;
if (String.IsNullOrEmpty(OrderNumber))
{
OrderNumber = "1000";
}
else
{
OrderNumber = ((StringHelper.TryGetInt(OrderNumber) ?? 1000) + 1).ToString();
}
}
var dtoOrder = new DTOOrder()
{
Market = market,
MarketplaceId = marketplaceId,
OrderDate = OrderDate,
OrderStatus = "Unshipped",
SourceOrderStatus = "Unshipped",
OrderId = OrderNumber,
CustomerOrderId = OrderNumber,
MarketOrderId = OrderNumber,
AmazonEmail = ToAddress.Email,
BuyerEmail = ToAddress.Email,
PersonName = ToAddress.FullName,
BuyerName = ToAddress.FullName,
ShippingAddress1 = ToAddress.Address1,
ShippingAddress2 = ToAddress.Address2,
ShippingCity = ToAddress.City,
ShippingCountry = ToAddress.Country,
ShippingZip = ToAddress.Zip,
ShippingZipAddon = ToAddress.ZipAddon,
ShippingPhone = ToAddress.Phone,
ShippingState = StringHelper.GetFirstNotEmpty(ToAddress.USAState, ToAddress.NonUSAState),
ShippingPaid = 0,
ShippingPrice = 0,
TotalPaid = Items.Sum(i => i.ItemPrice),
TotalPrice = Items.Sum(i => i.ItemPrice),
Quantity = Items.Sum(i => i.Quantity),
InitialServiceType = ShippingService,
ShippingService = ShippingService,
SourceShippingService = ShippingService,
Items = orderItems,
};
var userOrderApi = new UserOrderApi(new List <DTOOrder>()
{
dtoOrder
});
var serviceFactory = new ServiceFactory();
var addressCheckServices = serviceFactory.GetAddressCheckServices(log,
time,
dbFactory,
company.AddressProviderInfoList);
var companyAddress = new CompanyAddressService(company);
var addressService = new AddressService(addressCheckServices, companyAddress.GetReturnAddress(MarketIdentifier.Empty()), companyAddress.GetPickupAddress(MarketIdentifier.Empty()));
var rateProviders = serviceFactory.GetShipmentProviders(log,
time,
dbFactory,
weightService,
company.ShipmentProviderInfoList,
null,
null,
null,
null);
var stampsRateProvider = rateProviders.FirstOrDefault(r => r.Type == ShipmentProviderType.Stamps);
var validatorService = new OrderValidatorService(log, dbFactory, emailService, settingService, orderHistory, actionService,
priceService, htmlScraper, addressService, companyAddress.GetReturnAddress(MarketIdentifier.Empty()), stampsRateProvider, time, company);
var orderHistoryService = new OrderHistoryService(log, time, dbFactory);
var cacheService = new CacheService(log, time, actionService, quantityManager);
using (var db = dbFactory.GetRWDb())
{
try
{
var orderSyncFactory = new OrderSyncFactory();
var synchronizer = orderSyncFactory.GetForMarket(userOrderApi,
log,
company,
settingService,
syncInfo,
rateProviders,
quantityManager,
emailService,
validatorService,
orderHistoryService,
cacheService,
actionService,
companyAddress,
time,
weightService,
null);
if (!String.IsNullOrEmpty(OrderNumber))
{
synchronizer.ProcessSpecifiedOrder(db, OrderNumber);
Messages.Add(MessageString.Success("The order has been successfully created, order #: " + OrderNumber));
}
}
catch (Exception ex)
{
Messages.Add(MessageString.Error(ex.Message));
}
}
}
public OrderHistoryController(IOrderHistoryService orederHistoryService)
{
_orderHistoryService = orederHistoryService;
}
public static MessageResult RemoveMultipleFromBatch(IUnitOfWork db,
ILogService log,
ISystemActionService systemAction,
IOrderHistoryService orderHistoryService,
IBatchManager batchManager,
long batchId,
string orderIds,
long?toBatchId,
bool?removeOnHold)
{
var by = AccessManager.UserId;
var wasChanged = false;
var hasClosed = false;
var fromBatch = db.OrderBatches.GetAsDto(batchId);
OrderBatchDTO toBatch = null;
if (toBatchId.HasValue)
{
toBatch = db.OrderBatches.GetAsDto(toBatchId.Value);
}
if (fromBatch.IsClosed || (toBatch != null && toBatch.IsClosed))
{
if (!AccessManager.CanEditSystemInfo() && !AccessManager.IsAdmin)
{
hasClosed = true;
}
}
if (fromBatch.IsLocked || (toBatch != null && toBatch.IsLocked))
{
if (!AccessManager.IsAdmin)
{
return(MessageResult.Error("Source or distination batch was locked"));
}
}
var orders = db.Orders.GetFiltered(o => o.BatchId == batchId);
if (!string.IsNullOrEmpty(orderIds) && !removeOnHold.HasValue)
{
var stringOrderIdList = orderIds.Split(", ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
var orderIdList = stringOrderIdList.Select(long.Parse).ToList();
foreach (var orderId in orderIdList)
{
var order = orders.FirstOrDefault(o => o.Id == orderId);
if (order != null)
{
if (!hasClosed || batchManager.CanBeRemovedFromBatch(order) || AccessManager.IsAdmin)
{
order.BatchId = toBatchId;
batchManager.CheckRemovedOrder(db, log, systemAction, order, toBatchId, by);
orderHistoryService.AddRecord(order.Id, OrderHistoryHelper.AddToBatchKey, fromBatch.Id, fromBatch.Name, toBatch?.Id, toBatch?.Name, by);
wasChanged = true;
}
}
}
}
else if (removeOnHold.HasValue && removeOnHold.Value)
{
var onHoldOrders = orders.Where(o => o.OnHold).ToList();
foreach (var order in onHoldOrders)
{
if (!hasClosed || batchManager.CanBeRemovedFromBatch(order))
{
order.BatchId = toBatchId;
batchManager.CheckRemovedOrder(db, log, systemAction, order, toBatchId, by);
orderHistoryService.AddRecord(order.Id, OrderHistoryHelper.AddToBatchKey, fromBatch.Id, fromBatch.Name, toBatch?.Id, toBatch?.Name, by);
wasChanged = true;
}
}
}
db.Commit();
if (!wasChanged && hasClosed)
{
return(MessageResult.Error("Source or distination batch was closed"));
}
if (!wasChanged)
{
return(MessageResult.Error("Order list is empty"));
}
return(MessageResult.Success());
}
public InsureChecker(ILogService log, IOrderHistoryService orderHistory)
{
_log = log;
_orderHistory = orderHistory;
}
public OrderCalendarService(IHolidayService holidayService, IOrderHistoryService orderHistoryService)
{
_orderHistoryService = orderHistoryService;
_holidayService = holidayService;
WeekDays = new List <Day>();
}
public OrderHistoriesController(IOrderHistoryService orderHistory)
{
_service = orderHistory;
}
