public InvoiceItemServiceTest(MockHttpClientFixture mockHttpClientFixture)
: base(mockHttpClientFixture)
{
this.service = new InvoiceItemService();
this.createOptions = new InvoiceItemCreateOptions
{
Amount = 123,
Currency = "usd",
CustomerId = "cus_123",
};
this.updateOptions = new InvoiceItemUpdateOptions
{
Metadata = new Dictionary <string, string>
{
{ "key", "value" },
},
};
this.listOptions = new InvoiceItemListOptions
{
Limit = 1,
};
}
public void CreatePending_ApplyAllPrices_ItemCreatedWithAllPricesApplied()
{
var id = Guid.NewGuid();
var jobItemId = _jobItemForCreatePendingId;
var invoiceItemRepositoryMock = MockRepository.GenerateMock <IInvoiceItemRepository>();
invoiceItemRepositoryMock.Stub(x => x.JobItemHasPendingInvoiceItem(jobItemId)).Return(false);
invoiceItemRepositoryMock.Expect(x => x.CreatePendingItem(null)).IgnoreArguments();
_invoiceItemService = InvoiceItemServiceFactory.Create(
_userContext,
CompanyDetailsRepositoryTestHelper.GetCompanyDetailsRepository_StubsApplyAllPrices_ReturnsTrue(),
MockRepository.GenerateStub <IInvoiceRepository>(),
invoiceItemRepositoryMock,
JobItemRepositoryTestHelper.GetJobItemRepository_StubsGetById_ReturnsJobItem(_jobItemForCreatePending),
QuoteItemRepositoryTestHelper.GetQuoteItemRepository_StubsGetQuoteItemForJobItem_ReturnsQuoteItem(jobItemId, _quoteItemForCreatePending),
MockRepository.GenerateStub <IListItemRepository>());
CreatePending(id, jobItemId);
invoiceItemRepositoryMock.VerifyAllExpectations();
Assert.AreNotEqual(Guid.Empty, _savedPendingItem.Id);
Assert.IsNotNull(_savedPendingItem.JobItem);
Assert.AreEqual(_quoteItemForCreatePending.JobItem.Instrument.ToString(), _savedPendingItem.Description);
Assert.AreEqual(_quoteItemForCreatePending.Quote.OrderNumber, _savedPendingItem.OrderNo);
Assert.AreEqual(_quoteItemForCreatePending.Calibration, _savedPendingItem.CalibrationPrice);
Assert.AreEqual(_quoteItemForCreatePending.Labour, _savedPendingItem.RepairPrice);
Assert.AreEqual(_quoteItemForCreatePending.Parts, _savedPendingItem.PartsPrice);
Assert.AreEqual(_quoteItemForCreatePending.Carriage, _savedPendingItem.CarriagePrice);
Assert.AreEqual(_quoteItemForCreatePending.Investigation, _savedPendingItem.InvestigationPrice);
}
public void CreatePending_QuoteItemPrepared_DomainValidationExceptionThrown()
{
var id = Guid.NewGuid();
var jobItemId = _jobItemForCreatePendingId;
_quoteItemForCreatePending.Status =
new ListItem
{
Id = Guid.NewGuid(),
Name = "Quote Prepared",
Type = ListItemType.StatusQuotedPrepared,
Category = new ListItemCategory {
Id = Guid.NewGuid(), Name = "Job Item Status", Type = ListItemCategoryType.JobItemStatus
}
};
_invoiceItemService = InvoiceItemServiceFactory.Create(
_userContext,
MockRepository.GenerateStub <ICompanyDetailsRepository>(),
MockRepository.GenerateStub <IInvoiceRepository>(),
InvoiceItemRepositoryTestHelper.GetInvoiceItemRepository_StubsJobItemHasPendingInvoiceItem_ReturnsFalse(jobItemId),
JobItemRepositoryTestHelper.GetJobItemRepository_StubsGetById_ReturnsJobItem(_jobItemForCreatePending),
QuoteItemRepositoryTestHelper.GetQuoteItemRepository_StubsGetQuoteItemForJobItem_ReturnsQuoteItem(jobItemId, _quoteItemForCreatePending),
MockRepository.GenerateStub <IListItemRepository>());
CreatePending(id, jobItemId);
Assert.IsTrue(_domainValidationException.ResultContainsMessage(Messages.QuoteStatusInvalid));
}
public PaymentFunctions(CustomerService customerService,
PaymentMethodService paymentMethodService,
InvoiceItemService invoiceItemService,
InvoiceService invoiceService)
{
_customerService = customerService;
_paymentMethodService = paymentMethodService;
_invoiceItemService = invoiceItemService;
_invoiceService = invoiceService;
}
public static void perform()
{
new Thread(() =>
{
Thread.CurrentThread.IsBackground = true;
Console.WriteLine("Thread running......");
InvoiceService.perform();
InvoiceItemService.perform();
PaymentService.perform();
MemberShipService.perform();
}).Start();
}
public void CreateFromPending_ValidDetailsWhenInvoiceHasOneItem_InvoiceItemSuccessfullyCreated()
{
var id = Guid.NewGuid();
var invoiceId = _invoiceForCreateFromPendingId;
var description = "Druck, DPI601IS, Digital Pressure Indicator";
var calibrationPrice = 25;
var repairPrice = 38;
var partsPrice = 200;
var carriagePrice = 30;
var investigationPrice = 0;
var invoiceRepositoryStub = MockRepository.GenerateStub <IInvoiceRepository>();
invoiceRepositoryStub.Stub(x => x.GetInvoiceItemCount(invoiceId)).Return(1);
invoiceRepositoryStub.Stub(x => x.GetById(invoiceId)).Return(_invoiceForCreateFromPending);
var invoiceItemRepositoryMock = MockRepository.GenerateMock <IInvoiceItemRepository>();
invoiceItemRepositoryMock.Expect(x => x.Create(null)).IgnoreArguments();
var jobItemRepositoryMock = MockRepository.GenerateMock <IJobItemRepository>();
jobItemRepositoryMock.Expect(x => x.EmitItemHistory(
_userContext.GetCurrentUser(), _jobItemForCreateFromPendingId, 0, 0, "Item invoiced on IR2000", ListItemType.StatusInvoiced, ListItemType.WorkTypeAdministration));
jobItemRepositoryMock.Expect(x => x.Update(_jobItemForCreateFromPending)).IgnoreArguments();
var listItemRepositoryStub = MockRepository.GenerateStub <IListItemRepository>();
listItemRepositoryStub.Stub(x => x.GetByType(ListItemType.StatusInvoiced)).Return(new ListItem {
Id = Guid.NewGuid(), Name = "Invoiced", Type = ListItemType.StatusInvoiced
});
_invoiceItemService = InvoiceItemServiceFactory.Create(
_userContext,
MockRepository.GenerateStub <ICompanyDetailsRepository>(),
invoiceRepositoryStub,
invoiceItemRepositoryMock,
jobItemRepositoryMock,
MockRepository.GenerateStub <IQuoteItemRepository>(),
listItemRepositoryStub);
CreateFromPending(id, invoiceId, description, calibrationPrice, repairPrice, partsPrice, carriagePrice, investigationPrice, _jobItemForCreateFromPending);
invoiceItemRepositoryMock.VerifyAllExpectations();
jobItemRepositoryMock.VerifyAllExpectations();
Assert.AreNotEqual(Guid.Empty, _savedInvoiceItemFromPending.Id);
Assert.AreEqual(2, _savedInvoiceItemFromPending.ItemNo);
Assert.AreEqual(description, _savedInvoiceItemFromPending.Description);
Assert.AreEqual(calibrationPrice, _savedInvoiceItemFromPending.CalibrationPrice);
Assert.AreEqual(repairPrice, _savedInvoiceItemFromPending.RepairPrice);
Assert.AreEqual(partsPrice, _savedInvoiceItemFromPending.PartsPrice);
Assert.AreEqual(carriagePrice, _savedInvoiceItemFromPending.CarriagePrice);
Assert.AreEqual(investigationPrice, _savedInvoiceItemFromPending.InvestigationPrice);
Assert.IsNotNull(_savedInvoiceItemFromPending.Invoice);
Assert.IsNotNull(_savedInvoiceItemFromPending.JobItem);
Assert.AreEqual(ListItemType.StatusInvoiced, _jobItemForCreateFromPending.Status.Type);
Assert.IsTrue(_jobItemForCreateFromPending.IsInvoiced);
}
public void GetInvoiceItems_UserHasInsufficientSecurityClearance_DomainValidationExceptionThrown()
{
_invoiceItemService = InvoiceItemServiceFactory.Create(
TestUserContext.Create("*****@*****.**", "Graham Robertson", "Operations Manager", UserRole.Public),
MockRepository.GenerateStub <ICompanyDetailsRepository>(),
MockRepository.GenerateStub <IInvoiceRepository>(),
MockRepository.GenerateStub <IInvoiceItemRepository>(),
MockRepository.GenerateStub <IJobItemRepository>(),
MockRepository.GenerateStub <IQuoteItemRepository>(),
MockRepository.GenerateStub <IListItemRepository>());
GetInvoiceItems();
Assert.IsTrue(_domainValidationException.ResultContainsMessage(Messages.InsufficientSecurityClearance));
}
public void CreatePending_InvalidJobItemId_ArgumentExceptionThrown()
{
var id = Guid.NewGuid();
var jobItemId = Guid.NewGuid();
_invoiceItemService = InvoiceItemServiceFactory.Create(
_userContext,
MockRepository.GenerateStub <ICompanyDetailsRepository>(),
MockRepository.GenerateStub <IInvoiceRepository>(),
InvoiceItemRepositoryTestHelper.GetInvoiceItemRepository_StubsJobItemHasPendingInvoiceItem_ReturnsFalse(jobItemId),
JobItemRepositoryTestHelper.GetJobItemRepository_StubsGetById_ReturnsNull(jobItemId),
QuoteItemRepositoryTestHelper.GetQuoteItemRepository_StubsGetQuoteItemForJobItem_ReturnsQuoteItem(jobItemId, _quoteItemForCreatePending),
MockRepository.GenerateStub <IListItemRepository>());
CreatePending(id, jobItemId);
}
public void CreatePending_JobItemAlreadyHasPendingItem_DomainValidationExceptionThrown()
{
var id = Guid.NewGuid();
var jobItemId = _jobItemForCreatePendingId;
_invoiceItemService = InvoiceItemServiceFactory.Create(
TestUserContext.Create("*****@*****.**", "Graham Robertson", "Operations Manager", UserRole.Public),
MockRepository.GenerateStub <ICompanyDetailsRepository>(),
MockRepository.GenerateStub <IInvoiceRepository>(),
InvoiceItemRepositoryTestHelper.GetInvoiceItemRepository_StubsJobItemHasPendingInvoiceItem_ReturnsTrue(jobItemId),
JobItemRepositoryTestHelper.GetJobItemRepository_StubsGetById_ReturnsJobItem(_jobItemForCreatePending),
QuoteItemRepositoryTestHelper.GetQuoteItemRepository_StubsGetQuoteItemForJobItem_ReturnsQuoteItem(jobItemId, _quoteItemForCreatePending),
MockRepository.GenerateStub <IListItemRepository>());
CreatePending(id, jobItemId);
Assert.IsTrue(_domainValidationException.ResultContainsMessage(Messages.JobItemHasPendingItem));
}
public void CreatePending_QuoteItemNotRaised_DomainValidationExceptionThrown()
{
var id = Guid.NewGuid();
var jobItemId = _jobItemForCreatePendingId;
_invoiceItemService = InvoiceItemServiceFactory.Create(
_userContext,
MockRepository.GenerateStub <ICompanyDetailsRepository>(),
MockRepository.GenerateStub <IInvoiceRepository>(),
InvoiceItemRepositoryTestHelper.GetInvoiceItemRepository_StubsJobItemHasPendingInvoiceItem_ReturnsFalse(jobItemId),
JobItemRepositoryTestHelper.GetJobItemRepository_StubsGetById_ReturnsJobItem(_jobItemForCreatePending),
QuoteItemRepositoryTestHelper.GetQuoteItemRepository_StubsGetQuoteItemForJobItem_ReturnsNull(jobItemId),
MockRepository.GenerateStub <IListItemRepository>());
CreatePending(id, jobItemId);
Assert.IsTrue(_domainValidationException.ResultContainsMessage(Messages.QuoteItemNull));
}
public StripePaymentGateway(ProductService productService, CustomerService customerService, PlanService planService,
CardService cardService, InvoiceService invoiceService, CouponService couponService, IMapper mapper, RefundService refundService,
SubscriptionService subscriptionService, InvoiceItemService invoiceItemService,
IOptions <AppSettings> appSettings)
{
_productService = productService;
_mapper = mapper;
_planService = planService;
_appSettings = appSettings.Value;
_cardService = cardService;
_invoiceService = invoiceService;
_customerSer = customerService;
_couponService = couponService;
_refundService = refundService;
_subscriptionService = subscriptionService;
_invoiceItemService = invoiceItemService;
}
public ProjectInvoiceService(
IServiceProvider serviceProvider,
StripeInvoiceService invoiceService,
InvoiceItemService invoiceItemService,
ILogger <ProjectInvoiceService> logger,
InvoicesEventHandlers events,
IProjectService projectService,
IBuyerAccountService buyerAccountService) : base(serviceProvider)
{
_invoiceService = invoiceService;
_invoiceItemService = invoiceItemService;
_logger = logger;
_projectService = projectService;
_buyerAccountService = buyerAccountService;
_invoices = UnitOfWork.RepositoryAsync <StripeInvoice>();
_timeEntries = UnitOfWork.RepositoryAsync <TimeEntry>();
_items = UnitOfWork.RepositoryAsync <StripeInvoiceItem>();
_contracts = UnitOfWork.RepositoryAsync <Contract>();
AddEventHandler(events);
}
public InvoiceItemServiceTest()
{
this.service = new InvoiceItemService();
this.createOptions = new InvoiceItemCreateOptions()
{
Amount = 123,
Currency = "usd",
CustomerId = "cus_123",
};
this.updateOptions = new InvoiceItemUpdateOptions()
{
Metadata = new Dictionary <string, string>()
{
{ "key", "value" },
},
};
this.listOptions = new InvoiceItemListOptions()
{
Limit = 1,
};
}
public void CreateFromPending_InvalidInvoiceId_ArgumentExceptionThrown()
{
var id = Guid.NewGuid();
var invoiceId = Guid.NewGuid();
var description = "Druck, DPI601IS, Digital Pressure Indicator";
var calibrationPrice = 25;
var repairPrice = 38;
var partsPrice = 200;
var carriagePrice = 30;
var investigationPrice = 0;
var invoiceItemRepositoryMock = MockRepository.GenerateMock <IInvoiceItemRepository>();
invoiceItemRepositoryMock.Expect(x => x.Create(null)).IgnoreArguments();
_invoiceItemService = InvoiceItemServiceFactory.Create(
_userContext,
MockRepository.GenerateStub <ICompanyDetailsRepository>(),
InvoiceRepositoryTestHelper.GetInvoiceRepository_StubsGetById_ReturnsNull(invoiceId),
invoiceItemRepositoryMock,
MockRepository.GenerateStub <IJobItemRepository>(),
MockRepository.GenerateStub <IQuoteItemRepository>(),
MockRepository.GenerateStub <IListItemRepository>());
CreateFromPending(id, invoiceId, description, calibrationPrice, repairPrice, partsPrice, carriagePrice, investigationPrice, _jobItemForCreateFromPending);
}
public override void OnActionExecuting()
{
_invoiceItemService = CreateService <InvoiceItemService>();
}
public InvoiceItemController(InvoiceItemService _InvoiceItemService)
{
InvoiceItemService = _InvoiceItemService;
}
public ActionResult Pay(Payment item)
{
var me = (User)Session["me"];
if (me == null)
{
return(RedirectToAction("Index"));
}
var stripeToken = Request.Form["stripeToken"];
if (String.IsNullOrEmpty(stripeToken))
{
TempData["result_code"] = -1;
TempData["message"] = "Stripe set an error with your informations";
TempData.Keep();
return(RedirectToAction("Index"));
}
var Email = Request.Form["stripeEmail"];
var stripeTokenType = Request.Form["stripeTokenType"];
var productService = new ProductService();
var priceService = new PriceService();
var invoiceItemService = new InvoiceItemService();
var invoiceServices = new InvoiceService();
var customerService = new CustomerService();
var planService = new PlanService();
var subscriptionService = new SubscriptionService();
var original_amount = 500;
var amount = Convert.ToInt32(me.reduction > 0 ? original_amount * me.reduction : original_amount);
var product = productService.Create(new ProductCreateOptions
{
Name = "Name of Service",
});
var price = priceService.Create(new PriceCreateOptions
{
Product = product.Id,
UnitAmount = amount,
Currency = "usd",
Recurring = new PriceRecurringOptions
{
Interval = "month",
},
});
var customer = customerService.Create(new CustomerCreateOptions
{
Email = Email,
Source = stripeToken,
});
var plan = planService.Create(new PlanCreateOptions
{
Amount = amount,
Currency = "usd",
Interval = "month",
IntervalCount = 1,
Product = product.Id, // "prod_IinH4BV2oyao8L",
});
var subscription = subscriptionService.Create(new SubscriptionCreateOptions
{
Customer = customer.Id,
Items = new List <SubscriptionItemOptions>
{
new SubscriptionItemOptions
{
Plan = plan.Id,
},
},
});
if (subscription.Status == "active")
{
item.original_amount = 500;
item.amount = amount;
item.code = QRCodeModel.GenerateRandomString();
item.payer_id = me.id;
db1.Payment.Add(item);
db1.SaveChanges();
TempData["result_code"] = 1;
TempData["message"] = "Subscription done successfully";
TempData.Keep();
return(RedirectToAction("Payments"));
}
TempData["result_code"] = -1;
TempData["message"] = "An error occured during the payment";
TempData.Keep();
return(RedirectToAction("Index"));
}
public async Task <bool> PreviewUpcomingInvoiceAndPayAsync(ISubscriber subscriber, string planId,
List <InvoiceSubscriptionItemOptions> subItemOptions, int prorateThreshold = 500)
{
var invoiceService = new InvoiceService();
var invoiceItemService = new InvoiceItemService();
var pendingInvoiceItems = invoiceItemService.ListAutoPaging(new InvoiceItemListOptions
{
CustomerId = subscriber.GatewayCustomerId
}).ToList().Where(i => i.InvoiceId == null);
var pendingInvoiceItemsDict = pendingInvoiceItems.ToDictionary(pii => pii.Id);
var upcomingPreview = await invoiceService.UpcomingAsync(new UpcomingInvoiceOptions
{
CustomerId = subscriber.GatewayCustomerId,
SubscriptionId = subscriber.GatewaySubscriptionId,
SubscriptionItems = subItemOptions
});
var itemsForInvoice = upcomingPreview.Lines?.Data?
.Where(i => pendingInvoiceItemsDict.ContainsKey(i.Id) || (i.Plan.Id == planId && i.Proration));
var invoiceAmount = itemsForInvoice?.Sum(i => i.Amount) ?? 0;
var invoiceNow = invoiceAmount >= prorateThreshold;
if (invoiceNow)
{
// Owes more than prorateThreshold on next invoice.
// Invoice them and pay now instead of waiting until next billing cycle.
Invoice invoice = null;
var createdInvoiceItems = new List <InvoiceItem>();
Braintree.Transaction braintreeTransaction = null;
try
{
foreach (var ii in itemsForInvoice)
{
if (pendingInvoiceItemsDict.ContainsKey(ii.Id))
{
continue;
}
var invoiceItem = await invoiceItemService.CreateAsync(new InvoiceItemCreateOptions
{
Currency = ii.Currency,
Description = ii.Description,
CustomerId = subscriber.GatewayCustomerId,
SubscriptionId = ii.SubscriptionId,
Discountable = ii.Discountable,
Amount = ii.Amount
});
createdInvoiceItems.Add(invoiceItem);
}
invoice = await invoiceService.CreateAsync(new InvoiceCreateOptions
{
Billing = Billing.SendInvoice,
DaysUntilDue = 1,
CustomerId = subscriber.GatewayCustomerId,
SubscriptionId = subscriber.GatewaySubscriptionId
});
var invoicePayOptions = new InvoicePayOptions();
var customerService = new CustomerService();
var customer = await customerService.GetAsync(subscriber.GatewayCustomerId);
if (customer != null)
{
if (customer.Metadata.ContainsKey("btCustomerId"))
{
invoicePayOptions.PaidOutOfBand = true;
var btInvoiceAmount = (invoiceAmount / 100M);
var transactionResult = await _btGateway.Transaction.SaleAsync(
new Braintree.TransactionRequest
{
Amount = btInvoiceAmount,
CustomerId = customer.Metadata["btCustomerId"],
Options = new Braintree.TransactionOptionsRequest
{
SubmitForSettlement = true,
PayPal = new Braintree.TransactionOptionsPayPalRequest
{
CustomField = $"{subscriber.BraintreeIdField()}:{subscriber.Id}"
}
},
CustomFields = new Dictionary <string, string>
{
[subscriber.BraintreeIdField()] = subscriber.Id.ToString()
}
});
if (!transactionResult.IsSuccess())
{
throw new GatewayException("Failed to charge PayPal customer.");
}
braintreeTransaction = transactionResult.Target;
await invoiceService.UpdateAsync(invoice.Id, new InvoiceUpdateOptions
{
Metadata = new Dictionary <string, string>
{
["btTransactionId"] = braintreeTransaction.Id,
["btPayPalTransactionId"] =
braintreeTransaction.PayPalDetails.AuthorizationId
}
});
}
}
await invoiceService.PayAsync(invoice.Id, invoicePayOptions);
}
catch (Exception e)
{
if (braintreeTransaction != null)
{
await _btGateway.Transaction.RefundAsync(braintreeTransaction.Id);
}
if (invoice != null)
{
await invoiceService.DeleteAsync(invoice.Id);
// Restore invoice items that were brought in
foreach (var item in pendingInvoiceItems)
{
var i = new InvoiceItemCreateOptions
{
Currency = item.Currency,
Description = item.Description,
CustomerId = item.CustomerId,
SubscriptionId = item.SubscriptionId,
Discountable = item.Discountable,
Metadata = item.Metadata,
Quantity = item.Quantity,
UnitAmount = item.UnitAmount
};
await invoiceItemService.CreateAsync(i);
}
}
else
{
foreach (var ii in createdInvoiceItems)
{
await invoiceItemService.DeleteAsync(ii.Id);
}
}
throw e;
}
}
return(invoiceNow);
}
public string SendInvoice(
string customerEmail,
decimal amountToPay,
string currency,
string description = "",
bool sendInvoice = true)
{
try
{
CustomerCreateOptions customerInfo = new CustomerCreateOptions
{
Email = customerEmail,
//PaymentMethod = "card",
};
var customerService = new CustomerService();
var customer = customerService.Create(customerInfo);
var invoiceItemOption = new InvoiceItemCreateOptions
{
Customer = customer.Id,
Amount = Convert.ToInt32(amountToPay * 100),
Currency = currency,
};
var invoiceItemService = new InvoiceItemService();
var invoiceItem = invoiceItemService.Create(invoiceItemOption);
var invoiceOptions = new InvoiceCreateOptions
{
Customer = customer.Id,
CollectionMethod = "send_invoice",
DaysUntilDue = 30,
Description = description,
AutoAdvance = true
};
var service = new InvoiceService();
var invoice = service.Create(invoiceOptions);
invoice = service.FinalizeInvoice(invoice.Id);
try
{
var paymentIntentService = new PaymentIntentService();
var paymentIntent = paymentIntentService.Get(invoice.PaymentIntentId);
var paymentIntentUpdateOptions = new PaymentIntentUpdateOptions
{
Description = description
};
paymentIntentService.Update(paymentIntent.Id, paymentIntentUpdateOptions);
}
catch (Exception)
{
//continue
}
if (sendInvoice)
{
invoice = service.SendInvoice(invoice.Id);
}
return(invoice.Id);
}
catch (Exception e)
{
Console.WriteLine(e);
return(null);
}
}
public void CreateInvoicesFromPendingItems_ValidPendingInvoiceItems_InvoicesCreated()
{
var dispatcher = MockRepository.GenerateMock <IQueueDispatcher <IMessage> >();
var userRepository = new UserAccountRepository();
var user = userRepository.GetByEmail("*****@*****.**", false);
var userContext = new TestUserContext(user);
var companyDetailsRepository = new CompanyDetailsRepository();
var quoteRepository = new QuoteRepository();
var quoteItemRepository = new QuoteItemRepository();
var customerRepository = new CustomerRepository();
var jobRepository = new JobRepository();
var jobItemRepository = new JobItemRepository();
var listItemRepository = new ListItemRepository();
var currencyRepository = new CurrencyRepository();
var entityIdProvider = new DirectEntityIdProvider();
var instrumentRepository = new InstrumentRepository();
var deliveryRepository = new DeliveryRepository();
var deliveryItemRepository = new DeliveryItemRepository();
var invoiceRepository = new InvoiceRepository();
var invoiceItemRepository = new InvoiceItemRepository();
var customerId1 = Guid.NewGuid();
var customerId2 = Guid.NewGuid();
var job1Id = Guid.NewGuid();
var job2Id = Guid.NewGuid();
var job3Id = Guid.NewGuid();
var jobItem1Id = Guid.NewGuid();
var jobItem2Id = Guid.NewGuid();
var jobItem3Id = Guid.NewGuid();
var jobItem4Id = Guid.NewGuid();
var jobItem5Id = Guid.NewGuid();
var jobItem6Id = Guid.NewGuid();
var jobItem7Id = Guid.NewGuid();
var jobItem8Id = Guid.NewGuid();
var jobItem9Id = Guid.NewGuid();
CreateInvoicesFromPendingItemsHelper.CreateContextForPendingItemTests(
customerId1, customerId2, job1Id, job2Id, job3Id, jobItem1Id, jobItem2Id, jobItem3Id, jobItem4Id, jobItem5Id, jobItem6Id, jobItem7Id, jobItem8Id, jobItem9Id);
var invoiceItemService = new InvoiceItemService(userContext, companyDetailsRepository, invoiceRepository, invoiceItemRepository, jobItemRepository, quoteItemRepository, listItemRepository, dispatcher);
invoiceItemService.CreatePending(Guid.NewGuid(), jobItem1Id);
invoiceItemService.CreatePending(Guid.NewGuid(), jobItem2Id);
invoiceItemService.CreatePending(Guid.NewGuid(), jobItem3Id);
invoiceItemService.CreatePending(Guid.NewGuid(), jobItem4Id);
invoiceItemService.CreatePending(Guid.NewGuid(), jobItem5Id);
invoiceItemService.CreatePending(Guid.NewGuid(), jobItem6Id);
invoiceItemService.CreatePending(Guid.NewGuid(), jobItem7Id);
invoiceItemService.CreatePending(Guid.NewGuid(), jobItem8Id);
invoiceItemService.CreatePending(Guid.NewGuid(), jobItem9Id);
var invoiceService = new InvoiceService(
userContext, invoiceItemService, invoiceRepository, new DirectEntityIdProvider(), listItemRepository, customerRepository, new BankDetailsRepository(), new TaxCodeRepository(), companyDetailsRepository, currencyRepository, dispatcher);
invoiceService.CreateInvoicesFromPendingItems();
var invoices = invoiceService.GetInvoices().ToList();
Assert.AreEqual(4, invoices.Count);
var invoiceItems = invoiceItemService.GetInvoiceItems(invoices[0].Id).ToList();
Assert.AreEqual(2, invoiceItems.Count);
invoiceItems = invoiceItemService.GetInvoiceItems(invoices[1].Id).ToList();
Assert.AreEqual(2, invoiceItems.Count);
invoiceItems = invoiceItemService.GetInvoiceItems(invoices[2].Id).ToList();
Assert.AreEqual(3, invoiceItems.Count);
invoiceItems = invoiceItemService.GetInvoiceItems(invoices[3].Id).ToList();
Assert.AreEqual(2, invoiceItems.Count);
var pendingItems = invoiceItemService.GetPendingInvoiceItems().ToList();
Assert.AreEqual(0, pendingItems.Count);
}
public InvoiceController(InvoiceItemService invoiceItemService, InvoiceService invoiceService)
{
_invoiceItemService = invoiceItemService;
_invoiceService = invoiceService;
}
public InvoiceItemsController(InvoiceItemService service)
{
_service = service;
}
public InvoiceInfo GeneratePayNowLink(
string customerEmail,
decimal amountToPay,
string currency,
string description = "")
{
try
{
CustomerCreateOptions customerInfo = new CustomerCreateOptions
{
Email = customerEmail,
//PaymentMethod = "card",
};
var customerService = new CustomerService();
var customer = customerService.Create(customerInfo);
var invoiceItemOption = new InvoiceItemCreateOptions
{
Customer = customer.Id,
Amount = Convert.ToInt32(amountToPay * 100),
Currency = currency,
};
var invoiceItemService = new InvoiceItemService();
var invoiceItem = invoiceItemService.Create(invoiceItemOption);
var invoiceOptions = new InvoiceCreateOptions
{
Customer = customer.Id,
CollectionMethod = "send_invoice",
DaysUntilDue = 30,
Description = description
};
var service = new InvoiceService();
var invoice = service.Create(invoiceOptions);
invoice = service.FinalizeInvoice(invoice.Id);
try
{
var paymentIntentService = new PaymentIntentService();
var paymentIntent = paymentIntentService.Get(invoice.PaymentIntentId);
var paymentIntentUpdateOptions = new PaymentIntentUpdateOptions
{
Description = description
};
paymentIntentService.Update(paymentIntent.Id, paymentIntentUpdateOptions);
}
catch (Exception)
{
//continue
}
var result = new InvoiceInfo
{
Url = invoice.HostedInvoiceUrl,
Id = invoice.Id
};
return(result);
}
catch (Exception e)
{
Console.WriteLine(e);
return(null);
}
}
