public void FindByIdQboTest() { Customer customer = new Customer(); string guid = Guid.NewGuid().ToString("N"); customer.GivenName = guid.Substring(0, 25); customer.Title = guid.Substring(0, 15); customer.MiddleName = guid.Substring(0, 5); customer.FamilyName = guid.Substring(0, 25); customer.DisplayName = guid.Substring(0, 20); ManualResetEvent manualEvent = new ManualResetEvent(false); Customer getcustomer = qboService.Add(customer); qboService.OnFindByIdAsyncCompleted = (sender, e) => { Assert.IsNotNull(e); Assert.IsNotNull(e.Entity); Assert.IsTrue(getcustomer.Id == (e.Entity as Customer).Id); manualEvent.Set(); }; Intuit.Ipp.Data.IntuitEntity intuitEntity = getcustomer as Intuit.Ipp.Data.IntuitEntity; qboService.FindByIdAsync(getcustomer); manualEvent.WaitOne(30000); }
/// <summary> /// This workflow coverscreating account, item, customer, invoice,payment and sending invoice /// </summary> /// <returns></returns> public async Task <ActionResult> InvoicingWorkflow() { //Make QBO api calls using .Net SDK if (Session["realmId"] != null) { string realmId = Session["realmId"].ToString(); try { //Initialize OAuth2RequestValidator and ServiceContext ServiceContext serviceContext = base.IntializeContext(realmId); DataService dataService = new DataService(serviceContext); //Create Account Account account = CreateAccount(); Account accountAdded = dataService.Add <Account>(account); //Add customer Customer customer = CreateCustomer(); Customer customerCreated = dataService.Add <Customer>(customer); //Add item Item item = CreateItem(accountAdded); Item itemAdded = dataService.Add <Item>(item); //Add Invoice Invoice objInvoice = CreateInvoice(realmId, customerCreated, itemAdded); Invoice addedInvoice = dataService.Add <Invoice>(objInvoice); //Email invoice // sending invoice dataService.SendEmail <Invoice>(addedInvoice, "*****@*****.**"); //Recieve payment for this invoice Payment payment = CreatePayment(customerCreated, addedInvoice); dataService.Add <Payment>(payment); return(View("Index", (object)("QBO API calls Success!"))); } catch (Exception ex) { return(View("Index", (object)"QBO API calls Failed!")); } } else { return(View("Index", (object)"QBO API call Failed!")); } }
public IActionResult Post([FromBody] TopicModel model) { var topic = ModelFactory.Map(model); DataService.Add(topic); return(Ok(ModelFactory.Map(topic, Url))); }
public IActionResult Post([FromBody] CommentModel model) { var comment = ModelFactory.Map(model); DataService.Add(comment); return(Ok(ModelFactory.Map(comment, Url))); }
private Item CreateInventoryItem(DataService dataService, Account incomeAccount, Account expenseAccount, Account assetAccount) { Item newItem = new Item { Type = ItemTypeEnum.Inventory, Name = "My Inventory 15" + Guid.NewGuid().ToString("N"), // Please change the name every time QtyOnHand = 10, InvStartDate = DateTime.Today, Description = "New Inventory with quantity 10", TrackQtyOnHand = true, TypeSpecified = true, QtyOnHandSpecified = true, TrackQtyOnHandSpecified = true, InvStartDateSpecified = true }; //QueryService<Account> querySvc = new QueryService<Account>(serviceContext); newItem.IncomeAccountRef = new ReferenceType() { Value = incomeAccount.Id }; newItem.ExpenseAccountRef = new ReferenceType() { Value = expenseAccount.Id }; newItem.AssetAccountRef = new ReferenceType() { Value = assetAccount.Id }; return(dataService.Add <Item>(newItem)); }
public Invoice CreateNewInvoice(CustomerInvoice cinvoice) { try { if (cinvoice == null) { throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Invoice cannot be null")); } var serviceContext = QbApiHelper.GetServiceContext(); var service = new DataService(serviceContext); var invoice = MapCustomerInvoiceToInvoice(cinvoice); var returnedInvoice = service.Add <Invoice>(invoice); return(returnedInvoice); } catch (Exception e) { throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "An error ocurred while creating a new Invoice: " + e.Message)); } }
internal static Invoice CreateInvoice(DataService dataService, QueryService <Account> queryService, Customer customer) { Item item = ItemCreate(dataService, queryService); Line line = new Line { DetailType = LineDetailTypeEnum.SalesItemLineDetail, DetailTypeSpecified = true, Description = "Sample for Reimburse Charge with Invoice.", Amount = new Decimal(40), AmountSpecified = true }; SalesItemLineDetail lineDetail = new SalesItemLineDetail { ItemRef = new ReferenceType { name = item.Name, Value = item.Id } }; line.AnyIntuitObject = lineDetail; Line[] lines = { line }; Invoice invoice = new Invoice { Line = lines, CustomerRef = new ReferenceType { name = customer.DisplayName, Value = customer.Id }, TxnDate = DateTime.Now.Date }; Invoice response = dataService.Add(invoice); return(response); }
public void AddRemoveCategory() { var context = new CoreDataContext(); var uow = new EntityFrameworkUnitOfWork(context); var repo = new EntityFrameworkRepository<Guid, Category, GuidIdInitializer>(context); var caregoryService = new DataService<Guid, Category, EntityFrameworkRepository<Guid, Category, GuidIdInitializer>>(uow, repo); var newCategory = caregoryService.Add(new Category { Name = "Computres", Categories = new List<Category> { new Category { Name = "-DeskTops" }, new Category { Name = "-Servers" }, new Category { Name = "-Laptops", Categories = new List<Category> { new Category { Name = "--Tablets" }, new Category { Name = "--Shmablets" }, } }, } }); var justAdded = caregoryService.Get(c => c.Id == newCategory.Id); Assert.AreEqual(justAdded.Categories.Count, newCategory.Categories.Count); caregoryService.Remove(justAdded); justAdded = caregoryService.Get(c => c.Id == newCategory.Id); Assert.IsNull(justAdded); }
internal static Item ItemCreate(DataService dataService, QueryService <Account> queryService) { var random = new Random(); var expenseAccount = QueryOrAddAccount(dataService, queryService, "select * from account where AccountType='Cost of Goods Sold'", AccountTypeEnum.CostofGoodsSold, AccountClassificationEnum.Expense, AccountSubTypeEnum.SuppliesMaterialsCogs); var incomeAccount = QueryOrAddAccount(dataService, queryService, "select * from account where AccountType='Income'", AccountTypeEnum.Income, AccountClassificationEnum.Revenue, AccountSubTypeEnum.SalesOfProductIncome); var item = new Item { Name = "Item_" + random.NextDouble(), ExpenseAccountRef = new ReferenceType { name = expenseAccount.Name, Value = expenseAccount.Id }, IncomeAccountRef = new ReferenceType { name = incomeAccount.Name, Value = incomeAccount.Id }, Type = ItemTypeEnum.NonInventory, TypeSpecified = true, UnitPrice = new decimal(100.0), UnitPriceSpecified = true }; var apiResponse = dataService.Add(item); return(apiResponse); }
public IActionResult Post([FromBody] MarkedModel model) { var marked = ModelFactory.Map(model); DataService.Add(marked); return(Ok(ModelFactory.Map(marked, Url))); }
public async Task <IActionResult> InsertFieldRight([FromBody] FieldRightListDTO item) { if (!ModelState.IsValid) { var errorsQuery = (from modelStateItem in ModelState where modelStateItem.Value.Errors.Any() select modelStateItem.Value.Errors[0].ErrorMessage); var errorMessage = "Виникла помилка під час перевірки данних:"; foreach (var error in errorsQuery) { errorMessage += "\n" + error; } return(BadRequest(errorMessage)); } item.Caption = item.FieldName + ": " + item.AccessLevel.ToString(); try { item.Id = DataService.Add <FieldRight>(item); await DataService.SaveChangesAsync(); } catch (Exception ex) { return(BadRequest(ex.InnerException?.Message ?? ex.Message)); } return(Ok(item)); }
public async void SaveClick() { if (String.IsNullOrEmpty(Title)) { await App.Current.MainPage.DisplayAlert("Error", "Title field cannot be empty !", "ok"); return; } if (String.IsNullOrEmpty(Text)) { await App.Current.MainPage.DisplayAlert("Error", "Notes field cannot be empty !", "ok"); return; } DataService noteService = new DataService(); noteService.Add(new Models.NotesModel() { Title = this.Title, Text = this.Text, TextColor = this.SelectedTextColor }); //Text = String.Empty; // (App.Current.MainPage as Shell).GoToAsync("app:///newapp/greeting?msg=Hello"); // await Shell.Current.GoToAsync("//animals/monkeys"); //(App.Current.MainPage as Shell).("app:///newapp/greeting?msg=Hello"); //await App.Current.MainPage.Navigation.PopAsync(); // await App.Navigator.PopAsync(true); }
public IActionResult Post([FromBody] HistoryModel model) { var history = ModelFactory.Map(model); DataService.Add(history); return(Ok(ModelFactory.Map(history, Url))); }
public static void Setup(TestContext context) { CleanDb(); var service = new DataService(connString); service.Add(new List <TransactionDto>() { new TransactionDto() { Id = "foo1", Amount = 11, Code = "USD", Date = dt1, Status = 0 }, new TransactionDto() { Id = "foo2", Amount = 22, Code = "EUR", Date = dt1.AddDays(-10), Status = 1 }, new TransactionDto() { Id = "foo3", Amount = 33, Code = "USD", Date = dt1.AddDays(10), Status = 2 } }); }
public override async Task <IActionResult> Edit(Guid id, ResultInputControlDetailsDTO model) { if (model.Id != id) { return(NotFound()); } if (ModelState.IsValid) { var entity = new ResultInputControl(); _objectMapper.Map(model, entity); DataService.Add(entity); await DataService.SaveChangesAsync(); try { await _service.InsertSgdRepDrugList(entity); } catch (Exception e) { DataService.Remove(entity); await DataService.SaveChangesAsync(); Log.Error($"Lims import error, {e.Message}"); return(NotFound()); } return(RedirectToAction("Index")); } return(View(model)); }
public IActionResult Post([FromBody] QuestionModel model) { var question = ModelFactory.Map(model); DataService.Add(question); return(Ok(ModelFactory.Map(question, Url))); }
public async Task <IActionResult> InsertRoleRight([FromBody] RoleRightListDTO item) { if (!ModelState.IsValid) { var errorsQuery = (from modelStateItem in ModelState where modelStateItem.Value.Errors.Any() select modelStateItem.Value.Errors[0].ErrorMessage); var errorMessage = "Виникла помилка під час перевірки данних:"; foreach (var error in errorsQuery) { errorMessage += "\n" + error; } return(BadRequest(errorMessage)); } var right = (await DataService.GetDtoAsync <RoleRightListDTO>(x => x.Id == item.RightId)).FirstOrDefault(); try { item.Id = DataService.Add <RoleRight>(item); await DataService.SaveChangesAsync(); } catch (Exception ex) { return(BadRequest(ex.InnerException?.Message ?? ex.Message)); } if (right != null) { item.IsActive = right.IsActive; } return(Ok(item)); }
public static Customer CreateCustomer(ServiceContext context) { Customer customer = new Customer { GivenName = "Kaley_" + Guid.NewGuid().ToString("N"), FamilyName = "McMohan", DisplayName = "Kaley_" + Guid.NewGuid().ToString("N") + " McMohan", Taxable = true, TaxableSpecified = true }; EmailAddress emailAddr = new EmailAddress { Address = "*****@*****.**" }; PhysicalAddress address = new PhysicalAddress { Line1 = "123 Mary Ave", City = "Sunnyvale", CountrySubDivisionCode = "CA", CountryCode = "USA", PostalCode = "94086" }; customer.PrimaryEmailAddr = emailAddr; customer.BillAddr = address; customer.ShipAddr = address; DataService service = new DataService(context); Customer addedCustomer = service.Add <Customer>(customer); return(addedCustomer); }
internal static Item FindOrAddItem(ServiceContext context, ItemTypeEnum type) { Item typeOfItem = null; List <Item> listOfItem = FindAll <Item>(context, new Item(), 1, 500).Where(i => i.status != EntityStatusEnum.SyncError).ToList(); if (listOfItem.Count > 0) { foreach (Item item in listOfItem) { if (item.Type == type) { typeOfItem = item; break; } } } if (typeOfItem == null) { DataService service = new DataService(context); Item item; item = QBOHelper.CreateItem(context); Item createdItem = service.Add <Item>(item); typeOfItem = createdItem; } return(typeOfItem); }
internal static Purchase FindOrAddPurchase(ServiceContext context, PaymentTypeEnum paymentType) { Purchase typeOfPurchase = null; List <Purchase> listOfPurchase = FindAll <Purchase>(context, new Purchase(), 1, 10).Where(p => p.status != EntityStatusEnum.SyncError).ToList(); if (listOfPurchase.Count > 0) { if (context.ServiceType == IntuitServicesType.QBO) { foreach (Purchase payment in listOfPurchase) { if (payment.PaymentType == paymentType) { typeOfPurchase = payment; break; } } if (typeOfPurchase == null) { //create a new purchase account DataService service = new DataService(context); Purchase purchase; purchase = QBOHelper.CreatePurchase(context, PaymentTypeEnum.Cash); Purchase createdPurchase = service.Add <Purchase>(purchase); typeOfPurchase = createdPurchase; } } } return(typeOfPurchase); }
internal static PaymentMethod FindOrAddPaymentMethod(ServiceContext context, string paymentType) { PaymentMethod typeOfPayment = null; List <PaymentMethod> listOfPayment = FindAll <PaymentMethod>(context, new PaymentMethod(), 1, 10).Where(p => p.status != EntityStatusEnum.SyncError).ToList(); if (listOfPayment.Count > 0) { if (context.ServiceType == IntuitServicesType.QBO) { foreach (PaymentMethod payment in listOfPayment) { if (payment.Type == paymentType) { typeOfPayment = payment; break; } } if (typeOfPayment == null) { //Create a new purchase account DataService service = new DataService(context); PaymentMethod payment; payment = QBOHelper.CreatePaymentMethod(context); PaymentMethod createdPurchase = service.Add <PaymentMethod>(payment); typeOfPayment = createdPurchase; } } } return(typeOfPayment); }
public IActionResult Post([FromBody] UserModel model) { var user = ModelFactory.Map(model); DataService.Add(user); return(Ok(ModelFactory.Map(user, Url))); }
internal static Account FindOrAddAccount(ServiceContext context, AccountTypeEnum accountType, AccountClassificationEnum classification) { Account typeOfAccount = null; List <Account> listOfAccount = FindAll <Account>(context, new Account(), 1, 500); if (listOfAccount.Count > 0) { foreach (Account acc in listOfAccount) { if (acc.AccountType == accountType && acc.Classification == classification && acc.status != EntityStatusEnum.SyncError) { typeOfAccount = acc; break; } } } if (typeOfAccount == null) { DataService service = new DataService(context); Account account; account = QBOHelper.CreateAccount(context, accountType, classification); account.Classification = classification; account.AccountType = accountType; Account createdAccount = service.Add <Account>(account); typeOfAccount = createdAccount; } return(typeOfAccount); }
public async Task <IActionResult> InsertProfileEmployee([FromBody] ProfileEmployeeListDTO item) { if (!ModelState.IsValid) { var errorsQuery = (from modelStateItem in ModelState where modelStateItem.Value.Errors.Any() select modelStateItem.Value.Errors[0].ErrorMessage); var errorMessage = "Виникла помилка під час перевірки данних:"; foreach (var error in errorsQuery) { errorMessage += "\n" + error; } return(BadRequest(errorMessage)); } var employee = (await DataService.GetDtoAsync <ProfileEmployeeListDTO>(x => x.Id == item.UserId)).FirstOrDefault(); try { item.Id = DataService.Add <UserProfile>(item); await DataService.SaveChangesAsync(); } catch (Exception ex) { return(BadRequest(ex.InnerException?.Message ?? ex.Message)); } if (employee != null) { item.Organization = employee.Organization; } return(Ok(item)); }
/// <summary> /// Create a JE with debit and credit lines /// </summary> public async Task <ActionResult> AccountingWorkflow() { //Make QBO api calls using .Net SDK if (Session["realmId"] != null) { string realmId = Session["realmId"].ToString(); try { //Initialize ServiceContext ServiceContext serviceContext = base.IntializeContext(realmId); // Create Journal Entry by creating 2 accounts(Bank, Credit Card); //Adding the Bill using Dataservice object DataService service = new DataService(serviceContext); //Create Journal request JournalEntry journalEntryRequest = CreateJournalEntry(serviceContext); // Make a QBO Journal Api call JournalEntry journalEntryResponse = service.Add <JournalEntry>(journalEntryRequest); return(View("Index", (object)("QBO API calls Success!"))); } catch (Exception ex) { return(View("Index", (object)"QBO API calls Failed!")); } } else { return(View("Index", (object)"QBO API call Failed!")); } }
public ActionResult AddVendor(VendorModel objVendorModel) { if (Session["realmId"] != null) { string realmId = Session["realmId"].ToString(); try { string AccessToken = Session["access_token"].ToString(); var principal = User as ClaimsPrincipal; OAuth2RequestValidator oauthValidator = new OAuth2RequestValidator(AccessToken); // Create a ServiceContext with Auth tokens and realmId ServiceContext serviceContext = new ServiceContext(realmId, IntuitServicesType.QBO, oauthValidator); serviceContext.IppConfiguration.MinorVersion.Qbo = "23"; DataService commonServiceQBO = new DataService(serviceContext); // Create a QuickBooks QueryService using ServiceContext PhysicalAddress vendorAddr = new PhysicalAddress(); EmailAddress vendoremail = new EmailAddress(); TelephoneNumber mobileNumber = new TelephoneNumber(); WebSiteAddress websiteaddr = new WebSiteAddress(); Vendor vendor = new Vendor(); //Mandatory Fields vendor.GivenName = objVendorModel.FirstName; vendor.Title = objVendorModel.Title; vendor.MiddleName = objVendorModel.MiddleName; vendor.FamilyName = objVendorModel.LastName; vendor.AcctNum = objVendorModel.AccountNo; vendor.Balance = Convert.ToDecimal(objVendorModel.BalanceAmount); vendor.CompanyName = objVendorModel.Company; vendorAddr.City = objVendorModel.City; vendorAddr.Country = objVendorModel.Country; vendoremail.Address = objVendorModel.Email; mobileNumber.FreeFormNumber = objVendorModel.MobileNumber; websiteaddr.URI = objVendorModel.Website; vendor.BillAddr = vendorAddr; vendor.PrimaryEmailAddr = vendoremail; vendor.Mobile = mobileNumber; vendor.WebAddr = websiteaddr; Vendor resultVendor = commonServiceQBO.Add(vendor) as Vendor; QueryService <Vendor> querySvcVendor = new QueryService <Vendor>(serviceContext); List <Vendor> vendorListData = querySvcVendor.ExecuteIdsQuery("SELECT * FROM Vendor").OrderByDescending(x => x.Id).ToList(); var tt = vendorListData.FirstOrDefault(); Vendor resultCustomer = commonServiceQBO.FindById(tt) as Vendor; return(RedirectToAction("VendorList", "VendorQuickBook")); } catch (Exception ex) { return(View("ApiCallService", (object)("QBO API call Failed!" + " Error message: " + ex.Message))); } } else { return(View("ApiCallService", (object)"QBO API call Failed!")); } }
internal static T AddToQBO <T>(ServiceContext context, T entity) where T : IEntity { DataService service = new DataService(context); T added = service.Add <T>(entity); return(added); }
/// <summary> /// Push the time activity to QBO /// </summary> /// <param name="timeActivitydto"></param> /// <returns></returns> internal TimeActivitydto Save(TimeActivitydto timeActivitydto) { try { TimeActivity timeActivity = new TimeActivity(); timeActivity.TxnDate = timeActivitydto.Date; SelectListItem selectedCustom = GetSelectedItem(timeActivitydto.Customer, timeActivitydto.CustomerSelected); timeActivity.CustomerRef = new ReferenceType { Value = selectedCustom.Value, }; SelectListItem selectedItem = GetSelectedItem(timeActivitydto.Item, timeActivitydto.ItemSelected); timeActivity.ItemRef = new ReferenceType() { Value = selectedItem.Value }; SelectListItem selectedEmp = GetSelectedItem(timeActivitydto.Employee, timeActivitydto.EmployeeSelected); timeActivity.NameOf = TimeActivityTypeEnum.Employee; timeActivity.NameOfSpecified = true; timeActivity.AnyIntuitObject = new ReferenceType() { Value = selectedEmp.Value }; timeActivity.ItemElementName = ItemChoiceType5.EmployeeRef; timeActivity.BillableStatus = BillableStatusEnum.NotBillable; timeActivity.BillableStatusSpecified = true; timeActivity.Taxable = false; timeActivity.TaxableSpecified = true; //Time timeActivity.HourlyRate = new Decimal(0.00); timeActivity.HourlyRateSpecified = true; timeActivity.Hours = 10; timeActivity.HoursSpecified = true; timeActivity.Minutes = 0; timeActivity.Description = timeActivitydto.Description; timeActivity.MinutesSpecified = true; timeActivity = dataService.Add <TimeActivity>(timeActivity); timeActivitydto.QboId = timeActivity.Id; timeActivitydto.Hours = timeActivity.Hours; timeActivitydto.TxnDate = timeActivity.TxnDate; timeActivitydto.AlertMessage = string.Format("Time Activity successfully created and pushed to QBO (QBO ID = {0})", timeActivity.Id); return(timeActivitydto); } catch (Intuit.Ipp.Exception.FaultException ex) { throw ex; } catch (Intuit.Ipp.Exception.InvalidTokenException ex) { throw ex; } catch (Intuit.Ipp.Exception.SdkException ex) { throw ex; } }
private static T Add <T>(ServiceContext context, T entity) where T : IEntity { //Initializing the Dataservice object with ServiceContext var service = new DataService(context); var added = service.Add(entity); return(added); }
internal static Customer CustomerCreate(DataService dataService) { Customer customer = new Customer { DisplayName = "Customer_" + GetGuid() }; Customer apiResponse = dataService.Add(customer); return(apiResponse); }
internal static Vendor VendorCreate(DataService dataService) { Vendor vendor = new Vendor { DisplayName = "Vendor_" + GetGuid() }; Vendor apiResponse = dataService.Add(vendor); return(apiResponse); }