public RefundResponse Refund(RefundRequest request) { var refundService = new StripeRefundService(); var result = _refundResponseCreator.CreateResponse(refundService.Create(request.ChargeId, _refundRequestCreator.CreateRequest(request))); return(result); }
static void GetChargeRefunds(StripeRefundService refundService, TraceWriter log) { string lastObjectId = GetLastObjectID(); StripeList <StripeRefund> refundItems = null; //DateTime greaterEqualCreated = DateTime.UtcNow.AddHours(-48); //var lesserThanCreatedFilter = GetMinCreatedTime(); log.Info($"LastObjectId: {lastObjectId}"); var listOptions = new StripeRefundListOptions() { Limit = 100, StartingAfter = lastObjectId, }; DateTime?lastRefundCreated = null; do { refundItems = refundService.List(listOptions); foreach (var r in refundItems.Data) { //log.Info(r.ToString()); var Refunds = StripeRefundToStripeTransaction(r); UpsertStripeRefunds(Refunds, log); } lastObjectId = refundItems.Data.LastOrDefault()?.Id; lastRefundCreated = refundItems.Data.LastOrDefault()?.Created; listOptions.StartingAfter = lastObjectId; log.Info($"Refund last ObjectId: {lastObjectId}. Created: {lastRefundCreated} "); } while (refundItems.HasMore); }
public StripeProcessor(ISettingService settingService, ICurrencyService currencyService, ICustomerService customerService, CurrencySettings currencySettings, IWebHelper webHelper, IOrderTotalCalculationService orderTotalCalculationService, IOrderService orderService, StripePaymentSettings stripePaymentSettings, ILocalizationService localizationService, ILogger logger) { _stripePaymentSettings = stripePaymentSettings; _settingService = settingService; _currencyService = currencyService; _customerService = customerService; _currencySettings = currencySettings; _webHelper = webHelper; _orderTotalCalculationService = orderTotalCalculationService; _orderService = orderService; _localizationService = localizationService; _logger = logger; if (!stripePaymentSettings.IsValid()) { return; } StripeConfiguration.SetApiKey(stripePaymentSettings.SecretApiKey); _chargeService = new StripeChargeService(); _tokenService = new StripeTokenService(); _refundService = new StripeRefundService(); ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12; }
static void GetRefundsForLast24Hours(StripeChargeService chargeService, TraceWriter log) { StripeRefundService refundService = new StripeRefundService(); refundService.ExpandBalanceTransaction = true; refundService.ExpandCharge = true; StripeRefundListOptions refundListOptions = new StripeRefundListOptions() { Limit = 50 }; DateTime greaterEqualCreated = DateTime.UtcNow.AddHours(-24); IEnumerable <StripeRefund> refunds; string lastObjectId = null; DateTime?lastRefundCreated = null; do { refunds = refundService.List(refundListOptions); foreach (var r in refunds) { //var c = chargeService.Get(r.ChargeId); //var trans = StripeChargeToStripeTransaction(c); var trans = StripeRefundToStripeTransaction(r); UpsertStripeTransaction(trans, log); } lastObjectId = refunds.LastOrDefault()?.Id; lastRefundCreated = refunds.LastOrDefault()?.Created; refundListOptions.StartingAfter = lastObjectId; log.Info($"Refund last ObjectId: {lastObjectId}. Created: {lastRefundCreated} "); } while (refunds.Count() == 10 && lastRefundCreated.HasValue && lastRefundCreated.Value >= greaterEqualCreated); }
public async Task CancelAndRecoverChargesAsync(ISubscriber subscriber) { if (!string.IsNullOrWhiteSpace(subscriber.GatewaySubscriptionId)) { var subscriptionService = new StripeSubscriptionService(); await subscriptionService.CancelAsync(subscriber.GatewaySubscriptionId, false); } if (string.IsNullOrWhiteSpace(subscriber.GatewayCustomerId)) { return; } var chargeService = new StripeChargeService(); var charges = await chargeService.ListAsync(new StripeChargeListOptions { CustomerId = subscriber.GatewayCustomerId }); if (charges?.Data != null) { var refundService = new StripeRefundService(); foreach (var charge in charges.Data.Where(c => !c.Refunded)) { await refundService.CreateAsync(charge.Id); } } var customerService = new StripeCustomerService(); await customerService.DeleteAsync(subscriber.GatewayCustomerId); }
public static string RefundToUser(string chargeId, bool isFullRefund, int specificAmount) { try { string stripekey = ConfigurationManager.AppSettings["AdminStripeApiKey"]; StripeConfiguration.SetApiKey(stripekey); StripeRefundCreateOptions refundOptions; if (isFullRefund == true) { refundOptions = new StripeRefundCreateOptions() { Reason = StripeRefundReasons.RequestedByCustomer, //RefundApplicationFee = true }; } else { refundOptions = new StripeRefundCreateOptions() { Reason = StripeRefundReasons.RequestedByCustomer, //RefundApplicationFee = true, Amount = specificAmount * 100 }; } var refundService = new StripeRefundService(); StripeRefund refund = refundService.Create(chargeId, refundOptions); return(refund.Id); } catch (Exception ex) { Common.ExcepLog(ex); return(null); } }
public async Task <StripeRefund> RefundChargeAsync(string chargeId, StripeRefundCreateOptions options, string apiKey) { var refundService = new StripeRefundService(apiKey); var refund = refundService.Create(chargeId, options); return(refund); }
public void Refund(string paymentId, int amount) { var chargeService = new StripeRefundService(); new StripeRefundCreateOptions().Amount = amount; chargeService.Create(paymentId); }
private StripeRefund CreateStripeRefund(long Amount, string ChargeID) { var refundOptions = new StripeRefundCreateOptions() { Amount = (int)Amount, Reason = StripeRefundReasons.Unknown }; var refundService = new StripeRefundService(); return(refundService.Create(ChargeID, refundOptions)); }
private StripeRefund CallStripeRefund(string stripeChargeId, double diffPrice) { var refundService = new StripeRefundService(); StripeRefund refund = refundService.Create(stripeChargeId, new StripeRefundCreateOptions() { Amount = Convert.ToInt32(diffPrice * 100), Reason = StripeRefundReasons.RequestedByCustomer }); return(refund); }
public static StripeRefund RefundCharge(string chargeId) { try { var refundService = new StripeRefundService(); StripeRefund refund = refundService.Create(chargeId); return(refund); } catch (Exception ex) { var exp = ex.Message.ToString(); return(null); } }
public static StripeRefund RefundCharge(string token, int amount) { // Set your secret key: remember to change this to your live secret key in production // See your keys here: https://dashboard.stripe.com/account/apikeys StripeConfiguration.SetApiKey(MasterStrings.StripeSecretKey); var refundOptions = new StripeRefundCreateOptions() { Amount = amount, Reason = "requested_by_customer" }; var refundService = new StripeRefundService(); StripeRefund refund = refundService.Create(token, refundOptions); return(refund); }
public static void Run([TimerTrigger("0 0 7 * * *")] TimerInfo myTimer, TraceWriter log) { if (myTimer.IsPastDue) { log.Info("Timer is running late!"); } log.Info($"C# Timer trigger function executed at: {DateTime.Now}"); StripeRefundService refundService = new StripeRefundService(); refundService.ExpandBalanceTransaction = true; refundService.ExpandFailureBalanceTransaction = true; refundService.ExpandCharge = true; StripeConfiguration.SetApiKey(ConfigurationManager.AppSettings["StripeApiKey"]); GetChargeRefunds48hrs(refundService, log); //GetChargeRefunds(refundService, log); }
public RefundService (IWorkContext workContext, ILogger logger, StripeConnectPaymentSettings stripeConnectPaymentSettings, IWebHelper webHelper, HttpClient httpClient, ICustomerEntityService customerEntityService, IChargeService chargeService, IOrderChargeEntityService chargeEntityService) { _workContext = workContext; _logger = logger; _stripeConnectPaymentSettings = stripeConnectPaymentSettings; _webHelper = webHelper; _httpClient = httpClient; _customerEntityService = customerEntityService; _chargeService = chargeService; _chargeEntityService = chargeEntityService; _stripeRefundService = new StripeRefundService(_stripeConnectPaymentSettings.SecretKey); }
public static List <Transaction> GetDonorBoxTransactions(string apiKey, DateTime startDate, DateTime endDate) { StripeConfiguration.SetApiKey(apiKey); var transactions = new List <Transaction>(); var balanceClient = new StripeBalanceService(); var parameters = new StripeBalanceTransactionListOptions(); var chargeClient = new StripeChargeService(); var refundClient = new StripeRefundService(); parameters.Created = new StripeDateFilter { GreaterThanOrEqual = startDate, LessThanOrEqual = endDate }; parameters.Limit = 100; foreach (var balanceTransaction in balanceClient.List(parameters).Where(t => t.Type != "payout")) { StripeCharge charge = null; if (balanceTransaction.Type == "charge" || balanceTransaction.Type == "payment") { charge = chargeClient.Get(balanceTransaction.SourceId); } else if (balanceTransaction.Type == "refund") { var chargeId = refundClient.Get(balanceTransaction.SourceId).ChargeId; charge = chargeClient.Get(chargeId); } if (charge?.Status == "succeeded") { transactions.Add(StripeMapping.MapToTransaction(balanceTransaction, charge)); } } return(transactions); }
public StripeRefundServiceTest() { this.service = new StripeRefundService(); this.createOptions = new StripeRefundCreateOptions() { Amount = 123, }; this.updateOptions = new StripeRefundUpdateOptions() { Metadata = new Dictionary <string, string>() { { "key", "value" }, }, }; this.listOptions = new StripeRefundListOptions() { Limit = 1, }; }
private void CreateRefund(Transaction t) { StripeConfiguration.SetApiKey(Settings.StripeApiKey); var refundService = new StripeRefundService(); var refundOptions = new StripeRefundCreateOptions(); refundOptions.Amount = (int)(t.Amount * 100); var refund = refundService.Create(t.PreviousTransactionNumber, refundOptions); if (refund.Id.Length > 0) { t.Result.Succeeded = true; t.Result.ReferenceNumber = refund.Id; } else { t.Result.Succeeded = false; t.Result.ResponseCode = "FAIL"; t.Result.ResponseCodeDescription = "Stripe Failure"; } }
public async Task <Tuple <Organization, OrganizationUser> > SignUpAsync(OrganizationSignup signup) { var plan = StaticStore.Plans.FirstOrDefault(p => p.Type == signup.Plan && !p.Disabled); if (plan == null) { throw new BadRequestException("Plan not found."); } var customerService = new StripeCustomerService(); var subscriptionService = new StripeSubscriptionService(); StripeCustomer customer = null; StripeSubscription subscription = null; if (!plan.CanBuyAdditionalSeats && signup.AdditionalSeats > 0) { throw new BadRequestException("Plan does not allow additional users."); } if (plan.CanBuyAdditionalSeats && plan.MaxAdditionalSeats.HasValue && signup.AdditionalSeats > plan.MaxAdditionalSeats.Value) { throw new BadRequestException($"Selected plan allows a maximum of " + $"{plan.MaxAdditionalSeats.GetValueOrDefault(0)} additional users."); } if (plan.Type == PlanType.Free) { var ownerExistingOrgCount = await _organizationUserRepository.GetCountByFreeOrganizationAdminUserAsync(signup.Owner.Id); if (ownerExistingOrgCount > 0) { throw new BadRequestException("You can only be an admin of one free organization."); } } else { customer = await customerService.CreateAsync(new StripeCustomerCreateOptions { Description = signup.BusinessName, Email = signup.BillingEmail, SourceToken = signup.PaymentToken }); var subCreateOptions = new StripeSubscriptionCreateOptions { Items = new List <StripeSubscriptionItemOption> { new StripeSubscriptionItemOption { PlanId = plan.StripePlanId, Quantity = 1 } } }; if (signup.AdditionalSeats > 0) { subCreateOptions.Items.Add(new StripeSubscriptionItemOption { PlanId = plan.StripeSeatPlanId, Quantity = signup.AdditionalSeats }); } try { subscription = await subscriptionService.CreateAsync(customer.Id, subCreateOptions); } catch (StripeException) { if (customer != null) { await customerService.DeleteAsync(customer.Id); } throw; } } var organization = new Organization { Name = signup.Name, BillingEmail = signup.BillingEmail, BusinessName = signup.BusinessName, PlanType = plan.Type, Seats = (short)(plan.BaseSeats + signup.AdditionalSeats), MaxSubvaults = plan.MaxSubvaults, Plan = plan.Name, StripeCustomerId = customer?.Id, StripeSubscriptionId = subscription?.Id, CreationDate = DateTime.UtcNow, RevisionDate = DateTime.UtcNow }; try { await _organizationRepository.CreateAsync(organization); var orgUser = new OrganizationUser { OrganizationId = organization.Id, UserId = signup.Owner.Id, Key = signup.OwnerKey, Type = OrganizationUserType.Owner, Status = OrganizationUserStatusType.Confirmed, AccessAllSubvaults = true, CreationDate = DateTime.UtcNow, RevisionDate = DateTime.UtcNow }; await _organizationUserRepository.CreateAsync(orgUser); // push await _pushService.PushSyncOrgKeysAsync(signup.Owner.Id); return(new Tuple <Organization, OrganizationUser>(organization, orgUser)); } catch { if (subscription != null) { await subscriptionService.CancelAsync(subscription.Id, false); } if (customer != null) { var chargeService = new StripeChargeService(); var charges = await chargeService.ListAsync(new StripeChargeListOptions { CustomerId = customer.Id }); if (charges?.Data != null) { var refundService = new StripeRefundService(); foreach (var charge in charges.Data.Where(c => !c.Refunded)) { await refundService.CreateAsync(charge.Id); } } await customerService.DeleteAsync(customer.Id); } if (organization.Id != default(Guid)) { await _organizationRepository.DeleteAsync(organization); } throw; } }
public HttpResponseMessage ProcessTransaction(IncomingProcessTransaction model) { return(ErrorFactory.Handle(() => { var userId = User?.Identity?.GetUserId(); if (string.IsNullOrWhiteSpace(userId)) { throw new Exception(); } var context = new PoolReservationEntities(); using (var unitOfWork = new UnitOfWork(context)) { PrepareAndGetReservationForProcessing_Result reservation = null; try { reservation = context.PrepareAndGetReservationForProcessing(model.ReservationId)?.FirstOrDefault(); } catch (Exception) { context.ChangeProcessingStatusToPending(model.ReservationId); } if (reservation == null) { try { context.ChangeProcessingStatusToPending(model.ReservationId); } catch (Exception) { } return JsonFactory.CreateJsonMessage(null, HttpStatusCode.NotFound, this.Request); } if (reservation.StatusId != Convert.ToInt32(ReservationGroupStatusEnum.PROCESSING)) { try { context.ChangeProcessingStatusToPending(model.ReservationId); } catch (Exception) { } return JsonFactory.CreateJsonMessage(new OutgoingMessage { Action = "wrongStatus" }, HttpStatusCode.NotFound, this.Request); } ReservationGroup reservationDBObject = null; try { reservationDBObject = unitOfWork.Reservations.GetReservationWithItems(userId, model.ReservationId); if (reservationDBObject == null) { return JsonFactory.CreateJsonMessage(null, HttpStatusCode.NotFound, this.Request); } } catch (Exception) { context.ChangeProcessingStatusToPending(model.ReservationId); } if (reservationDBObject.StatusId != Convert.ToInt32(ReservationGroupStatusEnum.PROCESSING)) { try { context.ChangeProcessingStatusToPending(model.ReservationId); } catch (Exception) { } return JsonFactory.CreateJsonMessage(new OutgoingMessage { Action = "wrongStatus" }, HttpStatusCode.NotFound, this.Request); } ReservationTransaction resTransaction = null; int stripeModifiedPriceInCents = 0; try { decimal priceToCharge = 0M; foreach (var item in reservationDBObject.ReserveItems) { if (item.IsDeleted == true) { continue; } priceToCharge += item.FinalPrice; } decimal stripeModifiedPrice = priceToCharge * 100.0M; stripeModifiedPriceInCents = (int)Math.Round(stripeModifiedPrice); //Must Update Repo If Changed. Rounds to the nearest penny. if (stripeModifiedPriceInCents <= 50) { return JsonFactory.CreateJsonMessage(new OutgoingMessage { Action = "noPriceToCharge" }, HttpStatusCode.NotFound, this.Request); } resTransaction = unitOfWork.Reservations.AddStripeChargeToPendingReservation(userId, userId, model.ReservationId, model.StripeTokenId, priceToCharge); unitOfWork.Complete(); } catch (Exception e) { context.ChangeProcessingStatusToPending(model.ReservationId); } string chargeId = null; try { if (resTransaction == null) { throw new Exception(); } var myCharge = new StripeChargeCreateOptions(); // always set these properties myCharge.Amount = stripeModifiedPriceInCents; myCharge.Currency = "usd"; // set this if you want to myCharge.Description = "JustMosey Reservation"; myCharge.SourceTokenOrExistingSourceId = model.StripeTokenId; // (not required) set this to false if you don't want to capture the charge yet - requires you call capture later myCharge.Capture = true; var chargeService = new StripeChargeService(); StripeCharge stripeCharge = chargeService.Create(myCharge); chargeId = stripeCharge.Id; unitOfWork.Reservations.UpdateStripeSuccessfulChargeOnPendingReservation(userId, userId, resTransaction.Id, chargeId); unitOfWork.Complete(); } catch (Exception e) { try { var refundService = new StripeRefundService(); StripeRefund refund = refundService.Create(chargeId, new StripeRefundCreateOptions() { Amount = stripeModifiedPriceInCents, Reason = StripeRefundReasons.Unknown }); } catch (Exception) { } try { unitOfWork.Reservations.RefundStripeSuccessfulChargeOnPendingReservation(userId, userId, resTransaction.Id); unitOfWork.Complete(); } catch (Exception) { } try { } catch (Exception) { context.ChangeProcessingStatusToPending(model.ReservationId); } return JsonFactory.CreateJsonMessage(new OutgoingMessage { Action = "unknownErrorAfterProcessing" }, HttpStatusCode.InternalServerError, this.Request); } try { var updatedReservationDBObject = unitOfWork.Reservations.GetReservationWithItems(userId, model.ReservationId); var outgoingRes = OutgoingReservationGroup.Parse(updatedReservationDBObject); return JsonFactory.CreateJsonMessage(outgoingRes, HttpStatusCode.OK, this.Request); } catch (Exception) { return JsonFactory.CreateJsonMessage(null, HttpStatusCode.OK, this.Request); } } }, this.Request)); }
public int Add(AddSubscriptionBookingParams param) { try { using (var transaction = new TransactionScope()) { var bookingCode = Helper.RandomString(Constant.BookingCodeLength); while (IsBookingCodeExists(bookingCode)) { bookingCode = Helper.RandomString(Constant.BookingCodeLength); } param.SubscriptionBookingsObject.BookingCode = bookingCode; // Insert New Bookings DayaxeDbContext.SubscriptionBookings.InsertOnSubmit(param.SubscriptionBookingsObject); Commit(); if (param.SubscriptionBookingDiscounts != null && param.SubscriptionBookingDiscounts.Id > 0) { var subscriptionDiscount = new SubscriptionBookingDiscounts { DiscountId = param.SubscriptionBookingDiscounts.Id, SubscriptionBookingId = param.SubscriptionBookingsObject.Id, SubscriptionId = param.SubscriptionBookingsObject.SubscriptionId }; DayaxeDbContext.SubscriptionBookingDiscounts.InsertOnSubmit(subscriptionDiscount); } // Insert to History for First Cycle var cycle = new SubscriptionCycles { SubscriptionBookingId = param.SubscriptionBookingsObject.Id, StartDate = param.SubscriptionBookingsObject.StartDate, EndDate = param.SubscriptionBookingsObject.EndDate, CancelDate = param.SubscriptionBookingsObject.CancelDate, LastUpdatedBy = param.SubscriptionBookingsObject.LastUpdatedBy, LastUpdatedDate = param.SubscriptionBookingsObject.LastUpdatedDate, Status = param.SubscriptionBookingsObject.Status, Price = param.ActualPrice, MerchantPrice = param.MerchantPrice, PayByCredit = param.PayByCredit, TotalPrice = param.TotalPrice, Quantity = param.SubscriptionBookingsObject.Quantity, StripeChargeId = string.Empty, StripeCouponId = param.SubscriptionBookingsObject.StripeCouponId, StripeInvoiceId = string.Empty, CycleNumber = 1 }; DayaxeDbContext.SubscriptionCycles.InsertOnSubmit(cycle); // Insert Discount for Current Customer active Subscription var discount = new Discounts { DiscountName = string.Format("{0} - {1} {2}", param.SubscriptionName, param.FirstName, param.LastName), Code = string.Format("SUP{0}", Helper.RandomString(8)), StartDate = param.SubscriptionBookingsObject.StartDate, EndDate = param.SubscriptionBookingsObject.EndDate, CodeRequired = true, PercentOff = 100, PromoType = (byte)Enums.PromoType.SubscriptionPromo, MinAmount = 0, IsAllProducts = true, MaxPurchases = (byte)param.MaxPurchases }; DayaxeDbContext.Discounts.InsertOnSubmit(discount); Commit(); // Add Invoices var subscriptionInvoice = new SubscriptionInvoices { SubscriptionCyclesId = cycle.Id, BookingStatus = cycle.Status, Quantity = cycle.Quantity, Price = cycle.Price, MerchantPrice = cycle.MerchantPrice, PayByCredit = cycle.PayByCredit, TotalPrice = cycle.TotalPrice, InvoiceStatus = (int)Enums.InvoiceStatus.Charge, StripeChargeId = cycle.StripeChargeId, ChargeAmount = cycle.Price, StripeRefundId = string.Empty, RefundAmount = 0, RefundCreditAmount = 0, StripeCouponId = cycle.StripeCouponId, CreatedDate = DateTime.UtcNow, CreatedBy = 1 }; DayaxeDbContext.SubscriptionInvoices.InsertOnSubmit(subscriptionInvoice); var discountUsed = new SubsciptionDiscountUseds { CustomerId = param.SubscriptionBookingsObject.CustomerId, DiscountId = discount.Id, SubscriptionBookingId = param.SubscriptionBookingsObject.Id }; DayaxeDbContext.SubsciptionDiscountUseds.InsertOnSubmit(discountUsed); var cusCredits = DayaxeDbContext.CustomerCredits .SingleOrDefault(cc => cc.CustomerId == param.CustomerCreditsObject.CustomerId); // Add Logs when refund by Upgrade to Subscription if (param.RefundCreditByUpgrade > 0) { var creditLogs = new CustomerCreditLogs { Amount = param.RefundCreditByUpgrade, ProductId = 0, BookingId = 0, SubscriptionId = param.SubscriptionBookingsObject.SubscriptionId, CreatedBy = param.CustomerCreditsObject.CustomerId, CreatedDate = DateTime.UtcNow, CreditType = (byte)Enums.CreditType.PartialPuchaseRefund, Description = param.RefundCreditDescription, CustomerId = param.CustomerCreditsObject.CustomerId, ReferralId = param.CustomerCreditsObject.ReferralCustomerId, SubscriptionBookingId = param.SubscriptionBookingsObject.Id, Status = true, GiftCardId = 0 }; DayaxeDbContext.CustomerCreditLogs.InsertOnSubmit(creditLogs); if (cusCredits != null) { cusCredits.Amount += param.RefundCreditByUpgrade; } } // Add Logs when pay by DayAxe Credit if (param.PayByCredit > 0) { var creditLogs = new CustomerCreditLogs { Amount = param.PayByCredit, ProductId = 0, BookingId = 0, SubscriptionId = param.SubscriptionBookingsObject.SubscriptionId, CreatedBy = param.CustomerCreditsObject.CustomerId, CreatedDate = DateTime.UtcNow, CreditType = (byte)Enums.CreditType.Charge, Description = param.Description, CustomerId = param.CustomerCreditsObject.CustomerId, ReferralId = param.CustomerCreditsObject.ReferralCustomerId, SubscriptionBookingId = param.SubscriptionBookingsObject.Id, Status = true, GiftCardId = 0 }; DayaxeDbContext.CustomerCreditLogs.InsertOnSubmit(creditLogs); if (cusCredits != null) { cusCredits.Amount -= param.PayByCredit; } } // First Buy of referral if (param.CustomerCreditsObject != null && param.CustomerCreditsObject.ReferralCustomerId > 0 && ( DayaxeDbContext.Bookings.Count(x => x.CustomerId == param.SubscriptionBookingsObject.CustomerId) == 1 || DayaxeDbContext.SubscriptionBookings.Count(x => x.CustomerId == param.SubscriptionBookingsObject.CustomerId) == 1)) { var logs = DayaxeDbContext.CustomerCreditLogs .Where(ccl => ccl.CustomerId == param.CustomerCreditsObject.ReferralCustomerId && ccl.ReferralId == param.SubscriptionBookingsObject.CustomerId && !ccl.Status) .ToList(); if (logs.Any()) { logs.ForEach(log => { var cus = DayaxeDbContext.CustomerCredits .FirstOrDefault(cc => cc.CustomerId == log.CustomerId); if (cus != null) { cus.Amount += log.Amount; } log.Status = true; }); Commit(); } } // Add to Customer Credit Log var logsReferred = DayaxeDbContext.CustomerCreditLogs .Where(ccl => ccl.ReferralId == param.SubscriptionBookingsObject.CustomerId && !ccl.Status) .ToList(); if (logsReferred.Any()) { logsReferred.ForEach(log => { var cus = DayaxeDbContext.CustomerCredits .FirstOrDefault(cc => cc.CustomerId == log.CustomerId); if (cus != null) { cus.Amount += log.Amount; } log.Status = true; }); } // Insert Schedule var schedules = new Schedules { ScheduleSendType = (int)Enums.ScheduleSendType.IsEmailConfirmSubscription, Name = "Send Email confirm Subscription", Status = (int)Enums.ScheduleType.NotRun, SubscriptionBookingId = param.SubscriptionBookingsObject.Id }; DayaxeDbContext.Schedules.InsertOnSubmit(schedules); // Maybe not use here because flow upgrade to subscription do not use this if (param.BookingId > 0) { var bookings = DayaxeDbContext.Bookings.FirstOrDefault(b => b.BookingId == param.BookingId); if (bookings != null) { var chargePrice = (int)((bookings.TotalPrice - bookings.HotelPrice) * 100); try { bookings.TotalPrice -= bookings.HotelPrice; bookings.PassStatus = (int)Enums.BookingStatus.Active; var discounts = new DiscountBookings { DiscountId = discount.Id, ProductId = bookings.ProductId, BookingId = bookings.BookingId }; DayaxeDbContext.DiscountBookings.InsertOnSubmit(discounts); bookings.IsActiveSubscription = true; string responseString; if (chargePrice > 0) { var chargeService = new StripeChargeService(); StripeCharge charge = chargeService.Capture(bookings.StripeChargeId, chargePrice); responseString = charge.StripeResponse.ResponseJson; } else { var refundOptions = new StripeRefundCreateOptions { Reason = StripeRefundReasons.RequestedByCustomer }; var refundService = new StripeRefundService(); StripeRefund refund = refundService.Create(bookings.StripeChargeId, refundOptions); responseString = refund.StripeResponse.ResponseJson; } var logs = new Logs { LogKey = "UpgradeSubscriptionCharge", UpdatedContent = string.Format("Params: {0} - Response: {1}", JsonConvert.SerializeObject(param, CustomSettings.SerializerSettings()), responseString), UpdatedBy = param.SubscriptionBookingsObject.CustomerId, UpdatedDate = DateTime.UtcNow }; AddLog(logs); } catch (Exception ex) { var logs = new Logs { LogKey = "UpgradeSubscriptionChargeError", UpdatedContent = string.Format("Params: {0} - {1} - {2} - {3}", JsonConvert.SerializeObject(param, CustomSettings.SerializerSettings()), ex.Message, ex.StackTrace, ex.Source), UpdatedBy = param.SubscriptionBookingsObject.CustomerId, UpdatedDate = DateTime.UtcNow }; AddLog(logs); } } } Commit(); transaction.Complete(); } } catch (Exception ex) { var logs = new Logs { LogKey = "AddBookingError", UpdatedContent = string.Format("{0} - {1} - {2} - {3}", param.SubscriptionBookingsObject.CustomerId, ex.Message, ex.StackTrace, ex.Source), UpdatedBy = param.SubscriptionBookingsObject.CustomerId, UpdatedDate = DateTime.UtcNow }; AddLog(logs); throw new Exception(ex.Message, ex); } return(param.SubscriptionBookingsObject.Id); }