public async Task ItCanUpdateAnAsset() { var updatedDescription = $"Changed {DateTime.UtcNow}"; var asset = new Asset() { Id = 1, Description = updatedDescription, }; var request = new FortnoxApiRequest(this.connectionSettings.AccessToken, this.connectionSettings.ClientSecret); var result = await AssetsService.UpdateAssetAsync(request, asset); Assert.AreEqual(updatedDescription, result.Description); }
public void UpdateArticle() { var article = new Article { Description = "TestArtikel", ArticleNumber = "100000" }; var newArticleName = $"TestArtikel {DateTime.UtcNow}"; article.Description = newArticleName; var request = new FortnoxApiRequest(this.connectionSettings.AccessToken, this.connectionSettings.ClientSecret); var updatedArticle = ArticleService.UpdateArticleAsync(request, article).GetAwaiter().GetResult(); Assert.AreEqual(newArticleName, updatedArticle.Description); }
// NOTE: Writes the SIE byte array to the specified file. If the file already exists it is overwritten. public static async Task GetAndSaveSIEToDiskAsync(FortnoxApiRequest request, SIETypes type, string filePath, int?finnancialYear = null) { var route = $"{ApiEndpoints.SIE}/{(int)type}"; if (finnancialYear.HasValue) { route = $"{route}?financialyear={finnancialYear.Value}"; } var apiRequest = new FortnoxApiClientRequest <byte[]>(HttpMethod.Get, request.AccessToken, request.ClientSecret, route); var resultingByteArray = await FortnoxAPIClient.CallAsync(apiRequest); File.WriteAllBytes(filePath, resultingByteArray); }
public static async Task <SupplierInvoiceExternalURLConnection> GetSupplierInvoiceExternalURLConnectionsAsync( FortnoxApiRequest request, string id) { var apiRequest = new FortnoxApiClientRequest < SingleResource <SupplierInvoiceExternalURLConnection> >( HttpMethod.Get, request.AccessToken, request.ClientSecret, $"{ApiEndpoints.SupplierInvoiceExternalURLConnections}/{id}"); return((await FortnoxAPIClient.CallAsync(apiRequest)).Data); }
private async Task <SupplierInvoiceExternalURLConnection> CreateEntity(int supplierInvoiceNumber) { var request = new FortnoxApiRequest(this.connectionSettings.AccessToken, this.connectionSettings.ClientSecret); return (await SupplierInvoiceExternalURLConnectionsService.CreateSupplierInvoiceExternalURLConnectionsAsync( request, new SupplierInvoiceExternalURLConnection { SupplierInvoiceNumber = supplierInvoiceNumber, ExternalURLConnection = ExternalUrl, } )); }
public void UpdateEmployee() { var Employee = new Employee { FirstName = "TestAnställd", EmployeeId = "4" }; var newEmployeeName = $"TestAnställd {DateTime.UtcNow}"; Employee.FirstName = newEmployeeName; var request = new FortnoxApiRequest(this.connectionSettings.AccessToken, this.connectionSettings.ClientSecret); var updatedEmployee = EmployeeService.UpdateEmployeeAsync(request, Employee).GetAwaiter().GetResult(); Assert.AreEqual(newEmployeeName, updatedEmployee.FirstName); }
public void DeleteWayOfDeliveryTest() { //TODO: Avoid cluttering Fortnox with data var request = new FortnoxApiRequest(this.connectionSettings.AccessToken, this.connectionSettings.ClientSecret); var response = WayOfDeliveryService.CreateWayOfDeliveryAsync(request, new WayOfDelivery { Code = "DEL", Description = "Will Be deleted" }).GetAwaiter().GetResult(); Assert.AreEqual("DEL", response.Code); WayOfDeliveryService.DeleteWayOfDeliveryAsync(request, response.Code).GetAwaiter().GetResult(); }
public async Task ItCanCreateAContractTemplate() { Assert.Inconclusive("Skipping this test as it can add extraneous data to the system"); var template = GenerateTemplate(); var request = new FortnoxApiRequest(connectionSettings.AccessToken, connectionSettings.ClientSecret); var response = await ContractTemplateService.CreateContractTemplateAsync( request, template ); Assert.IsNotNull(response); Assert.IsNotNull(response.Data); Assert.AreEqual(template.TemplateName, response.Data.TemplateName); }
public void CreateAndDeleteTermsOfDeliveryTest() { var request = new FortnoxApiRequest(this.connectionSettings.AccessToken, this.connectionSettings.ClientSecret); var response = TermsOfPaymentService.CreateTermsOfPaymentAsync(request, new TermsOfPayment { Code = "DEL", Description = "Delete Payment", }).GetAwaiter().GetResult(); Assert.AreEqual("DEL", response.Code); Assert.AreEqual("Delete Payment", response.Description); TermsOfPaymentService.DeleteTermsOfPaymentAsync(request, "DEL").GetAwaiter().GetResult(); }
public static async Task <File> CreateFileAsync( FortnoxApiRequest request, byte[] fileData, string fileName, string folderId) { var apiRequest = new FortnoxApiClientRequest <SingleResource <File> >( HttpMethod.Post, request.AccessToken, request.ClientSecret, $"{ApiEndpoints.Archive}/?folderid={folderId}"); return((await FortnoxAPIClient.UploadAsync(apiRequest, fileName, fileData)).Data); }
public void DeleteCostCenterTest() { //TODO: Avoid cluttering Fortnox with data var request = new FortnoxApiRequest(this.connectionSettings.AccessToken, this.connectionSettings.ClientSecret); var response = CostCenterService.CreateCostCenterAsync(request, new CostCenter { Code = "TEMP", Description = "To be removed..", }).GetAwaiter().GetResult(); Assert.AreEqual("TEMP", response.Code); CostCenterService.DeleteCostCenterAsync(request, "TEMP").GetAwaiter().GetResult(); }
public void CreateAndDeleteTrustedEmailDomainTest() { //TODO: Avoid cluttering Fortnox with data var request = new FortnoxApiRequest(this.connectionSettings.AccessToken, this.connectionSettings.ClientSecret); var response = TrustedEmailDomainService.CreateTrustedEmailDomainAsync(request, new TrustedEmailDomain { Domain = "Domän", }).GetAwaiter().GetResult(); Assert.AreEqual("Domän", response.Domain); Assert.IsTrue(response.Id.HasValue); TrustedEmailDomainService.DeleteTrustedEmailDomainAsync(request, response.Id.ToString()).GetAwaiter().GetResult(); }
public async Task ItCanCreateAFile() { var tempFile = CreateTempFile(out var tempFileName); var fileBytes = await File.ReadAllBytesAsync(tempFile); File.Delete(tempFile); var request = new FortnoxApiRequest(connectionSettings.AccessToken, connectionSettings.ClientSecret); var response = await ArchiveService.CreateFileAsync(request, fileBytes, tempFileName, "root"); await RemoveArchive(response.Id); Assert.IsNotNull(response); Assert.AreEqual(tempFileName, response.Name); }
private async Task <ArticleFileConnection> CreateConnection() { var fileId = await CreateFile(); var articles = await GetArticles(); var article = articles.FirstOrDefault() ?? await CreateArticle(); var request = new FortnoxApiRequest(connectionSettings.AccessToken, connectionSettings.ClientSecret); return(await ArticleFileConnectionService.CreateArticleFileConnection( request, article.ArticleNumber, fileId )); }
public async Task CreateAbsenceTransactionTest() { var request = new FortnoxApiRequest(this.connectionSettings.AccessToken, this.connectionSettings.ClientSecret); var response = await AbsenceTransactionsService.CreateAbsenceTransactionAsync(request, new AbsenceTransaction { EmployeeId = "2", CauseCode = CauseCode.SJK, Date = DateTime.Parse("2020-03-7"), Extent = 100.0m, }); Assert.AreEqual(100, response.Extent); await AbsenceTransactionsService.DeleteAbsenceTransactionAsync(request, response.EmployeeId, "2020-03-7", response.CauseCode); }
public static async Task <Asset> WriteUpAssetAsync(FortnoxApiRequest request, string identifier, WriteUpOrDownAsset asset) { var apiRequest = new FortnoxApiClientRequest <SingleResource <WriteUpOrDownAsset> >( HttpMethod.Put, request.AccessToken, request.ClientSecret, $"{ApiEndpoints.Assets}/writeup/{identifier}" ) { Data = new SingleResource <WriteUpOrDownAsset> { Data = asset } }; return((await FortnoxAPIClient.CallAsync <SingleResource <WriteUpOrDownAsset>, SingleResource <Asset> >(apiRequest)).Data); }
public async Task BookkeepInvoicePaymentTest() { var request = new FortnoxApiRequest(this.connectionSettings.AccessToken, this.connectionSettings.ClientSecret); var response = InvoicePaymentService.CreateInvoicePaymentAsync(request, new CreateOrUpdateInvoicePayment { Amount = 99, AmountCurrency = 99, InvoiceNumber = 2 }).GetAwaiter().GetResult(); var bookkeeptInvoicePayment = await InvoicePaymentService.BookkeepInvoicePaymentAsync(request, response.Number); Assert.AreEqual(false, response.Booked); Assert.AreEqual(true, bookkeeptInvoicePayment.Booked); }
public void CreateAndDeletePriceTest() { var request = new FortnoxApiRequest(this.connectionSettings.AccessToken, this.connectionSettings.ClientSecret); var response = PriceService.CreatePriceAsync(request, new Price { ArticleNumber = "10", FromQuantity = 11, PriceValue = 123, PriceList = "A" }).GetAwaiter().GetResult(); Assert.AreEqual(123, response.PriceValue); PriceService.DeletePriceAsync(request, "A", "10", "11").GetAwaiter().GetResult(); }
public static async Task <Currency> UpdateCurrencyAsync(FortnoxApiRequest request, Currency currency) { var apiRequest = new FortnoxApiClientRequest <SingleResource <Currency> >( HttpMethod.Put, request.AccessToken, request.ClientSecret, $"{ApiEndpoints.Currencies}/{currency.Code}") { Data = new SingleResource <Currency> { Data = currency } }; return((await FortnoxAPIClient.CallAsync(apiRequest)).Data); }
public void UpdateContractTest() { var comment = $"{DateTime.Now}"; var request = new FortnoxApiRequest(this.connectionSettings.AccessToken, this.connectionSettings.ClientSecret); var contract = ContractService.GetContractAsync(request, "1").GetAwaiter().GetResult(); var updatedContract = new Contract { DocumentNumber = contract.DocumentNumber, Comments = comment }; var response = ContractService.UpdateContractAsync(request, updatedContract).GetAwaiter().GetResult(); Assert.AreEqual(contract.DocumentNumber, response.DocumentNumber); Assert.AreEqual(comment, response.Comments); }
public static async Task <TaxReduction> UpdateTaxReductionAsync(FortnoxApiRequest request, TaxReduction taxReduction) { var apiRequest = new FortnoxApiClientRequest <SingleResource <TaxReduction> >( HttpMethod.Put, request.AccessToken, request.ClientSecret, $"{ApiEndpoints.TaxReductions}/{taxReduction.Id}") { Data = new SingleResource <TaxReduction> { Data = taxReduction } }; return((await FortnoxAPIClient.CallAsync(apiRequest)).Data); }
public static async Task <Asset> UpdateAssetAsync(FortnoxApiRequest request, Asset asset) { var apiRequest = new FortnoxApiClientRequest <SingleResource <Asset> >( HttpMethod.Put, request.AccessToken, request.ClientSecret, $"{ApiEndpoints.Assets}/{asset.Id}" ) { Data = new SingleResource <Asset> { Data = asset } }; return((await FortnoxAPIClient.CallAsync(apiRequest)).Data); }
public static async Task <SupplierInvoice> CreateSupplierInvoiceAsync(FortnoxApiRequest request, SupplierInvoice invoice) { var apiRequest = new FortnoxApiClientRequest <SingleResource <SupplierInvoice> >( HttpMethod.Post, request.AccessToken, request.ClientSecret, $"{ApiEndpoints.SupplierInvoices}") { Data = new SingleResource <SupplierInvoice>() { Data = invoice } }; return((await FortnoxAPIClient.CallAsync(apiRequest)).Data); }
public async Task CreateAndDeleteInvoicePaymentTest() { var request = new FortnoxApiRequest(this.connectionSettings.AccessToken, this.connectionSettings.ClientSecret); var response = InvoicePaymentService.CreateInvoicePaymentAsync(request, new CreateOrUpdateInvoicePayment { Amount = 99, AmountCurrency = 99, InvoiceNumber = 2 }).GetAwaiter().GetResult(); await InvoicePaymentService.DeleteInvoicePaymentAsync(request, $"{response.Number}"); Assert.AreEqual("2", response.InvoiceCustomerNumber); Assert.AreEqual(99, response.Amount); Assert.AreEqual(99, response.AmountCurrency); }
private async Task <AssetFileConnection> CreateConnection() { var fileId = await CreateFile(); var assets = await GetAssets(); var asset = assets.FirstOrDefault() ?? await CreateAsset(); var request = new FortnoxApiRequest(connectionSettings.AccessToken, connectionSettings.ClientSecret); return(await AssetFileConnectionService.CreateAssetFileConnection( request, asset.Id.ToString(), fileId )); }
public async Task ItCanDeleteAFolder() { var createRequest = new FortnoxApiRequest(connectionSettings.AccessToken, connectionSettings.ClientSecret); var createdFolder = await ArchiveService.CreateFolderAsync( createRequest, $"Test{(new Random()).Next(0, 100000)}" ); var deleteRequest = new FortnoxApiRequest(connectionSettings.AccessToken, connectionSettings.ClientSecret); await ArchiveService.DeleteArchiveAsync(deleteRequest, createdFolder.Folder.Id); var getFolderRequest = new ArchiveListRequest(connectionSettings.AccessToken, connectionSettings.ClientSecret); await Assert.ThrowsExceptionAsync <Exception>(async() => await ArchiveService.GetArchiveAsync( getFolderRequest, createdFolder.Folder.Id )); }
public async Task CreateAndUpdateThenDeleteAttendanceTransactionTest() { var request = new FortnoxApiRequest(this.connectionSettings.AccessToken, this.connectionSettings.ClientSecret); var today = DateTime.UtcNow; var response = AttendanceTransactionService.CreateAttendanceTransactionAsync(request, new AttendanceTransaction { EmployeeId = "1593082874", CauseCode = "TID", Date = today, Hours = 2, Project = "", }).GetAwaiter().GetResult(); Assert.AreEqual(2, response.Hours); await AttendanceTransactionService.DeleteAttendanceTransactionAsync(request, "1593082874", today.ToString("yyyy-MM-dd"), "TID"); }
public async Task GetTaxReductionTest() { var taxReductions = await GetTaxReductions(); if (!taxReductions.Data.Any()) { Assert.Inconclusive("No TaxReductions exist in the system"); return; } var request = new FortnoxApiRequest(this.connectionSettings.AccessToken, this.connectionSettings.ClientSecret); var response = await TaxReductionService.GetTaxReductionAsync( request, taxReductions.Data.First().Id ); Assert.IsTrue(response.Id == taxReductions.Data.First().Id); }
public async Task GetSupplierInvoice() { var invoices = await GetSupplierInvoices(); if (!invoices.Data.Any()) { Assert.Inconclusive("No SupplierInvoices exist in the system"); return; } var request = new FortnoxApiRequest(this.connectionSettings.AccessToken, this.connectionSettings.ClientSecret); var response = await SupplierInvoiceService.GetSupplierInvoiceAsync( request, Convert.ToInt32(invoices.Data.First().GivenNumber) ); Assert.IsNotNull(response); }
public async Task CreateSupplierInvoiceExternalUrlConnectionTest() { var request = new FortnoxApiRequest(this.connectionSettings.AccessToken, this.connectionSettings.ClientSecret); var response = await SupplierInvoiceExternalURLConnectionsService.CreateSupplierInvoiceExternalURLConnectionsAsync( request, new SupplierInvoiceExternalURLConnection { SupplierInvoiceNumber = 1, ExternalURLConnection = ExternalUrl, } ); await DeleteEntity(response.Id); Assert.AreEqual(ExternalUrl, response.ExternalURLConnection); Assert.AreEqual(1, response.SupplierInvoiceNumber); }