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);
}
