public static List <InvoiceSKU> GetInvoiceSKU(string distributorID, Int64 invoiceID)
{
var proxy = ServiceClientProvider.GetOrderServiceProxy();
try
{
var request = new GetInvoiceSkuRequest_V01
{
DistributorID = distributorID,
InvoiceID = invoiceID
};
var response = proxy.GetInvoiceSku(new GetInvoiceSkuRequest1(request)).GetInvoiceSkuResult as GetInvoiceSkuResponse_V01;
if (response != null && response.Status == ServiceResponseStatusType.Success &&
null != response.InvoiceSkus && response.InvoiceSkus.Count > 0)
{
return(response.InvoiceSkus);
}
return(null);
}
catch (Exception ex)
{
WebUtilities.LogExceptionWithContext(ex);
LoggerHelper.Exception("System.Exception", new Exception("OrderService: GetInvoiceSKU\n", ex));
}
finally
{
if (proxy.State != CommunicationState.Closed)
{
proxy.Close();
}
proxy = null;
}
return(null);
}
/// <summary>
/// method to get the check payment details response from service
/// </summary>
/// <param name="distributorID"></param>
/// <returns></returns>
private static GetInvoicesResponse_V01 getInvoicesResponse(string distributorID)
{
var proxy = ServiceClientProvider.GetOrderServiceProxy();
try
{
var request = new GetInvoicesRequest_V01
{
DistributorID = distributorID,
};
var response = proxy.GetInvoices(new GetInvoicesRequest1(request)).GetInvoicesResult as GetInvoicesResponse_V01;
return(response);
}
catch (Exception ex)
{
WebUtilities.LogExceptionWithContext(ex);
LoggerHelper.Exception("System.Exception", new Exception("OrderService: getInvoicesResponse\n", ex));
}
finally
{
if (proxy.State != CommunicationState.Closed)
{
proxy.Close();
}
proxy = null;
}
return(null);
}
/// <summary>
/// Gets the next valid invoice number for the given distributor
/// </summary>
/// <param name="distributorID">The ID of the distributor</param>
/// <returns>The next valid invoice number</returns>
public static Int64 GetNextDistributorInvoiceNumber(string distributorID)
{
var proxy = ServiceClientProvider.GetOrderServiceProxy();
try
{
var request = new GetNextDistributorInvoiceNumberRequest_V01
{
DistributorID = distributorID
};
var response =
proxy.GetNextDistributorInvoiceNumber(new GetNextDistributorInvoiceNumberRequest1(request)).GetNextDistributorInvoiceNumberResult as GetNextDistributorInvoiceNumberResponse_V01;
if (response != null && response.Status == ServiceResponseStatusType.Success &&
response.InvoiceNumber > 0)
{
return(response.InvoiceNumber);
}
}
catch (Exception ex)
{
WebUtilities.LogExceptionWithContext(ex);
LoggerHelper.Exception("System.Exception", new Exception("OrderService: GetNextDistributorInvoiceNumber\n", ex));
}
finally
{
if (proxy.State != CommunicationState.Closed)
{
proxy.Close();
}
proxy = null;
}
return(0);
}
public static Int64 SetInvoice(Invoice invoice)
{
var proxy = ServiceClientProvider.GetOrderServiceProxy();
try
{
var request = new SetInvoiceRequest_V01
{
Invoice = invoice
};
var response = proxy.SetInvoice(new SetInvoiceRequest1(request)).SetInvoiceResult as SetInvoiceResponse_V01;
if (response != null && response.Status == ServiceResponseStatusType.Success)
{
ExpireInvoicesCache(invoice.DistributorID);
return(response.InvoiceID);
}
return(0);
}
catch (Exception ex)
{
WebUtilities.LogExceptionWithContext(ex);
LoggerHelper.Exception("System.Exception", new Exception("OrderService: SetInvoice\n", ex));
}
finally
{
if (proxy.State != CommunicationState.Closed)
{
proxy.Close();
}
proxy = null;
}
return(0);
}
private DistributorPurchasingLimitsCollection GetDistributorPurchasingLimitsCollection()
{
DistributorPurchasingLimitsCollection distributorPurchasingLimitsCollection = null;
var mpeThresholdCountries =
new List <string>(Settings.GetRequiredAppSetting("MPEThresholdCountries").Split(new[] { ',' }));
if (mpeThresholdCountries.Contains(_processingCountry))
{
if (_distributorLevel == "DS")
{
_currentLoggedInCountry = _processingCountry;
}
}
using (var proxy = ServiceClientProvider.GetOrderServiceProxy())
{
try
{
var request = new GetDistributorPurchasingLimitsRequest_V01
{
DistributorID = _distributorId,
CountryCode = _currentLoggedInCountry
};
// RS exception in country for request
if (_currentLoggedInCountry.Equals("RS"))
{
request.CountryCode = CountryType.RS.HmsCountryCodes.FirstOrDefault();
}
var response =
proxy.GetDistributorPurchasingLimits(new GetDistributorPurchasingLimitsRequest(request)).GetDistributorPurchasingLimitsResult as GetDistributorPurchasingLimitsResponse_V01;
if (response != null && response.Status == ServiceResponseStatusType.Success)
{
distributorPurchasingLimitsCollection = response.PurchasingLimits;
}
}
catch (Exception ex)
{
LoggerHelper.Exception("System.Exception", new Exception(
string.Format(
"Error retrieving GetPurchasingLimits Status from Order service for: DS:{0} - Country:{1}, {2}",
_distributorId, _currentLoggedInCountry, ex)));
distributorPurchasingLimitsCollection = null;
}
}
return(distributorPurchasingLimitsCollection);
}
/// <summary>
/// explicit method to clean up the check payment details response
/// </summary>
/// <param name="distributorID"></param>
/// <returns></returns>
public static bool ExpireInvoicesCache(string distributorID)
{
try
{
string cacheKey = INVOICE_CACHE_KEY_PREFIX + distributorID;
SimpleCache.Expire(typeof(GetInvoicesResponse_V01), cacheKey);
return(true);
}
catch (Exception ex)
{
WebUtilities.LogExceptionWithContext(ex);
LoggerHelper.Exception("System.Exception", new Exception(
"OrderService: Fail to clear GetInvoices cache for DistributorID: " + distributorID + " \n", ex));
}
return(false);
}
public static void CheckForMPCFraud(DistributorOrderingProfile distributor)
{
string errorResxKey = string.Empty;
try
{
if (distributor != null && distributor.IsMPCFraud == null)
{
using (var proxyDs = ServiceClientProvider.GetDistributorServiceProxy())
{
var requestV01 = new GetBasicDistributorRequest_V01
{
DistributorID = distributor.Id
};
var circuitBreaker =
CircuitBreakerFactory.GetFactory().GetCircuitBreaker <GetBasicDistributorResponse_V01>();
var responseV01 =
circuitBreaker.Execute(() => proxyDs.GetBasicDistributor(new GetBasicDistributorRequest(requestV01))).GetBasicDistributorResult as
GetBasicDistributorResponse_V01;
if (responseV01 != null && responseV01.Status == ServiceResponseStatusType.Success)
{
if (responseV01.Distributor != null)
{
distributor.IsMPCFraud = responseV01.Distributor.IsMPCFraud;
}
}
}
}
}
catch (Exception ex)
{
LoggerHelper.Exception("System.Exception", new Exception(
string.Format(
"Error retrieving MPC Fraud from Distributor service for: DS:{0} - Country:{1}, {2}",
distributor.Id, distributor.CurrentLoggedInCountry, ex)));
}
}
public DualOrderMonthViewModel GetDualOrderMonth(string country)
{
if (string.IsNullOrEmpty(country))
{
LoggerHelper.Error("country is null - MobileDualOrderMonthController");
return(null);
}
try
{
var _businessSettings = new DualOrderMonthProvider(new DualOrderMonthLoader());
var result = new DualOrderMonthResponseViewModel();
var localNow = DateUtils.GetCurrentLocalTime(country);
var isDualOrderMonth = _businessSettings.IsDualOrderMonth(country, localNow);
var dualOrderMonthModel = new DualOrderMonthViewModel
{
PreviousOrderMonth = localNow.Month - 1,
};
if (isDualOrderMonth)
{
var monthEndDate = _businessSettings.GetDualMonthEndValue(country, localNow);
dualOrderMonthModel.PreviousOrderMonthEndDate = null != monthEndDate
? monthEndDate.Value.ToString("yyyy-MM-ddTHH:mm:sszzz")
: "calendar";
}
else
{
dualOrderMonthModel.PreviousOrderMonthEndDate = "calendar";
}
return(dualOrderMonthModel);
}
catch (Exception ex)
{
LoggerHelper.Exception("General", ex, "error in DualOrderMonthViewModel GetDualOrderMonth");
return(null);
}
}
public static bool DeleteInvoice(string distributorID, long invoiceID, long contactInfoID)
{
var proxy = ServiceClientProvider.GetOrderServiceProxy();
try
{
var request = new DeleteInvoiceRequest_V01
{
DistributorID = distributorID,
InvoiceID = invoiceID,
ContactInfoID = contactInfoID
};
var response = proxy.DeleteInvoice(new DeleteInvoiceRequest1(request)).DeleteInvoiceResult as DeleteInvoiceResponse_V01;
if (response != null && response.Status == ServiceResponseStatusType.Success)
{
ExpireInvoicesCache(distributorID);
return(true);
}
return(false);
}
catch (Exception ex)
{
WebUtilities.LogExceptionWithContext(ex);
LoggerHelper.Exception("System.Exception", new Exception("OrderService: DeleteInvoice\n", ex));
}
finally
{
if (proxy.State != CommunicationState.Closed)
{
proxy.Close();
}
proxy = null;
}
return(false);
}
public static string CheckForDRFraud(DistributorOrderingProfile distributor, string zipCode)
{
string errorResxKey = string.Empty;
var fraudStatus = DRFraudStatusType.None;
bool isBlocked, isSponsorBlocked, isDsFound;
isBlocked = isSponsorBlocked = isDsFound = false;
using (var proxy = ServiceClientProvider.GetOrderServiceProxy())
{
try
{
if (distributor != null && distributor.FraudStatus == null)
{
using (var proxyDs = ServiceClientProvider.GetDistributorServiceProxy())
{
var requestV01 = new GetBasicDistributorRequest_V01
{
DistributorID = distributor.Id
};
var circuitBreaker =
CircuitBreakerFactory.GetFactory().GetCircuitBreaker <GetBasicDistributorResponse_V01>();
var responseV01 =
circuitBreaker.Execute(() => proxyDs.GetBasicDistributor(new GetBasicDistributorRequest(requestV01))).GetBasicDistributorResult as
GetBasicDistributorResponse_V01;
if (responseV01 != null && responseV01.Status == ServiceResponseStatusType.Success)
{
if (responseV01.Distributor != null)
{
isBlocked = responseV01.Distributor.DRFraudStatusFlags.IsDistributorblocked;
isSponsorBlocked = responseV01.Distributor.DRFraudStatusFlags.IsSponsorBlocked;
isDsFound = true;
}
}
}
}
else if (distributor != null && distributor.FraudStatus != null)
{
isBlocked = distributor.FraudStatus.IsDistributorblocked;
isSponsorBlocked = distributor.FraudStatus.IsSponsorBlocked;
isDsFound = true;
}
if (isDsFound)
{
var request = new GetDRFraudStatusRequest_V01();
request.DistributorID = distributor.Id;
request.CountryCode = distributor.CurrentLoggedInCountry;
request.PostalCode = zipCode;
request.DistributorIsBlocked = isBlocked;
request.SponsorIsBlocked = isSponsorBlocked;
var response =
proxy.GetDRFraudStatus(new GetDRFraudStatusRequest(request)).GetDRFraudStatusResult as GetDRFraudStatusResponse_V01;
if (response.Status == ServiceProvider.OrderSvc.ServiceResponseStatusType.Success)
{
fraudStatus = response.FraudStatus;
}
}
else
{
LoggerHelper.Exception("System.Exception", new Exception(
string.Format(
"Error retrieving DS DRFraudStatusFlags from Cache and Distributor service for: DS:{0} - Country:{1}",
distributor.Id, distributor.CurrentLoggedInCountry)));
fraudStatus = DRFraudStatusType.None;
}
}
catch (Exception ex)
{
LoggerHelper.Exception("System.Exception", new Exception(
string.Format(
"Error retrieving DRFraud Status from Order service for: DS:{0} - Country:{1}, {2}",
distributor.Id, distributor.CurrentLoggedInCountry, ex)));
fraudStatus = DRFraudStatusType.None;
}
}
if (fraudStatus == DRFraudStatusType.DistributorIsBlocked)
{
errorResxKey = "BlockedDS";
}
else if (fraudStatus == DRFraudStatusType.PostalCodeIsBlocked)
{
errorResxKey = "BlockedZip";
}
return(errorResxKey);
}
public static DRFraudStatusType CheckForDRFraud(string distributorID, string countryCode, string zipCode)
{
var fraudStatus = DRFraudStatusType.None;
string CacheKey = string.Format("{0}_{1}", "DSFraud", countryCode);
Dictionary <string, List <string> > blockedPostalCodes = HttpRuntime.Cache[CacheKey] as Dictionary <string, List <string> >;
DistributorOrderingProfile distributorOrderingProfile = GetProfile(distributorID, countryCode);
if (blockedPostalCodes == null)
{
using (var proxy = ServiceClientProvider.GetOrderServiceProxy())
{
try
{
var request = new GetDRFraudStatusRequest_V01();
request.DistributorID = distributorID;
request.CountryCode = countryCode;
request.PostalCode = zipCode;
request.DistributorIsBlocked = distributorOrderingProfile.IsDistributorBlocked;
request.SponsorIsBlocked = distributorOrderingProfile.IsSponsorBlocked;
var response =
proxy.GetDRFraudStatus(new GetDRFraudStatusRequest(request)).GetDRFraudStatusResult as GetDRFraudStatusResponse_V01;
if (response.Status == ServiceProvider.OrderSvc.ServiceResponseStatusType.Success)
{
fraudStatus = response.FraudStatus;
blockedPostalCodes = response.BlockedPostCodes;
}
HttpRuntime.Cache[CacheKey] = response.BlockedPostCodes != null ? response.BlockedPostCodes : new Dictionary <string, List <string> > {
};
}
catch (Exception ex)
{
LoggerHelper.Exception("System.Exception", new Exception(
string.Format(
"Error retrieving DRFraud Status from Order service for: DS:{0} - Country:{1}, {2}",
distributorID, countryCode, ex)));
fraudStatus = DRFraudStatusType.None;
}
}
}
if (distributorOrderingProfile.IsDistributorBlocked && blockedPostalCodes != null)
{
if (blockedPostalCodes.ContainsKey(countryCode) && blockedPostalCodes[countryCode].Contains(zipCode))
{
return(DRFraudStatusType.PostalCodeIsBlocked);
}
}
//if (fraudStatus == DRFraudStatusType.DistributorIsBlocked)
//{
// errorResxKey = "BlockedDS";
//}
//else if (fraudStatus == DRFraudStatusType.PostalCodeIsBlocked)
//{
// errorResxKey = "BlockedZip";
//}
return(fraudStatus);
}
public static List <Invoice> SearchInvoice(InvoiceSearchFilter invoiceSearchFilter, string distributorID)
{
var proxy = ServiceClientProvider.GetOrderServiceProxy();
try
{
var allInvoices = GetInvoices(distributorID);
if (null == allInvoices)
{
return(null);
}
if (invoiceSearchFilter != null)
{
if (invoiceSearchFilter.SearchByDateOrAmount)
{
return(DoSearchByDateOrAmount(invoiceSearchFilter, allInvoices));
}
else
{
if (!string.IsNullOrEmpty(invoiceSearchFilter.SKU) ||
!string.IsNullOrEmpty(invoiceSearchFilter.Description))
{
var request = new SearchInvoiceRequest_V01
{
DistributorID = distributorID,
SKU = invoiceSearchFilter.SKU,
Description = invoiceSearchFilter.Description
};
var response = proxy.SearchInvoice(new SearchInvoiceRequest1(request)).SearchInvoiceResult as SearchInvoiceResponse_V01;
if (response != null && response.Status == ServiceResponseStatusType.Success &&
null != response.InvoiceIDs && response.InvoiceIDs.Count > 0)
{
var invoicesBySkuOrDesc = allInvoices.Where(i => response.InvoiceIDs.Any(a => a == i.ID));
if (null != invoicesBySkuOrDesc && invoicesBySkuOrDesc.Count() > 0)
{
return(invoicesBySkuOrDesc.ToList());
}
return(null);
}
}
else
{
return(DoSearchByOtherFields(invoiceSearchFilter, allInvoices));
}
}
}
}
catch (Exception ex)
{
WebUtilities.LogExceptionWithContext(ex);
LoggerHelper.Exception("System.Exception", new Exception("OrderService: SearchInvoice\n", ex));
}
finally
{
if (proxy.State != CommunicationState.Closed)
{
proxy.Close();
}
proxy = null;
}
return(null);
}