예제 #1
0
        /// <summary>
        /// gets the items according to the filter
        /// </summary>
        /// <param name="filterInfo"></param>
        /// <returns></returns>
        public async Task <List <ItemDto> > FilterItems(InventoryItemFilterInfo filterInfo)
        {
            _loggingService.LogDebug(new
            {
                action     = nameof(FilterItems),
                filterInfo = filterInfo.ToString()
            });

            return(await _apiService.PostAsync <InventoryItemFilterInfo, List <ItemDto> >("Item/FilterItems", filterInfo));
        }
예제 #2
0
        public Task <AlpApiResponse <List <ItemDto> > > FilterItems(InventoryItemFilterInfo info)
        {
            var sessionToken = HttpContext.Request.Headers["sessiontoken"];

            if (!_accountService.Authorize(sessionToken, new List <RoleType> {
                RoleType.Admin, RoleType.DepartmentInventoryOperator
            }))
            {
                return(Task.FromResult(new AlpApiResponse <List <ItemDto> > {
                    Success = false, Message = "Nincs jogosultsága ehhez a művelethez!"
                }));
            }
            return(_itemService.FindItemsForDisplay(info));
        }
예제 #3
0
        /// <summary>
        /// filters items
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        public async Task <AlpApiResponse <List <ItemDto> > > FindItemsForDisplay(InventoryItemFilterInfo info)
        {
            var response = new AlpApiResponse <List <ItemDto> >();

            try
            {
                _logger.LogDebug(new
                {
                    action = nameof(FindItemsForDisplay),
                    info   = info?.ToString()
                }.ToString());

                if (info == null)
                {
                    response.Success = false;
                    response.Message = "Hibás szűrőparaméter!";
                    return(response);
                }

                var includesIds = info.Id != null && info.Id.Count > 0;
                var isManufacturerAndTypeSpecified = !string.IsNullOrEmpty(info.ManufacturerAndType);

                var areBuildingsSpecified   = info.Buildings != null && info.Buildings.Count > 0;
                var areDepartmentsSpecified = info.Departments != null && info.Departments.Count > 0;
                var areFloorsSpecified      = info.Floors != null && info.Floors.Count > 0;
                var areItemNaturesSpecified = info.ItemNatures != null && info.ItemNatures.Count > 0;
                var areItemStatesSpecified  = info.ItemStates != null && info.ItemStates.Count > 0;
                var areItemTypesSpecified   = info.ItemTypes != null && info.ItemTypes.Count > 0;
                var areLocationsSpecified   = info.Locations != null && info.Locations.Count > 0;
                var areSectionsSpecified    = info.Sections != null && info.Sections.Count > 0;

                var buildingIds   = info.Buildings.Select(b => b.Id).ToList();
                var departmentIds = info.Departments.Select(b => b.Id).ToList();
                var floorIds      = info.Floors.Select(b => b.Id).ToList();
                var itemNatureIds = info.ItemNatures.Select(b => b.Id).ToList();
                var itemStateIds  = info.ItemStates.Select(b => b.Id).ToList();
                var itemTypeIds   = info.ItemTypes.Select(b => b.Id).ToList();
                var locationIds   = info.Locations.Select(b => b.Id).ToList();
                var sectionIds    = info.Sections.Select(b => b.Id).ToList();

                List <Item> entities;
                if (!includesIds)
                {
                    entities = await _context.Item.AsNoTracking()
                               .Include(item => item.Department)
                               .Include(item => item.Employee)
                               .Include(item => item.Building)
                               .Include(item => item.Section)
                               .Include(item => item.Floor)
                               .Include(item => item.ItemNature)
                               .Include(item => item.ItemState)
                               .Include(item => item.ItemType)
                               .Where(item => (!isManufacturerAndTypeSpecified ||
                                               item.Manufacturer.Contains(info.ManufacturerAndType) ||
                                               item.ModelType.Contains(info.ManufacturerAndType)) &&
                                      (!info.BruttoPriceMin.HasValue ||
                                       (item.BruttoPrice.HasValue && item.BruttoPrice >= info.BruttoPriceMin)) &&
                                      (!info.BruttoPriceMax.HasValue ||
                                       (item.BruttoPrice.HasValue && item.BruttoPrice <= info.BruttoPriceMax)) &&
                                      (!info.DateOfCreationMax.HasValue ||
                                       (item.DateOfCreation.HasValue &&
                                        info.DateOfCreationMax >= item.DateOfCreation)) &&
                                      (!info.DateOfCreationMax.HasValue ||
                                       (item.DateOfCreation.HasValue &&
                                        info.DateOfCreationMin <= item.DateOfCreation)) &&
                                      (!info.YearOfManufactureMax.HasValue ||
                                       (item.ProductionYear.HasValue &&
                                        info.YearOfManufactureMax >= item.ProductionYear)) &&
                                      (!info.YearOfManufactureMin.HasValue ||
                                       (item.ProductionYear.HasValue &&
                                        info.YearOfManufactureMin <= item.ProductionYear)) &&
                                      (!info.DateOfScrapMax.HasValue ||
                                       (item.DateOfScrap.HasValue && info.DateOfScrapMax >= item.DateOfScrap)) &&
                                      (!info.DateOfCreationMin.HasValue || item.DateOfScrap.HasValue &&
                                       info.DateOfScrapMin >= item.DateOfScrap) &&
                                      (!areBuildingsSpecified || (item.BuildingId.HasValue && buildingIds.Contains(item.BuildingId.Value))) &&
                                      (!areDepartmentsSpecified || (item.DepartmentId.HasValue && departmentIds.Contains(item.DepartmentId.Value))) &&
                                      (!areItemNaturesSpecified || (item.ItemNatureId.HasValue && itemNatureIds.Contains(item.ItemNatureId.Value))) &&
                                      (!areItemTypesSpecified || (item.ItemTypeId.HasValue && itemTypeIds.Contains(item.ItemTypeId.Value))) &&
                                      (!areItemStatesSpecified || itemStateIds.Contains(item.ItemStateId)) &&
                                      (!areSectionsSpecified || (item.SectionId.HasValue && sectionIds.Contains(item.SectionId.Value))) &&
                                      (!areFloorsSpecified || (item.FloorId.HasValue && floorIds.Contains(item.FloorId.Value))))
                               .ToListAsync();
                }
                else
                {
                    entities = await _context.Item.AsNoTracking()
                               .Include(item => item.Department)
                               .Include(item => item.Employee)
                               .Include(item => item.Building)
                               .Include(item => item.Section)
                               .Include(item => item.Floor)
                               .Include(item => item.ItemNature)
                               .Include(item => item.ItemState)
                               .Include(item => item.ItemType)
                               .Where(item => info.Id.Contains(item.InventoryNumber) ||
                                      info.Id.Contains(item.OldInventoryNumber) ||
                                      info.Id.Contains(item.SerialNumber) ||
                                      info.Id.Contains(item.YellowNumber.ToString()) ||
                                      info.Id.Contains(item.AccreditationNumber))
                               .ToListAsync();
                }

                var items = entities.Select(entity => entity.EntityToDto()).ToList();
                response.Value = items;
            }
            catch (Exception e)
            {
                _logger.LogError(new
                {
                    exception             = e,
                    message               = e.Message,
                    innerException        = e,
                    innerExceptionMessage = e.InnerException?.Message
                }.ToString());
                response.Message = e.Message;
                response.Success = false;
            }

            return(response);
        }