Example #1
0
        /// <summary>
        /// Legal unit creation method
        /// </summary>
        /// <param name="data">Data</param>
        /// <param name="userId">User Id</param>
        /// <returns></returns>
        public async Task <Dictionary <string, string[]> > CreateLegalUnit(LegalUnitCreateM data, string userId)
        => await CreateUnitContext <LegalUnit, LegalUnitCreateM>(data, userId, unit =>
        {
            var helper = new StatUnitCheckPermissionsHelper(_dbContext);
            helper.CheckRegionOrActivityContains(userId, data.Address?.RegionId, data.ActualAddress?.RegionId, data.PostalAddress?.RegionId, data.Activities.Select(x => x.ActivityCategoryId).ToList());

            if (Common.HasAccess <LegalUnit>(data.DataAccess, v => v.LocalUnits))
            {
                if (data.LocalUnits == null)
                {
                    return(Task.CompletedTask);
                }
                var localUnits = _dbContext.LocalUnits.Where(x => data.LocalUnits.Contains(x.RegId));
                foreach (var localUnit in localUnits)
                {
                    unit.LocalUnits.Add(localUnit);
                }

                if (data.LocalUnits != null)
                {
                    unit.HistoryLocalUnitIds = string.Join(",", data.LocalUnits);
                }
            }
            return(Task.CompletedTask);
        });
Example #2
0
        /// <summary>
        /// Delete / Restore stat. units
        /// </summary>
        /// <param name="unitType">Type of stat. units</param>
        /// <param name="id">Id stat. units</param>
        /// <param name="toDelete">Remoteness flag</param>
        /// <param name="userId">User ID</param>
        public void DeleteUndelete(StatUnitTypes unitType, int id, bool toDelete, string userId)
        {
            if (_dataAccessService.CheckWritePermissions(userId, unitType))
            {
                throw new UnauthorizedAccessException();
            }

            var  item       = _commonSvc.GetStatisticalUnitByIdAndType(id, unitType, true).Result;
            bool isEmployee = _userService.IsInRoleAsync(userId, DefaultRoleNames.Employee).Result;
            var  mappedItem = Mapper.Map <IStatisticalUnit, ElasticStatUnit>(item);

            if (isEmployee)
            {
                var helper = new StatUnitCheckPermissionsHelper(_dbContext);
                helper.CheckRegionOrActivityContains(userId, mappedItem.RegionIds, mappedItem.ActivityCategoryIds);
            }
            if (item.IsDeleted == toDelete)
            {
                _elasticService.EditDocument(Mapper.Map <IStatisticalUnit, ElasticStatUnit>(item)).Wait();
            }
            else
            {
                CheckBeforeDelete(item, toDelete);
                var deletedUnit = _deleteUndeleteActions[unitType](id, toDelete, userId);
                _postDeleteActions[unitType](deletedUnit, toDelete, userId);

                _elasticService.EditDocument(Mapper.Map <IStatisticalUnit, ElasticStatUnit>(deletedUnit)).Wait();
            }
        }
Example #3
0
        /// <summary>
        /// Local unit creation method
        /// </summary>
        /// <param name="data">Data</param>
        /// <param name="userId">User Id</param>
        /// <returns></returns>
        public async Task <Dictionary <string, string[]> > CreateLocalUnit(LocalUnitCreateM data, string userId)
        {
            var helper = new StatUnitCheckPermissionsHelper(_dbContext);

            helper.CheckRegionOrActivityContains(userId, data.Address?.RegionId, data.ActualAddress?.RegionId, data.PostalAddress?.RegionId, data.Activities.Select(x => x.ActivityCategoryId).ToList());

            return(await CreateUnitContext <LocalUnit, LocalUnitCreateM>(data, userId, null));
        }
Example #4
0
        /// <summary>
        /// Stat search method. units
        /// </summary>
        /// <param name = "filter"> Request </param>
        /// <param name = "userId"> User Id </param>
        /// <param name = "isDeleted"> Distance flag </param>
        /// <returns> </returns>
        public async Task <SearchVm> Search(SearchQueryM filter, string userId, bool isDeleted = false)
        {
            await _elasticService.CheckElasticSearchConnection();

            bool isAdmin = await _userService.IsInRoleAsync(userId, DefaultRoleNames.Administrator);

            long totalCount;
            List <ElasticStatUnit> units;

            if (filter.IsEmpty())
            {
                var baseQuery = _dbContext.StatUnitSearchView
                                .Where(s => s.IsDeleted == isDeleted && s.LiqDate == null);

                totalCount = baseQuery.Count();
                units      = (await baseQuery.Skip((filter.Page - 1) * filter.PageSize).Take(filter.PageSize).ToListAsync())
                             .Select(Mapper.Map <StatUnitSearchView, ElasticStatUnit>).ToList();
            }
            else
            {
                var searchResponse = await _elasticService.Search(filter, userId, isDeleted);

                totalCount = searchResponse.TotalCount;
                units      = searchResponse.Result.ToList();
            }

            var finalIds = units.Where(x => x.UnitType != StatUnitTypes.EnterpriseGroup)
                           .Select(x => x.RegId).ToList();
            var finalRegionIds = units.Select(x => x.RegionId).ToList();

            var unitsToPersonNames = await GetUnitsToPersonNamesByUnitIds(finalIds);

            var unitsToMainActivities = await GetUnitsToPrimaryActivities(finalIds);

            var regions = await GetRegionsFullPaths(finalRegionIds);

            var permissions = await _userService.GetDataAccessAttributes(userId, null);

            var helper = new StatUnitCheckPermissionsHelper(_dbContext);
            var result = units
                         .Select(x => new SearchViewAdapterModel(x, unitsToPersonNames[x.RegId],
                                                                 unitsToMainActivities[x.RegId],
                                                                 regions.GetValueOrDefault(x.RegionId)))
                         .Select(x => SearchItemVm.Create(x, x.UnitType,
                                                          permissions.GetReadablePropNames(),
                                                          !isAdmin && !helper.IsRegionOrActivityContains(userId, x.RegionId != null ? new List <int> {
                (int)x.RegionId
            } : new List <int>(), x.ActivityCategoryIds)));

            return(SearchVm.Create(result, totalCount));
        }
Example #5
0
        /// <summary>
        /// Enterprise creation method
        /// </summary>
        /// <param name="data">Data</param>
        /// <param name="userId">User Id</param>
        /// <returns></returns>
        public async Task <Dictionary <string, string[]> > CreateEnterpriseUnit(EnterpriseUnitCreateM data, string userId)
        => await CreateUnitContext <EnterpriseUnit, EnterpriseUnitCreateM>(data, userId, unit =>
        {
            var helper = new StatUnitCheckPermissionsHelper(_dbContext);
            helper.CheckRegionOrActivityContains(userId, data.Address?.RegionId, data.ActualAddress?.RegionId, data.PostalAddress?.RegionId, data.Activities.Select(x => x.ActivityCategoryId).ToList());

            var legalUnits = _dbContext.LegalUnits.Where(x => data.LegalUnits.Contains(x.RegId)).ToList();
            foreach (var legalUnit in legalUnits)
            {
                unit.LegalUnits.Add(legalUnit);
            }

            if (data.LegalUnits != null)
            {
                unit.HistoryLegalUnitIds = string.Join(",", data.LegalUnits);
            }

            return(Task.CompletedTask);
        });
Example #6
0
        /// <summary>
        /// Method for creating an enterprise group
        /// </summary>
        /// <param name="data">Data</param>
        /// <param name="userId">User Id</param>
        /// <returns></returns>
        public async Task <Dictionary <string, string[]> > CreateEnterpriseGroup(EnterpriseGroupCreateM data, string userId)
        => await CreateContext <EnterpriseGroup, EnterpriseGroupCreateM>(data, userId, unit =>
        {
            var helper = new StatUnitCheckPermissionsHelper(_dbContext);
            helper.CheckRegionOrActivityContains(userId, data.Address?.RegionId, data.ActualAddress?.RegionId, data.PostalAddress?.RegionId, new List <int>());

            if (Common.HasAccess <EnterpriseGroup>(data.DataAccess, v => v.EnterpriseUnits))
            {
                var enterprises = _dbContext.EnterpriseUnits.Where(x => data.EnterpriseUnits.Contains(x.RegId))
                                  .ToList();
                foreach (var enterprise in enterprises)
                {
                    unit.EnterpriseUnits.Add(enterprise);
                }

                if (data.EnterpriseUnits != null)
                {
                    unit.HistoryEnterpriseUnitIds = string.Join(",", data.EnterpriseUnits);
                }
            }

            return(Task.CompletedTask);
        });
Example #7
0
        /// <summary>
        /// Method to get view model
        /// </summary>
        /// <param name = "id"> Id stat. units </param>
        /// <param name = "type"> Type of stat. units </param>
        /// <param name = "userId"> User Id </param>
        /// <param name = "ignoredActions"> </param>
        /// <returns> </returns>
        public async Task <StatUnitViewModel> GetViewModel(int?id, StatUnitTypes type, string userId, ActionsEnum ignoredActions)
        {
            bool isEmployee = await _userService.IsInRoleAsync(userId, DefaultRoleNames.Employee);

            var item = id.HasValue
                ? await _commonSvc.GetStatisticalUnitByIdAndType(id.Value, type, false)
                : GetDefaultDomainForType(type);

            if (item == null)
            {
                throw new BadRequestException(nameof(Resource.NotFoundMessage));
            }

            if ((ignoredActions == ActionsEnum.Edit) && isEmployee)
            {
                var helper     = new StatUnitCheckPermissionsHelper(_context);
                var mappedItem = new ElasticStatUnit();
                Mapper.Map(item, mappedItem);
                helper.CheckRegionOrActivityContains(userId, mappedItem.RegionIds, mappedItem.ActivityCategoryIds);
            }

            var dataAccess = await _userService.GetDataAccessAttributes(userId, item.UnitType);

            var config = type == StatUnitTypes.EnterpriseGroup
                ? _mandatoryFields.EnterpriseGroup
                : (object)_mandatoryFields.StatUnit;
            var mandatoryDict = config.GetType().GetProperties().ToDictionary(x => x.Name, GetValueFrom(config));

            if (type != StatUnitTypes.EnterpriseGroup)
            {
                object subConfig;
                switch (type)
                {
                case StatUnitTypes.LocalUnit:
                    subConfig = _mandatoryFields.LocalUnit;
                    break;

                case StatUnitTypes.LegalUnit:
                    subConfig = _mandatoryFields.LegalUnit;
                    break;

                case StatUnitTypes.EnterpriseUnit:
                    subConfig = _mandatoryFields.Enterprise;
                    break;

                default: throw new Exception("bad statunit type");
                }
                var getValue = GetValueFrom(subConfig);
                subConfig.GetType().GetProperties().ForEach(x => mandatoryDict[x.Name] = getValue(x));
            }

            //The LegalUnits field of the EnterpriseUnit type is required by business logic
            if (type == StatUnitTypes.EnterpriseUnit && mandatoryDict.ContainsKey("LegalUnits"))
            {
                mandatoryDict["LegalUnits"] = true;
            }

            return(StatUnitViewModelCreator.Create(item, dataAccess, mandatoryDict, ignoredActions));

            Func <PropertyInfo, bool> GetValueFrom(object source) => prop =>
            {
                var value = prop.GetValue(source);
                return(value is bool b && b);
            };
        }