Codebasis als Dateien ins Arbeitsrepo statt als Gitlink

QuellCode/CentronERP war nur als Gitlink (Submodul-Referenz auf 79c1142)
getrackt, ohne .gitmodules und ohne erreichbares Remote. Der
Untersuchungsgegenstand der Versuchsreihe war damit nicht reproduzierbar
gesichert: Ein Klon haette ein leeres Verzeichnis erhalten, und die Belege
der 3.287 Anforderungen waeren nicht ueberpruefbar gewesen.

Umstellung:
- Historie nach c:\DEV\CentronERP_git_snapshot_79c1142 ausgelagert
  (vollstaendig lesbar, enthaelt 79c1142 und Vorgaenger 89ccfd6)
- Gitlink aus dem Index entfernt
- Dateiinhalt aufgenommen: 24.557 Dateien, rund 333 MB

Die verschachtelte .gitignore der Codebasis gilt weiter, Build-Artefakte
bleiben ausgeschlossen. Details in Versuche/Versuch_01/_Codebasis-Nachweis.md

QuellCode/CentronERP/tests/Centron.Tests.Integration/Centron.Tests.Integration.csproj

@@ -0,0 +1,30 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net10.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+
+        <IsPackable>false</IsPackable>
+        <IsTestProject>true</IsTestProject>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="coverlet.collector" Version="10.0.0">
+          <PrivateAssets>all</PrivateAssets>
+          <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        </PackageReference>
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.5.1" />
+        <PackageReference Include="xunit" Version="2.9.3" />
+        <PackageReference Include="xunit.runner.visualstudio" Version="3.1.5" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <Using Include="Xunit" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\..\src\webservice\Centron.WebServices.Core\Centron.WebServices.Core.csproj" />
+    </ItemGroup>
+
+</Project>

QuellCode/CentronERP/tests/Centron.Tests.Integration/IntegrationTest.cs

@@ -0,0 +1,50 @@
+using System.Linq.Expressions;
+using Centron.BusinessLogic.Sales.Support;
+using Centron.Data.Entities.Sales.Support;
+using Centron.Data.WebServices.Sales.Support;
+using Centron.Host.Messages;
+using Centron.Host.RestRequests;
+using CentronSoftware.Centron.WebServices.Connections;
+
+namespace Centron.Tests.Integration;
+
+public class IntegrationTest
+{
+    [Fact]
+    public async Task TestGetHelpdesksThroughPaging()
+    {
+        var connection = IntegrationTestHelper.GetConnection();
+
+        var loginToken = await IntegrationTestHelper.Login(connection);
+        
+        var request = GetRequest(new GetHelpdesksThroughPagingRequest
+        {
+            Page = 1,
+            EntriesPerPage = 100,
+            HelpdeskFilter = new HelpdeskFilter(),
+            Sort = HelpdeskSort.CreateDate,
+            Descending = true,
+        }, loginToken);
+        
+        Expression<Func<ICentronRestService, Response<HelpdeskPreviewListThroughPagingDTO>>> execute = f => f.GetHelpdesksThroughPaging(request);
+
+        var response = await connection.CallAsync(execute);
+
+        var result = response.Result.FirstOrDefault();
+
+        Assert.NotNull(result);
+        Assert.Equivalent(new List<HelpdeskPreviewDTO>(), result.Result.ToList());
+        Assert.Equal(1, result.CurrentPage);
+        Assert.Equal(1, result.PageCount);
+        Assert.Equal(12, result.Count);
+    }
+    
+    private Request<T> GetRequest<T>(T data, string ticket = "")
+    {
+        return new Request<T>
+        {
+            Data = data,
+            Ticket = ticket,
+        };
+    }
+}

QuellCode/CentronERP/tests/Centron.Tests.Integration/IntegrationTestHelper.cs

@@ -0,0 +1,97 @@
+using System.Linq.Expressions;
+using Centron.Host.Messages;
+using Centron.Host.RestRequests;
+using Centron.Interfaces.Administration.Connections;
+using CentronSoftware.Centron.WebServices.Connections;
+
+namespace Centron.Tests.Integration;
+
+public class IntegrationTestHelper
+{
+    private static string? LoginToken { get; set; }
+    
+    private static readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);
+
+    public static async Task<string> Login(CentronWebService connection, string? username = null, string? password = null, string? device = null)
+    {
+        await _semaphore.WaitAsync();
+        if (LoginToken != null)
+        {
+            _semaphore.Release();
+            return LoginToken;
+        }
+
+        var request = GetRequest(new LoginRequest
+        {
+            Username = username ?? "admin",
+            Password = password ?? "1",
+            Application = "{7880B678-989E-4405-B570-F7FC34D25367}",
+            Device = device ?? "test",
+            AppVersion = "1.0.2502",
+            LoginKind = WebLoginType.User,
+        });
+        
+        Expression<Func<ICentronRestService, Response<string>>> execute= f => f.Login(request);
+
+        try
+        {
+            var response = await connection.CallAsync(execute);
+            var result = response.Result.FirstOrDefault();
+            Assert.NotNull(result);
+            Assert.NotEmpty(result);
+            LoginToken = result;
+            return result;
+        }
+        finally 
+        {
+            _semaphore.Release();
+        }
+    }
+
+    public static async Task Logout(CentronWebService connection)
+    {
+        await _semaphore.WaitAsync();
+        if (LoginToken == null)
+        {
+            _semaphore.Release();
+            return;
+        }
+
+        var request = GetRequest(LoginToken!);
+        Expression<Func<ICentronRestService, Response>> execute = f => f.Logout(request);
+
+        try
+        {
+            var response = await connection.CallAsync(execute);
+            Assert.Equal(StatusCode.Success, response.Status);
+            LoginToken = null;
+        }
+        finally
+        {
+            _semaphore.Release();
+        }
+    }
+
+    public static Request GetRequest(string ticket = "")
+    {
+        return new Request
+        {
+            Ticket = ticket
+        };
+    }
+
+    public static Request<T> GetRequest<T>(T data, string ticket = "")
+    {
+        return new Request<T>
+        {
+            Data = data,
+            Ticket = ticket,
+        };
+    }
+
+    public static CentronWebService GetConnection()
+    {
+        var url = "http://localhost:1234/CentronService";
+        return new CentronWebService(url);
+    }    
+}

QuellCode/CentronERP/tests/Centron.Tests.Integration/InvoiceIntegrationTest.cs

@@ -0,0 +1,260 @@
+using System.Linq.Expressions;
+using Centron.BusinessLogic.Sales.Receipts.DataAndResults;
+using Centron.BusinessLogic.WebServices.Sales.Receipts.DataAndResults;
+using Centron.Data.WebServices.Sales.Receipts;
+using Centron.Host.Messages;
+using Centron.Host.RestRequests;
+using Centron.Interfaces;
+using CentronSoftware.Centron.WebServices.Connections;
+using CentronSoftware.Centron.WebServices.Entities.Sales.Receipts.ReceiptReceiver;
+
+namespace Centron.Tests.Integration;
+
+public class InvoiceIntegrationTest
+{
+
+    [Fact]
+    public async Task CreateOffer()
+    {
+        var connection = IntegrationTestHelper.GetConnection();
+
+        var loginToken = await IntegrationTestHelper.Login(connection);
+        
+        var request = new CreateReceiptRequest
+        {
+            ReceiptKind = CentronObjectKindNumeric.OfferClass,
+            AddressI3D = 18,
+            ContactPersonI3D = 30,
+            CreateData = new CreateReceiptData(),
+            CustomerI3D = 2,
+            InsertSalutationAndAgreement = false,
+            IgnoreDefaultContract = false,
+            InsertCustomerDiscount = false
+        };
+
+        Expression<Func<ICentronRestService, Response<CreateReceiptResultDTO>>> executeNewReceipt = f => f.CreateNewReceipt(GetRequest(request, loginToken));
+
+        var response = await connection.CallAsync(executeNewReceipt);
+        
+        Assert.NotNull(response);
+        Assert.NotNull(response.Result.FirstOrDefault());
+
+        var i3d = response.Result.First().Receipt.ReceiptReceiver.I3D;
+
+        var expectedReceiptReceiver = new ReceiptReceiverDTO
+        { 
+            I3D = i3d,
+            CompanyName= "Barkunde",
+            Department = "",
+            ContactName = "Frau Web Account",
+            ContactDepartment = "",
+            Street = "Kistlerhofstraße",
+            HouseNumber = "75",
+            HasPostOfficeBox = false,
+            PostOfficeBox = "",
+            Zip = "81379",
+            City = "München",
+            Country = "Deutschland",
+            CountryI3D = 1,
+            AdditionalAddressSupplement = ""
+        };
+        Assert.Equivalent(expectedReceiptReceiver, response.Result.First().Receipt.ReceiptReceiver);
+    }
+
+    [Fact]
+    public async Task CreateReceiverObject()
+    {
+        var connection = IntegrationTestHelper.GetConnection();
+
+        var loginToken = await IntegrationTestHelper.Login(connection);
+        
+        var request = new CreateReceiverTextRequest
+        {
+            AddressI3D = 18,
+            ContactPersonI3D = 30,
+            CustomerI3D = 2,
+        };
+
+        Expression<Func<ICentronRestService, Response<ReceiptReceiverDTO>>> executeNewReceipt = f => f.CreateReceiverObject(GetRequest(request, loginToken));
+
+        var response = await connection.CallAsync(executeNewReceipt);
+        
+        Assert.NotNull(response);
+        Assert.NotNull(response.Result.FirstOrDefault());
+
+        var i3d = response.Result.First().I3D;
+
+        var expectedReceiptReceiver = new ReceiptReceiverDTO
+        { 
+            I3D = i3d,
+            CompanyName= "Barkunde",
+            Department = "",
+            ContactName = "Frau Web Account",
+            ContactDepartment = "",
+            Street = "Kistlerhofstraße",
+            HouseNumber = "75",
+            HasPostOfficeBox = false,
+            PostOfficeBox = "",
+            Zip = "81379",
+            City = "München",
+            Country = "Deutschland",
+            CountryI3D = 1,
+            AdditionalAddressSupplement = ""
+        };
+        Assert.Equivalent(expectedReceiptReceiver, response.Result.First());
+    }
+
+
+    [Fact]
+    public async Task CreateInvoiceWithAlternativeAddress()
+    {
+        var connection = IntegrationTestHelper.GetConnection();
+
+        var loginToken = await IntegrationTestHelper.Login(connection);
+        
+        var request = new CreateReceiptRequest
+        {
+            ReceiptKind = CentronObjectKindNumeric.InvoiceClass,
+            AddressI3D = 18,
+            ContactPersonI3D = 30,
+            CreateData = new CreateReceiptData(){UseAlternativeAddress = true},
+            CustomerI3D = 2,
+            InsertSalutationAndAgreement = false,
+            IgnoreDefaultContract = false,
+            InsertCustomerDiscount = false
+        };
+
+        Expression<Func<ICentronRestService, Response<CreateReceiptResultDTO>>> executeNewReceipt = f => f.CreateNewReceipt(GetRequest(request, loginToken));
+
+        var response = await connection.CallAsync(executeNewReceipt);
+        
+        Assert.NotNull(response);
+        Assert.NotNull(response.Result.FirstOrDefault());
+
+        var i3d = response.Result.First().Receipt.ReceiptReceiver.I3D;
+
+        var expectedReceiptReceiver = new ReceiptReceiverDTO
+        { 
+            I3D = i3d,
+            CompanyName= "Barkunde",
+            Department = "",
+            ContactName = "",
+            ContactDepartment = "",
+            Street = "Holzweg",
+            HouseNumber = "1",
+            HasPostOfficeBox = false,
+            PostOfficeBox = "",
+            Zip = "12345",
+            City = "Wald",
+            Country = "Deutschland",
+            CountryI3D = 1,
+            AdditionalAddressSupplement = ""
+        };
+        Assert.Equivalent(expectedReceiptReceiver, response.Result.First().Receipt.ReceiptReceiver);
+    }
+
+    [Theory]
+    [InlineData(CentronObjectKindNumeric.OfferClass)]
+    [InlineData(CentronObjectKindNumeric.InvoiceClass)]
+    [InlineData(CentronObjectKindNumeric.OrderClass)]
+    [InlineData(CentronObjectKindNumeric.CreditVoucherClass)]
+    public async Task SaveAndLoadOffer(CentronObjectKindNumeric receiptKind)
+    {
+        var connection = IntegrationTestHelper.GetConnection();
+
+        var loginToken = await IntegrationTestHelper.Login(connection);
+        
+        var request = new CreateReceiptRequest
+        {
+            ReceiptKind = receiptKind,
+            AddressI3D = 18,
+            ContactPersonI3D = 30,
+            CreateData = new CreateReceiptData(){UseAlternativeAddress = false},
+            CustomerI3D = 2,
+            InsertSalutationAndAgreement = false,
+            IgnoreDefaultContract = false,
+            InsertCustomerDiscount = false
+        };
+
+        Expression<Func<ICentronRestService, Response<CreateReceiptResultDTO>>> executeNewReceipt = f => f.CreateNewReceipt(GetRequest(request, loginToken));
+
+        var response = await connection.CallAsync(executeNewReceipt);
+
+        Assert.NotNull(response);
+        Assert.NotNull(response.Result.FirstOrDefault());
+        
+        var receipt = response.Result.First().Receipt;
+        
+        var requestSave = new SaveReceiptRequest()
+        {
+            Receipt = receipt,
+            SaveData = new SaveReceiptData()
+            {
+                IgnoreCallbacks = true
+            },
+            AutoLockIfNewReceipt = false,
+        };
+
+        Expression<Func<ICentronRestService, Response<SaveReceiptResultDTO>>> executeSave = f => f.SaveReceipt(GetRequest(requestSave, loginToken));
+
+        var responseSave = await connection.CallAsync(executeSave);
+
+        Assert.NotNull(responseSave);
+        Assert.NotNull(responseSave.Result.First().ReceiptI3D);
+        
+        var requestSearch = new GetReceiptByI3DRequest()
+        {
+            ReceiptI3D = responseSave.Result.First().ReceiptI3D.GetValueOrDefault(),
+            ObjectKind = responseSave.Result.First().Receipt.ReceiptKind
+        };
+
+        Expression<Func<ICentronRestService, Response<ReceiptBaseDTO>>> executeSearch = f => f.GetReceiptByI3D(GetRequest(requestSearch, loginToken));
+
+        var responseSearch = await connection.CallAsync(executeSearch);
+        
+        Assert.NotNull(responseSearch);
+        var i3d = responseSearch.Result.First().ReceiptReceiver.I3D;
+        
+        var expectedReceiptReceiver = new ReceiptReceiverDTO
+        { 
+            I3D = i3d,
+            CompanyName= "Barkunde",
+            Department = "",
+            ContactName = "Frau Web Account",
+            ContactDepartment = "",
+            Street = "Kistlerhofstraße",
+            HouseNumber = "75",
+            HasPostOfficeBox = false,
+            PostOfficeBox = "",
+            Zip = "81379",
+            City = "München",
+            Country = "Deutschland",
+            CountryI3D = 1,
+            AdditionalAddressSupplement = ""
+        };
+
+        Assert.Equivalent(expectedReceiptReceiver, responseSearch.Result.First().ReceiptReceiver);
+        
+        var requestNewVersion = new CreateNewReceiptVersionRequest()
+        {
+            ReceiptI3D = responseSave.Result.First().ReceiptI3D.GetValueOrDefault(),
+            CreateNewVersionData = new CreateNewVersionData(){IgnoreCallbacks = true},
+            ReceiptKind = responseSave.Result.First().Receipt.ReceiptKind
+        };
+
+        Expression<Func<ICentronRestService, Response<CreateNewVersionResultDTO>>> executeNewVersion = f => f.CreateNewReceiptVersion(GetRequest(requestNewVersion, loginToken));
+
+        var responseNewVersion = await connection.CallAsync(executeNewVersion);
+        
+        Assert.Equivalent(expectedReceiptReceiver, responseNewVersion.Result.First().Receipt.ReceiptReceiver);
+    }
+
+    private Request<T> GetRequest<T>(T data, string ticket = "")
+    {
+        return new Request<T>
+        {
+            Data = data,
+            Ticket = ticket,
+        };
+    }
+}

QuellCode/CentronERP/tests/Centron.Tests.Integration/Tests/EmployeeManagement/Ticket154840.cs

@@ -0,0 +1,499 @@
+using Centron.BusinessLogic.Administration.Rights;
+using Centron.Data.WebServices.Administration;
+using Centron.Data.WebServices.Administration.Employees;
+using Centron.Data.WebServices.EmployeeArea;
+using Centron.Host.Messages;
+using Centron.Interfaces.Administration.Employees;
+using CentronSoftware.Centron.WebServices.Connections;
+using System.Linq.Expressions;
+
+namespace Centron.Tests.Integration.Tests.EmployeeManagement
+{
+    /// <summary>
+    /// We test if a user with no admin rights is able to retrieve sensible employee data from collegues via webservice
+    /// </summary>
+    /// <returns></returns>
+    public class Ticket154840
+    {
+        private const string _appUserLogin = "drnorights";
+        private const string _appUserPassword = "123456";
+        private const string _appUserDevice = "TestDevice";
+        
+        [Fact]
+        public async Task Execute()
+        {   
+            // Prepare
+            var connection = IntegrationTestHelper.GetConnection();
+            var adminToken = await IntegrationTestHelper.Login(connection);
+            var adminUserEmployee = await this.GetLoggedInEmployee(connection, adminToken);
+                        
+            var secretAgentEmployee = await this.GetOrCreateEmployee(connection, adminToken, this.CreateSecretAgentEmployeeDTO);
+            var drNoRightsEmployee = await this.GetOrCreateEmployee(connection, adminToken, this.CreateDrNoRightsEmployeeDTO);
+            var drNoRightsAppUser = await this.GetOrCreateAppUser(connection, adminToken, this.CreateDrNoRightsAppUser(drNoRightsEmployee));
+            var noRightsGroup = await this.GetOrCreateRightsGroup(connection, adminToken);
+            await this.AddUserToRightsGroup(connection, adminToken, drNoRightsAppUser.I3D, noRightsGroup.I3D);
+
+            // Test reading employee data with administrative rights
+            await this.RequestOtherEmployeeDataWithAdministrativeRights(connection, adminToken, secretAgentEmployee);
+            await this.RequestOwnEmployeeDataWithAdministrativeRights(connection, adminToken, adminUserEmployee);
+
+            await IntegrationTestHelper.Logout(connection); // Logout admin
+
+            var drNoRightsToken = await IntegrationTestHelper.Login(connection, _appUserLogin, _appUserPassword, _appUserDevice);
+
+            // Test reading employee data without administrative rights
+            await this.RequestOtherEmployeeDataWithoutAdministrativeRights(connection, drNoRightsToken, secretAgentEmployee);
+            await this.RequestOwnEmployeeDataWithoutAdministrativeRights(connection, drNoRightsToken, drNoRightsEmployee);
+        }
+
+        #region Get/Create Employee data
+
+        private EmployeeDTO CreateSecretAgentEmployeeDTO()
+        {
+            return new EmployeeDTO()
+            {
+                FirstName = "James",
+                LastName = "Bond",
+                ShortSign = "007",
+                Employeenumber = 7,
+                Email = "bond@mi6.uk",
+                DisplayText = "Top Secret!",
+                RemainingDaysOfVacation = 28,
+                VacationEntitlement = 7,
+                State = 1,
+                SupportLevel = null,
+                DefaultStorageI3D = null,
+                Dispatcher = false,
+                IsActive = true,
+                Availability = EmployeeAvailability.DoNotDisturb,
+                LastAvailabilityChange = new DateTime(2021, 10, 8, 07, 07, 07),
+                BranchI3D = null,
+                LeavingDate = new DateTime(2077, 07, 07, 07, 07, 07),
+                Template1 = false,
+                Template2 = false,
+                Template3 = false,
+                Template4 = false,
+                PersonnelNumber = 7,
+                SuperiorI3D = null,
+                Image = new byte[] { 0, 0, 7 },
+                SalutationI3D = 1,
+                Street = "No. 25, Wellington Square",
+                Zip = "SW3 4NJ",
+                City = "London",
+                EMailLockbox = "box007",
+                Phone1 = "007 official",
+                Phone2 = "007 mobile",
+                Phone3 = "007 private",
+                Phone4 = "007 bereau",
+                Fax1 = "007 fax1",
+                Fax2 = "007 fax2",
+                Birthday = new DateTime(1980, 11, 11),
+                Salary = 82000,
+                Job = "Secret Agent",
+                LanguageSkills = "Italian, French, Russian, German, Portuguese, Spanish, Mandarin, Cantonese, Japanese",
+                HoursForNextMonth = 160,
+                TrialPeriod = 6,
+                RemindTrialPeriod = true,
+                TrialPeriodRemindInDays = 30,
+                ContractPeriod = 12,
+                RemindContractEnd = true,
+                ContractRemindInDays = 30,
+                CommencementDate = new DateTime(1962, 10, 6),
+                ContractKind = "License to kill",
+                SaleText = "25 films so far... what else to say",
+                Comment = "Oh, just a drink. A martini, shaken, not stirred.",
+                CostCenter = null,
+                SupplierI3D = null,
+                RootDirI3D = null,
+                ManagementVariableField01 = 1000.0m,
+                ManagementVariableField02 = 2000.0m,
+                ManagementVariableField03 = 3000.0m,
+                ManagementVariableField04 = 4000.0m,
+                ManagementVariableField05 = 5000.0m,
+                ManagementVariableField06 = 6000.0m,
+                ManagementVariableField07 = 7000.0m,
+                ManagementVariableField08 = 8000.0m,
+                ManagementVariableField09 = 9000.0m,
+                ManagementVariableField10 = 10000.0m,
+                SignatureAsPicture = new byte[] { 0, 0, 7 },
+                SignatureAsPictureFileExtension = "png",
+                Signature = "Bond, James Bond"
+            };
+        }
+
+        private EmployeeDTO CreateDrNoRightsEmployeeDTO()
+        {
+            return new EmployeeDTO()
+            {
+                FirstName = "Julius",
+                LastName = "No",
+                ShortSign = "Dr. No",
+                Employeenumber = 7,
+                Email = "julius@no.uk",
+                DisplayText = "Mad Scientist!",
+                RemainingDaysOfVacation = 100,
+                VacationEntitlement = 4,
+                State = 1,
+                SupportLevel = null,
+                DefaultStorageI3D = null,
+                Dispatcher = false,
+                IsActive = true,
+                Availability = EmployeeAvailability.Busy,
+                LastAvailabilityChange = new DateTime(1962, 10, 6, 00, 00, 00),
+                BranchI3D = null,
+                LeavingDate = new DateTime(2088, 2, 2, 2, 2, 2),
+                Template1 = false,
+                Template2 = false,
+                Template3 = false,
+                Template4 = false,
+                PersonnelNumber = 2,
+                SuperiorI3D = null,
+                Image = new byte[] { 2, 2, 2 },
+                SalutationI3D = 1,
+                Street = "SPECTRE Base",
+                Zip = "FL 33042",
+                City = "Crab Key Island",
+                EMailLockbox = "boxDrNo",
+                Phone1 = "Nr2 official",
+                Phone2 = "Nr2 mobile",
+                Phone3 = "Nr2 private",
+                Phone4 = "Nr2 bereau",
+                Fax1 = "Nr2 fax1",
+                Fax2 = "Nr2 fax2",
+                Birthday = new DateTime(1918, 2, 2),
+                Salary = 1000000,
+                Job = "Mad Scientist",
+                LanguageSkills = "English, Chinese",
+                HoursForNextMonth = 240,
+                TrialPeriod = 3,
+                RemindTrialPeriod = false,
+                TrialPeriodRemindInDays = 10,
+                ContractPeriod = 36,
+                RemindContractEnd = false,
+                ContractRemindInDays = 10,
+                CommencementDate = new DateTime(1962, 10, 6),
+                ContractKind = "SPECTRE Main Member",
+                SaleText = "Plays with atoms",
+                Comment = "The successful criminal brain is always superior. It has to be.",
+                CostCenter = null,
+                SupplierI3D = null,
+                RootDirI3D = null,
+                ManagementVariableField01 = 1000000.0m,
+                ManagementVariableField02 = 2000000.0m,
+                ManagementVariableField03 = 3000000.0m,
+                ManagementVariableField04 = 4000000.0m,
+                ManagementVariableField05 = 5000000.0m,
+                ManagementVariableField06 = 6000000.0m,
+                ManagementVariableField07 = 7000000.0m,
+                ManagementVariableField08 = 8000000.0m,
+                ManagementVariableField09 = 9000000.0m,
+                ManagementVariableField10 = 10000000.0m,
+                SignatureAsPicture = new byte[] { 2, 2, 2 },
+                SignatureAsPictureFileExtension = "png",
+                Signature = "Dr. Julius No"
+            };
+        }
+                
+        private async Task<EmployeeDTO> GetOrCreateEmployee(CentronWebService connection, string adminToken, Func<EmployeeDTO> createEmployeeMethod)
+        {
+            var newEmployee = createEmployeeMethod();
+            var existingEmployee = await this.LoadEmployee(connection, adminToken, newEmployee);
+
+            if (existingEmployee == null)
+            {
+                existingEmployee = newEmployee;
+                newEmployee.I3D = await this.SaveEmployee(newEmployee, connection, adminToken);
+            }              
+
+            return existingEmployee;
+        }
+
+        private async Task<EmployeeDTO?> LoadEmployee(CentronWebService connection, string loginToken, EmployeeDTO newEmployee)
+        {            
+            var request = new Request() { Ticket = loginToken };
+            var response = await connection.CallAsync(f => f.GetAllActiveEmployees(request));
+
+            Assert.Equal(StatusCode.Success, response.Status);
+            Assert.NotNull(response.Result);
+
+            var result = response.Result.FirstOrDefault(f => 
+                string.Equals(f.FirstName, newEmployee.FirstName) &&
+                string.Equals(f.LastName, newEmployee.LastName) &&
+                f.PersonnelNumber == newEmployee.PersonnelNumber);
+
+            return result;
+        }
+
+        private async Task<int> SaveEmployee(EmployeeDTO employeeDTO, CentronWebService connection, string loginToken)
+        {
+            var request = IntegrationTestHelper.GetRequest(employeeDTO, loginToken);
+            var response = await connection.CallAsync(f => f.SaveEmployee(request));
+
+            Assert.Equal(StatusCode.Success, response.Status);
+            Assert.NotNull(response.Result?.First());
+
+            return response.Result?.First() ?? 0;
+        }
+
+        #endregion
+
+
+        #region Get/Create AppUser data
+
+        private AppUserDTO CreateDrNoRightsAppUser(EmployeeDTO drNoRightsEmployee)
+        {
+            return new AppUserDTO()
+            {
+                EmployeeI3D = drNoRightsEmployee.I3D,
+                Name = _appUserLogin,
+                PasswordMinLength = 0,
+                PasswordValidDurationDays = int.MaxValue,
+                LastPasswordChangedDate = DateTime.Now,
+                AccountDisabledFromDate = null,
+                IsAccountDisabled = false,
+                Kommentar = "Has no rights XD",
+                Status = 1,
+                LoginUsername = _appUserLogin,
+                Password = _appUserPassword,
+                UseTwoFactorAuthentication = false,
+                TwoFactorValidDurationInDays = null,
+                AuthentificationKind = AuthentificationKind.Default
+            };
+        }
+
+        private async Task<AppUserDTO> GetOrCreateAppUser(CentronWebService connection, string adminToken, AppUserDTO newAppUserDTO)
+        {
+            var existingAppUser = await this.LoadAppUser(connection, adminToken, newAppUserDTO);
+
+            if(existingAppUser == null)
+                existingAppUser = await this.SaveAppUser(connection, adminToken, newAppUserDTO);
+
+            return existingAppUser;
+        }
+
+        private async Task<AppUserDTO?> LoadAppUser(CentronWebService connection, string adminToken, AppUserDTO appUserDTO)
+        {
+            var request = new Request() { Ticket = adminToken };
+            var response = await connection.CallAsync(f => f.GetAllAppUsers(request));
+
+            Assert.Equal(StatusCode.Success, response.Status);
+            Assert.NotNull(response.Result);
+
+            return response.Result.FirstOrDefault(f => f.EmployeeI3D == appUserDTO.EmployeeI3D);
+        }
+
+        private async Task<AppUserDTO> SaveAppUser(CentronWebService connection, string adminToken, AppUserDTO appUserDTO)
+        {
+            var request = IntegrationTestHelper.GetRequest(appUserDTO, adminToken);
+            var response = await connection.CallAsync(f => f.SaveOrUpdateAppUser(request));
+
+            Assert.Equal(StatusCode.Success, response.Status);
+            Assert.NotNull(response.Result?.First());
+
+            return response.Result!.First()!;
+        }
+
+        private async Task<EmployeeDTO> GetLoggedInEmployee(CentronWebService connection, string loginToken)
+        {
+            var request = new Request() { Ticket = loginToken };
+            var response = await connection.CallAsync(f => f.GetLoggedInUser(request));
+
+            Assert.Equal(StatusCode.Success, response.Status);
+            Assert.NotNull(response.Result?.First());
+
+            var userEmployeePreview = response.Result!.First();
+            var userEmployeeData = await this.GetEmployeeByI3D(connection, loginToken, userEmployeePreview.I3D);
+
+            Assert.NotNull(userEmployeeData);
+
+            return userEmployeeData;
+        }
+
+        #endregion
+
+
+        #region Get/Create RightsGroup
+
+        private async Task<AppGroupDTO> GetOrCreateRightsGroup(CentronWebService connection, string adminToken)
+        {
+            var request = new Request() { Ticket = adminToken };
+            var response = await connection.CallAsync(f => f.GetAllRightGroups(request));
+
+            Assert.Equal(StatusCode.Success, response.Status);
+            Assert.True(response.Result != null);
+
+            var noRightsGroup = response.Result!.FirstOrDefault(f => string.Equals(f.Name, "NoRightsGroup"));
+
+            if (noRightsGroup == null)
+            {
+                noRightsGroup = new AppGroupDTO() { Name = "NoRightsGroup" };
+                var createRequest = new Request<AppGroupDTO>() { Data = noRightsGroup, Ticket = adminToken };
+                var createResponse = await connection.CallAsync(f => f.SaveRightGroup(createRequest));
+
+                Assert.Equal(StatusCode.Success, createResponse.Status);
+                Assert.NotNull(createResponse.Result?.First());
+
+                noRightsGroup = createResponse.Result.First();                                
+            }            
+
+            return noRightsGroup;
+        }
+
+        private async Task AddUserToRightsGroup(CentronWebService connection, string adminToken, int appUserI3D, int rightGroupI3D)
+        {
+            var updateRequest = new UpdateAppGroupAndUserDTO() { AppUserI3D = appUserI3D, AppGroupI3D = rightGroupI3D };
+            var request = new Request<UpdateAppGroupAndUserDTO>() { Data = updateRequest, Ticket = adminToken };
+
+            var removeResponse = await connection.CallAsync(f => f.RemoveUserFromRightGroup(request));
+            Assert.Equal(StatusCode.Success, removeResponse.Status);
+
+            var addResponse = await connection.CallAsync(f => f.AddUserToRightGroup(request));
+            Assert.Equal(StatusCode.Success, addResponse.Status);
+        }
+
+        #endregion
+
+
+        #region Test methods
+
+        private async Task RequestOtherEmployeeDataWithAdministrativeRights(CentronWebService connection, string loginToken, EmployeeDTO referenceEmployeeData)
+        {
+            var otherEmployeePreview = await this.GetEmployeeInfoByI3D(connection, loginToken, referenceEmployeeData.I3D);
+            Assert.NotNull(otherEmployeePreview);
+            Assert.Equal(0, otherEmployeePreview.RemainingDaysOfVacation);  // Currently not implemented by EmployeeToEmployeePreviewDTO, if that changes adjust the test
+            Assert.Equal(0, otherEmployeePreview.VacationEntitlement);      // Currently not implemented by EmployeeToEmployeePreviewDTO, if that changes adjust the test
+            Assert.Null(otherEmployeePreview.LeavingDate);   // Currently not implemented by EmployeeToEmployeePreviewDTO, if that changes adjust the test
+
+            var otherEmployeeData = await this.GetEmployeeByI3D(connection, loginToken, referenceEmployeeData.I3D);
+            Assert.NotNull(otherEmployeeData);
+
+            this.AssertEmployeeDataEquals(otherEmployeeData, referenceEmployeeData);
+        }
+
+        private async Task RequestOwnEmployeeDataWithAdministrativeRights(CentronWebService connection, string loginToken, EmployeeDTO referenceEmployeeData)
+        {
+            var ownEmployeePreview = await this.GetEmployeeInfoByI3D(connection, loginToken, referenceEmployeeData.I3D);
+            Assert.NotNull(ownEmployeePreview);
+
+            var ownEmployeeData = await this.GetEmployeeByI3D(connection, loginToken, referenceEmployeeData.I3D);
+            Assert.NotNull(ownEmployeeData);
+
+            this.AssertEmployeeDataEquals(ownEmployeeData, referenceEmployeeData);
+        }
+
+        private async Task RequestOtherEmployeeDataWithoutAdministrativeRights(CentronWebService connection, string loginToken, EmployeeDTO referenceEmployee)
+        {
+            var testEmployeePreview = await this.GetEmployeeInfoByI3D(connection, loginToken, referenceEmployee.I3D);
+            Assert.NotNull(testEmployeePreview);
+            Assert.Equal(0, testEmployeePreview.RemainingDaysOfVacation);
+            Assert.Equal(0, testEmployeePreview.VacationEntitlement);
+            Assert.Null(testEmployeePreview.LeavingDate);
+
+            // Sensible Data should now be replaced with placeholders.
+            var testEmployee = await this.GetEmployeeByI3D(connection, loginToken, referenceEmployee.I3D);
+            Assert.NotNull(testEmployee);
+            Assert.Equal(0, testEmployee.RemainingDaysOfVacation);
+            Assert.Equal(0, testEmployee.VacationEntitlement);
+            Assert.Null(testEmployee.LeavingDate);
+            Assert.Equal(string.Empty, testEmployee.Street);
+            Assert.Equal(string.Empty, testEmployee.Zip);
+            Assert.Equal(string.Empty, testEmployee.City);
+            Assert.Equal(string.Empty, testEmployee.Phone3);
+            Assert.Null(testEmployee.Birthday);
+            Assert.Equal(decimal.Zero, testEmployee.Salary);
+            Assert.Equal(string.Empty, testEmployee.LanguageSkills);
+            Assert.Null(testEmployee.HoursForNextMonth);
+            Assert.Null(testEmployee.TrialPeriod);
+            Assert.Equal(int.MinValue, testEmployee.ContractPeriod);
+            Assert.Equal(string.Empty, testEmployee.ContractKind);
+            Assert.Null(testEmployee.CommencementDate);
+            Assert.Equal(string.Empty, testEmployee.Comment);
+            Assert.Equal(decimal.Zero, testEmployee.ManagementVariableField01);
+            Assert.Equal(decimal.Zero, testEmployee.ManagementVariableField02);
+            Assert.Equal(decimal.Zero, testEmployee.ManagementVariableField03);
+            Assert.Equal(decimal.Zero, testEmployee.ManagementVariableField04);
+            Assert.Equal(decimal.Zero, testEmployee.ManagementVariableField05);
+            Assert.Equal(decimal.Zero, testEmployee.ManagementVariableField06);
+            Assert.Equal(decimal.Zero, testEmployee.ManagementVariableField07);
+            Assert.Equal(decimal.Zero, testEmployee.ManagementVariableField08);
+            Assert.Equal(decimal.Zero, testEmployee.ManagementVariableField09);
+            Assert.Equal(decimal.Zero, testEmployee.ManagementVariableField10);
+            Assert.Null(testEmployee.SignatureAsPicture);
+            Assert.Equal(string.Empty, testEmployee.Signature);
+        }
+
+        private async Task RequestOwnEmployeeDataWithoutAdministrativeRights(CentronWebService connection, string loginToken, EmployeeDTO referenceEmployeeData)
+        {
+            var ownEmployeePreview = await this.GetEmployeeInfoByI3D(connection, loginToken, referenceEmployeeData.I3D);
+            Assert.NotNull(ownEmployeePreview);
+
+            var ownEmployeeData = await this.GetEmployeeByI3D(connection, loginToken, referenceEmployeeData.I3D);
+            Assert.NotNull(ownEmployeeData);
+
+            this.AssertEmployeeDataEquals(ownEmployeeData, referenceEmployeeData);
+        }
+
+        private async Task<EmployeePreviewDTO> GetEmployeeInfoByI3D(CentronWebService connection, string loginToken, int employeeI3D)
+        {
+            var request = IntegrationTestHelper.GetRequest(employeeI3D, loginToken);
+
+            Expression<Func<ICentronRestService, Response<EmployeePreviewDTO>>> execute = f => f.GetEmployeeInfoByI3D(request);
+
+            var response = await connection.CallAsync(execute);
+
+            if (response.Status != StatusCode.Success)
+                throw new Exception($"Unable to get EmployeePreviewDTO: {response.Message}");
+
+            Assert.NotNull(response.Result?.FirstOrDefault());
+
+            return response.Result.First();
+        }
+
+        private async Task<EmployeeDTO> GetEmployeeByI3D(CentronWebService connection, string loginToken, int employeeI3D)
+        {
+            var request = IntegrationTestHelper.GetRequest(employeeI3D, loginToken);
+
+            Expression<Func<ICentronRestService, Response<EmployeeDTO>>> execute = f => f.GetEmployeeByI3D(request);
+
+            var response = await connection.CallAsync(execute);
+
+            if (response.Status != StatusCode.Success)
+                throw new Exception($"Unable to get EmployeeDTO: {response.Message}");
+
+            Assert.NotNull(response.Result?.FirstOrDefault());
+
+            return response.Result.First();
+        }
+
+        private void AssertEmployeeDataEquals(EmployeeDTO employee, EmployeeDTO reference)
+        {
+            Assert.Equal(reference.Street, employee.Street);
+            Assert.Equal(reference.Zip, employee.Zip);
+            Assert.Equal(reference.City, employee.City);
+            Assert.Equal(reference.Phone3, employee.Phone3);
+            Assert.Equal(reference.Birthday, employee.Birthday);
+            Assert.Equal(reference.Salary, employee.Salary);
+            Assert.Equal(reference.LanguageSkills, employee.LanguageSkills);
+            Assert.Equal(reference.HoursForNextMonth, employee.HoursForNextMonth);
+            Assert.Equal(reference.TrialPeriod, employee.TrialPeriod);
+            Assert.Equal(reference.ContractPeriod, employee.ContractPeriod);
+            Assert.Equal(reference.ContractKind, employee.ContractKind);
+            Assert.Equal(reference.CommencementDate, employee.CommencementDate);
+            Assert.Equal(reference.Comment, employee.Comment);
+            Assert.Equal(reference.ManagementVariableField01, employee.ManagementVariableField01);
+            Assert.Equal(reference.ManagementVariableField02, employee.ManagementVariableField02);
+            Assert.Equal(reference.ManagementVariableField03, employee.ManagementVariableField03);
+            Assert.Equal(reference.ManagementVariableField04, employee.ManagementVariableField04);
+            Assert.Equal(reference.ManagementVariableField05, employee.ManagementVariableField05);
+            Assert.Equal(reference.ManagementVariableField06, employee.ManagementVariableField06);
+            Assert.Equal(reference.ManagementVariableField07, employee.ManagementVariableField07);
+            Assert.Equal(reference.ManagementVariableField08, employee.ManagementVariableField08);
+            Assert.Equal(reference.ManagementVariableField09, employee.ManagementVariableField09);
+            Assert.Equal(reference.ManagementVariableField10, employee.ManagementVariableField10);
+            Assert.Equal(reference.SignatureAsPicture, employee.SignatureAsPicture);
+            Assert.Equal(reference.Signature, employee.Signature);
+        }
+
+        #endregion
+    }
+}

QuellCode/CentronERP/tests/Centron.Tests.Integration/WebServiceConfig.xml

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<WebServiceConfig>
+    <WebServiceAddress>http://localhost:1234/CentronService</WebServiceAddress>
+    <PublicWebServiceAddress></PublicWebServiceAddress>
+    <WebServiceCertificateFilePath></WebServiceCertificateFilePath>
+    <WebServiceCertificatePassword></WebServiceCertificatePassword>
+    <ActiveDirectoryAuthEnabled>false</ActiveDirectoryAuthEnabled>
+    <ActiveDirectoryUrl></ActiveDirectoryUrl>
+    <ActiveDirectoryName></ActiveDirectoryName>
+    <ActiveDirectoryCertificateHash></ActiveDirectoryCertificateHash>
+    <DatabaseConnectionString>
+    </DatabaseConnectionString>
+    <DatabaseConnectionStringPlain>
+        Server=localhost,1433; Database=Centron; User Id=SA; Password=SA!password
+    </DatabaseConnectionStringPlain>
+    <UseIncreasedThreadPool>true</UseIncreasedThreadPool>
+    <ActivateHelpPage>false</ActivateHelpPage>
+    <ExecuteServices>false</ExecuteServices>
+    <ProxyAddress></ProxyAddress>
+    <ProxyPort />
+    <ProxyUsername />
+    <ProxyPassword></ProxyPassword>
+    <TwoFactorAuthEnabled>false</TwoFactorAuthEnabled>
+    <TwoFactorAuthType>RadiusServer</TwoFactorAuthType>
+    <RadiusServerAddress></RadiusServerAddress>
+    <RadiusServerSecret></RadiusServerSecret>
+    <RadiusServerConnectionTimeoutInSeconds>30</RadiusServerConnectionTimeoutInSeconds>
+    <RadiusServerNasIdentifier></RadiusServerNasIdentifier>
+    <RadiusServerNasIpAddress></RadiusServerNasIpAddress>
+    <MailTwoFactorAuthSenderAddress></MailTwoFactorAuthSenderAddress>
+    <MailTwoFactorAuthTimeoutInSeconds>120</MailTwoFactorAuthTimeoutInSeconds>
+    <TwoFactorValidDurationInDays>0</TwoFactorValidDurationInDays>
+</WebServiceConfig>