Esempio n. 1
0
        private OrgUnitData MapRegistrationToOrgUnitDTO(OrgUnitRegistration registration, List <AddressRelation> addressRefs)
        {
            OrgUnitData organisationEnhed = new OrgUnitData();

            organisationEnhed.ShortKey          = registration.ShortKey;
            organisationEnhed.Name              = registration.Name;
            organisationEnhed.Addresses         = addressRefs;
            organisationEnhed.Timestamp         = registration.Timestamp;
            organisationEnhed.Uuid              = registration.Uuid;
            organisationEnhed.ParentOrgUnitUuid = registration.ParentOrgUnitUuid;
            organisationEnhed.Tasks             = registration.Tasks;

            switch (registration.Type)
            {
            case OrgUnitType.DEPARTMENT:
                organisationEnhed.OrgUnitType = UUIDConstants.ORGUNIT_TYPE_DEPARTMENT;
                break;

            case OrgUnitType.TEAM:
                organisationEnhed.OrgUnitType = UUIDConstants.ORGUNIT_TYPE_TEAM;
                break;

            default:
                throw new Exception("Unknown type: " + registration.Type);
            }

            return(organisationEnhed);
        }
Esempio n. 2
0
        /// <summary>
        /// This method will check whether the OrgUnit already exists inside Organisation, read it if it does, and perform
        /// the correct update (registering the delta-changes between the local object and the org-object). If the object
        /// does not already exist, it will pass the registration to the Create method.
        /// </summary>
        public void Update(OrgUnitRegistration registration)
        {
            log.Debug("Performing Update on OrgUnit '" + registration.Uuid + "'");

            ValidateAndEnforceCasing(registration);

            try
            {
                var result = organisationEnhedStub.GetLatestRegistration(registration.Uuid);
                if (result == null)
                {
                    log.Debug("Update on OrgUnit '" + registration.Uuid + "' changed to a Create because it does not exists as an active object within Organisation");
                    Create(registration);
                }
                else
                {
                    var addressRefs = UpdateAddresses(registration, result);

                    // this must happen after addresses have been imported, as it might result in UUID's being created
                    OrgUnitData orgUnitData = MapRegistrationToOrgUnitDTO(registration, addressRefs);

                    #region Update payout units
                    // if this unit handles payouts on behalf of a payout unit, create a reference to that payout unit
                    if (!string.IsNullOrEmpty(registration.PayoutUnitUuid))
                    {
                        string payoutUnitFunctionUuid = ServiceHelper.EnsurePayoutUnitFunctionExists(registration.PayoutUnitUuid, registration.Timestamp);

                        orgUnitData.OrgFunctionUuids.Add(payoutUnitFunctionUuid);
                    }
                    #endregion

                    ServiceHelper.UpdateManager(registration);

                    organisationEnhedStub.Ret(orgUnitData);

                    // ensure "henvendelsessted" tasks are updated
                    if (!OrganisationRegistryProperties.GetInstance().DisableHenvendelsessteder)
                    {
                        ServiceHelper.UpdateContactForTasks(registration.Uuid, registration.ContactForTasks, registration.Timestamp);
                    }

                    UpdateOrganisationObject(orgUnitData);

                    log.Debug("Update successful on OrgUnit '" + registration.Uuid + "'");
                }
            }
            catch (Exception ex) when(ex is STSNotFoundException || ex is ServiceNotFoundException)
            {
                log.Warn("Update on OrgUnitService failed for '" + registration.Uuid + "' due to unavailable KOMBIT services", ex);
                throw new TemporaryFailureException(ex.Message);
            }
        }
Esempio n. 3
0
 private void UpdateOrganisationObject(OrgUnitData orgUnitData)
 {
     try
     {
         // if this is the root, we need to update the Organisation object
         if (string.IsNullOrEmpty(orgUnitData.ParentOrgUnitUuid))
         {
             organisationStub.Ret(orgUnitData.Uuid);
         }
     }
     catch (Exception ex)
     {
         // this is okay - it is expected that KOMBIT will take ownership of the object in the future
         log.Warn("Failed to update Organisation object with Overordnet relationship - probably because of KOMBIT ownership: " + ex.Message);
     }
 }
Esempio n. 4
0
        /// <summary>
        /// This method will create the object in Organisation - note that if the object already exists, this method
        /// will fail. If unsure whether the object exists, use Update() instead, as that will fallback to Create
        /// if the object does not exist.
        /// </summary>
        public void Create(OrgUnitRegistration registration)
        {
            log.Debug("Performing Create on OrgUnit '" + registration.Uuid + "'");

            ValidateAndEnforceCasing(registration);

            try
            {
                var addressRefs = ImportAddresses(registration);

                // mapping the unit must come after the addresses, as importing the address might set a UUID on the addresses if not supplied by the caller
                OrgUnitData orgUnitData = MapRegistrationToOrgUnitDTO(registration, addressRefs);

                // create manager relationship
                if (!string.IsNullOrEmpty(registration.ManagerUuid))
                {
                    ServiceHelper.UpdateManager(registration);
                }

                // if this unit is a working unit, that does payouts in behalf of a payout unit, create a reference to that payout unit
                if (!string.IsNullOrEmpty(registration.PayoutUnitUuid))
                {
                    string payoutUnitFunctionUuid = ServiceHelper.EnsurePayoutUnitFunctionExists(registration.PayoutUnitUuid, registration.Timestamp);

                    orgUnitData.OrgFunctionUuids.Add(payoutUnitFunctionUuid);
                }

                organisationEnhedStub.Importer(orgUnitData);

                UpdateOrganisationObject(orgUnitData);

                // ensure "henvendelsessted" tasks are created
                if (!OrganisationRegistryProperties.GetInstance().DisableHenvendelsessteder)
                {
                    ServiceHelper.UpdateContactForTasks(registration.Uuid, registration.ContactForTasks, registration.Timestamp);
                }

                log.Debug("Create successful on OrgUnit '" + registration.Uuid + "'");
            }
            catch (Exception ex) when(ex is STSNotFoundException || ex is ServiceNotFoundException)
            {
                log.Warn("Create on OrgUnitService failed for '" + registration.Uuid + "' due to unavailable KOMBIT services", ex);
                throw new TemporaryFailureException(ex.Message);
            }
        }
Esempio n. 5
0
        private OrgUnitData MapRegistrationToOrgUnitDTO(OrgUnitRegistration registration)
        {
            // loop through all address information in the input, and build the corresponding relations for OrgUnit object
            List <AddressRelation> addressRelations = new List <AddressRelation>();

            if (registration.Phone != null)
            {
                AddressRelation address = new AddressRelation();
                address.Type = AddressRelationType.PHONE;
                address.Uuid = registration.Phone.Uuid;
                addressRelations.Add(address);
            }

            if (registration.Email != null)
            {
                AddressRelation address = new AddressRelation();
                address.Type = AddressRelationType.EMAIL;
                address.Uuid = registration.Email.Uuid;
                addressRelations.Add(address);
            }

            if (registration.Location != null)
            {
                AddressRelation address = new AddressRelation();
                address.Type = AddressRelationType.LOCATION;
                address.Uuid = registration.Location.Uuid;
                addressRelations.Add(address);
            }

            if (registration.LOSShortName != null)
            {
                AddressRelation address = new AddressRelation();
                address.Type = AddressRelationType.LOSSHORTNAME;
                address.Uuid = registration.LOSShortName.Uuid;
                addressRelations.Add(address);
            }

            if (registration.Ean != null)
            {
                AddressRelation address = new AddressRelation();
                address.Type = AddressRelationType.EAN;
                address.Uuid = registration.Ean.Uuid;
                addressRelations.Add(address);
            }

            if (registration.Post != null)
            {
                AddressRelation address = new AddressRelation();
                address.Type = AddressRelationType.POST;
                address.Uuid = registration.Post.Uuid;
                addressRelations.Add(address);
            }

            if (registration.ContactOpenHours != null)
            {
                AddressRelation address = new AddressRelation();
                address.Type = AddressRelationType.CONTACT_ADDRESS_OPEN_HOURS;
                address.Uuid = registration.ContactOpenHours.Uuid;
                addressRelations.Add(address);
            }

            if (registration.EmailRemarks != null)
            {
                AddressRelation address = new AddressRelation();
                address.Type = AddressRelationType.EMAIL_REMARKS;
                address.Uuid = registration.EmailRemarks.Uuid;
                addressRelations.Add(address);
            }

            if (registration.PostReturn != null)
            {
                AddressRelation address = new AddressRelation();
                address.Type = AddressRelationType.POST_RETURN;
                address.Uuid = registration.PostReturn.Uuid;
                addressRelations.Add(address);
            }

            if (registration.Contact != null)
            {
                AddressRelation address = new AddressRelation();
                address.Type = AddressRelationType.CONTACT_ADDRESS;
                address.Uuid = registration.Contact.Uuid;
                addressRelations.Add(address);
            }

            if (registration.PhoneOpenHours != null)
            {
                AddressRelation address = new AddressRelation();
                address.Type = AddressRelationType.PHONE_OPEN_HOURS;
                address.Uuid = registration.PhoneOpenHours.Uuid;
                addressRelations.Add(address);
            }

            OrgUnitData organisationEnhed = new OrgUnitData();

            organisationEnhed.ShortKey          = registration.ShortKey;
            organisationEnhed.Name              = registration.Name;
            organisationEnhed.Addresses         = addressRelations;
            organisationEnhed.Timestamp         = registration.Timestamp;
            organisationEnhed.Uuid              = registration.Uuid;
            organisationEnhed.ParentOrgUnitUuid = registration.ParentOrgUnitUuid;

            return(organisationEnhed);
        }
Esempio n. 6
0
        /// <summary>
        /// This method will create the object in Organisation - note that if the object already exists, this method
        /// will fail. If unsure whether the object exists, use Update() instead, as that will fallback to Create
        /// if the object does not exist.
        /// </summary>
        public void Create(OrgUnitRegistration registration)
        {
            log.Debug("Performing Create on OrgUnit '" + registration.Uuid + "'");

            ValidateAndEnforceCasing(registration);

            try
            {
                string uuid = null;

                // Import addresses
                ServiceHelper.ImportAddress(registration.Phone, registration.Timestamp, out uuid);
                if (uuid != null)
                {
                    registration.Phone.Uuid = uuid;
                }

                ServiceHelper.ImportAddress(registration.Email, registration.Timestamp, out uuid);
                if (uuid != null)
                {
                    registration.Email.Uuid = uuid;
                }

                ServiceHelper.ImportAddress(registration.Location, registration.Timestamp, out uuid);
                if (uuid != null)
                {
                    registration.Location.Uuid = uuid;
                }

                ServiceHelper.ImportAddress(registration.LOSShortName, registration.Timestamp, out uuid);
                if (uuid != null)
                {
                    registration.LOSShortName.Uuid = uuid;
                }

                ServiceHelper.ImportAddress(registration.EmailRemarks, registration.Timestamp, out uuid);
                if (uuid != null)
                {
                    registration.EmailRemarks.Uuid = uuid;
                }

                ServiceHelper.ImportAddress(registration.PostReturn, registration.Timestamp, out uuid);
                if (uuid != null)
                {
                    registration.PostReturn.Uuid = uuid;
                }

                ServiceHelper.ImportAddress(registration.Contact, registration.Timestamp, out uuid);
                if (uuid != null)
                {
                    registration.Contact.Uuid = uuid;
                }

                ServiceHelper.ImportAddress(registration.PhoneOpenHours, registration.Timestamp, out uuid);
                if (uuid != null)
                {
                    registration.PhoneOpenHours.Uuid = uuid;
                }

                ServiceHelper.ImportAddress(registration.ContactOpenHours, registration.Timestamp, out uuid);
                if (uuid != null)
                {
                    registration.ContactOpenHours.Uuid = uuid;
                }

                ServiceHelper.ImportAddress(registration.Ean, registration.Timestamp, out uuid);
                if (uuid != null)
                {
                    registration.Ean.Uuid = uuid;
                }

                ServiceHelper.ImportAddress(registration.Post, registration.Timestamp, out uuid);
                if (uuid != null)
                {
                    registration.Post.Uuid = uuid;
                }

                // mapping the unit must come after the addresses, as importing the address might set a UUID on the addresses if not supplied by the caller
                OrgUnitData orgUnitData = MapRegistrationToOrgUnitDTO(registration);

                // flag all it-systems that we use within this OU
                if (registration.ItSystemUuids != null)
                {
                    foreach (string itSystemUuid in registration.ItSystemUuids)
                    {
                        ServiceHelper.OrgUnitStartUsingItSystem(registration.Uuid, itSystemUuid, registration.Timestamp);
                    }
                }

                // create relations to all ContactPlaces
                if (registration.ContactPlaces != null)
                {
                    foreach (DTO.V1_1.ContactPlace contactPlace in registration.ContactPlaces)
                    {
                        string contactPlaceUuid = ServiceHelper.CreateContactPlace(registration, contactPlace);

                        orgUnitData.OrgFunctionUuids.Add(contactPlaceUuid);
                    }
                }

                // if this unit is a working unit, that does payouts in behalf of a payout unit, create a reference to that payout unit
                if (!string.IsNullOrEmpty(registration.PayoutUnitUuid))
                {
                    string payoutUnitFunctionUuid = ServiceHelper.EnsurePayoutUnitFunctionExists(registration.PayoutUnitUuid, registration.Timestamp);

                    orgUnitData.OrgFunctionUuids.Add(payoutUnitFunctionUuid);
                }

                organisationEnhedStub.Importer(orgUnitData);

                UpdateOrganisationObject(orgUnitData);

                log.Debug("Create successful on OrgUnit '" + registration.Uuid + "'");
            }
            catch (Exception ex) when(ex is STSNotFoundException || ex is ServiceNotFoundException)
            {
                log.Warn("Create on OrgUnitService failed for '" + registration.Uuid + "' due to unavailable KOMBIT services", ex);
                throw new TemporaryFailureException(ex.Message);
            }
        }
Esempio n. 7
0
        /// <summary>
        /// This method will check whether the OrgUnit already exists inside Organisation, read it if it does, and perform
        /// the correct update (registering the delta-changes between the local object and the org-object). If the object
        /// does not already exist, it will pass the registration to the Create method.
        /// </summary>
        public void Update(OrgUnitRegistration registration)
        {
            log.Debug("Performing Update on OrgUnit '" + registration.Uuid + "'");

            ValidateAndEnforceCasing(registration);

            try
            {
                var result = organisationEnhedStub.GetLatestRegistration(registration.Uuid);
                if (result == null)
                {
                    log.Debug("Update on OrgUnit '" + registration.Uuid + "' changed to a Create because it does not exists as an active object within Organisation");
                    Create(registration);
                }
                else
                {
                    #region Update Addresses in Organisation if needed
                    // check what already exists in Organisation - and store the UUIDs of the existing addresses, we will need those later
                    string orgPhoneUuid = null, orgEmailUuid = null, orgLocationUuid = null, orgLOSShortNameUuid = null, orgEanUuid = null, orgContactHoursUuid = null, orgPhoneHoursUuid = null, orgPostUuid = null, orgPostReturnUuid = null, orgContactUuid = null, orgEmailRemarksUuid = null;
                    if (result.RelationListe.Adresser != null)
                    {
                        foreach (var orgAddress in result.RelationListe.Adresser)
                        {
                            if (orgAddress.Rolle.Item.Equals(UUIDConstants.ADDRESS_ROLE_ORGUNIT_PHONE))
                            {
                                orgPhoneUuid = orgAddress.ReferenceID.Item;
                            }
                            else if (orgAddress.Rolle.Item.Equals(UUIDConstants.ADDRESS_ROLE_ORGUNIT_EMAIL))
                            {
                                orgEmailUuid = orgAddress.ReferenceID.Item;
                            }
                            else if (orgAddress.Rolle.Item.Equals(UUIDConstants.ADDRESS_ROLE_ORGUNIT_LOCATION))
                            {
                                orgLocationUuid = orgAddress.ReferenceID.Item;
                            }
                            else if (orgAddress.Rolle.Item.Equals(UUIDConstants.ADDRESS_ROLE_ORGUNIT_LOSSHORTNAME))
                            {
                                orgLOSShortNameUuid = orgAddress.ReferenceID.Item;
                            }
                            else if (orgAddress.Rolle.Item.Equals(UUIDConstants.ADDRESS_ROLE_ORGUNIT_EAN))
                            {
                                orgEanUuid = orgAddress.ReferenceID.Item;
                            }
                            else if (orgAddress.Rolle.Item.Equals(UUIDConstants.ADDRESS_ROLE_ORGUNIT_PHONE_OPEN_HOURS))
                            {
                                orgPhoneHoursUuid = orgAddress.ReferenceID.Item;
                            }
                            else if (orgAddress.Rolle.Item.Equals(UUIDConstants.ADDRESS_ROLE_ORGUNIT_POST))
                            {
                                orgPostUuid = orgAddress.ReferenceID.Item;
                            }
                            else if (orgAddress.Rolle.Item.Equals(UUIDConstants.ADDRESS_ROLE_ORGUNIT_CONTACT_ADDRESS_OPEN_HOURS))
                            {
                                orgContactHoursUuid = orgAddress.ReferenceID.Item;
                            }
                            else if (orgAddress.Rolle.Item.Equals(UUIDConstants.ADDRESS_ROLE_ORGUNIT_POST_RETURN))
                            {
                                orgPostReturnUuid = orgAddress.ReferenceID.Item;
                            }
                            else if (orgAddress.Rolle.Item.Equals(UUIDConstants.ADDRESS_ROLE_ORGUNIT_CONTACT_ADDRESS))
                            {
                                orgContactUuid = orgAddress.ReferenceID.Item;
                            }
                            else if (orgAddress.Rolle.Item.Equals(UUIDConstants.ADDRESS_ROLE_ORGUNIT_EMAIL_REMARKS))
                            {
                                orgEmailRemarksUuid = orgAddress.ReferenceID.Item;
                            }
                        }
                    }

                    // run through all the input addresses, and deal with them one by one
                    ServiceHelper.UpdateAddress(registration.Phone, orgPhoneUuid, registration.Timestamp);
                    ServiceHelper.UpdateAddress(registration.Email, orgEmailUuid, registration.Timestamp);
                    ServiceHelper.UpdateAddress(registration.Location, orgLocationUuid, registration.Timestamp);
                    ServiceHelper.UpdateAddress(registration.LOSShortName, orgLOSShortNameUuid, registration.Timestamp);
                    ServiceHelper.UpdateAddress(registration.Ean, orgEanUuid, registration.Timestamp);
                    ServiceHelper.UpdateAddress(registration.ContactOpenHours, orgContactHoursUuid, registration.Timestamp);
                    ServiceHelper.UpdateAddress(registration.EmailRemarks, orgEmailRemarksUuid, registration.Timestamp);
                    ServiceHelper.UpdateAddress(registration.PostReturn, orgPostReturnUuid, registration.Timestamp);
                    ServiceHelper.UpdateAddress(registration.Contact, orgContactUuid, registration.Timestamp);
                    ServiceHelper.UpdateAddress(registration.PhoneOpenHours, orgPhoneHoursUuid, registration.Timestamp);
                    ServiceHelper.UpdateAddress(registration.Post, orgPostUuid, registration.Timestamp);
                    #endregion

                    // this must happen after addresses have been imported, as it might result in UUID's being created
                    OrgUnitData orgUnitData = MapRegistrationToOrgUnitDTO(registration);

                    #region Update it-usage
                    List <string> itSystemsInOrg = ServiceHelper.FindItSystemsForOrgUnit(registration.Uuid);

                    // TODO, it is not stopping the old ones, but it is adding the new ones (hurray) - this is a bug in KMD read method, which needs to be fixed before this will work correctly
                    foreach (string itSystemUuid in ServiceHelper.GetItSystemsNoLongerInUse(itSystemsInOrg, registration.ItSystemUuids))
                    {
                        ServiceHelper.OrgUnitStopUsingItSystem(registration.Uuid, itSystemUuid, registration.Timestamp);
                    }

                    foreach (string itSystemUuid in ServiceHelper.GetItSystemsNewInUse(itSystemsInOrg, registration.ItSystemUuids))
                    {
                        ServiceHelper.OrgUnitStartUsingItSystem(registration.Uuid, itSystemUuid, registration.Timestamp);
                    }
                    #endregion

                    #region Update payout units
                    // if this unit handles payouts on behalf of a payout unit, create a reference to that payout unit
                    if (!string.IsNullOrEmpty(registration.PayoutUnitUuid))
                    {
                        string payoutUnitFunctionUuid = ServiceHelper.EnsurePayoutUnitFunctionExists(registration.PayoutUnitUuid, registration.Timestamp);

                        orgUnitData.OrgFunctionUuids.Add(payoutUnitFunctionUuid);
                    }
                    #endregion

                    #region Update ContactPlaces

                    /*
                     * 1. iterate over all existing functions
                     *    1a) read the function
                     *    1b) compare to local list of OU's
                     *        1ba) if match, compare KLE and update if needed (history, sigh) - save UUID of function for later use
                     *        1bb) if not match, do nothing for now (but add TODO, as we might want to delete it in a later update of the code)
                     *    1c) any local contact place not already existing is created, and UUID of function is stored for later use
                     *    1d) all UUIDs of functinos (created, skipped or updated (but not deleted)) are added to the update
                     *  2. the ret() method already performs the correct update
                     */
                    List <string> foundContactPlaces = new List <string>(); // use this for keeping track of already existing ContactPlaces

                    // compare all existing functions, to see which to update (and to grab the UUID of the functions)
                    if (result.RelationListe?.Opgaver != null)
                    {
                        foreach (var opgave in result.RelationListe.Opgaver)
                        {
                            string functionUuid = opgave.ReferenceID.Item;
                            string orgUnitUuid  = null;

                            // see if we can read the existing function
                            var orgContactPlace = organisationFunktionStub.GetLatestRegistration(functionUuid);
                            if (orgContactPlace == null)
                            {
                                log.Warn("OrgUnit " + registration.Uuid + " has a relation to a ContactPlaces function " + functionUuid + " that does not exist");
                                continue;
                            }

                            // figure out which OrgUnit this function points to
                            var tilknyttedeEnheder = orgContactPlace.RelationListe?.TilknyttedeEnheder;
                            if (tilknyttedeEnheder != null && tilknyttedeEnheder.Length == 1)
                            {
                                orgUnitUuid = tilknyttedeEnheder[0].ReferenceID?.Item;
                            }
                            if (orgUnitUuid == null)
                            {
                                log.Warn("OrgUnit " + registration.Uuid + " has a relation to a ContactPlaces function " + functionUuid + " that does not have a single OrgUnit reference");
                                continue;
                            }

                            // let us see if this is one of the locally supplied ContactPlaces (we might need to update the one stored in Org, and we need the UUID if it already exists)
                            if (registration.ContactPlaces != null)
                            {
                                foreach (DTO.V1_1.ContactPlace localContactPlace in registration.ContactPlaces)
                                {
                                    if (localContactPlace.OrgUnitUuid.Equals(orgUnitUuid))
                                    {
                                        ServiceHelper.UpdateContactPlace(functionUuid, localContactPlace.Tasks, registration.Timestamp);

                                        // store a reference, so this function is not deleted
                                        orgUnitData.OrgFunctionUuids.Add(functionUuid);

                                        // and flag it as found, so we do not create a new one
                                        foundContactPlaces.Add(localContactPlace.OrgUnitUuid);
                                    }
                                }
                            }
                        }
                    }

                    // create all *new* ContactPlaces
                    if (registration.ContactPlaces != null)
                    {
                        foreach (DTO.V1_1.ContactPlace contactPlace in registration.ContactPlaces)
                        {
                            if (!foundContactPlaces.Contains(contactPlace.OrgUnitUuid))
                            {
                                string contactPlaceUuid = ServiceHelper.CreateContactPlace(registration, contactPlace);

                                orgUnitData.OrgFunctionUuids.Add(contactPlaceUuid);
                            }
                        }
                    }
                    #endregion

                    organisationEnhedStub.Ret(orgUnitData);

                    UpdateOrganisationObject(orgUnitData);

                    log.Debug("Update successful on OrgUnit '" + registration.Uuid + "'");
                }
            }
            catch (Exception ex) when(ex is STSNotFoundException || ex is ServiceNotFoundException)
            {
                log.Warn("Update on OrgUnitService failed for '" + registration.Uuid + "' due to unavailable KOMBIT services", ex);
                throw new TemporaryFailureException(ex.Message);
            }
        }