Пример #1
0
 public async Task<IActionResult> List([FromQuery] UnitSubmitM model)
     => Ok(await _service.LinksList(model));
Пример #2
0
        /// <summary>
        /// Stat search method. units by code
        /// </summary>
        /// <param name = "type"> Type of static unit </param>
        /// <param name = "code"> Code </param>
        /// <param name = "isDeleted"> Delete flag </param>
        /// <param name = "limit"> Display limitation </param>
        /// <param name = "userId"> User Id </param>
        /// <param name = "regId"> Registration Id </param>
        /// <param name = "page"> Current page </param>
        /// <returns> </returns>
        public async Task <List <UnitLookupVm> > Search(StatUnitTypes type, string code, string userId, int regId, bool isDeleted, int limit = 5, int page = 1)
        {
            if (isDeleted)
            {
                var list = new List <UnitLookupVm>();

                var root = new UnitSubmitM()
                {
                    Id   = regId,
                    Type = type
                };
                switch (type)
                {
                case StatUnitTypes.EnterpriseGroup:
                    list.AddRange(Common.ToUnitLookupVm(
                                      await _commonSvc.GetUnitsList <EnterpriseUnit>(false)
                                      .Where(v => v.EntGroupId == regId)
                                      .Select(Common.UnitMapping)
                                      .ToListAsync()
                                      ));
                    break;

                case StatUnitTypes.EnterpriseUnit:
                    list.AddRange(Common.ToUnitLookupVm(
                                      await _commonSvc.GetUnitsList <EnterpriseUnit>(false)
                                      .Where(v => v.RegId == regId)
                                      .Include(v => v.EnterpriseGroup)
                                      .Select(v => v.EnterpriseGroup)
                                      .Select(Common.UnitMapping)
                                      .ToListAsync()
                                      ));
                    list.AddRange(Common.ToUnitLookupVm(
                                      await _commonSvc.GetUnitsList <LegalUnit>(false)
                                      .Where(v => v.EnterpriseUnitRegId == regId)
                                      .Select(Common.UnitMapping)
                                      .ToListAsync()
                                      ));
                    break;

                case StatUnitTypes.LegalUnit:
                    list.AddRange(Common.ToUnitLookupVm(
                                      await _commonSvc.GetUnitsList <LegalUnit>(false)
                                      .Where(v => v.RegId == regId)
                                      .Include(v => v.EnterpriseUnit)
                                      .Select(v => v.EnterpriseUnit)
                                      .Select(Common.UnitMapping)
                                      .ToListAsync()
                                      ));
                    list.AddRange(Common.ToUnitLookupVm(
                                      await _commonSvc.GetUnitsList <LocalUnit>(false)
                                      .Where(v => v.LegalUnitId == regId)
                                      .Select(Common.UnitMapping)
                                      .ToListAsync()
                                      ));
                    break;

                case StatUnitTypes.LocalUnit:
                    var linkedList = await _service.LinksList(root);

                    if (linkedList.Count > 0)
                    {
                        list.Add(new UnitLookupVm {
                            Id = linkedList[0].Source1.Id, Type = linkedList[0].Source1.Type, Code = linkedList[0].Source1.Code, Name = linkedList[0].Source1.Name
                        });
                    }
                    break;
                }

                return(list);
            }

            var statUnitTypes = new List <StatUnitTypes>();

            switch (type)
            {
            case StatUnitTypes.LocalUnit:
                statUnitTypes.Add(StatUnitTypes.LegalUnit);
                break;

            case StatUnitTypes.LegalUnit:
                statUnitTypes.Add(StatUnitTypes.LocalUnit);
                statUnitTypes.Add(StatUnitTypes.EnterpriseUnit);
                break;

            case StatUnitTypes.EnterpriseUnit:
                statUnitTypes.Add(StatUnitTypes.LegalUnit);
                statUnitTypes.Add(StatUnitTypes.EnterpriseGroup);
                break;

            case StatUnitTypes.EnterpriseGroup:
                statUnitTypes.Add(StatUnitTypes.EnterpriseUnit);
                break;
            }

            var filter = new SearchQueryM
            {
                Type     = statUnitTypes,
                StatId   = code,
                Page     = page,
                PageSize = limit
            };

            var searchResponse = await _elasticService.Search(filter, userId, isDeleted);

            return(searchResponse.Result.Select(u => new UnitLookupVm {
                Id = u.RegId, Code = u.StatId, Name = u.Name, Type = u.UnitType
            }).ToList());
        }