コード例 #1
0
        public async Task <IActionResult> AddOrUpdate(SectorMappingModel model)
        {
            var response = await mappingService.AddOrUpdateAsync(model);

            if (!response.Success)
            {
                return(BadRequest(response.Message));
            }
            return(Ok(true));
        }
コード例 #2
0
        public async Task <ActionResponse> AddOrUpdateAsync(SectorMappingModel model)
        {
            using (var unitWork = new UnitOfWork(context))
            {
                ActionResponse response = new ActionResponse();
                IMessageHelper mHelper;
                try
                {
                    var sectorType = unitWork.SectorTypesRepository.GetByID(model.SectorTypeId);
                    if (sectorType == null)
                    {
                        mHelper          = new MessageHelper();
                        response.Success = false;
                        response.Message = mHelper.GetNotFound("Sector Type");
                        return(await Task <ActionResponse> .Run(() => response).ConfigureAwait(false));
                    }

                    if (sectorType.IsPrimary == true)
                    {
                        mHelper          = new MessageHelper();
                        response.Success = false;
                        response.Message = mHelper.InvalidSectorMapping(sectorType.TypeName);
                        return(await Task <ActionResponse> .Run(() => response).ConfigureAwait(false));
                    }

                    var sectors = unitWork.SectorRepository.GetManyQueryable(s => (model.MappingId == s.Id) || (s.Id == model.SectorId));
                    var sector  = (from s in sectors
                                   where s.Id == model.SectorId
                                   select s).FirstOrDefault();

                    if (sector == null)
                    {
                        mHelper          = new MessageHelper();
                        response.Success = false;
                        response.Message = mHelper.GetNotFound("Sector to map");
                        return(response);
                    }

                    var sectorToMap = (from s in sectors
                                       where s.Id == model.MappingId
                                       select s).FirstOrDefault();

                    if (sectorToMap == null)
                    {
                        mHelper          = new MessageHelper();
                        response.Success = false;
                        response.Message = mHelper.GetNotFound("Primary sector for mapping");
                        return(response);
                    }

                    var strategy = context.Database.CreateExecutionStrategy();
                    await strategy.ExecuteAsync(async() =>
                    {
                        using (var transaction = context.Database.BeginTransaction())
                        {
                            var sectorMappings = await unitWork.SectorMappingsRepository.GetManyQueryableAsync(m => m.SectorId == model.SectorId);
                            foreach (var mapping in sectorMappings)
                            {
                                unitWork.SectorMappingsRepository.Delete(mapping);
                                await unitWork.SaveAsync();
                            }
                            unitWork.SectorMappingsRepository.Insert(new EFSectorMappings()
                            {
                                SectorId       = sector.Id,
                                SectorTypeId   = sectorType.Id,
                                MappedSectorId = sectorToMap.Id
                            });
                            await unitWork.SaveAsync();
                            transaction.Commit();
                        }
                    });
                }
                catch (Exception ex)
                {
                    response.Success = false;
                    response.Message = ex.Message;
                }
                return(await Task <ActionResponse> .Run(() => response).ConfigureAwait(false));
            }
        }