public static void AddQuantityOperation(ILogService log,
IUnitOfWork db,
IQuantityManager quantityManager,
string orderId,
IList <DTOOrderItem> items,
ITime time,
long?by)
{
var operationDto = new QuantityOperationDTO();
operationDto.Type = (int)QuantityOperationType.FromMailPage;
operationDto.OrderId = orderId;
operationDto.Comment = String.Empty;
operationDto.QuantityChanges = new List <QuantityChangeDTO>();
if (items != null)
{
foreach (var item in items)
{
operationDto.QuantityChanges.Add(new QuantityChangeDTO()
{
StyleId = item.StyleEntityId ?? 0,
StyleItemId = item.StyleItemId ?? 0,
Quantity = item.Quantity,
});
}
}
quantityManager.AddQuantityOperation(db,
operationDto,
time.GetAppNowTime(),
by);
}
static public void Delete(IUnitOfWork db,
IQuantityManager quantityManager,
ICacheService cache,
long operationId,
DateTime when,
long?by)
{
var operation = db.QuantityOperations.Get(operationId);
var operationChanges = db.QuantityChanges
.GetAll()
.Where(ch => ch.QuantityOperationId == operationId)
.ToList();
db.QuantityOperations.Remove(operation);
db.Commit();
foreach (var change in operationChanges)
{
quantityManager.LogStyleItemQuantity(db,
change.StyleItemId,
-change.Quantity,
null,
QuantityChangeSourceType.RemoveSpecialCase,
null,
change.Id,
StringHelper.Substring(StringHelper.GetFirstNotEmpty(operation.OrderId), 50),
when,
by);
cache.RequestStyleItemIdUpdates(db, new List <long>()
{
change.StyleItemId
}, by);
}
}
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 CallCacheProcessing(ILogService log,
ITime time,
IQuantityManager quantityManager)
{
_log = log;
_time = time;
_quantityManager = quantityManager;
}
public ImportKomarInvoices(ILogService log,
ITime time,
IDbFactory dbFactory,
IQuantityManager quantityManager)
{
_log = log;
_time = time;
_dbFactory = dbFactory;
_quantityManager = quantityManager;
}
public CallFtpMarketProcessing(IDbFactory dbFactory,
ILogService log,
ITime time,
ISystemActionService actionService,
IQuantityManager quantityManager,
IEmailService emailService)
{
_log = log;
_dbFactory = dbFactory;
_time = time;
_actionService = actionService;
_quantityManager = quantityManager;
_emailService = emailService;
}
public CallDsApiProcessing(ILogService log,
ITime time,
ICacheService cacheService,
IQuantityManager quantityManager,
ISystemActionService actionService,
IEmailService emailService,
IDbFactory dbFactory)
{
_dbFactory = dbFactory;
_cacheService = cacheService;
_quantityManager = quantityManager;
_actionService = actionService;
_barcodeService = new BarcodeService(log, time, dbFactory);
_log = log;
_time = time;
_emailService = emailService;
var itemHistoryService = new ItemHistoryService(_log, _time, _dbFactory);
var barcodeService = new BarcodeService(log, time, dbFactory);
_autoCreateListingService = new AutoCreateNonameListingService(_log, _time, dbFactory, cacheService, barcodeService, emailService, itemHistoryService, AppSettings.IsDebug);
}
public static void Remove(IUnitOfWork db,
long id,
IQuantityManager quantityManager,
ICacheService cache,
DateTime when,
long?by)
{
var box = db.SealedBoxes.Get(id);
box.Deleted = true;
box.UpdateDate = when;
box.UpdatedBy = by;
db.Commit();
var openBoxItems = db.SealedBoxItems.GetAll().Where(bi => bi.BoxId == id).ToList();
foreach (var boxItem in openBoxItems)
{
quantityManager.LogStyleItemQuantity(db,
boxItem.StyleItemId ?? 0,
null,
boxItem.BreakDown * box.BoxQuantity,
QuantityChangeSourceType.RemoveBox,
null,
boxItem.Id,
box?.BoxBarcode,
when,
by);
}
cache.RequestStyleIdUpdates(db,
new List <long>()
{
box.StyleId
},
UpdateCacheMode.IncludeChild,
AccessManager.UserId);
}
public long Apply(IUnitOfWork db, IQuantityManager quantityManager, DateTime when, long?by)
{
var existBox = db.OpenBoxes.GetFiltered(b => b.Id == Id && !b.Deleted).FirstOrDefault();
long?boxId = null;
var isNewBox = false;
var archiveChanged = false;
var boxQuantityChanged = false;
if (existBox == null)
{
boxId = AddNewBox(db, when, by);
isNewBox = true;
}
else
{
archiveChanged = existBox.Archived != Archived;
boxQuantityChanged = existBox.BoxQuantity != BoxQuantity;
UpdateExistingBox(db, existBox, when, by);
boxId = existBox.Id;
}
var boxItems = StyleItems.Items
.Where(si => si.Quantity.HasValue)
.Select(si => new OpenBoxItemDto()
{
Id = si.BoxItemId ?? 0,
StyleItemId = si.Id,
Quantity = si.Quantity ?? 0,
}).ToList();
var updateResults = db.OpenBoxItems.UpdateBoxItemsForBox(boxId.Value, boxItems, when, by);
foreach (var updateResult in updateResults)
{
var boxItem = boxItems.FirstOrDefault(bi => bi.Id == updateResult.Id);
if (boxItem != null)
{
var changeType = QuantityChangeSourceType.None;
if (updateResult.Status == UpdateType.Update || boxQuantityChanged)
{
changeType = QuantityChangeSourceType.ChangeBox;
}
if (updateResult.Status == UpdateType.Insert)
{
changeType = QuantityChangeSourceType.AddNewBox;
}
if (updateResult.Status == UpdateType.Removed)
{
changeType = QuantityChangeSourceType.RemoveBox;
}
quantityManager.LogStyleItemQuantity(db,
boxItem.StyleItemId,
changeType != QuantityChangeSourceType.RemoveBox ? boxItem.Quantity * BoxQuantity : (int?)null,
changeType == QuantityChangeSourceType.RemoveBox ? boxItem.Quantity * BoxQuantity : (int?)null,
changeType,
null,
boxItem.Id,
existBox?.BoxBarcode,
when,
by);
var archiveChangeType = QuantityChangeSourceType.None;
if (isNewBox)
{
if (Archived)
{
archiveChangeType = QuantityChangeSourceType.ArchiveBox;
}
}
else
{
if (archiveChanged)
{
archiveChangeType = Archived ? QuantityChangeSourceType.ArchiveBox : QuantityChangeSourceType.UnArchiveBox;
}
}
if (archiveChangeType != QuantityChangeSourceType.None)
{
quantityManager.LogStyleItemQuantity(db,
boxItem.StyleItemId,
changeType == QuantityChangeSourceType.UnArchiveBox
? boxItem.Quantity * BoxQuantity
: (int?)null,
changeType == QuantityChangeSourceType.ArchiveBox
? boxItem.Quantity * BoxQuantity
: (int?)null,
changeType,
null,
boxItem.Id,
existBox?.BoxBarcode,
when,
by);
}
}
}
var id = db.Styles.GetFiltered(s => s.Id == StyleId).Select(s => s.Id).FirstOrDefault();
return(id);
}
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 WeightController(IQuantityManager manager)
{
this._Manager = manager;
}
public VolumeController(IQuantityManager manager)
{
this._Manager = manager;
}
protected SyncResult SyncAllNewOrders(CancellationToken?token,
ILogService log,
IMarketApi api,
MarketType market,
Func <ILogService, IMarketApi, ISyncInformer, string, IList <ListingOrderDTO> > getOrderItemsFromMarketFunc,
ISyncInformer syncInfo,
IList <IShipmentApi> rateProviders,
IQuantityManager quantityManager,
ISettingsService settings,
IEmailService emailService,
IOrderValidatorService validatorService,
ICacheService cacheService,
ICompanyAddressService companyAddress,
DateTime syncMissedFrom,
ITime time)
{
try
{
log.Info("Get missed orders");
var statusList = new List <string> {
OrderStatusEnumEx.Canceled,
OrderStatusEnumEx.Shipped,
OrderStatusEnumEx.Unshipped,
OrderStatusEnumEx.Pending
}; //NOTE: On API level there status will be converted on eBay status
var allOrders = api.GetOrders(log, syncMissedFrom, statusList).ToList();
if (allOrders.Any())
{
var result = ProcessNewOrdersPack(token,
log,
api,
getOrderItemsFromMarketFunc,
rateProviders,
validatorService,
syncInfo,
settings,
quantityManager,
emailService,
cacheService,
companyAddress,
allOrders,
time);
if (!result.IsSuccess)
{
syncInfo.AddWarning("", "The orders pack processing has failed");
return(new SyncResult()
{
IsSuccess = false
});
}
return(result);
}
return(new SyncResult()
{
IsSuccess = true,
ProcessedOrders = new List <SyncResultOrderInfo>()
});
}
catch (Exception ex)
{
syncInfo.AddError(null, "Error when storing new unshipped orders", ex);
log.Error("Error when storing new unshipped orders", ex);
return(new SyncResult()
{
IsSuccess = false
});
}
}
protected SyncResult SyncAllUnshippedOrders(CancellationToken?cancel,
ILogService log,
IMarketApi api,
Func <ILogService, IMarketApi, ISyncInformer, string, IList <ListingOrderDTO> > getOrderItemsFromMarketFunc,
ISyncInformer syncInfo,
IList <IShipmentApi> rateProviders,
IQuantityManager quantityManager,
ISettingsService settings,
IEmailService emailService,
IOrderValidatorService validatorService,
ICacheService cacheService,
ICompanyAddressService companyAddress,
DateTime syncMissedFrom,
ITime time)
{
try
{
log.Info("Get missed orders");
SyncResult result = new SyncResult();
var statusList = new List <string> {
OrderStatusEnumEx.Unshipped, OrderStatusEnumEx.PartiallyShipped, OrderStatusEnumEx.Canceled
};
var unshippedOrders = api.GetOrders(log, syncMissedFrom, statusList).ToList();
if (unshippedOrders.Any())
{
result = ProcessNewOrdersPack(cancel,
log,
api,
getOrderItemsFromMarketFunc,
rateProviders,
validatorService,
syncInfo,
settings,
quantityManager,
emailService,
cacheService,
companyAddress,
unshippedOrders,
time);
if (!result.IsSuccess)
{
syncInfo.AddWarning("", "The orders pack processing has failed");
return(new SyncResult()
{
IsSuccess = false
});
}
}
return(new SyncResult()
{
IsSuccess = true,
//NOTE: Return all unshipped orders for correct calculation total orders on Amazon
//unprocessed orders actual didn't updated (we can safely skip processing of it)
ProcessedOrders = result.ProcessedOrders,
SkippedOrders = result.SkippedOrders,
/*unshippedOrders.Select(o => new SyncResultOrderInfo()
* {
* OrderId = o.OrderId,
* OrderStatus = o.OrderStatus
* }).ToList()*/
});
}
catch (Exception ex)
{
syncInfo.AddError(null, "Error when storing new unshipped orders", ex);
log.Error("Error when storing new unshipped orders", ex);
return(new SyncResult()
{
IsSuccess = false
});
}
}
/// <summary>
/// Requested new pending orders (from last exist pending order date)
/// </summary>
/// <returns></returns>
protected SyncResult StoreNewPendingOrders(CancellationToken?token,
ILogService log,
IMarketApi api,
Func <ILogService, IMarketApi, ISyncInformer, string, IList <ListingOrderDTO> > getOrderItemsFromMarketFunc,
IList <IShipmentApi> rateProviders,
IOrderValidatorService validatorService,
IEmailService emailService,
ISyncInformer syncInfo,
ISettingsService settings,
IQuantityManager quantityManager,
ICacheService cacheService,
ICompanyAddressService companyAddress,
ITime time)
{
try
{
using (var db = new UnitOfWork(_log))
{
var lastPending = db.Orders
.GetFiltered(o => o.OrderStatus == OrderStatusEnumEx.Pending &&
o.Market == (int)api.Market &&
o.MarketplaceId == api.MarketplaceId)
.OrderBy(o => o.Id).FirstOrDefault();
var date = lastPending != null && lastPending.OrderDate.HasValue ? lastPending.OrderDate : null;
log.Info(date != null ? "Last pending order date: " + date.Value : "No pending orders!");
var updatedAfter = date ?? DateHelper.GetAmazonNowTime().AddDays(-1);
log.Info(string.Format("Process Orders created since {0}", updatedAfter));
var statusList = new List <string> {
OrderStatusEnum.Pending.Str()
};
var pendingOrders = api.GetOrders(log, updatedAfter, statusList).ToList();
log.Info("Total pending orders:" + pendingOrders.Count());
syncInfo.PingSync();
var result = ProcessNewOrdersPack(token,
log,
api,
getOrderItemsFromMarketFunc,
rateProviders,
validatorService,
syncInfo,
settings,
quantityManager,
emailService,
cacheService,
companyAddress,
pendingOrders,
time);
if (!result.IsSuccess)
{
syncInfo.AddWarning("", "The orders pack processing has failed");
return(new SyncResult()
{
IsSuccess = false
});
}
return(result);
}
}
catch (Exception ex)
{
syncInfo.AddError(null, "Error when storing new orders", ex);
log.Error("Error when storing new orders", ex);
return(new SyncResult()
{
IsSuccess = false
});
}
}
public void Apply(IUnitOfWork db,
IQuantityManager quantityManager,
ILogService log,
ICacheService cache,
ISystemActionService actionService,
DateTime when,
long?by)
{
log.Info("AddSealedBoxWizardViewModel.Apply, StyleId=" + StyleId);
if (IncomeType == (int)BoxIncomePackType.PPK)
{
var box = new SealedBoxViewModel();
box.StyleId = StyleId;
box.BoxBarcode = BoxBarcode;
box.BoxQuantity = BoxQuantity;
box.Price = Price ?? 0;
box.Owned = Owned;
box.PolyBags = false;
box.Printed = Printed;
box.CreateDate = CreateDate.HasValue ? DateHelper.ConvertUtcToApp(CreateDate.Value.ToUniversalTime()) : when;
box.StyleItems = new StyleItemCollection()
{
Items = Sizes.Select(s => new StyleItemViewModel()
{
Id = s.Id,
Breakdown = s.Breakdown,
}).ToList()
};
box.Apply(db, quantityManager, when, by);
}
if (IncomeType == (int)BoxIncomePackType.PolyBagged)
{
foreach (var size in Sizes.Where(si => si.Quantity > 0))
{
var box = new SealedBoxViewModel();
box.StyleId = StyleId;
box.BoxBarcode = BoxBarcode;
box.BoxQuantity = size.Quantity ?? 0;
box.Price = Price ?? 0;
box.Owned = Owned;
box.PolyBags = true;
box.Printed = Printed;
box.CreateDate = CreateDate.HasValue ? DateHelper.ConvertUtcToApp(CreateDate.Value.ToUniversalTime()) : when;
box.StyleItems = new StyleItemCollection()
{
Items = new List <StyleItemViewModel>()
{
new StyleItemViewModel()
{
Id = size.Id,
Breakdown = UnitsPerBox
}
}
};
box.Apply(db, quantityManager, when, by);
}
}
if (IncomeType == (int)BoxIncomePackType.Other)
{
var box = new OpenBoxViewModel();
box.StyleId = StyleId;
box.BoxBarcode = BoxBarcode;
box.BoxQuantity = 1;
box.Price = Price ?? 0;
box.Owned = Owned;
box.PolyBags = false;
box.Printed = Printed;
box.CreateDate = CreateDate.HasValue ? DateHelper.ConvertUtcToApp(CreateDate.Value.ToUniversalTime()) : when;
box.StyleItems = new StyleItemCollection()
{
Items = Sizes.Select(s => new StyleItemViewModel()
{
Id = s.Id,
Quantity = s.Quantity,
}).ToList()
};
box.Apply(db, quantityManager, when, by);
}
foreach (var size in Sizes)
{
var styleItem = db.StyleItems.Get(size.Id);
if (size.UseBoxQuantity &&
styleItem.Quantity.HasValue)
{
log.Info("Switch to box quantity, styleItemId=" + size.Id);
var oldQuantity = styleItem.Quantity;
styleItem.Quantity = null;
styleItem.QuantitySetBy = null;
styleItem.QuantitySetDate = null;
styleItem.RestockDate = null;
db.Commit();
quantityManager.LogStyleItemQuantity(db,
styleItem.Id,
null,
oldQuantity,
QuantityChangeSourceType.UseBoxQuantity,
null,
null,
BoxBarcode,
when,
by);
}
}
cache.RequestStyleIdUpdates(db,
new List <long>()
{
StyleId
},
UpdateCacheMode.IncludeChild,
by);
SystemActionHelper.RequestQuantityDistribution(db, actionService, StyleId, by);
}
public void Setup()
{
Database.SetInitializer <AmazonContext>(null);
XmlConfigurator.Configure(new FileInfo(AppSettings.log4net_Config));
_dbFactory = new DbFactory();
_time = new TimeService(_dbFactory);
_settings = new SettingsService(_dbFactory);
_styleHistoryService = new StyleHistoryService(_log, _time, _dbFactory);
_styleManager = new StyleManager(_log, _time, _styleHistoryService);
_actionService = new SystemActionService(_log, _time);
_quantityManager = new QuantityManager(_log, _time);
_priceManager = new PriceManager(_log, _time, _dbFactory, _actionService, _settings);
_cacheService = new CacheService(_log, _time, _actionService, _quantityManager);
_barcodeService = new BarcodeService(_log, _time, _dbFactory);
_weightService = new WeightService();
IEmailSmtpSettings smtpSettings = new EmailSmtpSettings();
using (var db = new UnitOfWork())
{
_company = db.Companies.GetFirstWithSettingsAsDto();
if (AppSettings.IsDebug)
{
smtpSettings = SettingsBuilder.GetSmtpSettingsFromAppSettings();
}
else
{
smtpSettings = SettingsBuilder.GetSmtpSettingsFromCompany(_company);
}
_addressService = AddressService.Default;
_emailService = new EmailService(_log, smtpSettings, _addressService);
//todo check itemHist
_autoCreateNonameListingService = new AutoCreateNonameListingService(_log,
_time,
_dbFactory,
_cacheService,
_barcodeService,
_emailService, null,
AppSettings.IsDebug);
var marketplaces = new MarketplaceKeeper(_dbFactory, true);
marketplaces.Init();
var shipmentPrividers = db.ShipmentProviders.GetByCompanyId(_company.Id);
var apiFactory = new MarketFactory(marketplaces.GetAll(), _time, _log, _dbFactory, AppSettings.JavaPath);
var weightService = new WeightService();
var serviceFactory = new ServiceFactory();
var rateProviders = serviceFactory.GetShipmentProviders(_log,
_time,
_dbFactory,
weightService,
shipmentPrividers,
null,
null,
null,
null);
_magentoApi = (Magento20MarketApi)apiFactory.GetApi(_company.Id, MarketType.Magento, MarketplaceKeeper.ShopifyDWS);
_shopifyDWSApi = (ShopifyApi)apiFactory.GetApi(_company.Id, MarketType.Shopify, MarketplaceKeeper.ShopifyDWS);
_eBayApi = (eBayApi)apiFactory.GetApi(_company.Id, MarketType.eBay, "");
_amazonApi = (AmazonApi)apiFactory.GetApi(_company.Id, MarketType.Amazon, MarketplaceKeeper.AmazonComMarketplaceId);
_walmartApi = (WalmartApi)apiFactory.GetApi(_company.Id, MarketType.Walmart, "");
}
}
public LengthController(IQuantityManager manager)
{
this._Manager = manager;
}
public void SendEmail(IUnitOfWork db,
ILogService log,
IEmailService emailService,
IQuantityManager quantityManager,
DateTime when,
long?by)
{
CallResult <Exception> result;
if (AppSettings.IsDemo)
{
result = CallResult <Exception> .Success(null);
}
else
{
result = emailService.SendEmail(this, CallSource.UI, by);
}
CallHelper.ThrowIfFail(result);
Order order = null;
switch (this.EmailType)
{
case EmailTypes.RequestFeedback:
db.Orders.UpdateRequestedFeedback(this.OrderNumber);
break;
case EmailTypes.AddressVerify:
db.Orders.UpdateRequestedAddressVerify(this.OrderNumber);
break;
case EmailTypes.LostPackage:
break;
case EmailTypes.LostPackage2:
break;
case EmailTypes.UndeliverableAsAddressed:
break;
case EmailTypes.ExchangeInstructions:
if (ExchangeItems != null)
{
var exchangeToItems = ExchangeItems.Where(i => i.InputQuantity > 0).ToList();
if (exchangeToItems.Any())
{
var model = new QuantityOperationDTO()
{
Type = (int)QuantityOperationType.ExchangeOnHold,
OrderId = this.OrderNumber,
Comment = "Sent Exchange Instruction",
QuantityChanges = exchangeToItems.Select(i => new QuantityChangeDTO()
{
Quantity = i.InputQuantity,
StyleId = i.ExchangeStyleId ?? 0,
StyleItemId = i.ExchangeStyleItemId ?? 0,
StyleString = i.ExchangeStyleString,
ExpiredOn = when.AddDays(14),
Tag = "Exchanged from: " + i.StyleString + ", styleItemId: " + i.StyleItemId,
}).ToList(),
};
quantityManager.AddQuantityOperation(db, model, when, by);
}
foreach (var item in ExchangeItems)
{
log.Info("Exchange item, from styleId=" + item.StyleId + " styleItemId=" + item.StyleItemId +
" --- to styleId=" + item.ExchangeStyleId + ", styleItemId=" +
item.ExchangeStyleItemId + ", quantity=" + item.InputQuantity);
//TODO: save into DB
}
}
break;
}
if (!String.IsNullOrEmpty(NewComment))
{
AddOrderComment(db,
OrderNumber,
NewComment,
when,
by);
}
var emailNotifyType = EmailNotifyHelper.GetEmailNotifyFrom(this.EmailType);
db.OrderEmailNotifies.Add(new OrderEmailNotify()
{
OrderNumber = this.OrderNumber,
Reason = "User emailed, webpage",
Type = (int)emailNotifyType,
CreateDate = when,
CreatedBy = by
});
db.Commit();
if (ReplyToEmailId.HasValue)
{
var email = db.Emails.Get(ReplyToEmailId.Value);
if (email != null)
{
email.ResponseStatus = (int)EmailResponseStatusEnum.Sent;
db.Commit();
log.Info("Mark as responsed (as reply), emailId=" + email.Id);
}
}
if (!String.IsNullOrEmpty(this.OrderNumber))
{
var orderEmails = db.Emails.GetAllByOrderId(this.OrderNumber)
.Where(e => e.FolderType == (int)EmailFolders.Inbox &&
((String.IsNullOrEmpty(e.AnswerMessageID) &&
e.ResponseStatus == (int)EmailResponseStatusEnum.None) ||
e.ResponseStatus == (int)EmailResponseStatusEnum.ResponsePromised))
.ToList();
foreach (var email in orderEmails)
{
var dbEmail = db.Emails.Get(email.Id);
dbEmail.ResponseStatus = (int)EmailResponseStatusEnum.Sent;
log.Info("Mark as responsed (by orderNumber), emailId=" + email.Id);
}
db.Commit();
}
}
public static void GenerateOpenBox(IUnitOfWork db,
ICacheService cache,
IQuantityManager quantityManager,
long styleId,
DateTime when,
long?by)
{
var styleItemCaches = db.StyleItemCaches.GetFiltered(si => si.StyleId == styleId).ToList();
var openBox = new OpenBox();
openBox.BoxBarcode = "Generated_" + when.ToString("yyyyMMdd");
openBox.StyleId = styleId;
openBox.BoxQuantity = 1;
openBox.CreateDate = when;
openBox.CreatedBy = by;
db.OpenBoxes.Add(openBox);
db.Commit();
foreach (var styleItem in styleItemCaches)
{
var openBoxItem = new OpenBoxItem()
{
BoxId = openBox.Id,
StyleItemId = styleItem.Id,
Quantity = styleItem.RemainingQuantity,
CreateDate = when,
CreatedBy = by
};
db.OpenBoxItems.Add(openBoxItem);
}
db.Commit();
var styleItems = db.StyleItems.GetFiltered(si => si.StyleId == styleId).ToList();
foreach (var styleItem in styleItems)
{
var oldQuantity = styleItem.Quantity;
var styleItemCache = styleItemCaches.FirstOrDefault(sic => sic.Id == styleItem.Id);
int?newQuantity = styleItemCache != null ? styleItemCache.RemainingQuantity : (int?)null;
styleItem.Quantity = null;
styleItem.QuantitySetDate = null;
styleItem.QuantitySetBy = null;
styleItem.RestockDate = null;
quantityManager.LogStyleItemQuantity(db,
styleItem.Id,
newQuantity,
oldQuantity,
QuantityChangeSourceType.UseBoxQuantity,
null,
null,
null,
when,
by);
db.Commit();
}
db.Styles.SetReSaveDate(styleId, when, by);
if (AppSettings.IsDebug)
{
cache.UpdateStyleCacheForStyleId(db, new List <long>()
{
styleId
});
cache.UpdateStyleItemCacheForStyleId(db, new List <long>()
{
styleId
});
}
else
{
cache.RequestStyleIdUpdates(db,
new List <long>()
{
styleId
},
UpdateCacheMode.IncludeChild,
AccessManager.UserId);
}
}
public long Apply(IUnitOfWork db,
IQuantityManager quantityManager,
DateTime when,
long?by)
{
var existBox = db.SealedBoxes.GetFiltered(b => b.Id == Id && !b.Deleted).FirstOrDefault();
long?boxId = null;
if (existBox == null)
{
boxId = AddNewBox(db, when, by);
}
else
{
UpdateExistingBox(db, existBox, when, by);
boxId = existBox.Id;
}
var boxItems = StyleItems.Items
.Where(si => si.Breakdown.HasValue)
.Select(si => new SealedBoxItemDto()
{
Id = si.BoxItemId ?? 0,
StyleItemId = si.Id,
BreakDown = si.Breakdown ?? 0,
}).ToList();
var updateResults = db.SealedBoxItems.UpdateBoxItemsForBox(boxId.Value, boxItems, when, by);
foreach (var updateResult in updateResults)
{
var boxItem = boxItems.FirstOrDefault(bi => bi.Id == updateResult.Id);
if (boxItem != null)
{
var changeType = QuantityChangeSourceType.None;
if (updateResult.Status == UpdateType.Update)
{
changeType = QuantityChangeSourceType.ChangeBox;
}
if (updateResult.Status == UpdateType.Insert)
{
changeType = QuantityChangeSourceType.AddNewBox;
}
if (updateResult.Status == UpdateType.Removed)
{
changeType = QuantityChangeSourceType.RemoveBox;
}
quantityManager.LogStyleItemQuantity(db,
boxItem.StyleItemId,
changeType != QuantityChangeSourceType.RemoveBox ? boxItem.BreakDown * BoxQuantity : (int?)null,
changeType != QuantityChangeSourceType.AddNewBox ? boxItem.BreakDown * BoxQuantity : (int?)null,
changeType,
null,
boxItem.Id,
existBox?.BoxBarcode,
when,
by);
}
}
var id = db.Styles.GetFiltered(s => s.Id == StyleId).Select(s => s.Id).FirstOrDefault();
return(id);
}
public TemperatureController(IQuantityManager manager)
{
this._Manager = manager;
}
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 IList <MessageString> Generate(ILogService log,
ITime time,
ILabelService labelService,
IQuantityManager quantityManager,
IUnitOfWork db,
IWeightService weightService,
IShippingService shippingService,
bool sampleMode,
DateTime when,
long?by)
{
var results = new List <MessageString>();
//Cancel privious
if (CancelCurrentOrderLabel)
{
var cancelResults = CancelCurrentOrderLabels(log,
db,
labelService,
time,
OrderEntityId.Value,
sampleMode);
results.AddRange(cancelResults);
}
//Print new
var printResult = GenerateLabel(db,
labelService,
weightService,
shippingService,
this,
time.GetAppNowTime(),
by);
if (printResult.Success)
{
//Remove from batch if unshipped
var wasRemoved = RemoveFromBatchIfUnshipped(log,
db,
OrderEntityId.Value);
if (wasRemoved)
{
results.Add(MessageString.Success("Order was removed from batch"));
}
}
//Processing print result
Messages.AddRange(printResult.Messages.Select(m => MessageString.Error(m.Text)).ToList());
IsPrinted = printResult.Success;
PrintedLabelPath = printResult.Url;
PrintedLabelUrl = UrlHelper.GetPrintLabelPathById(printResult.PrintPackId);
PrintedTrackingNumber = printResult.TrackingNumber;
if (ReduceInventory)
{
AddQuantityOperation(log,
db,
quantityManager,
OrderID,
Items.Select(i => i.GetItemDto()).ToList(),
time,
by);
results.Add(MessageString.Success("Inventory quantity was adjusted"));
}
//Add to track table
if (ReasonCode == (int)MailLabelReasonCodes.ReturnLabelReasonCode)
{
AddToOrderTracking(log,
db,
OrderID,
printResult.TrackingNumber,
printResult.Carrier,
when,
by);
results.Add(MessageString.Success("Tracking number was added to Track Orders list"));
}
if (OrderEntityId.HasValue &&
!String.IsNullOrEmpty(OrderComment))
{
db.OrderComments.Add(new OrderComment()
{
OrderId = OrderEntityId.Value,
Message = OrderComment, // "[System] Returned",
Type = (int)CommentType.ReturnExchange,
CreateDate = when,
CreatedBy = by
});
db.Commit();
results.Add(MessageString.Success("Comment was added"));
}
if (printResult.Success && !string.IsNullOrEmpty(printResult.Url))
{
log.Info(string.Format("LabelPath for {0} order: {1}",
string.IsNullOrEmpty(OrderID) ? "Ebay" : OrderID, printResult.Url));
}
if (printResult.Success && UpdateAmazon)
{
results.Add(MessageString.Success("Send the order update to the market was scheduled"));
}
return(results);
}
protected SyncResult UpdateExistingUnshippedOrders(CancellationToken?token,
ILogService log,
IMarketApi api,
Func <ILogService, IMarketApi, ISyncInformer, string, IList <ListingOrderDTO> > getOrderItemsFromMarketFunc,
ISyncInformer syncInfo,
IList <IShipmentApi> rateProviders,
IQuantityManager quantityManager,
IEmailService emailService,
IOrderValidatorService validatorService,
IList <string> excludeOrderIdList,
ICompanyAddressService companyAddress,
ITime time)
{
IList <Order> ordersToUpdate = new List <Order>();
try
{
using (var db = new UnitOfWork(log))
{
var existOrders = db.Orders.GetOrdersByStatus(api.Market,
api.MarketplaceId,
new[] {
OrderStatusEnumEx.Pending,
OrderStatusEnumEx.Unshipped,
OrderStatusEnumEx.PartiallyShipped
}
).ToList();
if (excludeOrderIdList != null)
{
ordersToUpdate = existOrders.Where(o => !excludeOrderIdList.Contains(o.AmazonIdentifier)).ToList();
}
else
{
ordersToUpdate = existOrders;
}
log.Info("Orders to update count:" + ordersToUpdate.Count
+ " (existing in DB=" + existOrders.Count
+ ", exclude list=" + (excludeOrderIdList != null ? excludeOrderIdList.Count.ToString() : "[null]") + ")");
var index = 0;
var step = 50;
while (index < ordersToUpdate.Count)
{
var ordersToProcess = ordersToUpdate.Skip(index).Take(step).ToList();
log.Info("Start process orders from api, from=" + index + ", count=" + ordersToProcess.Count);
if (!ProcessExistOrdersPack(token,
log,
api,
getOrderItemsFromMarketFunc,
syncInfo,
db,
rateProviders,
quantityManager,
emailService,
validatorService,
companyAddress,
ordersToProcess,
time))
{
syncInfo.AddWarning("", "The pending orders pack processing has failed");
//Break cycle if pack processing is fail, something wrong (m.b. unavailable Db, m.b. parallel sync)
return(new SyncResult()
{
IsSuccess = false
});
}
index += step;
syncInfo.PingSync();
}
}
return(new SyncResult()
{
IsSuccess = true,
ProcessedOrders = ordersToUpdate.Select(o => new SyncResultOrderInfo()
{
OrderId = o.AmazonIdentifier,
OrderStatus = o.OrderStatus
}).ToList()
});
}
catch (Exception ex)
{
LogError(log, syncInfo, ex, "", "Error when updating existing orders");
return(new SyncResult()
{
IsSuccess = false
});
}
}
public long Add(IUnitOfWork db,
IQuantityManager quantityManager,
ICacheService cache,
DateTime when,
long?by)
{
IList <ListingOrderDTO> orderItems;
StyleEntireDto style;
var operationDto = new QuantityOperationDTO();
operationDto.Type = (int)Type;
operationDto.OrderId = OrderId;
operationDto.Comment = Comment;
operationDto.QuantityChanges = new List <QuantityChangeDTO>();
switch (Type)
{
case QuantityOperationType.Exchange:
orderItems = db.Listings.GetOrderItems(OrderId);
var current = orderItems.FirstOrDefault(o => o.ItemOrderId == OrderItemId);
if (current != null)
{
operationDto.QuantityChanges.Add(new QuantityChangeDTO()
{
StyleId = current.StyleId ?? 0,
StyleItemId = current.StyleItemId ?? 0,
Quantity = -(Quantity ?? 0),
});
}
style = db.Styles.GetActiveByStyleIdAsDto(StyleId);
if (style != null)
{
operationDto.QuantityChanges.Add(new QuantityChangeDTO()
{
StyleId = style.Id,
StyleItemId = StyleItemId ?? 0,
Quantity = Quantity ?? 0
});
}
break;
case QuantityOperationType.Return:
orderItems = db.Listings.GetOrderItems(OrderId);
foreach (var item in orderItems)
{
if (InputOrderItems != null)
{
var inputItem = InputOrderItems.FirstOrDefault(i => i.ItemOrderId == item.ItemOrderId);
if (inputItem != null)
{
item.QuantityOrdered = inputItem.Quantity;
}
}
if (item.QuantityOrdered > 0)
{
operationDto.QuantityChanges.Add(new QuantityChangeDTO()
{
StyleId = item.StyleId ?? 0,
StyleItemId = item.StyleItemId ?? 0,
Quantity = -item.QuantityOrdered,
});
}
}
break;
case QuantityOperationType.ExchangeOnHold:
case QuantityOperationType.ReturnOnHold:
orderItems = db.Listings.GetOrderItems(OrderId);
foreach (var item in orderItems)
{
operationDto.QuantityChanges.Add(new QuantityChangeDTO()
{
StyleId = item.StyleId ?? 0,
StyleItemId = item.StyleItemId ?? 0,
Quantity = -item.QuantityOrdered,
InActive = true
});
}
break;
case QuantityOperationType.Replacement:
orderItems = db.Listings.GetOrderItems(OrderId);
foreach (var item in orderItems)
{
operationDto.QuantityChanges.Add(new QuantityChangeDTO()
{
StyleId = item.StyleId ?? 0,
StyleItemId = item.StyleItemId ?? 0,
Quantity = item.QuantityOrdered,
});
}
break;
case QuantityOperationType.Lost:
case QuantityOperationType.SoldOutside:
case QuantityOperationType.StoreManual:
case QuantityOperationType.Damaged:
case QuantityOperationType.CompensationGift:
style = db.Styles.GetActiveByStyleIdAsDto(StyleId);
if (style != null)
{
operationDto.QuantityChanges.Add(new QuantityChangeDTO()
{
StyleId = style.Id,
StyleItemId = StyleItemId ?? 0,
Quantity = Quantity ?? 0,
});
}
break;
case QuantityOperationType.InvalidBox:
style = db.Styles.GetActiveByStyleIdAsDto(StyleId);
if (style != null)
{
operationDto.QuantityChanges.Add(new QuantityChangeDTO()
{
StyleId = style.Id,
StyleItemId = StyleItemId ?? 0,
Quantity = Quantity ?? 0,
});
}
style = db.Styles.GetActiveByStyleIdAsDto(StyleIdToRemove);
if (style != null)
{
operationDto.QuantityChanges.Add(new QuantityChangeDTO()
{
StyleId = style.Id,
StyleItemId = StyleItemIdToRemove ?? 0,
Quantity = QuantityToRemove ?? 0,
});
}
break;
}
var operationId = quantityManager.AddQuantityOperation(db,
operationDto,
when,
by);
if (StyleItemId.HasValue)
{
cache.RequestStyleItemIdUpdates(db, new List <long>()
{
StyleItemId.Value
}, by);
}
if (StyleItemIdToRemove.HasValue)
{
cache.RequestStyleItemIdUpdates(db, new List <long>()
{
StyleItemIdToRemove.Value
}, by);
}
return(operationId);
}
public long Apply(IUnitOfWork db,
ICacheService cache,
IQuantityManager quantityManager,
IStyleHistoryService styleHistory,
ISystemActionService actionService,
DateTime when,
long?by)
{
var style = db.Styles.Get(StyleId);
style.UpdateDate = when;
style.UpdatedBy = by;
style.ReSaveDate = when;
style.ReSaveBy = by;
StyleViewModel.UpdateLocations(db, styleHistory, StyleId, Locations, when, by);
var wasAnyChanges = false;
if (Sizes != null && Sizes.Any())
{
var styleItems = db.StyleItems.GetFiltered(si => si.StyleId == StyleId).ToList();
var styleItemCaches = db.StyleItemCaches.GetFiltered(si => si.StyleId == StyleId).ToList();
foreach (var size in Sizes) //Update quantity (marking when/by)
{
//int? oldQuantity = null;
//int? newQuantity = null;
string tag = null;
bool wasChanged = false;
var styleItem = styleItems.FirstOrDefault(si => si.Id == size.StyleItemId);
var styleItemCache = styleItemCaches.FirstOrDefault(sic => sic.Id == size.StyleItemId);
if (styleItem != null)
{
if (size.UseBoxQuantity)
{
if (styleItem.Quantity != null)
{
var oldQuantity = styleItem.Quantity;
var newQuantity = size.BoxQuantity;
tag = size.BoxQuantitySetDate.ToString();
styleItem.Quantity = null;
styleItem.QuantitySetDate = null;
styleItem.QuantitySetBy = null;
//styleItem.RestockDate = null;
wasChanged = true;
quantityManager.LogStyleItemQuantity(db,
styleItem.Id,
newQuantity,
oldQuantity,
QuantityChangeSourceType.UseBoxQuantity,
tag,
null,
null,
when,
by);
}
}
if (size.NewRestockDate.HasValue &&
styleItem.RestockDate != size.NewRestockDate)
{
styleHistory.AddRecord(styleItem.StyleId,
StyleHistoryHelper.RestockDateKey,
DateHelper.ToDateTimeString(styleItem.RestockDate),
StringHelper.JoinTwo("-", styleItem.Size, styleItem.Color),
DateHelper.ToDateTimeString(size.NewRestockDate),
styleItem.Id.ToString(),
by);
styleItem.RestockDate = size.NewRestockDate;
wasChanged = true;
}
if (size.NewManuallyQuantity.HasValue)
{
var operationType = size.NewManuallyQuantity.Value < 0 ? QuantityOperationType.Lost : QuantityOperationType.AddManually;
var quantityOperation = new QuantityOperationDTO()
{
Type = (int)operationType,
QuantityChanges = new List <QuantityChangeDTO>()
{
new QuantityChangeDTO()
{
StyleId = style.Id,
StyleItemId = styleItem.Id,
Quantity = -1 * size.NewManuallyQuantity.Value,
//NOTE: we need to change sign to opposite because we substract quantity operataions from inventory
}
},
Comment = "From style quantity dialog",
};
quantityManager.AddQuantityOperation(db,
quantityOperation,
when,
by);
//NOTE: Hot updating the cache (only for first few seconds to display the updates before recalculation)
if (styleItemCache != null)
{
styleItemCache.SpecialCaseQuantityFromDate += -1 * size.NewManuallyQuantity.Value;
styleItemCache.TotalSpecialCaseQuantity += -1 * size.NewManuallyQuantity.Value;
}
wasChanged = true;
}
if (size.IsRemoveRestockDate == true)
{
styleItem.RestockDate = null;
wasChanged = true;
}
if (size.OnHold != styleItem.OnHold)
{
quantityManager.LogStyleItemQuantity(db,
styleItem.Id,
size.OnHold ? 0 : styleItem.Quantity,
size.OnHold ? styleItem.Quantity : 0,
QuantityChangeSourceType.OnHold,
size.OnHold.ToString(),
null,
null,
when,
by);
styleItem.OnHold = size.OnHold;
wasChanged = true;
}
}
if (wasChanged)
{
db.Commit();
wasAnyChanges = true;
}
}
}
//NOTE: always update cache
cache.RequestStyleIdUpdates(db,
new List <long>()
{
StyleId
},
UpdateCacheMode.IncludeChild,
AccessManager.UserId);
if (wasAnyChanges)
{
db.Commit();
SystemActionHelper.RequestQuantityDistribution(db, actionService, StyleId, by);
}
return(StyleId);
}
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
});
}
