public async Task <Result> AddLocalitySynonym(AddLocalitySynonymRequest addLocalitySynonymRequest,
                                                      CancellationToken cancellationToken = default)
        {
            return(await GetLocality(addLocalitySynonymRequest.ExistingLocalityName)
                   .Ensure(l => l != null,
                           $"Locality with name {addLocalitySynonymRequest.ExistingLocalityName} and countryCode {addLocalitySynonymRequest.CountryCode} does not exist.")
                   .Ensure(IsNotExistSynonym !,
                           $"Synonym for {addLocalitySynonymRequest.ExistingLocalityName} and countryCode {addLocalitySynonymRequest.CountryCode} with name {addLocalitySynonymRequest.SynonymLocalityName} already exist.")
                   .Ensure(IsNotExistSynonymInLocalities !,
                           $"Locality with name {addLocalitySynonymRequest.SynonymLocalityName} and countryCode {addLocalitySynonymRequest.CountryCode} exist in Localities and can not be synonym for locality {addLocalitySynonymRequest.ExistingLocalityName}")
                   .Tap(AddSynonym !));


            async Task <Result <Locality?> > GetLocality(string name)
            => await(from l in _dbContext.Localities
                     join c in _dbContext.Countries on l.CountryId equals c.Id
                         where l.IsActive && l.Names.En == name && c.Code == addLocalitySynonymRequest.CountryCode
                     select l)
            .SingleOrDefaultAsync(cancellationToken);


            async Task <bool> IsNotExistSynonym(Locality locality)
            {
                var synonym = await _dbContext.LocalitySynonyms
                              .SingleOrDefaultAsync(ls => ls.LocalityId == locality.Id && ls.Names.En == addLocalitySynonymRequest.SynonymLocalityName,
                                                    cancellationToken);

                return(synonym == default);
            }

            async Task <bool> IsNotExistSynonymInLocalities(Locality _)
            {
                var(_, _, locality, _) = await GetLocality(addLocalitySynonymRequest.SynonymLocalityName);

                return(locality == null);
            }

            async Task AddSynonym(Locality locality)
            {
                var now = DateTimeOffset.UtcNow;

                _dbContext.LocalitySynonyms.Add(new LocalitySynonym
                {
                    LocalityId = locality.Id,
                    Names      = new MultiLanguage <string> {
                        En = addLocalitySynonymRequest.SynonymLocalityName
                    },
                    SynonymType = LocalitySynonymTypes.New,
                    Created     = now,
                    Modified    = now
                });
                await _dbContext.SaveChangesAsync(cancellationToken);
            }
        }
Example #2
0
        public async Task <IActionResult> AddLocalitySynonym([FromBody] AddLocalitySynonymRequest addLocalitySynonymRequest,
                                                             CancellationToken cancellationToken = default)
        {
            var(_, isFailure, error) = await _localityManagementService.AddLocalitySynonym(addLocalitySynonymRequest, cancellationToken);

            if (isFailure)
            {
                return(BadRequestWithProblemDetails(error));
            }

            return(NoContent());
        }