From 590d0c52497b1105a846a675c46fc9774c91db32 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Morten=20Remb=C3=B8l=20Jacobsen?= Date: Tue, 27 Sep 2022 12:58:57 +0200 Subject: [PATCH 001/272] Added draft --- .../IStsOrganizationSynchronizationService.cs | 10 +++++ .../StsOrganizationSynchronizationService.cs | 40 ++++++++++++------- 2 files changed, 36 insertions(+), 14 deletions(-) diff --git a/Core.ApplicationServices/Organizations/IStsOrganizationSynchronizationService.cs b/Core.ApplicationServices/Organizations/IStsOrganizationSynchronizationService.cs index 6733e2ebad..a5fe64c14a 100644 --- a/Core.ApplicationServices/Organizations/IStsOrganizationSynchronizationService.cs +++ b/Core.ApplicationServices/Organizations/IStsOrganizationSynchronizationService.cs @@ -6,6 +6,16 @@ namespace Core.ApplicationServices.Organizations { public interface IStsOrganizationSynchronizationService { + //TODO: More detailed error + /// + /// TODO: Description + /// + /// + /// + /// + /// + /// + Maybe ValidateConnection(Guid organizationId); /// /// Retrieves a view of the organization as it exists in STS Organization /// diff --git a/Core.ApplicationServices/Organizations/StsOrganizationSynchronizationService.cs b/Core.ApplicationServices/Organizations/StsOrganizationSynchronizationService.cs index 5ace41bf55..345e4f1ca8 100644 --- a/Core.ApplicationServices/Organizations/StsOrganizationSynchronizationService.cs +++ b/Core.ApplicationServices/Organizations/StsOrganizationSynchronizationService.cs @@ -28,24 +28,36 @@ public StsOrganizationSynchronizationService( _authorizationContext = authorizationContext; } - public Result GetStsOrganizationalHierarchy(Guid organizationId, Maybe levelsToInclude) + public Maybe ValidateConnection(Guid organizationId) { - var orgWithPermission = _organizationService - .GetOrganization(organizationId) - .Bind(WithImportPermission); + return GetOrganizationWithImportPermission(organizationId) + .Match(ValidateConnection, error => error); + } - if (orgWithPermission.Failed) - return orgWithPermission.Error; + private OperationError ValidateConnection(Organization organizationId) + { + //TODO: Exchange the + throw new NotImplementedException(); + } - var organization = orgWithPermission.Value; - var orgTreeResult = _stsOrganizationUnitService.ResolveOrganizationTree(organization); - if (orgTreeResult.Failed) - { - var detailedOperationError = orgTreeResult.Error; - return new OperationError($"Failed to load organization tree:{detailedOperationError.Detail:G}:{detailedOperationError.FailureType:G}:{detailedOperationError.Message}", detailedOperationError.FailureType); - } + public Result GetStsOrganizationalHierarchy(Guid organizationId, Maybe levelsToInclude) + { + return + GetOrganizationWithImportPermission(organizationId) + .Bind(LoadOrganizationUnits) + .Bind(root => FilterByRequestedLevels(root, levelsToInclude)); + } + + private Result LoadOrganizationUnits(Organization organization) + { + return _stsOrganizationUnitService.ResolveOrganizationTree(organization).Match>(root => root, detailedOperationError => new OperationError($"Failed to load organization tree:{detailedOperationError.Detail:G}:{detailedOperationError.FailureType:G}:{detailedOperationError.Message}", detailedOperationError.FailureType)); + } - return FilterByRequestedLevels(orgTreeResult.Value, levelsToInclude); + private Result GetOrganizationWithImportPermission(Guid organizationId) + { + return _organizationService + .GetOrganization(organizationId) + .Bind(WithImportPermission); } private Result WithImportPermission(Organization organization) From b61d92848ef816537c25b8101ba0e0f9a1843ad3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Morten=20Remb=C3=B8l=20Jacobsen?= Date: Tue, 27 Sep 2022 20:57:18 +0200 Subject: [PATCH 002/272] Added service content draft --- .../StsOrganizationSynchronizationService.cs | 5 +-- .../Organizations/IStsOrganizationService.cs | 1 + .../IStsOrganizationUnitService.cs | 1 + .../StsOrganizationCompanyLookupService.cs | 4 +- .../DomainServices/StsOrganizationService.cs | 40 ++++++++++++++----- .../StsOrganizationUnitService.cs | 5 +++ 6 files changed, 41 insertions(+), 15 deletions(-) diff --git a/Core.ApplicationServices/Organizations/StsOrganizationSynchronizationService.cs b/Core.ApplicationServices/Organizations/StsOrganizationSynchronizationService.cs index 345e4f1ca8..2ac3a87718 100644 --- a/Core.ApplicationServices/Organizations/StsOrganizationSynchronizationService.cs +++ b/Core.ApplicationServices/Organizations/StsOrganizationSynchronizationService.cs @@ -34,10 +34,9 @@ public Maybe ValidateConnection(Guid organizationId) .Match(ValidateConnection, error => error); } - private OperationError ValidateConnection(Organization organizationId) + private Maybe ValidateConnection(Organization organization) { - //TODO: Exchange the - throw new NotImplementedException(); + return _stsOrganizationUnitService.ValidateConnection(organization); } public Result GetStsOrganizationalHierarchy(Guid organizationId, Maybe levelsToInclude) diff --git a/Core.DomainServices/Organizations/IStsOrganizationService.cs b/Core.DomainServices/Organizations/IStsOrganizationService.cs index 0d705c69a3..20dbfc3372 100644 --- a/Core.DomainServices/Organizations/IStsOrganizationService.cs +++ b/Core.DomainServices/Organizations/IStsOrganizationService.cs @@ -7,6 +7,7 @@ namespace Core.DomainServices.Organizations { public interface IStsOrganizationService { + Maybe ValidateConnection(Organization organization); Result> ResolveStsOrganizationUuid(Organization organization); } } diff --git a/Core.DomainServices/Organizations/IStsOrganizationUnitService.cs b/Core.DomainServices/Organizations/IStsOrganizationUnitService.cs index 78e320f582..17c5a3f7f3 100644 --- a/Core.DomainServices/Organizations/IStsOrganizationUnitService.cs +++ b/Core.DomainServices/Organizations/IStsOrganizationUnitService.cs @@ -7,5 +7,6 @@ namespace Core.DomainServices.Organizations public interface IStsOrganizationUnitService { Result> ResolveOrganizationTree(Organization organization); + Maybe ValidateConnection(Organization organization); } } diff --git a/Infrastructure.STS.Company/DomainServices/StsOrganizationCompanyLookupService.cs b/Infrastructure.STS.Company/DomainServices/StsOrganizationCompanyLookupService.cs index 7dbc92e70c..ace97792de 100644 --- a/Infrastructure.STS.Company/DomainServices/StsOrganizationCompanyLookupService.cs +++ b/Infrastructure.STS.Company/DomainServices/StsOrganizationCompanyLookupService.cs @@ -23,6 +23,7 @@ public StsOrganizationCompanyLookupService(StsOrganisationIntegrationConfigurati _serviceRoot = $"https://{configuration.EndpointHost}/service/Organisation/Virksomhed/5"; } + //TODO: More detailed response - we need the info for the validation endpoint! public Result ResolveStsOrganizationCompanyUuid(Organization organization) { if (organization == null) @@ -37,7 +38,8 @@ public Result ResolveStsOrganizationCompanyUuid(Organizati var response = channel.soeg(request); var statusResult = response.SoegResponse1.SoegOutput.StandardRetur; - var stsError = statusResult.StatusKode.ParseStsError(); + //TODO: Extend with service agreement related - test by calling into places we dont have an agreement: https://www.serviceplatformen.dk/administration/errorcodes-doc/errorcodes/4afb35be-7b7a-45b3-ab01-bd5017a8b182_errorcodes.html + var stsError = statusResult.StatusKode.ParseStsError(); if (stsError.HasValue) { return new OperationError($"Error resolving the organization company from STS:{statusResult.StatusKode}:{statusResult.FejlbeskedTekst}", OperationFailure.UnknownError); diff --git a/Infrastructure.STS.Organization/DomainServices/StsOrganizationService.cs b/Infrastructure.STS.Organization/DomainServices/StsOrganizationService.cs index eee0b7998f..773a190ace 100644 --- a/Infrastructure.STS.Organization/DomainServices/StsOrganizationService.cs +++ b/Infrastructure.STS.Organization/DomainServices/StsOrganizationService.cs @@ -22,7 +22,7 @@ public class StsOrganizationService : IStsOrganizationService private readonly ILogger _logger; private readonly string _certificateThumbprint; private readonly string _serviceRoot; - + public StsOrganizationService( StsOrganisationIntegrationConfiguration configuration, IStsOrganizationCompanyLookupService companyLookupService, @@ -36,6 +36,12 @@ public StsOrganizationService( _serviceRoot = $"https://{configuration.EndpointHost}/service/Organisation/Organisation/5"; } + public Maybe ValidateConnection(Core.DomainModel.Organization.Organization organization) + { + return ResolveExternalUuid(organization) + .Match(_ => Maybe.None, error => error); + } + public Result> ResolveStsOrganizationUuid(Core.DomainModel.Organization.Organization organization) { if (organization == null) @@ -50,18 +56,10 @@ public Result> Resolv return fkOrgIdentity.ExternalUuid; } - if (organization.IsCvrInvalid()) - { - return new DetailedOperationError(OperationFailure.BadState, ResolveOrganizationUuidError.InvalidCvrOnOrganization); - } + var companyUuid = ResolveExternalUuid(organization); - //Resolve the associated company uuid - var companyUuid = _companyLookupService.ResolveStsOrganizationCompanyUuid(organization); if (companyUuid.Failed) - { - _logger.Error("Error {error} while resolving company uuid for organization with id {id}", companyUuid.Error.ToString(), organization.Id); - return new DetailedOperationError(OperationFailure.UnknownError, ResolveOrganizationUuidError.FailedToLookupOrganizationCompany); - } + return companyUuid.Value; //Search for the organization based on the resolved company (all organizations are tied to a company) using var clientCertificate = X509CertificateClientCertificateFactory.GetClientCertificate(_certificateThumbprint); @@ -97,6 +95,26 @@ public Result> Resolv return uuid; } + private Result> ResolveExternalUuid(Core.DomainModel.Organization.Organization organization) + { + if (organization.IsCvrInvalid()) + { + return new DetailedOperationError(OperationFailure.BadState, ResolveOrganizationUuidError.InvalidCvrOnOrganization); + } + + //Resolve the associated company uuid + var companyUuid = _companyLookupService.ResolveStsOrganizationCompanyUuid(organization); + if (companyUuid.Failed) + { + _logger.Error("Error {error} while resolving company uuid for organization with id {id}", + companyUuid.Error.ToString(), organization.Id); + return new DetailedOperationError( + OperationFailure.UnknownError, ResolveOrganizationUuidError.FailedToLookupOrganizationCompany); + } + + return companyUuid.Value; + } + private static soegRequest CreateSearchForOrganizationRequest(Core.DomainModel.Organization.Organization organization, Guid companyUuid) { return new soegRequest diff --git a/Infrastructure.STS.OrganizationUnit/DomainServices/StsOrganizationUnitService.cs b/Infrastructure.STS.OrganizationUnit/DomainServices/StsOrganizationUnitService.cs index 6165947a6f..11c7ae1ade 100644 --- a/Infrastructure.STS.OrganizationUnit/DomainServices/StsOrganizationUnitService.cs +++ b/Infrastructure.STS.OrganizationUnit/DomainServices/StsOrganizationUnitService.cs @@ -140,6 +140,11 @@ public Result ValidateConnection(Organization organization) + { + throw new NotImplementedException(); + } + private static Stack CreateOrgUnitConversionStack((Guid, RegistreringType1) root, Dictionary> unitsByParent) { var processingStack = new Stack(); From e949eb96e1cec7a95fc57bc359697619eedd4ea2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Morten=20Remb=C3=B8l=20Jacobsen?= Date: Wed, 28 Sep 2022 10:12:33 +0200 Subject: [PATCH 003/272] added detailed errors to connection check --- .../IStsOrganizationSynchronizationService.cs | 10 +--- .../StsOrganizationSynchronizationService.cs | 6 +-- .../Core.DomainServices.csproj | 1 + .../StsOrganization/CheckConnectionError.cs | 10 ++++ .../ResolveOrganizationUuidError.cs | 4 +- .../IStsOrganizationCompanyLookupService.cs | 3 +- .../Organizations/IStsOrganizationService.cs | 2 +- .../IStsOrganizationUnitService.cs | 2 +- .../SSO/StsBrugerInfoService.cs | 6 +-- Infrastructure.STS.Common/Model/StsError.cs | 2 + .../Model/StsErrorParser.cs | 23 +++++++- .../StsOrganizationCompanyLookupService.cs | 52 +++++++++++++------ .../Infrastructure.STS.Company.csproj | 4 ++ Infrastructure.STS.Company/packages.config | 4 ++ .../DomainServices/StsOrganizationService.cs | 34 ++++++++++-- .../StsOrganizationUnitService.cs | 12 +++-- ...tsOrganizationSynchronizationController.cs | 14 +++++ .../CheckStsOrganizationConnectionResponse.cs | 16 ++++++ Presentation.Web/Presentation.Web.csproj | 1 + 19 files changed, 162 insertions(+), 44 deletions(-) create mode 100644 Core.DomainServices/Model/StsOrganization/CheckConnectionError.cs create mode 100644 Infrastructure.STS.Company/packages.config create mode 100644 Presentation.Web/Models/API/V1/Organizations/CheckStsOrganizationConnectionResponse.cs diff --git a/Core.ApplicationServices/Organizations/IStsOrganizationSynchronizationService.cs b/Core.ApplicationServices/Organizations/IStsOrganizationSynchronizationService.cs index a5fe64c14a..6c9ee5e332 100644 --- a/Core.ApplicationServices/Organizations/IStsOrganizationSynchronizationService.cs +++ b/Core.ApplicationServices/Organizations/IStsOrganizationSynchronizationService.cs @@ -6,16 +6,10 @@ namespace Core.ApplicationServices.Organizations { public interface IStsOrganizationSynchronizationService { - //TODO: More detailed error /// - /// TODO: Description + /// Validates if KITOS can read organization data from STS Organisation /// - /// - /// - /// - /// - /// - Maybe ValidateConnection(Guid organizationId); + Maybe> ValidateConnection(Guid organizationId); /// /// Retrieves a view of the organization as it exists in STS Organization /// diff --git a/Core.ApplicationServices/Organizations/StsOrganizationSynchronizationService.cs b/Core.ApplicationServices/Organizations/StsOrganizationSynchronizationService.cs index 2ac3a87718..63df5e467d 100644 --- a/Core.ApplicationServices/Organizations/StsOrganizationSynchronizationService.cs +++ b/Core.ApplicationServices/Organizations/StsOrganizationSynchronizationService.cs @@ -28,13 +28,13 @@ public StsOrganizationSynchronizationService( _authorizationContext = authorizationContext; } - public Maybe ValidateConnection(Guid organizationId) + public Maybe> ValidateConnection(Guid organizationId) { return GetOrganizationWithImportPermission(organizationId) - .Match(ValidateConnection, error => error); + .Match(ValidateConnection, error => new DetailedOperationError(error.FailureType, CheckConnectionError.Unknown, error.Message.GetValueOrDefault())); } - private Maybe ValidateConnection(Organization organization) + private Maybe> ValidateConnection(Organization organization) { return _stsOrganizationUnitService.ValidateConnection(organization); } diff --git a/Core.DomainServices/Core.DomainServices.csproj b/Core.DomainServices/Core.DomainServices.csproj index ce9a997d10..74dac4a455 100644 --- a/Core.DomainServices/Core.DomainServices.csproj +++ b/Core.DomainServices/Core.DomainServices.csproj @@ -90,6 +90,7 @@ + diff --git a/Core.DomainServices/Model/StsOrganization/CheckConnectionError.cs b/Core.DomainServices/Model/StsOrganization/CheckConnectionError.cs new file mode 100644 index 0000000000..568253301b --- /dev/null +++ b/Core.DomainServices/Model/StsOrganization/CheckConnectionError.cs @@ -0,0 +1,10 @@ +namespace Core.DomainServices.Model.StsOrganization +{ + public enum CheckConnectionError + { + InvalidCvrOnOrganization, + MissingServiceAgreement, + ExistingServiceAgreementIssue, + Unknown + } +} diff --git a/Core.DomainServices/Model/StsOrganization/ResolveOrganizationUuidError.cs b/Core.DomainServices/Model/StsOrganization/ResolveOrganizationUuidError.cs index 6ba86f118f..2252c56de7 100644 --- a/Core.DomainServices/Model/StsOrganization/ResolveOrganizationUuidError.cs +++ b/Core.DomainServices/Model/StsOrganization/ResolveOrganizationUuidError.cs @@ -6,6 +6,8 @@ public enum ResolveOrganizationUuidError FailedToLookupOrganizationCompany, FailedToSearchForOrganizationByCompanyUuid, DuplicateOrganizationResults, - FailedToSaveUuidOnKitosOrganization + FailedToSaveUuidOnKitosOrganization, + MissingServiceAgreement, + ExistingServiceAgreementIssue } } diff --git a/Core.DomainServices/Organizations/IStsOrganizationCompanyLookupService.cs b/Core.DomainServices/Organizations/IStsOrganizationCompanyLookupService.cs index 4e7f476e33..6e049132fc 100644 --- a/Core.DomainServices/Organizations/IStsOrganizationCompanyLookupService.cs +++ b/Core.DomainServices/Organizations/IStsOrganizationCompanyLookupService.cs @@ -1,11 +1,12 @@ using System; using Core.Abstractions.Types; using Core.DomainModel.Organization; +using Infrastructure.STS.Common.Model; namespace Core.DomainServices.Organizations { public interface IStsOrganizationCompanyLookupService { - Result ResolveStsOrganizationCompanyUuid(Organization organization); + Result> ResolveStsOrganizationCompanyUuid(Organization organization); } } diff --git a/Core.DomainServices/Organizations/IStsOrganizationService.cs b/Core.DomainServices/Organizations/IStsOrganizationService.cs index 20dbfc3372..3b4c87e135 100644 --- a/Core.DomainServices/Organizations/IStsOrganizationService.cs +++ b/Core.DomainServices/Organizations/IStsOrganizationService.cs @@ -7,7 +7,7 @@ namespace Core.DomainServices.Organizations { public interface IStsOrganizationService { - Maybe ValidateConnection(Organization organization); + Maybe> ValidateConnection(Organization organization); Result> ResolveStsOrganizationUuid(Organization organization); } } diff --git a/Core.DomainServices/Organizations/IStsOrganizationUnitService.cs b/Core.DomainServices/Organizations/IStsOrganizationUnitService.cs index 17c5a3f7f3..531fca7966 100644 --- a/Core.DomainServices/Organizations/IStsOrganizationUnitService.cs +++ b/Core.DomainServices/Organizations/IStsOrganizationUnitService.cs @@ -7,6 +7,6 @@ namespace Core.DomainServices.Organizations public interface IStsOrganizationUnitService { Result> ResolveOrganizationTree(Organization organization); - Maybe ValidateConnection(Organization organization); + Maybe> ValidateConnection(Organization organization); } } diff --git a/Core.DomainServices/SSO/StsBrugerInfoService.cs b/Core.DomainServices/SSO/StsBrugerInfoService.cs index 16146f3b29..63f4fccfcd 100644 --- a/Core.DomainServices/SSO/StsBrugerInfoService.cs +++ b/Core.DomainServices/SSO/StsBrugerInfoService.cs @@ -78,7 +78,7 @@ public Maybe GetStsBrugerInfo(Guid uuid, string cvrNumber) var stdOutput = laesResponseResult.LaesResponse1?.LaesOutput?.StandardRetur; var returnCode = stdOutput?.StatusKode ?? "unknown"; var errorCode = stdOutput?.FejlbeskedTekst ?? string.Empty; - var stsError = stdOutput?.StatusKode.ParseStsError() ?? Maybe.None; + var stsError = stdOutput?.StatusKode.ParseStsErrorFromStandardResultCode() ?? Maybe.None; if (stsError.Select(error => error == StsError.NotFound).GetValueOrDefault()) return $"Requested user '{uuid}' from cvr '{cvrNumber}' was not found. STS Bruger endpoint returned '{returnCode}:{errorCode}'"; @@ -179,7 +179,7 @@ private Result, string> GetStsAdresseEmailFromUuid(string em var stdOutput = laesResponse.LaesResponse1?.LaesOutput?.StandardRetur; var returnCode = stdOutput?.StatusKode ?? "unknown"; var errorCode = stdOutput?.FejlbeskedTekst ?? string.Empty; - var stsError = stdOutput?.StatusKode.ParseStsError() ?? Maybe.None; + var stsError = stdOutput?.StatusKode.ParseStsErrorFromStandardResultCode() ?? Maybe.None; if (stsError.Select(error => error == StsError.NotFound).GetValueOrDefault()) return $"Requested email address '{emailAdresseUuid}' from cvr '{cvrNumber}' was not found. STS Adresse endpoint returned '{returnCode}:{errorCode}'"; @@ -237,7 +237,7 @@ private Result GetStsPersonFromUuid(string personUuid, st var returnCode = stdOutput?.StatusKode ?? "unknown"; var errorCode = stdOutput?.FejlbeskedTekst ?? string.Empty; - var stsError = stdOutput?.StatusKode.ParseStsError() ?? Maybe.None; + var stsError = stdOutput?.StatusKode.ParseStsErrorFromStandardResultCode() ?? Maybe.None; if (stsError.Select(error => error == StsError.NotFound).GetValueOrDefault()) return $"Requested person '{personUuid}' from cvr '{cvrNumber}' was not found. STS Person endpoint returned '{returnCode}:{errorCode}'"; diff --git a/Infrastructure.STS.Common/Model/StsError.cs b/Infrastructure.STS.Common/Model/StsError.cs index 1ffd86e2bc..5ae5403ac0 100644 --- a/Infrastructure.STS.Common/Model/StsError.cs +++ b/Infrastructure.STS.Common/Model/StsError.cs @@ -4,6 +4,8 @@ public enum StsError { NotFound, BadInput, + MissingServiceAgreement, + ExistingServiceAgreementIssue, Unknown } } diff --git a/Infrastructure.STS.Common/Model/StsErrorParser.cs b/Infrastructure.STS.Common/Model/StsErrorParser.cs index b01380d06e..8983909e86 100644 --- a/Infrastructure.STS.Common/Model/StsErrorParser.cs +++ b/Infrastructure.STS.Common/Model/StsErrorParser.cs @@ -1,4 +1,5 @@ -using System.Collections.Generic; +using System; +using System.Collections.Generic; using Core.Abstractions.Types; namespace Infrastructure.STS.Common.Model @@ -10,7 +11,7 @@ public static class StsErrorParser { "44", StsError.NotFound }, { "40", StsError.BadInput } }; - public static Maybe ParseStsError(this string resultCode) + public static Maybe ParseStsErrorFromStandardResultCode(this string resultCode) { if (resultCode == "20") { @@ -19,5 +20,23 @@ public static Maybe ParseStsError(this string resultCode) return KnownErrors.TryGetValue(resultCode, out var knownError) ? knownError : StsError.Unknown; } + + public static Maybe ParseStsFromErrorCode(this string errorCode) + { + if (errorCode != null) + { + if (errorCode.Equals("ServiceAgreementNotFound", StringComparison.OrdinalIgnoreCase)) + { + return StsError.MissingServiceAgreement; + } + if (errorCode.Contains("ServiceAgreement")) + { + //Covers a lot of different erros related to the service agreement: https://www.serviceplatformen.dk/administration/errorcodes-doc/errorcodes/4afb35be-7b7a-45b3-ab01-bd5017a8b182_errorcodes.html + return StsError.ExistingServiceAgreementIssue; + } + } + + return StsError.Unknown; + } } } diff --git a/Infrastructure.STS.Company/DomainServices/StsOrganizationCompanyLookupService.cs b/Infrastructure.STS.Company/DomainServices/StsOrganizationCompanyLookupService.cs index ace97792de..2f9fe82c88 100644 --- a/Infrastructure.STS.Company/DomainServices/StsOrganizationCompanyLookupService.cs +++ b/Infrastructure.STS.Company/DomainServices/StsOrganizationCompanyLookupService.cs @@ -9,22 +9,24 @@ using Infrastructure.STS.Common.Factories; using Infrastructure.STS.Common.Model; using Infrastructure.STS.Company.ServiceReference; +using Serilog; namespace Infrastructure.STS.Company.DomainServices { public class StsOrganizationCompanyLookupService : IStsOrganizationCompanyLookupService { + private readonly ILogger _logger; private readonly string _certificateThumbprint; private readonly string _serviceRoot; - public StsOrganizationCompanyLookupService(StsOrganisationIntegrationConfiguration configuration) + public StsOrganizationCompanyLookupService(StsOrganisationIntegrationConfiguration configuration, ILogger logger) { + _logger = logger; _certificateThumbprint = configuration.CertificateThumbprint; _serviceRoot = $"https://{configuration.EndpointHost}/service/Organisation/Virksomhed/5"; } - //TODO: More detailed response - we need the info for the validation endpoint! - public Result ResolveStsOrganizationCompanyUuid(Organization organization) + public Result> ResolveStsOrganizationCompanyUuid(Organization organization) { if (organization == null) { @@ -35,23 +37,43 @@ public Result ResolveStsOrganizationCompanyUuid(Organizati var channel = organizationPortTypeClient.ChannelFactory.CreateChannel(); var request = CreateSearchByCvrRequest(organization); - var response = channel.soeg(request); - var statusResult = response.SoegResponse1.SoegOutput.StandardRetur; - //TODO: Extend with service agreement related - test by calling into places we dont have an agreement: https://www.serviceplatformen.dk/administration/errorcodes-doc/errorcodes/4afb35be-7b7a-45b3-ab01-bd5017a8b182_errorcodes.html - var stsError = statusResult.StatusKode.ParseStsError(); - if (stsError.HasValue) + try { - return new OperationError($"Error resolving the organization company from STS:{statusResult.StatusKode}:{statusResult.FejlbeskedTekst}", OperationFailure.UnknownError); + var response = channel.soeg(request); + + var statusResult = response.SoegResponse1.SoegOutput.StandardRetur; + var stsError = statusResult.StatusKode.ParseStsErrorFromStandardResultCode(); + if (stsError.HasValue) + { + return new DetailedOperationError(OperationFailure.UnknownError, stsError.Value, $"Error resolving the organization company from STS:{statusResult.StatusKode}:{statusResult.FejlbeskedTekst}"); + } + + var ids = response.SoegResponse1.SoegOutput.IdListe; + if (ids.Length != 1) + { + return new DetailedOperationError(OperationFailure.UnknownError, StsError.Unknown, $"Error resolving the organization company from STS. Expected a single UUID but got:{string.Join(",", ids)}"); + } + + return new Guid(ids.Single()); } + catch (FaultException spFault) + { + var knownStsError = spFault.Detail.ErrorList.Select(error => error.ErrorCode.ParseStsFromErrorCode()).FirstOrDefault(x => x.HasValue); + var stsError = knownStsError.GetValueOrFallback(StsError.Unknown); + var operationFailure = + stsError is StsError.MissingServiceAgreement or StsError.ExistingServiceAgreementIssue + ? OperationFailure.Forbidden + : OperationFailure.UnknownError; - var ids = response.SoegResponse1.SoegOutput.IdListe; - if (ids.Length != 1) + _logger.Error(spFault, "Service platform exception while finding company uuid from cvr {cvr} for organization with id {organizationId}", organization.Cvr, organization.Id); + return new DetailedOperationError(operationFailure, stsError, $"STS Organisation threw and exception while searching for uuid by cvr:{organization.Cvr} for organization with id:{organization.Id}"); + } + catch (Exception e) { - return new OperationError($"Error resolving the organization company from STS. Expected a single UUID but got:{string.Join(",", ids)}", OperationFailure.UnknownError); + _logger.Error(e, "Unknown Exception while finding company uuid from cvr {cvr} for organization with id {organizationId}", organization.Cvr, organization.Id); + return new DetailedOperationError(OperationFailure.UnknownError, StsError.Unknown, $"STS Organisation threw and unknown exception while searching for uuid by cvr:{organization.Cvr} for organization with id:{organization.Id}"); } - - return new Guid(ids.Single()); } private static soegRequest CreateSearchByCvrRequest(Organization organization) @@ -64,7 +86,7 @@ private static soegRequest CreateSearchByCvrRequest(Organization organization) { MunicipalityCVR = organization.Cvr }, - SoegInput = new SoegInputType1() + SoegInput = new SoegInputType1 { RelationListe = new RelationListeType(), FoersteResultatReference = "0", diff --git a/Infrastructure.STS.Company/Infrastructure.STS.Company.csproj b/Infrastructure.STS.Company/Infrastructure.STS.Company.csproj index 4fb2ba0d04..b23f065c72 100644 --- a/Infrastructure.STS.Company/Infrastructure.STS.Company.csproj +++ b/Infrastructure.STS.Company/Infrastructure.STS.Company.csproj @@ -32,6 +32,9 @@ 4 + + ..\packages\Serilog.2.11.0\lib\net46\Serilog.dll + @@ -138,6 +141,7 @@ Designer + diff --git a/Infrastructure.STS.Company/packages.config b/Infrastructure.STS.Company/packages.config new file mode 100644 index 0000000000..22e0304f77 --- /dev/null +++ b/Infrastructure.STS.Company/packages.config @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/Infrastructure.STS.Organization/DomainServices/StsOrganizationService.cs b/Infrastructure.STS.Organization/DomainServices/StsOrganizationService.cs index 773a190ace..1ad1582b75 100644 --- a/Infrastructure.STS.Organization/DomainServices/StsOrganizationService.cs +++ b/Infrastructure.STS.Organization/DomainServices/StsOrganizationService.cs @@ -36,10 +36,20 @@ public StsOrganizationService( _serviceRoot = $"https://{configuration.EndpointHost}/service/Organisation/Organisation/5"; } - public Maybe ValidateConnection(Core.DomainModel.Organization.Organization organization) + public Maybe> ValidateConnection(Core.DomainModel.Organization.Organization organization) { return ResolveExternalUuid(organization) - .Match(_ => Maybe.None, error => error); + .Match(_ => Maybe>.None, error => + { + var connectionError = error.Detail switch + { + ResolveOrganizationUuidError.InvalidCvrOnOrganization => CheckConnectionError.InvalidCvrOnOrganization, + ResolveOrganizationUuidError.MissingServiceAgreement => CheckConnectionError.MissingServiceAgreement, + ResolveOrganizationUuidError.ExistingServiceAgreementIssue => CheckConnectionError.ExistingServiceAgreementIssue, + _ => CheckConnectionError.Unknown + }; + return new DetailedOperationError(error.FailureType, connectionError, error.Message.GetValueOrFallback(string.Empty)); + }); } public Result> ResolveStsOrganizationUuid(Core.DomainModel.Organization.Organization organization) @@ -69,7 +79,7 @@ public Result> Resolv var channel = organizationPortTypeClient.ChannelFactory.CreateChannel(); var response = channel.soeg(searchRequest); var statusResult = response.SoegResponse1.SoegOutput.StandardRetur; - var stsError = statusResult.StatusKode.ParseStsError(); + var stsError = statusResult.StatusKode.ParseStsErrorFromStandardResultCode(); if (stsError.HasValue) { _logger.Error("Failed to search for organization ({id}) by company uuid {uuid}. Failed with {stsError} {code} and {message}", organization.Id, companyUuid.Value, stsError.Value, statusResult.StatusKode, statusResult.FejlbeskedTekst); @@ -108,8 +118,22 @@ private Result> Resol { _logger.Error("Error {error} while resolving company uuid for organization with id {id}", companyUuid.Error.ToString(), organization.Id); - return new DetailedOperationError( - OperationFailure.UnknownError, ResolveOrganizationUuidError.FailedToLookupOrganizationCompany); + + var detailedError = companyUuid.Error.Detail switch + { + StsError.MissingServiceAgreement => ResolveOrganizationUuidError.MissingServiceAgreement, + StsError.ExistingServiceAgreementIssue => ResolveOrganizationUuidError.ExistingServiceAgreementIssue, + _ => ResolveOrganizationUuidError.FailedToLookupOrganizationCompany + }; + + var operationFailure = companyUuid.Error.Detail switch + { + StsError.MissingServiceAgreement => companyUuid.Error.FailureType, + StsError.ExistingServiceAgreementIssue => companyUuid.Error.FailureType, + _ => OperationFailure.UnknownError + }; + + return new DetailedOperationError(operationFailure, detailedError); } return companyUuid.Value; diff --git a/Infrastructure.STS.OrganizationUnit/DomainServices/StsOrganizationUnitService.cs b/Infrastructure.STS.OrganizationUnit/DomainServices/StsOrganizationUnitService.cs index 11c7ae1ade..83eb0cd82c 100644 --- a/Infrastructure.STS.OrganizationUnit/DomainServices/StsOrganizationUnitService.cs +++ b/Infrastructure.STS.OrganizationUnit/DomainServices/StsOrganizationUnitService.cs @@ -59,7 +59,7 @@ public Result ValidateConnection(Organization organization) + public Maybe> ValidateConnection(Organization organization) { - throw new NotImplementedException(); + if (organization == null) + { + throw new ArgumentNullException(nameof(organization)); + } + return _organizationService.ValidateConnection(organization); } private static Stack CreateOrgUnitConversionStack((Guid, RegistreringType1) root, Dictionary> unitsByParent) diff --git a/Presentation.Web/Controllers/API/V1/StsOrganizationSynchronizationController.cs b/Presentation.Web/Controllers/API/V1/StsOrganizationSynchronizationController.cs index 0b9a009cad..08a3ebd2b9 100644 --- a/Presentation.Web/Controllers/API/V1/StsOrganizationSynchronizationController.cs +++ b/Presentation.Web/Controllers/API/V1/StsOrganizationSynchronizationController.cs @@ -31,6 +31,20 @@ public HttpResponseMessage GetSnapshotFromStsOrganization(Guid organizationId, u .Match(Ok, FromOperationError); } + [HttpGet] + [Route("connection-status")] + public HttpResponseMessage GetConnectionStatus(Guid organizationId) + { + return _stsOrganizationSynchronizationService + .ValidateConnection(organizationId) + .Match + ( + error => Ok(new CheckStsOrganizationConnectionResponse(false, error.Detail)), + () => Ok(new CheckStsOrganizationConnectionResponse(true)) + ); + + } + private static StsOrganizationOrgUnitDTO MapOrganizationUnitDTO(StsOrganizationUnit organizationUnit) { return new StsOrganizationOrgUnitDTO() diff --git a/Presentation.Web/Models/API/V1/Organizations/CheckStsOrganizationConnectionResponse.cs b/Presentation.Web/Models/API/V1/Organizations/CheckStsOrganizationConnectionResponse.cs new file mode 100644 index 0000000000..44d4e14e01 --- /dev/null +++ b/Presentation.Web/Models/API/V1/Organizations/CheckStsOrganizationConnectionResponse.cs @@ -0,0 +1,16 @@ +using Core.DomainServices.Model.StsOrganization; + +namespace Presentation.Web.Models.API.V1.Organizations +{ + public class CheckStsOrganizationConnectionResponse + { + public bool Connected { get; } + public CheckConnectionError? Error { get; } + + public CheckStsOrganizationConnectionResponse(bool connected, CheckConnectionError? connectionErrors = null) + { + Connected = connected; + Error = connectionErrors; + } + } +} \ No newline at end of file diff --git a/Presentation.Web/Presentation.Web.csproj b/Presentation.Web/Presentation.Web.csproj index cae514f94f..b2ca1da0e1 100644 --- a/Presentation.Web/Presentation.Web.csproj +++ b/Presentation.Web/Presentation.Web.csproj @@ -396,6 +396,7 @@ + From 0193fc1b674b10a43c3497579f2ef11d55847bb0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Morten=20Remb=C3=B8l=20Jacobsen?= Date: Wed, 28 Sep 2022 10:54:24 +0200 Subject: [PATCH 004/272] added integration test for checkconnectionstatus fixed cvr check when performing lookup of organization id --- .../DomainServices/StsOrganizationService.cs | 2 +- ...tsOrganizationSynchronizationController.cs | 11 +++- .../CheckStsOrganizationConnectionResponse.cs | 16 ----- ...eckStsOrganizationConnectionResponseDTO.cs | 10 +++ Presentation.Web/Presentation.Web.csproj | 2 +- .../StsOrganizationSynchronizationApiTest.cs | 61 +++++++++++++++---- 6 files changed, 69 insertions(+), 33 deletions(-) delete mode 100644 Presentation.Web/Models/API/V1/Organizations/CheckStsOrganizationConnectionResponse.cs create mode 100644 Presentation.Web/Models/API/V1/Organizations/CheckStsOrganizationConnectionResponseDTO.cs diff --git a/Infrastructure.STS.Organization/DomainServices/StsOrganizationService.cs b/Infrastructure.STS.Organization/DomainServices/StsOrganizationService.cs index 1ad1582b75..3373146e79 100644 --- a/Infrastructure.STS.Organization/DomainServices/StsOrganizationService.cs +++ b/Infrastructure.STS.Organization/DomainServices/StsOrganizationService.cs @@ -107,7 +107,7 @@ public Result> Resolv private Result> ResolveExternalUuid(Core.DomainModel.Organization.Organization organization) { - if (organization.IsCvrInvalid()) + if (organization.Cvr == null || organization.IsCvrInvalid()) { return new DetailedOperationError(OperationFailure.BadState, ResolveOrganizationUuidError.InvalidCvrOnOrganization); } diff --git a/Presentation.Web/Controllers/API/V1/StsOrganizationSynchronizationController.cs b/Presentation.Web/Controllers/API/V1/StsOrganizationSynchronizationController.cs index 08a3ebd2b9..43c823bc49 100644 --- a/Presentation.Web/Controllers/API/V1/StsOrganizationSynchronizationController.cs +++ b/Presentation.Web/Controllers/API/V1/StsOrganizationSynchronizationController.cs @@ -39,8 +39,15 @@ public HttpResponseMessage GetConnectionStatus(Guid organizationId) .ValidateConnection(organizationId) .Match ( - error => Ok(new CheckStsOrganizationConnectionResponse(false, error.Detail)), - () => Ok(new CheckStsOrganizationConnectionResponse(true)) + error => Ok(new CheckStsOrganizationConnectionResponseDTO + { + Error = error.Detail, + Connected = false + }), + () => Ok(new CheckStsOrganizationConnectionResponseDTO() + { + Connected = true + }) ); } diff --git a/Presentation.Web/Models/API/V1/Organizations/CheckStsOrganizationConnectionResponse.cs b/Presentation.Web/Models/API/V1/Organizations/CheckStsOrganizationConnectionResponse.cs deleted file mode 100644 index 44d4e14e01..0000000000 --- a/Presentation.Web/Models/API/V1/Organizations/CheckStsOrganizationConnectionResponse.cs +++ /dev/null @@ -1,16 +0,0 @@ -using Core.DomainServices.Model.StsOrganization; - -namespace Presentation.Web.Models.API.V1.Organizations -{ - public class CheckStsOrganizationConnectionResponse - { - public bool Connected { get; } - public CheckConnectionError? Error { get; } - - public CheckStsOrganizationConnectionResponse(bool connected, CheckConnectionError? connectionErrors = null) - { - Connected = connected; - Error = connectionErrors; - } - } -} \ No newline at end of file diff --git a/Presentation.Web/Models/API/V1/Organizations/CheckStsOrganizationConnectionResponseDTO.cs b/Presentation.Web/Models/API/V1/Organizations/CheckStsOrganizationConnectionResponseDTO.cs new file mode 100644 index 0000000000..8ad9163782 --- /dev/null +++ b/Presentation.Web/Models/API/V1/Organizations/CheckStsOrganizationConnectionResponseDTO.cs @@ -0,0 +1,10 @@ +using Core.DomainServices.Model.StsOrganization; + +namespace Presentation.Web.Models.API.V1.Organizations +{ + public class CheckStsOrganizationConnectionResponseDTO + { + public bool Connected { get; set; } + public CheckConnectionError? Error { get; set; } + } +} \ No newline at end of file diff --git a/Presentation.Web/Presentation.Web.csproj b/Presentation.Web/Presentation.Web.csproj index b2ca1da0e1..e83c3d75bc 100644 --- a/Presentation.Web/Presentation.Web.csproj +++ b/Presentation.Web/Presentation.Web.csproj @@ -396,7 +396,7 @@ - + diff --git a/Tests.Integration.Presentation.Web/Organizations/StsOrganizationSynchronizationApiTest.cs b/Tests.Integration.Presentation.Web/Organizations/StsOrganizationSynchronizationApiTest.cs index 4d1d417131..f2e6985b63 100644 --- a/Tests.Integration.Presentation.Web/Organizations/StsOrganizationSynchronizationApiTest.cs +++ b/Tests.Integration.Presentation.Web/Organizations/StsOrganizationSynchronizationApiTest.cs @@ -3,19 +3,25 @@ using System.Linq; using System.Net; using System.Threading.Tasks; +using Core.ApplicationServices.Extensions; using Core.DomainModel; using Core.DomainModel.Organization; +using Core.DomainServices.Model.StsOrganization; +using Presentation.Web.Models.API.V1; using Presentation.Web.Models.API.V1.Organizations; using Tests.Integration.Presentation.Web.Tools; using Tests.Integration.Presentation.Web.Tools.External; +using Tests.Integration.Presentation.Web.Tools.XUnit; using Tests.Toolkit.Patterns; using Xunit; namespace Tests.Integration.Presentation.Web.Organizations { + [Collection(nameof(SequentialTestGroup))] public class StsOrganizationSynchronizationApiTest : WithAutoFixture { - private const string AuthorizedCvr = "58271713"; //This one is Ballerup and we have a service agreement in both local and integration for that so that's why it is used for test + private const string UnAuthorizedCvr = "55133018"; //This one is Aarhus and we don't have a service agreement with them in STS Test environment + private const string AuthorizedCvr = "58271713"; //This one is Ballerup and we have a service agreement with them in STS Test environment [Theory] [InlineData(1)] @@ -25,29 +31,58 @@ public async Task Can_GET_Organization_Snapshot_With_Filtered_Depth(uint levels) //Arrange var token = await HttpApi.GetTokenAsync(OrganizationRole.GlobalAdmin); var cookie = await HttpApi.GetCookieAsync(OrganizationRole.GlobalAdmin); - Guid targetOrgUuid = Guid.Empty; + var targetOrgUuid = await GetOrCreateOrgWithCvr(token, AuthorizedCvr); + var url = TestEnvironment.CreateUrl($"api/v1/organizations/{targetOrgUuid:D}/sts-organization-synchronization/snapshot?levels={levels}"); + + //Act + using var response = await HttpApi.GetWithCookieAsync(url, cookie); + + //Assert + Assert.Equal(HttpStatusCode.OK, response.StatusCode); + var root = await response.ReadResponseBodyAsKitosApiResponseAsync(); + Assert.Equal(levels, CountMaxLevels(root)); + AssertOrgTree(root, new HashSet()); + } + + [Theory] + [InlineData(UnAuthorizedCvr, false, CheckConnectionError.MissingServiceAgreement)] + [InlineData(null, false, CheckConnectionError.InvalidCvrOnOrganization)] + [InlineData(AuthorizedCvr, true, null)] + public async Task Can_GET_ConnectionStatus(string cvr, bool expectConnected, CheckConnectionError? expectedError) + { + //Arrange + var token = await HttpApi.GetTokenAsync(OrganizationRole.GlobalAdmin); + var cookie = await HttpApi.GetCookieAsync(OrganizationRole.GlobalAdmin); + var targetOrgUuid = await GetOrCreateOrgWithCvr(token, cvr); + var url = TestEnvironment.CreateUrl($"api/v1/organizations/{targetOrgUuid:D}/sts-organization-synchronization/connection-status"); + //Act + using var response = await HttpApi.GetWithCookieAsync(url, cookie); + + //Assert + Assert.Equal(HttpStatusCode.OK, response.StatusCode); + var root = await response.ReadResponseBodyAsKitosApiResponseAsync(); + Assert.Equal(expectConnected, root.Connected); + Assert.Equal(expectedError, root.Error); + } + + private async Task GetOrCreateOrgWithCvr(GetTokenResponseDTO token, string cvr) + { + Guid targetOrgUuid; //Check if we already have the authorized org before we test snapshot (so we dont have to create a new org) - var orgWithCorrectCvr = (await OrganizationV2Helper.GetOrganizationsAsync(token.Token, cvrContent: AuthorizedCvr)).FirstOrDefault(); + var orgWithCorrectCvr = (await OrganizationV2Helper.GetOrganizationsAsync(token.Token, cvrContent: cvr)) + .FirstOrDefault(); if (orgWithCorrectCvr != null) { targetOrgUuid = orgWithCorrectCvr.Uuid; } else { - var org = await OrganizationHelper.CreateOrganizationAsync(TestEnvironment.DefaultOrganizationId, $"StsSync_{A():N}", AuthorizedCvr, OrganizationTypeKeys.Kommune, AccessModifier.Public); + var org = await OrganizationHelper.CreateOrganizationAsync(TestEnvironment.DefaultOrganizationId, $"StsSync_{A():N}", cvr, OrganizationTypeKeys.Kommune, AccessModifier.Public); targetOrgUuid = org.Uuid; } - var url = TestEnvironment.CreateUrl($"api/v1/organizations/{targetOrgUuid:D}/sts-organization-synchronization/snapshot?levels={levels}"); - - //Act - using var response = await HttpApi.GetWithCookieAsync(url, cookie); - //Assert - Assert.Equal(HttpStatusCode.OK, response.StatusCode); - var root = await response.ReadResponseBodyAsKitosApiResponseAsync(); - Assert.Equal(levels, CountMaxLevels(root)); - AssertOrgTree(root,new HashSet()); + return targetOrgUuid; } private static void AssertOrgTree(StsOrganizationOrgUnitDTO unit, HashSet seenUuids) From 4bef4754e41ec61c22fd392ce1e668c87b81afed Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Morten=20Remb=C3=B8l=20Jacobsen?= Date: Thu, 29 Sep 2022 08:39:33 +0200 Subject: [PATCH 005/272] added component to deal with fk org status and service to provide info --- .../StsOrganization/CheckConnectionError.cs | 8 +- Presentation.Web/Content/less/kitos.less | 4 + Presentation.Web/Presentation.Web.csproj | 5 ++ ...fk-organization-import-config.component.ts | 64 ++++++++++++++ .../fk-organization-import-config.view.html | 11 +++ .../local-config-import-org.controller.ts | 7 +- .../local-config-import-template.view.html | 84 +++++++++++-------- .../organization/check-connectoin-error.ts | 8 ++ ...ts-organization-connection-response-dto.ts | 6 ++ .../services/sts-organization-sync-service.ts | 35 ++++++++ Presentation.Web/app/services/userServices.ts | 2 + 11 files changed, 193 insertions(+), 41 deletions(-) create mode 100644 Presentation.Web/app/components/local-config/import/fk-organization-import-config.component.ts create mode 100644 Presentation.Web/app/components/local-config/import/fk-organization-import-config.view.html create mode 100644 Presentation.Web/app/models/api/organization/check-connectoin-error.ts create mode 100644 Presentation.Web/app/models/api/organization/check-sts-organization-connection-response-dto.ts create mode 100644 Presentation.Web/app/services/sts-organization-sync-service.ts diff --git a/Core.DomainServices/Model/StsOrganization/CheckConnectionError.cs b/Core.DomainServices/Model/StsOrganization/CheckConnectionError.cs index 568253301b..079ef094b4 100644 --- a/Core.DomainServices/Model/StsOrganization/CheckConnectionError.cs +++ b/Core.DomainServices/Model/StsOrganization/CheckConnectionError.cs @@ -2,9 +2,9 @@ { public enum CheckConnectionError { - InvalidCvrOnOrganization, - MissingServiceAgreement, - ExistingServiceAgreementIssue, - Unknown + InvalidCvrOnOrganization = 0, + MissingServiceAgreement = 1, + ExistingServiceAgreementIssue = 2, + Unknown = 3 } } diff --git a/Presentation.Web/Content/less/kitos.less b/Presentation.Web/Content/less/kitos.less index 155b04d14c..293c5636c4 100644 --- a/Presentation.Web/Content/less/kitos.less +++ b/Presentation.Web/Content/less/kitos.less @@ -675,6 +675,10 @@ div.pull-outside-table { margin-top: 50px; } +.margin-top-sm { + margin-top: 25px; +} + table.table-fixed { table-layout: fixed; } diff --git a/Presentation.Web/Presentation.Web.csproj b/Presentation.Web/Presentation.Web.csproj index e83c3d75bc..edb4166460 100644 --- a/Presentation.Web/Presentation.Web.csproj +++ b/Presentation.Web/Presentation.Web.csproj @@ -356,6 +356,7 @@ + @@ -364,6 +365,8 @@ + + @@ -634,6 +637,7 @@ + @@ -867,6 +871,7 @@ + diff --git a/Presentation.Web/app/components/local-config/import/fk-organization-import-config.component.ts b/Presentation.Web/app/components/local-config/import/fk-organization-import-config.component.ts new file mode 100644 index 0000000000..2e3ba1ad88 --- /dev/null +++ b/Presentation.Web/app/components/local-config/import/fk-organization-import-config.component.ts @@ -0,0 +1,64 @@ +module Kitos.LocalAdmin.Components { + "use strict"; + + function setupComponent(): ng.IComponentOptions { + return { + bindings: { + currentOrganizationUuid: "=" + }, + controller: FkOrganizationImportController, + controllerAs: "ctrl", + templateUrl: `app/components/local-config/import/fk-organization-import-config.view.html` + }; + } + + interface IFkOrganizationImportController extends ng.IComponentController { + currentOrganizationUuid: string + } + + class FkOrganizationImportController implements IFkOrganizationImportController { + currentOrganizationUuid: string; //note set by bindings + connected: boolean | null = null; + connectionError: string | null = null; + + static $inject: string[] = ["stsOrganizationSyncService"]; + constructor(private readonly stsOrganizationSyncService: Kitos.Services.Organization.IStsOrganizationSyncService) { + } + + $onInit() { + /////////////////////////////////////////////////// + //TODO: Validate that required bindings are set // + /////////////////////////////////////////////////// + this.stsOrganizationSyncService + .getConnectionStatus(this.currentOrganizationUuid) + .then(result => { + if (result.connected) { + this.connected = true; + } else { + this.connected = false; + switch (result.error) { + case Models.Api.Organization.CheckConnectionError.ExistingServiceAgreementIssue: + this.connectionError = "Der er problemer med den eksisterende serviceaftale, der giver KITOS adgang til data fra din kommune i FK Organisatoin. Kontakt venligst den KITOS ansvarlige i din kommune for hjælp." + break; + case Models.Api.Organization.CheckConnectionError.InvalidCvrOnOrganization: + this.connectionError = "Der enten mangler eller er registreret et ugyldigt CVR nummer på din kommune i KITOS." + break; + case Models.Api.Organization.CheckConnectionError.MissingServiceAgreement: + this.connectionError = "Din organisation mangler en gyldig serviceaftale der giver KITOS adgang til data fra din kommune i FK Organisation. Kontakt venligst den KITOS ansvarlige i din kommune for hjælp." + break; + case Models.Api.Organization.CheckConnectionError.Unknown: //intended fallthrough + default: + this.connectionError = "Der skete en ukendt fejl ifm. tjek for forbindelsen til FK Organisation. Genindlæs venligst siden for at prøve igen." + break; + } + } + }, error => { + console.error(error); + this.connected = false; + this.connectionError = "Der skete en fejl ifm. tjek for forbindelsen til FK Organisation. Genindlæs venligst siden for at prøve igen." + }) + } + } + angular.module("app") + .component("fkOrgnizationImportConfig", setupComponent()); +} \ No newline at end of file diff --git a/Presentation.Web/app/components/local-config/import/fk-organization-import-config.view.html b/Presentation.Web/app/components/local-config/import/fk-organization-import-config.view.html new file mode 100644 index 0000000000..933d2a150c --- /dev/null +++ b/Presentation.Web/app/components/local-config/import/fk-organization-import-config.view.html @@ -0,0 +1,11 @@ +
+ +
+ KITOS har adgang til organisationens data via FK Organisation + KITOS har ikke adgang til organisationens data via FK Organisation +
+
+ + {{::ctrl.connectionError}} +
+
diff --git a/Presentation.Web/app/components/local-config/import/local-config-import-org.controller.ts b/Presentation.Web/app/components/local-config/import/local-config-import-org.controller.ts index d56f36a18e..1ed8f83a5a 100644 --- a/Presentation.Web/app/components/local-config/import/local-config-import-org.controller.ts +++ b/Presentation.Web/app/components/local-config/import/local-config-import-org.controller.ts @@ -10,11 +10,12 @@ ]); app.controller('local-config.import.ImportOrgCtrl', [ - '$rootScope', '$scope', '$http', 'notify', 'user', - function ($rootScope, $scope, $http, notify, user) { + '$scope', '$http', 'notify', 'user', + function ($scope, $http, notify, user) { $scope.url = 'api/excel?organizationId=' + user.currentOrganizationId + '&exportOrgUnits'; $scope.title = 'organisationsenheder'; - + $scope.showFkOrgImport = true; + $scope.currentOrganizationUuid = user.currentOrganizationUuid; //Import OrganizationUnits $scope.submit = function () { var msg = notify.addInfoMessage("Læser excel ark...", false); diff --git a/Presentation.Web/app/components/local-config/import/local-config-import-template.view.html b/Presentation.Web/app/components/local-config/import/local-config-import-template.view.html index 29488b1060..b70f810bd1 100644 --- a/Presentation.Web/app/components/local-config/import/local-config-import-template.view.html +++ b/Presentation.Web/app/components/local-config/import/local-config-import-template.view.html @@ -1,40 +1,56 @@ 
-
-
-
- Hent excel-ark til import af {{title}}. +
+
+ Via Excel
-
- - -
- - +
+
+
+
+ Hent excel-ark til import af {{title}}. +
+
+ + +
+ +
- -
-

-

- - Fejl ved import -

- Der var {{errorData.errors.length}} fejl i den uploadede fil og derfor er intet blevet importeret. Ret og prøv igen. -

-
    -
  • - Faneblad {{error.sheetName}}, celle {{error.column}}{{error.row}}: {{error.message}} -
  • -
+ +
+

+

+ + Fejl ved import +

+ Der var {{errorData.errors.length}} fejl i den uploadede fil og derfor er intet blevet importeret. Ret og prøv igen. +

+
    +
  • + Faneblad {{error.sheetName}}, celle {{error.column}}{{error.row}}: {{error.message}} +
  • +
+
+
+

+

+ + Fejl ved import +

+ Der skete en uforudset fejl i forbindelse med importen. Intet er derfor blevet importeret. +
+ Rapportér fejlen til din lokale adminstrator sammen med den excel fil du forsøgte at importere. Tak. +

+
+
-
-

-

- - Fejl ved import -

- Der skete en uforudset fejl i forbindelse med importen. Intet er derfor blevet importeret. -
- Rapportér fejlen til din lokale adminstrator sammen med den excel fil du forsøgte at importere. Tak. -

+ +
+
+ Via FK Organisation +
+
+ +
diff --git a/Presentation.Web/app/models/api/organization/check-connectoin-error.ts b/Presentation.Web/app/models/api/organization/check-connectoin-error.ts new file mode 100644 index 0000000000..151ef75dea --- /dev/null +++ b/Presentation.Web/app/models/api/organization/check-connectoin-error.ts @@ -0,0 +1,8 @@ +module Kitos.Models.Api.Organization { + export enum CheckConnectionError { + InvalidCvrOnOrganization = 0, + MissingServiceAgreement = 1, + ExistingServiceAgreementIssue = 2, + Unknown = 3 + } +} \ No newline at end of file diff --git a/Presentation.Web/app/models/api/organization/check-sts-organization-connection-response-dto.ts b/Presentation.Web/app/models/api/organization/check-sts-organization-connection-response-dto.ts new file mode 100644 index 0000000000..66f84e1a2d --- /dev/null +++ b/Presentation.Web/app/models/api/organization/check-sts-organization-connection-response-dto.ts @@ -0,0 +1,6 @@ +module Kitos.Models.Api.Organization { + export interface CheckStsOrganizationConnectionResponseDTO { + connected: boolean + error: CheckConnectionError | null + } +} \ No newline at end of file diff --git a/Presentation.Web/app/services/sts-organization-sync-service.ts b/Presentation.Web/app/services/sts-organization-sync-service.ts new file mode 100644 index 0000000000..c5b61a5e18 --- /dev/null +++ b/Presentation.Web/app/services/sts-organization-sync-service.ts @@ -0,0 +1,35 @@ +module Kitos.Services.Organization { + export interface IStsOrganizationSyncService { + getConnectionStatus(organizationId: string): ng.IPromise + } + + export class StsOrganizationSyncService implements IStsOrganizationSyncService { + + static $inject = ["genericApiWrapper", "inMemoryCacheService", "$q"]; + constructor( + private readonly genericApiWrapper: Services.Generic.ApiWrapper, + private readonly inMemoryCacheService: Kitos.Shared.Caching.IInMemoryCacheService, + private readonly $q: ng.IQService) { + } + + private getBasePath(organizationUuid: string) { + return `api/v1/organizations/${organizationUuid}/sts-organization-synchronization`; + } + + getConnectionStatus(organizationUuid: string): ng.IPromise { + const cacheKey = `FK_CONNECTION_STATUS_${organizationUuid}`; + const result = this.inMemoryCacheService.getEntry(cacheKey); + if (result != null) { + return this.$q.resolve(result); + } + return this.genericApiWrapper + .getDataFromUrl(`${this.getBasePath(organizationUuid)}/connection-status`) + .then(connectionStatus => { + this.inMemoryCacheService.setEntry(cacheKey, connectionStatus, Kitos.Shared.Time.Offset.compute(Kitos.Shared.Time.TimeUnit.Minutes, 1)); + return connectionStatus; + }); + } + } + + app.service("stsOrganizationSyncService", StsOrganizationSyncService); +} \ No newline at end of file diff --git a/Presentation.Web/app/services/userServices.ts b/Presentation.Web/app/services/userServices.ts index 8c04ee6d8a..50b3fb6a91 100644 --- a/Presentation.Web/app/services/userServices.ts +++ b/Presentation.Web/app/services/userServices.ts @@ -26,6 +26,7 @@ currentOrganization: string; currentOrganizationId: number; + currentOrganizationUuid: string; currentOrganizationName: string; currentConfig: any; } @@ -124,6 +125,7 @@ defaultOrganizationUnitId: defaultOrgUnitId, currentOrganization: currOrg, currentOrganizationId: currOrg.id, + currentOrganizationUuid: currOrg.uuid, currentOrganizationName: currOrg.name, currentConfig: currOrg.config }; From 5e247d59f37dc20ffd27174ff8198352db334930 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Morten=20Remb=C3=B8l=20Jacobsen?= Date: Thu, 29 Sep 2022 13:08:11 +0200 Subject: [PATCH 006/272] added unit test for the connection validation mapping --- .../DomainServices/StsOrganizationService.cs | 2 +- .../StsOrganizationServiceTest.cs | 85 +++++++++++++++++++ .../Tests.Unit.Core.csproj | 9 ++ 3 files changed, 95 insertions(+), 1 deletion(-) create mode 100644 Tests.Unit.Core.ApplicationServices/DomainServices/Organizations/StsOrganizationServiceTest.cs diff --git a/Infrastructure.STS.Organization/DomainServices/StsOrganizationService.cs b/Infrastructure.STS.Organization/DomainServices/StsOrganizationService.cs index 3373146e79..adf183758e 100644 --- a/Infrastructure.STS.Organization/DomainServices/StsOrganizationService.cs +++ b/Infrastructure.STS.Organization/DomainServices/StsOrganizationService.cs @@ -107,7 +107,7 @@ public Result> Resolv private Result> ResolveExternalUuid(Core.DomainModel.Organization.Organization organization) { - if (organization.Cvr == null || organization.IsCvrInvalid()) + if (string.IsNullOrWhiteSpace(organization.Cvr) || organization.IsCvrInvalid()) { return new DetailedOperationError(OperationFailure.BadState, ResolveOrganizationUuidError.InvalidCvrOnOrganization); } diff --git a/Tests.Unit.Core.ApplicationServices/DomainServices/Organizations/StsOrganizationServiceTest.cs b/Tests.Unit.Core.ApplicationServices/DomainServices/Organizations/StsOrganizationServiceTest.cs new file mode 100644 index 0000000000..568f326e6a --- /dev/null +++ b/Tests.Unit.Core.ApplicationServices/DomainServices/Organizations/StsOrganizationServiceTest.cs @@ -0,0 +1,85 @@ +using System; +using AutoFixture; +using Core.Abstractions.Types; +using Core.DomainModel.Organization; +using Core.DomainServices.Model.StsOrganization; +using Core.DomainServices.Organizations; +using Core.DomainServices.Repositories.Organization; +using Core.DomainServices.SSO; +using Infrastructure.STS.Common.Model; +using Infrastructure.STS.Organization.DomainServices; +using Moq; +using Serilog; +using Tests.Toolkit.Patterns; +using Xunit; + +namespace Tests.Unit.Core.DomainServices.Organizations +{ + public class StsOrganizationServiceTest : WithAutoFixture + { + private const string ValidCvr = "12345678"; + private StsOrganizationService _sut; + private Mock _companyLookupServiceMock; + + protected override void OnFixtureCreated(Fixture fixture) + { + base.OnFixtureCreated(fixture); + _companyLookupServiceMock = new Mock(); + _sut = new StsOrganizationService(A(), _companyLookupServiceMock.Object, new Mock().Object, Mock.Of()); + } + + [Theory] + [InlineData(null)] //not provided + [InlineData("")] //not provided + [InlineData(" ")] //not provided + [InlineData("1234567")] // less than 8 + [InlineData("12345678912")] //more than 10 + public void ValidateConnection_Fails_With_Invalid_Cvr(string cvr) + { + //Arrange + var organization = new Organization { Cvr = cvr }; + + //Act + var error = _sut.ValidateConnection(organization); + + //Assert + Assert.True(error.HasValue); + Assert.Equal(CheckConnectionError.InvalidCvrOnOrganization, error.Value.Detail); + } + + [Theory] + [InlineData(OperationFailure.Forbidden, StsError.MissingServiceAgreement, CheckConnectionError.MissingServiceAgreement, OperationFailure.Forbidden)] + [InlineData(OperationFailure.BadInput, StsError.ExistingServiceAgreementIssue, CheckConnectionError.ExistingServiceAgreementIssue, OperationFailure.BadInput)] + [InlineData(OperationFailure.BadInput, StsError.NotFound, CheckConnectionError.Unknown, OperationFailure.UnknownError)] + [InlineData(OperationFailure.BadInput, StsError.BadInput, CheckConnectionError.Unknown, OperationFailure.UnknownError)] + public void ValidateConnection_Fails_With_Lookup_Error(OperationFailure failureTypeFromLookup, StsError errorFromLookup, CheckConnectionError expectedError, OperationFailure expectedFailure) + { + //Arrange + var organization = new Organization { Cvr = ValidCvr }; + _companyLookupServiceMock.Setup(x => x.ResolveStsOrganizationCompanyUuid(organization)) + .Returns(new DetailedOperationError(failureTypeFromLookup, errorFromLookup)); + + //Act + var error = _sut.ValidateConnection(organization); + + //Assert + Assert.True(error.HasValue); + Assert.Equal(expectedError, error.Value.Detail); + Assert.Equal(expectedFailure, error.Value.FailureType); + } + + [Fact] + public void ValidateConnection_Succeeds_If_Company_Uuuid_Lookup_Succeeds() + { + //Arrange + var organization = new Organization { Cvr = ValidCvr }; + _companyLookupServiceMock.Setup(x => x.ResolveStsOrganizationCompanyUuid(organization)).Returns(A()); + + //Act + var error = _sut.ValidateConnection(organization); + + //Assert + Assert.False(error.HasValue); + } + } +} diff --git a/Tests.Unit.Core.ApplicationServices/Tests.Unit.Core.csproj b/Tests.Unit.Core.ApplicationServices/Tests.Unit.Core.csproj index 2199c8abfc..16e272f265 100644 --- a/Tests.Unit.Core.ApplicationServices/Tests.Unit.Core.csproj +++ b/Tests.Unit.Core.ApplicationServices/Tests.Unit.Core.csproj @@ -225,6 +225,7 @@ + @@ -308,6 +309,14 @@ {a05389ea-25f4-45b5-8534-0775d9671456} Infrastructure.Soap + + {423D7522-4882-4438-94F4-7B3F5778C83F} + Infrastructure.STS.Common + + + {3DC91665-93BB-442D-B186-7E90C7CD6E32} + Infrastructure.STS.Organization + {43199485-65c5-4bff-88b2-b594d5b58146} Tests.Toolkit From a54d83c7db68b13e380fefb806395ee29e3758a6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Morten=20Remb=C3=B8l=20Jacobsen?= Date: Thu, 29 Sep 2022 13:32:29 +0200 Subject: [PATCH 007/272] cleanup --- .../IStsOrganizationSynchronizationService.cs | 1 - ...fk-organization-import-config.component.ts | 63 ++++++++++--------- 2 files changed, 32 insertions(+), 32 deletions(-) diff --git a/Core.ApplicationServices/Organizations/IStsOrganizationSynchronizationService.cs b/Core.ApplicationServices/Organizations/IStsOrganizationSynchronizationService.cs index 6c9ee5e332..131c510dc8 100644 --- a/Core.ApplicationServices/Organizations/IStsOrganizationSynchronizationService.cs +++ b/Core.ApplicationServices/Organizations/IStsOrganizationSynchronizationService.cs @@ -8,7 +8,6 @@ public interface IStsOrganizationSynchronizationService { /// /// Validates if KITOS can read organization data from STS Organisation - /// Maybe> ValidateConnection(Guid organizationId); /// /// Retrieves a view of the organization as it exists in STS Organization diff --git a/Presentation.Web/app/components/local-config/import/fk-organization-import-config.component.ts b/Presentation.Web/app/components/local-config/import/fk-organization-import-config.component.ts index 2e3ba1ad88..1f450647e0 100644 --- a/Presentation.Web/app/components/local-config/import/fk-organization-import-config.component.ts +++ b/Presentation.Web/app/components/local-config/import/fk-organization-import-config.component.ts @@ -17,7 +17,7 @@ } class FkOrganizationImportController implements IFkOrganizationImportController { - currentOrganizationUuid: string; //note set by bindings + currentOrganizationUuid: string | null = null; //note set by bindings connected: boolean | null = null; connectionError: string | null = null; @@ -26,37 +26,38 @@ } $onInit() { - /////////////////////////////////////////////////// - //TODO: Validate that required bindings are set // - /////////////////////////////////////////////////// - this.stsOrganizationSyncService - .getConnectionStatus(this.currentOrganizationUuid) - .then(result => { - if (result.connected) { - this.connected = true; - } else { - this.connected = false; - switch (result.error) { - case Models.Api.Organization.CheckConnectionError.ExistingServiceAgreementIssue: - this.connectionError = "Der er problemer med den eksisterende serviceaftale, der giver KITOS adgang til data fra din kommune i FK Organisatoin. Kontakt venligst den KITOS ansvarlige i din kommune for hjælp." - break; - case Models.Api.Organization.CheckConnectionError.InvalidCvrOnOrganization: - this.connectionError = "Der enten mangler eller er registreret et ugyldigt CVR nummer på din kommune i KITOS." - break; - case Models.Api.Organization.CheckConnectionError.MissingServiceAgreement: - this.connectionError = "Din organisation mangler en gyldig serviceaftale der giver KITOS adgang til data fra din kommune i FK Organisation. Kontakt venligst den KITOS ansvarlige i din kommune for hjælp." - break; - case Models.Api.Organization.CheckConnectionError.Unknown: //intended fallthrough - default: - this.connectionError = "Der skete en ukendt fejl ifm. tjek for forbindelsen til FK Organisation. Genindlæs venligst siden for at prøve igen." - break; + if (this.currentOrganizationUuid === null) { + console.error("missing attribute: 'currentOrganizationUuid'"); + } else { + this.stsOrganizationSyncService + .getConnectionStatus(this.currentOrganizationUuid) + .then(result => { + if (result.connected) { + this.connected = true; + } else { + this.connected = false; + switch (result.error) { + case Models.Api.Organization.CheckConnectionError.ExistingServiceAgreementIssue: + this.connectionError = "Der er problemer med den eksisterende serviceaftale, der giver KITOS adgang til data fra din kommune i FK Organisatoin. Kontakt venligst den KITOS ansvarlige i din kommune for hjælp." + break; + case Models.Api.Organization.CheckConnectionError.InvalidCvrOnOrganization: + this.connectionError = "Der enten mangler eller er registreret et ugyldigt CVR nummer på din kommune i KITOS." + break; + case Models.Api.Organization.CheckConnectionError.MissingServiceAgreement: + this.connectionError = "Din organisation mangler en gyldig serviceaftale der giver KITOS adgang til data fra din kommune i FK Organisation. Kontakt venligst den KITOS ansvarlige i din kommune for hjælp." + break; + case Models.Api.Organization.CheckConnectionError.Unknown: //intended fallthrough + default: + this.connectionError = "Der skete en ukendt fejl ifm. tjek for forbindelsen til FK Organisation. Genindlæs venligst siden for at prøve igen." + break; + } } - } - }, error => { - console.error(error); - this.connected = false; - this.connectionError = "Der skete en fejl ifm. tjek for forbindelsen til FK Organisation. Genindlæs venligst siden for at prøve igen." - }) + }, error => { + console.error(error); + this.connected = false; + this.connectionError = "Der skete en fejl ifm. tjek for forbindelsen til FK Organisation. Genindlæs venligst siden for at prøve igen." + }); + } } } angular.module("app") From 25f18f7a4ecc878cf030fc74ec4bfce1661659fb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Morten=20Remb=C3=B8l=20Jacobsen?= Date: Thu, 29 Sep 2022 13:37:26 +0200 Subject: [PATCH 008/272] moved advice test to sequential group --- Tests.Integration.Presentation.Web/Advice/AdviceTest.cs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Tests.Integration.Presentation.Web/Advice/AdviceTest.cs b/Tests.Integration.Presentation.Web/Advice/AdviceTest.cs index 2af002c2f5..266affd2e8 100644 --- a/Tests.Integration.Presentation.Web/Advice/AdviceTest.cs +++ b/Tests.Integration.Presentation.Web/Advice/AdviceTest.cs @@ -11,11 +11,13 @@ using Core.DomainServices.Extensions; using Presentation.Web.Models.API.V1; using Tests.Integration.Presentation.Web.Tools; +using Tests.Integration.Presentation.Web.Tools.XUnit; using Tests.Toolkit.Patterns; using Xunit; namespace Tests.Integration.Presentation.Web.Advice { + [Collection(nameof(SequentialTestGroup))] public class AdviceTest : WithAutoFixture, IAsyncLifetime { private ItContractDTO _root; From 305d757cd2f39b63a6e5aeefd9d37eb0714e526a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Morten=20Remb=C3=B8l=20Jacobsen?= Date: Thu, 29 Sep 2022 13:43:55 +0200 Subject: [PATCH 009/272] moved potentially flaky test into sequential test group --- .../Advice/AdviceSequentialTest.cs | 59 +++++++++++ .../Advice/AdviceTest.cs | 100 +----------------- .../Advice/AdviceTestBase.cs | 91 ++++++++++++++++ .../Tests.Integration.Presentation.Web.csproj | 2 + 4 files changed, 153 insertions(+), 99 deletions(-) create mode 100644 Tests.Integration.Presentation.Web/Advice/AdviceSequentialTest.cs create mode 100644 Tests.Integration.Presentation.Web/Advice/AdviceTestBase.cs diff --git a/Tests.Integration.Presentation.Web/Advice/AdviceSequentialTest.cs b/Tests.Integration.Presentation.Web/Advice/AdviceSequentialTest.cs new file mode 100644 index 0000000000..0de9c70f07 --- /dev/null +++ b/Tests.Integration.Presentation.Web/Advice/AdviceSequentialTest.cs @@ -0,0 +1,59 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Net; +using System.Threading.Tasks; +using Core.DomainModel.Advice; +using Core.DomainModel.Shared; +using Core.DomainServices.Extensions; +using Tests.Integration.Presentation.Web.Tools; +using Tests.Integration.Presentation.Web.Tools.XUnit; +using Xunit; + +namespace Tests.Integration.Presentation.Web.Advice +{ + [Collection(nameof(SequentialTestGroup))] + public class AdviceSequentialTest : AdviceTestBase + { + [Fact] + public async Task Cannot_Delete_Advice_That_Has_Been_Sent() + { + //Arrange + var recipient = CreateDefaultEmailRecipient(CreateWellformedEmail()); + var createAdvice = CreateDefaultAdvice(Scheduling.Day, AdviceType.Immediate, recipient); + + using var createResult = await AdviceHelper.PostAdviceAsync(createAdvice, OrganizationId); + Assert.Equal(HttpStatusCode.Created, createResult.StatusCode); + var createdAdvice = await createResult.ReadResponseBodyAsAsync(); + + //Wait for the advice to have been sent + await WaitForAsync(() => Task.FromResult(DatabaseAccess.MapFromEntitySet(advices => advices.AsQueryable().ById(createdAdvice.Id).AdviceSent.Any())), TimeSpan.FromSeconds(30)); + + + //Act + using var deleteResult = await AdviceHelper.DeleteAdviceAsync(createdAdvice.Id); + + //Assert + Assert.Equal(HttpStatusCode.BadRequest, deleteResult.StatusCode); + } + + private Core.DomainModel.Advice.Advice CreateDefaultAdvice(Scheduling schedule, AdviceType type, AdviceUserRelation recipient) + { + return new Core.DomainModel.Advice.Advice + { + RelationId = Root.Id, + Type = RelatedEntityType.itContract, + Body = A(), + Subject = A(), + Scheduling = schedule, + AdviceType = type, + Reciepients = new List() + { + recipient + }, + AlarmDate = DateTime.Now, + StopDate = GetRandomDateAfterToday(), + }; + } + } +} diff --git a/Tests.Integration.Presentation.Web/Advice/AdviceTest.cs b/Tests.Integration.Presentation.Web/Advice/AdviceTest.cs index 266affd2e8..2c80102386 100644 --- a/Tests.Integration.Presentation.Web/Advice/AdviceTest.cs +++ b/Tests.Integration.Presentation.Web/Advice/AdviceTest.cs @@ -1,28 +1,17 @@ using System; -using System.Collections.Generic; -using System.Diagnostics; using System.Linq; using System.Net; -using System.Threading; using System.Threading.Tasks; using Core.DomainModel.Advice; using Core.DomainModel.Organization; using Core.DomainModel.Shared; -using Core.DomainServices.Extensions; -using Presentation.Web.Models.API.V1; using Tests.Integration.Presentation.Web.Tools; -using Tests.Integration.Presentation.Web.Tools.XUnit; -using Tests.Toolkit.Patterns; using Xunit; namespace Tests.Integration.Presentation.Web.Advice { - [Collection(nameof(SequentialTestGroup))] - public class AdviceTest : WithAutoFixture, IAsyncLifetime + public class AdviceTest : AdviceTestBase { - private ItContractDTO _root; - private const int OrganizationId = TestEnvironment.DefaultOrganizationId; - [Fact] public async Task Can_Add_Advice() { @@ -235,28 +224,6 @@ public async Task Cannot_Delete_Advice_That_Does_Not_Exist() Assert.Equal(HttpStatusCode.NotFound, deleteResult.StatusCode); } - [Fact] - public async Task Cannot_Delete_Advice_That_Has_Been_Sent() - { - //Arrange - var recipient = CreateDefaultEmailRecipient(CreateWellformedEmail()); - var createAdvice = CreateDefaultAdvice(Scheduling.Day, AdviceType.Immediate, recipient); - - using var createResult = await AdviceHelper.PostAdviceAsync(createAdvice, OrganizationId); - Assert.Equal(HttpStatusCode.Created, createResult.StatusCode); - var createdAdvice = await createResult.ReadResponseBodyAsAsync(); - - //Wait for the advice to have been sent - await WaitForAsync(() => Task.FromResult(DatabaseAccess.MapFromEntitySet(advices => advices.AsQueryable().ById(createdAdvice.Id).AdviceSent.Any())), TimeSpan.FromSeconds(30)); - - - //Act - using var deleteResult = await AdviceHelper.DeleteAdviceAsync(createdAdvice.Id); - - //Assert - Assert.Equal(HttpStatusCode.BadRequest, deleteResult.StatusCode); - } - [Fact] public async Task Cannot_Delete_Inactive_Advice_That_Has_Not_Been_Sent_If_No_Rights() { @@ -319,70 +286,5 @@ private static async Task AssertAdviceCreationReturns(Core.DomainModel.Advice.Ad using var createResultBeforeRoleAssignment = await AdviceHelper.PostAdviceAsync(advice, OrganizationId, readOnlyUserCookie); Assert.Equal(expectedResult, createResultBeforeRoleAssignment.StatusCode); } - - private Core.DomainModel.Advice.Advice CreateDefaultAdvice(Scheduling schedule, AdviceType type, AdviceUserRelation recipient) - { - return new Core.DomainModel.Advice.Advice - { - RelationId = _root.Id, - Type = RelatedEntityType.itContract, - Body = A(), - Subject = A(), - Scheduling = schedule, - AdviceType = type, - Reciepients = new List() - { - recipient - }, - AlarmDate = DateTime.Now, - StopDate = GetRandomDateAfterToday(), - }; - } - - - private AdviceUserRelation CreateDefaultEmailRecipient(string name) - { - return new AdviceUserRelation - { - Email = name, - RecieverType = RecieverType.RECIEVER, - RecpientType = RecipientType.USER - }; - } - - private string CreateWellformedEmail() - { - //Make sure special chars are part of the test email - return $"{A()}_a.b-c@test.dk"; - } - - private DateTime GetRandomDateAfterToday() - { - return DateTime.Now.AddDays(Math.Abs(A())); - } - - public async Task InitializeAsync() - { - _root = await ItContractHelper.CreateContract(A(), OrganizationId); - } - - public Task DisposeAsync() - { - return Task.CompletedTask; - } - - private static async Task WaitForAsync(Func> check, TimeSpan howLong) - { - bool conditionMet; - var stopwatch = new Stopwatch(); - stopwatch.Start(); - do - { - Thread.Sleep(TimeSpan.FromMilliseconds(250)); - conditionMet = await check(); - } while (conditionMet == false && stopwatch.Elapsed <= howLong); - - Assert.True(conditionMet, $"Failed to meet required condition within {howLong.TotalMilliseconds} milliseconds"); - } } } diff --git a/Tests.Integration.Presentation.Web/Advice/AdviceTestBase.cs b/Tests.Integration.Presentation.Web/Advice/AdviceTestBase.cs new file mode 100644 index 0000000000..67cb4d918b --- /dev/null +++ b/Tests.Integration.Presentation.Web/Advice/AdviceTestBase.cs @@ -0,0 +1,91 @@ +using Core.DomainModel.Advice; +using Core.DomainModel.Shared; +using System.Collections.Generic; +using System.Diagnostics; +using System.Threading.Tasks; +using System.Threading; +using System; +using Tests.Integration.Presentation.Web.Tools; +using Tests.Toolkit.Patterns; +using Xunit; +using Presentation.Web.Models.API.V1; + +namespace Tests.Integration.Presentation.Web.Advice +{ + public abstract class AdviceTestBase : WithAutoFixture, IAsyncLifetime + { + public async Task InitializeAsync() + { + Root = await ItContractHelper.CreateContract(A(), OrganizationId); + } + + public Task DisposeAsync() + { + return Task.CompletedTask; + } + + private ItContractDTO _root; + protected const int OrganizationId = TestEnvironment.DefaultOrganizationId; + + protected Core.DomainModel.Advice.Advice CreateDefaultAdvice(Scheduling schedule, AdviceType type, AdviceUserRelation recipient) + { + return new Core.DomainModel.Advice.Advice + { + RelationId = Root.Id, + Type = RelatedEntityType.itContract, + Body = A(), + Subject = A(), + Scheduling = schedule, + AdviceType = type, + Reciepients = new List() + { + recipient + }, + AlarmDate = DateTime.Now, + StopDate = GetRandomDateAfterToday(), + }; + } + + + protected AdviceUserRelation CreateDefaultEmailRecipient(string name) + { + return new AdviceUserRelation + { + Email = name, + RecieverType = RecieverType.RECIEVER, + RecpientType = RecipientType.USER + }; + } + + protected string CreateWellformedEmail() + { + //Make sure special chars are part of the test email + return $"{A()}_a.b-c@test.dk"; + } + + protected DateTime GetRandomDateAfterToday() + { + return DateTime.Now.AddDays(Math.Abs(A())); + } + + protected static async Task WaitForAsync(Func> check, TimeSpan howLong) + { + bool conditionMet; + var stopwatch = new Stopwatch(); + stopwatch.Start(); + do + { + Thread.Sleep(TimeSpan.FromMilliseconds(250)); + conditionMet = await check(); + } while (conditionMet == false && stopwatch.Elapsed <= howLong); + + Assert.True(conditionMet, $"Failed to meet required condition within {howLong.TotalMilliseconds} milliseconds"); + } + + protected ItContractDTO Root + { + get => _root; + set => _root = value; + } + } +} diff --git a/Tests.Integration.Presentation.Web/Tests.Integration.Presentation.Web.csproj b/Tests.Integration.Presentation.Web/Tests.Integration.Presentation.Web.csproj index fda405cbb7..f079b03948 100644 --- a/Tests.Integration.Presentation.Web/Tests.Integration.Presentation.Web.csproj +++ b/Tests.Integration.Presentation.Web/Tests.Integration.Presentation.Web.csproj @@ -124,7 +124,9 @@ + + From 7253153cb21f137df69725e09798cfc5a0986021 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Morten=20Remb=C3=B8l=20Jacobsen?= Date: Thu, 29 Sep 2022 13:44:25 +0200 Subject: [PATCH 010/272] Extended timeout --- .../Advice/AdviceSequentialTest.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Tests.Integration.Presentation.Web/Advice/AdviceSequentialTest.cs b/Tests.Integration.Presentation.Web/Advice/AdviceSequentialTest.cs index 0de9c70f07..e3be183e06 100644 --- a/Tests.Integration.Presentation.Web/Advice/AdviceSequentialTest.cs +++ b/Tests.Integration.Presentation.Web/Advice/AdviceSequentialTest.cs @@ -27,7 +27,7 @@ public async Task Cannot_Delete_Advice_That_Has_Been_Sent() var createdAdvice = await createResult.ReadResponseBodyAsAsync(); //Wait for the advice to have been sent - await WaitForAsync(() => Task.FromResult(DatabaseAccess.MapFromEntitySet(advices => advices.AsQueryable().ById(createdAdvice.Id).AdviceSent.Any())), TimeSpan.FromSeconds(30)); + await WaitForAsync(() => Task.FromResult(DatabaseAccess.MapFromEntitySet(advices => advices.AsQueryable().ById(createdAdvice.Id).AdviceSent.Any())), TimeSpan.FromSeconds(120)); //Act From 4e963d9117e38180512fbe15d706d426e55c632f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Morten=20Remb=C3=B8l=20Jacobsen?= Date: Fri, 30 Sep 2022 07:44:33 +0200 Subject: [PATCH 011/272] use org service to validate connection --- .../StsOrganizationSynchronizationService.cs | 7 +++++-- .../Organizations/IStsOrganizationUnitService.cs | 1 - .../DomainServices/StsOrganizationUnitService.cs | 9 --------- .../StsOrganizationSynchronizationServiceTest.cs | 2 +- 4 files changed, 6 insertions(+), 13 deletions(-) diff --git a/Core.ApplicationServices/Organizations/StsOrganizationSynchronizationService.cs b/Core.ApplicationServices/Organizations/StsOrganizationSynchronizationService.cs index 63df5e467d..71f17598af 100644 --- a/Core.ApplicationServices/Organizations/StsOrganizationSynchronizationService.cs +++ b/Core.ApplicationServices/Organizations/StsOrganizationSynchronizationService.cs @@ -14,17 +14,20 @@ public class StsOrganizationSynchronizationService : IStsOrganizationSynchroniza private readonly IStsOrganizationUnitService _stsOrganizationUnitService; private readonly IOrganizationService _organizationService; private readonly ILogger _logger; + private readonly IStsOrganizationService _stsOrganizationService; private readonly IAuthorizationContext _authorizationContext; public StsOrganizationSynchronizationService( IAuthorizationContext authorizationContext, IStsOrganizationUnitService stsOrganizationUnitService, IOrganizationService organizationService, - ILogger logger) + ILogger logger, + IStsOrganizationService stsOrganizationService) { _stsOrganizationUnitService = stsOrganizationUnitService; _organizationService = organizationService; _logger = logger; + _stsOrganizationService = stsOrganizationService; _authorizationContext = authorizationContext; } @@ -36,7 +39,7 @@ public Maybe> ValidateConnection(Gu private Maybe> ValidateConnection(Organization organization) { - return _stsOrganizationUnitService.ValidateConnection(organization); + return _stsOrganizationService.ValidateConnection(organization); } public Result GetStsOrganizationalHierarchy(Guid organizationId, Maybe levelsToInclude) diff --git a/Core.DomainServices/Organizations/IStsOrganizationUnitService.cs b/Core.DomainServices/Organizations/IStsOrganizationUnitService.cs index 531fca7966..78e320f582 100644 --- a/Core.DomainServices/Organizations/IStsOrganizationUnitService.cs +++ b/Core.DomainServices/Organizations/IStsOrganizationUnitService.cs @@ -7,6 +7,5 @@ namespace Core.DomainServices.Organizations public interface IStsOrganizationUnitService { Result> ResolveOrganizationTree(Organization organization); - Maybe> ValidateConnection(Organization organization); } } diff --git a/Infrastructure.STS.OrganizationUnit/DomainServices/StsOrganizationUnitService.cs b/Infrastructure.STS.OrganizationUnit/DomainServices/StsOrganizationUnitService.cs index 83eb0cd82c..0cee1a844d 100644 --- a/Infrastructure.STS.OrganizationUnit/DomainServices/StsOrganizationUnitService.cs +++ b/Infrastructure.STS.OrganizationUnit/DomainServices/StsOrganizationUnitService.cs @@ -140,15 +140,6 @@ public Result> ValidateConnection(Organization organization) - { - if (organization == null) - { - throw new ArgumentNullException(nameof(organization)); - } - return _organizationService.ValidateConnection(organization); - } - private static Stack CreateOrgUnitConversionStack((Guid, RegistreringType1) root, Dictionary> unitsByParent) { var processingStack = new Stack(); diff --git a/Tests.Unit.Core.ApplicationServices/ApplicationServices/Organizations/StsOrganizationSynchronizationServiceTest.cs b/Tests.Unit.Core.ApplicationServices/ApplicationServices/Organizations/StsOrganizationSynchronizationServiceTest.cs index ff2c5735c5..0a42032fef 100644 --- a/Tests.Unit.Core.ApplicationServices/ApplicationServices/Organizations/StsOrganizationSynchronizationServiceTest.cs +++ b/Tests.Unit.Core.ApplicationServices/ApplicationServices/Organizations/StsOrganizationSynchronizationServiceTest.cs @@ -31,7 +31,7 @@ public StsOrganizationSynchronizationServiceTest(ITestOutputHelper testOutputHel _authorizationContextMock = new Mock(); _stsOrganizationUnitService = new Mock(); _organizationServiceMock = new Mock(); - _sut = new StsOrganizationSynchronizationService(_authorizationContextMock.Object, _stsOrganizationUnitService.Object, _organizationServiceMock.Object, Mock.Of()); + _sut = new StsOrganizationSynchronizationService(_authorizationContextMock.Object, _stsOrganizationUnitService.Object, _organizationServiceMock.Object, Mock.Of(), Mock.Of()); } protected override void OnFixtureCreated(Fixture fixture) From d908f845dc7fd2921d2704c051b328c553314b0e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Morten=20Remb=C3=B8l=20Jacobsen?= Date: Fri, 30 Sep 2022 10:05:25 +0200 Subject: [PATCH 012/272] Added temp feature --- .../Models/Application/FeatureToggle/TemporaryFeature.cs | 1 + 1 file changed, 1 insertion(+) diff --git a/Presentation.Web/Models/Application/FeatureToggle/TemporaryFeature.cs b/Presentation.Web/Models/Application/FeatureToggle/TemporaryFeature.cs index 59869c1f8f..70a5b54a29 100644 --- a/Presentation.Web/Models/Application/FeatureToggle/TemporaryFeature.cs +++ b/Presentation.Web/Models/Application/FeatureToggle/TemporaryFeature.cs @@ -5,5 +5,6 @@ /// public enum TemporaryFeature { + FK_Organisation = 0 } } \ No newline at end of file From 5fd8b15cb4b0e51d96931b015746f9460e96d908 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Morten=20Remb=C3=B8l=20Jacobsen?= Date: Fri, 30 Sep 2022 10:33:49 +0200 Subject: [PATCH 013/272] added use of feature toggle --- Presentation.Web/Presentation.Web.csproj | 3 +++ .../app/components/home/home.controller.ts | 10 +++++-- .../local-config-import-org.controller.ts | 6 ++--- .../feature-toggle/sso-state-view-model.ts | 27 +++++++++++++++++++ .../feature-toggle/feature-toggle-service.ts | 26 ++++++++++++++++++ .../feature-toggle/temporary-feature.ts | 5 ++++ 6 files changed, 72 insertions(+), 5 deletions(-) create mode 100644 Presentation.Web/app/models/ViewModel/feature-toggle/sso-state-view-model.ts create mode 100644 Presentation.Web/app/services/feature-toggle/feature-toggle-service.ts create mode 100644 Presentation.Web/app/services/feature-toggle/temporary-feature.ts diff --git a/Presentation.Web/Presentation.Web.csproj b/Presentation.Web/Presentation.Web.csproj index edb4166460..6e43f62882 100644 --- a/Presentation.Web/Presentation.Web.csproj +++ b/Presentation.Web/Presentation.Web.csproj @@ -376,6 +376,7 @@ + @@ -866,6 +867,8 @@ + + diff --git a/Presentation.Web/app/components/home/home.controller.ts b/Presentation.Web/app/components/home/home.controller.ts index ce69ff0041..baed7753f1 100644 --- a/Presentation.Web/app/components/home/home.controller.ts +++ b/Presentation.Web/app/components/home/home.controller.ts @@ -16,8 +16,8 @@ } ]); - app.controller("home.IndexCtrl", ["$rootScope", "$scope", "$http", "$state", "$stateParams", "notify", "userService", "texts", "navigationService", "$sce", "$location", "$", - ($rootScope, $scope, $http, $state, $stateParams, notify, userService, texts, navigationService, $sce, $location, $) => { + app.controller("home.IndexCtrl", ["$rootScope", "$scope", "$http", "$state", "notify", "userService", "texts", "navigationService", "$sce", "$location", "$", "featureToggleService", + ($rootScope, $scope, $http, $state, notify, userService, texts, navigationService, $sce, $location, $, featureToggleService: Kitos.Services.FeatureToggle.IFeatureToggleService) => { const factory = new Kitos.Models.ViewModel.Sso.SsoStateViewModelFactory($); let ssoStateViewModel = factory.createFromViewState(); @@ -30,6 +30,12 @@ } } + const ftFactory = new Kitos.Models.ViewModel.FeatureToggle.FeatureToggleViewModelFactory($); + const ftViewModel = ftFactory.createFromViewState(); + if (ftViewModel.featureToggle !== null) { + featureToggleService.addFeature(ftViewModel.featureToggle); + } + $rootScope.page.title = "Index"; $rootScope.page.subnav = []; $scope.texts = []; diff --git a/Presentation.Web/app/components/local-config/import/local-config-import-org.controller.ts b/Presentation.Web/app/components/local-config/import/local-config-import-org.controller.ts index 1ed8f83a5a..18251692c5 100644 --- a/Presentation.Web/app/components/local-config/import/local-config-import-org.controller.ts +++ b/Presentation.Web/app/components/local-config/import/local-config-import-org.controller.ts @@ -10,11 +10,11 @@ ]); app.controller('local-config.import.ImportOrgCtrl', [ - '$scope', '$http', 'notify', 'user', - function ($scope, $http, notify, user) { + '$scope', '$http', 'notify', 'user', 'featureToggleService', + function ($scope, $http, notify, user, featureToggleService: Kitos.Services.FeatureToggle.IFeatureToggleService) { $scope.url = 'api/excel?organizationId=' + user.currentOrganizationId + '&exportOrgUnits'; $scope.title = 'organisationsenheder'; - $scope.showFkOrgImport = true; + $scope.showFkOrgImport = featureToggleService.hasFeature(Kitos.Services.FeatureToggle.TemporaryFeature.FK_Organisation); $scope.currentOrganizationUuid = user.currentOrganizationUuid; //Import OrganizationUnits $scope.submit = function () { diff --git a/Presentation.Web/app/models/ViewModel/feature-toggle/sso-state-view-model.ts b/Presentation.Web/app/models/ViewModel/feature-toggle/sso-state-view-model.ts new file mode 100644 index 0000000000..3e44e514a8 --- /dev/null +++ b/Presentation.Web/app/models/ViewModel/feature-toggle/sso-state-view-model.ts @@ -0,0 +1,27 @@ +module Kitos.Models.ViewModel.FeatureToggle { + export interface IFeatureToggleViewModel { + featureToggle: string | null; + } + + export class FeatureToggleViewModelFactory { + + constructor(private readonly $) { + + } + + createFromViewState() { + let featureToggleValue: string | null = null; + const state = new Utility.ViewDataState(this.$); + + const featureToggleElement = state.getStateOrNull("feature-toggle"); + if (featureToggleElement) { + featureToggleValue = featureToggleElement.value; + featureToggleElement.element.remove(); + } + + return { + featureToggle: featureToggleValue + }; + } + } +} \ No newline at end of file diff --git a/Presentation.Web/app/services/feature-toggle/feature-toggle-service.ts b/Presentation.Web/app/services/feature-toggle/feature-toggle-service.ts new file mode 100644 index 0000000000..48ce2ae28a --- /dev/null +++ b/Presentation.Web/app/services/feature-toggle/feature-toggle-service.ts @@ -0,0 +1,26 @@ +module Kitos.Services.FeatureToggle { + + export interface IFeatureToggleService { + hasFeature(feature: TemporaryFeature): boolean + addFeature(feature: TemporaryFeature): void + } + + class FeatureToggleService implements IFeatureToggleService { + private readonly _ftState: Array; + + constructor() { + this._ftState = []; + } + + hasFeature(feature: TemporaryFeature): boolean { + return this._ftState.indexOf(feature) !== -1; + } + + addFeature(feature: TemporaryFeature): void { + this._ftState.push(feature); + } + } + + app.constant("featureToggleService", new FeatureToggleService()); + +} diff --git a/Presentation.Web/app/services/feature-toggle/temporary-feature.ts b/Presentation.Web/app/services/feature-toggle/temporary-feature.ts new file mode 100644 index 0000000000..f3297f7de0 --- /dev/null +++ b/Presentation.Web/app/services/feature-toggle/temporary-feature.ts @@ -0,0 +1,5 @@ +module Kitos.Services.FeatureToggle { + export enum TemporaryFeature { + FK_Organisation = "FK_Organisation" + } +} From b1f7e24ffd9fcc860a748e3207d230711645d79f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Morten=20Remb=C3=B8l=20Jacobsen?= Date: Fri, 30 Sep 2022 10:42:08 +0200 Subject: [PATCH 014/272] fixed --- Presentation.Web/Presentation.Web.csproj | 2 +- .../{sso-state-view-model.ts => feature-toggle-view-model.ts} | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) rename Presentation.Web/app/models/ViewModel/feature-toggle/{sso-state-view-model.ts => feature-toggle-view-model.ts} (79%) diff --git a/Presentation.Web/Presentation.Web.csproj b/Presentation.Web/Presentation.Web.csproj index 6e43f62882..234ad986ab 100644 --- a/Presentation.Web/Presentation.Web.csproj +++ b/Presentation.Web/Presentation.Web.csproj @@ -376,7 +376,7 @@ - + diff --git a/Presentation.Web/app/models/ViewModel/feature-toggle/sso-state-view-model.ts b/Presentation.Web/app/models/ViewModel/feature-toggle/feature-toggle-view-model.ts similarity index 79% rename from Presentation.Web/app/models/ViewModel/feature-toggle/sso-state-view-model.ts rename to Presentation.Web/app/models/ViewModel/feature-toggle/feature-toggle-view-model.ts index 3e44e514a8..2401165eee 100644 --- a/Presentation.Web/app/models/ViewModel/feature-toggle/sso-state-view-model.ts +++ b/Presentation.Web/app/models/ViewModel/feature-toggle/feature-toggle-view-model.ts @@ -1,6 +1,6 @@ module Kitos.Models.ViewModel.FeatureToggle { export interface IFeatureToggleViewModel { - featureToggle: string | null; + featureToggle: Kitos.Services.FeatureToggle.TemporaryFeature | null; } export class FeatureToggleViewModelFactory { @@ -10,7 +10,7 @@ } createFromViewState() { - let featureToggleValue: string | null = null; + let featureToggleValue: Kitos.Services.FeatureToggle.TemporaryFeature | null = null; const state = new Utility.ViewDataState(this.$); const featureToggleElement = state.getStateOrNull("feature-toggle"); From 5aa1bdc60bde09e0aff547c34f5e64a4b40e435a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Morten=20Remb=C3=B8l=20Jacobsen?= Date: Fri, 30 Sep 2022 11:55:41 +0200 Subject: [PATCH 015/272] cleanup backend and added migration for db cleanup --- .../HandleOrganizationBeingDeleted.cs | 11 - Core.DomainModel/Core.DomainModel.csproj | 1 - .../Organization/OrganizationUnit.cs | 8 - Core.DomainModel/Organization/TaskRef.cs | 6 - Core.DomainModel/Organization/TaskUsage.cs | 56 --- .../Organizations/OrgUnitService.cs | 13 +- .../Repositories/KLE/KLEStandardRepository.cs | 19 +- .../Infrastructure.DataAccess.csproj | 8 +- Infrastructure.DataAccess/KitosContext.cs | 2 - .../Mapping/TaskUsageMap.cs | 30 -- ...2209300954018_Remove_TaskUsage.Designer.cs | 29 ++ .../202209300954018_Remove_TaskUsage.cs | 55 +++ .../202209300954018_Remove_TaskUsage.resx | 126 +++++++ Presentation.Web/App_Start/MappingConfig.cs | 10 - .../API/V1/OrganizationUnitController.cs | 124 +------ .../Controllers/API/V1/TaskUsageController.cs | 328 ------------------ .../Organizations/OrganizationV2Controller.cs | 6 +- .../Models/API/V1/TaskRefUsageDTO.cs | 8 - .../Models/API/V1/TaskUsageDTO.cs | 16 - .../Models/API/V1/TaskUsageNestedDTO.cs | 32 -- .../OrganizationUnitResponseDTO.cs | 7 +- Presentation.Web/Presentation.Web.csproj | 4 - .../KLE/KleUpdateIntegrationTests.cs | 69 +--- .../V2/OrganizationUnitsApiV2Test.cs | 11 +- .../Tests.Integration.Presentation.Web.csproj | 1 - .../Tools/TaskUsageHelper.cs | 25 -- .../KLE/KLEStandardRepositoryTest.cs | 28 +- 27 files changed, 227 insertions(+), 806 deletions(-) delete mode 100644 Core.DomainModel/Organization/TaskUsage.cs delete mode 100644 Infrastructure.DataAccess/Mapping/TaskUsageMap.cs create mode 100644 Infrastructure.DataAccess/Migrations/202209300954018_Remove_TaskUsage.Designer.cs create mode 100644 Infrastructure.DataAccess/Migrations/202209300954018_Remove_TaskUsage.cs create mode 100644 Infrastructure.DataAccess/Migrations/202209300954018_Remove_TaskUsage.resx delete mode 100644 Presentation.Web/Controllers/API/V1/TaskUsageController.cs delete mode 100644 Presentation.Web/Models/API/V1/TaskRefUsageDTO.cs delete mode 100644 Presentation.Web/Models/API/V1/TaskUsageDTO.cs delete mode 100644 Presentation.Web/Models/API/V1/TaskUsageNestedDTO.cs delete mode 100644 Tests.Integration.Presentation.Web/Tools/TaskUsageHelper.cs diff --git a/Core.ApplicationServices/Organizations/Handlers/HandleOrganizationBeingDeleted.cs b/Core.ApplicationServices/Organizations/Handlers/HandleOrganizationBeingDeleted.cs index f108c8d0a0..5e03e8a82e 100644 --- a/Core.ApplicationServices/Organizations/Handlers/HandleOrganizationBeingDeleted.cs +++ b/Core.ApplicationServices/Organizations/Handlers/HandleOrganizationBeingDeleted.cs @@ -32,7 +32,6 @@ public class HandleOrganizationBeingDeleted : IDomainEventHandler _taskUsageRepository; private readonly IDomainEvents _domainEvents; public HandleOrganizationBeingDeleted( @@ -43,7 +42,6 @@ public HandleOrganizationBeingDeleted( IItInterfaceService interfaceService, IOrganizationService organizationService, IDefaultOrganizationResolver defaultOrganizationResolver, - IGenericRepository taskUsageRepository, IDomainEvents domainEvents) { _contractService = contractService; @@ -53,7 +51,6 @@ public HandleOrganizationBeingDeleted( _interfaceService = interfaceService; _organizationService = organizationService; _defaultOrganizationResolver = defaultOrganizationResolver; - _taskUsageRepository = taskUsageRepository; _domainEvents = domainEvents; } @@ -156,14 +153,6 @@ private void ClearLocalRegistrations(Organization organization) var dprs = organization.DataProcessingRegistrations.ToList(); dprs.ForEach(x => _dataProcessingRegistrationService.Delete(x.Id).ThrowOnFailure()); organization.DataProcessingRegistrations.Clear(); - - //Strip all task usages in the organization - foreach (var organizationUnit in organization.OrgUnits.ToList()) - { - _taskUsageRepository.RemoveRange(organizationUnit.TaskUsages.ToList()); - organizationUnit.TaskUsages.Clear(); - } - _taskUsageRepository.Save(); } private void ResolveRightsHolderConflicts(OrganizationRemovalConflicts conflicts, Organization organization) diff --git a/Core.DomainModel/Core.DomainModel.csproj b/Core.DomainModel/Core.DomainModel.csproj index 3e342b175c..e69e1300d1 100644 --- a/Core.DomainModel/Core.DomainModel.csproj +++ b/Core.DomainModel/Core.DomainModel.csproj @@ -238,7 +238,6 @@ - diff --git a/Core.DomainModel/Organization/OrganizationUnit.cs b/Core.DomainModel/Organization/OrganizationUnit.cs index de89420a8e..293e3b5588 100644 --- a/Core.DomainModel/Organization/OrganizationUnit.cs +++ b/Core.DomainModel/Organization/OrganizationUnit.cs @@ -14,7 +14,6 @@ public class OrganizationUnit : HasRightsEntity(); OwnedTasks = new List(); DefaultUsers = new List(); Using = new List(); @@ -42,13 +41,6 @@ public OrganizationUnit() /// The organization which the unit belongs to. /// public virtual Organization Organization { get; set; } - - /// - /// The usage of task on this Organization Unit. - /// Should be a subset of the TaskUsages of the parent department. - /// - public virtual ICollection TaskUsages { get; set; } - /// /// Local tasks that was created in this unit /// diff --git a/Core.DomainModel/Organization/TaskRef.cs b/Core.DomainModel/Organization/TaskRef.cs index 89726576d6..3e62d6f616 100644 --- a/Core.DomainModel/Organization/TaskRef.cs +++ b/Core.DomainModel/Organization/TaskRef.cs @@ -18,7 +18,6 @@ public TaskRef() this.ItSystems = new List(); this.ItSystemUsages = new List(); this.ItSystemUsagesOptOut = new List(); - this.Usages = new List(); } /// @@ -55,11 +54,6 @@ public TaskRef() public virtual TaskRef Parent { get; set; } public virtual ICollection Children { get; set; } - /// - /// Usages of this task - /// - public virtual ICollection Usages { get; set; } - /// /// ItSystems which have been marked with this task /// diff --git a/Core.DomainModel/Organization/TaskUsage.cs b/Core.DomainModel/Organization/TaskUsage.cs deleted file mode 100644 index 5ecf1dd9f1..0000000000 --- a/Core.DomainModel/Organization/TaskUsage.cs +++ /dev/null @@ -1,56 +0,0 @@ -using System.Collections.Generic; - -namespace Core.DomainModel.Organization -{ - /// - /// Represents that aTaskRef has been marked as important for an - /// OrganizationUnit. - /// Helper object which can hold comments and status property - /// - public class TaskUsage : Entity, IHierarchy, IOrganizationModule, ISupportsUserSpecificAccessControl - { - public TaskUsage() - { - Children = new List(); - } - - public int TaskRefId { get; set; } - /// - /// The task in use - /// - public virtual TaskRef TaskRef { get; set; } - - public int OrgUnitId { get; set; } - /// - /// The organization unit which uses the task - /// - public virtual OrganizationUnit OrgUnit { get; set; } - - public int? ParentId { get; set; } - /// - /// If the parent of also has marked the , - /// the parent usage is accesible from here. - /// - public virtual TaskUsage Parent { get; set; } - - /// - /// Child usages (see ) - /// - public virtual ICollection Children { get; set; } - - /// - /// Whether the TaskUsage can be found on the overview - /// - public bool Starred { get; set; } - - public TrafficLight TechnologyStatus { get; set; } - public TrafficLight UsageStatus { get; set; } - - public string Comment { get; set; } - - public bool HasUserWriteAccess(User user) - { - return OrgUnit != null && OrgUnit.HasUserWriteAccess(user); - } - } -} diff --git a/Core.DomainServices/Organizations/OrgUnitService.cs b/Core.DomainServices/Organizations/OrgUnitService.cs index 0c01a7c26a..291adf96c1 100644 --- a/Core.DomainServices/Organizations/OrgUnitService.cs +++ b/Core.DomainServices/Organizations/OrgUnitService.cs @@ -14,12 +14,10 @@ public class OrgUnitService : IOrgUnitService { private readonly IGenericRepository _orgUnitRepository; private readonly IGenericRepository _itSystemUsageOrgUnitUsageRepository; - private readonly IGenericRepository _taskUsageRepository; - public OrgUnitService(IGenericRepository orgUnitRepository, IGenericRepository taskUsageRepository, IGenericRepository itSystemUsageOrgUnitUsageRepository) + public OrgUnitService(IGenericRepository orgUnitRepository, IGenericRepository itSystemUsageOrgUnitUsageRepository) { _orgUnitRepository = orgUnitRepository; - _taskUsageRepository = taskUsageRepository; _itSystemUsageOrgUnitUsageRepository = itSystemUsageOrgUnitUsageRepository; } @@ -91,15 +89,6 @@ public bool IsAncestorOf(int unitId, int ancestorId) public void Delete(int id) { - // delete task usages - var taskUsages = _taskUsageRepository.Get(x => x.OrgUnitId == id); - foreach (var taskUsage in taskUsages) - { - _taskUsageRepository.DeleteByKey(taskUsage.Id); - } - _taskUsageRepository.Save(); - - // Remove OrgUnit from ItSystemUsages var itSystemUsageOrgUnitUsages = _itSystemUsageOrgUnitUsageRepository.Get(x => x.OrganizationUnitId == id); foreach (var itSystemUsage in itSystemUsageOrgUnitUsages) diff --git a/Core.DomainServices/Repositories/KLE/KLEStandardRepository.cs b/Core.DomainServices/Repositories/KLE/KLEStandardRepository.cs index db4fa80f1b..18770fa2ae 100644 --- a/Core.DomainServices/Repositories/KLE/KLEStandardRepository.cs +++ b/Core.DomainServices/Repositories/KLE/KLEStandardRepository.cs @@ -23,7 +23,6 @@ public class KLEStandardRepository : IKLEStandardRepository private readonly ITransactionManager _transactionManager; private readonly IGenericRepository _existingTaskRefRepository; private readonly IGenericRepository _systemUsageRepository; - private readonly IGenericRepository _taskUsageRepository; private readonly IKLEParentHelper _kleParentHelper; private readonly IKLEConverterHelper _kleConverterHelper; private readonly ILogger _logger; @@ -34,10 +33,9 @@ public KLEStandardRepository( ITransactionManager transactionManager, IGenericRepository existingTaskRefRepository, IGenericRepository systemUsageRepository, - IGenericRepository taskUsageRepository, IOperationClock clock, ILogger logger, - IDomainEvents domainEvents) : this(new KLEParentHelper(), new KLEConverterHelper(clock), taskUsageRepository) + IDomainEvents domainEvents) : this(new KLEParentHelper(), new KLEConverterHelper(clock)) { _kleDataBridge = kleDataBridge; _transactionManager = transactionManager; @@ -47,11 +45,10 @@ public KLEStandardRepository( _domainEvents = domainEvents; } - private KLEStandardRepository(IKLEParentHelper kleParentHelper, IKLEConverterHelper kleConverterHelper, IGenericRepository taskUsageRepository) + private KLEStandardRepository(IKLEParentHelper kleParentHelper, IKLEConverterHelper kleConverterHelper) { _kleParentHelper = kleParentHelper; _kleConverterHelper = kleConverterHelper; - _taskUsageRepository = taskUsageRepository; } public KLEStatus GetKLEStatus(Maybe lastUpdated) @@ -186,7 +183,6 @@ private void UpdateRemovedTaskRefs(IEnumerable changes) RemoveSystemUsageOptOutTaskRefs(kleChange); } RemoveSystemUsageTaskRefs(removals); - RemoveTaskUsageTaskRef(removals); RemoveTaskRef(removals); } @@ -235,17 +231,6 @@ private void RemoveSystemUsageTaskRefs(List kleChanges) } } - private void RemoveTaskUsageTaskRef(IEnumerable kleChanges) - { - var keys = kleChanges.Select(x => x.TaskKey).ToList(); - var taskUsages = _taskUsageRepository - .GetWithReferencePreload(t => t.TaskRef) - .Where(t => keys.Contains(t.TaskRef.TaskKey)) - .ToList(); - - _taskUsageRepository.RemoveRange(taskUsages); - } - private void RemoveTaskRef(IEnumerable kleChanges) { var removedTaskKeys = kleChanges diff --git a/Infrastructure.DataAccess/Infrastructure.DataAccess.csproj b/Infrastructure.DataAccess/Infrastructure.DataAccess.csproj index 2f5dedaf37..3c3375b943 100644 --- a/Infrastructure.DataAccess/Infrastructure.DataAccess.csproj +++ b/Infrastructure.DataAccess/Infrastructure.DataAccess.csproj @@ -134,7 +134,6 @@ - @@ -935,6 +934,10 @@ 202209270528087_Add_Expiration_to_itsystemoverview.cs + + + 202209300954018_Remove_TaskUsage.cs + @@ -1558,6 +1561,9 @@ 202209270528087_Add_Expiration_to_itsystemoverview.cs + + 202209300954018_Remove_TaskUsage.cs + diff --git a/Infrastructure.DataAccess/KitosContext.cs b/Infrastructure.DataAccess/KitosContext.cs index 3b3d6a5999..498c2c7ff4 100644 --- a/Infrastructure.DataAccess/KitosContext.cs +++ b/Infrastructure.DataAccess/KitosContext.cs @@ -80,7 +80,6 @@ public KitosContext(string nameOrConnectionString) public DbSet SensitiveDataTypes { get; set; } public DbSet TerminationDeadlineTypes { get; set; } public DbSet TaskRefs { get; set; } - public DbSet TaskUsages { get; set; } public DbSet Texts { get; set; } public DbSet Users { get; set; } public DbSet ArchivePeriods { get; set; } @@ -204,7 +203,6 @@ protected override void OnModelCreating(DbModelBuilder modelBuilder) modelBuilder.Configurations.Add(new PurchaseFormTypeMap()); modelBuilder.Configurations.Add(new SensitiveDataTypeMap()); modelBuilder.Configurations.Add(new TaskRefMap()); - modelBuilder.Configurations.Add(new TaskUsageMap()); modelBuilder.Configurations.Add(new TextMap()); modelBuilder.Configurations.Add(new TerminationDeadlineTypeMap()); modelBuilder.Configurations.Add(new UserMap()); diff --git a/Infrastructure.DataAccess/Mapping/TaskUsageMap.cs b/Infrastructure.DataAccess/Mapping/TaskUsageMap.cs deleted file mode 100644 index 7cbb46db2b..0000000000 --- a/Infrastructure.DataAccess/Mapping/TaskUsageMap.cs +++ /dev/null @@ -1,30 +0,0 @@ -using Core.DomainModel; -using Core.DomainModel.Organization; - -namespace Infrastructure.DataAccess.Mapping -{ - public class TaskUsageMap : EntityMap - { - public TaskUsageMap() - { - // Properties - // Table & Column Mappings - this.ToTable("TaskUsage"); - - // Relationships - this.HasRequired(t => t.OrgUnit) - .WithMany(o => o.TaskUsages) - .HasForeignKey(t => t.OrgUnitId) - .WillCascadeOnDelete(false); - - this.HasRequired(t => t.TaskRef) - .WithMany(r => r.Usages) - .HasForeignKey(t => t.TaskRefId); - - this.HasOptional(t => t.Parent) - .WithMany(d => d.Children) - .HasForeignKey(t => t.ParentId) - .WillCascadeOnDelete(false); - } - } -} diff --git a/Infrastructure.DataAccess/Migrations/202209300954018_Remove_TaskUsage.Designer.cs b/Infrastructure.DataAccess/Migrations/202209300954018_Remove_TaskUsage.Designer.cs new file mode 100644 index 0000000000..49d3d78e2c --- /dev/null +++ b/Infrastructure.DataAccess/Migrations/202209300954018_Remove_TaskUsage.Designer.cs @@ -0,0 +1,29 @@ +// +namespace Infrastructure.DataAccess.Migrations +{ + using System.CodeDom.Compiler; + using System.Data.Entity.Migrations; + using System.Data.Entity.Migrations.Infrastructure; + using System.Resources; + + [GeneratedCode("EntityFramework.Migrations", "6.4.4")] + public sealed partial class Remove_TaskUsage : IMigrationMetadata + { + private readonly ResourceManager Resources = new ResourceManager(typeof(Remove_TaskUsage)); + + string IMigrationMetadata.Id + { + get { return "202209300954018_Remove_TaskUsage"; } + } + + string IMigrationMetadata.Source + { + get { return null; } + } + + string IMigrationMetadata.Target + { + get { return Resources.GetString("Target"); } + } + } +} diff --git a/Infrastructure.DataAccess/Migrations/202209300954018_Remove_TaskUsage.cs b/Infrastructure.DataAccess/Migrations/202209300954018_Remove_TaskUsage.cs new file mode 100644 index 0000000000..5c4847742d --- /dev/null +++ b/Infrastructure.DataAccess/Migrations/202209300954018_Remove_TaskUsage.cs @@ -0,0 +1,55 @@ +namespace Infrastructure.DataAccess.Migrations +{ + using System; + using System.Data.Entity.Migrations; + + public partial class Remove_TaskUsage : DbMigration + { + public override void Up() + { + DropForeignKey("dbo.TaskUsage", "LastChangedByUserId", "dbo.User"); + DropForeignKey("dbo.TaskUsage", "ObjectOwnerId", "dbo.User"); + DropForeignKey("dbo.TaskUsage", "OrgUnitId", "dbo.OrganizationUnit"); + DropForeignKey("dbo.TaskUsage", "ParentId", "dbo.TaskUsage"); + DropForeignKey("dbo.TaskUsage", "TaskRefId", "dbo.TaskRef"); + DropIndex("dbo.TaskUsage", new[] { "TaskRefId" }); + DropIndex("dbo.TaskUsage", new[] { "OrgUnitId" }); + DropIndex("dbo.TaskUsage", new[] { "ParentId" }); + DropIndex("dbo.TaskUsage", new[] { "ObjectOwnerId" }); + DropIndex("dbo.TaskUsage", new[] { "LastChangedByUserId" }); + DropTable("dbo.TaskUsage"); + } + + public override void Down() + { + CreateTable( + "dbo.TaskUsage", + c => new + { + Id = c.Int(nullable: false, identity: true), + TaskRefId = c.Int(nullable: false), + OrgUnitId = c.Int(nullable: false), + ParentId = c.Int(), + Starred = c.Boolean(nullable: false), + TechnologyStatus = c.Int(nullable: false), + UsageStatus = c.Int(nullable: false), + Comment = c.String(), + ObjectOwnerId = c.Int(nullable: false), + LastChanged = c.DateTime(nullable: false, precision: 7, storeType: "datetime2"), + LastChangedByUserId = c.Int(nullable: false), + }) + .PrimaryKey(t => t.Id); + + CreateIndex("dbo.TaskUsage", "LastChangedByUserId"); + CreateIndex("dbo.TaskUsage", "ObjectOwnerId"); + CreateIndex("dbo.TaskUsage", "ParentId"); + CreateIndex("dbo.TaskUsage", "OrgUnitId"); + CreateIndex("dbo.TaskUsage", "TaskRefId"); + AddForeignKey("dbo.TaskUsage", "TaskRefId", "dbo.TaskRef", "Id", cascadeDelete: true); + AddForeignKey("dbo.TaskUsage", "ParentId", "dbo.TaskUsage", "Id"); + AddForeignKey("dbo.TaskUsage", "OrgUnitId", "dbo.OrganizationUnit", "Id"); + AddForeignKey("dbo.TaskUsage", "ObjectOwnerId", "dbo.User", "Id"); + AddForeignKey("dbo.TaskUsage", "LastChangedByUserId", "dbo.User", "Id"); + } + } +} diff --git a/Infrastructure.DataAccess/Migrations/202209300954018_Remove_TaskUsage.resx b/Infrastructure.DataAccess/Migrations/202209300954018_Remove_TaskUsage.resx new file mode 100644 index 0000000000..417a156d9f --- /dev/null +++ b/Infrastructure.DataAccess/Migrations/202209300954018_Remove_TaskUsage.resx @@ -0,0 +1,126 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 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 + + + dbo + + \ No newline at end of file diff --git a/Presentation.Web/App_Start/MappingConfig.cs b/Presentation.Web/App_Start/MappingConfig.cs index ff5eb3b1e9..a74d40d12c 100644 --- a/Presentation.Web/App_Start/MappingConfig.cs +++ b/Presentation.Web/App_Start/MappingConfig.cs @@ -204,16 +204,6 @@ public MappingProfile() .ReverseMap() .IgnoreDestinationEntityFields(); - CreateMap() - .ForMember(dto => dto.HasDelegations, opt => opt.MapFrom(src => src.Children.Any())) - .ReverseMap() - .IgnoreDestinationEntityFields(); - - CreateMap() - .ForMember(dto => dto.HasDelegations, opt => opt.MapFrom(src => src.Children.Any())) - .ReverseMap() - .IgnoreDestinationEntityFields(); - CreateMap() .ReverseMap() .IgnoreDestinationEntityFields(); diff --git a/Presentation.Web/Controllers/API/V1/OrganizationUnitController.cs b/Presentation.Web/Controllers/API/V1/OrganizationUnitController.cs index 480869998f..6eafeec6fb 100644 --- a/Presentation.Web/Controllers/API/V1/OrganizationUnitController.cs +++ b/Presentation.Web/Controllers/API/V1/OrganizationUnitController.cs @@ -19,18 +19,15 @@ public class OrganizationUnitController : GenericHierarchyApiController _taskRepository; - private readonly IGenericRepository _taskUsageRepository; public OrganizationUnitController( IGenericRepository repository, IOrgUnitService orgUnitService, - IGenericRepository taskRepository, - IGenericRepository taskUsageRepository) + IGenericRepository taskRepository) : base(repository) { _orgUnitService = orgUnitService; _taskRepository = taskRepository; - _taskUsageRepository = taskUsageRepository; } public HttpResponseMessage Post(OrgUnitDTO dto) => base.Post(dto.OrganizationId, dto); @@ -149,125 +146,6 @@ public override HttpResponseMessage Patch(int id, int organizationId, JObject ob [NonAction] public override HttpResponseMessage Put(int id, int organizationId, JObject jObject) => throw new NotSupportedException(); - /// - /// Returns every task that a given OrgUnit can use. This depends on the task usages of the parent OrgUnit. - /// For every task returned, possibly a taskUsage is returned too, if the OrgUnit is currently using that task. - /// - /// ID of the OrgUnit - /// Optional id to filter by task group - /// Routing qualifier - /// Paging options - /// List of (task, taskUsage), where the taskUsage might be null - public HttpResponseMessage GetAccessibleTasks(int id, int? taskGroup, bool? tasks, [FromUri] PagingModel pagingModel) - { - try - { - var orgUnit = Repository.GetByKey(id); - - if (orgUnit == null) - return NotFound(); - - if (!AllowRead(orgUnit)) - return Forbidden(); - - IQueryable taskQuery; - // if the org unit has a parent, only select those tasks that is in use by the parent org unit - if (orgUnit.ParentId.HasValue) - { - // this is not so good performance wise - var orgUnitQueryable = Repository.AsQueryable().Where(unit => unit.Id == id); - taskQuery = orgUnitQueryable.SelectMany(u => u.Parent.TaskUsages.Select(usage => usage.TaskRef)); - - // it would have been better with: - // pagingModel.Where(taskRef => taskRef.Usages.Any(usage => usage.OrgUnitId == orgUnit.ParentId)); - // but we cant because of a bug in the mysql connector: http://bugs.mysql.com/bug.php?id=70722 - } - else - { - taskQuery = _taskRepository.AsQueryable(); - } - - // if a task group is given, only find the tasks in that group and sub groups - if (taskGroup.HasValue) - { - pagingModel.Where( - taskRef => - (taskRef.ParentId.Value == taskGroup.Value || - taskRef.Parent.ParentId.Value == taskGroup.Value) && - !taskRef.Children.Any()); - } - else - { - // else get all task leaves - pagingModel.Where(taskRef => !taskRef.Children.Any()); - } - - var theTasks = Page(taskQuery, pagingModel).ToList(); - - // convert tasks to DTO containing both the task and possibly also a taskUsage, if that exists - var dtos = (from taskRef in theTasks - let taskUsage = taskRef.Usages.FirstOrDefault(usage => usage.OrgUnitId == id) - select new TaskRefUsageDTO() - { - TaskRef = Map(taskRef), - Usage = Map(taskUsage) - }).ToList(); // must call .ToList here else the output will be wrapped in $type,$values - - return Ok(dtos); - } - catch (Exception e) - { - return LogError(e); - } - } - - /// - /// Returns the task usages of a given OrgUnit. - /// - /// ID of the OrgUnit - /// Optional id of a taskgroup - /// Routing qualifier - /// Paging options - /// List of (task, taskUsage) - public HttpResponseMessage GetTaskUsages(int id, int? taskGroup, bool? usages, - [FromUri] PagingModel pagingModel) - { - try - { - var organizationUnit = Repository.GetByKey(id); - if (organizationUnit == null) - return NotFound(); - - if (!AllowRead(organizationUnit)) - return Forbidden(); - - var usageQuery = _taskUsageRepository.AsQueryable(); - pagingModel.Where(usage => usage.OrgUnitId == id); - - // if a task group is given, only find the tasks in that group and sub groups - if (taskGroup.HasValue) - { - pagingModel.Where(taskUsage => taskUsage.TaskRef.ParentId.Value == taskGroup.Value || - taskUsage.TaskRef.Parent.ParentId.Value == taskGroup.Value); - } - - var theUsages = Page(usageQuery, pagingModel).ToList(); - - var dtos = (from usage in theUsages - select new TaskRefUsageDTO() - { - TaskRef = Map(usage.TaskRef), - Usage = Map(usage) - }).ToList(); // must call .ToList here else the output will be wrapped in $type,$values - - return Ok(dtos); - } - catch (Exception e) - { - return LogError(e); - } - } - protected override void DeleteQuery(OrganizationUnit entity) { _orgUnitService.Delete(entity.Id); diff --git a/Presentation.Web/Controllers/API/V1/TaskUsageController.cs b/Presentation.Web/Controllers/API/V1/TaskUsageController.cs deleted file mode 100644 index 6463451357..0000000000 --- a/Presentation.Web/Controllers/API/V1/TaskUsageController.cs +++ /dev/null @@ -1,328 +0,0 @@ -using System; -using System.Collections.Generic; -using System.Dynamic; -using System.IO; -using System.Linq; -using System.Net; -using System.Net.Http; -using System.Net.Http.Headers; -using System.Text; -using System.Web.Http; -using Core.ApplicationServices; -using Core.DomainModel.ItSystemUsage; -using Core.DomainModel.Organization; -using Core.DomainServices; -using Core.DomainServices.Authorization; -using Newtonsoft.Json.Linq; -using Presentation.Web.Infrastructure.Attributes; -using Presentation.Web.Infrastructure.Authorization.Controller.Crud; -using Presentation.Web.Models.API.V1; -using Swashbuckle.Swagger.Annotations; - -namespace Presentation.Web.Controllers.API.V1 -{ - [PublicApi] - public class TaskUsageController : GenericHierarchyApiController - { - private readonly IGenericRepository _orgUnitRepository; - private readonly IGenericRepository _taskRepository; - - public TaskUsageController( - IGenericRepository repository, - IGenericRepository orgUnitRepository, - IGenericRepository taskRepository) - : base(repository) - { - _orgUnitRepository = orgUnitRepository; - _taskRepository = taskRepository; - } - - protected override IControllerCrudAuthorization GetCrudAuthorization() - { - return new ChildEntityCrudAuthorization(x => _orgUnitRepository.GetByKey(x.OrgUnitId), base.GetCrudAuthorization()); - } - - [HttpGet] - [Route("api/taskUsage/")] - [SwaggerResponse(HttpStatusCode.OK, Type = typeof(ApiReturnDTO>))] - public HttpResponseMessage Get(int orgUnitId, int organizationId, bool onlyStarred, [FromUri] PagingModel pagingModel) - { - try - { - if (GetOrganizationReadAccessLevel(organizationId) < OrganizationDataReadAccessLevel.All) - { - return Forbidden(); - } - - pagingModel.Where(usage => usage.OrgUnitId == orgUnitId); - - if (onlyStarred) pagingModel.Where(usage => usage.Starred); - - var usages = Page(Repository.AsQueryable(), pagingModel).ToList(); - - var dtos = new List(); - - foreach (var taskUsage in usages) - { - var dto = Map(taskUsage); - dto.HasWriteAccess = AllowModify(taskUsage); - dto.SystemUsages = AssociatedSystemUsages(taskUsage); - dtos.Add(dto); - } - - return Ok(dtos); - } - catch (Exception e) - { - return LogError(e); - } - } - - [HttpPost] - [Route("api/taskUsage/taskGroup")] - public HttpResponseMessage PostTaskGroup(int orgUnitId, int? taskId) - { - try - { - var orgUnit = _orgUnitRepository.GetByKey(orgUnitId); - if (orgUnit == null) - return NotFound(); - List tasks; - if (taskId.HasValue) - { - // get child leaves of taskId that havn't got a usage in the org unit - tasks = _taskRepository.Get( - x => - (x.ParentId == taskId || x.Parent.ParentId == taskId) && !x.Children.Any() && - x.Usages.All(y => y.OrgUnitId != orgUnitId)).ToList(); - } - else - { - // no taskId was specified so get everything - tasks = _taskRepository.Get( - x => - !x.Children.Any() && - x.Usages.All(y => y.OrgUnitId != orgUnitId)).ToList(); - } - - if (!tasks.Any()) - return NotFound(); - - foreach (var task in tasks) - { - var taskUsage = new TaskUsage() - { - OrgUnitId = orgUnitId, - TaskRefId = task.Id, - }; - if (!AllowCreate(orgUnit.OrganizationId, taskUsage)) - { - return Forbidden(); - } - Repository.Insert(taskUsage); - } - Repository.Save(); - return Ok(); - } - catch (Exception e) - { - return LogError(e); - } - } - - [NonAction] - public override HttpResponseMessage Post(int organizationId, TaskUsageDTO taskUsageDto) => throw new NotSupportedException(); - - [HttpPost] - [Route("api/taskUsage/")] - public HttpResponseMessage Post(CreateTaskUsageDTO taskUsageDto) - { - try - { - var item = new TaskUsage - { - TaskRefId = taskUsageDto.TaskRefId, - OrgUnitId = taskUsageDto.OrgUnitId, - }; - var organizationUnit = _orgUnitRepository.GetByKey(taskUsageDto.OrgUnitId); - if (organizationUnit == null) - { - return BadRequest("Invalid organizationId"); - } - if (!AllowCreate(organizationUnit.OrganizationId, item)) - { - return Forbidden(); - } - var savedItem = PostQuery(item); - - return Created(Map(savedItem), new Uri(Request.RequestUri + "/" + savedItem.Id)); - } - catch (Exception e) - { - // check if inner message is a duplicate, if so return conflict - if (e.InnerException?.InnerException != null) - { - if (e.InnerException.InnerException.Message.Contains("Duplicate entry")) - { - return Conflict(e.InnerException.InnerException.Message); - } - } - return LogError(e); - } - } - - [HttpDelete] - [Route("api/taskUsage/")] - public HttpResponseMessage DeleteTaskGroup(int orgUnitId, int? taskId) - { - try - { - var orgUnit = _orgUnitRepository.GetByKey(orgUnitId); - if (orgUnit == null) - return NotFound(); - - List taskUsages; - if (taskId.HasValue) - { - taskUsages = orgUnit.TaskUsages.Where( - taskUsage => taskUsage.TaskRef.ParentId == taskId || taskUsage.TaskRef.Parent.ParentId == taskId).ToList(); - } - else - { - // no taskId was specified so get everything - taskUsages = orgUnit.TaskUsages.ToList(); - } - - if (!taskUsages.Any()) - return NotFound(); - - foreach (var taskUsage in taskUsages) - { - if (!AllowDelete(taskUsage)) - { - return Forbidden(); - } - Repository.DeleteByKey(taskUsage.Id); - } - Repository.Save(); - return Ok(); - } - catch (Exception e) - { - return LogError(e); - } - } - - [HttpGet] - [Route("api/taskUsage/")] - public HttpResponseMessage GetExcel(bool? csv, int orgUnitId, bool onlyStarred) - { - try - { - var organizationUnit = _orgUnitRepository.GetByKey(orgUnitId); - - if (organizationUnit == null) - return NotFound(); - - if (!AllowRead(organizationUnit)) - return Forbidden(); - - var usages = Repository - .Get(usage => usage.OrgUnitId == orgUnitId && usage.Starred == onlyStarred); - - var dtos = new List(); - - foreach (var taskUsage in usages) - { - var dto = Map(taskUsage); - dto.SystemUsages = AssociatedSystemUsages(taskUsage); - dtos.Add(dto); - } - - var list = new List(); - var header = new ExpandoObject() as IDictionary; - header.Add("OrgUnit", "Organisationsenhed"); - header.Add("KLEID", "KLE ID"); - header.Add("KLENavn", "KLE Navn"); - header.Add("Teknologi", "Teknologi"); - header.Add("Anvendelse", "Anvendelse"); - header.Add("Kommentar", "Kommentar"); - header.Add("System", "IT System"); - list.Add(header); - - // Adding via recursive method so that children are - // placed directly after their parent in the output - Action addUsageToList = null; - addUsageToList = elem => - { - var obj = new ExpandoObject() as IDictionary; - obj.Add("OrgUnit", elem.OrgUnitName); - obj.Add("KLEID", elem.TaskRefTaskKey); - obj.Add("KLENavn", elem.TaskRefDescription); - obj.Add("Teknologi", elem.TechnologyStatus); - obj.Add("Anvendelse", elem.UsageStatus); - obj.Add("Kommentar", elem.Comment); - obj.Add("System", String.Join(",", elem.SystemUsages.Select(x => x.ItSystemName))); - list.Add(obj); - foreach (var child in elem.Children) - { - addUsageToList(child); // recursive call - } - }; - - foreach (var usage in dtos) - { - addUsageToList(usage); - } - var s = list.ToCsv(); - var bytes = Encoding.Unicode.GetBytes(s); - var stream = new MemoryStream(); - stream.Write(bytes, 0, bytes.Length); - stream.Seek(0, SeekOrigin.Begin); - - var result = new HttpResponseMessage(HttpStatusCode.OK); - result.Content = new StreamContent(stream); - result.Content.Headers.ContentType = new MediaTypeHeaderValue("text/csv"); - result.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment") { FileNameStar = "organisationsoverblik.csv", DispositionType = "ISO-8859-1" }; - return result; - } - catch (Exception e) - { - return LogError(e); - } - } - - protected override TaskUsage PostQuery(TaskUsage item) - { - var orgUnit = _orgUnitRepository.GetByKey(item.OrgUnitId); - - if (orgUnit.ParentId != null) - { - var parentUsage = orgUnit.Parent.TaskUsages.First(usage => usage.TaskRefId == item.TaskRefId); - item.Parent = parentUsage; - } - - return base.PostQuery(item); - } - - public override HttpResponseMessage Put(int id, int organizationId, JObject jObject) - { - return NotAllowed(); - } - - private IEnumerable AssociatedSystemUsages(TaskUsage taskUsage) - { - var indirectUsages = - taskUsage.TaskRef.ItSystems.SelectMany(system => system.Usages) - .Where(usage => usage.OrganizationId == taskUsage.OrgUnit.OrganizationId); - - var directUsages = - taskUsage.TaskRef.ItSystemUsages.Where( - usage => usage.OrganizationId == taskUsage.OrgUnit.OrganizationId); - - var allUsages = indirectUsages.Union(directUsages); - - return Map, IEnumerable>(allUsages); - } - } -} diff --git a/Presentation.Web/Controllers/API/V2/External/Organizations/OrganizationV2Controller.cs b/Presentation.Web/Controllers/API/V2/External/Organizations/OrganizationV2Controller.cs index f8bb514e12..9ad6034056 100644 --- a/Presentation.Web/Controllers/API/V2/External/Organizations/OrganizationV2Controller.cs +++ b/Presentation.Web/Controllers/API/V2/External/Organizations/OrganizationV2Controller.cs @@ -251,11 +251,7 @@ private static OrganizationUnitResponseDTO ToOrganizationUnitResponseDto(Organiz Name = unit.Name, UnitId = unit.LocalId, Ean = unit.Ean, - ParentOrganizationUnit = unit.Parent?.Transform(parent => parent.MapIdentityNamePairDTO()), - Kle = unit - .TaskUsages - .Select(taskUsage => taskUsage.TaskRef.MapIdentityNamePairDTO()) - .ToList() + ParentOrganizationUnit = unit.Parent?.Transform(parent => parent.MapIdentityNamePairDTO()) }; } private OrganizationUserResponseDTO ToUserResponseDTO((Guid organizationUuid, User user) context) diff --git a/Presentation.Web/Models/API/V1/TaskRefUsageDTO.cs b/Presentation.Web/Models/API/V1/TaskRefUsageDTO.cs deleted file mode 100644 index 7d08870483..0000000000 --- a/Presentation.Web/Models/API/V1/TaskRefUsageDTO.cs +++ /dev/null @@ -1,8 +0,0 @@ -namespace Presentation.Web.Models.API.V1 -{ - public class TaskRefUsageDTO - { - public TaskRefDTO TaskRef { get; set; } - public TaskUsageDTO Usage { get; set; } - } -} diff --git a/Presentation.Web/Models/API/V1/TaskUsageDTO.cs b/Presentation.Web/Models/API/V1/TaskUsageDTO.cs deleted file mode 100644 index 47ae9d2567..0000000000 --- a/Presentation.Web/Models/API/V1/TaskUsageDTO.cs +++ /dev/null @@ -1,16 +0,0 @@ -namespace Presentation.Web.Models.API.V1 -{ - public class TaskUsageDTO - { - public int Id { get; set; } - public int TaskRefId { get; set; } - public int OrgUnitId { get; set; } - - public bool Starred { get; set; } - public int TechnologyStatus { get; set; } - public int UsageStatus { get; set; } - public string Comment { get; set; } - - public bool HasDelegations { get; set; } - } -} diff --git a/Presentation.Web/Models/API/V1/TaskUsageNestedDTO.cs b/Presentation.Web/Models/API/V1/TaskUsageNestedDTO.cs deleted file mode 100644 index 63242b0499..0000000000 --- a/Presentation.Web/Models/API/V1/TaskUsageNestedDTO.cs +++ /dev/null @@ -1,32 +0,0 @@ -using System.Collections.Generic; - -namespace Presentation.Web.Models.API.V1 -{ - public class TaskUsageNestedDTO - { - public TaskUsageNestedDTO() - { - // initializing selfmade properites to avoid null exceptions - SystemUsages = new List(); - } - public int Id { get; set; } - - public int TaskRefId { get; set; } - public string TaskRefTaskKey { get; set; } - public string TaskRefDescription { get; set; } - - public int OrgUnitId { get; set; } - public string OrgUnitName { get; set; } - - public bool Starred { get; set; } - public int TechnologyStatus { get; set; } - public int UsageStatus { get; set; } - public string Comment { get; set; } - - public IEnumerable Children { get; set; } - public bool HasDelegations { get; set; } - - public IEnumerable SystemUsages { get; set; } - public bool HasWriteAccess { get; set; } - } -} diff --git a/Presentation.Web/Models/API/V2/Response/Organization/OrganizationUnitResponseDTO.cs b/Presentation.Web/Models/API/V2/Response/Organization/OrganizationUnitResponseDTO.cs index 64c2d65cb2..4316f3389c 100644 --- a/Presentation.Web/Models/API/V2/Response/Organization/OrganizationUnitResponseDTO.cs +++ b/Presentation.Web/Models/API/V2/Response/Organization/OrganizationUnitResponseDTO.cs @@ -1,5 +1,4 @@ -using System.Collections.Generic; -using Presentation.Web.Models.API.V2.Response.Generic.Identity; +using Presentation.Web.Models.API.V2.Response.Generic.Identity; namespace Presentation.Web.Models.API.V2.Response.Organization { @@ -10,10 +9,6 @@ public class OrganizationUnitResponseDTO : IdentityNamePairResponseDTO /// public IdentityNamePairResponseDTO ParentOrganizationUnit { get; set; } /// - /// Kle relevant for the organization unit - /// - public IEnumerable Kle { get; set; } - /// /// Optional EAN number for the organization unit. /// public long? Ean { get; set; } diff --git a/Presentation.Web/Presentation.Web.csproj b/Presentation.Web/Presentation.Web.csproj index 234ad986ab..d2d6e66fcc 100644 --- a/Presentation.Web/Presentation.Web.csproj +++ b/Presentation.Web/Presentation.Web.csproj @@ -1047,7 +1047,6 @@ - @@ -1084,10 +1083,7 @@ - - - diff --git a/Tests.Integration.Presentation.Web/KLE/KleUpdateIntegrationTests.cs b/Tests.Integration.Presentation.Web/KLE/KleUpdateIntegrationTests.cs index bcbb2b9d45..d39cc1bb93 100644 --- a/Tests.Integration.Presentation.Web/KLE/KleUpdateIntegrationTests.cs +++ b/Tests.Integration.Presentation.Web/KLE/KleUpdateIntegrationTests.cs @@ -153,28 +153,6 @@ public async Task Put_Removes_Obsoleted_TaskRefs_And_Patches_Uuids_And_Adds_Any_ }); #endregion root - #region organization - //Add some task in organization units refs which we expect to be removed - MutateDatabase(db => - { - using (var taskUsages = new GenericRepository(db)) - using (var taskRefs = new GenericRepository(db)) - { - var other = taskRefs.AsQueryable().First(); - var objectOwnerId = other.ObjectOwnerId; - var organizationUnitId = other.OwnedByOrganizationUnitId; - var taskRef1 = taskRefs.Insert(CreateTaskRef(objectOwnerId, organizationUnitId)); - var taskRef2 = taskRefs.Insert(CreateTaskRef(objectOwnerId, organizationUnitId)); - taskRefs.Save(); - - //Add usages which we expect to be removed - taskUsages.Insert(CreateTaskUsage(taskRef1, objectOwnerId, organizationUnitId)); - taskUsages.Insert(CreateTaskUsage(taskRef2, objectOwnerId, organizationUnitId)); - taskUsages.Save(); - } - }); - #endregion organization - #region systems var system1Dto = await ItSystemHelper.CreateItSystemInOrganizationAsync(A(), TestEnvironment.DefaultOrganizationId, AccessModifier.Public); @@ -335,19 +313,6 @@ private static void VerifyTaskRefIntegrity(IReadOnlyList } } - private static void VerifyTaskUsageIntegrity(IReadOnlyList expectedUsages) - { - var actualTaskRefs = BuildTaskUsageIntegritySet().ToList(); - Assert.Equal(expectedUsages.Count, actualTaskRefs.Count); - - for (var i = 0; i < actualTaskRefs.Count; i++) - { - var expected = expectedUsages[i]; - var actual = actualTaskRefs[i]; - expected.ToExpectedObject().ShouldMatch(actual); - } - } - private static void VerifyTaskRefUsageKeys(IReadOnlyList expectedKeys, IReadOnlyList actualKeys) { Assert.Equal(expectedKeys.Count, actualKeys.Count); @@ -369,18 +334,6 @@ private static IEnumerable BuildTaskRefIntegritySet() .ToList()); } - private static IEnumerable BuildTaskUsageIntegritySet() - { - return MapFromEntitySet>( - repository => - repository - .AsQueryable() - .ToList() - .Select(MapIntegrityInput) - .OrderBy(x => x.TaskRefId) - .ToList()); - } - private static TaskRefIntegrityInput MapIntegrityInput(TaskRef arg) { return new TaskRefIntegrityInput @@ -392,15 +345,6 @@ private static TaskRefIntegrityInput MapIntegrityInput(TaskRef arg) }; } - private static TaskUsageIntegrityInput MapIntegrityInput(TaskUsage arg) - { - return new TaskUsageIntegrityInput - { - Id = arg.Id, - TaskRefId = arg.TaskRef?.TaskKey ?? throw new InvalidOperationException("Unable to load task key of parent") - }; - } - private static IEnumerable FlattenTreeDepthFirst(TaskRef root) { var children = new List(); @@ -466,7 +410,7 @@ private static async Task PrepareForDetailedTest() ResetKleHistory(); } - private TaskRef CreateTaskRef(int? objectOwnerId, int organizationUnitId) + private static TaskRef CreateTaskRef(int? objectOwnerId, int organizationUnitId) { if (TestKeys.TryPop(out var nextKey)) { @@ -482,17 +426,6 @@ private TaskRef CreateTaskRef(int? objectOwnerId, int organizationUnitId) throw new InvalidOperationException("Unable to get more keys"); } - private static TaskUsage CreateTaskUsage(TaskRef taskRef1, int? objectOwnerId, int organizationUnitId) - { - return new() - { - TaskRefId = taskRef1.Id, - LastChangedByUserId = objectOwnerId, - ObjectOwnerId = objectOwnerId, - OrgUnitId = organizationUnitId - }; - } - private static void ResetKleHistory() { using var kleRepo = new GenericRepository(TestEnvironment.GetDatabase()); diff --git a/Tests.Integration.Presentation.Web/Organizations/V2/OrganizationUnitsApiV2Test.cs b/Tests.Integration.Presentation.Web/Organizations/V2/OrganizationUnitsApiV2Test.cs index e4798d06d7..a997ecd987 100644 --- a/Tests.Integration.Presentation.Web/Organizations/V2/OrganizationUnitsApiV2Test.cs +++ b/Tests.Integration.Presentation.Web/Organizations/V2/OrganizationUnitsApiV2Test.cs @@ -24,16 +24,11 @@ public async Task GET_OrganizationUnits() //Arrange var organization = await CreateOrganizationAsync(); var taskRef = DatabaseAccess.MapFromEntitySet(refs => refs.AsQueryable().First()); - var rootUnitId = DatabaseAccess.MapFromEntitySet(units => units.AsQueryable().ByOrganizationId(organization.Id).First(x => x.ParentId == null).Id); var (_, token) = await CreateApiUser(organization); var unit1 = await OrganizationHelper.CreateOrganizationUnitRequestAsync(organization.Id, CreateName()); var unit1_1 = await OrganizationHelper.CreateOrganizationUnitRequestAsync(organization.Id, CreateName(), unit1.Id); var unit2 = await OrganizationHelper.CreateOrganizationUnitRequestAsync(organization.Id, CreateName()); - //Task ref must be set on the parent for the using to be available on children - await TaskUsageHelper.CreateTaskUsageAsync(rootUnitId, taskRef.Id); - await TaskUsageHelper.CreateTaskUsageAsync(unit2.Id, taskRef.Id); - //Act var units = (await OrganizationUnitV2Helper.GetOrganizationUnitsAsync(token, organization.Uuid)).ToList(); @@ -41,7 +36,6 @@ public async Task GET_OrganizationUnits() Assert.Equal(4, units.Count); //Organizational hierarchy always contains at least 1 (the root created with the organization and then comes the user defined units) var root = Assert.Single(units.Where(x => x.Name == organization.Name)); Assert.Null(root.ParentOrganizationUnit); - Assert.NotNull(root.Kle.SingleOrDefault(x => x.Uuid == taskRef.Uuid)); AssertCreatedOrganizationUnit(units, unit1, (root.Uuid, root.Name)); AssertCreatedOrganizationUnit(units, unit1_1, (unit1.Uuid, unit1.Name)); AssertCreatedOrganizationUnit(units, unit2, (root.Uuid, root.Name), taskRef); @@ -183,16 +177,15 @@ private string CreateEmail() private static void AssertCreatedOrganizationUnit(IEnumerable allUnits, OrgUnitDTO expectedUnit, (Guid Uuid, string Name) expectedRoot, params TaskRef[] kle) { var dto = Assert.Single(allUnits.Where(x => x.Uuid == expectedUnit.Uuid)); - AssertCreatedOrganizationUnit(dto, expectedUnit, expectedRoot, kle); + AssertCreatedOrganizationUnit(dto, expectedUnit, expectedRoot); } - private static void AssertCreatedOrganizationUnit(OrganizationUnitResponseDTO dto, OrgUnitDTO expectedUnit, (Guid Uuid, string Name) expectedRoot, params TaskRef[] kle) + private static void AssertCreatedOrganizationUnit(OrganizationUnitResponseDTO dto, OrgUnitDTO expectedUnit, (Guid Uuid, string Name) expectedRoot) { Assert.Equal(expectedRoot.Uuid, dto.ParentOrganizationUnit?.Uuid); Assert.Equal(expectedRoot.Name, dto.ParentOrganizationUnit?.Name); Assert.Equal(expectedUnit.Ean, dto.Ean); Assert.Equal(expectedUnit.LocalId, dto.UnitId); - Assert.Equal(kle.Select(x => (x.Uuid, x.TaskKey)), dto.Kle.Select(x => (x.Uuid, x.Name))); } } } diff --git a/Tests.Integration.Presentation.Web/Tests.Integration.Presentation.Web.csproj b/Tests.Integration.Presentation.Web/Tests.Integration.Presentation.Web.csproj index f079b03948..476d63bb58 100644 --- a/Tests.Integration.Presentation.Web/Tests.Integration.Presentation.Web.csproj +++ b/Tests.Integration.Presentation.Web/Tests.Integration.Presentation.Web.csproj @@ -217,7 +217,6 @@ - diff --git a/Tests.Integration.Presentation.Web/Tools/TaskUsageHelper.cs b/Tests.Integration.Presentation.Web/Tools/TaskUsageHelper.cs deleted file mode 100644 index bf4734b8ba..0000000000 --- a/Tests.Integration.Presentation.Web/Tools/TaskUsageHelper.cs +++ /dev/null @@ -1,25 +0,0 @@ -using System.Net; -using System.Threading.Tasks; -using Presentation.Web.Models; -using Presentation.Web.Models.API.V1; -using Xunit; - -namespace Tests.Integration.Presentation.Web.Tools -{ - public static class TaskUsageHelper - { - public static async Task CreateTaskUsageAsync(int organizationUnitId, int taskRefId, Cookie optionalCookie = null) - { - var cookie = optionalCookie ?? await HttpApi.GetCookieAsync(Core.DomainModel.Organization.OrganizationRole.GlobalAdmin); - var body = new CreateTaskUsageDTO - { - TaskRefId = taskRefId, - OrgUnitId = organizationUnitId - }; - - using var response = await HttpApi.PostWithCookieAsync(TestEnvironment.CreateUrl("api/taskUsage"), cookie, body); - Assert.Equal(HttpStatusCode.Created, response.StatusCode); - return await response.ReadResponseBodyAsKitosApiResponseAsync(); - } - } -} diff --git a/Tests.Unit.Core.ApplicationServices/ApplicationServices/KLE/KLEStandardRepositoryTest.cs b/Tests.Unit.Core.ApplicationServices/ApplicationServices/KLE/KLEStandardRepositoryTest.cs index f43a7ec91d..e28a3381c5 100644 --- a/Tests.Unit.Core.ApplicationServices/ApplicationServices/KLE/KLEStandardRepositoryTest.cs +++ b/Tests.Unit.Core.ApplicationServices/ApplicationServices/KLE/KLEStandardRepositoryTest.cs @@ -25,7 +25,6 @@ public class KLEStandardRepositoryTest private readonly Mock _mockTransactionManager; private readonly Mock _mockLogger; private readonly Mock> _mockSystemUsageRepository; - private readonly Mock> _mockTaskUsageRepository; private readonly Mock _mockClock; private readonly Mock _mockDomainEvent; private readonly GenericRepositoryTaskRefStub _stubTaskRefRepository; @@ -37,12 +36,11 @@ public KLEStandardRepositoryTest() _mockTransactionManager = new Mock(); _mockLogger = new Mock(); _mockSystemUsageRepository = new Mock>(); - _mockTaskUsageRepository = new Mock>(); _mockDomainEvent = new Mock(); _stubTaskRefRepository = new GenericRepositoryTaskRefStub(); _mockClock = new Mock(); _mockClock.Setup(c => c.Now).Returns(DateTime.Now); - _sut = new KLEStandardRepository(_mockKleDataBridge.Object, _mockTransactionManager.Object, _stubTaskRefRepository, _mockSystemUsageRepository.Object, _mockTaskUsageRepository.Object, _mockClock.Object, _mockLogger.Object, _mockDomainEvent.Object); + _sut = new KLEStandardRepository(_mockKleDataBridge.Object, _mockTransactionManager.Object, _stubTaskRefRepository, _mockSystemUsageRepository.Object, _mockClock.Object, _mockLogger.Object, _mockDomainEvent.Object); } [Theory] @@ -214,30 +212,6 @@ public void UpdateKLE_Given_Summary_Updates_ItSystemUsageOptOut() Assert.False(itSystemUsage.TaskRefs.Contains(updateObjects.removedTaskRef)); } - [Fact] - public void UpdateKLE_Given_Summary_Updates_TaskUsage() - { - //Arrange - var updateObjects = SetupUpdateObjects(); - const int taskUsageKey = 1; - var taskUsage = new TaskUsage - { - Id = taskUsageKey, - TaskRef = updateObjects.removedTaskRef - }; - var taskUsages = new List { taskUsage }; - _mockTaskUsageRepository - .Setup(s => s.GetWithReferencePreload(t => t.TaskRef)) - .Returns(taskUsages.AsQueryable); - _mockTaskUsageRepository.Setup(s => s.RemoveRange(taskUsages)); - - //Act - _sut.UpdateKLE(0); - - //Assert - _mockTaskUsageRepository.VerifyAll(); - } - #region Helpers private ( From ae4818e1db88a89a13eb34789a796a535d64d466 Mon Sep 17 00:00:00 2001 From: Aleksander Naskret Date: Fri, 30 Sep 2022 13:09:35 +0200 Subject: [PATCH 016/272] Anonymize deleted user name --- Core.ApplicationServices/UserService.cs | 2 +- Core.DomainModel/User.cs | 1 - .../Infrastructure.DataAccess.csproj | 7 + ...217_RemovedEmailBeforeDeletion.Designer.cs | 29 ++++ ...209301046217_RemovedEmailBeforeDeletion.cs | 23 ++++ ...9301046217_RemovedEmailBeforeDeletion.resx | 126 ++++++++++++++++++ .../Users/UserTest.cs | 2 +- 7 files changed, 187 insertions(+), 3 deletions(-) create mode 100644 Infrastructure.DataAccess/Migrations/202209301046217_RemovedEmailBeforeDeletion.Designer.cs create mode 100644 Infrastructure.DataAccess/Migrations/202209301046217_RemovedEmailBeforeDeletion.cs create mode 100644 Infrastructure.DataAccess/Migrations/202209301046217_RemovedEmailBeforeDeletion.resx diff --git a/Core.ApplicationServices/UserService.cs b/Core.ApplicationServices/UserService.cs index f9289a23e9..05bc1c3178 100644 --- a/Core.ApplicationServices/UserService.cs +++ b/Core.ApplicationServices/UserService.cs @@ -334,7 +334,7 @@ public Maybe DeleteUserFromKitos(Guid userUuid) private static void Delete(User user) { user.LockedOutDate = DateTime.Now; - user.EmailBeforeDeletion = user.Email; + user.Name = "Slettet bruger"; user.Email = $"{Guid.NewGuid()}_deleted_user@kitos.dk"; user.PhoneNumber = null; user.LastName = $"{(user.LastName ?? "").TrimEnd()} (SLETTET)"; diff --git a/Core.DomainModel/User.cs b/Core.DomainModel/User.cs index c5c0f48da3..cb0dc93b1c 100644 --- a/Core.DomainModel/User.cs +++ b/Core.DomainModel/User.cs @@ -41,7 +41,6 @@ public User() public string Password { get; set; } public string Salt { get; set; } public DateTime? LastAdvisDate { get; set; } - public string EmailBeforeDeletion { get; set; } public DateTime? DeletedDate { get; set; } public bool Deleted { get; set; } diff --git a/Infrastructure.DataAccess/Infrastructure.DataAccess.csproj b/Infrastructure.DataAccess/Infrastructure.DataAccess.csproj index 2f5dedaf37..5f22166738 100644 --- a/Infrastructure.DataAccess/Infrastructure.DataAccess.csproj +++ b/Infrastructure.DataAccess/Infrastructure.DataAccess.csproj @@ -935,6 +935,10 @@ 202209270528087_Add_Expiration_to_itsystemoverview.cs + + + 202209301046217_RemovedEmailBeforeDeletion.cs + @@ -1558,6 +1562,9 @@ 202209270528087_Add_Expiration_to_itsystemoverview.cs + + 202209301046217_RemovedEmailBeforeDeletion.cs + diff --git a/Infrastructure.DataAccess/Migrations/202209301046217_RemovedEmailBeforeDeletion.Designer.cs b/Infrastructure.DataAccess/Migrations/202209301046217_RemovedEmailBeforeDeletion.Designer.cs new file mode 100644 index 0000000000..939cc51aae --- /dev/null +++ b/Infrastructure.DataAccess/Migrations/202209301046217_RemovedEmailBeforeDeletion.Designer.cs @@ -0,0 +1,29 @@ +// +namespace Infrastructure.DataAccess.Migrations +{ + using System.CodeDom.Compiler; + using System.Data.Entity.Migrations; + using System.Data.Entity.Migrations.Infrastructure; + using System.Resources; + + [GeneratedCode("EntityFramework.Migrations", "6.4.4")] + public sealed partial class RemovedEmailBeforeDeletion : IMigrationMetadata + { + private readonly ResourceManager Resources = new ResourceManager(typeof(RemovedEmailBeforeDeletion)); + + string IMigrationMetadata.Id + { + get { return "202209301046217_RemovedEmailBeforeDeletion"; } + } + + string IMigrationMetadata.Source + { + get { return null; } + } + + string IMigrationMetadata.Target + { + get { return Resources.GetString("Target"); } + } + } +} diff --git a/Infrastructure.DataAccess/Migrations/202209301046217_RemovedEmailBeforeDeletion.cs b/Infrastructure.DataAccess/Migrations/202209301046217_RemovedEmailBeforeDeletion.cs new file mode 100644 index 0000000000..e257444adc --- /dev/null +++ b/Infrastructure.DataAccess/Migrations/202209301046217_RemovedEmailBeforeDeletion.cs @@ -0,0 +1,23 @@ +namespace Infrastructure.DataAccess.Migrations +{ + using System; + using System.Data.Entity.Migrations; + + public partial class RemovedEmailBeforeDeletion : DbMigration + { + public override void Up() + { + DropColumn("dbo.User", "EmailBeforeDeletion"); + Sql(@" + UPDATE ""User"" + SET Name = 'Slettet bruger' + WHERE Deleted = 1;" + ); + } + + public override void Down() + { + AddColumn("dbo.User", "EmailBeforeDeletion", c => c.String()); + } + } +} diff --git a/Infrastructure.DataAccess/Migrations/202209301046217_RemovedEmailBeforeDeletion.resx b/Infrastructure.DataAccess/Migrations/202209301046217_RemovedEmailBeforeDeletion.resx new file mode 100644 index 0000000000..c87b2a6315 --- /dev/null +++ b/Infrastructure.DataAccess/Migrations/202209301046217_RemovedEmailBeforeDeletion.resx @@ -0,0 +1,126 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 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 + + + dbo + + \ No newline at end of file diff --git a/Tests.Integration.Presentation.Web/Users/UserTest.cs b/Tests.Integration.Presentation.Web/Users/UserTest.cs index 3068754036..aa6eb52031 100644 --- a/Tests.Integration.Presentation.Web/Users/UserTest.cs +++ b/Tests.Integration.Presentation.Web/Users/UserTest.cs @@ -162,7 +162,7 @@ public async Task Delete_User() Assert.Contains("_deleted_user@kitos.dk", user.Email); Assert.Contains("(SLETTET)", user.LastName); - Assert.Equal(originalEmail, user.EmailBeforeDeletion); + Assert.Equal("Slettet bruger", user.Name); Assert.NotNull(user.LockedOutDate); Assert.NotNull(user.DeletedDate); Assert.Null(user.PhoneNumber); From 21861e31cef69b8155d474bde64a54624e1f5b19 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Morten=20Remb=C3=B8l=20Jacobsen?= Date: Fri, 30 Sep 2022 13:13:56 +0200 Subject: [PATCH 017/272] updated ui --- Core.DomainModel/Config.cs | 6 - .../Infrastructure.DataAccess.csproj | 10 +- .../202209300954018_Remove_TaskUsage.resx | 126 --------- ...209301050100_Remove_TaskUsage.Designer.cs} | 2 +- ...cs => 202209301050100_Remove_TaskUsage.cs} | 43 ++-- .../202209301050100_Remove_TaskUsage.resx | 126 +++++++++ .../Models/API/V1/CreateTaskUsageDTO.cs | 8 - Presentation.Web/Presentation.Web.csproj | 8 - .../PageObjects/Organization/UsersPage.po.ts | 2 +- Presentation.Web/app/Constants/Constants.ts | 2 +- .../local-config-current-org.view.html | 28 -- .../components/org/org-subnav.controller.ts | 4 - .../org-overview-modal-comment.view.html | 28 -- .../org-overview-task-foldout-leaf.view.html | 40 --- .../org-overview-task-foldout-node.view.html | 48 ---- .../org/overview/org-overview-usage.view.html | 105 -------- .../org/overview/org-overview.controller.ts | 242 ------------------ .../org/overview/org-overview.view.html | 46 ---- .../org/structure/org-structure.controller.ts | 155 +---------- .../org/structure/org-structure.view.html | 85 ------ Presentation.Web/app/models/config.ts | 3 - .../models/organization/organization-unit.ts | 2 - Presentation.Web/app/models/task-ref.ts | 2 - Presentation.Web/app/models/task-usage.ts | 20 -- .../navigation-authorized.view.html | 3 +- .../KLE/TaskUsageIntegrityInput.cs | 8 - .../LocalAdminArea/LocalConfigTest.cs | 6 - .../Tests.Integration.Presentation.Web.csproj | 1 - 28 files changed, 164 insertions(+), 995 deletions(-) delete mode 100644 Infrastructure.DataAccess/Migrations/202209300954018_Remove_TaskUsage.resx rename Infrastructure.DataAccess/Migrations/{202209300954018_Remove_TaskUsage.Designer.cs => 202209301050100_Remove_TaskUsage.Designer.cs} (92%) rename Infrastructure.DataAccess/Migrations/{202209300954018_Remove_TaskUsage.cs => 202209301050100_Remove_TaskUsage.cs} (57%) create mode 100644 Infrastructure.DataAccess/Migrations/202209301050100_Remove_TaskUsage.resx delete mode 100644 Presentation.Web/Models/API/V1/CreateTaskUsageDTO.cs delete mode 100644 Presentation.Web/app/components/org/overview/org-overview-modal-comment.view.html delete mode 100644 Presentation.Web/app/components/org/overview/org-overview-task-foldout-leaf.view.html delete mode 100644 Presentation.Web/app/components/org/overview/org-overview-task-foldout-node.view.html delete mode 100644 Presentation.Web/app/components/org/overview/org-overview-usage.view.html delete mode 100644 Presentation.Web/app/components/org/overview/org-overview.controller.ts delete mode 100644 Presentation.Web/app/components/org/overview/org-overview.view.html delete mode 100644 Presentation.Web/app/models/task-usage.ts delete mode 100644 Tests.Integration.Presentation.Web/KLE/TaskUsageIntegrityInput.cs diff --git a/Core.DomainModel/Config.cs b/Core.DomainModel/Config.cs index 26c84c1072..efc0e1c582 100644 --- a/Core.DomainModel/Config.cs +++ b/Core.DomainModel/Config.cs @@ -19,9 +19,6 @@ public class Config : Entity, IIsPartOfOrganization /* IT SUPPORT */ public int ItSupportModuleNameId { get; set; } public string ItSupportGuide { get; set; } - public bool ShowTabOverview { get; set; } - public bool ShowColumnTechnology { get; set; } - public bool ShowColumnUsage { get; set; } public virtual Organization.Organization Organization { get; set; } @@ -33,9 +30,6 @@ public static Config Default(User objectOwner) ShowItSystemModule = true, ShowItContractPrefix = true, ShowItSystemPrefix = true, - ShowColumnTechnology = true, - ShowColumnUsage = true, - ShowTabOverview = true, ShowDataProcessing = true, ObjectOwner = objectOwner, LastChangedByUser = objectOwner diff --git a/Infrastructure.DataAccess/Infrastructure.DataAccess.csproj b/Infrastructure.DataAccess/Infrastructure.DataAccess.csproj index 3c3375b943..3026dff852 100644 --- a/Infrastructure.DataAccess/Infrastructure.DataAccess.csproj +++ b/Infrastructure.DataAccess/Infrastructure.DataAccess.csproj @@ -934,9 +934,9 @@ 202209270528087_Add_Expiration_to_itsystemoverview.cs - - - 202209300954018_Remove_TaskUsage.cs + + + 202209301050100_Remove_TaskUsage.cs @@ -1561,8 +1561,8 @@ 202209270528087_Add_Expiration_to_itsystemoverview.cs - - 202209300954018_Remove_TaskUsage.cs + + 202209301050100_Remove_TaskUsage.cs diff --git a/Infrastructure.DataAccess/Migrations/202209300954018_Remove_TaskUsage.resx b/Infrastructure.DataAccess/Migrations/202209300954018_Remove_TaskUsage.resx deleted file mode 100644 index 417a156d9f..0000000000 --- a/Infrastructure.DataAccess/Migrations/202209300954018_Remove_TaskUsage.resx +++ /dev/null @@ -1,126 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - text/microsoft-resx - - - 2.0 - - - System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - - - System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - - - 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 - - - dbo - - \ No newline at end of file diff --git a/Infrastructure.DataAccess/Migrations/202209300954018_Remove_TaskUsage.Designer.cs b/Infrastructure.DataAccess/Migrations/202209301050100_Remove_TaskUsage.Designer.cs similarity index 92% rename from Infrastructure.DataAccess/Migrations/202209300954018_Remove_TaskUsage.Designer.cs rename to Infrastructure.DataAccess/Migrations/202209301050100_Remove_TaskUsage.Designer.cs index 49d3d78e2c..84e42fb702 100644 --- a/Infrastructure.DataAccess/Migrations/202209300954018_Remove_TaskUsage.Designer.cs +++ b/Infrastructure.DataAccess/Migrations/202209301050100_Remove_TaskUsage.Designer.cs @@ -13,7 +13,7 @@ public sealed partial class Remove_TaskUsage : IMigrationMetadata string IMigrationMetadata.Id { - get { return "202209300954018_Remove_TaskUsage"; } + get { return "202209301050100_Remove_TaskUsage"; } } string IMigrationMetadata.Source diff --git a/Infrastructure.DataAccess/Migrations/202209300954018_Remove_TaskUsage.cs b/Infrastructure.DataAccess/Migrations/202209301050100_Remove_TaskUsage.cs similarity index 57% rename from Infrastructure.DataAccess/Migrations/202209300954018_Remove_TaskUsage.cs rename to Infrastructure.DataAccess/Migrations/202209301050100_Remove_TaskUsage.cs index 5c4847742d..3f34f58143 100644 --- a/Infrastructure.DataAccess/Migrations/202209300954018_Remove_TaskUsage.cs +++ b/Infrastructure.DataAccess/Migrations/202209301050100_Remove_TaskUsage.cs @@ -2,7 +2,7 @@ { using System; using System.Data.Entity.Migrations; - + public partial class Remove_TaskUsage : DbMigration { public override void Up() @@ -17,29 +17,40 @@ public override void Up() DropIndex("dbo.TaskUsage", new[] { "ParentId" }); DropIndex("dbo.TaskUsage", new[] { "ObjectOwnerId" }); DropIndex("dbo.TaskUsage", new[] { "LastChangedByUserId" }); + DropColumn("dbo.Config", "ShowTabOverview"); + DropColumn("dbo.Config", "ShowColumnTechnology"); + DropColumn("dbo.Config", "ShowColumnUsage"); DropTable("dbo.TaskUsage"); + + //Fix old preferences + Sql(@" UPDATE dbo.[User] + SET DefaultUserStartPreference = 'organization.structure' + WHERE DefaultUserStartPreference = 'organization.overview';"); } - + public override void Down() { CreateTable( "dbo.TaskUsage", c => new - { - Id = c.Int(nullable: false, identity: true), - TaskRefId = c.Int(nullable: false), - OrgUnitId = c.Int(nullable: false), - ParentId = c.Int(), - Starred = c.Boolean(nullable: false), - TechnologyStatus = c.Int(nullable: false), - UsageStatus = c.Int(nullable: false), - Comment = c.String(), - ObjectOwnerId = c.Int(nullable: false), - LastChanged = c.DateTime(nullable: false, precision: 7, storeType: "datetime2"), - LastChangedByUserId = c.Int(nullable: false), - }) + { + Id = c.Int(nullable: false, identity: true), + TaskRefId = c.Int(nullable: false), + OrgUnitId = c.Int(nullable: false), + ParentId = c.Int(), + Starred = c.Boolean(nullable: false), + TechnologyStatus = c.Int(nullable: false), + UsageStatus = c.Int(nullable: false), + Comment = c.String(), + ObjectOwnerId = c.Int(nullable: false), + LastChanged = c.DateTime(nullable: false, precision: 7, storeType: "datetime2"), + LastChangedByUserId = c.Int(nullable: false), + }) .PrimaryKey(t => t.Id); - + + AddColumn("dbo.Config", "ShowColumnUsage", c => c.Boolean(nullable: false)); + AddColumn("dbo.Config", "ShowColumnTechnology", c => c.Boolean(nullable: false)); + AddColumn("dbo.Config", "ShowTabOverview", c => c.Boolean(nullable: false)); CreateIndex("dbo.TaskUsage", "LastChangedByUserId"); CreateIndex("dbo.TaskUsage", "ObjectOwnerId"); CreateIndex("dbo.TaskUsage", "ParentId"); diff --git a/Infrastructure.DataAccess/Migrations/202209301050100_Remove_TaskUsage.resx b/Infrastructure.DataAccess/Migrations/202209301050100_Remove_TaskUsage.resx new file mode 100644 index 0000000000..a55bcb9a80 --- /dev/null +++ b/Infrastructure.DataAccess/Migrations/202209301050100_Remove_TaskUsage.resx @@ -0,0 +1,126 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 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 + + + dbo + + \ No newline at end of file diff --git a/Presentation.Web/Models/API/V1/CreateTaskUsageDTO.cs b/Presentation.Web/Models/API/V1/CreateTaskUsageDTO.cs deleted file mode 100644 index b316b71858..0000000000 --- a/Presentation.Web/Models/API/V1/CreateTaskUsageDTO.cs +++ /dev/null @@ -1,8 +0,0 @@ -namespace Presentation.Web.Models.API.V1 -{ - public class CreateTaskUsageDTO - { - public int TaskRefId { get; set; } - public int OrgUnitId { get; set; } - } -} \ No newline at end of file diff --git a/Presentation.Web/Presentation.Web.csproj b/Presentation.Web/Presentation.Web.csproj index d2d6e66fcc..0453e1d94c 100644 --- a/Presentation.Web/Presentation.Web.csproj +++ b/Presentation.Web/Presentation.Web.csproj @@ -687,7 +687,6 @@ - @@ -1414,13 +1413,8 @@ - - - - - @@ -1465,7 +1459,6 @@ - @@ -1512,7 +1505,6 @@ - diff --git a/Presentation.Web/Tests/PageObjects/Organization/UsersPage.po.ts b/Presentation.Web/Tests/PageObjects/Organization/UsersPage.po.ts index df8e48e6ea..fcda1393f3 100644 --- a/Presentation.Web/Tests/PageObjects/Organization/UsersPage.po.ts +++ b/Presentation.Web/Tests/PageObjects/Organization/UsersPage.po.ts @@ -31,7 +31,7 @@ class UsersPage implements IPageObject { "it-system.catalog", "it-contract.overview", "data-processing.overview", - "organization.overview" + "organization.structure" ].map(x => x.replace(".", "_")); } } diff --git a/Presentation.Web/app/Constants/Constants.ts b/Presentation.Web/app/Constants/Constants.ts index bd2cd83b3e..55b32682c6 100644 --- a/Presentation.Web/app/Constants/Constants.ts +++ b/Presentation.Web/app/Constants/Constants.ts @@ -6,7 +6,7 @@ static readonly SystemCatalog = "it-system.catalog"; static readonly ContractOverview = "it-contract.overview"; static readonly DataProcessingRegistrationOverview = "data-processing.overview"; - static readonly OrganizationOverview = "organization.overview"; + static readonly OrganizationOverview = "organization.structure"; static readonly InterfaceCatalog = "it-system.interfaceCatalog"; } diff --git a/Presentation.Web/app/components/local-config/local-config-current-org.view.html b/Presentation.Web/app/components/local-config/local-config-current-org.view.html index b7fc8155f9..35cea992e0 100644 --- a/Presentation.Web/app/components/local-config/local-config-current-org.view.html +++ b/Presentation.Web/app/components/local-config/local-config-current-org.view.html @@ -24,31 +24,3 @@
-
-
- -
-
- -
-
- -
-
- -
-
-
-
-
diff --git a/Presentation.Web/app/components/org/org-subnav.controller.ts b/Presentation.Web/app/components/org/org-subnav.controller.ts index c77bf0643d..4cf65ad5b8 100644 --- a/Presentation.Web/app/components/org/org-subnav.controller.ts +++ b/Presentation.Web/app/components/org/org-subnav.controller.ts @@ -22,10 +22,6 @@ var subnav = []; - if (user.currentConfig.showTabOverview) { - subnav.push({ state: 'organization.overview', text: 'Overblik' }); - } - subnav.push({ state: 'organization.structure', text: 'Organisation' }); subnav.push({ state: 'organization.user', text: 'Brugere' }); subnav.push({ state: 'organization.gdpr', text: 'Stamdata' }); diff --git a/Presentation.Web/app/components/org/overview/org-overview-modal-comment.view.html b/Presentation.Web/app/components/org/overview/org-overview-modal-comment.view.html deleted file mode 100644 index 0116567fe2..0000000000 --- a/Presentation.Web/app/components/org/overview/org-overview-modal-comment.view.html +++ /dev/null @@ -1,28 +0,0 @@ - - - diff --git a/Presentation.Web/app/components/org/overview/org-overview-task-foldout-leaf.view.html b/Presentation.Web/app/components/org/overview/org-overview-task-foldout-leaf.view.html deleted file mode 100644 index 5b274e7735..0000000000 --- a/Presentation.Web/app/components/org/overview/org-overview-task-foldout-leaf.view.html +++ /dev/null @@ -1,40 +0,0 @@ -
- -
- {{ indent(usage.level) }} - - {{ usage.orgUnitName }} -
- - -
-
- -
-
- -
-
- - -
-
- - -
-
diff --git a/Presentation.Web/app/components/org/overview/org-overview-task-foldout-node.view.html b/Presentation.Web/app/components/org/overview/org-overview-task-foldout-node.view.html deleted file mode 100644 index 8c86cb1c4b..0000000000 --- a/Presentation.Web/app/components/org/overview/org-overview-task-foldout-node.view.html +++ /dev/null @@ -1,48 +0,0 @@ -
-
-
- {{ indent(usage.level) }} - - - {{ usage.orgUnitName }} - -
- -
-
-
-
- - -
-
- -
-
-
- -
-
-
-
-
-
-
-
-
-
-
diff --git a/Presentation.Web/app/components/org/overview/org-overview-usage.view.html b/Presentation.Web/app/components/org/overview/org-overview-usage.view.html deleted file mode 100644 index 532353b54d..0000000000 --- a/Presentation.Web/app/components/org/overview/org-overview-usage.view.html +++ /dev/null @@ -1,105 +0,0 @@ -
- -
- - {{ usage.orgUnitName }} -
- - -
{{ usage.taskRefTaskKey }}
-
{{ usage.taskRefDescription }}
- - -
-
- -
-
- -
-
- - -
-
- - -
- - - -
-
- -
-
- - - - -
{{ usage.taskRefTaskKey }}
-
{{ usage.taskRefDescription }}
- - -
-
-
- -
- - -
-
- - -
- - - -
-
- - -
-
-
-
-
-
-
-
-
-
-
diff --git a/Presentation.Web/app/components/org/overview/org-overview.controller.ts b/Presentation.Web/app/components/org/overview/org-overview.controller.ts deleted file mode 100644 index bd98a3ec8a..0000000000 --- a/Presentation.Web/app/components/org/overview/org-overview.controller.ts +++ /dev/null @@ -1,242 +0,0 @@ -(function(ng, app) { - function indent(level) { - var result = ""; - for (var i = 0; i < level; i++) result += "....."; - - return result; - }; - - app.config([ - '$stateProvider', function($stateProvider) { - $stateProvider.state('organization.overview', { - url: '/overview', - templateUrl: 'app/components/org/overview/org-overview.view.html', - controller: 'org.OverviewCtrl', - resolve: { - orgUnits: [ - '$http', 'user', function ($http, user) { - return $http.get('api/organizationUnit?organization=' + user.currentOrganizationId).then(function (result) { - var options: Kitos.Models.ViewModel.Generic.Select2OptionViewModelWithIndentation[] = []; - - function visit(orgUnit: Kitos.Models.Api.Organization.OrganizationUnit, indentationLevel: number) { - var option = { - id: String(orgUnit.id), - text: orgUnit.name, - indentationLevel: indentationLevel - }; - - options.push(option); - - _.each(orgUnit.children, function (child) { - return visit(child, indentationLevel + 1); - }); - - } - visit(result.data.response, 0); - return options; - }); - } - ], - } - }); - } - ]); - - app.controller('org.OverviewCtrl', [ - '$rootScope', '$scope', '$http', '$uibModal', 'user', "orgUnits", - function ($rootScope, $scope, $http, $modal, user, orgUnits: Kitos.Models.ViewModel.Generic.Select2OptionViewModelWithIndentation[]) { - - $scope.orgUnits = orgUnits; - $scope.allowClear = false; - - $rootScope.page.title = 'Organisation - Overblik'; - - function checkForDefaultUnit() { - if (!user.currentOrganizationUnitId) return; - - var selectedDefaultOrganization = _.find($scope.orgUnits, (orgUnit) => orgUnit.id === String(user.currentOrganizationUnitId)); - if (selectedDefaultOrganization !== undefined) { - $scope.orgUnitId = user.currentOrganizationUnitId; - } - } - checkForDefaultUnit(); - - $scope.pagination = { - skip: 0, - take: 10, - orderBy: 'taskRef.taskKey' - }; - - $scope.csvUrl = 'api/taskusage/?csv&orgUnitId=' + $scope.orgUnitId + '&onlyStarred=true' + '&orgUnitId=' + user.currentOrganizationId; - - $scope.$watchCollection('pagination', function() { - loadUsages(); - }); - - /* load task usages */ - function loadUsages() { - if (!$scope.orgUnitId) return; - if (!$scope.orgUnitId.id) return; - - var url = 'api/taskusage/?orgUnitId=' + $scope.orgUnitId.id + '&onlyStarred=true' + '&organizationId=' + user.currentOrganizationId; - - url += '&skip=' + $scope.pagination.skip; - url += '&take=' + $scope.pagination.take; - - if ($scope.pagination.orderBy) { - url += '&orderBy=' + $scope.pagination.orderBy; - if ($scope.pagination.descending) url += '&descending=' + $scope.pagination.descending; - } - - $http.get(url) - .then(function onSuccess(result) { - var paginationHeader = JSON.parse(result.headers('X-Pagination')); - $scope.totalCount = paginationHeader.TotalCount; - $scope.taskUsages = result.data.response; - - /* visit every task usage and delegation */ - function visit(usage, parent, level) { - usage.updateUrl = 'api/taskUsage/' + usage.id; - usage.parent = parent; - usage.level = level; - - if (parent) usage.hasWriteAccess = parent.hasWriteAccess; - - /* if this task hasn't been delegated, it's a leaf. A leaf can select and update the statuses - * at which point we need to update the parents statuses as well - */ - if (!usage.hasDelegations) { - $scope.$watch(function() { return usage.technologyStatus; }, function(newVal, oldVal) { - updateTechStatus(usage); - }); - $scope.$watch(function() { return usage.usageStatus; }, function(newVal, oldVal) { - updateUsageStatus(usage); - }); - } - - /* visit children */ - _.each(usage.children, function(child) { - visit(child, usage, level + 1); - }); - } - - /* each of these are root usages */ - _.each($scope.taskUsages, function(usage: { isRoot }) { - usage.isRoot = true; - - visit(usage, null, 0); - - updateTechStatus(usage); - updateUsageStatus(usage); - }); - }); - }; - - $scope.loadUsages = loadUsages; - - function updateTechStatus(usage) { - if (usage.parent) { - updateTechStatus(usage.parent); - } else { - calculateTechStatus(usage); - } - }; - - function updateUsageStatus(usage) { - if (usage.parent) { - updateUsageStatus(usage.parent); - } else { - calculateUsageStatus(usage); - } - }; - - /* helper function to aggregate status-trafficlight */ - function addToStatusResult(status, result) { - if (status == 3) result.green++; - else if (status == 2) result.yellow++; - else if (status == 1) result.red++; - else result.white++; - - result.max++; - - return result; - } - - /* helper function to sum two status-trafficlights */ - function sumStatusResult(result1, result2) { - return { - max: result1.max + result2.max, - white: result1.white + result2.white, - red: result1.red + result2.red, - yellow: result1.yellow + result2.yellow, - green: result1.green + result2.green - }; - } - - function calculateTechStatus(usage) { - - /* this will hold the aggregated tech status of this node */ - var result = { - max: 0, - white: 0, - red: 0, - yellow: 0, - green: 0, - }; - - /* if the usage isn't delegated, the agg result is just this tech status */ - if (!usage.hasDelegations) { - result = addToStatusResult(usage.technologyStatus, result); - } else { - _.each(usage.children, function(child) { - var delegationResult = calculateTechStatus(child); - result = sumStatusResult(result, delegationResult); - }); - } - - usage.calculatedTechStatus = result; - - return result; - }; - - - function calculateUsageStatus(usage) { - var result = { - max: 0, - white: 0, - red: 0, - yellow: 0, - green: 0 - }; - - if (!usage.hasDelegations) { - return addToStatusResult(usage.usageStatus, result); - } - - _.each(usage.children, function(child) { - var delegationResult = calculateUsageStatus(child); - result = sumStatusResult(result, delegationResult); - }); - - usage.calculatedUsageStatus = result; - - return result; - }; - - $scope.indent = indent; - - $scope.openComment = function(usage) { - $modal.open({ - templateUrl: 'app/components/org/overview/org-overview-modal-comment.view.html', - controller: [ - '$scope', '$uibModalInstance', 'autofocus', function ($modalScope, $modalInstance, autofocus) { - autofocus(); - $modalScope.usage = usage; - $modalScope.hasWriteAccess = usage.hasWriteAccess; - } - ] - }); - }; - } - ]); -})(angular, app); diff --git a/Presentation.Web/app/components/org/overview/org-overview.view.html b/Presentation.Web/app/components/org/overview/org-overview.view.html deleted file mode 100644 index dd489d12bb..0000000000 --- a/Presentation.Web/app/components/org/overview/org-overview.view.html +++ /dev/null @@ -1,46 +0,0 @@ - - -
-
- - -
-
- KLE ID - -
-
- KLE Navn - -
-
-
- Digitaliseringsgrad -
-
- Teknologi - Anvendelse -
- -
-
IT System
-
- -
-
-
- -
- -
- - -  diff --git a/Presentation.Web/app/components/org/structure/org-structure.controller.ts b/Presentation.Web/app/components/org/structure/org-structure.controller.ts index 0d602af780..f31d70079b 100644 --- a/Presentation.Web/app/components/org/structure/org-structure.controller.ts +++ b/Presentation.Web/app/components/org/structure/org-structure.controller.ts @@ -33,8 +33,8 @@ ]); app.controller("org.StructureCtrl", [ - "$scope", "$http", "$q", "$filter", "$uibModal", "$state", "notify", "orgUnits", "localOrgUnitRoles", "orgUnitRoles", "user", "hasWriteAccess", "authorizationServiceFactory", "select2LoadingService", "inMemoryCacheService", - function ($scope, $http: ng.IHttpService, $q, $filter, $modal, $state, notify, orgUnits, localOrgUnitRoles, orgUnitRoles, user, hasWriteAccess, authorizationServiceFactory: Kitos.Services.Authorization.IAuthorizationServiceFactory, select2LoadingService: Kitos.Services.ISelect2LoadingService, inMemoryCacheService: Kitos.Shared.Caching.IInMemoryCacheService) { + "$scope", "$http", "$uibModal", "$state", "notify", "orgUnits", "localOrgUnitRoles", "orgUnitRoles", "user", "hasWriteAccess", "authorizationServiceFactory", "select2LoadingService", "inMemoryCacheService", + function ($scope, $http: ng.IHttpService, $modal, $state, notify, orgUnits, localOrgUnitRoles, orgUnitRoles, user, hasWriteAccess, authorizationServiceFactory: Kitos.Services.Authorization.IAuthorizationServiceFactory, select2LoadingService: Kitos.Services.ISelect2LoadingService, inMemoryCacheService: Kitos.Shared.Caching.IInMemoryCacheService) { $scope.orgId = user.currentOrganizationId; $scope.pagination = { skip: 0, @@ -157,7 +157,6 @@ }; loadRights(node); - loadTasks(); }; function loadRights(node) { @@ -570,160 +569,10 @@ }); }; - $scope.$watch("selectedTaskGroup", function (newVal, oldVal) { - $scope.pagination.skip = 0; - loadTasks(); - }); - - $scope.$watchCollection("pagination", loadTasks); $scope.$watchCollection("rightsPagination", function () { loadRights($scope.chosenOrgUnit); }); - // default kle mode - $scope.showAllTasks = true; - // default kle sort order - $scope.pagination.orderBy = "taskKey"; - - // change between show all tasks and only show active tasks - $scope.changeTaskView = function () { - $scope.showAllTasks = !$scope.showAllTasks; - $scope.pagination.orderBy = $scope.showAllTasks ? "taskKey" : "taskRef.taskKey"; - $scope.pagination.skip = 0; - loadTasks(); - }; - - function loadTasks() { - if (!$scope.chosenOrgUnit) return; - - var url = "api/organizationUnit/" + $scope.chosenOrgUnit.id; - - if ($scope.showAllTasks) url += "?tasks"; - else url += "?usages"; - - url += "&taskGroup=" + $scope.selectedTaskGroup; - url += "&skip=" + $scope.pagination.skip + "&take=" + $scope.pagination.take; - - if ($scope.pagination.orderBy) { - url += "&orderBy=" + $scope.pagination.orderBy; - if ($scope.pagination.descending) url += "&descending=" + $scope.pagination.descending; - } - - $http.get>(url).then((result) => { - $scope.taskRefUsageList = result.data.response; - - var paginationHeader = JSON.parse(result.headers("X-Pagination")); - $scope.totalCount = paginationHeader.TotalCount; - decorateTasks(); - }, (error) => { - notify.addErrorMessage("Kunne ikke hente opgaver!"); - }); - } - - function addUsage(refUsage, showMessage) { - if (showMessage) var msg = notify.addInfoMessage("Opretter tilknytning...", false); - - const url = `api/taskUsage`; - - const payload = { - taskRefId: refUsage.taskRef.id, - orgUnitId: $scope.chosenOrgUnit.id - }; - - $http.post>(url, payload).then((result) => { - refUsage.usage = result.data.response; - if (showMessage) msg.toSuccessMessage("Tilknytningen er oprettet"); - }, (error) => { - if (showMessage) msg.toErrorMessage("Fejl! Kunne ikke oprette tilknytningen!"); - }); - } - - function removeUsage(refUsage, showMessage) { - if (showMessage) var msg = notify.addInfoMessage("Fjerner tilknytning...", false); - - const url = `api/taskUsage/${refUsage.usage.id}?organizationId=${user.currentOrganizationId}`; - - $http.delete>(url).then((result) => { - refUsage.usage = null; - if (showMessage) msg.toSuccessMessage("Tilknytningen er fjernet"); - }, (error) => { - if (showMessage) msg.toErrorMessage("Fejl! Kunne ikke fjerne tilknytningen!"); - }); - } - - function decorateTasks() { - _.each($scope.taskRefUsageList, function (refUsage: { toggleUsage; usage; toggleStar; }) { - refUsage.toggleUsage = function () { - if (refUsage.usage) { - removeUsage(refUsage, true); - } else { - addUsage(refUsage, true); - } - }; - - refUsage.toggleStar = function () { - if (!refUsage.usage) return; - - var payload = { - starred: !refUsage.usage.starred - }; - - var url = "api/taskUsage/" + refUsage.usage.id; - var msg = notify.addInfoMessage("Opdaterer...", false); - $http>({ method: "PATCH", url: url + "?organizationId=" + user.currentOrganizationId, data: payload }).then(() => { - refUsage.usage.starred = !refUsage.usage.starred; - msg.toSuccessMessage("Feltet er opdateret"); - }, (error) => { - msg.toErrorMessage("Fejl!"); - }); - }; - }); - } - - $scope.selectAllTasks = function () { - _.each($scope.taskRefUsageList, function (refUsage: { usage }) { - if (!refUsage.usage) { - addUsage(refUsage, false); - } - }); - }; - - $scope.removeAllTasks = function () { - _.each($scope.taskRefUsageList, function (refUsage: { usage }) { - if (refUsage.usage) { - removeUsage(refUsage, false); - } - }); - }; - - $scope.selectTaskGroup = function () { - var url = "api/taskusage/taskGroup?orgUnitId=" + $scope.chosenOrgUnit.id + "&taskId=" + $scope.selectedTaskGroup; - - var msg = notify.addInfoMessage("Opretter tilknytning...", false); - $http.post>(url, null).then((result) => { - msg.toSuccessMessage("Tilknytningen er oprettet"); - reload(); - }, (error) => { - msg.toErrorMessage("Fejl! Kunne ikke oprette tilknytningen!"); - }); - }; - - $scope.removeTaskGroup = function () { - var url = "api/taskusage?orgUnitId=" + $scope.chosenOrgUnit.id + "&taskId=" + $scope.selectedTaskGroup; - - var msg = notify.addInfoMessage("Fjerner tilknytning...", false); - $http.delete>(url).then(() => { - msg.toSuccessMessage("Tilknytningen er fjernet"); - reload(); - }, (error) => { - msg.toErrorMessage("Fejl! Kunne ikke fjerne tilknytningen!"); - }); - }; - - function reload() { - $state.go(".", null, { reload: true }); - } - $scope.dragEnabled = false; $scope.toggleDrag = function () { diff --git a/Presentation.Web/app/components/org/structure/org-structure.view.html b/Presentation.Web/app/components/org/structure/org-structure.view.html index 4d0db05ccd..a3472cfc14 100644 --- a/Presentation.Web/app/components/org/structure/org-structure.view.html +++ b/Presentation.Web/app/components/org/structure/org-structure.view.html @@ -177,91 +177,6 @@

- -
-
- - Tilknyttede opgaver -
-
-
-
- - - - - - - - - - - - - - - - - - - - - - - - - - - - -
- - Vis alle - Vis valgte - - - KLE ID - - - KLE Navn - - OverblikDelegeret
- - - - - - - - - - - -
- - - - - - -
- -
-
diff --git a/Presentation.Web/app/models/config.ts b/Presentation.Web/app/models/config.ts index 62b83f16d3..4f55022aa3 100644 --- a/Presentation.Web/app/models/config.ts +++ b/Presentation.Web/app/models/config.ts @@ -6,9 +6,6 @@ ShowDataProcessing: boolean; ItSupportModuleNameId: number; ItSupportGuide: string; - ShowTabOverview: boolean; - ShowColumnTechnology: boolean; - ShowColumnUsage: boolean; Organization: IOrganization; } } diff --git a/Presentation.Web/app/models/organization/organization-unit.ts b/Presentation.Web/app/models/organization/organization-unit.ts index 5670010332..2b8176662f 100644 --- a/Presentation.Web/app/models/organization/organization-unit.ts +++ b/Presentation.Web/app/models/organization/organization-unit.ts @@ -12,8 +12,6 @@ OrganizationId: number; /** The organization which the unit belongs to. */ Organization: IOrganization; - /** The usage of task on this Organization Unit.Should be a subset of the TaskUsages of the parent department. */ - TaskUsages: Array; OwnedTasks: Array; /** Users which have set this as their default OrganizationUnit. */ DefaultUsers: Array; diff --git a/Presentation.Web/app/models/task-ref.ts b/Presentation.Web/app/models/task-ref.ts index 3826c1e8c3..bac602aa64 100644 --- a/Presentation.Web/app/models/task-ref.ts +++ b/Presentation.Web/app/models/task-ref.ts @@ -21,8 +21,6 @@ OwnedByOrganizationUnit: IOrganizationUnit; Parent: ITaskRef; Children: Array; - /** Usages of this task */ - Usages: Array; /** ItSystems which have been marked with this task */ ItSystems: Array; /** ItSystemUsages which have been marked with this task */ diff --git a/Presentation.Web/app/models/task-usage.ts b/Presentation.Web/app/models/task-usage.ts deleted file mode 100644 index cd7f9a8435..0000000000 --- a/Presentation.Web/app/models/task-usage.ts +++ /dev/null @@ -1,20 +0,0 @@ -module Kitos.Models { - export interface ITaskUsage extends IEntity { - TaskRefId: number; - /** The task in use */ - TaskRef: ITaskRef; - OrgUnitId: number; - /** The organization unit which uses the task */ - OrgUnit: IOrganizationUnit; - ParentId: number; - /** If the parent of also has marked the ,the parent usage is accesible from here. */ - Parent: ITaskUsage; - /** Child usages (see ) */ - Children: Array; - /** Whether the TaskUsage can be found on the overview */ - Starred: boolean; - TechnologyStatus: TrafficLight; - UsageStatus: TrafficLight; - Comment: string; - } -} diff --git a/Presentation.Web/app/shared/navigation/navigation-authorized.view.html b/Presentation.Web/app/shared/navigation/navigation-authorized.view.html index faa965b17c..1689771448 100644 --- a/Presentation.Web/app/shared/navigation/navigation-authorized.view.html +++ b/Presentation.Web/app/shared/navigation/navigation-authorized.view.html @@ -1,8 +1,7 @@  - Bemærk: Særlig rettighed der ikke bør kombineres med andre udover API adgang. + Bemærk: Særlig rettighed der ikke bør kombineres med andre udover "API bruger". @@ -85,11 +85,12 @@
- +
- Aktiverer mulighed for udstedelse af KITOS Tokens. + Aktiverer mulighed for udstedelse af KITOS Tokens.
+ Bemærk: Adgang til KITOS brugerfladen deaktiveres.
diff --git a/Presentation.Web/app/components/org/user/org-user-edit.modal.view.html b/Presentation.Web/app/components/org/user/org-user-edit.modal.view.html index f6acdf91d3..a4751ebfb2 100644 --- a/Presentation.Web/app/components/org/user/org-user-edit.modal.view.html +++ b/Presentation.Web/app/components/org/user/org-user-edit.modal.view.html @@ -66,7 +66,7 @@

Redigér bruger

- Bemærk: Særlig rettighed der ikke bør kombineres med andre udover API adgang. + Bemærk: Særlig rettighed der ikke bør kombineres med andre udover "API bruger".
@@ -76,11 +76,12 @@

Redigér bruger

- +
- Aktiverer mulighed for udstedelse af KITOS Tokens. + Aktiverer mulighed for udstedelse af KITOS Tokens.
+ Bemærk: Adgang til KITOS brugerfladen deaktiveres.
diff --git a/Presentation.Web/app/components/org/user/org-user.controller.ts b/Presentation.Web/app/components/org/user/org-user.controller.ts index 0a46b6aa37..8aab098d2b 100644 --- a/Presentation.Web/app/components/org/user/org-user.controller.ts +++ b/Presentation.Web/app/components/org/user/org-user.controller.ts @@ -319,7 +319,7 @@ }, { - field: "hasApi", title: "API adgang", width: 96, + field: "hasApi", title: "API bruger", width: 96, persistId: "apiaccess", attributes: { "class": "text-center", "data-element-type": "userObject" }, headerAttributes: { diff --git a/Tests.Integration.Presentation.Web/Security/AuthorizationTests.cs b/Tests.Integration.Presentation.Web/Security/AuthorizationTests.cs index dd0cd9ea68..3d81058d91 100644 --- a/Tests.Integration.Presentation.Web/Security/AuthorizationTests.cs +++ b/Tests.Integration.Presentation.Web/Security/AuthorizationTests.cs @@ -37,6 +37,16 @@ public async Task Api_Access_User_Can_Get_Token() Assert.False(string.IsNullOrWhiteSpace(tokenResponse.Token)); } + [Fact] + public async Task Api_Access_User_Cannot_Get_Cookie() + { + //Act + using var cookieResponse = await HttpApi.SendGetCookieAsync(_regularApiUser); + + //Assert + Assert.Equal(HttpStatusCode.Unauthorized, cookieResponse.StatusCode); + } + [Fact] public async Task User_Without_Api_Access_Can_Not_Get_Token() { @@ -55,8 +65,8 @@ public async Task User_Without_Api_Access_Can_Not_Get_Token() public async Task Get_Token_Returns_401_On_Invalid_Password() { //Arrange - var loginDto = ObjectCreateHelper.MakeSimpleLoginDto(_regularApiUser.Username, A()); - + var loginDto = ObjectCreateHelper.MakeSimpleLoginDto(_globalAdmin.Username, A()); + //Act using (var httpResponseMessage = await HttpApi.PostAsync(_getTokenUrl, loginDto)) { @@ -69,7 +79,7 @@ public async Task Get_Token_Returns_401_On_Invalid_Password() public async Task Get_Token_Returns_401_On_Invalid_Username() { //Arrange - var loginDto = ObjectCreateHelper.MakeSimpleLoginDto(A(), _regularApiUser.Password); + var loginDto = ObjectCreateHelper.MakeSimpleLoginDto(A(), A()); //Act using (var httpResponseMessage = await HttpApi.PostAsync(_getTokenUrl, loginDto)) diff --git a/Tests.Integration.Presentation.Web/Tools/HttpApi.cs b/Tests.Integration.Presentation.Web/Tools/HttpApi.cs index 4d53d6868c..676d6c8fad 100644 --- a/Tests.Integration.Presentation.Web/Tools/HttpApi.cs +++ b/Tests.Integration.Presentation.Web/Tools/HttpApi.cs @@ -406,15 +406,7 @@ public static async Task GetCookieAsync(KitosCredentials userCredentials if (CookiesCache.TryGetValue(userCredentials.Username, out var cachedCookie)) return cachedCookie; - var url = TestEnvironment.CreateUrl("api/authorize"); - var loginDto = ObjectCreateHelper.MakeSimpleLoginDto(userCredentials.Username, userCredentials.Password); - - using var cookieResponse = await WithRetryPolicy(async () => - { - var request = CreatePostMessage(url, loginDto); - - return await SendWithCSRFToken(request); - }); + var cookieResponse = await SendGetCookieAsync(userCredentials); Assert.Equal(HttpStatusCode.Created, cookieResponse.StatusCode); var cookieParts = cookieResponse.Headers.First(x => x.Key == "Set-Cookie").Value.First().Split('='); @@ -423,12 +415,25 @@ public static async Task GetCookieAsync(KitosCredentials userCredentials var cookie = new Cookie(cookieName, cookieValue) { - Domain = url.Host + Domain = cookieResponse.RequestMessage.RequestUri.Host }; CookiesCache.TryAdd(userCredentials.Username, cookie); return cookie; } + public static async Task SendGetCookieAsync(KitosCredentials userCredentials) + { + var url = TestEnvironment.CreateUrl("api/authorize"); + var loginDto = ObjectCreateHelper.MakeSimpleLoginDto(userCredentials.Username, userCredentials.Password); + + return await WithRetryPolicy(async () => + { + var request = CreatePostMessage(url, loginDto); + + return await SendWithCSRFToken(request); + }); + } + public static async Task GetCookieAsync(OrganizationRole role, bool acceptUnAuthorized = false) { var userCredentials = TestEnvironment.GetCredentials(role); From 002c74401265c0ab871d32b019e7135bf5d7be7d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Morten=20Remb=C3=B8l=20Jacobsen?= Date: Mon, 3 Oct 2022 07:30:05 +0200 Subject: [PATCH 023/272] renaming from connection to access status --- ...tsOrganizationSynchronizationController.cs | 16 +++++++++---- ...eckStsOrganizationConnectionResponseDTO.cs | 10 -------- .../StsOrganizationAccessStatusResponseDTO.cs | 16 +++++++++++++ .../StsOrganizationConnectionResponseDTO.cs | 11 +++++++++ Presentation.Web/Presentation.Web.csproj | 6 +++-- ...fk-organization-import-config.component.ts | 24 +++++++++---------- .../fk-organization-import-config.view.html | 10 ++++---- ...ts-organization-connection-response-dto.ts | 6 ----- ...organization-access-status-response-dto.ts | 6 +++++ ...ts-organization-connection-response-dto.ts | 5 ++++ .../services/sts-organization-sync-service.ts | 8 +++---- .../StsOrganizationSynchronizationApiTest.cs | 6 ++--- 12 files changed, 77 insertions(+), 47 deletions(-) delete mode 100644 Presentation.Web/Models/API/V1/Organizations/CheckStsOrganizationConnectionResponseDTO.cs create mode 100644 Presentation.Web/Models/API/V1/Organizations/StsOrganizationAccessStatusResponseDTO.cs create mode 100644 Presentation.Web/Models/API/V1/Organizations/StsOrganizationConnectionResponseDTO.cs delete mode 100644 Presentation.Web/app/models/api/organization/check-sts-organization-connection-response-dto.ts create mode 100644 Presentation.Web/app/models/api/organization/sts-organization-access-status-response-dto.ts create mode 100644 Presentation.Web/app/models/api/organization/sts-organization-connection-response-dto.ts diff --git a/Presentation.Web/Controllers/API/V1/StsOrganizationSynchronizationController.cs b/Presentation.Web/Controllers/API/V1/StsOrganizationSynchronizationController.cs index 43c823bc49..47ff95381d 100644 --- a/Presentation.Web/Controllers/API/V1/StsOrganizationSynchronizationController.cs +++ b/Presentation.Web/Controllers/API/V1/StsOrganizationSynchronizationController.cs @@ -39,14 +39,20 @@ public HttpResponseMessage GetConnectionStatus(Guid organizationId) .ValidateConnection(organizationId) .Match ( - error => Ok(new CheckStsOrganizationConnectionResponseDTO + error => Ok(new StsOrganizationConnectionResponseDTO { - Error = error.Detail, - Connected = false + AccessStatus = new StsOrganizationAccessStatusResponseDTO + { + AccessGranted = false, + Error = error.Detail + } }), - () => Ok(new CheckStsOrganizationConnectionResponseDTO() + () => Ok(new StsOrganizationConnectionResponseDTO { - Connected = true + AccessStatus = new StsOrganizationAccessStatusResponseDTO + { + AccessGranted = true + } }) ); diff --git a/Presentation.Web/Models/API/V1/Organizations/CheckStsOrganizationConnectionResponseDTO.cs b/Presentation.Web/Models/API/V1/Organizations/CheckStsOrganizationConnectionResponseDTO.cs deleted file mode 100644 index 8ad9163782..0000000000 --- a/Presentation.Web/Models/API/V1/Organizations/CheckStsOrganizationConnectionResponseDTO.cs +++ /dev/null @@ -1,10 +0,0 @@ -using Core.DomainServices.Model.StsOrganization; - -namespace Presentation.Web.Models.API.V1.Organizations -{ - public class CheckStsOrganizationConnectionResponseDTO - { - public bool Connected { get; set; } - public CheckConnectionError? Error { get; set; } - } -} \ No newline at end of file diff --git a/Presentation.Web/Models/API/V1/Organizations/StsOrganizationAccessStatusResponseDTO.cs b/Presentation.Web/Models/API/V1/Organizations/StsOrganizationAccessStatusResponseDTO.cs new file mode 100644 index 0000000000..b127eb48ae --- /dev/null +++ b/Presentation.Web/Models/API/V1/Organizations/StsOrganizationAccessStatusResponseDTO.cs @@ -0,0 +1,16 @@ +using Core.DomainServices.Model.StsOrganization; + +namespace Presentation.Web.Models.API.V1.Organizations +{ + public class StsOrganizationAccessStatusResponseDTO + { + /// + /// Determines if KITOS has access to data from FK Organisation + /// + public bool AccessGranted { get; set; } + /// + /// If is false, this field contains the access error + /// + public CheckConnectionError? Error { get; set; } + } +} \ No newline at end of file diff --git a/Presentation.Web/Models/API/V1/Organizations/StsOrganizationConnectionResponseDTO.cs b/Presentation.Web/Models/API/V1/Organizations/StsOrganizationConnectionResponseDTO.cs new file mode 100644 index 0000000000..0a7170a1a0 --- /dev/null +++ b/Presentation.Web/Models/API/V1/Organizations/StsOrganizationConnectionResponseDTO.cs @@ -0,0 +1,11 @@ +namespace Presentation.Web.Models.API.V1.Organizations +{ + public class StsOrganizationConnectionResponseDTO + { + //TODO: Add "Connected" boolean to indicate if the organization is connected to STS organization + /// + /// Describes the access status from KITOS to the organization in the FK Organisation system + /// + public StsOrganizationAccessStatusResponseDTO AccessStatus { get; set; } + } +} \ No newline at end of file diff --git a/Presentation.Web/Presentation.Web.csproj b/Presentation.Web/Presentation.Web.csproj index 234ad986ab..a45437c341 100644 --- a/Presentation.Web/Presentation.Web.csproj +++ b/Presentation.Web/Presentation.Web.csproj @@ -366,7 +366,8 @@ - + + @@ -400,7 +401,8 @@ - + + diff --git a/Presentation.Web/app/components/local-config/import/fk-organization-import-config.component.ts b/Presentation.Web/app/components/local-config/import/fk-organization-import-config.component.ts index 1f450647e0..f019ffa699 100644 --- a/Presentation.Web/app/components/local-config/import/fk-organization-import-config.component.ts +++ b/Presentation.Web/app/components/local-config/import/fk-organization-import-config.component.ts @@ -18,8 +18,8 @@ class FkOrganizationImportController implements IFkOrganizationImportController { currentOrganizationUuid: string | null = null; //note set by bindings - connected: boolean | null = null; - connectionError: string | null = null; + accessGranted: boolean | null = null; + accessError: string | null = null; static $inject: string[] = ["stsOrganizationSyncService"]; constructor(private readonly stsOrganizationSyncService: Kitos.Services.Organization.IStsOrganizationSyncService) { @@ -32,30 +32,30 @@ this.stsOrganizationSyncService .getConnectionStatus(this.currentOrganizationUuid) .then(result => { - if (result.connected) { - this.connected = true; + if (result.accessStatus.accessGranted) { + this.accessGranted = true; } else { - this.connected = false; - switch (result.error) { + this.accessGranted = false; + switch (result.accessStatus.error) { case Models.Api.Organization.CheckConnectionError.ExistingServiceAgreementIssue: - this.connectionError = "Der er problemer med den eksisterende serviceaftale, der giver KITOS adgang til data fra din kommune i FK Organisatoin. Kontakt venligst den KITOS ansvarlige i din kommune for hjælp." + this.accessError = "Der er problemer med den eksisterende serviceaftale, der giver KITOS adgang til data fra din kommune i FK Organisatoin. Kontakt venligst den KITOS ansvarlige i din kommune for hjælp." break; case Models.Api.Organization.CheckConnectionError.InvalidCvrOnOrganization: - this.connectionError = "Der enten mangler eller er registreret et ugyldigt CVR nummer på din kommune i KITOS." + this.accessError = "Der enten mangler eller er registreret et ugyldigt CVR nummer på din kommune i KITOS." break; case Models.Api.Organization.CheckConnectionError.MissingServiceAgreement: - this.connectionError = "Din organisation mangler en gyldig serviceaftale der giver KITOS adgang til data fra din kommune i FK Organisation. Kontakt venligst den KITOS ansvarlige i din kommune for hjælp." + this.accessError = "Din organisation mangler en gyldig serviceaftale der giver KITOS adgang til data fra din kommune i FK Organisation. Kontakt venligst den KITOS ansvarlige i din kommune for hjælp." break; case Models.Api.Organization.CheckConnectionError.Unknown: //intended fallthrough default: - this.connectionError = "Der skete en ukendt fejl ifm. tjek for forbindelsen til FK Organisation. Genindlæs venligst siden for at prøve igen." + this.accessError = "Der skete en ukendt fejl ifm. tjek for forbindelsen til FK Organisation. Genindlæs venligst siden for at prøve igen." break; } } }, error => { console.error(error); - this.connected = false; - this.connectionError = "Der skete en fejl ifm. tjek for forbindelsen til FK Organisation. Genindlæs venligst siden for at prøve igen." + this.accessGranted = false; + this.accessError = "Der skete en fejl ifm. tjek for forbindelsen til FK Organisation. Genindlæs venligst siden for at prøve igen." }); } } diff --git a/Presentation.Web/app/components/local-config/import/fk-organization-import-config.view.html b/Presentation.Web/app/components/local-config/import/fk-organization-import-config.view.html index 933d2a150c..75f87e4531 100644 --- a/Presentation.Web/app/components/local-config/import/fk-organization-import-config.view.html +++ b/Presentation.Web/app/components/local-config/import/fk-organization-import-config.view.html @@ -1,11 +1,11 @@ -
+
- KITOS har adgang til organisationens data via FK Organisation - KITOS har ikke adgang til organisationens data via FK Organisation + KITOS har adgang til organisationens data via FK Organisation + KITOS har ikke adgang til organisationens data via FK Organisation
-
+
- {{::ctrl.connectionError}} + {{::ctrl.accessError}}
diff --git a/Presentation.Web/app/models/api/organization/check-sts-organization-connection-response-dto.ts b/Presentation.Web/app/models/api/organization/check-sts-organization-connection-response-dto.ts deleted file mode 100644 index 66f84e1a2d..0000000000 --- a/Presentation.Web/app/models/api/organization/check-sts-organization-connection-response-dto.ts +++ /dev/null @@ -1,6 +0,0 @@ -module Kitos.Models.Api.Organization { - export interface CheckStsOrganizationConnectionResponseDTO { - connected: boolean - error: CheckConnectionError | null - } -} \ No newline at end of file diff --git a/Presentation.Web/app/models/api/organization/sts-organization-access-status-response-dto.ts b/Presentation.Web/app/models/api/organization/sts-organization-access-status-response-dto.ts new file mode 100644 index 0000000000..3e57749015 --- /dev/null +++ b/Presentation.Web/app/models/api/organization/sts-organization-access-status-response-dto.ts @@ -0,0 +1,6 @@ +module Kitos.Models.Api.Organization { + export interface StsOrganizationAccessStatusResponseDTO { + accessGranted: boolean + error: CheckConnectionError | null + } +} \ No newline at end of file diff --git a/Presentation.Web/app/models/api/organization/sts-organization-connection-response-dto.ts b/Presentation.Web/app/models/api/organization/sts-organization-connection-response-dto.ts new file mode 100644 index 0000000000..115ca3fb93 --- /dev/null +++ b/Presentation.Web/app/models/api/organization/sts-organization-connection-response-dto.ts @@ -0,0 +1,5 @@ +module Kitos.Models.Api.Organization { + export interface StsOrganizationConnectionResponseDTO { + accessStatus: StsOrganizationAccessStatusResponseDTO + } +} \ No newline at end of file diff --git a/Presentation.Web/app/services/sts-organization-sync-service.ts b/Presentation.Web/app/services/sts-organization-sync-service.ts index c5b61a5e18..7bab180979 100644 --- a/Presentation.Web/app/services/sts-organization-sync-service.ts +++ b/Presentation.Web/app/services/sts-organization-sync-service.ts @@ -1,6 +1,6 @@ module Kitos.Services.Organization { export interface IStsOrganizationSyncService { - getConnectionStatus(organizationId: string): ng.IPromise + getConnectionStatus(organizationId: string): ng.IPromise } export class StsOrganizationSyncService implements IStsOrganizationSyncService { @@ -16,14 +16,14 @@ return `api/v1/organizations/${organizationUuid}/sts-organization-synchronization`; } - getConnectionStatus(organizationUuid: string): ng.IPromise { + getConnectionStatus(organizationUuid: string): ng.IPromise { const cacheKey = `FK_CONNECTION_STATUS_${organizationUuid}`; - const result = this.inMemoryCacheService.getEntry(cacheKey); + const result = this.inMemoryCacheService.getEntry(cacheKey); if (result != null) { return this.$q.resolve(result); } return this.genericApiWrapper - .getDataFromUrl(`${this.getBasePath(organizationUuid)}/connection-status`) + .getDataFromUrl(`${this.getBasePath(organizationUuid)}/connection-status`) .then(connectionStatus => { this.inMemoryCacheService.setEntry(cacheKey, connectionStatus, Kitos.Shared.Time.Offset.compute(Kitos.Shared.Time.TimeUnit.Minutes, 1)); return connectionStatus; diff --git a/Tests.Integration.Presentation.Web/Organizations/StsOrganizationSynchronizationApiTest.cs b/Tests.Integration.Presentation.Web/Organizations/StsOrganizationSynchronizationApiTest.cs index f2e6985b63..90b926ae55 100644 --- a/Tests.Integration.Presentation.Web/Organizations/StsOrganizationSynchronizationApiTest.cs +++ b/Tests.Integration.Presentation.Web/Organizations/StsOrganizationSynchronizationApiTest.cs @@ -61,9 +61,9 @@ public async Task Can_GET_ConnectionStatus(string cvr, bool expectConnected, Che //Assert Assert.Equal(HttpStatusCode.OK, response.StatusCode); - var root = await response.ReadResponseBodyAsKitosApiResponseAsync(); - Assert.Equal(expectConnected, root.Connected); - Assert.Equal(expectedError, root.Error); + var root = await response.ReadResponseBodyAsKitosApiResponseAsync(); + Assert.Equal(expectConnected, root.AccessStatus.AccessGranted); + Assert.Equal(expectedError, root.AccessStatus.Error); } private async Task GetOrCreateOrgWithCvr(GetTokenResponseDTO token, string cvr) From d43165dc13dddae685c3033da25558c1943ccbfd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Morten=20Remb=C3=B8l=20Jacobsen?= Date: Mon, 3 Oct 2022 07:48:25 +0200 Subject: [PATCH 024/272] added origin to organization unit --- Core.DomainModel/Core.DomainModel.csproj | 1 + .../Organization/OrganizationUnit.cs | 13 +- .../Organization/OrganizationUnitOrigin.cs | 14 ++ .../Infrastructure.DataAccess.csproj | 7 + .../Mapping/OrganizationUnitMap.cs | 11 +- ..._Organization_Unit_Origin_Info.Designer.cs | 29 ++++ ...46163_Add_Organization_Unit_Origin_Info.cs | 31 +++++ ...163_Add_Organization_Unit_Origin_Info.resx | 126 ++++++++++++++++++ 8 files changed, 230 insertions(+), 2 deletions(-) create mode 100644 Core.DomainModel/Organization/OrganizationUnitOrigin.cs create mode 100644 Infrastructure.DataAccess/Migrations/202210030546163_Add_Organization_Unit_Origin_Info.Designer.cs create mode 100644 Infrastructure.DataAccess/Migrations/202210030546163_Add_Organization_Unit_Origin_Info.cs create mode 100644 Infrastructure.DataAccess/Migrations/202210030546163_Add_Organization_Unit_Origin_Info.resx diff --git a/Core.DomainModel/Core.DomainModel.csproj b/Core.DomainModel/Core.DomainModel.csproj index 3e342b175c..b5f7430fe4 100644 --- a/Core.DomainModel/Core.DomainModel.csproj +++ b/Core.DomainModel/Core.DomainModel.csproj @@ -82,6 +82,7 @@ + diff --git a/Core.DomainModel/Organization/OrganizationUnit.cs b/Core.DomainModel/Organization/OrganizationUnit.cs index de89420a8e..6bf5fc9505 100644 --- a/Core.DomainModel/Organization/OrganizationUnit.cs +++ b/Core.DomainModel/Organization/OrganizationUnit.cs @@ -18,9 +18,20 @@ public OrganizationUnit() OwnedTasks = new List(); DefaultUsers = new List(); Using = new List(); - Uuid = Guid.NewGuid(); + var uuid = Guid.NewGuid(); + Uuid = uuid; + Origin = OrganizationUnitOrigin.Kitos; } + /// + /// Determines the origin of the organization unit + /// + public OrganizationUnitOrigin Origin { get; set; } + /// + /// Determines the optional external origin-specific uuid + /// + public Guid ExternalOriginUuid { get; set; } + public string LocalId { get; set; } public string Name { get; set; } diff --git a/Core.DomainModel/Organization/OrganizationUnitOrigin.cs b/Core.DomainModel/Organization/OrganizationUnitOrigin.cs new file mode 100644 index 0000000000..731622ad2e --- /dev/null +++ b/Core.DomainModel/Organization/OrganizationUnitOrigin.cs @@ -0,0 +1,14 @@ +namespace Core.DomainModel.Organization +{ + public enum OrganizationUnitOrigin + { + /// + /// Organization unit is created and maintained in kitos + /// + Kitos = 0, + /// + /// Organization unit was created and is maintained in STS Organisation + /// + STS_Organisation = 1 + } +} diff --git a/Infrastructure.DataAccess/Infrastructure.DataAccess.csproj b/Infrastructure.DataAccess/Infrastructure.DataAccess.csproj index 2f5dedaf37..aa69b67437 100644 --- a/Infrastructure.DataAccess/Infrastructure.DataAccess.csproj +++ b/Infrastructure.DataAccess/Infrastructure.DataAccess.csproj @@ -935,6 +935,10 @@ 202209270528087_Add_Expiration_to_itsystemoverview.cs + + + 202210030546163_Add_Organization_Unit_Origin_Info.cs + @@ -1558,6 +1562,9 @@ 202209270528087_Add_Expiration_to_itsystemoverview.cs + + 202210030546163_Add_Organization_Unit_Origin_Info.cs + diff --git a/Infrastructure.DataAccess/Mapping/OrganizationUnitMap.cs b/Infrastructure.DataAccess/Mapping/OrganizationUnitMap.cs index d1a7f814e7..a704ebbc81 100644 --- a/Infrastructure.DataAccess/Mapping/OrganizationUnitMap.cs +++ b/Infrastructure.DataAccess/Mapping/OrganizationUnitMap.cs @@ -1,4 +1,3 @@ -using Core.DomainModel; using Core.DomainModel.Organization; namespace Infrastructure.DataAccess.Mapping @@ -33,6 +32,16 @@ public OrganizationUnitMap() Property(x => x.Uuid) .IsRequired() .HasUniqueIndexAnnotation("UX_OrganizationUnit_UUID", 0); + + + Property(x => x.ExternalOriginUuid) + .IsOptional() + //Non-unique index since it's an external origin uuid determined by an external system + .HasIndexAnnotation("IX_OrganizationUnit_UUID"); + + Property(x => x.OrganizationId) + .IsRequired() + .HasIndexAnnotation("IX_OrganizationUnit_Origin"); } } } diff --git a/Infrastructure.DataAccess/Migrations/202210030546163_Add_Organization_Unit_Origin_Info.Designer.cs b/Infrastructure.DataAccess/Migrations/202210030546163_Add_Organization_Unit_Origin_Info.Designer.cs new file mode 100644 index 0000000000..5de3fac077 --- /dev/null +++ b/Infrastructure.DataAccess/Migrations/202210030546163_Add_Organization_Unit_Origin_Info.Designer.cs @@ -0,0 +1,29 @@ +// +namespace Infrastructure.DataAccess.Migrations +{ + using System.CodeDom.Compiler; + using System.Data.Entity.Migrations; + using System.Data.Entity.Migrations.Infrastructure; + using System.Resources; + + [GeneratedCode("EntityFramework.Migrations", "6.4.4")] + public sealed partial class Add_Organization_Unit_Origin_Info : IMigrationMetadata + { + private readonly ResourceManager Resources = new ResourceManager(typeof(Add_Organization_Unit_Origin_Info)); + + string IMigrationMetadata.Id + { + get { return "202210030546163_Add_Organization_Unit_Origin_Info"; } + } + + string IMigrationMetadata.Source + { + get { return null; } + } + + string IMigrationMetadata.Target + { + get { return Resources.GetString("Target"); } + } + } +} diff --git a/Infrastructure.DataAccess/Migrations/202210030546163_Add_Organization_Unit_Origin_Info.cs b/Infrastructure.DataAccess/Migrations/202210030546163_Add_Organization_Unit_Origin_Info.cs new file mode 100644 index 0000000000..b357777d13 --- /dev/null +++ b/Infrastructure.DataAccess/Migrations/202210030546163_Add_Organization_Unit_Origin_Info.cs @@ -0,0 +1,31 @@ +namespace Infrastructure.DataAccess.Migrations +{ + using System; + using System.Data.Entity.Migrations; + + public partial class Add_Organization_Unit_Origin_Info : DbMigration + { + public override void Up() + { + DropIndex("dbo.OrganizationUnit", "UX_LocalId"); + AddColumn("dbo.OrganizationUnit", "Origin", c => c.Int(nullable: false)); + AddColumn("dbo.OrganizationUnit", "ExternalOriginUuid", c => c.Guid()); + CreateIndex("dbo.OrganizationUnit", "ExternalOriginUuid", name: "IX_OrganizationUnit_UUID"); + CreateIndex("dbo.OrganizationUnit", "LocalId", unique: true, name: "UX_LocalId"); + CreateIndex("dbo.OrganizationUnit", "OrganizationId", name: "IX_OrganizationUnit_Origin"); + + //Initially all organization units are set to 0 = KITOS + Sql("UPDATE dbo.OrganizationUnit SET Origin = 0;"); + } + + public override void Down() + { + DropIndex("dbo.OrganizationUnit", "IX_OrganizationUnit_Origin"); + DropIndex("dbo.OrganizationUnit", "UX_LocalId"); + DropIndex("dbo.OrganizationUnit", "IX_OrganizationUnit_UUID"); + DropColumn("dbo.OrganizationUnit", "ExternalOriginUuid"); + DropColumn("dbo.OrganizationUnit", "Origin"); + CreateIndex("dbo.OrganizationUnit", new[] { "OrganizationId", "LocalId" }, unique: true, name: "UX_LocalId"); + } + } +} diff --git a/Infrastructure.DataAccess/Migrations/202210030546163_Add_Organization_Unit_Origin_Info.resx b/Infrastructure.DataAccess/Migrations/202210030546163_Add_Organization_Unit_Origin_Info.resx new file mode 100644 index 0000000000..96f978466b --- /dev/null +++ b/Infrastructure.DataAccess/Migrations/202210030546163_Add_Organization_Unit_Origin_Info.resx @@ -0,0 +1,126 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 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 + + + dbo + + \ No newline at end of file From 0c615a03870b100e08adb930b2a5087375ad74fd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Morten=20Remb=C3=B8l=20Jacobsen?= Date: Mon, 3 Oct 2022 08:16:23 +0200 Subject: [PATCH 025/272] added org sync status table --- Core.DomainModel/Core.DomainModel.csproj | 1 + Core.DomainModel/Organization/Organization.cs | 9 +- .../Organization/StsOrganizationConnection.cs | 19 +++ DeploymentScripts/DbMigrations.ps1 | 5 +- .../Infrastructure.DataAccess.csproj | 11 +- Infrastructure.DataAccess/KitosContext.cs | 2 + .../Mapping/OrganizationUnitMap.cs | 2 +- .../Mapping/StsOrganizationConnectionMap.cs | 17 +++ ...46163_Add_Organization_Unit_Origin_Info.cs | 31 ----- ...163_Add_Organization_Unit_Origin_Info.resx | 126 ------------------ ...Organization_Unit_Origin_Info.Designer.cs} | 2 +- ...03412_Add_Organization_Unit_Origin_Info.cs | 56 ++++++++ ...412_Add_Organization_Unit_Origin_Info.resx | 126 ++++++++++++++++++ ..._Organization_Unit_Origin_Info.Designer.cs | 29 ++++ ...13577_Add_Organization_Unit_Origin_Info.cs | 56 ++++++++ ...577_Add_Organization_Unit_Origin_Info.resx | 126 ++++++++++++++++++ 16 files changed, 448 insertions(+), 170 deletions(-) create mode 100644 Core.DomainModel/Organization/StsOrganizationConnection.cs create mode 100644 Infrastructure.DataAccess/Mapping/StsOrganizationConnectionMap.cs delete mode 100644 Infrastructure.DataAccess/Migrations/202210030546163_Add_Organization_Unit_Origin_Info.cs delete mode 100644 Infrastructure.DataAccess/Migrations/202210030546163_Add_Organization_Unit_Origin_Info.resx rename Infrastructure.DataAccess/Migrations/{202210030546163_Add_Organization_Unit_Origin_Info.Designer.cs => 202210030603412_Add_Organization_Unit_Origin_Info.Designer.cs} (92%) create mode 100644 Infrastructure.DataAccess/Migrations/202210030603412_Add_Organization_Unit_Origin_Info.cs create mode 100644 Infrastructure.DataAccess/Migrations/202210030603412_Add_Organization_Unit_Origin_Info.resx create mode 100644 Infrastructure.DataAccess/Migrations/202210030613577_Add_Organization_Unit_Origin_Info.Designer.cs create mode 100644 Infrastructure.DataAccess/Migrations/202210030613577_Add_Organization_Unit_Origin_Info.cs create mode 100644 Infrastructure.DataAccess/Migrations/202210030613577_Add_Organization_Unit_Origin_Info.resx diff --git a/Core.DomainModel/Core.DomainModel.csproj b/Core.DomainModel/Core.DomainModel.csproj index b5f7430fe4..db368801cb 100644 --- a/Core.DomainModel/Core.DomainModel.csproj +++ b/Core.DomainModel/Core.DomainModel.csproj @@ -83,6 +83,7 @@ + diff --git a/Core.DomainModel/Organization/Organization.cs b/Core.DomainModel/Organization/Organization.cs index f9a1b8cfb6..b50fe95086 100644 --- a/Core.DomainModel/Organization/Organization.cs +++ b/Core.DomainModel/Organization/Organization.cs @@ -126,6 +126,7 @@ public Organization() public virtual ICollection UIModuleCustomizations { get; set; } public virtual ICollection ArchiveSupplierForItSystems { get; set; } + public virtual StsOrganizationConnection StsOrganizationConnection { get; set; } /// @@ -155,7 +156,7 @@ public Maybe GetUiModuleCustomization(string module) { if (module == null) throw new ArgumentNullException(nameof(module)); - + return UIModuleCustomizations .SingleOrDefault(config => config.Module == module) .FromNullable(); @@ -167,14 +168,14 @@ public Result ModifyModuleCustomization(s throw new ArgumentNullException("Module parameter cannot be null"); if (nodes == null) throw new ArgumentNullException("Nodes parameter cannot be null"); - + var uiNodes = nodes.ToList(); var customizedUiNodes = uiNodes.ToList(); - + var moduleCustomization = GetUiModuleCustomization(module).GetValueOrDefault(); if (moduleCustomization == null) { - moduleCustomization = new UIModuleCustomization {Organization = this, Module = module}; + moduleCustomization = new UIModuleCustomization { Organization = this, Module = module }; UIModuleCustomizations.Add(moduleCustomization); } diff --git a/Core.DomainModel/Organization/StsOrganizationConnection.cs b/Core.DomainModel/Organization/StsOrganizationConnection.cs new file mode 100644 index 0000000000..cda1751ecc --- /dev/null +++ b/Core.DomainModel/Organization/StsOrganizationConnection.cs @@ -0,0 +1,19 @@ +namespace Core.DomainModel.Organization +{ + + /// + /// Determines the properties of the organization's connection to STS Organisation + /// + public class StsOrganizationConnection : Entity, IOwnedByOrganization + { + public int OrganizationId { get; set; } + public virtual Organization Organization { get; set; } + public bool Connected { get; set; } + /// + /// Determines the optional synchronization depth used during synchronization from STS Organisation + /// + public int? SynchronizationDepth { get; set; } + //TODO https://os2web.atlassian.net/browse/KITOSUDV-3317 adds the change logs here + //TODO: https://os2web.atlassian.net/browse/KITOSUDV-3312 adds automatic subscription here + } +} diff --git a/DeploymentScripts/DbMigrations.ps1 b/DeploymentScripts/DbMigrations.ps1 index 659668c65a..bba5c2ffdc 100644 --- a/DeploymentScripts/DbMigrations.ps1 +++ b/DeploymentScripts/DbMigrations.ps1 @@ -8,14 +8,15 @@ Function Run-DB-Migrations([bool]$newDb = $false, [string]$migrationsFolder, [st Write-Host "Disabling seed for new database" $Env:SeedNewDb="no" } - + & "$migrationsFolder\ef6.exe" ` database update ` --assembly "$migrationsFolder\Infrastructure.DataAccess.dll" ` --connection-string "$connectionString" ` --connection-provider "System.Data.SqlClient" ` - --verbose ` --project-dir "$migrationsFolder" + + # NOTE: add the --verbose flag to get full statement output (for debugging) if($LASTEXITCODE -ne 0) { Throw "FAILED TO MIGRATE DB" } } \ No newline at end of file diff --git a/Infrastructure.DataAccess/Infrastructure.DataAccess.csproj b/Infrastructure.DataAccess/Infrastructure.DataAccess.csproj index aa69b67437..79bac47f18 100644 --- a/Infrastructure.DataAccess/Infrastructure.DataAccess.csproj +++ b/Infrastructure.DataAccess/Infrastructure.DataAccess.csproj @@ -95,6 +95,7 @@ + @@ -935,9 +936,9 @@ 202209270528087_Add_Expiration_to_itsystemoverview.cs - - - 202210030546163_Add_Organization_Unit_Origin_Info.cs + + + 202210030613577_Add_Organization_Unit_Origin_Info.cs @@ -1562,8 +1563,8 @@ 202209270528087_Add_Expiration_to_itsystemoverview.cs - - 202210030546163_Add_Organization_Unit_Origin_Info.cs + + 202210030613577_Add_Organization_Unit_Origin_Info.cs diff --git a/Infrastructure.DataAccess/KitosContext.cs b/Infrastructure.DataAccess/KitosContext.cs index 3b3d6a5999..b07bd3c362 100644 --- a/Infrastructure.DataAccess/KitosContext.cs +++ b/Infrastructure.DataAccess/KitosContext.cs @@ -159,6 +159,7 @@ public KitosContext(string nameOrConnectionString) public DbSet ItContractOverviewReadModelItSystemUsages { get; set; } public DbSet ItContractOverviewRoleAssignmentReadModels { get; set; } public DbSet ItContractOverviewReadModelSystemRelations { get; set; } + public DbSet StsOrganizationConnections { get; set; } protected override void OnModelCreating(DbModelBuilder modelBuilder) { @@ -256,6 +257,7 @@ protected override void OnModelCreating(DbModelBuilder modelBuilder) modelBuilder.Configurations.Add(new ItContractOverviewReadModelItSystemUsageMap()); modelBuilder.Configurations.Add(new ItContractOverviewRoleAssignmentReadModelMap()); modelBuilder.Configurations.Add(new ItContractOverviewReadModelSystemRelationMap()); + modelBuilder.Configurations.Add(new StsOrganizationConnectionMap()); } } } diff --git a/Infrastructure.DataAccess/Mapping/OrganizationUnitMap.cs b/Infrastructure.DataAccess/Mapping/OrganizationUnitMap.cs index a704ebbc81..0f4816d40c 100644 --- a/Infrastructure.DataAccess/Mapping/OrganizationUnitMap.cs +++ b/Infrastructure.DataAccess/Mapping/OrganizationUnitMap.cs @@ -39,7 +39,7 @@ public OrganizationUnitMap() //Non-unique index since it's an external origin uuid determined by an external system .HasIndexAnnotation("IX_OrganizationUnit_UUID"); - Property(x => x.OrganizationId) + Property(x => x.Origin) .IsRequired() .HasIndexAnnotation("IX_OrganizationUnit_Origin"); } diff --git a/Infrastructure.DataAccess/Mapping/StsOrganizationConnectionMap.cs b/Infrastructure.DataAccess/Mapping/StsOrganizationConnectionMap.cs new file mode 100644 index 0000000000..fab565d855 --- /dev/null +++ b/Infrastructure.DataAccess/Mapping/StsOrganizationConnectionMap.cs @@ -0,0 +1,17 @@ +using Core.DomainModel.Organization; + +namespace Infrastructure.DataAccess.Mapping +{ + public class StsOrganizationConnectionMap : EntityMap + { + public StsOrganizationConnectionMap() + { + HasRequired(x => x.Organization) + .WithOptional(x => x.StsOrganizationConnection); + + Property(x => x.Connected) + .IsRequired() + .HasIndexAnnotation("IX_Connected"); + } + } +} diff --git a/Infrastructure.DataAccess/Migrations/202210030546163_Add_Organization_Unit_Origin_Info.cs b/Infrastructure.DataAccess/Migrations/202210030546163_Add_Organization_Unit_Origin_Info.cs deleted file mode 100644 index b357777d13..0000000000 --- a/Infrastructure.DataAccess/Migrations/202210030546163_Add_Organization_Unit_Origin_Info.cs +++ /dev/null @@ -1,31 +0,0 @@ -namespace Infrastructure.DataAccess.Migrations -{ - using System; - using System.Data.Entity.Migrations; - - public partial class Add_Organization_Unit_Origin_Info : DbMigration - { - public override void Up() - { - DropIndex("dbo.OrganizationUnit", "UX_LocalId"); - AddColumn("dbo.OrganizationUnit", "Origin", c => c.Int(nullable: false)); - AddColumn("dbo.OrganizationUnit", "ExternalOriginUuid", c => c.Guid()); - CreateIndex("dbo.OrganizationUnit", "ExternalOriginUuid", name: "IX_OrganizationUnit_UUID"); - CreateIndex("dbo.OrganizationUnit", "LocalId", unique: true, name: "UX_LocalId"); - CreateIndex("dbo.OrganizationUnit", "OrganizationId", name: "IX_OrganizationUnit_Origin"); - - //Initially all organization units are set to 0 = KITOS - Sql("UPDATE dbo.OrganizationUnit SET Origin = 0;"); - } - - public override void Down() - { - DropIndex("dbo.OrganizationUnit", "IX_OrganizationUnit_Origin"); - DropIndex("dbo.OrganizationUnit", "UX_LocalId"); - DropIndex("dbo.OrganizationUnit", "IX_OrganizationUnit_UUID"); - DropColumn("dbo.OrganizationUnit", "ExternalOriginUuid"); - DropColumn("dbo.OrganizationUnit", "Origin"); - CreateIndex("dbo.OrganizationUnit", new[] { "OrganizationId", "LocalId" }, unique: true, name: "UX_LocalId"); - } - } -} diff --git a/Infrastructure.DataAccess/Migrations/202210030546163_Add_Organization_Unit_Origin_Info.resx b/Infrastructure.DataAccess/Migrations/202210030546163_Add_Organization_Unit_Origin_Info.resx deleted file mode 100644 index 96f978466b..0000000000 --- a/Infrastructure.DataAccess/Migrations/202210030546163_Add_Organization_Unit_Origin_Info.resx +++ /dev/null @@ -1,126 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - text/microsoft-resx - - - 2.0 - - - System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - - - System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - - - 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 - - - dbo - - \ No newline at end of file diff --git a/Infrastructure.DataAccess/Migrations/202210030546163_Add_Organization_Unit_Origin_Info.Designer.cs b/Infrastructure.DataAccess/Migrations/202210030603412_Add_Organization_Unit_Origin_Info.Designer.cs similarity index 92% rename from Infrastructure.DataAccess/Migrations/202210030546163_Add_Organization_Unit_Origin_Info.Designer.cs rename to Infrastructure.DataAccess/Migrations/202210030603412_Add_Organization_Unit_Origin_Info.Designer.cs index 5de3fac077..f438dcf165 100644 --- a/Infrastructure.DataAccess/Migrations/202210030546163_Add_Organization_Unit_Origin_Info.Designer.cs +++ b/Infrastructure.DataAccess/Migrations/202210030603412_Add_Organization_Unit_Origin_Info.Designer.cs @@ -13,7 +13,7 @@ public sealed partial class Add_Organization_Unit_Origin_Info : IMigrationMetada string IMigrationMetadata.Id { - get { return "202210030546163_Add_Organization_Unit_Origin_Info"; } + get { return "202210030603412_Add_Organization_Unit_Origin_Info"; } } string IMigrationMetadata.Source diff --git a/Infrastructure.DataAccess/Migrations/202210030603412_Add_Organization_Unit_Origin_Info.cs b/Infrastructure.DataAccess/Migrations/202210030603412_Add_Organization_Unit_Origin_Info.cs new file mode 100644 index 0000000000..949cb3b1cd --- /dev/null +++ b/Infrastructure.DataAccess/Migrations/202210030603412_Add_Organization_Unit_Origin_Info.cs @@ -0,0 +1,56 @@ +namespace Infrastructure.DataAccess.Migrations +{ + using System; + using System.Data.Entity.Migrations; + + public partial class Add_Organization_Unit_Origin_Info : DbMigration + { + public override void Up() + { + DropIndex("dbo.OrganizationUnit", "UX_LocalId"); + CreateTable( + "dbo.StsOrganizationConnections", + c => new + { + Id = c.Int(nullable: false), + OrganizationId = c.Int(nullable: false), + Connected = c.Boolean(nullable: false), + ObjectOwnerId = c.Int(nullable: false), + LastChanged = c.DateTime(nullable: false, precision: 7, storeType: "datetime2"), + LastChangedByUserId = c.Int(nullable: false), + }) + .PrimaryKey(t => t.Id) + .ForeignKey("dbo.User", t => t.LastChangedByUserId) + .ForeignKey("dbo.User", t => t.ObjectOwnerId) + .ForeignKey("dbo.Organization", t => t.Id) + .Index(t => t.Id) + .Index(t => t.Connected) + .Index(t => t.ObjectOwnerId) + .Index(t => t.LastChangedByUserId); + + AddColumn("dbo.OrganizationUnit", "Origin", c => c.Int(nullable: false)); + AddColumn("dbo.OrganizationUnit", "ExternalOriginUuid", c => c.Guid()); + CreateIndex("dbo.OrganizationUnit", "ExternalOriginUuid", name: "IX_OrganizationUnit_UUID"); + CreateIndex("dbo.OrganizationUnit", "LocalId", unique: true, name: "UX_LocalId"); + CreateIndex("dbo.OrganizationUnit", "OrganizationId", name: "IX_OrganizationUnit_Origin"); + } + + public override void Down() + { + DropForeignKey("dbo.StsOrganizationConnections", "Id", "dbo.Organization"); + DropForeignKey("dbo.StsOrganizationConnections", "ObjectOwnerId", "dbo.User"); + DropForeignKey("dbo.StsOrganizationConnections", "LastChangedByUserId", "dbo.User"); + DropIndex("dbo.StsOrganizationConnections", new[] { "LastChangedByUserId" }); + DropIndex("dbo.StsOrganizationConnections", new[] { "ObjectOwnerId" }); + DropIndex("dbo.StsOrganizationConnections", new[] { "Connected" }); + DropIndex("dbo.StsOrganizationConnections", new[] { "Id" }); + DropIndex("dbo.OrganizationUnit", "IX_OrganizationUnit_Origin"); + DropIndex("dbo.OrganizationUnit", "UX_LocalId"); + DropIndex("dbo.OrganizationUnit", "IX_OrganizationUnit_UUID"); + DropColumn("dbo.OrganizationUnit", "ExternalOriginUuid"); + DropColumn("dbo.OrganizationUnit", "Origin"); + DropTable("dbo.StsOrganizationConnections"); + CreateIndex("dbo.OrganizationUnit", new[] { "OrganizationId", "LocalId" }, unique: true, name: "UX_LocalId"); + } + } +} diff --git a/Infrastructure.DataAccess/Migrations/202210030603412_Add_Organization_Unit_Origin_Info.resx b/Infrastructure.DataAccess/Migrations/202210030603412_Add_Organization_Unit_Origin_Info.resx new file mode 100644 index 0000000000..ce5f7f2a27 --- /dev/null +++ b/Infrastructure.DataAccess/Migrations/202210030603412_Add_Organization_Unit_Origin_Info.resx @@ -0,0 +1,126 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 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 + + + dbo + + \ No newline at end of file diff --git a/Infrastructure.DataAccess/Migrations/202210030613577_Add_Organization_Unit_Origin_Info.Designer.cs b/Infrastructure.DataAccess/Migrations/202210030613577_Add_Organization_Unit_Origin_Info.Designer.cs new file mode 100644 index 0000000000..0b9509ad1f --- /dev/null +++ b/Infrastructure.DataAccess/Migrations/202210030613577_Add_Organization_Unit_Origin_Info.Designer.cs @@ -0,0 +1,29 @@ +// +namespace Infrastructure.DataAccess.Migrations +{ + using System.CodeDom.Compiler; + using System.Data.Entity.Migrations; + using System.Data.Entity.Migrations.Infrastructure; + using System.Resources; + + [GeneratedCode("EntityFramework.Migrations", "6.4.4")] + public sealed partial class Add_Organization_Unit_Origin_Info : IMigrationMetadata + { + private readonly ResourceManager Resources = new ResourceManager(typeof(Add_Organization_Unit_Origin_Info)); + + string IMigrationMetadata.Id + { + get { return "202210030613577_Add_Organization_Unit_Origin_Info"; } + } + + string IMigrationMetadata.Source + { + get { return null; } + } + + string IMigrationMetadata.Target + { + get { return Resources.GetString("Target"); } + } + } +} diff --git a/Infrastructure.DataAccess/Migrations/202210030613577_Add_Organization_Unit_Origin_Info.cs b/Infrastructure.DataAccess/Migrations/202210030613577_Add_Organization_Unit_Origin_Info.cs new file mode 100644 index 0000000000..afd101dc1f --- /dev/null +++ b/Infrastructure.DataAccess/Migrations/202210030613577_Add_Organization_Unit_Origin_Info.cs @@ -0,0 +1,56 @@ +namespace Infrastructure.DataAccess.Migrations +{ + using System; + using System.Data.Entity.Migrations; + + public partial class Add_Organization_Unit_Origin_Info : DbMigration + { + public override void Up() + { + CreateTable( + "dbo.StsOrganizationConnections", + c => new + { + Id = c.Int(nullable: false), + OrganizationId = c.Int(nullable: false), + Connected = c.Boolean(nullable: false), + SynchronizationDepth = c.Int(), + ObjectOwnerId = c.Int(nullable: false), + LastChanged = c.DateTime(nullable: false, precision: 7, storeType: "datetime2"), + LastChangedByUserId = c.Int(nullable: false), + }) + .PrimaryKey(t => t.Id) + .ForeignKey("dbo.User", t => t.LastChangedByUserId) + .ForeignKey("dbo.User", t => t.ObjectOwnerId) + .ForeignKey("dbo.Organization", t => t.Id) + .Index(t => t.Id) + .Index(t => t.Connected) + .Index(t => t.ObjectOwnerId) + .Index(t => t.LastChangedByUserId); + + AddColumn("dbo.OrganizationUnit", "Origin", c => c.Int(nullable: false)); + AddColumn("dbo.OrganizationUnit", "ExternalOriginUuid", c => c.Guid()); + CreateIndex("dbo.OrganizationUnit", "Origin", name: "IX_OrganizationUnit_Origin"); + CreateIndex("dbo.OrganizationUnit", "ExternalOriginUuid", name: "IX_OrganizationUnit_UUID"); + + //Initially all units' origin is "Kitos" + Sql("UPDATE dbo.OrganizationUnit SET Origin = 0;"); + } + + public override void Down() + { + DropForeignKey("dbo.StsOrganizationConnections", "Id", "dbo.Organization"); + DropForeignKey("dbo.StsOrganizationConnections", "ObjectOwnerId", "dbo.User"); + DropForeignKey("dbo.StsOrganizationConnections", "LastChangedByUserId", "dbo.User"); + DropIndex("dbo.StsOrganizationConnections", new[] { "LastChangedByUserId" }); + DropIndex("dbo.StsOrganizationConnections", new[] { "ObjectOwnerId" }); + DropIndex("dbo.StsOrganizationConnections", new[] { "Connected" }); + DropIndex("dbo.StsOrganizationConnections", new[] { "Id" }); + DropIndex("dbo.OrganizationUnit", "IX_OrganizationUnit_UUID"); + DropIndex("dbo.OrganizationUnit", "IX_OrganizationUnit_Origin"); + DropColumn("dbo.OrganizationUnit", "ExternalOriginUuid"); + DropColumn("dbo.OrganizationUnit", "Origin"); + DropTable("dbo.StsOrganizationConnections"); + } + } +} diff --git a/Infrastructure.DataAccess/Migrations/202210030613577_Add_Organization_Unit_Origin_Info.resx b/Infrastructure.DataAccess/Migrations/202210030613577_Add_Organization_Unit_Origin_Info.resx new file mode 100644 index 0000000000..f8a45be5e8 --- /dev/null +++ b/Infrastructure.DataAccess/Migrations/202210030613577_Add_Organization_Unit_Origin_Info.resx @@ -0,0 +1,126 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 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 + + + dbo + + \ No newline at end of file From 66a7295dda5e7d873cbb8c8f08fee7c0010c946e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Morten=20Remb=C3=B8l=20Jacobsen?= Date: Mon, 3 Oct 2022 08:21:14 +0200 Subject: [PATCH 026/272] fixed text. Removed controller condition which is now handled in the "User.Getauthenticationmethods" method --- Presentation.Web/Controllers/API/V1/AuthorizeController.cs | 6 ------ .../Security/AuthorizationTests.cs | 4 ++-- 2 files changed, 2 insertions(+), 8 deletions(-) diff --git a/Presentation.Web/Controllers/API/V1/AuthorizeController.cs b/Presentation.Web/Controllers/API/V1/AuthorizeController.cs index a201fbe392..05133270cc 100644 --- a/Presentation.Web/Controllers/API/V1/AuthorizeController.cs +++ b/Presentation.Web/Controllers/API/V1/AuthorizeController.cs @@ -151,12 +151,6 @@ public HttpResponseMessage GetToken(LoginDTO loginDto) var user = result.Value; - if (CanIssueTokenTo(user)) - { - Logger.Warn("User with Id {id} tried to use get a token for the API but was forbidden", user.Id); - return Forbidden(); - } - var token = new TokenValidator().CreateToken(user); var response = new GetTokenResponseDTO diff --git a/Tests.Integration.Presentation.Web/Security/AuthorizationTests.cs b/Tests.Integration.Presentation.Web/Security/AuthorizationTests.cs index 3d81058d91..cf1a749de7 100644 --- a/Tests.Integration.Presentation.Web/Security/AuthorizationTests.cs +++ b/Tests.Integration.Presentation.Web/Security/AuthorizationTests.cs @@ -57,8 +57,8 @@ public async Task User_Without_Api_Access_Can_Not_Get_Token() //Act var tokenResponse = await HttpApi.PostAsync(url, loginDto); - //Assert - Assert.Equal(HttpStatusCode.Forbidden, tokenResponse.StatusCode); + //Assert that unauthorized is returend .. token auth not enabled for the user + Assert.Equal(HttpStatusCode.Unauthorized, tokenResponse.StatusCode); } [Fact] From 1885f9186ebf7417cc98c49929791b4352104bca Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Morten=20Remb=C3=B8l=20Jacobsen?= Date: Mon, 3 Oct 2022 09:03:35 +0200 Subject: [PATCH 027/272] Added sync status endpoint and service layer --- .../Core.ApplicationServices.csproj | 1 + .../StsOrganizationSynchronizationDetails.cs | 20 +++++++++++++ .../IStsOrganizationSynchronizationService.cs | 10 +++++++ .../StsOrganizationSynchronizationService.cs | 14 +++++++++ ...tsOrganizationSynchronizationController.cs | 30 ++++++++++++++++++- .../ConnectToStsOrganizationRequestDTO.cs | 7 +++++ .../StsOrganizationConnectionResponseDTO.cs | 1 - ...zationSynchronizationDetailsResponseDTO.cs | 11 +++++++ Presentation.Web/Presentation.Web.csproj | 2 ++ 9 files changed, 94 insertions(+), 2 deletions(-) create mode 100644 Core.ApplicationServices/Model/Organizations/StsOrganizationSynchronizationDetails.cs create mode 100644 Presentation.Web/Models/API/V1/Organizations/ConnectToStsOrganizationRequestDTO.cs create mode 100644 Presentation.Web/Models/API/V1/Organizations/StsOrganizationSynchronizationDetailsResponseDTO.cs diff --git a/Core.ApplicationServices/Core.ApplicationServices.csproj b/Core.ApplicationServices/Core.ApplicationServices.csproj index 7b1f726607..369aec0e34 100644 --- a/Core.ApplicationServices/Core.ApplicationServices.csproj +++ b/Core.ApplicationServices/Core.ApplicationServices.csproj @@ -146,6 +146,7 @@ + diff --git a/Core.ApplicationServices/Model/Organizations/StsOrganizationSynchronizationDetails.cs b/Core.ApplicationServices/Model/Organizations/StsOrganizationSynchronizationDetails.cs new file mode 100644 index 0000000000..fecdf9650c --- /dev/null +++ b/Core.ApplicationServices/Model/Organizations/StsOrganizationSynchronizationDetails.cs @@ -0,0 +1,20 @@ +namespace Core.ApplicationServices.Model.Organizations +{ + public class StsOrganizationSynchronizationDetails + { + public bool Connected { get; } + public int? SynchronizationDepth { get; } + public bool CanCreateConnection { get; } + public bool CanUpdateConnection { get; } + public bool CanDeleteConnection { get; } + + public StsOrganizationSynchronizationDetails(bool connected, int? synchronizationDepth, bool canCreateConnection, bool canUpdateConnection, bool canDeleteConnection) + { + Connected = connected; + SynchronizationDepth = synchronizationDepth; + CanCreateConnection = canCreateConnection; + CanUpdateConnection = canUpdateConnection; + CanDeleteConnection = canDeleteConnection; + } + } +} diff --git a/Core.ApplicationServices/Organizations/IStsOrganizationSynchronizationService.cs b/Core.ApplicationServices/Organizations/IStsOrganizationSynchronizationService.cs index 131c510dc8..2c985f3bf3 100644 --- a/Core.ApplicationServices/Organizations/IStsOrganizationSynchronizationService.cs +++ b/Core.ApplicationServices/Organizations/IStsOrganizationSynchronizationService.cs @@ -1,5 +1,6 @@ using System; using Core.Abstractions.Types; +using Core.ApplicationServices.Model.Organizations; using Core.DomainServices.Model.StsOrganization; namespace Core.ApplicationServices.Organizations @@ -8,8 +9,17 @@ public interface IStsOrganizationSynchronizationService { /// /// Validates if KITOS can read organization data from STS Organisation + /// + /// + /// Maybe> ValidateConnection(Guid organizationId); /// + /// Gets the synchronization details of the organization + /// + /// + /// + Result GetSynchronizationDetails(Guid organizationId); + /// /// Retrieves a view of the organization as it exists in STS Organization /// /// diff --git a/Core.ApplicationServices/Organizations/StsOrganizationSynchronizationService.cs b/Core.ApplicationServices/Organizations/StsOrganizationSynchronizationService.cs index 71f17598af..4302573baa 100644 --- a/Core.ApplicationServices/Organizations/StsOrganizationSynchronizationService.cs +++ b/Core.ApplicationServices/Organizations/StsOrganizationSynchronizationService.cs @@ -2,6 +2,7 @@ using Core.Abstractions.Types; using Core.ApplicationServices.Authorization; using Core.ApplicationServices.Authorization.Permissions; +using Core.ApplicationServices.Model.Organizations; using Core.DomainModel.Organization; using Core.DomainServices.Model.StsOrganization; using Core.DomainServices.Organizations; @@ -37,6 +38,19 @@ public Maybe> ValidateConnection(Gu .Match(ValidateConnection, error => new DetailedOperationError(error.FailureType, CheckConnectionError.Unknown, error.Message.GetValueOrDefault())); } + public Result GetSynchronizationDetails(Guid organizationId) + { + return GetOrganizationWithImportPermission(organizationId) + .Select(organization => + { + var currentConnectionStatus = ValidateConnection(organization); + var isConnected = organization.StsOrganizationConnection?.Connected == true; + var canCreateConnection = currentConnectionStatus.IsNone && organization.StsOrganizationConnection?.Connected != true; + var canUpdateConnection = currentConnectionStatus.IsNone && isConnected; + return new StsOrganizationSynchronizationDetails(isConnected, organization.StsOrganizationConnection?.SynchronizationDepth, canCreateConnection, canUpdateConnection, isConnected); + }); + } + private Maybe> ValidateConnection(Organization organization) { return _stsOrganizationService.ValidateConnection(organization); diff --git a/Presentation.Web/Controllers/API/V1/StsOrganizationSynchronizationController.cs b/Presentation.Web/Controllers/API/V1/StsOrganizationSynchronizationController.cs index 47ff95381d..f154717f12 100644 --- a/Presentation.Web/Controllers/API/V1/StsOrganizationSynchronizationController.cs +++ b/Presentation.Web/Controllers/API/V1/StsOrganizationSynchronizationController.cs @@ -22,7 +22,7 @@ public StsOrganizationSynchronizationController(IStsOrganizationSynchronizationS } [HttpGet] - [Route("snapshot")] + [Route("snapshot")] //TODO: Rename to query | preview? public HttpResponseMessage GetSnapshotFromStsOrganization(Guid organizationId, uint? levels = null) { return _stsOrganizationSynchronizationService @@ -58,6 +58,34 @@ public HttpResponseMessage GetConnectionStatus(Guid organizationId) } + [HttpGet] + [Route("synchronization-status")] + public HttpResponseMessage GetSynchronizationStatus(Guid organizationId) + { + return _stsOrganizationSynchronizationService + .GetSynchronizationDetails(organizationId) + .Select(details => new StsOrganizationSynchronizationDetailsResponseDTO + { + Connected = details.Connected, + SynchronizationDepth = details.SynchronizationDepth, + CanCreateConnection = details.CanCreateConnection, + CanDeleteConnection = details.CanDeleteConnection, + CanUpdateConnection = details.CanUpdateConnection + }) + .Match(Ok, FromOperationError); + + } + + [HttpPost] + [Route("connection")] + public HttpResponseMessage CreateConnection(ConnectToStsOrganizationRequestDTO request) + { + //TODO: Perform the import (only allowed to CREATE if not already created). If created, the current one must be updated! + return Ok(); + } + + //TODO: https://os2web.atlassian.net/browse/KITOSUDV-3313 adds the PUT (POST creates the connection) + private static StsOrganizationOrgUnitDTO MapOrganizationUnitDTO(StsOrganizationUnit organizationUnit) { return new StsOrganizationOrgUnitDTO() diff --git a/Presentation.Web/Models/API/V1/Organizations/ConnectToStsOrganizationRequestDTO.cs b/Presentation.Web/Models/API/V1/Organizations/ConnectToStsOrganizationRequestDTO.cs new file mode 100644 index 0000000000..be3f24bc9b --- /dev/null +++ b/Presentation.Web/Models/API/V1/Organizations/ConnectToStsOrganizationRequestDTO.cs @@ -0,0 +1,7 @@ +namespace Presentation.Web.Models.API.V1.Organizations +{ + public class ConnectToStsOrganizationRequestDTO + { + public int? SynchronizationDepth { get; set; } + } +} \ No newline at end of file diff --git a/Presentation.Web/Models/API/V1/Organizations/StsOrganizationConnectionResponseDTO.cs b/Presentation.Web/Models/API/V1/Organizations/StsOrganizationConnectionResponseDTO.cs index 0a7170a1a0..033d0b4331 100644 --- a/Presentation.Web/Models/API/V1/Organizations/StsOrganizationConnectionResponseDTO.cs +++ b/Presentation.Web/Models/API/V1/Organizations/StsOrganizationConnectionResponseDTO.cs @@ -2,7 +2,6 @@ { public class StsOrganizationConnectionResponseDTO { - //TODO: Add "Connected" boolean to indicate if the organization is connected to STS organization /// /// Describes the access status from KITOS to the organization in the FK Organisation system /// diff --git a/Presentation.Web/Models/API/V1/Organizations/StsOrganizationSynchronizationDetailsResponseDTO.cs b/Presentation.Web/Models/API/V1/Organizations/StsOrganizationSynchronizationDetailsResponseDTO.cs new file mode 100644 index 0000000000..9d02674b0d --- /dev/null +++ b/Presentation.Web/Models/API/V1/Organizations/StsOrganizationSynchronizationDetailsResponseDTO.cs @@ -0,0 +1,11 @@ +namespace Presentation.Web.Models.API.V1.Organizations +{ + public class StsOrganizationSynchronizationDetailsResponseDTO + { + public bool Connected { get; set; } + public int? SynchronizationDepth { get; set; } + public bool CanCreateConnection { get; set; } + public bool CanUpdateConnection { get; set; } + public bool CanDeleteConnection { get; set; } + } +} \ No newline at end of file diff --git a/Presentation.Web/Presentation.Web.csproj b/Presentation.Web/Presentation.Web.csproj index a45437c341..716ac60249 100644 --- a/Presentation.Web/Presentation.Web.csproj +++ b/Presentation.Web/Presentation.Web.csproj @@ -401,8 +401,10 @@ + + From 89a1bb3bd444c8bc41a70a71d6763d8585aab377 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Morten=20Remb=C3=B8l=20Jacobsen?= Date: Mon, 3 Oct 2022 09:04:34 +0200 Subject: [PATCH 028/272] added task --- .../API/V1/StsOrganizationSynchronizationController.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Presentation.Web/Controllers/API/V1/StsOrganizationSynchronizationController.cs b/Presentation.Web/Controllers/API/V1/StsOrganizationSynchronizationController.cs index f154717f12..ad279b99f6 100644 --- a/Presentation.Web/Controllers/API/V1/StsOrganizationSynchronizationController.cs +++ b/Presentation.Web/Controllers/API/V1/StsOrganizationSynchronizationController.cs @@ -32,7 +32,7 @@ public HttpResponseMessage GetSnapshotFromStsOrganization(Guid organizationId, u } [HttpGet] - [Route("connection-status")] + [Route("connection-status")] //TODO: Obsolete this endpoint and add the access status to the other one! public HttpResponseMessage GetConnectionStatus(Guid organizationId) { return _stsOrganizationSynchronizationService From bad13b551415b802935fb3fd106ca9eb75f3a9a0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Morten=20Remb=C3=B8l=20Jacobsen?= Date: Mon, 3 Oct 2022 09:44:37 +0200 Subject: [PATCH 029/272] changed the validation method to be a status method containing connection status and available commands --- .../StsOrganizationSynchronizationDetails.cs | 8 +++-- .../IStsOrganizationSynchronizationService.cs | 6 ---- .../StsOrganizationSynchronizationService.cs | 16 +++++---- ...tsOrganizationSynchronizationController.cs | 36 ++++--------------- .../StsOrganizationConnectionResponseDTO.cs | 10 ------ ...zationSynchronizationDetailsResponseDTO.cs | 1 + Presentation.Web/Presentation.Web.csproj | 3 +- ...ts-organization-connection-response-dto.ts | 5 --- ...ion-synchronization-status-response-dto.ts | 10 ++++++ .../services/sts-organization-sync-service.ts | 16 ++++++--- .../StsOrganizationSynchronizationApiTest.cs | 2 +- 11 files changed, 46 insertions(+), 67 deletions(-) delete mode 100644 Presentation.Web/Models/API/V1/Organizations/StsOrganizationConnectionResponseDTO.cs delete mode 100644 Presentation.Web/app/models/api/organization/sts-organization-connection-response-dto.ts create mode 100644 Presentation.Web/app/models/api/organization/sts-organization-synchronization-status-response-dto.ts diff --git a/Core.ApplicationServices/Model/Organizations/StsOrganizationSynchronizationDetails.cs b/Core.ApplicationServices/Model/Organizations/StsOrganizationSynchronizationDetails.cs index fecdf9650c..83ca24d2b4 100644 --- a/Core.ApplicationServices/Model/Organizations/StsOrganizationSynchronizationDetails.cs +++ b/Core.ApplicationServices/Model/Organizations/StsOrganizationSynchronizationDetails.cs @@ -1,4 +1,6 @@ -namespace Core.ApplicationServices.Model.Organizations +using Core.DomainServices.Model.StsOrganization; + +namespace Core.ApplicationServices.Model.Organizations { public class StsOrganizationSynchronizationDetails { @@ -7,14 +9,16 @@ public class StsOrganizationSynchronizationDetails public bool CanCreateConnection { get; } public bool CanUpdateConnection { get; } public bool CanDeleteConnection { get; } + public CheckConnectionError? CheckConnectionError { get; } - public StsOrganizationSynchronizationDetails(bool connected, int? synchronizationDepth, bool canCreateConnection, bool canUpdateConnection, bool canDeleteConnection) + public StsOrganizationSynchronizationDetails(bool connected, int? synchronizationDepth, bool canCreateConnection, bool canUpdateConnection, bool canDeleteConnection, CheckConnectionError? checkConnectionError) { Connected = connected; SynchronizationDepth = synchronizationDepth; CanCreateConnection = canCreateConnection; CanUpdateConnection = canUpdateConnection; CanDeleteConnection = canDeleteConnection; + CheckConnectionError = checkConnectionError; } } } diff --git a/Core.ApplicationServices/Organizations/IStsOrganizationSynchronizationService.cs b/Core.ApplicationServices/Organizations/IStsOrganizationSynchronizationService.cs index 2c985f3bf3..54e77ff05f 100644 --- a/Core.ApplicationServices/Organizations/IStsOrganizationSynchronizationService.cs +++ b/Core.ApplicationServices/Organizations/IStsOrganizationSynchronizationService.cs @@ -7,12 +7,6 @@ namespace Core.ApplicationServices.Organizations { public interface IStsOrganizationSynchronizationService { - /// - /// Validates if KITOS can read organization data from STS Organisation - /// - /// - /// - Maybe> ValidateConnection(Guid organizationId); /// /// Gets the synchronization details of the organization /// diff --git a/Core.ApplicationServices/Organizations/StsOrganizationSynchronizationService.cs b/Core.ApplicationServices/Organizations/StsOrganizationSynchronizationService.cs index 4302573baa..f9d49d2fa2 100644 --- a/Core.ApplicationServices/Organizations/StsOrganizationSynchronizationService.cs +++ b/Core.ApplicationServices/Organizations/StsOrganizationSynchronizationService.cs @@ -32,12 +32,6 @@ public StsOrganizationSynchronizationService( _authorizationContext = authorizationContext; } - public Maybe> ValidateConnection(Guid organizationId) - { - return GetOrganizationWithImportPermission(organizationId) - .Match(ValidateConnection, error => new DetailedOperationError(error.FailureType, CheckConnectionError.Unknown, error.Message.GetValueOrDefault())); - } - public Result GetSynchronizationDetails(Guid organizationId) { return GetOrganizationWithImportPermission(organizationId) @@ -47,7 +41,15 @@ public Result GetSynchron var isConnected = organization.StsOrganizationConnection?.Connected == true; var canCreateConnection = currentConnectionStatus.IsNone && organization.StsOrganizationConnection?.Connected != true; var canUpdateConnection = currentConnectionStatus.IsNone && isConnected; - return new StsOrganizationSynchronizationDetails(isConnected, organization.StsOrganizationConnection?.SynchronizationDepth, canCreateConnection, canUpdateConnection, isConnected); + return new StsOrganizationSynchronizationDetails + ( + isConnected, + organization.StsOrganizationConnection?.SynchronizationDepth, + canCreateConnection, + canUpdateConnection, + isConnected, + currentConnectionStatus.Match(error => error.Detail, () => default(CheckConnectionError?)) + ); }); } diff --git a/Presentation.Web/Controllers/API/V1/StsOrganizationSynchronizationController.cs b/Presentation.Web/Controllers/API/V1/StsOrganizationSynchronizationController.cs index ad279b99f6..8e8db0ee77 100644 --- a/Presentation.Web/Controllers/API/V1/StsOrganizationSynchronizationController.cs +++ b/Presentation.Web/Controllers/API/V1/StsOrganizationSynchronizationController.cs @@ -32,34 +32,7 @@ public HttpResponseMessage GetSnapshotFromStsOrganization(Guid organizationId, u } [HttpGet] - [Route("connection-status")] //TODO: Obsolete this endpoint and add the access status to the other one! - public HttpResponseMessage GetConnectionStatus(Guid organizationId) - { - return _stsOrganizationSynchronizationService - .ValidateConnection(organizationId) - .Match - ( - error => Ok(new StsOrganizationConnectionResponseDTO - { - AccessStatus = new StsOrganizationAccessStatusResponseDTO - { - AccessGranted = false, - Error = error.Detail - } - }), - () => Ok(new StsOrganizationConnectionResponseDTO - { - AccessStatus = new StsOrganizationAccessStatusResponseDTO - { - AccessGranted = true - } - }) - ); - - } - - [HttpGet] - [Route("synchronization-status")] + [Route("connection-status")] public HttpResponseMessage GetSynchronizationStatus(Guid organizationId) { return _stsOrganizationSynchronizationService @@ -70,7 +43,12 @@ public HttpResponseMessage GetSynchronizationStatus(Guid organizationId) SynchronizationDepth = details.SynchronizationDepth, CanCreateConnection = details.CanCreateConnection, CanDeleteConnection = details.CanDeleteConnection, - CanUpdateConnection = details.CanUpdateConnection + CanUpdateConnection = details.CanUpdateConnection, + AccessStatus = new StsOrganizationAccessStatusResponseDTO + { + AccessGranted = details.CheckConnectionError == null, + Error = details.CheckConnectionError + } }) .Match(Ok, FromOperationError); diff --git a/Presentation.Web/Models/API/V1/Organizations/StsOrganizationConnectionResponseDTO.cs b/Presentation.Web/Models/API/V1/Organizations/StsOrganizationConnectionResponseDTO.cs deleted file mode 100644 index 033d0b4331..0000000000 --- a/Presentation.Web/Models/API/V1/Organizations/StsOrganizationConnectionResponseDTO.cs +++ /dev/null @@ -1,10 +0,0 @@ -namespace Presentation.Web.Models.API.V1.Organizations -{ - public class StsOrganizationConnectionResponseDTO - { - /// - /// Describes the access status from KITOS to the organization in the FK Organisation system - /// - public StsOrganizationAccessStatusResponseDTO AccessStatus { get; set; } - } -} \ No newline at end of file diff --git a/Presentation.Web/Models/API/V1/Organizations/StsOrganizationSynchronizationDetailsResponseDTO.cs b/Presentation.Web/Models/API/V1/Organizations/StsOrganizationSynchronizationDetailsResponseDTO.cs index 9d02674b0d..1968ba16e1 100644 --- a/Presentation.Web/Models/API/V1/Organizations/StsOrganizationSynchronizationDetailsResponseDTO.cs +++ b/Presentation.Web/Models/API/V1/Organizations/StsOrganizationSynchronizationDetailsResponseDTO.cs @@ -2,6 +2,7 @@ { public class StsOrganizationSynchronizationDetailsResponseDTO { + public StsOrganizationAccessStatusResponseDTO AccessStatus { get; set; } public bool Connected { get; set; } public int? SynchronizationDepth { get; set; } public bool CanCreateConnection { get; set; } diff --git a/Presentation.Web/Presentation.Web.csproj b/Presentation.Web/Presentation.Web.csproj index 716ac60249..5f69cb9ebf 100644 --- a/Presentation.Web/Presentation.Web.csproj +++ b/Presentation.Web/Presentation.Web.csproj @@ -367,7 +367,7 @@ - + @@ -402,7 +402,6 @@ - diff --git a/Presentation.Web/app/models/api/organization/sts-organization-connection-response-dto.ts b/Presentation.Web/app/models/api/organization/sts-organization-connection-response-dto.ts deleted file mode 100644 index 115ca3fb93..0000000000 --- a/Presentation.Web/app/models/api/organization/sts-organization-connection-response-dto.ts +++ /dev/null @@ -1,5 +0,0 @@ -module Kitos.Models.Api.Organization { - export interface StsOrganizationConnectionResponseDTO { - accessStatus: StsOrganizationAccessStatusResponseDTO - } -} \ No newline at end of file diff --git a/Presentation.Web/app/models/api/organization/sts-organization-synchronization-status-response-dto.ts b/Presentation.Web/app/models/api/organization/sts-organization-synchronization-status-response-dto.ts new file mode 100644 index 0000000000..1c8ff1d09f --- /dev/null +++ b/Presentation.Web/app/models/api/organization/sts-organization-synchronization-status-response-dto.ts @@ -0,0 +1,10 @@ +module Kitos.Models.Api.Organization { + export interface StsOrganizationSynchronizationStatusResponseDTO { + accessStatus: StsOrganizationAccessStatusResponseDTO + connected: boolean + synchronizationDepth: number | null + canCreateConnection: boolean + canUpdateConnection: boolean + canDeleteConnection: boolean + } +} \ No newline at end of file diff --git a/Presentation.Web/app/services/sts-organization-sync-service.ts b/Presentation.Web/app/services/sts-organization-sync-service.ts index 7bab180979..ee58c97da9 100644 --- a/Presentation.Web/app/services/sts-organization-sync-service.ts +++ b/Presentation.Web/app/services/sts-organization-sync-service.ts @@ -1,6 +1,6 @@ module Kitos.Services.Organization { export interface IStsOrganizationSyncService { - getConnectionStatus(organizationId: string): ng.IPromise + getConnectionStatus(organizationId: string): ng.IPromise } export class StsOrganizationSyncService implements IStsOrganizationSyncService { @@ -16,19 +16,25 @@ return `api/v1/organizations/${organizationUuid}/sts-organization-synchronization`; } - getConnectionStatus(organizationUuid: string): ng.IPromise { - const cacheKey = `FK_CONNECTION_STATUS_${organizationUuid}`; - const result = this.inMemoryCacheService.getEntry(cacheKey); + private getCacheKey(organizationUuid: string) { + return `FK_CONNECTION_STATUS_${organizationUuid}`; + } + + getConnectionStatus(organizationUuid: string): ng.IPromise { + const cacheKey = this.getCacheKey(organizationUuid); + const result = this.inMemoryCacheService.getEntry(cacheKey); if (result != null) { return this.$q.resolve(result); } return this.genericApiWrapper - .getDataFromUrl(`${this.getBasePath(organizationUuid)}/connection-status`) + .getDataFromUrl(`${this.getBasePath(organizationUuid)}/connection-status`) .then(connectionStatus => { this.inMemoryCacheService.setEntry(cacheKey, connectionStatus, Kitos.Shared.Time.Offset.compute(Kitos.Shared.Time.TimeUnit.Minutes, 1)); return connectionStatus; }); } + + //TODO: Purge cache after doing a command! } app.service("stsOrganizationSyncService", StsOrganizationSyncService); diff --git a/Tests.Integration.Presentation.Web/Organizations/StsOrganizationSynchronizationApiTest.cs b/Tests.Integration.Presentation.Web/Organizations/StsOrganizationSynchronizationApiTest.cs index 90b926ae55..ced088fa92 100644 --- a/Tests.Integration.Presentation.Web/Organizations/StsOrganizationSynchronizationApiTest.cs +++ b/Tests.Integration.Presentation.Web/Organizations/StsOrganizationSynchronizationApiTest.cs @@ -61,7 +61,7 @@ public async Task Can_GET_ConnectionStatus(string cvr, bool expectConnected, Che //Assert Assert.Equal(HttpStatusCode.OK, response.StatusCode); - var root = await response.ReadResponseBodyAsKitosApiResponseAsync(); + var root = await response.ReadResponseBodyAsKitosApiResponseAsync(); Assert.Equal(expectConnected, root.AccessStatus.AccessGranted); Assert.Equal(expectedError, root.AccessStatus.Error); } From db52b95aa5b2f1e2bad3be4138916a7a855436c0 Mon Sep 17 00:00:00 2001 From: Aleksander Naskret Date: Mon, 3 Oct 2022 10:34:12 +0200 Subject: [PATCH 030/272] added sql script --- .../Infrastructure.DataAccess.csproj | 4 ++- ...rate_Users_Not_Associated_With_Any_Org.sql | 27 +++++++++++++++++++ 2 files changed, 30 insertions(+), 1 deletion(-) create mode 100644 Infrastructure.DataAccess/Migrations/SQLScripts/Migrate_Users_Not_Associated_With_Any_Org.sql diff --git a/Infrastructure.DataAccess/Infrastructure.DataAccess.csproj b/Infrastructure.DataAccess/Infrastructure.DataAccess.csproj index 2f5dedaf37..786fabdea3 100644 --- a/Infrastructure.DataAccess/Infrastructure.DataAccess.csproj +++ b/Infrastructure.DataAccess/Infrastructure.DataAccess.csproj @@ -1574,7 +1574,9 @@ - + + + diff --git a/Infrastructure.DataAccess/Migrations/SQLScripts/Migrate_Users_Not_Associated_With_Any_Org.sql b/Infrastructure.DataAccess/Migrations/SQLScripts/Migrate_Users_Not_Associated_With_Any_Org.sql new file mode 100644 index 0000000000..3c7489cc02 --- /dev/null +++ b/Infrastructure.DataAccess/Migrations/SQLScripts/Migrate_Users_Not_Associated_With_Any_Org.sql @@ -0,0 +1,27 @@ +/* +User story reference: + https://os2web.atlassian.net/browse/KITOSUDV-3422 + +Content: + Sets Users with no assossiated Organizations as deleted +*/ + +UPDATE [User] +SET + Name = 'Slettet bruger', + LockedOutDate = GETDATE(), + Email = NEWID() + '_deleted_user@kitos.dk', + PhoneNumber = null, + LastName = (CASE + WHEN LastName IS NULL THEN '' + ELSE LastName + END) + ' (SLETTET)', + DeletedDate = GETDATE(), + Deleted = 1, + IsGlobalAdmin = 0, + HasApiAccess = 0, + HasStakeHolderAccess = 0 +FROM [User] T0 +LEFT JOIN OrganizationRights T1 +ON T0.Id = T1.UserId +WHERE T1.Id IS NULL \ No newline at end of file From cf1a18f1880683fdbe83574bebe3fa9dd673c860 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Morten=20Remb=C3=B8l=20Jacobsen?= Date: Mon, 3 Oct 2022 11:32:35 +0200 Subject: [PATCH 031/272] added new sync status --- ...fk-organization-import-config.component.ts | 62 +++++++++++++------ .../fk-organization-import-config.view.html | 13 ++++ 2 files changed, 55 insertions(+), 20 deletions(-) diff --git a/Presentation.Web/app/components/local-config/import/fk-organization-import-config.component.ts b/Presentation.Web/app/components/local-config/import/fk-organization-import-config.component.ts index f019ffa699..ab58ee1a29 100644 --- a/Presentation.Web/app/components/local-config/import/fk-organization-import-config.component.ts +++ b/Presentation.Web/app/components/local-config/import/fk-organization-import-config.component.ts @@ -12,14 +12,23 @@ }; } + interface IFkOrganizationSynchronizationStatus { + connected: boolean + synchronizationDepth: number | null + } + interface IFkOrganizationImportController extends ng.IComponentController { currentOrganizationUuid: string + accessGranted: boolean | null; + accessError: string | null + synchronizationStatus: IFkOrganizationSynchronizationStatus | null } class FkOrganizationImportController implements IFkOrganizationImportController { currentOrganizationUuid: string | null = null; //note set by bindings accessGranted: boolean | null = null; accessError: string | null = null; + synchronizationStatus: IFkOrganizationSynchronizationStatus | null = null; static $inject: string[] = ["stsOrganizationSyncService"]; constructor(private readonly stsOrganizationSyncService: Kitos.Services.Organization.IStsOrganizationSyncService) { @@ -32,26 +41,8 @@ this.stsOrganizationSyncService .getConnectionStatus(this.currentOrganizationUuid) .then(result => { - if (result.accessStatus.accessGranted) { - this.accessGranted = true; - } else { - this.accessGranted = false; - switch (result.accessStatus.error) { - case Models.Api.Organization.CheckConnectionError.ExistingServiceAgreementIssue: - this.accessError = "Der er problemer med den eksisterende serviceaftale, der giver KITOS adgang til data fra din kommune i FK Organisatoin. Kontakt venligst den KITOS ansvarlige i din kommune for hjælp." - break; - case Models.Api.Organization.CheckConnectionError.InvalidCvrOnOrganization: - this.accessError = "Der enten mangler eller er registreret et ugyldigt CVR nummer på din kommune i KITOS." - break; - case Models.Api.Organization.CheckConnectionError.MissingServiceAgreement: - this.accessError = "Din organisation mangler en gyldig serviceaftale der giver KITOS adgang til data fra din kommune i FK Organisation. Kontakt venligst den KITOS ansvarlige i din kommune for hjælp." - break; - case Models.Api.Organization.CheckConnectionError.Unknown: //intended fallthrough - default: - this.accessError = "Der skete en ukendt fejl ifm. tjek for forbindelsen til FK Organisation. Genindlæs venligst siden for at prøve igen." - break; - } - } + this.bindAccessProperties(result); + this.bindSynchronizationStatus(result); }, error => { console.error(error); this.accessGranted = false; @@ -59,6 +50,37 @@ }); } } + + private bindSynchronizationStatus(result: Models.Api.Organization.StsOrganizationSynchronizationStatusResponseDTO) { + this.synchronizationStatus = { + connected: result.connected, + synchronizationDepth: result.synchronizationDepth + }; + //TODO: Bind the available commands + } + + private bindAccessProperties(result: Models.Api.Organization.StsOrganizationSynchronizationStatusResponseDTO) { + if (result.accessStatus.accessGranted) { + this.accessGranted = true; + } else { + this.accessGranted = false; + switch (result.accessStatus.error) { + case Models.Api.Organization.CheckConnectionError.ExistingServiceAgreementIssue: + this.accessError = "Der er problemer med den eksisterende serviceaftale, der giver KITOS adgang til data fra din kommune i FK Organisatoin. Kontakt venligst den KITOS ansvarlige i din kommune for hjælp."; + break; + case Models.Api.Organization.CheckConnectionError.InvalidCvrOnOrganization: + this.accessError = "Der enten mangler eller er registreret et ugyldigt CVR nummer på din kommune i KITOS."; + break; + case Models.Api.Organization.CheckConnectionError.MissingServiceAgreement: + this.accessError = "Din organisation mangler en gyldig serviceaftale der giver KITOS adgang til data fra din kommune i FK Organisation. Kontakt venligst den KITOS ansvarlige i din kommune for hjælp."; + break; + case Models.Api.Organization.CheckConnectionError.Unknown: //intended fallthrough + default: + this.accessError = "Der skete en ukendt fejl ifm. tjek for forbindelsen til FK Organisation. Genindlæs venligst siden for at prøve igen."; + break; + } + } + } } angular.module("app") .component("fkOrgnizationImportConfig", setupComponent()); diff --git a/Presentation.Web/app/components/local-config/import/fk-organization-import-config.view.html b/Presentation.Web/app/components/local-config/import/fk-organization-import-config.view.html index 75f87e4531..c7102af57d 100644 --- a/Presentation.Web/app/components/local-config/import/fk-organization-import-config.view.html +++ b/Presentation.Web/app/components/local-config/import/fk-organization-import-config.view.html @@ -9,3 +9,16 @@ {{::ctrl.accessError}}
+
+ +
+ + Organisationen er forbundet til FK Organisation + + + + KITOS er forbundet i "{{::ctrl.synchronizationStatus.synchronizationDepth}}" niveauer fra FK Organisation. + + Organisationen er ikke forbundet til FK Organisation +
+
\ No newline at end of file From 7e29a95043e40c4dacff68c1252e76e0123d6c51 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Morten=20Remb=C3=B8l=20Jacobsen?= Date: Mon, 3 Oct 2022 13:41:40 +0200 Subject: [PATCH 032/272] added button layout --- Presentation.Web/Content/less/kitos.less | 4 + ...fk-organization-import-config.component.ts | 85 ++++++++++++++++--- .../fk-organization-import-config.view.html | 10 +++ 3 files changed, 89 insertions(+), 10 deletions(-) diff --git a/Presentation.Web/Content/less/kitos.less b/Presentation.Web/Content/less/kitos.less index 293c5636c4..5b0f395c15 100644 --- a/Presentation.Web/Content/less/kitos.less +++ b/Presentation.Web/Content/less/kitos.less @@ -1594,3 +1594,7 @@ tbody.bordered > tr > td { .faded-gray { color: #888; } + +.right-margin-5px { + margin-right: 5px; +} \ No newline at end of file diff --git a/Presentation.Web/app/components/local-config/import/fk-organization-import-config.component.ts b/Presentation.Web/app/components/local-config/import/fk-organization-import-config.component.ts index ab58ee1a29..63b4120eed 100644 --- a/Presentation.Web/app/components/local-config/import/fk-organization-import-config.component.ts +++ b/Presentation.Web/app/components/local-config/import/fk-organization-import-config.component.ts @@ -12,6 +12,20 @@ }; } + enum CommandCategory { + Create = "create", + Update = "update", + Delete = "delete" + } + + interface IFkOrganizationCommand { + id: string + text: string + onClick: () => void + enabled: boolean + category: CommandCategory + } + interface IFkOrganizationSynchronizationStatus { connected: boolean synchronizationDepth: number | null @@ -22,6 +36,7 @@ accessGranted: boolean | null; accessError: string | null synchronizationStatus: IFkOrganizationSynchronizationStatus | null + commands: Array | null; } class FkOrganizationImportController implements IFkOrganizationImportController { @@ -29,6 +44,7 @@ accessGranted: boolean | null = null; accessError: string | null = null; synchronizationStatus: IFkOrganizationSynchronizationStatus | null = null; + commands: Array | null = null; static $inject: string[] = ["stsOrganizationSyncService"]; constructor(private readonly stsOrganizationSyncService: Kitos.Services.Organization.IStsOrganizationSyncService) { @@ -38,25 +54,74 @@ if (this.currentOrganizationUuid === null) { console.error("missing attribute: 'currentOrganizationUuid'"); } else { - this.stsOrganizationSyncService - .getConnectionStatus(this.currentOrganizationUuid) - .then(result => { - this.bindAccessProperties(result); - this.bindSynchronizationStatus(result); - }, error => { - console.error(error); - this.accessGranted = false; - this.accessError = "Der skete en fejl ifm. tjek for forbindelsen til FK Organisation. Genindlæs venligst siden for at prøve igen." - }); + this.initialize(); } } + private initialize() { + this.stsOrganizationSyncService + .getConnectionStatus(this.currentOrganizationUuid) + .then(result => { + this.bindAccessProperties(result); + this.bindSynchronizationStatus(result); + this.bindCommands(result); + }, error => { + console.error(error); + this.accessGranted = false; + this.accessError = "Der skete en fejl ifm. tjek for forbindelsen til FK Organisation. Genindlæs venligst siden for at prøve igen."; + }); + } + + private bindCommands(result: Models.Api.Organization.StsOrganizationSynchronizationStatusResponseDTO) { + const newCommands: Array = []; + //if (result.connected) { + newCommands.push({ + id: "updateSync", + text: "Rediger", + category: CommandCategory.Update, + enabled: result.canUpdateConnection, + onClick: () => { + //TODO: https://os2web.atlassian.net/browse/KITOSUDV-3313 + // NOTE: Remember to rebind + console.log("UPDATE"); + } + }); + newCommands.push({ + id: "breakSync", + text: "Afbryd", + category: CommandCategory.Delete, + enabled: result.canDeleteConnection, + onClick: () => { + //TODO: https://os2web.atlassian.net/browse/KITOSUDV-3320 + // NOTE: Remember to rebind + console.log("DELETE"); + } + }); + //} else { + newCommands.push({ + id: "createSync", + text: "Forbind", + category: CommandCategory.Create, + enabled: result.canCreateConnection, + onClick: () => { + //TODO - open a dialog! + console.log("CREATE"); + } + }); + //} + + this.commands = newCommands; + } + private bindSynchronizationStatus(result: Models.Api.Organization.StsOrganizationSynchronizationStatusResponseDTO) { this.synchronizationStatus = { connected: result.connected, synchronizationDepth: result.synchronizationDepth }; //TODO: Bind the available commands + //TODO: Consider + // TODO: - Dialog or in-page flow? + // TODO: Buttons... same color or?.. } private bindAccessProperties(result: Models.Api.Organization.StsOrganizationSynchronizationStatusResponseDTO) { diff --git a/Presentation.Web/app/components/local-config/import/fk-organization-import-config.view.html b/Presentation.Web/app/components/local-config/import/fk-organization-import-config.view.html index c7102af57d..81a6c85f72 100644 --- a/Presentation.Web/app/components/local-config/import/fk-organization-import-config.view.html +++ b/Presentation.Web/app/components/local-config/import/fk-organization-import-config.view.html @@ -21,4 +21,14 @@ Organisationen er ikke forbundet til FK Organisation
+ +
+
+
\ No newline at end of file From 8e8379d9a78a196078f0bedd92397348ae8fb1f6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Morten=20Remb=C3=B8l=20Jacobsen?= Date: Mon, 3 Oct 2022 14:38:12 +0200 Subject: [PATCH 033/272] added "creation" to frontend service --- ...fk-organization-import-config.component.ts | 14 +++++++---- .../fk-organization-import-config.view.html | 2 +- .../app/services/generic/ApiUseCaseFactory.ts | 8 +++++++ .../services/sts-organization-sync-service.ts | 23 +++++++++++++++---- 4 files changed, 37 insertions(+), 10 deletions(-) diff --git a/Presentation.Web/app/components/local-config/import/fk-organization-import-config.component.ts b/Presentation.Web/app/components/local-config/import/fk-organization-import-config.component.ts index 63b4120eed..8a70705210 100644 --- a/Presentation.Web/app/components/local-config/import/fk-organization-import-config.component.ts +++ b/Presentation.Web/app/components/local-config/import/fk-organization-import-config.component.ts @@ -54,11 +54,11 @@ if (this.currentOrganizationUuid === null) { console.error("missing attribute: 'currentOrganizationUuid'"); } else { - this.initialize(); + this.loadState(); } } - private initialize() { + private loadState() { this.stsOrganizationSyncService .getConnectionStatus(this.currentOrganizationUuid) .then(result => { @@ -74,7 +74,7 @@ private bindCommands(result: Models.Api.Organization.StsOrganizationSynchronizationStatusResponseDTO) { const newCommands: Array = []; - //if (result.connected) { + if (result.connected) { newCommands.push({ id: "updateSync", text: "Rediger", @@ -97,7 +97,7 @@ console.log("DELETE"); } }); - //} else { + } else { newCommands.push({ id: "createSync", text: "Forbind", @@ -106,9 +106,13 @@ onClick: () => { //TODO - open a dialog! console.log("CREATE"); + //TODO: Open the dialog in stead + this.stsOrganizationSyncService + .createConnection(this.currentOrganizationUuid, null) //TODO: Get second arg + .then(() => this.loadState()); } }); - //} + } this.commands = newCommands; } diff --git a/Presentation.Web/app/components/local-config/import/fk-organization-import-config.view.html b/Presentation.Web/app/components/local-config/import/fk-organization-import-config.view.html index 81a6c85f72..4e35ef3b82 100644 --- a/Presentation.Web/app/components/local-config/import/fk-organization-import-config.view.html +++ b/Presentation.Web/app/components/local-config/import/fk-organization-import-config.view.html @@ -28,7 +28,7 @@ class="btn right-margin-5px" ng-class="{'btn-primary': command.category === 'create' || command.category === 'update' , 'btn-danger': command.category == 'delete'}" ng-click="command.onClick()" - ng-disabled="command.disabled"> + ng-disabled="!command.enabled"> {{::command.text}} \ No newline at end of file diff --git a/Presentation.Web/app/services/generic/ApiUseCaseFactory.ts b/Presentation.Web/app/services/generic/ApiUseCaseFactory.ts index 57096bf6cc..53a37ab83d 100644 --- a/Presentation.Web/app/services/generic/ApiUseCaseFactory.ts +++ b/Presentation.Web/app/services/generic/ApiUseCaseFactory.ts @@ -99,6 +99,7 @@ createDeletion(objectName: string, change: ApiCall): AsyncApiChangeUseCase; createAssignmentRemoval(apiCall: ApiCall): AsyncApiChangeUseCase; createAssignmentCreation(apiCall: ApiCall): AsyncApiChangeUseCase; + createCreation(objectName: string, change: ApiCall): AsyncApiChangeUseCase; } export class ApiUseCaseFactory implements IApiUseCaseFactory { @@ -108,6 +109,13 @@ } + createCreation(objectName: string, change: ApiCall): AsyncApiChangeUseCase { + if (!change) { + throw new Error("apiCall must be defined"); + } + return new AsyncApiChangeUseCase(this.notify, change, objectName, ChangeType.Creation); + } + createDeletion(objectName: string, change: () => angular.IPromise): AsyncApiChangeUseCase { if (!change) { throw new Error("apiCall must be defined"); diff --git a/Presentation.Web/app/services/sts-organization-sync-service.ts b/Presentation.Web/app/services/sts-organization-sync-service.ts index ee58c97da9..72525d6473 100644 --- a/Presentation.Web/app/services/sts-organization-sync-service.ts +++ b/Presentation.Web/app/services/sts-organization-sync-service.ts @@ -1,15 +1,17 @@ module Kitos.Services.Organization { export interface IStsOrganizationSyncService { - getConnectionStatus(organizationId: string): ng.IPromise + getConnectionStatus(organizationUuid: string): ng.IPromise + createConnection(organizationUuidid: string, synchronizationDepth: number | null): ng.IPromise } export class StsOrganizationSyncService implements IStsOrganizationSyncService { - static $inject = ["genericApiWrapper", "inMemoryCacheService", "$q"]; + static $inject = ["genericApiWrapper", "inMemoryCacheService", "$q", "apiUseCaseFactory"]; constructor( private readonly genericApiWrapper: Services.Generic.ApiWrapper, private readonly inMemoryCacheService: Kitos.Shared.Caching.IInMemoryCacheService, - private readonly $q: ng.IQService) { + private readonly $q: ng.IQService, + private readonly apiUseCaseFactory: Services.Generic.IApiUseCaseFactory) { } private getBasePath(organizationUuid: string) { @@ -20,6 +22,10 @@ return `FK_CONNECTION_STATUS_${organizationUuid}`; } + private purgeCache(organizationUuid: string) { + this.inMemoryCacheService.deleteEntry(this.getCacheKey(organizationUuid)); + } + getConnectionStatus(organizationUuid: string): ng.IPromise { const cacheKey = this.getCacheKey(organizationUuid); const result = this.inMemoryCacheService.getEntry(cacheKey); @@ -34,7 +40,16 @@ }); } - //TODO: Purge cache after doing a command! + createConnection(organizationUuidid: string, synchronizationDepth: number | null): ng.IPromise { + return this.apiUseCaseFactory.createCreation("Forbindelse til FK Organisation", () => { + return this.genericApiWrapper.post(`${this.getBasePath(organizationUuidid)}/connection`, { + synchronizationDepth: synchronizationDepth + }); + }).executeAsync(() => { + //Clear cache after + this.purgeCache(organizationUuidid); + }); + } } app.service("stsOrganizationSyncService", StsOrganizationSyncService); From 4445beb18a49232418f0fc2f1a4f60cb6d8eb5f2 Mon Sep 17 00:00:00 2001 From: Aleksander Naskret Date: Mon, 3 Oct 2022 10:46:53 +0200 Subject: [PATCH 034/272] added script call to the migration --- .../202209301046217_RemovedEmailBeforeDeletion.cs | 8 +++++--- .../Migrate_Users_Not_Associated_With_Any_Org.sql | 2 +- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/Infrastructure.DataAccess/Migrations/202209301046217_RemovedEmailBeforeDeletion.cs b/Infrastructure.DataAccess/Migrations/202209301046217_RemovedEmailBeforeDeletion.cs index 5a00dd17a6..97c39f73de 100644 --- a/Infrastructure.DataAccess/Migrations/202209301046217_RemovedEmailBeforeDeletion.cs +++ b/Infrastructure.DataAccess/Migrations/202209301046217_RemovedEmailBeforeDeletion.cs @@ -1,6 +1,7 @@ -namespace Infrastructure.DataAccess.Migrations +using Infrastructure.DataAccess.Tools; + +namespace Infrastructure.DataAccess.Migrations { - using System; using System.Data.Entity.Migrations; public partial class RemovedEmailBeforeDeletion : DbMigration @@ -13,8 +14,9 @@ UPDATE [User] SET Name = 'Slettet bruger' WHERE Deleted = 1;" ); + SqlResource(SqlMigrationScriptRepository.GetResourceName("Migrate_Users_Not_Associated_With_Any_Org.sql")); } - + public override void Down() { AddColumn("dbo.User", "EmailBeforeDeletion", c => c.String()); diff --git a/Infrastructure.DataAccess/Migrations/SQLScripts/Migrate_Users_Not_Associated_With_Any_Org.sql b/Infrastructure.DataAccess/Migrations/SQLScripts/Migrate_Users_Not_Associated_With_Any_Org.sql index 3c7489cc02..83636f2dce 100644 --- a/Infrastructure.DataAccess/Migrations/SQLScripts/Migrate_Users_Not_Associated_With_Any_Org.sql +++ b/Infrastructure.DataAccess/Migrations/SQLScripts/Migrate_Users_Not_Associated_With_Any_Org.sql @@ -24,4 +24,4 @@ SET FROM [User] T0 LEFT JOIN OrganizationRights T1 ON T0.Id = T1.UserId -WHERE T1.Id IS NULL \ No newline at end of file +WHERE T1.Id IS NULL AND T0.Deleted = 0 \ No newline at end of file From bef8bfbea662b2c8b01babb693592dc1f058495d Mon Sep 17 00:00:00 2001 From: Aleksander Naskret Date: Tue, 4 Oct 2022 09:17:28 +0200 Subject: [PATCH 035/272] fix script --- .../Infrastructure.DataAccess.csproj | 2 +- ...209301046217_RemovedEmailBeforeDeletion.cs | 1 + ...rate_Users_Not_Associated_With_Any_Org.sql | 40 ++++++++++--------- 3 files changed, 23 insertions(+), 20 deletions(-) diff --git a/Infrastructure.DataAccess/Infrastructure.DataAccess.csproj b/Infrastructure.DataAccess/Infrastructure.DataAccess.csproj index 0d6279bd94..995688e4a1 100644 --- a/Infrastructure.DataAccess/Infrastructure.DataAccess.csproj +++ b/Infrastructure.DataAccess/Infrastructure.DataAccess.csproj @@ -1582,7 +1582,7 @@ - + diff --git a/Infrastructure.DataAccess/Migrations/202209301046217_RemovedEmailBeforeDeletion.cs b/Infrastructure.DataAccess/Migrations/202209301046217_RemovedEmailBeforeDeletion.cs index 97c39f73de..35d6f9efa2 100644 --- a/Infrastructure.DataAccess/Migrations/202209301046217_RemovedEmailBeforeDeletion.cs +++ b/Infrastructure.DataAccess/Migrations/202209301046217_RemovedEmailBeforeDeletion.cs @@ -14,6 +14,7 @@ UPDATE [User] SET Name = 'Slettet bruger' WHERE Deleted = 1;" ); + SqlResource(SqlMigrationScriptRepository.GetResourceName("Migrate_Users_Not_Associated_With_Any_Org.sql")); } diff --git a/Infrastructure.DataAccess/Migrations/SQLScripts/Migrate_Users_Not_Associated_With_Any_Org.sql b/Infrastructure.DataAccess/Migrations/SQLScripts/Migrate_Users_Not_Associated_With_Any_Org.sql index 83636f2dce..088dee6ab9 100644 --- a/Infrastructure.DataAccess/Migrations/SQLScripts/Migrate_Users_Not_Associated_With_Any_Org.sql +++ b/Infrastructure.DataAccess/Migrations/SQLScripts/Migrate_Users_Not_Associated_With_Any_Org.sql @@ -6,22 +6,24 @@ Content: Sets Users with no assossiated Organizations as deleted */ -UPDATE [User] -SET - Name = 'Slettet bruger', - LockedOutDate = GETDATE(), - Email = NEWID() + '_deleted_user@kitos.dk', - PhoneNumber = null, - LastName = (CASE - WHEN LastName IS NULL THEN '' - ELSE LastName - END) + ' (SLETTET)', - DeletedDate = GETDATE(), - Deleted = 1, - IsGlobalAdmin = 0, - HasApiAccess = 0, - HasStakeHolderAccess = 0 -FROM [User] T0 -LEFT JOIN OrganizationRights T1 -ON T0.Id = T1.UserId -WHERE T1.Id IS NULL AND T0.Deleted = 0 \ No newline at end of file +BEGIN + UPDATE [User] + SET + Name = 'Slettet bruger', + LockedOutDate = GETDATE(), + Email = CONVERT(NVARCHAR(36), NEWID()) + '_deleted_user@kitos.dk', + PhoneNumber = null, + LastName = (CASE + WHEN LastName IS NULL THEN '' + ELSE LastName + END) + ' (SLETTET)', + DeletedDate = GETDATE(), + Deleted = 1, + IsGlobalAdmin = 0, + HasApiAccess = 0, + HasStakeHolderAccess = 0 + FROM [User] T0 + LEFT JOIN OrganizationRights T1 + ON T0.Id = T1.UserId + WHERE T1.Id IS NULL AND T0.Deleted = 0; +END \ No newline at end of file From 9f19f397c8e294d1d70a10e272817694c45a5e86 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Morten=20Remb=C3=B8l=20Jacobsen?= Date: Tue, 4 Oct 2022 14:50:14 +0200 Subject: [PATCH 036/272] added the import dialog view and controller as well as control flow --- Presentation.Web/Presentation.Web.csproj | 2 + ...ation-import-config-import-modal.dialog.ts | 54 +++++++++++++++++++ ...ation-import-config-import-modal.view.html | 19 +++++++ ...fk-organization-import-config.component.ts | 18 ++++--- 4 files changed, 85 insertions(+), 8 deletions(-) create mode 100644 Presentation.Web/app/components/local-config/import/fk-organization-import-config-import-modal.dialog.ts create mode 100644 Presentation.Web/app/components/local-config/import/fk-organization-import-config-import-modal.view.html diff --git a/Presentation.Web/Presentation.Web.csproj b/Presentation.Web/Presentation.Web.csproj index e3a85e6284..b50368c1a4 100644 --- a/Presentation.Web/Presentation.Web.csproj +++ b/Presentation.Web/Presentation.Web.csproj @@ -356,6 +356,7 @@ + @@ -641,6 +642,7 @@ + diff --git a/Presentation.Web/app/components/local-config/import/fk-organization-import-config-import-modal.dialog.ts b/Presentation.Web/app/components/local-config/import/fk-organization-import-config-import-modal.dialog.ts new file mode 100644 index 0000000000..656340aad7 --- /dev/null +++ b/Presentation.Web/app/components/local-config/import/fk-organization-import-config-import-modal.dialog.ts @@ -0,0 +1,54 @@ +module Kitos.LocalAdmin.FkOrganisation.Modals { + export enum FKOrganisationImportFlow { + Create = "create", + Update = "update" + } + + export interface IFKOrganisationImportDialogFactory { + open(flow: FKOrganisationImportFlow, organizationUuid: string, synchronizationDepth: number | null): ng.ui.bootstrap.IModalInstanceService + } + + export class FKOrganisationImportDialogFactory implements IFKOrganisationImportDialogFactory { + static $inject = ["$uibModal"]; + constructor(private readonly $uibModal: ng.ui.bootstrap.IModalService) { } + + open(flow: FKOrganisationImportFlow, organizationUuid: string, synchronizationDepth: number | null): ng.ui.bootstrap.IModalInstanceService { + return this.$uibModal.open({ + windowClass: "modal fade in", + templateUrl: "app/components/local-config/import/fk-organization-import-config-import-modal.view.html", + controller: FKOrganisationImportController, + controllerAs: "vm", + resolve: { + "flow": [() => flow], + "orgUuid": [() => organizationUuid], + "synchronizationDepth": [() => synchronizationDepth] + } + }); + } + } + + class FKOrganisationImportController { + static $inject = ["flow", "orgUuid", "synchronizationDepth", "stsOrganizationSyncService"]; + constructor( + readonly flow: FKOrganisationImportFlow, + private readonly organizationUuid: string, + private readonly synchronizationDepth: number | null, + private readonly stsOrganizationSyncService: Services.Organization.IStsOrganizationSyncService) { + //TODO: Once this becomes an edit dialog, also add the sy c depth + } + + $onInit() { + //TODO: Use this to begin load of the hierarchy from FK Organization so that it is ready for preview! + } + + performImport() { + this.stsOrganizationSyncService + .createConnection(this.organizationUuid, this.synchronizationDepth) + .then(() => { + //TODO: Then---close the modal instance + }); + } + } + + app.service("fkOrganisationImportDialogFactory", FKOrganisationImportDialogFactory) +} \ No newline at end of file diff --git a/Presentation.Web/app/components/local-config/import/fk-organization-import-config-import-modal.view.html b/Presentation.Web/app/components/local-config/import/fk-organization-import-config-import-modal.view.html new file mode 100644 index 0000000000..08854dc110 --- /dev/null +++ b/Presentation.Web/app/components/local-config/import/fk-organization-import-config-import-modal.view.html @@ -0,0 +1,19 @@ + + +
+ + + +
\ No newline at end of file diff --git a/Presentation.Web/app/components/local-config/import/fk-organization-import-config.component.ts b/Presentation.Web/app/components/local-config/import/fk-organization-import-config.component.ts index 8a70705210..d2cd01b550 100644 --- a/Presentation.Web/app/components/local-config/import/fk-organization-import-config.component.ts +++ b/Presentation.Web/app/components/local-config/import/fk-organization-import-config.component.ts @@ -46,8 +46,10 @@ synchronizationStatus: IFkOrganizationSynchronizationStatus | null = null; commands: Array | null = null; - static $inject: string[] = ["stsOrganizationSyncService"]; - constructor(private readonly stsOrganizationSyncService: Kitos.Services.Organization.IStsOrganizationSyncService) { + static $inject: string[] = ["stsOrganizationSyncService", "fkOrganisationImportDialogFactory"]; + constructor( + private readonly stsOrganizationSyncService: Kitos.Services.Organization.IStsOrganizationSyncService, + private readonly fkOrganisationImportDialogFactory: Kitos.LocalAdmin.FkOrganisation.Modals.IFKOrganisationImportDialogFactory) { } $onInit() { @@ -104,12 +106,12 @@ category: CommandCategory.Create, enabled: result.canCreateConnection, onClick: () => { - //TODO - open a dialog! - console.log("CREATE"); - //TODO: Open the dialog in stead - this.stsOrganizationSyncService - .createConnection(this.currentOrganizationUuid, null) //TODO: Get second arg - .then(() => this.loadState()); + this.fkOrganisationImportDialogFactory + .open(Kitos.LocalAdmin.FkOrganisation.Modals.FKOrganisationImportFlow.Create, this.currentOrganizationUuid, null) + .closed.then(() => { + //Reload state from backend if the dialog was closed + this.loadState(); + }); } }); } From d8edb94d8729a9ad069f53a6888875cfa1507383 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Morten=20Remb=C3=B8l=20Jacobsen?= Date: Wed, 5 Oct 2022 09:40:39 +0200 Subject: [PATCH 037/272] added loading-spinner component to use for async component loads --- .../Content/img/loading-spinner.gif | Bin 0 -> 20410 bytes Presentation.Web/Content/less/kitos.less | 7 +++- Presentation.Web/Presentation.Web.csproj | 3 ++ ...fk-organization-import-config.component.ts | 2 +- .../fk-organization-import-config.view.html | 5 ++- .../progress-spinner.component.ts | 35 ++++++++++++++++++ .../progress-spinner.view.html | 1 + 7 files changed, 50 insertions(+), 3 deletions(-) create mode 100644 Presentation.Web/Content/img/loading-spinner.gif create mode 100644 Presentation.Web/app/shared/progress-spinner/progress-spinner.component.ts create mode 100644 Presentation.Web/app/shared/progress-spinner/progress-spinner.view.html diff --git a/Presentation.Web/Content/img/loading-spinner.gif b/Presentation.Web/Content/img/loading-spinner.gif new file mode 100644 index 0000000000000000000000000000000000000000..32ac2b463bc9e29563eb5ac69da257fe8cdb2bfd GIT binary patch literal 20410 zcmdsgn-PV0!0m)Dk^GJR8+JHgc&sqDk>@< zDk$10pePPu6sHO*ietg4R;?Rt>$a`io;ReM?cTP#J^ypQoZ}bypda*iJ@>la`+3(2 z3zr9uPnAFtXaIs>B&^HRb@g;fL!^(MJgVDQC*TQGvsKq`TyH+s{KK0c=u~>emWqV< z1V10YjFlOezPj|{<%`C{jp+;0@7}+A>ddK>Y8fp{m=YQsEA#ObTOhz6=Kcg@(cpJ? z(_b|GGa>YQ<94;e-F8!N-LmuP6L$C2XG9!I{&KK!<;CyTxR44~-G$PVA1;QV#JwjD z5$)dG&l_wwIqh2NxgV0q=~hBbB0pV}Hy!qcoYRV@GSfZF!stW4A7*>kP4l+u zz@+rHxl@wxB4>z^BKVSXEs26VlPG+-_3v+g`uUf4#dI8GfmX%kL%BIv%2zb%aJC`8 z<9!KNqm_3TGu*cDu9A7u!kMDk%y8;MIqz2(e`+%t#xcF-lvNuHyD#quT>cEc-XZ(t zvMZkRu5R{&lnI{9c>DU1!}xJaQkZ^<{via??W^kWhqF6!2?t!n^x|4hrGWxpZI&Qz zglNkr&&4&N3Ob4!T;yFoxe)_AB2pOncu1!cw#tH%n90(19VW`I&8S~#=>%=rUNLA0 z?sp<@jMlsHphtSFRe*}whNVDPq%cA`z7F~ZQ>L0INy&~v@`Y&i8N8ws3b5WN7+Ke4 z@eTUm4|fszu<_sXX@T?B@6j+Eo8_pevLVS!vu8H|<9l#7Q4_F1r z0XPBn0CE5!KoI~Bm;~el;7f{10LFk}Kr$EsK)ab?05iZIj6=qJ0ysC15?~&T6@Wi$O%|A!$mmEgM_`%&?O=|;?0|s+*av+Q^xv^ZznARz zPn;JeM-Mb63@>wO9(p38vU0DSU&@NwIo>CtFzxad9#rKOzvyt-rx4^YU$t(14BlRg zT1(;OL7T2p=S)O}G_T6>C5djKAV@@0s|4GjKm6u&PD@1WJ9sih3+H@^5A zaVV#ke(ujw88g#%c!wZAaYYJSeT{kSla!w3DoG6zLIrqXUEgA!CzNj6X+*8J(!~5S)jL8@1SrLBOmKy_B{`>>(`X+lDSw4Hx zRjTmP($cj1r?xHMd-F?WXVIhvPVh}v=Xfcs=;zrXZKr8CNlwEd0X#o_pYcHmW8J%V zM~;v?wKIu!Cnt^XU(6Ny;a@MPOh?WyTk^8&yzLR?mw8qtwNb^&pY$aJ2Vt9fnRYOl z-z%!}?|2(JpX=rp(SK z-8>qTxoA%ahbC7UM~1j4FO~(eJ8<@cccp~R@V-fYIEmBGZyfp&Ypv^+Ap>hzagNZ_ zb@81rR(}r7$rc<@=7d!n@1twH?w01~BG^kqEZKqN3#cWcr8QI+cfB&gZ6k`4;}f5Y zAo^aV$+x zElA%MOUj`N>zq1J@&6ML9W~S$AUHoxdh9_CJjApni>h9*cLfgREc0k#U#a{^R|xkOdz0<7(S; zFjETR5j8cT`R7U`LnDVCjEgDcV4oU}@WVDfD~N1PqwqP_$oONiF3QjI^-?@fT2I`7 zv}QA(>C~TBzrV6ul7oMIEPFQtMdR(_24C5=17<|jRigLZn>dc|p5`%BA8}&&w|DhV z4U&Vo>*DE|zo4@<0u+B{+Bz=ugu3u+bVjvoC2AR4efy!Q$pUFb--2a@1?V0< zt6oVj%(k(7!QgV0D0rL^!Y;h3z4UZ0d-0;TDRrIqdH9MG^;Heln&~pKePFc#n>(R( zT`7_i{4E*Z=ECF-4|NqLH3tym7uR*aq=b)&fT;kH4n_zhJa{Pl z_dNdq?0@|ToMr1rh}Uuk8vVL!>zar5VIi_P#|Yi!%#UFWo?LY^;99liYsD;DjTYNM^y|)C6Moe)OFEpcZk16hTL{2##)6x z9_~W2=SEO5&P}J}L=}_adTxp^U**~ORj#c{g-INUg`Ef8t!wVaAZ-RQk7Bt3K4kYS zPQ>eZ^=8yrbS}JKAp~!TUR&Ls^RTG8T62gS@Y%W$a;4%3PdgXSnvjk?vQb)WJw@sM zz)LAvpcB}qj4#`LajSUFg~&2V@FX!c2oB}f-1}}~fP;H8nbl)IA;8LAw9~MmXq@`N zpaSX-X~?yjcymVRH#Kos+O*F&ieA|E*!)AWjo9LjaG#({nGGY(^u1-+vq#yiW5aXH z$S8NcKNTs(oK0GW7#x7R@=0z7f;IlNizx8QSvt|H8pP~~eNeS4@T+31d_s_?I&uJY zI%Gnty1%^uw%SB%iTBn-s`yrsHv`HZc;~e1*ocA*X}}@@i#_iRGiud>VFf4XhNkMW zBc#;_Iv)Pkn;)|3wV-sJHYk#6>_(p4Kk@4f#mbk=~ zL)nDaRQL}p<=->E)e^jFS>!ak7mda3w`46mc&ugh#yp3yLuDoCdh5f8$F$={wVM6z4cNGdz-FFjFO zWnpCgeB_?y#NfP32zT7xQ;PoB9@H#KjZxhOp;fEDi+>31~=a23M08fur zNSfwGF}!o7hCai*_nnKytAL!)pG58mpgc*r(A;ose{62Ex+cE35Xk*WFDK2B21)WKhN&EmF0ERlRG%VX<^K|vTw!JO(dg^ z6I3;$Th}$QEt_3pZ0wR|Q?rZHGUK)qi->j+f!w9T+3^cF(sX02wYE-4@D#^he1>?2 zlnd+9M)qQhEqxO#rJA2Z)3C(&Q#WF({k!Ja+E%|&cXf{3^qbkdKI;-{!KSc8DJG_~ zyTtOvGMA@@cIYvWeS<&$6inA#Vc1X&1BTk<8-WbmwHBm$4J0~VlkWcXSkcy87K)L9^|aa%a1h!B>{m8 zk{1Lwun&;7CNCcqXtS7@)cnjT5X69cz%)pFGxUIXAn_pOrE;m+b z5c=RT0CF6d2zWdIFE<|p0Q5l3!8rk>|DSp}$m@@#JX$``*c^W`0pv9jiZ$bYsGf6y zcB`t9j8C6~?9=Z3CY)f4BbjLT`(mMjhr?0xq+$n^H%M_|A*aLnphXC*N6S8KRi>r{~bW$b&yq^NR+ibejD@FN3ZtG>fM`Z-G(C5xT zC`siN%@N|hO|!-!s>5A|A5A8ZEYHq!RXOkiD-I%Ss4Tlabc8lIhrpsH(jy8}J5o1b z-U&Y07TjKg*bvXGPDB`yy)HER-HB%0=NxUUt_D)>p~7#|x7WOn$-h7Q^}C;Z(;~Nz zTOz!EeiZjTR@zsy_cE*qaBaBvQNa$1H{RHHAa_q#0Bv>xcH$RBcaOr_ zDNcK;huPuFZ%!lcm>wRSk3G0o6uU~DDtQ04Ak)4`dyh%0swlYmMo|R$O>hh6LhvoV z{o&YsA;uico(OyaSu1&{Bhz__hel+TFoi1R|1vZoz7$FHd*>9N`X*k54T{w-O~z)U zi3=G8wdUrH&kAf?{(TU~~%#jtQ3Px;1a27#JsIC83Y1@ZfJzB`Zy zbB`cUY;I&Fj{hIJ%EwXv?_>&j;*#*g^yo`>ud}R}~^p znynI>$QP?@@ueW=MO!psA{BR+lx3%-^$t+Hb^0PcxGxj`l*s?^7%e3iYt73z@M ztN5KVQ%SR4=6zU3afW;o`=kya=RH*p>2v~OCy05`jYtm>zb(yb2e)M?ft=H{<;UWy z9TXPCKSL}*cG9=89A0|ps20p^7PP&hA>-wc9v2F=_ZP*{(F5t0I(_xt$y?nM@P+E( z>dQH|;;)`s?K|)95nH@w;VZ(M>-+a8%JK8#YG+&}pu}mJHP<^KVxj{l*Bf~dO|Y-J zkkHqznU2919#sr)4vwrt7#6F!uS6vlB)P5kkq6pDC!r#?{>~K?9vxb)A#*gwE`|@& z{_SLoyg9SjaAtM-!tPC{F+%_^FF>n!7SpYQ|3Rr71Prp zI?_BOz=uGLj~V%YuUCFI#?J_Vc2B$5)jTA`LlU!gZy28(LAX_wKK{&$*+^qt-8bQQ zdkD8$=BRQ2C_AVeO(>fbTn?-3olB)Ol@OpTRMB=xeFK1tZw*7L0(={!9xA#GK-q?F zLK&@c8AaJeh3=H`{2|x%GUQ>Imn-BCPU{VeK?_O;h{%)Zy>W3G0PCmYvf%^Hyfn;(=4)651^Q zH-Y?yJX;rWB4`o$*emVqdw5Sqxd>4ioND7&aNB998k#bTj}Mx*Y`Ey@K0m*-!P}2u z1aiwxS9Nu2_k5gP{-xF^<&OrOz)vH7U8{V_#m_Flei8}eFr=AZljCCNm9lt?cW?B| z0fkd$ZSW5-Cr?-r5^!$Jx8?K^h##?J*-8< zvO8a_PM3sWaQL`cx(?@iZ`gL!>ez59Vp(7p&P(<5dXDg`7Ot|d9kPgDGegWS34HQ2 zf&3@FJ|-|@or>9BfJJ~QFn1~+stfQIpyq)54{H?wv$<0llNO*uW>Ysy%ZHuHn6Us| z0p-# zkW872c#B)i7)%LF)r3TdLF7OGN!ef=B|oC&8JR&px?rHlc%T%^vMO+xd@N@=PkFxV zp4#~0)q!$$oP%m1F@0KNZz z%abZU|1&QhSZKmQisP6Nka2sJEnwMJW&c5nGr6Tw(58&C%-AIzZB$Gt?&;bf9j#Ri zGOCS`vP9!m*6E;V*%=OsmK%{cXH1*co|G9$+`(uW z5+pL=YAuZhBU%%;Tdz9#njI%G?~pi2$ceU63iH4Wp)QXAWsM0JfVsq&-a`?WwZEnM~US zfbC*3ZP2KAfspo6IoO&^+sX;(iIbHXY|$v#A{77|_BNTe*QjZG1F#t?n`j#qBi$22 z03nTW0jBK&z(x==BN29X4mJz4Zj{+%4JJCVe&l!!0+~ie>xY}tccCl@j#<8N?O>Pn z>s|G83J|h3UnloS%a$cY`3TmnOn68cQb|SGr!(90kc0l{zkekaFZGEmwxk$cM#0`6 zyIZ4?v@96dk|#*KcQTHeOD7tOh|l|IxTABrGW8<9WL!3>*77LYs>@ z<8FAe^wsetsb^>Gah-Xo^~juaI03vaMQUM5XNcq24{9~JSA+qi@ju_nCXmVu&d9zTMw(X;<`48(5a|Z}K+T4WzH88I!#~Kmy!p7VIni~-St(jO*rI_mwv$l`b zA%EJ1n4JO$#qSh=(t$?vsqkNo$X*~6fYnitl z0jqv0AHb@Q$`7zgQqe?!RT0gs(ypVdx|&oPoC;mm%X|Q+ zPB@Q?#}b+#i=0B?o2b>~&adSG97LpnEYEolW7+hY2FaoJ2(hQCdE&zdvM{wtr6XDn zOm(J^)9#(ztnpyrJBqB`miHnttg8p6POf#gMbI8bpBhP^CR14>&!V2cDRDos^jkKi zy~S`dfz;#ra&60zhv)SCiE_lldIlYKpVuE7(t$;!OX!)w!A*3Ev%DTnStHd_oX^B1 zaU?4cIP8L&evPqd0b=s*YGuvsA1$sa8A0kvAxO(da^5MmM|;S<1d3{KZG;1uKCZx~*TO#&XDFstbYH?nL8~_)YKml)J0$eGw8XM<7Nhi57@|JPsQ| z{{8$uCDHb7Sa3Fck~5@}(hAg^JoqHWAzuKNG=-vl1>k@5qq`ZSdzufr58%3Et4P2% z&}Q=>Hl3- z9&=`MB5(O9kwXGOB6swGM4pR>6y^it=0J8t%lMzvS+}~;Lz;;4Z^A@Cn==9B!u1Ok zLUSU!Dwcs71OoyYrE=Qxg~CaN+9|cMQ1QdI%K0h_ZasjU(JcE?%4Mk3EkLb#^5alD zCN^7i2!YY1Dm^K$l^PbxtV8 zylb_4CDl{h_3HC!>WD7)+_ucW9j&K_OYXKVw+N3#WE)b+Gx+PQ-L^Ci0Lmxta`%Vf zJxSCc=K1m*2*DXNq$!n%xh@J+I&@jy9*)8K*Ta-t8|xxv#y*u{mb7+9$wrX zbN0+=B9Hrv-Nt`dG2qBlBva`CNdPS9HhxRj#ik95Sq1=!V|y78#o&Ml$~wTZdAA5M z+#K~_vu>_8%-sf<1CYi5aM0I*lpZSpL9l~SFn1f^1PPM)znuAgzuVveROfc~e%Ng| zWsw1@-_8c8TI8=Vp^CGINSQKAdwW(m{)=!sQ@i2p;3j|puAtsnS00KlblScV9PFqy zQeRRbIc&p1Ia1}|+bG2ra;@b%WY$(H&yzAjAxe(zmfNT>=VTOHdn>ONj@-))3P`*r zwJBsoHx;K*{2A2>Yj3BQlW`uHv*9>L(yB;2%^TU;>vT9<7Ys22xdtv8R2UmiFePXR zGbh@$S_!GMb#RTeq8_WX=oNY4GZKO=zTQS-*(Rj-FTv*$9H!TdkL^di-yrst)E68f zY`{Qn@vVgA$o3#Hj;^AGwHz2YnAo&nMVUl*^UGQL^FlPWjY&=Z`3V|s&7nKThY4Cv zxDA9p5*lq-_sdFnX27v$(@xo88;8$krc}+ST6xeE$dfk)J%rnR<0$jCm1-cw<*6GF zw;Gx+;3&I3Z5j^m(Q4eSd39S#hkULP0_Mtf9Z7lfSYGK(l=khH^7co#)(JVaKL~6b zTxVvy&ejkpy-Ak?74p>b!S-7T5F$8}vhJOIaoWP!%gS1)O4X__Lgk;8{E(ZJW_f#^ zjw0?;&RoxFZuxBe>XzK>qfie3AApGO?3t-P2$)>a(UB8%p<3D6$tjPdV04Cx?-vD@n@iF^`xy%5G{@0b` zciA?rU#`brOawPVkWiv|{o-MW1Z?A$0=BKYyA^fh(-Qm0Rk-F3mQim{B9q9(_zuRJ}E% z6rhmQ=g+^sa`x=6zb3)|qbp1x3jt6cdIN9*04X38#4QL{vp1Mk*Br@Xfjy=Uzui|g z9}55A{?dO*+z&WX@}M^W@B+-1}o zC`2JU+*Jd(1jO>KiS)#<1yN**a4)XxHi_r4y}e z=NP4l{x4Cf!tyE4!?9EVcO6R<)ELXYvSu76@(P8ZeVg^&7Bqn526rz5 zVSMjG%fac+d^!MjrRxq14%qRIDZRPYplF^EOx*xgWFpd9BXEadw!aM7CjsjbGt1h;ETvO>@rjK6_fv!O<*;Uw=qFydrz!S#pVwU_gyJy3f z`6VJ_-|$U3{f)~jjQaJ-m0Kt3?U2!TU!NyqS2B1+$p0dYrHbPT$&X*KkJ-6YJ#Sk% zweeDZ7;l*NUE@%$&?`!U3(dw3P<6J#L2&(&!_eqU*`_k}RN_S?2I za{RPKe01HmUSDK5ZnQL}b2v`RFj|EOg6#99d_+-V*c^?*%?`rwH%ncLma>U=O(X!s zW>HN8#K}Qc$hnfswY557{%;W9{8CD;U{2oR9&7NLU`Vl4c1~?RHMl;b_*lZNwt3G@ zo$;4npY@`;XIj2RT_Xtgy|%`4kO$B5-Nn5uj2Q0mK)wI&?JJ4GNc)70l=Lq|YKn3N zqRMd#gP`x<6p>Q}?I$wUOs^7WdhEDQZ~K%K*VE`Zg6_!g`Z1RgoI^XGUzM2~(Ea_> z5UhfVdK0*kYb%KRd4a>4GK!9{ZpFrw!kssgPTR2K-%p%{wNCM?a(wFquH7%N{D3% z9O%H70q6e%R?Ybfi2eAuwuKFdHP`}T_bFSbx+~$qdrS6x5^Mjsa%XxXZ_%DYUVPnj z>$wU%6S7(@L(=KlVRj2Q$iWK+hyp2xhP{JkFn0D?_dm#;usG}{b$w5Rgsx*O_dgGZ{M06}t6P!|R ziRP07Uk%M>BXI#pWsUg4DH_Gtal@j2 z2#MTUm#=q2uGJ%MQbaC&+#>HMnoK9-8RE3`7rm{r&Jc)Kd%_T`NfkJ~+sTd(8M^1r zo{;hOffaiiiabFgF5%tGS@zB0#rk!}5x#uh(WG^KHOBnZ#Z0# z0bSp4>bsWjbT3ju&g8E`U1VY5lb_kfZ4z|A8@Ey%(maW{b%OGQ*Ts-Sr6Jk!SBJO| zZhmikh=rC?Iz(BSIW(YKpE|g8oeSYq&rOSaD})aUlK(J}KWHO>36HfAfN+5K|BF_! zFCN@N3Z1_KXmF?bVst0C7(InlKy6vfceE6>DW!Hd{1bwNmapN;e;e zqTp9$hq>88n5r$IZpFw|n-s!w_FkzCt$3DvL3)^bxrN3MN@k;Ir=@c~m-89r`ZJ!S z;x#hr!hR{M-0`vuPhnHKLa|)AivY50xgE+ahNE4}?Vic_Nc*7(G96u~z$1tUE*CFr zw30s8 zhjSO7eK!03RGck?xdq=o{vW?WU;XL5IS|O;ac_clbfaM=)?7z`)CGYIgm|nv0Q(EG z4FhNR@ZykJD#q?*0J{JpVeW^=^4WZA2;?)63bU&KQ30|69L5~fe?6ap2Yse2arl%Y!QWWhqY zotCXdI_^>xOVMSX7iCUa>*RF0oI+sPT)8PNK+cL1l({~ZG5P%U(|E-1748VD`!A<3 zxhx1u>x;qb5J-ed6FYJ~-vZpMs~ixAL`a3PC-(0y9$o}aCC=IS&7 zPBAkNz1B(#njCIt!A3~VKq0@f)oUb!EELl}Vr~5F?ptIur$iR2Jk(VY#cPJ#YqD=d zko^QHPgUJ_VXqgSzu2gUA`ne%(AmW&hRhg=tDb6tf(Ny&@rqf z4VtZA{`Vs@C|D$m5yv&?Cq7E2kholNus8br#Z(DaQdbHOY)T;42m3aVkyAJblJVzK zIx^IKO5bWP%A1!bl43>oVj-fO7yjARk~192?lk zf3y=H-V8NUZFX#vRFC!&V|PMhY4bNZ+tlLwCCy60=}E8V|th~nGLjq>g6>{;pLd2aH6qUg;G0I$$I&M z92v@&?Uq;>>fvR*5x9obh0V6zU$bMMOusP9do$mzMe1CFGRl^J>F4Zu6yGje>*XOw zX?b!Ao91{$=4`#AN17$~$m2BL3-Pe_YMtzJ8-6CUqpG6`4v3v$1O&FMfB8`^jDa9B zv1C~)6av|Mx@YlbcZEU@`=V6K9w18c1@Pja*+au{GJhvH$MJ&CR!mMdC@`b3y!=@t zYmOGYukxvEA6VVEiD$NNms@J4>C&ne!J1f1IJrQI!J^0nB)R(-J2M=@LdbS*<&b2>+tkV~lvSm& zJSVB9U@D4X)PELD4ct0V;frVa2mgAE}6>lr@A`G-FM)872iVkDakn1{6$AlPfJaYq}u%bo`= zpP!7lpLeFbAbif0P4`P3h(z+bm8uMxJ)ciY%#Hp+ZpSAgH^r1n@f8B=t@?bqwH1+K zvpbrkBFPy)z90mPCOXeLI+gmR@Kh3(z~e+<5ybuN@zxH2U8_rRREvHHL%kkt z&mM#XZFeI$c9w(ui;pIw2kDF#(G-Z;{W{u7*l2!7>y2A*b#-vgJA948Xh`i`A(cot zp+{z8ta4$^9jqj@gNqd=*Ch_|chK$IR|kcR36+7%fDh($Rxi#d5BUVI985W6<~mA$$3^35s9|vMN70?Ua^3Twe&M^`p~& zQ4x0pI9t^^i28n{6(H67{ZI69BzO26f^?*zP70IOZKzO8n{qKP&A44s(38)?WH6O@ zLvo$8AH~dx+Avib(tJYdBmJIy$sfY!=L!n87_kNWA?2(CYN8~F--h^MvGurRyRG`= zobWSu6*sJQla1DEbrZ@g*DODdBX5vW|E9Qr#Ht&D1A3%=j{R2E?Rzb)bo_4)Nwae< zT<_gqt{Fe0x*ZAK|3R`~qW@FQ#6P@l@$dJD% z-@^htn~OPMAV5(7%;t>=I5~o2;D2mPK(+%{0n-6S13V7Q>k{B6AkTrWn6<~e2RAi< zqc52MDdB+Ok5|~yLeMJ1h;2ZpE#cLm-|+4&SxlomDk!Vgx9#z2pD_NGV#2D-8R=mn zv6!xnokLzJ_sX|REQ+3k)X7j(v1dgL7WsLYt(ZzI-xax_GK6Nc7jB47LC%tK_A-yg zcwyy27qR7;wyC(iKHW()2WEYkkcd8VA>JF$wzqd2h;z2OZBN48i>6o(V{Ez}N6_3@ z!-DJIO%@MZkbjJ(+OzoHZ^j2pv^$MCSek1}t5x%*%~rJ*yz9NbZ^IR2ow*_0HwmRz`0Ru@&d?s-s1WrE+(Yn{)lP zH6dAFHXn^+e3_r-g~aJoMV8JTa)Q{(JDSYpT6*t3Dq?y#(6P}p&nqxxPqp_bj_zOlR6Oi9goz5kTuo~ly_F%0$kCB%1SmEL;8u9DvfnxBV9_&hN zEAPoUp1=&MZodXMN$l6y24WSu8N2L99JB`QJYqvB=lakIL=zP=ahwi%ArCFM0NDq+ z)NnK^I}srTd*@L%%A#%-9IO8EQqImVwkrmIGS*=`Tzc^o{np;%Cco&?tjG?mZs)E= z`oZvVH&;M(_0GW)%1tTIEyR4Lf!0}ydbCM7n6zh39eH9DM@y=HM>)gQbU+L8S?#;O zkSCIFFI2(?8YbMnQaT%gHHAnhU2J2f{1kvn{?Qa#N|~K>fxD=aru;^F0}< z!Dzo97!TvF-m8DO(etmoN)D2GtT6#u3{H$-3V^AAdWGZxJbfD&G<1h$~5e7cKb=wsu_c86WAO0o!Y9INFxz%s|$x-NkSw z+D6kj4MfqJl{C>2XU@r}W%M&nd9z%d&d^b1act`|9+ax&xgN(o+0(FA$1PJV&sc4p zo`ZJwOzB7C4<+FozPjNsr`-H)5G~COd>bSZ;fyK--v&7vh}2qW^2z+UoNL3H?qa5w zJ^!k>HVmSj#Tpf_CD^sH_c(g1f`~-1=)G0jQd7^Gz72ABb&TviT#=Nu_>xa;7aF3s zRzZduslOXbAn`MzU@4Bt9mYzZ10UCwVo1MQxx6C7{JW4KXnoDlFupe)@pM{_)(fJBO=Er<@?cnVX(m1> zNGqM7c^KBpFqA{DZt?E7+il}y25yB&af0yOQV$KJwuJ&E+py~dj}d*4JulE;zvi0L zD~$#3hwmL@u`+(nK6sA*BA;^YZoi!KX=tzhb+SEfH!Yl_%gClE86pnQa!t9-iV;eAz zf*moi^D%d8Y6{hjc$z7ihGZPWq@YgQ6;J2#d64ZxN1}aWl1PyE8JBaV?3Z_@FC+}t zae@uXV9A2l%}K3>P70k~5Ds%RC4~$|a@yV2em13mRyg(DvbZ@tWZMfUHw;;p=N@Z3Ecp%69n&^UF2K8|?}Xk6x(sT+ z(-QRpx13L$n$w3LEbqU8s*H@@o4i7io1YBX1{UhSb*JDkes2@XB%Rti1vNcWpFJ6s zaCEy^GBwpv*T~DZ8YZv67OimKh~iD`D8MDC^GhU7FZ(h&bNjEu)`5s0v@+ zt25Ptr#j~$-|Kcuv@h+b?Z`8Gpi4W0^|is*_D9=wDZ;Od;#WkR7H`0}e0!ZgZpE|o zbKjs~)3rK>9@jDwpXDQFz5$j3z6L2}`i$BE1!~g;m4Jkw+@8qfbm) zN-+kw36`c(D+hYQEbhJy=qgY&>!U3S^&`f0jQ5~FB<>?(|6J^R*dT%&2I&nF7-$Oc6>vZV+5YkUCbO&n{{Y8I5bx$5(QN7% z1N#9F0`Qm^b9CS<;4Eu8<}&`Tzg|8z50<*3Rqqsf=EK8+RO;RnE>RsmYnGt)b#)$o z-1i!rm1NDpx!PwZTCTP!oG$jkq0=@_^;%8d90pzmuTZ#Hy6;YM!6L=cuHf@fyn;d( zZ#<8;EsE^W2n8HpNwaBzy=XCFzcxs)Vh(}a!lQb)#Cr?d{7Kh8+ehuIpXN(%L#J^1 z@ZE_7ksJ7s8M5EnkW9lj+(p%GH-GV_c}lS9i#MMQ7HX@(7jK>wMfU0&c^cMySHHf# z>OJQ+y1u4tOY>&+c-u}~mU7zx1(7p%_k3=xWOA?Uy3EnRs@N1E<3C~1!gKRn|! z%-im3Q8CYsuuxTH~ zA8ITJlp4c%;=2Q_+X`Sex}0OUy2b+KM%|oYQ62kt*bOC*mp-19*9lGAP$CLk{|M=3 z7jvyZ`8o1@2GqMry<$$j))U&bDT}nEE_>))LQ=ot=qH7@p_SC;+Mv2msNX{ZWf;y? oeA977xTG4XME-Ph3dQP^Kq-oKos*}d_U8@f*;_mS9pS|P1&|SxP5=M^ literal 0 HcmV?d00001 diff --git a/Presentation.Web/Content/less/kitos.less b/Presentation.Web/Content/less/kitos.less index 5b0f395c15..fbd6b599f1 100644 --- a/Presentation.Web/Content/less/kitos.less +++ b/Presentation.Web/Content/less/kitos.less @@ -1597,4 +1597,9 @@ tbody.bordered > tr > td { .right-margin-5px { margin-right: 5px; -} \ No newline at end of file +} + +.progress-spinner-img { + height: 20px; + width: 20px; +} diff --git a/Presentation.Web/Presentation.Web.csproj b/Presentation.Web/Presentation.Web.csproj index b50368c1a4..44673189d2 100644 --- a/Presentation.Web/Presentation.Web.csproj +++ b/Presentation.Web/Presentation.Web.csproj @@ -653,6 +653,7 @@ + @@ -661,6 +662,7 @@ + @@ -903,6 +905,7 @@ + diff --git a/Presentation.Web/app/components/local-config/import/fk-organization-import-config.component.ts b/Presentation.Web/app/components/local-config/import/fk-organization-import-config.component.ts index d2cd01b550..d9220ace5b 100644 --- a/Presentation.Web/app/components/local-config/import/fk-organization-import-config.component.ts +++ b/Presentation.Web/app/components/local-config/import/fk-organization-import-config.component.ts @@ -4,7 +4,7 @@ function setupComponent(): ng.IComponentOptions { return { bindings: { - currentOrganizationUuid: "=" + currentOrganizationUuid: "<" }, controller: FkOrganizationImportController, controllerAs: "ctrl", diff --git a/Presentation.Web/app/components/local-config/import/fk-organization-import-config.view.html b/Presentation.Web/app/components/local-config/import/fk-organization-import-config.view.html index 4e35ef3b82..adb93f17bc 100644 --- a/Presentation.Web/app/components/local-config/import/fk-organization-import-config.view.html +++ b/Presentation.Web/app/components/local-config/import/fk-organization-import-config.view.html @@ -1,4 +1,7 @@ -
+
+ +
+
KITOS har adgang til organisationens data via FK Organisation diff --git a/Presentation.Web/app/shared/progress-spinner/progress-spinner.component.ts b/Presentation.Web/app/shared/progress-spinner/progress-spinner.component.ts new file mode 100644 index 0000000000..0d79a0f8d2 --- /dev/null +++ b/Presentation.Web/app/shared/progress-spinner/progress-spinner.component.ts @@ -0,0 +1,35 @@ +module Kitos.Shared.Components.Progress { + "use strict"; + + function setupComponent(): ng.IComponentOptions { + return { + bindings: { + showText: "<", + customText: "<" + }, + controller: ProgressSpinnerComponentController, + controllerAs: "ctrl", + templateUrl: `app/shared/progress-spinner/progress-spinner.view.html` + }; + } + + interface IProgressSpinnerComponentController extends ng.IComponentController { + showText: boolean + customText: string | null | undefined; + + } + + class ProgressSpinnerComponentController implements IProgressSpinnerComponentController { + showText: boolean + customText: string | undefined; + + activeText: string | null = null; + $onInit() { + if (this.showText) { + this.activeText = this.customText ?? "Indlæser indhold..."; + } + } + } + angular.module("app") + .component("progressSpinner", setupComponent()); +} \ No newline at end of file diff --git a/Presentation.Web/app/shared/progress-spinner/progress-spinner.view.html b/Presentation.Web/app/shared/progress-spinner/progress-spinner.view.html new file mode 100644 index 0000000000..8c05e917cb --- /dev/null +++ b/Presentation.Web/app/shared/progress-spinner/progress-spinner.view.html @@ -0,0 +1 @@ +spinner {{::ctrl.activeText}} \ No newline at end of file From 68f2058235913480dedd37972c12b79c9d659f38 Mon Sep 17 00:00:00 2001 From: Aleksander Naskret Date: Wed, 5 Oct 2022 09:51:25 +0200 Subject: [PATCH 038/272] merge --- .../Infrastructure.DataAccess.csproj | 10 +- ...9301046217_RemovedEmailBeforeDeletion.resx | 126 ------------------ ...34_RemovedEmailBeforeDeletion.Designer.cs} | 2 +- ...10050748434_RemovedEmailBeforeDeletion.cs} | 0 ...0050748434_RemovedEmailBeforeDeletion.resx | 126 ++++++++++++++++++ 5 files changed, 132 insertions(+), 132 deletions(-) delete mode 100644 Infrastructure.DataAccess/Migrations/202209301046217_RemovedEmailBeforeDeletion.resx rename Infrastructure.DataAccess/Migrations/{202209301046217_RemovedEmailBeforeDeletion.Designer.cs => 202210050748434_RemovedEmailBeforeDeletion.Designer.cs} (92%) rename Infrastructure.DataAccess/Migrations/{202209301046217_RemovedEmailBeforeDeletion.cs => 202210050748434_RemovedEmailBeforeDeletion.cs} (100%) create mode 100644 Infrastructure.DataAccess/Migrations/202210050748434_RemovedEmailBeforeDeletion.resx diff --git a/Infrastructure.DataAccess/Infrastructure.DataAccess.csproj b/Infrastructure.DataAccess/Infrastructure.DataAccess.csproj index 9deeaaf5f4..8d391c42be 100644 --- a/Infrastructure.DataAccess/Infrastructure.DataAccess.csproj +++ b/Infrastructure.DataAccess/Infrastructure.DataAccess.csproj @@ -939,9 +939,9 @@ 202209290951403_Add_SystemActive_To_ItSystemUsageOverview.cs - - - 202209301046217_RemovedEmailBeforeDeletion.cs + + + 202210050748434_RemovedEmailBeforeDeletion.cs @@ -1569,8 +1569,8 @@ 202209290951403_Add_SystemActive_To_ItSystemUsageOverview.cs - - 202209301046217_RemovedEmailBeforeDeletion.cs + + 202210050748434_RemovedEmailBeforeDeletion.cs diff --git a/Infrastructure.DataAccess/Migrations/202209301046217_RemovedEmailBeforeDeletion.resx b/Infrastructure.DataAccess/Migrations/202209301046217_RemovedEmailBeforeDeletion.resx deleted file mode 100644 index c87b2a6315..0000000000 --- a/Infrastructure.DataAccess/Migrations/202209301046217_RemovedEmailBeforeDeletion.resx +++ /dev/null @@ -1,126 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - text/microsoft-resx - - - 2.0 - - - System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - - - System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - - - 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 - - - dbo - - \ No newline at end of file diff --git a/Infrastructure.DataAccess/Migrations/202209301046217_RemovedEmailBeforeDeletion.Designer.cs b/Infrastructure.DataAccess/Migrations/202210050748434_RemovedEmailBeforeDeletion.Designer.cs similarity index 92% rename from Infrastructure.DataAccess/Migrations/202209301046217_RemovedEmailBeforeDeletion.Designer.cs rename to Infrastructure.DataAccess/Migrations/202210050748434_RemovedEmailBeforeDeletion.Designer.cs index 939cc51aae..0c679a74d2 100644 --- a/Infrastructure.DataAccess/Migrations/202209301046217_RemovedEmailBeforeDeletion.Designer.cs +++ b/Infrastructure.DataAccess/Migrations/202210050748434_RemovedEmailBeforeDeletion.Designer.cs @@ -13,7 +13,7 @@ public sealed partial class RemovedEmailBeforeDeletion : IMigrationMetadata string IMigrationMetadata.Id { - get { return "202209301046217_RemovedEmailBeforeDeletion"; } + get { return "202210050748434_RemovedEmailBeforeDeletion"; } } string IMigrationMetadata.Source diff --git a/Infrastructure.DataAccess/Migrations/202209301046217_RemovedEmailBeforeDeletion.cs b/Infrastructure.DataAccess/Migrations/202210050748434_RemovedEmailBeforeDeletion.cs similarity index 100% rename from Infrastructure.DataAccess/Migrations/202209301046217_RemovedEmailBeforeDeletion.cs rename to Infrastructure.DataAccess/Migrations/202210050748434_RemovedEmailBeforeDeletion.cs diff --git a/Infrastructure.DataAccess/Migrations/202210050748434_RemovedEmailBeforeDeletion.resx b/Infrastructure.DataAccess/Migrations/202210050748434_RemovedEmailBeforeDeletion.resx new file mode 100644 index 0000000000..73fc0f78df --- /dev/null +++ b/Infrastructure.DataAccess/Migrations/202210050748434_RemovedEmailBeforeDeletion.resx @@ -0,0 +1,126 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 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 + + + dbo + + \ No newline at end of file From d884888e44c80abb00ab5889494a76fc5e7a0c3a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Morten=20Remb=C3=B8l=20Jacobsen?= Date: Wed, 5 Oct 2022 10:03:21 +0200 Subject: [PATCH 039/272] added missing migration files --- ...2210050759373_Remove_TaskUsage.Designer.cs | 29 ++++ .../202210050759373_Remove_TaskUsage.cs | 66 +++++++++ .../202210050759373_Remove_TaskUsage.resx | 126 ++++++++++++++++++ 3 files changed, 221 insertions(+) create mode 100644 Infrastructure.DataAccess/Migrations/202210050759373_Remove_TaskUsage.Designer.cs create mode 100644 Infrastructure.DataAccess/Migrations/202210050759373_Remove_TaskUsage.cs create mode 100644 Infrastructure.DataAccess/Migrations/202210050759373_Remove_TaskUsage.resx diff --git a/Infrastructure.DataAccess/Migrations/202210050759373_Remove_TaskUsage.Designer.cs b/Infrastructure.DataAccess/Migrations/202210050759373_Remove_TaskUsage.Designer.cs new file mode 100644 index 0000000000..78f73ede54 --- /dev/null +++ b/Infrastructure.DataAccess/Migrations/202210050759373_Remove_TaskUsage.Designer.cs @@ -0,0 +1,29 @@ +// +namespace Infrastructure.DataAccess.Migrations +{ + using System.CodeDom.Compiler; + using System.Data.Entity.Migrations; + using System.Data.Entity.Migrations.Infrastructure; + using System.Resources; + + [GeneratedCode("EntityFramework.Migrations", "6.4.4")] + public sealed partial class Remove_TaskUsage : IMigrationMetadata + { + private readonly ResourceManager Resources = new ResourceManager(typeof(Remove_TaskUsage)); + + string IMigrationMetadata.Id + { + get { return "202210050759373_Remove_TaskUsage"; } + } + + string IMigrationMetadata.Source + { + get { return null; } + } + + string IMigrationMetadata.Target + { + get { return Resources.GetString("Target"); } + } + } +} diff --git a/Infrastructure.DataAccess/Migrations/202210050759373_Remove_TaskUsage.cs b/Infrastructure.DataAccess/Migrations/202210050759373_Remove_TaskUsage.cs new file mode 100644 index 0000000000..e831060a97 --- /dev/null +++ b/Infrastructure.DataAccess/Migrations/202210050759373_Remove_TaskUsage.cs @@ -0,0 +1,66 @@ +namespace Infrastructure.DataAccess.Migrations +{ + using System; + using System.Data.Entity.Migrations; + + public partial class Remove_TaskUsage : DbMigration + { + public override void Up() + { + DropForeignKey("dbo.TaskUsage", "LastChangedByUserId", "dbo.User"); + DropForeignKey("dbo.TaskUsage", "ObjectOwnerId", "dbo.User"); + DropForeignKey("dbo.TaskUsage", "OrgUnitId", "dbo.OrganizationUnit"); + DropForeignKey("dbo.TaskUsage", "ParentId", "dbo.TaskUsage"); + DropForeignKey("dbo.TaskUsage", "TaskRefId", "dbo.TaskRef"); + DropIndex("dbo.TaskUsage", new[] { "TaskRefId" }); + DropIndex("dbo.TaskUsage", new[] { "OrgUnitId" }); + DropIndex("dbo.TaskUsage", new[] { "ParentId" }); + DropIndex("dbo.TaskUsage", new[] { "ObjectOwnerId" }); + DropIndex("dbo.TaskUsage", new[] { "LastChangedByUserId" }); + DropColumn("dbo.Config", "ShowTabOverview"); + DropColumn("dbo.Config", "ShowColumnTechnology"); + DropColumn("dbo.Config", "ShowColumnUsage"); + DropTable("dbo.TaskUsage"); + + //Fix old preferences + Sql(@" UPDATE dbo.[User] + SET DefaultUserStartPreference = 'organization.structure' + WHERE DefaultUserStartPreference = 'organization.overview';"); + } + + public override void Down() + { + CreateTable( + "dbo.TaskUsage", + c => new + { + Id = c.Int(nullable: false, identity: true), + TaskRefId = c.Int(nullable: false), + OrgUnitId = c.Int(nullable: false), + ParentId = c.Int(), + Starred = c.Boolean(nullable: false), + TechnologyStatus = c.Int(nullable: false), + UsageStatus = c.Int(nullable: false), + Comment = c.String(), + ObjectOwnerId = c.Int(nullable: false), + LastChanged = c.DateTime(nullable: false, precision: 7, storeType: "datetime2"), + LastChangedByUserId = c.Int(nullable: false), + }) + .PrimaryKey(t => t.Id); + + AddColumn("dbo.Config", "ShowColumnUsage", c => c.Boolean(nullable: false)); + AddColumn("dbo.Config", "ShowColumnTechnology", c => c.Boolean(nullable: false)); + AddColumn("dbo.Config", "ShowTabOverview", c => c.Boolean(nullable: false)); + CreateIndex("dbo.TaskUsage", "LastChangedByUserId"); + CreateIndex("dbo.TaskUsage", "ObjectOwnerId"); + CreateIndex("dbo.TaskUsage", "ParentId"); + CreateIndex("dbo.TaskUsage", "OrgUnitId"); + CreateIndex("dbo.TaskUsage", "TaskRefId"); + AddForeignKey("dbo.TaskUsage", "TaskRefId", "dbo.TaskRef", "Id", cascadeDelete: true); + AddForeignKey("dbo.TaskUsage", "ParentId", "dbo.TaskUsage", "Id"); + AddForeignKey("dbo.TaskUsage", "OrgUnitId", "dbo.OrganizationUnit", "Id"); + AddForeignKey("dbo.TaskUsage", "ObjectOwnerId", "dbo.User", "Id"); + AddForeignKey("dbo.TaskUsage", "LastChangedByUserId", "dbo.User", "Id"); + } + } +} diff --git a/Infrastructure.DataAccess/Migrations/202210050759373_Remove_TaskUsage.resx b/Infrastructure.DataAccess/Migrations/202210050759373_Remove_TaskUsage.resx new file mode 100644 index 0000000000..fd327af1d5 --- /dev/null +++ b/Infrastructure.DataAccess/Migrations/202210050759373_Remove_TaskUsage.resx @@ -0,0 +1,126 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 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 + + + dbo + + \ No newline at end of file From 17579062b659fec7d5736b741d338c21bbe45344 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Morten=20Remb=C3=B8l=20Jacobsen?= Date: Wed, 5 Oct 2022 12:57:57 +0200 Subject: [PATCH 040/272] added inputerrors the import dialog --- ...ation-import-config-import-modal.view.html | 34 ++++++++++++++----- 1 file changed, 25 insertions(+), 9 deletions(-) diff --git a/Presentation.Web/app/components/local-config/import/fk-organization-import-config-import-modal.view.html b/Presentation.Web/app/components/local-config/import/fk-organization-import-config-import-modal.view.html index 08854dc110..5c6f11ae71 100644 --- a/Presentation.Web/app/components/local-config/import/fk-organization-import-config-import-modal.view.html +++ b/Presentation.Web/app/components/local-config/import/fk-organization-import-config-import-modal.view.html @@ -6,14 +6,30 @@
-
-
+ \ No newline at end of file From 13f371194b8ba5fe0e98a348fc6e2be34b1080a8 Mon Sep 17 00:00:00 2001 From: Aleksander Naskret Date: Wed, 5 Oct 2022 12:31:56 +0200 Subject: [PATCH 042/272] added sql scripts --- .../Infrastructure.DataAccess.csproj | 3 + ...elete_Users_Other_Than_Preserved_Users.sql | 63 +++++++++++++++++++ .../Get_Users_To_Preserve.sql | 18 ++++++ 3 files changed, 84 insertions(+) create mode 100644 Infrastructure.DataAccess/Migrations/SQLScripts/Manually run scripts to fix staging DB/Delete_Users_Other_Than_Preserved_Users.sql create mode 100644 Infrastructure.DataAccess/Migrations/SQLScripts/Manually run scripts to fix staging DB/Get_Users_To_Preserve.sql diff --git a/Infrastructure.DataAccess/Infrastructure.DataAccess.csproj b/Infrastructure.DataAccess/Infrastructure.DataAccess.csproj index 61a17c57e6..0ff06ad045 100644 --- a/Infrastructure.DataAccess/Infrastructure.DataAccess.csproj +++ b/Infrastructure.DataAccess/Infrastructure.DataAccess.csproj @@ -945,6 +945,8 @@ + + @@ -1660,6 +1662,7 @@
+ diff --git a/Infrastructure.DataAccess/Migrations/SQLScripts/Manually run scripts to fix staging DB/Delete_Users_Other_Than_Preserved_Users.sql b/Infrastructure.DataAccess/Migrations/SQLScripts/Manually run scripts to fix staging DB/Delete_Users_Other_Than_Preserved_Users.sql new file mode 100644 index 0000000000..e0968bc7c1 --- /dev/null +++ b/Infrastructure.DataAccess/Migrations/SQLScripts/Manually run scripts to fix staging DB/Delete_Users_Other_Than_Preserved_Users.sql @@ -0,0 +1,63 @@ +/* +User story reference: + https://os2web.atlassian.net/browse/KITOSUDV-3402 + +Content: + Anonymizes users than Local admin and Api user +*/ + +BEGIN + -- Make sure the temp table doesn't exist + If(OBJECT_ID('tempdb..#idsToPreserve') Is Not Null) + Begin + Drop Table #idsToPreserve + End + + CREATE TABLE #idsToPreserve( + Id int + ) + + -- Insert values from the csv file + BULK INSERT #idsToPreserve + FROM 'D:\FileName.csv' + WITH + ( + FIRSTROW = 1, + DATAFILETYPE='widechar', -- UTF-16 + FIELDTERMINATOR = ';', + ROWTERMINATOR = '\n', + TABLOCK, + KEEPNULLS -- Treat empty fields as NULLs. + ) + + -- Delete users not in csv file + UPDATE [User] + SET + Name = 'Slettet bruger', + LockedOutDate = GETDATE(), + Email = CONVERT(NVARCHAR(36), NEWID()) + '_deleted_user@kitos.dk', + PhoneNumber = null, + LastName = (CASE + WHEN LastName IS NULL THEN '' + ELSE LastName + END) + ' (SLETTET)', + Password = NEWID(), + DeletedDate = GETDATE(), + Deleted = 1, + IsGlobalAdmin = 0, + HasApiAccess = 0, + HasStakeHolderAccess = 0 + FROM [User] + WHERE Deleted = 0 + AND Id NOT IN + ( + SELECT * + FROM #idsToPreserve + ); + + -- Make sure the temp table doesn't exist + If(OBJECT_ID('tempdb..#idsToPreserve') Is Not Null) + Begin + Drop Table #idsToPreserve + End +END \ No newline at end of file diff --git a/Infrastructure.DataAccess/Migrations/SQLScripts/Manually run scripts to fix staging DB/Get_Users_To_Preserve.sql b/Infrastructure.DataAccess/Migrations/SQLScripts/Manually run scripts to fix staging DB/Get_Users_To_Preserve.sql new file mode 100644 index 0000000000..44424daa80 --- /dev/null +++ b/Infrastructure.DataAccess/Migrations/SQLScripts/Manually run scripts to fix staging DB/Get_Users_To_Preserve.sql @@ -0,0 +1,18 @@ +/* +User story reference: + https://os2web.atlassian.net/browse/KITOSUDV-3402 + +Content: + +*/ + +BEGIN + SELECT DISTINCT T0.Id + FROM [User] T0 + LEFT JOIN OrganizationRights T1 + ON T0.Id = T1.UserId + WHERE T0.Deleted = 0 + AND (T1.Role = 1 + OR T1.Role = 7 + OR T0.HasApiAccess = 1 AND T1.UserId IS NOT NULL) +END \ No newline at end of file From c34e1ef399105c6ec6fba5b995c9e84040d9cd15 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Morten=20Remb=C3=B8l=20Jacobsen?= Date: Wed, 5 Oct 2022 15:04:53 +0200 Subject: [PATCH 043/272] added progress bar to import Added draft of import process --- .../IStsOrganizationSynchronizationService.cs | 9 ++- .../StsOrganizationSynchronizationService.cs | 78 ++++++++++++++++++- .../StsOrganization/StsOrganizationUnit.cs | 2 +- ...tsOrganizationSynchronizationController.cs | 16 ++-- .../ConnectToStsOrganizationRequestDTO.cs | 5 +- ...ation-import-config-import-modal.dialog.ts | 6 ++ ...ation-import-config-import-modal.view.html | 5 +- .../navigation-authorized.view.html | 2 +- .../progress-spinner.component.ts | 5 +- ...sOrganizationSynchronizationServiceTest.cs | 16 ++-- 10 files changed, 120 insertions(+), 24 deletions(-) diff --git a/Core.ApplicationServices/Organizations/IStsOrganizationSynchronizationService.cs b/Core.ApplicationServices/Organizations/IStsOrganizationSynchronizationService.cs index 54e77ff05f..3c5b521c43 100644 --- a/Core.ApplicationServices/Organizations/IStsOrganizationSynchronizationService.cs +++ b/Core.ApplicationServices/Organizations/IStsOrganizationSynchronizationService.cs @@ -19,6 +19,13 @@ public interface IStsOrganizationSynchronizationService /// /// /// - Result GetStsOrganizationalHierarchy(Guid organizationId, Maybe levelsToInclude); + Result GetStsOrganizationalHierarchy(Guid organizationId, Maybe levelsToInclude); + /// + /// Connect the organization to "STS Organisation" + /// + /// + /// + /// + Maybe Connect(Guid organizationId, Maybe levelsToInclude); } } diff --git a/Core.ApplicationServices/Organizations/StsOrganizationSynchronizationService.cs b/Core.ApplicationServices/Organizations/StsOrganizationSynchronizationService.cs index f9d49d2fa2..e1503c818c 100644 --- a/Core.ApplicationServices/Organizations/StsOrganizationSynchronizationService.cs +++ b/Core.ApplicationServices/Organizations/StsOrganizationSynchronizationService.cs @@ -1,4 +1,5 @@ using System; +using System.Collections.Generic; using Core.Abstractions.Types; using Core.ApplicationServices.Authorization; using Core.ApplicationServices.Authorization.Permissions; @@ -6,6 +7,7 @@ using Core.DomainModel.Organization; using Core.DomainServices.Model.StsOrganization; using Core.DomainServices.Organizations; +using Infrastructure.Services.DataAccess; using Serilog; namespace Core.ApplicationServices.Organizations @@ -16,6 +18,8 @@ public class StsOrganizationSynchronizationService : IStsOrganizationSynchroniza private readonly IOrganizationService _organizationService; private readonly ILogger _logger; private readonly IStsOrganizationService _stsOrganizationService; + private readonly IDatabaseControl _databaseControl; + private readonly ITransactionManager _transactionManager; private readonly IAuthorizationContext _authorizationContext; public StsOrganizationSynchronizationService( @@ -23,12 +27,16 @@ public StsOrganizationSynchronizationService( IStsOrganizationUnitService stsOrganizationUnitService, IOrganizationService organizationService, ILogger logger, - IStsOrganizationService stsOrganizationService) + IStsOrganizationService stsOrganizationService, + IDatabaseControl databaseControl, + ITransactionManager transactionManager) { _stsOrganizationUnitService = stsOrganizationUnitService; _organizationService = organizationService; _logger = logger; _stsOrganizationService = stsOrganizationService; + _databaseControl = databaseControl; + _transactionManager = transactionManager; _authorizationContext = authorizationContext; } @@ -58,7 +66,7 @@ private Maybe> ValidateConnection(O return _stsOrganizationService.ValidateConnection(organization); } - public Result GetStsOrganizationalHierarchy(Guid organizationId, Maybe levelsToInclude) + public Result GetStsOrganizationalHierarchy(Guid organizationId, Maybe levelsToInclude) { return GetOrganizationWithImportPermission(organizationId) @@ -66,6 +74,70 @@ public Result GetStsOrganizationalHierarchy .Bind(root => FilterByRequestedLevels(root, levelsToInclude)); } + public Maybe Connect(Guid organizationId, Maybe levelsToInclude) + { + var organizationResult = GetOrganizationWithImportPermission(organizationId); + if (organizationResult.Failed) + { + _logger.Warning("Failed while loading import org ({uuid}) with import permission. {errorCode}:{errorMessage}", organizationId, organizationResult.Error.FailureType, organizationResult.Error.Message.GetValueOrFallback("no-error")); + return organizationResult.Error; + } + + //TODO: Move the business logic into the domain part + var organization = organizationResult.Value; + if (organization.StsOrganizationConnection?.Connected == true) + { + return new OperationError("Already connected", OperationFailure.Conflict); + } + + return LoadOrganizationUnits(organization) + .Bind(root => FilterByRequestedLevels(root, levelsToInclude)) + .Match(root => CreateConnection(organization, root, levelsToInclude), error => error); + } + + private Maybe CreateConnection(Organization organization, StsOrganizationUnit importRoot, Maybe levelsToInclude) + { + using var transaction = _transactionManager.Begin(); + //TODO: Move into the domain + var currentRoot = organization.GetRoot(); + + //Switch the origin of the root + currentRoot.Origin = OrganizationUnitOrigin.STS_Organisation; + currentRoot.ExternalOriginUuid = importRoot.Uuid; + currentRoot.Name = importRoot.Name; + + //TODO: Import the sub tree + + organization.StsOrganizationConnection ??= new StsOrganizationConnection(); + organization.StsOrganizationConnection.Connected = true; + organization.StsOrganizationConnection.SynchronizationDepth = levelsToInclude.Match(levels => (int?)levels, () => default); + + //TODO: Remove - just testing here + //TODO: This actually works.. + //TODO: Introduce import strategy and change sts org unit to externalOrgUnit + currentRoot.Children.Add(new OrganizationUnit + { + Name = "test", + Origin = OrganizationUnitOrigin.STS_Organisation, + ExternalOriginUuid = Guid.NewGuid(), + Organization = organization, + Children = new List { new() + { + Name = "tes2", + Origin = OrganizationUnitOrigin.STS_Organisation, + ExternalOriginUuid = Guid.NewGuid(), + Organization = organization + } } + }); + + //TODO: We have to first insert the tree, then patch the ids.. we can flatten it and map the parent ids + + transaction.Commit(); + _databaseControl.SaveChanges(); + + return Maybe.None; + } + private Result LoadOrganizationUnits(Organization organization) { return _stsOrganizationUnitService.ResolveOrganizationTree(organization).Match>(root => root, detailedOperationError => new OperationError($"Failed to load organization tree:{detailedOperationError.Detail:G}:{detailedOperationError.FailureType:G}:{detailedOperationError.Message}", detailedOperationError.FailureType)); @@ -87,7 +159,7 @@ private Result WithImportPermission(Organization o return new OperationError($"The user does not have permission to use the STS Organization Sync functionality for the organization with uuid:{organization.Uuid}", OperationFailure.Forbidden); } - private static Result FilterByRequestedLevels(StsOrganizationUnit root, Maybe levelsToInclude) + private static Result FilterByRequestedLevels(StsOrganizationUnit root, Maybe levelsToInclude) { if (levelsToInclude.IsNone) { diff --git a/Core.DomainServices/Model/StsOrganization/StsOrganizationUnit.cs b/Core.DomainServices/Model/StsOrganization/StsOrganizationUnit.cs index c9f4ff5699..833e729af4 100644 --- a/Core.DomainServices/Model/StsOrganization/StsOrganizationUnit.cs +++ b/Core.DomainServices/Model/StsOrganization/StsOrganizationUnit.cs @@ -19,7 +19,7 @@ public StsOrganizationUnit(Guid uuid, string name, string userFacingKey, IEnumer Children = children.ToList().AsReadOnly(); } - public StsOrganizationUnit Copy(uint? childLevelsToInclude = null) + public StsOrganizationUnit Copy(int? childLevelsToInclude = null) { var children = new List(); var includeChildren = childLevelsToInclude is > 0 or null; diff --git a/Presentation.Web/Controllers/API/V1/StsOrganizationSynchronizationController.cs b/Presentation.Web/Controllers/API/V1/StsOrganizationSynchronizationController.cs index 8e8db0ee77..683da0a943 100644 --- a/Presentation.Web/Controllers/API/V1/StsOrganizationSynchronizationController.cs +++ b/Presentation.Web/Controllers/API/V1/StsOrganizationSynchronizationController.cs @@ -22,8 +22,8 @@ public StsOrganizationSynchronizationController(IStsOrganizationSynchronizationS } [HttpGet] - [Route("snapshot")] //TODO: Rename to query | preview? - public HttpResponseMessage GetSnapshotFromStsOrganization(Guid organizationId, uint? levels = null) + [Route("snapshot")] + public HttpResponseMessage GetSnapshotFromStsOrganization(Guid organizationId, int? levels = null) { return _stsOrganizationSynchronizationService .GetStsOrganizationalHierarchy(organizationId, levels.FromNullableValueType()) @@ -56,10 +56,16 @@ public HttpResponseMessage GetSynchronizationStatus(Guid organizationId) [HttpPost] [Route("connection")] - public HttpResponseMessage CreateConnection(ConnectToStsOrganizationRequestDTO request) + public HttpResponseMessage CreateConnection(Guid organizationId, [FromBody] ConnectToStsOrganizationRequestDTO request) { - //TODO: Perform the import (only allowed to CREATE if not already created). If created, the current one must be updated! - return Ok(); + if (!ModelState.IsValid) + { + return BadRequest(ModelState); + } + + return _stsOrganizationSynchronizationService + .Connect(organizationId, (request?.SynchronizationDepth).FromNullableValueType()) + .Match(FromOperationError, Ok); } //TODO: https://os2web.atlassian.net/browse/KITOSUDV-3313 adds the PUT (POST creates the connection) diff --git a/Presentation.Web/Models/API/V1/Organizations/ConnectToStsOrganizationRequestDTO.cs b/Presentation.Web/Models/API/V1/Organizations/ConnectToStsOrganizationRequestDTO.cs index be3f24bc9b..78dbd0979d 100644 --- a/Presentation.Web/Models/API/V1/Organizations/ConnectToStsOrganizationRequestDTO.cs +++ b/Presentation.Web/Models/API/V1/Organizations/ConnectToStsOrganizationRequestDTO.cs @@ -1,7 +1,10 @@ -namespace Presentation.Web.Models.API.V1.Organizations +using System.ComponentModel.DataAnnotations; + +namespace Presentation.Web.Models.API.V1.Organizations { public class ConnectToStsOrganizationRequestDTO { + [Range(1, int.MaxValue)] public int? SynchronizationDepth { get; set; } } } \ No newline at end of file diff --git a/Presentation.Web/app/components/local-config/import/fk-organization-import-config-import-modal.dialog.ts b/Presentation.Web/app/components/local-config/import/fk-organization-import-config-import-modal.dialog.ts index f163af88db..a93e178681 100644 --- a/Presentation.Web/app/components/local-config/import/fk-organization-import-config-import-modal.dialog.ts +++ b/Presentation.Web/app/components/local-config/import/fk-organization-import-config-import-modal.dialog.ts @@ -29,6 +29,7 @@ class FKOrganisationImportController { static $inject = ["flow", "orgUuid", "synchronizationDepth", "stsOrganizationSyncService", "$uibModalInstance"]; + busy: boolean = false; constructor( readonly flow: FKOrganisationImportFlow, private readonly organizationUuid: string, @@ -46,10 +47,15 @@ } performImport() { + this.busy = true; this.stsOrganizationSyncService .createConnection(this.organizationUuid, this.synchronizationDepth) .then(() => { + this.busy = false; this.$uibModalInstance.close(); + }, error => { + console.log("Error:", error); + this.busy = false; }); } } diff --git a/Presentation.Web/app/components/local-config/import/fk-organization-import-config-import-modal.view.html b/Presentation.Web/app/components/local-config/import/fk-organization-import-config-import-modal.view.html index 880b71ebc7..935d76eb1f 100644 --- a/Presentation.Web/app/components/local-config/import/fk-organization-import-config-import-modal.view.html +++ b/Presentation.Web/app/components/local-config/import/fk-organization-import-config-import-modal.view.html @@ -34,6 +34,7 @@