public async Task <IActionResult> PutTblInvoices(int id, TblInvoices tblInvoices)
{
if (id != tblInvoices.Id)
{
return(BadRequest());
}
_context.Entry(tblInvoices).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TblInvoicesExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public virtual async Task <TblInvoices> ApplyInvoiceTaxesAsync(TblInvoices invoice)
{
var invoiceTotalAmount = invoice.ComputeInvoiceTotalAmount(false, false);
invoice.TotalTaxAmount = 0;
invoice.TaxDescription = "";
if (invoiceTotalAmount > 0)
{
foreach (var tax in (await _taxesService.GetAsEnumerableAsync()).Where(p => p.IsActive && p.Amount > 0))
{
invoice.TotalTaxAmount += (invoiceTotalAmount * tax.Amount) / 100;
invoice.TaxDescription += $"{tax.GetLocalized(p => p.TaxName)} (%{tax.Amount}) + ";
}
}
invoice.TaxDescription = invoice.TaxDescription.TrimEnd(" + ");
var taxProcessors = _pluginFinder.GetPlugins <ITaxProcessor>();
foreach (var taxProcessor in taxProcessors.OrderBy(p => p.Order))
{
var result = taxProcessor.ProcessorInvoice(invoice);
if (result.Apply)
{
invoice.TotalTaxAmount += result.TaxAmountInMainCurrency;
invoice.TaxDescription += result.TaxDescription + " + ";
}
}
invoice.TaxDescription = invoice.TaxDescription.TrimEnd(" + ");
await SetTaxAsync(invoice.Id, invoice.TotalTaxAmount, invoice.TaxDescription);
return(invoice);
}
public async Task <ActionResult <TblInvoices> > PostTblInvoices(TblInvoices tblInvoices)
{
_context.TblInvoices.Add(tblInvoices);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetTblInvoices", new { id = tblInvoices.Id }, tblInvoices));
}
public InvoiceCheckoutEvent(TblInvoices invoice, string transactionId, double paidAmount, string paidAmountExStr, string paymentGatewayName, string currencyIso)
{
Invoice = invoice;
TransactionId = transactionId;
PaidAmount = paidAmount;
PaidAmountExStr = paidAmountExStr;
PaymentGatewayName = paymentGatewayName;
CurrencyIso = currencyIso;
}
public int AddInvoiceData(Model.Common.Invoice InvoiceModel, string InvoiceNo)
{
List <Model.Common.Invoice> Items = new List <Model.Common.Invoice>();
int returnVal = 0;
try
{
using (var dBContext = new CustomerReportContext())
{
Model.Common.Invoice get;
foreach (var it in dBContext.TblInvoices)
{
get = new Model.Common.Invoice();
get.InvoiceNo = it.InvoiceNo;
get.CustomerNo = it.CustomerNo;
get.InvoiceDate = it.InvoiceDate;
get.InvoiceAmount = it.InvoiceAmount;
get.PaymentDueDate = it.PaymentDueDate;
Items.Add(get);
}
TblInvoices Cust;
//Add record
Cust = new TblInvoices();
Cust.InvoiceNo = InvoiceModel.InvoiceNo;
Cust.CustomerNo = InvoiceModel.CustomerNo;
Cust.InvoiceDate = InvoiceModel.InvoiceDate;
Cust.InvoiceAmount = InvoiceModel.InvoiceAmount;
Cust.PaymentDueDate = Cust.InvoiceDate.AddDays(30);
//dBContext.TblInvoices.Add(Cust);
InvoiceNo = Cust.InvoiceNo;
bool Inv = Items.Any(asd => asd.InvoiceNo == InvoiceNo);
if (Inv == true)
{
returnVal = -1;
}
if (Inv == false)
{
dBContext.TblInvoices.Add(Cust);
returnVal = dBContext.SaveChanges();
}
//returnVal = dBContext.SaveChanges();
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return(returnVal);
}
public virtual async Task <InvoiceModel> PrepareInvoiceModelAsync(TblInvoices invoice)
{
var result = invoice.Adapt <InvoiceModel>();
result.UserName = invoice.User?.UserName;
result.InvoiceDetails = PrepareInvoiceDetailsModel(invoice.InvoiceDetails);
result.InvoiceSubTotal = invoice.ComputeInvoiceTotalAmount(false, false);
result.InvoiceTotal = invoice.ComputeInvoiceTotalAmount(false);
if (invoice.BillingAddress != null && invoice.BillingAddress.Any())
{
result.UserBillingAddress = PrepareInvoiceBillingAddressModel(invoice.BillingAddress.FirstOrDefault());
result.UserBillingAddress.InvoiceStatus = invoice.Status;
}
else
{
if (invoice.Status == InvoiceStatus.Pending && invoice.User != null)
{
//Try load user latest billing address
var address = await _invoiceService.FindUserLatestBillingAddressAsync(invoice.UserId) ??
new TblInvoiceBillingAddress()
{
Email = invoice.User.Email,
FirstName = invoice.User.FirstName,
LastName = invoice.User.LastName,
CountryId = invoice.User.UserCountryId ?? 0
};
result.UserBillingAddress = PrepareInvoiceBillingAddressModel(address);
result.UserBillingAddress.InvoiceStatus = invoice.Status;
}
}
if (result.UserBillingAddress == null)
{
result.UserBillingAddress = new InvoiceBillingAddressModel {
InvoiceStatus = invoice.Status
};
}
if (invoice.Status == InvoiceStatus.Paid)
{
result.PaymentGateways = new List <IPaymentMethod>()
{
_paymentGatewayManager.FindPaymentMethodBySystemName(invoice.PaymentGatewaySystemName)
};
}
else
{
result.PaymentGateways =
_paymentGatewayManager.GetAvailablePaymentGatewaysForCurrency(_workContext.CurrentCurrency.IsoCode);
}
return(result);
}
public virtual async Task <Guid> AddAsync(TblInvoices record)
{
_dbContext.Invoices.Add(record);
await _dbContext.SaveChangesAsync();
QueryCacheManager.ExpireTag(CacheTags.Invoice);
_eventPublisher.EntityInserted(record);
return(record.Id);
}
public DiscountProcessorResult ProcessorInvoice(TblInvoices invoice)
{
var result = new DiscountProcessorResult();
if (invoice == null)
{
return(result);
}
var appliedDiscountCode = _dbContext.InvoicesDiscountCode.FirstOrDefault(p => p.InvoiceId == invoice.Id);
if (appliedDiscountCode == null)
{
return(result);
}
var discountCode =
_dbContext.DiscountCode.FirstOrDefault(p => p.DiscountCode == appliedDiscountCode.DiscountCode.Trim());
if (discountCode == null)
{
return(result);
}
if (discountCode.ExpiryDate != null && discountCode.ExpiryDate < DateTime.Now)
{
return(result);
}
if (discountCode.MaxNumberOfUsage != null && discountCode.MaxNumberOfUsage <= _dbContext.InvoicesDiscountCode.Count(p => p.DiscountCode == appliedDiscountCode.DiscountCode && p.Invoice.Status == InvoiceStatus.Paid))
{
return(result);
}
if (discountCode.IsPercentage)
{
var invoiceTotal = invoice.ComputeInvoiceTotalAmount(false, false);
result.DiscountAmountInMainCurrency = (invoiceTotal * discountCode.DiscountAmount) / 100;
}
else
{
result.DiscountAmountInMainCurrency = discountCode.DiscountAmount;
}
result.Apply = true;
result.DiscountDescription = (string.IsNullOrWhiteSpace(discountCode.DiscountCodeTitle)
? _localizationService.GetResource("Plugin.DiscountCode.DiscountCode")
: discountCode.DiscountCodeTitle) +
$" ({(discountCode.IsPercentage ? discountCode.DiscountAmount.ToString("N2")+"%" : discountCode.DiscountAmount.ExchangeCurrencyStr(true))})";
return(result);
}
public static double ComputeInvoiceTotalAmount(this TblInvoices invoice, bool exchangeCurrency = true, bool withDiscountAndTax = true)
{
double sum = 0;
if (withDiscountAndTax)
{
sum = (invoice.InvoiceDetails?.Sum(p => p.UnitPrice * p.Qty) ?? 0) - (invoice.DiscountAmount ?? 0) + (invoice.TotalTaxAmount ?? 0);
}
else
{
sum = invoice.InvoiceDetails?.Sum(p => p.UnitPrice * p.Qty) ?? 0;
}
sum = sum < 0 ? 0 : sum;
return(exchangeCurrency ? sum.ExchangeCurrency() : sum);
}
protected virtual async Task <bool> UserHasAccessToInvoiceAsync(TblInvoices invoice, string userId)
{
if (invoice == null)
{
return(false);
}
if (string.IsNullOrWhiteSpace(userId))
{
return(invoice.UserId == null);
}
else
{
if (await _usersService.UserIsAdminAsync(userId))
{
return(true);
}
return(userId == invoice.UserId || invoice.UserId == null);
}
}
public virtual async Task <TblInvoices> ApplyInvoiceDiscountsAsync(TblInvoices invoice)
{
invoice.DiscountAmount = 0;
invoice.DiscountDescription = "";
var discountProcessors = _pluginFinder.GetPlugins <IDiscountProcessor>();
foreach (var discountProcessor in discountProcessors.OrderBy(p => p.Order))
{
var result = discountProcessor.ProcessorInvoice(invoice);
if (result.Apply)
{
invoice.DiscountAmount += result.DiscountAmountInMainCurrency;
invoice.DiscountDescription += result.DiscountDescription + " + ";
}
}
invoice.DiscountDescription = invoice.DiscountDescription.TrimEnd(" + ");
await SetDiscountAsync(invoice.Id, invoice.DiscountAmount, invoice.DiscountDescription);
return(invoice);
}
public virtual async Task <VerifyPaymentResult> VerifyPayment(TblInvoices invoice)
{
var result = new VerifyPaymentResult();
var token = invoice.PaymentGatewayToken;
var request = HttpContext.Current.Request;
if (string.IsNullOrWhiteSpace(request.QueryString["Status"]) ||
string.IsNullOrWhiteSpace(request.QueryString["token"]))
{
result.ErrorMessage = _localizationService.GetResource("Plugin.PaymentMethod.PayPal.StatusOrTokenInvalid");
return(result);
}
if (!request.QueryString["Status"].Equals("OK"))
{
result.ErrorMessage = _localizationService.GetResource("Plugin.PaymentMethod.PayPal.StatusFieldIsNotOK");
return(result);
}
await Task.Run(() =>
{
try
{
var service = new PayPalAPIInterfaceServiceService(GetPayPalConfig());
var getEcWrapper = new GetExpressCheckoutDetailsReq
{
GetExpressCheckoutDetailsRequest = new GetExpressCheckoutDetailsRequestType(token)
};
var getEcResponse = service.GetExpressCheckoutDetails(getEcWrapper);
var ecRequest = new DoExpressCheckoutPaymentRequestType();
var requestDetails = new DoExpressCheckoutPaymentRequestDetailsType();
ecRequest.DoExpressCheckoutPaymentRequestDetails = requestDetails;
requestDetails.PaymentDetails = getEcResponse.GetExpressCheckoutDetailsResponseDetails.PaymentDetails;
requestDetails.Token = token;
requestDetails.PayerID = getEcResponse.GetExpressCheckoutDetailsResponseDetails.PayerInfo.PayerID;
requestDetails.PaymentAction = PaymentActionCodeType.SALE;
var wrapper = new DoExpressCheckoutPaymentReq {
DoExpressCheckoutPaymentRequest = ecRequest
};
var doEcResponse = service.DoExpressCheckoutPayment(wrapper);
if (doEcResponse.Ack == AckCodeType.SUCCESS)
{
result.IsSuccess = true;
result.TransactionId = doEcResponse.DoExpressCheckoutPaymentResponseDetails.PaymentInfo[0].TransactionID;
}
else
{
foreach (var error in doEcResponse.Errors)
{
result.ErrorMessage +=
$"[{error.SeverityCode}] {error.ErrorCode} : {error.LongMessage} </br>";
}
}
}
catch
{
result.ErrorMessage = _localizationService.GetResource("Plugin.PaymentMethod.PayPal.ServiceUnavailable");
}
});
return(result);
}
public virtual async Task <PaymentRequestResult> RequestForPaymentUrl(string callbackUrl, TblInvoices invoice)
{
var settings = await _settingService.LoadSettingAsync <PayPalSettingsModel>();
var currentCurrency = DependencyResolver.Current.GetService <IWorkContext>().CurrentCurrency;
var amount = invoice.ComputeInvoiceTotalAmount();
var currencyCode = CurrencyCodeType.USD;
if (currentCurrency.IsoCode.ToLower().Trim() == "eur")
{
currencyCode = CurrencyCodeType.EUR;
}
var buyerEmail = "";
var paymentDesc = string.Format(_localizationService.GetResource("Plugin.PaymentMethod.PayPal.InvoiceNumber"), invoice.Id.ToString("N").ToUpper());
if (invoice.User != null)
{
buyerEmail = invoice.User.Email;
}
if (string.IsNullOrWhiteSpace(settings.APIUserName) ||
string.IsNullOrWhiteSpace(settings.APIPassword) ||
string.IsNullOrWhiteSpace(settings.APISignature))
{
return(new PaymentRequestResult()
{
ErrorMessage = _localizationService.GetResource("Plugin.PaymentMethod.PayPal.InvalidConfig")
});
}
var result = new PaymentRequestResult();
await Task.Run(() =>
{
try
{
var ecDetails = new SetExpressCheckoutRequestDetailsType()
{
ReturnURL = AppendQueryStringToUrl(callbackUrl, "Status", "OK"),
CancelURL = AppendQueryStringToUrl(callbackUrl, "Status", "NOK"),
LocaleCode = "US",
BuyerEmail = buyerEmail,
InvoiceID = invoice.Id.ToString(),
OrderDescription = paymentDesc,
ShippingMethod = ShippingServiceCodeType.DOWNLOAD,
PaymentAction = PaymentActionCodeType.SALE,
OrderTotal = new BasicAmountType(currencyCode, amount.ToString()),
NoShipping = "1", //PayPal does not display shipping address fields and removes shipping information from the transaction.
ReqConfirmShipping = "0", //do not require the buyer's shipping address be a confirmed address.
AddressOverride = "0", //The PayPal pages should not display the shipping address.
cppHeaderImage = settings.PayPalHeaderImageUrl,
BrandName = settings.PayPalBrandName,
};
var request = new SetExpressCheckoutRequestType(ecDetails);
var wrapper = new SetExpressCheckoutReq {
SetExpressCheckoutRequest = request
};
var service = new PayPalAPIInterfaceServiceService(GetPayPalConfig());
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
var setEcResponse = service.SetExpressCheckout(wrapper);
if (setEcResponse.Ack == AckCodeType.SUCCESS)
{
result.RedirectUrl = settings.PaymentPageUrl + "_express-checkout&token=" +
setEcResponse.Token;
result.Token = setEcResponse.Token;
result.IsSuccess = true;
}
else
{
foreach (var error in setEcResponse.Errors)
{
result.ErrorMessage +=
$"[{error.SeverityCode}] {error.ErrorCode} : {error.LongMessage} </br>";
}
}
}
catch
{
result.ErrorMessage = _localizationService.GetResource("Plugin.PaymentMethod.PayPal.ServiceUnavailable");
}
});
return(result);
}
public virtual async Task <VerifyPaymentResult> VerifyPayment(TblInvoices invoice)
{
var settings = await _settingService.LoadSettingAsync <ZarinPalSettingsModel>();
var currentCurrency = DependencyResolver.Current.GetService <IWorkContext>().CurrentCurrency;
var amount = invoice.ComputeInvoiceTotalAmount();
if (string.Compare(currentCurrency.IsoCode, "irr", StringComparison.OrdinalIgnoreCase) == 0)
{
amount = amount / 10;
}
var result = new VerifyPaymentResult();
var token = invoice.PaymentGatewayToken;
var request = HttpContext.Current.Request;
if (string.IsNullOrWhiteSpace(request.QueryString["Status"]) ||
string.IsNullOrWhiteSpace(request.QueryString["Authority"]))
{
result.ErrorMessage = _localizationService.GetResource("Plugin.PaymentMethod.Zarinpal.StatusOrAuthorityInvalid");
return(result);
}
if (!request.QueryString["Status"].Equals("OK"))
{
result.ErrorMessage = _localizationService.GetResource("Plugin.PaymentMethod.Zarinpal.StatusFieldIsNotOK");
return(result);
}
var zResult = 0;
long refId = 0;
var connectionError = false;
await Task.Run(() =>
{
try
{
using (var zarinpal = new com.zarinpal.www.PaymentGatewayImplementationService()
{
Url = settings.ZarinpalWebserviceUrl
})
{
zResult = zarinpal.PaymentVerification(settings.MerchantId,
token,
(int)amount,
out refId);
}
}
catch
{
connectionError = true;
}
});
if (zResult == 100)
{
result.IsSuccess = true;
result.TransactionId = refId.ToString();
}
else
{
result.ErrorMessage = connectionError ?
_localizationService.GetResource("Plugin.PaymentMethod.Zarinpal.ServiceUnavailable") :
$"[{zResult}] : {GetErrorDes(zResult)}";
}
return(result);
}
public virtual async Task <PaymentRequestResult> RequestForPaymentUrl(string callbackUrl, TblInvoices invoice)
{
var settings = await _settingService.LoadSettingAsync <ZarinPalSettingsModel>();
var currentCurrency = DependencyResolver.Current.GetService <IWorkContext>().CurrentCurrency;
var amount = invoice.ComputeInvoiceTotalAmount();
if (string.Compare(currentCurrency.IsoCode, "irr", StringComparison.OrdinalIgnoreCase) == 0)
{
amount = amount / 10;
}
var buyerEmail = "";
var buyerPhoneNumber = "";
var paymentDesc = string.Format(_localizationService.GetResource("Plugin.PaymentMethod.Zarinpal.InvoiceNumber"), invoice.Id.ToString("N").ToUpper());
if (invoice.User != null)
{
buyerEmail = invoice.User.Email;
buyerPhoneNumber = invoice.User.PhoneNumber;
}
if (string.IsNullOrWhiteSpace(settings.MerchantId))
{
return(new PaymentRequestResult()
{
ErrorMessage = _localizationService.GetResource("Plugin.PaymentMethod.Zarinpal.MerchantCodeIsInvalid")
});
}
var result = new PaymentRequestResult();
var zResult = 0;
var authority = "";
var connectionError = false;
await Task.Run(() =>
{
try
{
using (var zarinpal = new com.zarinpal.www.PaymentGatewayImplementationService()
{
Url = settings.ZarinpalWebserviceUrl
})
{
zResult = zarinpal.PaymentRequest(settings.MerchantId,
(int)amount,
paymentDesc,
buyerEmail,
buyerPhoneNumber,
callbackUrl,
out authority);
}
}
catch
{
connectionError = true;
}
});
if (zResult == 100)
{
result.RedirectUrl = string.Format(settings.ZarinpalPaymentPageUrl, authority);
result.Token = authority;
result.IsSuccess = true;
}
else
{
result.ErrorMessage = connectionError ?
_localizationService.GetResource("Plugin.PaymentMethod.Zarinpal.ServiceUnavailable") :
$"[{zResult}] : {GetErrorDes(zResult)}";
}
return(result);
}
public virtual async Task CheckoutInvoiceAsync(TblInvoices invoice, string transactionId)
{
var paidAmount = invoice.ComputeInvoiceTotalAmount(false);
await _dbContext.Invoices.Where(p => p.Id == invoice.Id)
.UpdateAsync(p => new TblInvoices()
{
PaidAmount = paidAmount,
Status = InvoiceStatus.Paid
});
if (invoice.PaymentDate == null)
{
await _dbContext.Invoices.Where(p => p.Id == invoice.Id)
.UpdateAsync(p => new TblInvoices()
{
PaymentDate = DateTime.Now,
});
}
if (!string.IsNullOrWhiteSpace(transactionId))
{
await _dbContext.Invoices.Where(p => p.Id == invoice.Id)
.UpdateAsync(p => new TblInvoices()
{
PaymentGatewayTransactionId = transactionId
});
}
QueryCacheManager.ExpireTag(CacheTags.Invoice);
_eventPublisher.Publish(new InvoiceCheckoutEvent(invoice, transactionId, paidAmount,
paidAmount.ExchangeCurrencyStr(), invoice.PaymentGatewayName, invoice.Currency.IsoCode));
//Process User Group Upgrade
var userGroupItem = invoice.InvoiceDetails.FirstOrDefault(p => p.ItemType == InvoiceDetailsItemType.SubscriptionPlan);
if (userGroupItem != null)
{
var userGroup = await _userGroupsService.FindByIdAsync(userGroupItem.ItemId);
if (userGroup != null && invoice.User != null)
{
//Upgrade user plan
await _usersService.UpgradeCustomerUserGroupAsync(invoice.UserId, userGroup);
//Purchase Expiration
await SetItemExpirationAsync(userGroupItem.Id, invoice.PaymentDate?.AddTimePeriodToDateTime(userGroup.SubscriptionExpirationPeriodType, userGroup.SubscriptionExpirationTime));
}
}
//Process Products
foreach (var productItem in invoice.InvoiceDetails.Where(p => p.ItemType == InvoiceDetailsItemType.Product))
{
var product = await _productService.FindByIdAsync(productItem.ItemId);
if (product != null)
{
//Purchase Expiration
await SetItemExpirationAsync(productItem.Id, invoice.PaymentDate?.AddTimePeriodToDateTime(product.PurchaseExpirationTimeType, product.PurchaseExpiration));
//License Code
if (!string.IsNullOrWhiteSpace(product.LicenseGeneratorServiceId))
{
var licenseGenerator = _licenseManager.FindLicenseGeneratorById(product.LicenseGeneratorServiceId);
if (licenseGenerator != null)
{
var license = await licenseGenerator.GenerateLicenseForProductAsync(invoice, invoice.User, product, productItem.Qty);
await SetItemLicenseAsync(productItem.Id, license);
}
}
}
}
//Process Products Attributes
foreach (var attributeItem in invoice.InvoiceDetails.Where(p => p.ItemType == InvoiceDetailsItemType.ProductAttribute))
{
var attribute = await _productCheckoutAttributesService.FindByIdAsync(attributeItem.ItemId);
if (attribute != null)
{
//License Code
if (!string.IsNullOrWhiteSpace(attribute.LicenseGeneratorServiceId))
{
var licenseGenerator = _licenseManager.FindLicenseGeneratorById(attribute.LicenseGeneratorServiceId);
if (licenseGenerator != null)
{
var license = await licenseGenerator.GenerateLicenseForProductAttributeAsync(invoice, invoice.User, attribute, attributeItem.Qty);
await SetItemLicenseAsync(attributeItem.Id, license);
}
}
}
}
//Process Products Attribute Options
foreach (var attributeOptionItem in invoice.InvoiceDetails.Where(p => p.ItemType == InvoiceDetailsItemType.ProductAttributeOption))
{
var attributeOption = await _productCheckoutAttributesService.FindOptionByIdAsync(attributeOptionItem.ItemId);
if (attributeOption != null)
{
//Purchase Expiration
await SetItemExpirationAsync(attributeOptionItem.Id, invoice.PaymentDate?.AddTimePeriodToDateTime(attributeOption.PurchaseExpirationTimeType, attributeOption.PurchaseExpiration));
//License Code
if (!string.IsNullOrWhiteSpace(attributeOption.LicenseGeneratorServiceId))
{
var licenseGenerator = _licenseManager.FindLicenseGeneratorById(attributeOption.LicenseGeneratorServiceId);
if (licenseGenerator != null)
{
var license = await licenseGenerator.GenerateLicenseForProductAttributeOptionAsync(invoice, invoice.User, attributeOption, attributeOptionItem.Qty);
await SetItemLicenseAsync(attributeOptionItem.Id, license);
}
}
}
}
}
public virtual async Task <TblInvoices> GetUserCurrentInvoiceAsync(bool createNewIfNull = true)
{
var currentUser = await _usersService.UserManager.FindByIdAsync(_workContext.CurrentUser?.Id);
TblInvoices invoice = null;
if (HttpContext.Current?.Session["CurrentInvoice"] is string invoiceIdStr)
{
if (Guid.TryParse(invoiceIdStr, out Guid invoiceId))
{
//from session
invoice = await FindByIdAsync(invoiceId);
}
}
//from cookies
if (invoice == null)
{
var cookie = HttpContext.Current?.Request.Cookies["UserSetting"] ?? new HttpCookie("UserSetting");
if (!string.IsNullOrWhiteSpace(cookie?.Values["CurrentInvoice"]))
{
if (Guid.TryParse(cookie.Values["CurrentInvoice"], out Guid invoiceId))
{
//from cookie
invoice = await FindByIdAsync(invoiceId);
}
}
}
if (invoice?.Status == InvoiceStatus.Paid)
{
if (invoice.UserId == null && currentUser != null)
{
//Set Invoice user Id if User loged in
await SetUserIdAsync(invoice.Id, currentUser.Id);
}
invoice = null;
}
if (invoice?.UserId != null)
{
invoice = null;
}
//get current user latest open invoice from DB
if (currentUser != null && invoice == null)
{
invoice = await GetAsQueryable()
.Include(p => p.InvoiceDetails)
.Include(p => p.User)
.Include(p => p.Currency)
.Include(p => p.BillingAddress)
.OrderByDescending(p => p.CreateDate)
.AsNoTracking()
.DeferredFirstOrDefault(p => p.UserId == currentUser.Id && p.Status == InvoiceStatus.Pending)
.FromCacheAsync(CacheTags.Invoice);
}
if (invoice == null && createNewIfNull)
{
//Create new invoice
invoice = new TblInvoices()
{
CreateDate = DateTime.Now,
Status = InvoiceStatus.Pending,
};
await AddAsync(invoice);
}
if (invoice != null && invoice.UserId == null && currentUser != null)
{
//Set Invoice user Id, if User loged in
invoice.UserId = currentUser.Id;
await SetUserIdAsync(invoice.Id, currentUser.Id);
}
//Save Invoice Id in Session & user Cookies
if (invoice != null && HttpContext.Current != null)
{
HttpContext.Current.Session["CurrentInvoice"] = invoice.Id.ToString();
if (!HttpContext.Current.Response.HeadersWritten && !new HttpRequestWrapper(HttpContext.Current.Request).IsAjaxRequest())
{
var responseCookie = HttpContext.Current.Request.Cookies["UserSetting"] ?? new HttpCookie("UserSetting");
responseCookie.Values["CurrentInvoice"] = invoice.Id.ToString();
responseCookie.Expires = DateTime.Now.AddYears(1).ToUniversalTime();
HttpContext.Current.Response.Cookies.Add(responseCookie);
}
}
return(invoice);
}
public virtual async Task <string> GenerateLicenseForProductAttributeOptionAsync(TblInvoices invoice, TblUsers user,
TblProductCheckoutAttributeOptions attributeOption, int quantity)
{
return("Test product checkout attribute option license for : " + attributeOption.GetLocalized(p => p.Name));
}
public virtual async Task <string> GenerateLicenseForProductAsync(TblInvoices invoice, TblUsers user,
TblProducts product, int quantity)
{
return("Test product license for : " + product.GetLocalized(p => p.Title));
}
