public CheckResult Check(IUnitOfWork db, DTOMarketOrder order, IList <ListingOrderDTO> items)
{
var today = _time.GetAppNowTime();
var futureShipDate = items.Where(l => l.RestockDate.HasValue).Max(l => l.RestockDate);
if (futureShipDate.HasValue && futureShipDate.Value > today.Date)
{
db.OrderNotifies.Add(
ComposeNotify(order.Id,
(int)OrderNotifyType.FutureShipping,
1,
DateHelper.ToDateString(futureShipDate.Value.Date),
_time.GetAppNowTime()));
return(new CheckResult()
{
IsSuccess = false
});
}
return(new CheckResult()
{
IsSuccess = true
});
}
public void OnNotFoundAllListings(DTOMarketOrder marketOrder,
IList <ListingOrderDTO> sourceOrderItems)
{
_emailService.SendSystemEmailToAdmin(
"Listing items weren't found for order, orderId: " + marketOrder.OrderId + ", market: " + marketOrder.Market + " - " + marketOrder.MarketplaceId,
"Items: " + String.Join(",", sourceOrderItems.Select(i => "SKU: " + i.SKU).ToList()));
}
public bool CreateIfNotExistFromOrderDto(DTOMarketOrder order, DateTime when)
{
var wasCreated = false;
if (!String.IsNullOrEmpty(order.BuyerEmail))
{
var dbBuyer = GetAll().FirstOrDefault(b => b.Email == order.BuyerEmail);
if (dbBuyer != null)
{
dbBuyer.LastOrderDate = order.OrderDate;
dbBuyer.Name = order.BuyerName;
}
else
{
dbBuyer = new Buyer()
{
Email = order.BuyerEmail,
Name = order.BuyerName,
LastOrderDate = order.OrderDate,
CreateDate = when
};
Add(dbBuyer);
wasCreated = true;
}
unitOfWork.Commit();
}
return(wasCreated);
}
public CheckResult Check(IUnitOfWork db, DTOMarketOrder order, IList <ListingOrderDTO> items)
{
if (order.OrderStatus == OrderStatusEnumEx.Shipped)
{
var existHasCancellation = db.OrderNotifies.IsExist(order.Id, OrderNotifyType.CancellationRequest);
if (existHasCancellation)
{
if (!db.OrderEmailNotifies.IsExist(order.OrderId,
OrderEmailNotifyType.OutputRejectedOrderCancelledEmailToBuyer))
{
_systemAction.AddAction(db,
SystemActionType.SendEmail,
order.OrderId,
new SendEmailInput()
{
EmailType = EmailTypes.RejectOrderCancellationToBuyer,
OrderId = order.OrderId,
},
null,
null);
}
}
return(new CheckResult()
{
IsSuccess = false
});
}
return(new CheckResult()
{
IsSuccess = true
});
}
public CheckResult Check(IUnitOfWork db,
DTOMarketOrder order,
IList <ListingOrderDTO> items,
AddressValidationStatus addressValidationStatus)
{
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");
}
if (addressValidationStatus >= AddressValidationStatus.Invalid)
{
var address = order.GetAddressDto();
var isFFAddress = AddressHelper.IsFFAddress(address);
if (isFFAddress)
{
return(new CheckResult()
{
IsSuccess = true
});
}
}
return(new CheckResult()
{
IsSuccess = false
});
}
public CheckResult Check(IUnitOfWork db,
DTOMarketOrder order,
IList <ListingOrderDTO> items,
AddressValidationStatus addressValidationStatus)
{
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");
}
if (ShippingUtils.IsLatvia(order.FinalShippingCountry))
{
if ((order.ShippingZip ?? "").Contains("LV-"))
{
return(new CheckResult()
{
IsSuccess = true,
AdditionalData = new[] { (order.ShippingZip ?? "").Replace("LV-", "LV") }
});
}
}
return(new CheckResult()
{
IsSuccess = false
});
}
public CheckResult Check(IUnitOfWork db, DTOMarketOrder order)
{
//NOTE: not standard it is DHL (should be w/o insurance)
if (order.InitialServiceType != ShippingUtils.StandardServiceName)
{
return(new CheckResult()
{
IsSuccess = false
});
}
var countryName = order.ShippingCountry;
var country = db.Countries.GetFiltered(c => c.CountryCode2 == countryName)
.FirstOrDefault();
var isInusred = country != null && country.IsInsure;
if (isInusred)
{
_log.Info("Insured by Country Code");
}
return(new CheckResult()
{
IsSuccess = isInusred
});
}
public CheckResult Check(IUnitOfWork db, DTOMarketOrder marketOrder)
{
return(new CheckResult()
{
IsSuccess = marketOrder.OrderType == (int)OrderTypeEnum.Prime
});
}
public IList <BuyerBlackListDto> GetSimular(DTOMarketOrder order)
{
var query = from b in unitOfWork.GetSet <ViewBuyerBlackList>()
where b.BuyerEmail == order.BuyerEmail
select b;
return(AsDto(query).ToList());
}
public bool CreateIfNotExistFromOrderDto(DTOMarketOrder order, DateTime when)
{
var customer = order.GetCustomerInfo();
var result = CreateIfNotExistOrUpdate(customer);
order.CustomerId = customer.Id;
return(result);
}
public void ShippingValidationStep(IUnitOfWork db,
IList <ListingOrderDTO> orderItems,
IList <ListingOrderDTO> sourceOrderItems,
IList <OrderShippingInfoDTO> shippings,
DTOMarketOrder marketOrder,
Order dbOrder)
{
var exceededChecker = new ExceededShippingCostChecker(_log,
_actionService,
_priceService,
_stampsRateApi,
_returnAddress,
_time);
var resultIsExceededShippingCost = exceededChecker.Check(db,
dbOrder.Id,
sourceOrderItems,
shippings,
marketOrder);
exceededChecker.ProcessResult(resultIsExceededShippingCost, db, dbOrder);
var lowerPriceChecker = new LowerItemPriceChecker(_log,
new PriceService(_dbFactory),
_time);
var resultIsLowerItemPrice = lowerPriceChecker.Check(db,
dbOrder.Id,
sourceOrderItems,
shippings,
marketOrder);
lowerPriceChecker.ProcessResult(resultIsExceededShippingCost, db, dbOrder);
var primeChecker = new PrimeShippingChecker(_log,
_emailService,
_time);
var resultPrimeShipping = primeChecker.Check(db,
dbOrder.Id,
orderItems,
shippings,
marketOrder);
primeChecker.ProcessResult(resultPrimeShipping, db, dbOrder);
var replacePhoneChecker = new ReplacePhoneChecker(_log,
_emailService,
_time,
_company);
var resultReplacePhone = replacePhoneChecker.Check(db,
marketOrder,
orderItems);
replacePhoneChecker.ProcessResult(resultReplacePhone, dbOrder);
}
public CheckResult Check(IUnitOfWork db, DTOMarketOrder order, IList <ListingOrderDTO> items)
{
var result = DuplicateValidatorCheck(db, order, items);
_log.Info("CheckDuplicate, result=" + result.IsSuccess + ", message=" + result.Message);
if (!result.IsSuccess)
{
db.OrderNotifies.Add(
ComposeNotify(order.Id,
(int)OrderNotifyType.Duplicate,
1,
result.Message,
_time.GetAppNowTime()));
db.Commit();
var emailInfo = new DuplicateEmailInfo(_emailService.AddressService,
order.CustomerOrderId,
(MarketType)order.Market,
new DuplicateOrdersDTO
{
Items = items,
OrderNumbers = result.AdditionalData
},
order.BuyerName,
order.BuyerEmail);
_emailService.SendEmail(emailInfo, CallSource.Service);
_log.Info("Send duplicated order email, orderId=" + order.Id);
db.OrderEmailNotifies.Add(new OrderEmailNotify()
{
OrderNumber = order.OrderId,
Reason = "System emailed, found duplicate",
Type = (int)OrderEmailNotifyType.OutputDuplicateAlertEmail,
CreateDate = _time.GetUtcTime(),
});
db.OrderComments.Add(new OrderComment()
{
OrderId = order.Id,
Message = "[System] Duplicate order alert email sent",
Type = (int)CommentType.OutputEmail,
CreateDate = _time.GetAppNowTime(),
UpdateDate = _time.GetAppNowTime()
});
db.Commit();
}
return(result);
}
public void OrderValidationStepAlwaysInitial(IUnitOfWork db,
ITime time,
DTOMarketOrder marketOrder,
IList <ListingOrderDTO> orderItems,
Order dbOrder)
{
var upgradeShippingService = new UpgradeShippingServiceChecker(_log, _time);
var result = upgradeShippingService.Check(db, marketOrder, orderItems);
upgradeShippingService.ProcessResult(result, dbOrder);
db.Commit();
}
public void OrderValidationStepAlways(IUnitOfWork db,
ITime time,
IMarketApi api,
CompanyDTO company,
DTOMarketOrder marketOrder,
IList <ListingOrderDTO> orderItems,
IList <OrderShippingInfoDTO> shippings,
Order dbOrder)
{
var hasCancellationChecker = new HasCancellationChecker(_log, _actionService, _time);
var result = hasCancellationChecker.Check(db, marketOrder, orderItems);
hasCancellationChecker.ProcessResult(result, dbOrder);
}
public void OrderValidationStepFinal(IUnitOfWork db,
ITime time,
CompanyDTO company,
DTOMarketOrder marketOrder,
IList <ListingOrderDTO> orderItems,
IList <OrderShippingInfoDTO> shippings,
Order dbOrder)
{
//NOTE: Disabled auto set signature confirmation
//var signConfirmationSendEmailChecker = new SignConfirmationSendEmailChecker(_log, db, _emailService, _time);
//var result = signConfirmationSendEmailChecker.Check(marketOrder,
// dbOrder,
// orderItems,
// shippings);
//signConfirmationSendEmailChecker.ProcessResult(result, dbOrder, marketOrder, orderItems);
}
public CheckResult Check(IUnitOfWork db, DTOMarketOrder order)
{
var result = BlackListValidatorCheck(db, order);
if (result.IsSuccess)
{
db.OrderNotifies.Add(
ComposeNotify(order.Id,
(int)OrderNotifyType.BlackList,
1,
result.Message,
_time.GetAppNowTime()));
db.Commit();
}
return(result);
}
private CheckResult BlackListValidatorCheck(IUnitOfWork db, DTOMarketOrder order)
{
var blackListRecords = db.BuyerBlackLists.GetSimular(order);
if (blackListRecords.Any())
{
return new CheckResult()
{
IsSuccess = true,
Message = blackListRecords[0].OrderId
}
}
;
return(new CheckResult()
{
IsSuccess = false
});
}
public CheckResult Check(DTOMarketOrder order, IList<ListingOrderDTO> items)
{
//NOTE: Temp disabled currenlty no need
//var address = order.GetAddressDto();
////if ((order.ShipmentProviderType == (int)ShipmentProviderType.Stamps
//// || order.ShipmentProviderType == (int)ShipmentProviderType.Amazon)
// //|| order.ShipmentProviderType == (int)ShipmentProviderType.None)
// //&& !String.IsNullOrEmpty(address.FinalCountry)
// //&& !ShippingUtils.IsInternational(address.FinalCountry)
// //&& ShippingUtils.IsServiceSameDay(order.InitialServiceType))
//{
// var sum = items.Sum(i => i.ItemPrice - (i.PromotionDiscount ?? 0));
// var currency = PriceHelper.GetCurrencyAbbr((MarketType)order.Market, order.MarketplaceId);
// var sumInUSD = PriceHelper.ConvertToUSD(sum, currency);
// if (sumInUSD > 200)
// return new CheckResult() { IsSuccess = true };
//}
return new CheckResult() { IsSuccess = false };
}
public CheckResult Check(DTOMarketOrder order)
{
CheckResult result = new CheckResult()
{
IsSuccess = false
};
var serviceType = order.InitialServiceType;
if (ShippingUtils.IsServiceSameDay(serviceType))
{
return(new CheckResult()
{
IsSuccess = true
});
}
return(result);
}
public CheckResult Check(IUnitOfWork db,
DTOMarketOrder marketOrder,
IList <ListingOrderDTO> orderItems)
{
if (marketOrder.ShipmentProviderType == (int)ShipmentProviderType.Dhl)
{
if (orderItems.All(i => i.Weight > 0) &&
orderItems.Sum(i => i.Weight) > 48) //3Lb
{
return(new CheckResult()
{
IsSuccess = true
});
}
}
return(new CheckResult()
{
IsSuccess = false
});
}
public CheckResult Check(IUnitOfWork db,
DTOMarketOrder order,
IList <ListingOrderDTO> orderItems)
{
var canUpgrade = false;
if (orderItems != null && orderItems.Any(oi => oi.OnMarketTemplateName == AmazonTemplateHelper.OversizeTemplate) &&
order.InitialServiceType == ShippingUtils.StandardServiceName &&
(order.Market == (int)MarketType.Amazon ||
order.Market == (int)MarketType.AmazonAU ||
order.Market == (int)MarketType.AmazonEU))
{
order.InitialServiceType = ShippingUtils.ExpeditedServiceName;
canUpgrade = true;
}
return(new CheckResult()
{
IsSuccess = canUpgrade
});
}
public CheckResult Check(DTOMarketOrder order)
{
CheckResult result = new CheckResult()
{
IsSuccess = false
};
var serviceType = order.InitialServiceType;
if ((ShippingUtils.IsServiceTwoDays(serviceType) ||
ShippingUtils.IsServiceNextDay(serviceType)) &&
ShippingUtils.IsInternational(order.ShippingCountry))
{
return(new CheckResult()
{
IsSuccess = true
});
}
return(result);
}
public CheckResult Check(IUnitOfWork db,
DTOMarketOrder order,
IList <ListingOrderDTO> items)
{
if (order.Id == 0)
{
throw new ArgumentOutOfRangeException("order.Id", "Should be non zero");
}
if (order.OrderStatus != OrderStatusEnumEx.Pending)
{
if (order.ShipmentProviderType == (int)ShipmentProviderType.FedexOneRate)
{
if (String.IsNullOrEmpty(order.FinalShippingPhone))
{
if (order.IsManuallyUpdated)
{
order.ManuallyShippingPhone = _company.Phone;
}
else
{
order.ShippingPhone = _company.Phone;
}
return(new CheckResult()
{
IsSuccess = true,
AdditionalData = new List <string>()
{
_company.Phone
}
});
}
}
}
return(new CheckResult()
{
IsSuccess = false
});
}
private CheckResult DuplicateValidatorCheck(IUnitOfWork db, DTOMarketOrder marketOrder, IList <ListingOrderDTO> orderItems)
{
var duplicateOrders = new List <string>();
var orderWithSameBuyer = db.Orders.GetOrdersWithSimilarDateAndBuyerAndAddress(marketOrder);
if (orderWithSameBuyer.Any())
{
_log.Info("Similar orders, count=" + orderWithSameBuyer.Count);
foreach (var order in orderWithSameBuyer)
{
var items = db.Listings.GetOrderItems(order.Id);
if (items.Any() && items.Count == orderItems.Count)
{
if (orderItems.All(oItem => items.Any(i => i.ListingId == oItem.ListingId)))
{
duplicateOrders.Add(order.OrderId);
break;
}
if (orderItems.All(oItem => items.Any(i => i.StyleItemId == oItem.StyleItemId)))
{
duplicateOrders.Add(order.OrderId);
break;
}
}
}
}
if (duplicateOrders.Any())
{
_log.Info("Possible duplicates for order: " + marketOrder.OrderId + "; duplicates: " + string.Join(", ", duplicateOrders));
}
return(new CheckResult()
{
IsSuccess = !duplicateOrders.Any(),
Message = duplicateOrders.Any() ? duplicateOrders[0] : String.Empty,
AdditionalData = duplicateOrders
});
}
public IList <DTOOrder> GetOrdersWithSimilarDateAndBuyerAndAddress(DTOMarketOrder orderDto)
{
if (orderDto == null)
{
throw new ArgumentNullException("orderDto");
}
var fromDate = orderDto.OrderDate.Value.AddHours(-24);
var toDate = orderDto.OrderDate.Value.AddHours(24);
//1. Retriving similar orders. Сравниваем по имени, адресу доставки, заказанной пижаме, размер
var query = from o in unitOfWork.Orders.GetAll()
where o.OrderDate > fromDate &&
o.OrderDate < toDate &&
o.OrderStatus != OrderStatusEnumEx.Canceled &&
o.OrderStatus != OrderStatusEnumEx.Pending
//&& o.OrderStatus.ToLower() == "unshipped" &&
&& o.PersonName == orderDto.PersonName &&
o.ShippingCountry == orderDto.ShippingCountry &&
o.ShippingAddress1 == orderDto.ShippingAddress1 &&
o.ShippingAddress2 == orderDto.ShippingAddress2 &&
o.ShippingCity == orderDto.ShippingCity &&
o.ShippingState == orderDto.ShippingState &&
o.ShippingZip == orderDto.ShippingZip &&
o.ShippingZipAddon == orderDto.ShippingZipAddon &&
o.ShippingPhone == orderDto.ShippingPhone &&
o.AmazonIdentifier != orderDto.OrderId //exclude itself
select new DTOOrder
{
Id = o.Id,
OrderId = o.AmazonIdentifier,
OrderStatus = o.OrderStatus,
OrderDate = o.OrderDate
};
return(query.ToList());
}
public CheckResult Check(IUnitOfWork db,
DTOMarketOrder order,
IList <ListingOrderDTO> items,
AddressValidationStatus addressValidationStatus)
{
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");
}
if (ShippingUtils.IsCanada(order.FinalShippingCountry))
{
var state = order.FinalShippingState;
if ((state ?? "").Length > 2)
{
var stateAbbr = db.States.GetCodeByName(state);
if (!String.IsNullOrEmpty(stateAbbr))
{
return(new CheckResult()
{
IsSuccess = true,
AdditionalData = new[] { stateAbbr }
});
}
}
}
return(new CheckResult()
{
IsSuccess = false
});
}
public CheckResult Check(IUnitOfWork db,
long orderId,
IList <ListingOrderDTO> orderItems,
IList <OrderShippingInfoDTO> shippings,
DTOMarketOrder marketOrder)
{
if (!orderItems.Any() || !shippings.Any())
{
return new CheckResult()
{
IsSuccess = false
}
}
;
if (marketOrder.UpgradeLevel > 0)
{
return new CheckResult()
{
IsSuccess = false
}
}
;
if (marketOrder.Market == (int)MarketType.Groupon)
{
return new CheckResult()
{
IsSuccess = false
}
}
;
CultureInfo culture = CultureInfo.CreateSpecificCulture("en-US");
culture.NumberFormat.CurrencyNegativePattern = 1;
decimal paidShppingCost = orderItems.Sum(i => i.ShippingPrice);
string currency = orderItems.First().ShippingPriceCurrency;
paidShppingCost = PriceHelper.RougeConvertToUSD(currency, paidShppingCost);
if (marketOrder.OrderType == (int)OrderTypeEnum.Prime)
{
paidShppingCost += orderItems.Sum(oi => AmazonPrimeHelper.GetShippingAmount(oi.Weight));
}
decimal?actualShippingsCost = null;
if (shippings != null && shippings.Any(sh => sh.IsActive))
{
actualShippingsCost = shippings.Where(sh => sh.IsActive &&
sh.ShippingMethodId != ShippingUtils.FedexSmartPost).Sum(sh => sh.StampsShippingCost ?? 0);
}
_log.Info("CheckIsExceededShippingCost: paid=" + paidShppingCost + " < actual=" + actualShippingsCost);
if (shippings != null)
{
//"Excessive shipping cost. Because priority flat went up I get lots of “excesive” in cases like. We need to ignore those cases…"
var activeShipping = shippings.FirstOrDefault(sh => sh.IsActive);
if (activeShipping != null &&
activeShipping.ShippingMethod != null &&
activeShipping.ShippingMethod.Id == ShippingUtils.PriorityFlatShippingMethodId)
{
return new CheckResult()
{
IsSuccess = false
}
}
;
}
#region New Checking
//price/1.17-shipping price-product cost-2 > -exc
if (actualShippingsCost != null)
{
decimal totalThreashold = 0;
decimal totalCost = 0;
bool allHaveCost = true;
foreach (var item in orderItems)
{
decimal?styleThreashold = null;
if (item.StyleId.HasValue)
{
var featureValue = db.StyleFeatureTextValues.GetFeatureValueByStyleIdByFeatureId(
item.StyleId.Value, StyleFeatureHelper.EXCESSIVE_SHIPMENT);
if (featureValue != null && !String.IsNullOrEmpty(featureValue.Value))
{
styleThreashold = StringHelper.TryGetDecimal(featureValue.Value);
}
var cost = db.StyleItemCaches.GetAllAsDto().Select(i => new { i.Id, i.Cost }).FirstOrDefault(i => i.Id == item.StyleItemId)?.Cost;
if (cost.HasValue)
{
totalCost += cost.Value * item.QuantityOrdered;
}
else
{
allHaveCost = false;
}
}
if (styleThreashold.HasValue)
{
totalThreashold += styleThreashold.Value * item.QuantityOrdered;
}
}
if (allHaveCost)
{
var totalPaid = PriceHelper.RougeConvertToUSD(currency, orderItems.Sum(i => i.ShippingPrice + i.ItemPrice));
//Please ignore income disparity<1 like 180-111-825-1659 / 381-205-041-7263
if (totalThreashold < 1)
{
totalThreashold = 1;
}
var isValid = totalPaid / 1.17M - actualShippingsCost - totalCost - 2 > -totalThreashold;
if (!isValid)
{
var excpectIncome = totalPaid / 1.17M - actualShippingsCost.Value - totalCost - 2;
_log.Info(String.Format("Added Income disparity, income: {0}, totalPaid: {1}, actualShippingCost: {2}, totalCost: {3}",
excpectIncome.ToString("C", culture),
totalPaid,
actualShippingsCost,
totalCost));
var message = String.Format("Income disparity, income: {0}",
excpectIncome.ToString("C", culture));
db.OrderComments.Add(new OrderComment()
{
OrderId = orderId,
Message = message,
Type = (int)CommentType.System,
CreateDate = _time.GetAppNowTime(),
});
db.Commit();
return(new CheckResult()
{
IsSuccess = true
});
}
}
}
#endregion
#region Old Checking
//TASK: When order has 2 robes, and they sent as 2 First class (like 102-1792536-3635439) don’t show Excess ship. cost
if (shippings.Where(sh => sh.IsActive).All(sh => sh.ShippingMethodId == ShippingUtils.AmazonFirstClassShippingMethodId ||
sh.ShippingMethodId == ShippingUtils.FirstClassShippingMethodId ||
sh.ShippingMethodId == ShippingUtils.DhlEComSMParcelGroundShippingMethodId ||
sh.ShippingMethodId == ShippingUtils.DhlEComSMParcelExpeditedShippingMethodId))
{
if (orderItems.All(
i => ItemStyleHelper.GetFromItemStyleOrTitle(i.ItemStyle, i.Title) == ItemStyleType.Robe))
{
return(new CheckResult()
{
IsSuccess = false
});
}
}
//NOTE: used default threashold: $1
//NOTE: if price disparity <$2 it's ok
var threshold = 2.0M;
//TASK: When order has 2 or more items and service "Standard" made threashold $2
if (orderItems.Sum(oi => oi.QuantityOrdered) >= 2 &&
ShippingUtils.IsServiceStandard(marketOrder.InitialServiceType))
{
threshold = 2.5M;
}
var withEmptyThreashold = 0;
var withNotEmptyThreashold = 0;
foreach (var item in orderItems)
{
decimal?styleThreashold = null;
if (item.StyleId.HasValue)
{
var featureValue = db.StyleFeatureTextValues.GetFeatureValueByStyleIdByFeatureId(
item.StyleId.Value, StyleFeatureHelper.EXCESSIVE_SHIPMENT);
if (featureValue != null && !String.IsNullOrEmpty(featureValue.Value))
{
styleThreashold = StringHelper.TryGetDecimal(featureValue.Value);
}
}
if (styleThreashold.HasValue)
{
threshold += styleThreashold.Value * item.QuantityOrdered;
withNotEmptyThreashold++;
}
else
{
withEmptyThreashold++;
}
}
//if (withEmptyThreashold > 0)
// threshold += 1.0M;
//if (withNotEmptyThreashold == 0)
// threshold = 1.0M;
if (actualShippingsCost > 0 && paidShppingCost > 0 && paidShppingCost + threshold < actualShippingsCost)
{
bool isOverchargeSkipped = false;
decimal totalIntlListingPriceInUSD = 0M;
decimal totalUsListingPrice = 0;
if (ShippingUtils.IsInternational(marketOrder.FinalShippingCountry))
{
#region Calc US Shipping Cost
decimal?actualUsShippingCost = 0M;
var shippingService = ShippingUtils.StandardServiceName; //ShippingUtils.InitialShippingServiceIncludeUpgrade(marketOrder.InitialServiceType.Replace("i:", ""), //convert to local
//marketOrder.UpgradeLevel);
decimal?paidUsShippingCost = ShippingUtils.GetRougePaidUSShippingAmount(shippingService, orderItems.Sum(i => i.QuantityOrdered));
var usRates = RateHelper.GetRougeChipestUSRate(_log,
_stampsRateProvider,
_fromAddress,
marketOrder,
shippingService,
orderItems,
orderItems);
if (usRates.Any())
{
actualUsShippingCost = usRates.Sum(r => r.Amount);
}
#endregion
foreach (var orderItem in orderItems)
{
totalIntlListingPriceInUSD += PriceHelper.RougeConvertToUSD(orderItem.ItemPriceCurrency, orderItem.ItemPrice);
var usListingPrice = GetUSListingPrice(db, orderItem);
if (usListingPrice == null)
{
totalUsListingPrice = 0;
break;
}
totalUsListingPrice += (usListingPrice * orderItem.QuantityOrdered) ?? 0;
}
decimal?usEarnedValue = ((totalUsListingPrice) + (paidUsShippingCost ?? 0) - (actualUsShippingCost ?? 0));
decimal?marketEarnedValue = (totalIntlListingPriceInUSD + paidShppingCost - actualShippingsCost.Value);
decimal?howMachEarnedValue = null;
if (actualUsShippingCost.HasValue &&
paidUsShippingCost.HasValue &&
totalUsListingPrice > 0 &&
actualShippingsCost.HasValue)
{
howMachEarnedValue = (totalIntlListingPriceInUSD + paidShppingCost - actualShippingsCost.Value) -
//how much we have earned now
(totalUsListingPrice + paidUsShippingCost.Value - actualUsShippingCost.Value); //how much we have earned if we sell it in US
isOverchargeSkipped = howMachEarnedValue > -threshold; //NOTE: Threashold
}
if (!isOverchargeSkipped)
{
//var message = internationalOverchargeSkip ? "No Excessive Shipping cost" : "Excessive Shipping cost";
var message = "";
if (totalUsListingPrice > 0)
{
message = String.Format("Income disparity: {0}+{1}-{2}={3} vs {4} => income diff.: {5}",
//MarketHelper.GetShortName((int)marketOrder.Market, marketOrder.MarketplaceId),
(totalUsListingPrice).ToString("C", culture),
(paidUsShippingCost ?? 0).ToString("C", culture),
(actualUsShippingCost ?? 0).ToString("C", culture),
usEarnedValue?.ToString("C", culture),
marketEarnedValue?.ToString("C", culture),
(howMachEarnedValue ?? 0).ToString("C", culture));
}
else
{
isOverchargeSkipped = true; //SKIP
message = "Excessive Shipping validation: no similar US listing";
}
db.OrderComments.Add(new OrderComment()
{
OrderId = orderId,
Message = message,
Type = (int)CommentType.System,
CreateDate = _time.GetAppNowTime(),
});
db.Commit();
}
}
else
{
//сделай пока $3.02 threashold
var localThreshold = Math.Max(threshold, 3.02M);
if (paidShppingCost + localThreshold < actualShippingsCost)
{
var message = String.Format("Paid shipping ({0}) lower shipping cost ({1}) more than threshold ({2})",
(paidShppingCost).ToString("C", culture),
(actualShippingsCost ?? 0).ToString("C", culture),
(localThreshold).ToString("C", culture));
db.OrderComments.Add(new OrderComment()
{
OrderId = orderId,
Message = message,
Type = (int)CommentType.System,
CreateDate = _time.GetAppNowTime(),
});
}
else
{
//NOTE: Temp Do Nothing
isOverchargeSkipped = true;
}
}
if (!isOverchargeSkipped)
{
db.OrderNotifies.Add(
ComposeNotify(orderId,
(int)OrderNotifyType.OverchargedShpppingCost,
1,
paidShppingCost + "<" + actualShippingsCost,
_time.GetAppNowTime()));
db.Commit();
}
if (!isOverchargeSkipped)
{
foreach (var orderItem in orderItems)
{
if (orderItem.SourceListingId.HasValue)
{
var listing = db.Listings.Get(orderItem.SourceListingId.Value);
if (listing != null)
{
SystemActionHelper.RequestPriceRecalculation(db, _actionService, listing.Id, null);
if (listing.Market == (int)MarketType.Walmart) //NOTE: need to update Second Day flag
{
SystemActionHelper.RequestItemUpdate(db, _actionService, listing.Id, null);
}
}
}
}
}
return(new CheckResult()
{
IsSuccess = !isOverchargeSkipped
});
}
#endregion
return(new CheckResult()
{
IsSuccess = false
});
}
public CheckResult Check(IUnitOfWork db,
DTOMarketOrder order,
IList <ListingOrderDTO> items,
AddressValidationStatus addressValidationStatus)
{
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");
}
if (order.IsManuallyUpdated)
{
order.ManuallyPersonName = ReplaceFrench(order.ManuallyPersonName);
}
else
{
order.PersonName = ReplaceFrench(order.PersonName);
}
if (order.IsManuallyUpdated)
{
order.ManuallyShippingAddress1 = ReplaceFrench(order.ManuallyShippingAddress1);
}
else
{
order.ShippingAddress1 = ReplaceFrench(order.ShippingAddress1);
}
if (order.IsManuallyUpdated)
{
order.ManuallyShippingAddress2 = ReplaceFrench(order.ManuallyShippingAddress2);
}
else
{
order.ShippingAddress2 = ReplaceFrench(order.ShippingAddress2);
}
if (order.IsManuallyUpdated)
{
order.ManuallyShippingState = ReplaceFrench(order.ManuallyShippingState);
}
else
{
order.ShippingState = ReplaceFrench(order.ShippingState);
}
if (order.IsManuallyUpdated)
{
order.ManuallyShippingCity = ReplaceFrench(order.ManuallyShippingCity);
}
else
{
order.ShippingCity = ReplaceFrench(order.ShippingCity);
}
return(new CheckResult()
{
IsSuccess = false
});
}
public Order CreateFromDto(DTOMarketOrder dto, DateTime?when)
{
var order = new Order
{
Market = dto.Market,
SalesChannel = dto.SalesChannel,
MarketplaceId = dto.MarketplaceId,
FulfillmentChannel = dto.FulfillmentChannel,
AmazonIdentifier = dto.OrderId,
MarketOrderId = dto.MarketOrderId,
CustomerOrderId = dto.CustomerOrderId,
SalesRecordNumber = dto.SalesRecordNumber,
SubOrderNumber = dto.SubOrderNumber,
SubOrderAmountPercent = dto.SubOrderAmountPercent,
DropShipperId = dto.DropShipperId,
AutoDSSelection = dto.AutoDSSelection,
PaymentMethod = dto.PaymentMethod,
PaymentInfo = dto.PaymentInfo,
DiscountAmount = dto.DiscountAmount,
DiscountDesc = dto.DiscountDesc,
TaxAmount = dto.TaxAmount,
TaxRate = dto.TaxRate,
DiscountTax = dto.DiscountTax,
ShippingTaxAmount = dto.ShippingTaxAmount,
OrderType = dto.OrderType,
OrderStatus = dto.OrderStatus,
OrderDate = dto.OrderDate,
EarliestShipDate = dto.EarliestShipDate,
LatestShipDate = dto.LatestShipDate,
EstDeliveryDate = dto.EarliestDeliveryDate,
LatestDeliveryDate = dto.LatestDeliveryDate,
PersonName = dto.PersonName,
TotalPaid = dto.TotalPaid,
ShippingPaid = dto.ShippingPaid,
TotalPrice = dto.TotalPrice,
TotalPriceCurrency = dto.TotalPriceCurrency,
ShippingPrice = dto.ShippingPrice,
ShippingDiscountAmount = dto.ShippingDiscountAmount,
Quantity = dto.Quantity,
BuyerName = dto.BuyerName,
BuyerEmail = dto.BuyerEmail,
ShippingCountry = dto.ShippingCountry,
ShippingAddress1 = dto.ShippingAddress1,
ShippingAddress2 = dto.ShippingAddress2,
ShippingCity = dto.ShippingCity,
ShippingState = dto.ShippingState,
ShippingZip = dto.ShippingZip,
ShippingZipAddon = dto.ShippingZipAddon,
ShippingPhone = dto.ShippingPhone,
AddressValidationStatus = dto.AddressValidationStatus,
ShippingCalculationStatus = 0,
InitialServiceType = dto.InitialServiceType,
ShipmentProviderType = dto.ShipmentProviderType,
SourceOrderStatus = dto.SourceOrderStatus,
SourceShippingService = dto.SourceShippingService,
SourceShippedDate = dto.SourceShippedDate,
PaidDate = dto.PaidDate,
MarketLastUpdatedDate = dto.MarketLastUpdatedDate,
IsSignConfirmation = dto.IsSignConfirmation,
IsInsured = dto.IsInsured,
OnHold = dto.OnHold,
CreateDate = when,
UpdateDate = when
};
Add(order);
unitOfWork.Commit();
return(order);
}
public CheckResult Check(IUnitOfWork db,
DTOMarketOrder order,
IList <ListingOrderDTO> items,
AddressValidationStatus addressValidationStatus)
{
//NOTE: Skipping valid addresses
if (addressValidationStatus < AddressValidationStatus.Invalid)
{
return(new CheckResult()
{
IsSuccess = true
});
}
var checkUSPSService = new PersonatorAddressCheckService(_log, _htmlScraper, null);
var address = order.GetAddressDto();
var addressCheckResult = checkUSPSService.ScrappingCheckAddress(address);
var result = new CheckResult()
{
IsSuccess = !addressCheckResult.IsNotServedByUSPSNote
};
_log.Info("AddressNotServedByUSPSChecker, hasNote=" + addressCheckResult.IsNotServedByUSPSNote);
if (addressCheckResult.IsNotServedByUSPSNote)
{
var existNotifier = db.OrderEmailNotifies.IsExist(order.OrderId,
OrderEmailNotifyType.OutputAddressNotServedByUSPSEmail);
if (!existNotifier)
{
var emailInfo = new AddressNotServedByUSPSEmailInfo(_emailService.AddressService,
null,
order.OrderId,
(MarketType)order.Market,
address,
order.BuyerName,
order.BuyerEmail,
order.EarliestShipDate ?? (order.OrderDate ?? DateTime.Today).AddDays(1));
_emailService.SendEmail(emailInfo, CallSource.Service);
_log.Info("Send address not served by USPS email, orderId=" + order.Id);
db.OrderEmailNotifies.Add(new OrderEmailNotify()
{
OrderNumber = order.OrderId,
Reason = "Address isn’t served by USPS",
Type = (int)OrderEmailNotifyType.OutputAddressNotServedByUSPSEmail,
CreateDate = _time.GetUtcTime(),
});
}
db.OrderComments.Add(new OrderComment()
{
OrderId = order.Id,
Message = "Address isn’t served by USPS. Address verification email sent.",
Type = (int)CommentType.OutputEmail,
CreateDate = _time.GetAppNowTime(),
UpdateDate = _time.GetAppNowTime()
});
db.Commit();
}
return(result);
}
