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