Ejemplo n.º 1
0
        public async Task <(List <Tool>, int)> getTools(int startat, int quantity, ToolFieldEnum fieldFilter,
                                                        string fieldValue, ToolFieldEnum orderField, OrderEnum order)
        {
            var queryTool = _context.Tools.Where(x => x.toolId > 0).Include(x => x.toolType).AsQueryable();

            queryTool = ApplyFilter(queryTool, fieldFilter, fieldValue);
            queryTool = ApplyOrder(queryTool, orderField, order);
            var toolId = await queryTool
                         .Skip(startat).Take(quantity)
                         .Select(x => x.toolId)
                         .ToListAsync();

            var queryToolCount = _context.Tools.Where(x => x.toolId > 0);

            queryToolCount = ApplyFilter(queryToolCount, fieldFilter, fieldValue);
            queryToolCount = ApplyOrder(queryToolCount, orderField, order);
            var totalCount = await queryToolCount.CountAsync();

            List <Tool> tools = new List <Tool> ();

            foreach (var item in toolId)
            {
                var tool = await getTool(item);

                if (tool != null)
                {
                    tools.Add(tool);
                }
            }

            return(tools, totalCount);
        }
Ejemplo n.º 2
0
        private IQueryable <Tool> ApplyFilter(IQueryable <Tool> queryTool,
                                              ToolFieldEnum fieldFilter, string fieldValue)
        {
            switch (fieldFilter)
            {
            case ToolFieldEnum.Code:
                queryTool = queryTool.Where(x => x.code.Contains(fieldValue));
                break;

            case ToolFieldEnum.Description:
                queryTool = queryTool.Where(x => x.description.Contains(fieldValue));
                break;

            case ToolFieldEnum.Name:
                queryTool = queryTool.Where(x => x.name.Contains(fieldValue));
                break;

            case ToolFieldEnum.SerialNumber:
                queryTool = queryTool.Where(x => x.serialNumber.Contains(fieldValue));
                break;

            case ToolFieldEnum.Status:
                queryTool = queryTool.Where(x => x.status.Contains(fieldValue));
                break;

            case ToolFieldEnum.TypeName:
                queryTool = queryTool.Where(x => x.typeName.Contains(fieldValue));
                break;

            default:
                break;
            }
            return(queryTool);
        }
Ejemplo n.º 3
0
        private IQueryable <Tool> ApplyOrder(IQueryable <Tool> queryTags,
                                             ToolFieldEnum orderField, OrderEnum order)
        {
            switch (orderField)
            {
            case ToolFieldEnum.Code:
                if (order == OrderEnum.Ascending)
                {
                    queryTags = queryTags.OrderBy(x => x.code);
                }
                else
                {
                    queryTags = queryTags.OrderByDescending(x => x.code);
                }
                break;

            case ToolFieldEnum.Description:
                if (order == OrderEnum.Ascending)
                {
                    queryTags = queryTags.OrderBy(x => x.description);
                }
                else
                {
                    queryTags = queryTags.OrderByDescending(x => x.description);
                }
                break;

            case ToolFieldEnum.Name:
                if (order == OrderEnum.Ascending)
                {
                    queryTags = queryTags.OrderBy(x => x.name);
                }
                else
                {
                    queryTags = queryTags.OrderByDescending(x => x.name);
                }
                break;

            case ToolFieldEnum.SerialNumber:
                if (order == OrderEnum.Ascending)
                {
                    queryTags = queryTags.OrderBy(x => x.serialNumber);
                }
                else
                {
                    queryTags = queryTags.OrderByDescending(x => x.serialNumber);
                }
                break;

            case ToolFieldEnum.Status:
                if (order == OrderEnum.Ascending)
                {
                    queryTags = queryTags.OrderBy(x => x.status);
                }
                else
                {
                    queryTags = queryTags.OrderByDescending(x => x.status);
                }
                break;

            case ToolFieldEnum.TypeName:
                if (order == OrderEnum.Ascending)
                {
                    queryTags = queryTags.OrderBy(x => x.typeName);
                }
                else
                {
                    queryTags = queryTags.OrderByDescending(x => x.typeName);
                }
                break;

            default:
                queryTags = queryTags.OrderBy(x => x.toolId);
                break;
            }
            return(queryTags);
        }