private static Dictionary <int, PurchasingLimits_V01> GetPurchasingLimitsFromRulesEngine(string distributorId,
string TIN)
{
if (string.IsNullOrEmpty(distributorId))
{
return(null);
}
else
{
try
{
var purchasingLimits =
HLRulesManager.Manager.GetPurchasingLimits(distributorId, TIN);
if (purchasingLimits != null)
{
savePurchasingLimitsToCache(purchasingLimits, distributorId);
}
return(purchasingLimits);
}
catch (Exception ex)
{
LoggerHelper.Error(
string.Format("Error updating Purchasing Limits for distributor: {0}\r\n{1}", distributorId,
ex.Message));
}
}
return(null);
}
public bool SetFavouriteSKUs(SetFavouriteParam request, ref List <ValidationErrorViewModel> errors)
{
bool result = false;
if (string.IsNullOrWhiteSpace(request.Locale) ||
string.IsNullOrWhiteSpace(request.DistributorID) ||
string.IsNullOrWhiteSpace(request.SKUList)
)
{
return(result);
}
try
{
result = _favorLoader.SetFavouriteSKUList(request.DistributorID, request.Locale, request.SKUList);
return(result);
}
catch (Exception ex)
{
errors.Add(
new ValidationErrorViewModel
{
Code = 999998,
Reason = string.Format("MobileFavouriteSKUProvider update error", ex.Message)
});
LoggerHelper.Error(string.Format("MobileFavouriteSKUProvider : {0}\n {1}\n", ex.Message, ex.StackTrace));
return(result);
}
}
private List <ItemTaxRate> GetItemTaxRatesFromCache(string countryCode)
{
var request = new GetTaxItemRateRequestV01 {
CountryCode = countryCode
};
try
{
var proxy = ServiceClientProvider.GetCustomerOrderServiceProxy();
var response = proxy.GetTaxItemRate(new GetTaxItemRateRequest1(request)).GetTaxItemRateResult;
if (null != response && response.Status == ServiceProvider.CustomerOrderSvc.ServiceResponseStatusType.Success)
{
var responseV01 = response as GetTaxItemRateResponse_V01;
if (null != responseV01 && responseV01.ItemTaxRates.Any())
{
return(responseV01.ItemTaxRates);
}
}
LoggerHelper.Error("Invoice Customer pricing GetItemTaxRatesFromTableStorage return null");
return(new List <ItemTaxRate>());
}
catch (Exception ex)
{
LoggerHelper.Error(
string.Format(
"OrderService - InvoiceProvider: An error occured while Calling GetTaxDataForDwsFromVertex service method {0}",
ex.Message));
}
return(new List <ItemTaxRate>());
}
protected override ShoppingCartRuleResult PerformRules(ShoppingCart_V02 cart, ShoppingCartRuleReason reason,
ShoppingCartRuleResult Result)
{
if (reason == ShoppingCartRuleReason.CartItemsBeingAdded)
{
var myhlCart = cart as MyHLShoppingCart;
if (null == myhlCart)
{
LoggerHelper.Error(
string.Format("{0} myhlCart is null {1}", Locale, cart.DistributorID));
Result.Result = RulesResult.Failure;
return(Result);
}
// to set purchasing limit type
var theLimits = GetPurchasingLimits(cart.DistributorID, myhlCart.SelectedDSSubType ?? string.Empty);
var currentLimits = theLimits[PurchasingLimitProvider.GetOrderMonth()];
if (currentLimits.PurchaseLimitType == PurchaseLimitType.Earnings)
{
var itemsToCalc = new List <ShoppingCartItem_V01>();
itemsToCalc.AddRange(myhlCart.CartItems);
if (myhlCart.CurrentItems != null && myhlCart.CurrentItems.Count > 0)
{
itemsToCalc.Add(myhlCart.CurrentItems[0]);
}
OrderTotals_V01 orderTotals = myhlCart.Calculate(itemsToCalc) as OrderTotals_V01;
if (orderTotals != null && orderTotals.DiscountPercentage != 0.0M)
{
myhlCart.SetDiscountForLimits(orderTotals.DiscountPercentage);
myhlCart.Totals = orderTotals;
}
}
}
return(base.PerformRules(cart, reason, Result));
}
public PurchasingLimits ReloadPurchasingLimits(int orderMonth)
{
PurchasingLimits_V01 purchasingLimitsV01 = null;
try
{
if (PurchasingLimitProvider.RequirePurchasingLimits(_distributorId, _currentLoggedInCountry))
{
CreatePurchasingLimits(GetDistributorPurchasingLimitsCollection());
}
if (PurchasingLimits == null)
{
return(purchasingLimitsV01);
}
if (orderMonth > 0)
{
SetPurchasingLimits(orderMonth);
}
SaveToCache();
}
catch (Exception ex)
{
LoggerHelper.Error(ex.ToString());
}
if (PurchasingLimits != null)
{
PurchasingLimits.TryGetValue(orderMonth, out purchasingLimitsV01);
}
return(purchasingLimitsV01);
}
private static void Save3DPaymentAfterEnrollment(string orderNumber, string distributorId, string locale, ThreeDSecuredCreditCard threeDCard)
{
if (null == threeDCard)
{
return;
}
var data = SerializeObject(threeDCard, typeof(ThreeDSecuredCreditCard));
if (threeDCard.IsErrored)
{
OrderProvider.InsertPaymentGatewayRecord(orderNumber, distributorId, "3DSecuredEnrollmentAuthentication", "3D credit card Enrollment Check has error -- Declined", locale);
OrderProvider.UpdatePaymentGatewayRecord(orderNumber, string.Concat("3D credit card Enrollment Check has error -- Declined", data),
PaymentGatewayLogEntryType.Response, PaymentGatewayRecordStatusType.InError);
LoggerHelper.Error(string.Format("Order payment error when calling 3D Payment Enrollment service:{0} Error : {1}",
orderNumber, "3D Payment Enrollment service rturned invalid status"));
}
else if (threeDCard.IsDeclined)
{
OrderProvider.InsertPaymentGatewayRecord(orderNumber, distributorId, "3DSecuredEnrollmentAuthentication", "3D credit card Enrollment Check received Declined", locale);
OrderProvider.UpdatePaymentGatewayRecord(orderNumber, string.Concat("3D credit card Enrollment Check received Declined", data),
PaymentGatewayLogEntryType.Response, PaymentGatewayRecordStatusType.Declined);
}
else if (threeDCard.IsEnrolled)
{
OrderProvider.InsertPaymentGatewayRecord(orderNumber, distributorId, "3DSecuredEnrollmentAuthentication", "3D credit card enrolled; Will send for 3D password authentication.", locale);
OrderProvider.UpdatePaymentGatewayRecord(orderNumber, string.Concat("3D credit card enrolled; Will send for 3D password authentication.", data),
PaymentGatewayLogEntryType.Response, PaymentGatewayRecordStatusType.ApprovalPending);
}
else // 3D card is Not Enrolled, and has no issue, should submit this order
{
OrderProvider.InsertPaymentGatewayRecord(orderNumber, distributorId, "3DSecuredEnrollmentAuthentication", "3D credit card NOT enrolled. Will submit order to BizTalk for Authorization.", locale);
}
}
/// <summary>
/// The get available discounts.
/// </summary>
/// <param name="distributorId">
/// The distributor id.
/// </param>
/// <returns>
/// List of customer discounts
/// </returns>
public static List <CustomerDiscountDefinition> GetAvailableDiscounts(string distributorId)
{
if (string.IsNullOrEmpty(distributorId))
{
return(null);
}
using (var proxy = ServiceClientProvider.GetCustomerOrderServiceProxy())
{
try
{
var request = new GetCustomerDiscountsByDistributor {
DistributorID = distributorId
};
var response = proxy.GetCustomerDiscounts(new GetCustomerDiscountsRequest1(request)).GetCustomerDiscountsResult as GetCustomerDiscountsResponse_V01;
if (response.Status == ServiceResponseStatusType.Success)
{
return(response.Discounts.ToList());
}
}
catch (Exception ex)
{
WebUtilities.LogServiceExceptionWithContext(ex, proxy);
// ExceptionPolicy.HandleException(ex, ProviderPolicies.SYSTEM_EXCEPTION);
LoggerHelper.Error(string.Format("GetAvailableDiscounts DS:{0} ERR:{1}", distributorId, ex));
return(null);
}
}
return(null);
}
/// <summary>
/// The get customer order by order id.
/// </summary>
/// <param name="orderId">
/// The order id.
/// </param>
/// <returns>
/// Customer Order Object
/// </returns>
public static CustomerOrder_V01 GetCustomerOrderByOrderID(string orderId)
{
if (string.IsNullOrEmpty(orderId))
{
return(null);
}
using (var proxy = ServiceClientProvider.GetCustomerOrderServiceProxy())
{
try
{
var request = new GetCustomerOrderRequest_V01();
var filter = new CustomerOrderById {
CustomerOrderId = orderId
};
request.Filter = filter;
var response = proxy.GetOrders(new GetOrdersRequest(request)).GetOrdersResult as GetCustomerOrderResponse_V01;
if (response != null && response.Status == ServiceResponseStatusType.Success)
{
return(response.Orders.ToList().Cast <CustomerOrder_V01>().ToList().FirstOrDefault());
}
}
catch (Exception ex)
{
WebUtilities.LogServiceExceptionWithContext(ex, proxy);
// ExceptionPolicy.HandleException(ex, ProviderPolicies.SYSTEM_EXCEPTION);
LoggerHelper.Error(string.Format("GetCustomerOrderByOrderID OrderID:{0} ERR:{1}", orderId, ex));
return(null);
}
}
return(null);
}
/// <summary>
/// The save customer order.
/// </summary>
/// <param name="customerOrder">
/// The customer order.
/// </param>
/// <returns>
/// The save customer order.
/// </returns>
public static bool SaveCustomerOrder(CustomerOrder_V01 customerOrder)
{
if (customerOrder == null)
{
return(false);
}
using (var proxy = ServiceClientProvider.GetCustomerOrderServiceProxy())
{
try
{
var request = new SaveCustomerOrderRequest_V01 {
Order = customerOrder
};
var response = proxy.SaveOrder(new SaveOrderRequest(request)).SaveOrderResult as SaveCustomerOrderResponse_V01;
if (response.Status == ServiceResponseStatusType.Success)
{
return(true);
}
}
catch (Exception ex)
{
WebUtilities.LogServiceExceptionWithContext(ex, proxy);
// ExceptionPolicy.HandleException(ex, ProviderPolicies.SYSTEM_EXCEPTION);
LoggerHelper.Error(string.Format("SaveCustomerOrder OrderID:{0} ERR:{1}", customerOrder.OrderID, ex));
return(false);
}
}
return(false);
}
public List <DiscontinuedSkuItemResponseViewModel> GetDiscontinuedSkuRequest(GetDiscontinuedSkuParam request)
{
List <DiscontinuedSkuItemResponseViewModel> result = null;
if (string.IsNullOrWhiteSpace(request.Locale) || string.IsNullOrWhiteSpace(request.DistributorId))
{
return(null);
}
try
{
var list = _discontinuedSkuLoader.GetDiscontinuedSkuList(request.DistributorId, request.Locale, request.ShoppingCartItemToCheck);
if (list.Count > 0)
{
result = ConvertToFavouriteItemViewModel(list);
}
return(result);
}
catch (Exception ex)
{
LoggerHelper.Error(string.Format("MobileDiscontinuedSkuProvider : {0}\n {1}\n", ex.Message, ex.StackTrace));
return(result);
}
}
public static bool SendInvoiceEmail(InvoiceModel invoice)
{
var proxy = ServiceClientProvider.GetCommunicationServiceProxy();
try
{
if (null != proxy)
{
var dataToSend = ConvertInvoiceToSendData(invoice);
var request = new TriggeredSendRequestRequest_V01();
request.Data = dataToSend;
var response = proxy.SendTriggeredMessage(new SendTriggeredMessageRequest(request)).SendTriggeredMessageResult;
if (response.Status == ServiceResponseStatusType.Success)
{
return(true);
}
else
{
LoggerHelper.Error(string.Format("CommunicationSvcProvider: Error sending Invoice Email invoice: {0}, member id: {1} status:{2}.", invoice.DisplayMemberInvoiceNumber, invoice.MemberId, response.Status));
return(false);
}
}
return(false);
}
catch (Exception ex)
{
LoggerHelper.Error(string.Format("CommunicationSvcProvider: Error sending Invoice Email invoice: {0}, member id: {1} Exception Message:{2}.", invoice.DisplayMemberInvoiceNumber, invoice.MemberId, ex.Message));
return(false);
}
}
public static AnnouncementInfoList GetChinaAnnouncementInfo(DateTime?fromDate, DateTime?toDate, string locale)
{
var proxy = ServiceClientProvider.GetCatalogServiceProxy();
try
{
var request = new AnnouncementInfoRequest_V01
{
BeginDate = fromDate,
EndDate = toDate,
Locale = locale
};
var response =
proxy.GetAnnouncementInfo(new GetAnnouncementInfoRequest(request)).GetAnnouncementInfoResult as AnnouncementInfoResponse_V01;
// Check response for error.
if (response == null || response.Status != ServiceResponseStatusType.Success)
{
throw new ApplicationException("CatalogProvider.GetChinaAnnouncementInfo error.");
}
return(response.Announcements);
}
catch (Exception ex)
{
LoggerHelper.Error(
string.Format("China GetChinaAnnouncementInfo error: {0} ", ex));
}
return(null);
}
public List <FavouriteSKUItemResponseViewModel> GetFavouriteSKUs(GetFavouriteParam request)
{
List <FavouriteSKUItemResponseViewModel> result = null;
if (string.IsNullOrWhiteSpace(request.Locale) || string.IsNullOrWhiteSpace(request.DistributorID))
{
return(result);
}
try
{
List <FavouriteSKU> SKUs = new List <FavouriteSKU>();
SKUs = _favorLoader.GetDistributorFavouriteSKU(request.DistributorID, request.Locale);
if (SKUs.Count > 0)
{
result = ConvertToFavouriteItemViewModel(SKUs);
}
return(result);
}
catch (Exception ex)
{
LoggerHelper.Error(string.Format("MobileFavouriteSKUProvider : {0}\n {1}\n", ex.Message, ex.StackTrace));
return(result);
}
}
public static DistributorPurchasingLimitsSourceType GetDistributorPurchasingLimitsSource(string country,
string distributorId)
{
if (HLConfigManager.Configurations.DOConfiguration.IsChina)
{
return(DistributorPurchasingLimitsSourceType.HMS);
}
var source = DistributorPurchasingLimitsSourceType.Unknown;
string cacheKey = string.Format("{0}_{1}_{2}", "PLSOURCE", country, distributorId);
string useFusion = HttpRuntime.Cache[cacheKey] as string;
if (useFusion == null)
{
if (!string.IsNullOrEmpty(distributorId) && !string.IsNullOrEmpty(country))
{
try
{
OrderServiceClient proxy = null;
proxy = ServiceClientProvider.GetOrderServiceProxy();
var request =
new GetDistributorPurchasingLimitsSourceRequest_V01();
request.DistributorID = distributorId;
request.CountryCode = country;
// RS exception in country for request
if (country.Equals("RS"))
{
request.CountryCode = HL.Common.ValueObjects.CountryType.RS.HmsCountryCodes.FirstOrDefault();
}
var response =
proxy.GetDistributorPurchasingLimitsSource(new GetDistributorPurchasingLimitsSourceRequest(request)).GetDistributorPurchasingLimitsSourceResult as
GetDistributorPurchasingLimitsSourceResponse_V01;
if (response.Status != ServiceProvider.OrderSvc.ServiceResponseStatusType.Success)
{
LoggerHelper.Error(
string.Format("Save Purchasing Limits failed for Distributor {0}, Country {1}, Status{2}",
distributorId, country, response.Status));
}
if (null != response)
{
source = response.Source;
useFusion = source == DistributorPurchasingLimitsSourceType.HMS ? Boolean.TrueString : Boolean.FalseString;
HttpRuntime.Cache.Insert(cacheKey, useFusion, null, DateTime.Now.AddMinutes(15), Cache.NoSlidingExpiration, CacheItemPriority.Normal, null);
}
}
catch (Exception ex)
{
LoggerHelper.Error(
string.Format(
"Error retrieving OutstandingOrders Status from BPEL service for: DS:{0} - Country:{1}, {2}",
distributorId, country, ex));
}
}
}
return(source = string.IsNullOrEmpty(useFusion) ? DistributorPurchasingLimitsSourceType.InternetOrdering : (useFusion.Equals(Boolean.TrueString) ? DistributorPurchasingLimitsSourceType.HMS : DistributorPurchasingLimitsSourceType.InternetOrdering));
}
/// <summary>Initialize this object</summary>
private void Initialize()
{
_CreateDateTime = DateUtils.GetCurrentLocalTime(_CountryCode);
var orderMonth = _CreateDateTime;
var fromDate = DateTimeUtils.GetFirstDayOfMonth(orderMonth);
var from = new DateTime(fromDate.Year, fromDate.Month, fromDate.Day);
var toDate = DateTimeUtils.GetLastDayOfMonth(orderMonth);
var to = new DateTime(toDate.Year, toDate.Month, toDate.Day, 23, 59, 59);
_MonthEndDate = _DualOrderMonthDate = to;
//List<DualMonthPair> dualMonth = ShoppingCartProvider.GetDualOrderMonthDatesFromService(from, to, _CountryCode);
if (!isPC())
{
var dualMonth = ShoppingCartProvider.GetDualOrderMonthDates(from, to, _CountryCode);
if (null != dualMonth)
{
foreach (DualMonthPair dmp in dualMonth)
{
if (_CreateDateTime < dmp.MonthEndDate)
{
// when MonthEndDate is 2014-12-31 23:59:59.000, _CreateDateTime is 12/31, _CreateDateTime.Day is 31 and OrderMonth is 11 => exception
int year = Convert.ToInt32(dmp.OrderMonth.Substring(0, 4));
int month = Convert.ToInt32(dmp.OrderMonth.Substring(4, 2));
var lastDay = DateTimeUtils.GetLastDayOfMonth(new DateTime(year, month, 1));
_DualOrderMonthDate = dmp.MonthEndDate;
_MonthEndDate = new DateTime(year, month, lastDay.Day, 23, 59, 59);
// _MonthEndDate = new DateTime(Convert.ToInt32(dmp.OrderMonth.Substring(0, 4)),
// Convert.ToInt32(dmp.OrderMonth.Substring(4, 2)),
// _CreateDateTime.Day, 23, 59, 59);
}
break;
}
if (HLConfigManager.Configurations.DOConfiguration.ExtendDualOrderMonth > 0)
{
_DualOrderMonthDate =
_DualOrderMonthDate.AddHours(
HLConfigManager.Configurations.DOConfiguration.ExtendDualOrderMonth);
}
}
else
{
LoggerHelper.Error("Failed to get Dual Month info from the Catalog Service");
}
}
_OrderMonthData.CurrentOrderMonth = OrderMonthNumber;
//Account for any EOM grace period
//if (_MonthEndGracePeriod.Ticks > 0)
//{
// _MonthEndDate = to + _MonthEndGracePeriod;
// _DualOrderMonthDate += _MonthEndGracePeriod;
//}
}
private static List <VolumeModel> GetVolumeViewModel(IEnumerable <DistributorVolume_V01> volumePoints,
string countryCode, string id)
{
if (null == volumePoints)
{
LoggerHelper.Error(string.Format("volumePoints is null in the method GetVolumeViewModel {0}\n{1}",
id, countryCode));
return(null);
}
try
{
var distributorProvider = new Core.DistributorProvider.DistributorProfileLoader();
var distributorModel = distributorProvider.Load(new GetDistributorProfileById {
Id = id
});
var currentMonth = DateUtils.GetCurrentLocalTime(countryCode).Month;
var volumeModels = volumePoints.Select(distributorVolumeV01 =>
{
var volumeMonth = GetVolumeMonth(distributorVolumeV01.VolumeMonth);
return(new VolumeModel
{
DV = ExtractValue(distributorVolumeV01.DownlineVolume, 0.0M),
GV = ExtractValue(distributorVolumeV01.GroupVolume, 0.0M),
PPV = ExtractValue(distributorVolumeV01.PersonallyPurchasedVolume, 0.0M),
PV = ExtractValue(distributorVolumeV01.Volume, 0.0M),
TV = ExtractValue(distributorVolumeV01.TotalVolume, 0.0M),
HeaderVolume = GetHeaderVolume(distributorVolumeV01, distributorModel.TypeCode),
VolumeMonth = volumeMonth,
IsCurrentMonth = currentMonth == volumeMonth,
PPVText = _localization.GetGlobalString("HrblUI", "VolumePPVText"),
DVText = _localization.GetGlobalString("HrblUI", "VolumeDVText"),
TVText = _localization.GetGlobalString("HrblUI", "VolumePVText"),
PVText = _localization.GetGlobalString("HrblUI", "VolumePVText"),
GVText = _localization.GetGlobalString("HrblUI", "VolumeGVText")
});
}).ToList();
ILoader <Dictionary <DateTime, DateTime>, string, DateTime> dualMonthLoader = new DualOrderMonthLoader();
var settings = new DualOrderMonthProvider(new DualOrderMonthLoader());
var localNow = DateUtils.GetCurrentLocalTime(countryCode);
var isDualOrderMonth = settings.IsDualOrderMonth(countryCode, localNow);
return(!isDualOrderMonth
? volumeModels.Where(v => v.VolumeMonth == currentMonth).ToList()
: volumeModels);
}
catch (Exception ex)
{
LoggerHelper.Error(string.Format("Exception occured GetVolumeViewModel method {0}\n{1}",
id, ex));
throw;
}
}
/// <summary>
/// Gets the details of the event for a member qualified
/// </summary>
/// <param name="eventId">The event Id</param>
/// <param name="distributorId">The member Id</param>
/// <param name="locale">The locale</param>
/// <returns></returns>
public static ServiceProvider.EventRestSvc.Event GetEventDetails(int eventId, string distributorId, string locale, bool isPublished = true)
{
if (eventId <= 0 || string.IsNullOrEmpty(distributorId) || string.IsNullOrEmpty(locale))
{
return(null);
}
ServiceProvider.EventRestSvc.Event result = null;
var memberCacheKey = string.Format("Member_EventDetails{0}", eventId);
var eventDetailsList = HttpRuntime.Cache[memberCacheKey] as Dictionary <string, ServiceProvider.EventRestSvc.Event>;
if (eventDetailsList == null || !eventDetailsList.Any() || !eventDetailsList.ContainsKey(distributorId))
{
if (eventDetailsList == null)
{
eventDetailsList = new Dictionary <string, ServiceProvider.EventRestSvc.Event>();
}
var proxy = ServiceClientProvider.GetEventDetailServiceProxy();
try
{
var request = new ServiceProvider.EventRestSvc.GetEventDetailsRequest()
{
EventId = eventId, LocaleCode = locale, MemberId = distributorId, isPublished = isPublished
};
var response = proxy.GetEventDetails(request);
if (response != null && response.GetEventDetailsResult != null && response.GetEventDetailsResult.errorCode == 0 && response.GetEventDetailsResult.Event != null)
{
result = response.GetEventDetailsResult.Event;
eventDetailsList.Add(distributorId, result);
}
}
catch (Exception ex)
{
LoggerHelper.Error(
string.Format("GetEventDetails error calling service EventId:{0} ERR:{1}",
eventId, ex.ToString()));
}
if (eventDetailsList.Any())
{
HttpRuntime.Cache.Insert(memberCacheKey, eventDetailsList, null,
DateTime.Now.AddMinutes(EventCacheMinutes),
Cache.NoSlidingExpiration, CacheItemPriority.NotRemovable, null);
}
}
if (eventDetailsList != null && eventDetailsList.ContainsKey(distributorId) && result == null)
{
result = eventDetailsList.FirstOrDefault(e => e.Key == distributorId).Value;
}
return(result);
}
internal List <VolumeModel> LoadFromService(string distributorId)
{
var proxy = GetProxy();
try
{
var circuitBreaker =
CircuitBreakerFactory.GetFactory().GetCircuitBreaker <GetDistributorVolumeResponse_V01>();
var countryCode = Thread.CurrentThread.CurrentUICulture.Name.Substring(3);
var currentLocalTime = DateUtils.GetCurrentLocalTime(countryCode);
var getVolumeRequest = new GetDistributorVolumeRequest_V01
{
DistributorID = distributorId,
StartDate = DateTimeUtils.GetFirstDayOfMonth(currentLocalTime.AddMonths(-1)),
EndDate = DateTimeUtils.GetLastDayOfMonth(currentLocalTime)
};
var response =
circuitBreaker.Execute(
() => proxy.GetDistributorVolumePoints(new GetDistributorVolumePointsRequest(getVolumeRequest)).GetDistributorVolumePointsResult as GetDistributorVolumeResponse_V01);
if (response == null)
{
LoggerHelper.Error("Null response was returned for " + distributorId);
return(null);
}
if (response.Status == ServiceResponseStatusType.Success)
{
return(GetVolumeViewModel(response.VolumePoints, countryCode, distributorId));
}
LoggerHelper.Error(
string.Format(
"VolumeProvider.LoadFromService Error. Unsuccessful result from web service. Status: {0}",
response.Status));
}
catch (Exception ex)
{
LoggerHelper.Error(string.Format("Exception occured Load Volume method {0}\n{1}",
distributorId, ex));
throw;
}
finally
{
if (null != proxy)
{
proxy.Close();
}
}
return(null);
}
private ShoppingCartRuleResult PerformRules(ShoppingCart_V02 cart,
ShoppingCartRuleReason reason,
ShoppingCartRuleResult Result)
{
if (reason == ShoppingCartRuleReason.CartItemsBeingAdded)
{
List <string> codes = new List <string>(CountryType.KZ.HmsCountryCodes);
codes.Add(CountryType.KZ.Key);
bool isCOPKZ = codes.Contains(DistributorProfileModel.ProcessingCountryCode);
if (!isCOPKZ)
{
return(Result);
}
if (!HasActiveAppTinCode(cart.DistributorID))
{
try
{
var cartVolume = 0m;
var currentItem = CatalogProvider.GetCatalogItem(cart.CurrentItems[0].SKU, Country);
var myCart = cart as MyHLShoppingCart;
if (myCart != null && !string.IsNullOrEmpty(myCart.VolumeInCart.ToString()))
{
cartVolume = myCart.VolumeInCart;
}
var newVolumePoints = currentItem.VolumePoints * cart.CurrentItems[0].Quantity;
if (cartVolume + newVolumePoints > MaxVolPoints)
{
Result.AddMessage(
string.Format(
HttpContext.GetGlobalResourceObject(
string.Format("{0}_Rules", HLConfigManager.Platform), "VolumePointExceeds")
.ToString(), cart.CurrentItems[0].SKU));
Result.Result = RulesResult.Failure;
cart.RuleResults.Add(Result);
return(Result);
}
}
catch (Exception ex)
{
LoggerHelper.Error(
string.Format(
"Error while performing Add to Cart Rule for Belarus distributor: {0}, Cart Id:{1}, \r\n{2}",
cart.DistributorID, cart.ShoppingCartID, ex.ToString()));
}
}
}
return(Result);
}
/// <summary>
/// Gets the list of qualifiers for an event.
/// </summary>
/// <param name="eventId">The event Id.</param>
/// <returns></returns>
public static List <ServiceProvider.EventSvc.EventQualifier_V01> GetEventQualifierList(int eventId)
{
if (eventId <= 0)
{
return(null);
}
var memberCacheKey = string.Format("MemberList_Event{0}", eventId);
var eventQualifierList = HttpRuntime.Cache[memberCacheKey] as List <ServiceProvider.EventSvc.EventQualifier_V01>;
if (eventQualifierList == null || !eventQualifierList.Any())
{
eventQualifierList = new List <ServiceProvider.EventSvc.EventQualifier_V01>();
using (var proxy = ServiceClientProvider.GetEventServiceProxy())
{
try
{
var request = new ServiceProvider.EventSvc.GetEventQualifierListRequest();
var requestV01 = new ServiceProvider.EventSvc.GetEventQualifierRequest_V01
{
EventID = eventId,
//EventIDSpecified = true
};
request.request = requestV01;
var response = proxy.GetEventQualifierList(request);
var response01 = response.GetEventQualifierListResult as ServiceProvider.EventSvc.GetEventQualifierResponse_V01;
if (response01 != null && response01.EventQualifiers != null)
{
eventQualifierList = response01.EventQualifiers.ToList();
}
}
catch (Exception ex)
{
eventQualifierList = new List <ServiceProvider.EventSvc.EventQualifier_V01>();
LoggerHelper.Error(
string.Format("GetEventQualifierList error calling service EventId:{0} ERR:{1}",
eventId, ex.ToString()));
}
}
if (eventQualifierList.Any())
{
HttpRuntime.Cache.Insert(memberCacheKey, eventQualifierList, null,
DateTime.Now.AddMinutes(EventCacheMinutes),
Cache.NoSlidingExpiration, CacheItemPriority.NotRemovable, null);
}
}
return(eventQualifierList);
}
/// <summary>
/// get inventory for china store
/// </summary>
/// <param name="storeID"></param>
/// <returns></returns>
public static Inventory_V01 GetInventory(string storeID)
{
string cachekey = string.Format("{0}{1}", INVENTORY_CACHE_PREFIX, storeID);
CatalogInterfaceClient proxy = null;
using (proxy = ServiceClientProvider.GetCatalogServiceProxy())
{
try
{
var response =
proxy.GetInventory(new GetInventoryRequest1(new GetInventoryRequest_V01 {
CountryCode = "CN", StoreID = storeID
})).GetInventoryResult as
GetInventoryResponse_V01;
// Check response for error.
if (response == null || response.Status != ServiceResponseStatusType.Success ||
response.Inventory == null)
{
throw new ApplicationException(
"CatalogProvider.GetInventory error. GetInventoryResponse indicates error. storeID : " +
storeID);
}
HttpRuntime.Cache.Insert(cachekey,
response.Inventory,
null,
DateTime.Now.AddMinutes(INVENTORY_CACHE_MINUTES),
Cache.NoSlidingExpiration,
CacheItemPriority.NotRemovable,
null);
if (Settings.GetRequiredAppSetting("LogCatalogCN", "false").ToLower() == "true")
{
LogRequest(string.Format("Store ID: {0}", storeID));
LogRequest(string.Format("GetInventory service response: {0}",
OrderCreationHelper.Serialize(response.Inventory)));
}
return(response.Inventory);
}
catch (Exception ex)
{
LoggerHelper.Error(
string.Format("ChinaGetInventory error, storeID: {0} {1}", storeID, ex));
}
}
return(null);
}
private ShoppingCartRuleResult CartItemAddedRuleHandler(ShoppingCart_V01 cart, ShoppingCartRuleResult result, string level)
{
var distributorId = cart.DistributorID;
var isAPFDueandNotPaid = APFDueProvider.IsAPFDueAndNotPaid(distributorId, Locale);
if (isAPFDueandNotPaid && HLConfigManager.Configurations.DOConfiguration.IsChina)
{
string cacheKey = string.Empty;
bool reloadAPFs = (null != cart && null != cart.CartItems) && isAPFDueandNotPaid &&
!APFDueProvider.IsAPFSkuPresent(cart.CartItems);
cart.APFEdited = false;
DoApfDue(cart.DistributorID, cart, cacheKey, Locale, reloadAPFs, result, true);
}
try
{
var hlCart = cart as MyHLShoppingCart;
if (null != hlCart)
{
var isPlacing = !String.IsNullOrWhiteSpace(hlCart.SrPlacingForPcOriginalMemberId);
if (isPlacing)
{
var skuList = APFDueProvider.GetAPFSkuList();
if (skuList != null && skuList.Count > 0)
{
var items =
(from s in skuList
from c in cart.CartItems
where s == c.SKU
select c.SKU).ToList();
if (null != items && items.Count > 0)
{
hlCart.DeleteItemsFromCart(items, true);
}
}
}
}
}
catch (Exception ex)
{
LoggerHelper.Error(
string.Format("APFRules.CartItemAddedRuleHandler DS:{0} locale:{2} ERR:{1}", cart.DistributorID,
ex, Locale));
}
return(result);
}
public virtual ServiceProvider.OrderSvc.OrderTotals_V01 CallDistributorPricing(ServiceProvider.OrderSvc.Order_V01 order, bool useHmsCalc)
{
try
{
string errorCode;
return(ShoppingCartProvider.GetQuote(order, QuotePartType.Freight, useHmsCalc, out errorCode));
}
catch (Exception ex)
{
LoggerHelper.Error(
string.Format(
"OrderService - InvoiceProvider: An error occured while Calling CallDistributorPricing service method {0}",
ex.Message));
}
return(null);
}
public Dictionary <DateTime, DateTime> Load(string countryCode, DateTime localNow)
{
if (string.IsNullOrWhiteSpace(countryCode))
{
throw new ArgumentException("CountryCode is blank", "countryCode");
}
var fromDate = DateTimeUtils.GetFirstDayOfMonth(localNow);
var toDate = DateTimeUtils.GetLastDayOfMonth(localNow);
var proxy = ServiceClientProvider.GetCatalogServiceProxy();
try
{
var circuitBreaker =
CircuitBreakerFactory.GetFactory().GetCircuitBreaker <GetDualMonthDatesResponse_V01>();
var response =
circuitBreaker.Execute(() => proxy.GetDualMonthDates(new GetDualMonthDatesRequest1(new GetDualMonthDatesRequest_V01
{
CountryCode = countryCode,
FromDate = fromDate,
ToDate = toDate
})).GetDualMonthDatesResult as GetDualMonthDatesResponse_V01);
if (response != null && response.Status == ServiceResponseStatusType.Success)
{
return(GetDualMonthDictionary(response.DualMonth, localNow));
}
}
catch
{
LoggerHelper.Error("Errored out in GetDualOrderMonth" + countryCode);
if (null != proxy)
{
proxy.Close();
}
throw;
}
finally
{
if (null != proxy)
{
proxy.Close();
}
}
LoggerHelper.Error("Errored out in GetDualOrderMonth Catalog service" + countryCode);
return(null);
}
/// <summary>
/// The update customer order tags.
/// </summary>
/// <param name="customerOrderID">
/// The customer order id.
/// </param>
/// <param name="orderTag">
/// The order tag.
/// </param>
/// <returns>
/// The update customer order tags.
/// </returns>
public static bool UpdateCustomerOrderTags(string customerOrderID, CustomerOrderStatusTag orderTag)
{
if (string.IsNullOrEmpty(customerOrderID))
{
return(false);
}
using (var proxy = ServiceClientProvider.GetCustomerOrderServiceProxy())
{
try
{
var request = new SavePartialCustomerOrderRequest
{
OrderId = customerOrderID,
Updates =
new[]
{
new CustomerOrderPropertyValue
{
Property = CustomerOrderProperty.CustomerOrderStatusTag,
Value =
(int)
Enum.Parse(
typeof(CustomerOrderStatusTag),
Enum.GetName(typeof(CustomerOrderStatusTag), orderTag))
}
}.ToList()
};
var response = proxy.SaveOrder(new SaveOrderRequest(request)).SaveOrderResult as SaveCustomerOrderResponse_V01;
if (response.Status == ServiceResponseStatusType.Success)
{
return(true);
}
}
catch (Exception ex)
{
WebUtilities.LogServiceExceptionWithContext(ex, proxy);
// ExceptionPolicy.HandleException(ex, ProviderPolicies.SYSTEM_EXCEPTION);
LoggerHelper.Error(string.Format("UpdateCustomerOrderTags OrderID:{0} ERR:{1}", customerOrderID, ex));
return(false);
}
}
return(false);
}
public static void SavePurchaseLimitsToStore(string country, string distributorId)
{
//2.CurrentOrderMonth
if (HLConfigManager.Configurations.DOConfiguration.IsChina)
{
return;
}
var limits = getPurchasingLimitsFromCache(distributorId);
if (null != limits && limits.Count > 0)
{
//var orderMonth = new OrderMonth(country);
// orderMonth.ResolveOrderMonth();
foreach (var limit in limits)
{
var request = new SetPurchasingLimitsRequest_V01();
request.Country = country;
request.DistributorId = distributorId;
request.OrderMonth = limit.Key.ToString();
var purchasingLimit = limit.Value;
request.PurchasingLimits = purchasingLimit;
OrderServiceClient proxy = null;
try
{
proxy = ServiceClientProvider.GetOrderServiceProxy();
var response =
proxy.SetPurchasingLimits(new SetPurchasingLimitsRequest1(request)).SetPurchasingLimitsResult as SetPurchasingLimitsResponse_V01;
if (response.Status != ServiceProvider.OrderSvc.ServiceResponseStatusType.Success)
{
LoggerHelper.Error(
string.Format(
"Save Purchasing Limits failed for Distributor {0}, Country {1}, Status{2}",
distributorId, country, response.Status));
}
}
catch (Exception ex)
{
LoggerHelper.Error(
string.Format("Save PurchasingLimits failed for Distributor {0}, country Code: {1} {2}",
distributorId, country, ex));
}
}
}
}
/// <summary>
/// The save discount.
/// </summary>
/// <param name="coupon">
/// The coupon.
/// </param>
/// <param name="distributorId">
/// The distributor id.
/// </param>
/// <returns>
/// The save discount.
/// </returns>
/// <exception cref="ArgumentException">
/// </exception>
public static bool SaveDiscount(CustomerDiscountDefinition coupon, string distributorId)
{
if (coupon == null)
{
return(false);
}
using (var proxy = ServiceClientProvider.GetCustomerOrderServiceProxy())
{
try
{
var request = new SaveCustomerDiscountRequest_V01
{
Discount = coupon,
DistributorID = distributorId
};
var response = proxy.SaveCustomerDiscount(new SaveCustomerDiscountRequest1(request));
if (response.SaveCustomerDiscountResult.Status == ServiceResponseStatusType.Success)
{
return(true);
}
if (response.SaveCustomerDiscountResult.Status.ToString() == "Failure, ClientFault")
{
foreach (var parameterError in response.SaveCustomerDiscountResult.ParameterErrorList)
{
if (parameterError.Name.Equals("Discount Code"))
{
throw new ArgumentException("Duplicate coupon code");
}
}
}
}
catch (Exception ex)
{
if (ex.GetType().Equals(typeof(ArgumentException)))
{
throw;
}
LoggerHelper.Error(string.Format("SaveDiscount DS ID:{0} ERR:{1}", distributorId, ex));
return(false);
}
}
return(false);
}
private static string SerializeObject(Object pObject, Type objectType)
{
try
{
var ser = new XmlSerializer(objectType);
var sb = new StringBuilder();
var writer = new System.IO.StringWriter(sb);
ser.Serialize(writer, pObject);
return(sb.ToString());
}
catch (Exception ex)
{
LoggerHelper.Error(string.Format("ThreeDPaymentProvider serializeObject error: {0}", ex.Message));
return(string.Empty);
}
}
private void ClearShoppingCartModuleCache()
{
try
{
if (SessionInfo != null)
{
SessionInfo.IsFirstTimeSpainPopup = false;
}
var cartWidgetSource = new CartWidgetSource();
cartWidgetSource.ExpireShoppingCartCache(DistributorID, Locale);
}
catch (Exception ex)
{
LoggerHelper.Error(
string.Format("Error occurred ClearMyHL3ShoppingCartCache. Id is {0}-{1}.\r\n{2}", DistributorID, Locale,
ex.Message));
}
}
public void ReloadPurchasingLimits(string distributorID)
{
try
{
if (PurchasingLimitProvider.IsRestrictedByMarketingPlan(distributorID))
{
CreatePurchasingLimits(GetDistributorPurchasingLimitsCollection());
}
if (PurchasingLimits != null)
{
SaveToCache();
}
}
catch (Exception ex)
{
LoggerHelper.Error(ex.ToString());
}
}