/// <summary>
        /// Справочник Направлений
        /// </summary>
        private static async Task <ReportResponse> GetDirectionsTable(ReportRequest input, ILogger logger)
        {
            var sqlR   = new DirectionsRepository(logger);
            var result = new ReportResponse {
                Rows = new List <Row>()
            };

            var data = await sqlR.GetAll();

            result.Columns = new List <Column>
            {
                new Column("col0", "Название", "string", disableEdit: false),
            };

            foreach (var item in data)
            {
                var row = new Row
                {
                    Id       = new RowId(item.Id, 1),
                    HasItems = false.ToString(),
                    ParentId = null,
                    //Имя
                    Col0 = item.Name,
                };

                result.Rows.Add(row);
            }

            return(result);
        }
Beispiel #2
0
 public DirectionController
 (
     ILogger <DirectionController> logger,
     IMapper mapper
 )
 {
     base.Initialize();
     _logger = logger;
     _mapper = mapper;
     _sqlR   = new DirectionsRepository(_logger);
 }
        /// <summary>
        /// Отдает маршруты с временными промежутками то и рейсов для ебучего расписания
        /// </summary>
        public async Task <RoutesWithTimelinePaging> GetRoutesWithTimeline(int turnoverId, int skip, int limit, int?routeId = null)
        {
            RoutesWithTripsAndToPaging data;

            if (routeId != null)
            {
                data = await GetRoutesWithTripsAndToByTurnoverId(turnoverId, skip, limit, routeId);
            }
            else
            {
                data = await GetRoutesWithTripsAndToByTurnoverId(turnoverId, skip, limit);
            }

            var result = new RoutesWithTimelinePaging {
                Total = data.Total, Data = new List <ScheduleRouteTripsTo>()
            };

            foreach (var item in data.Data.OrderBy(x => int.Parse("0" + Regex.Match(x.Name, "(\\d+)").Value)))
            {
                var toAdd = new ScheduleRouteTripsTo();
                toAdd.RouteId   = item.Id;
                toAdd.Mileage   = item.Mileage;
                toAdd.RouteName = item.Name;
                toAdd.TimeLines = await TimelineFromTrips(item.Trips);

                var timelineFromInspectionRoutes = TimelineFromInspectionRoutes(item.InspectionRoutes);
                if (timelineFromInspectionRoutes.Count > 0)
                {
                    toAdd.TimeLines.AddRange(timelineFromInspectionRoutes);
                }
                result.Data.Add(toAdd);
            }

            var sqlRTurnover    = new TurnoversRepoisitory(_logger);
            var sqlRDirection   = new DirectionsRepository(_logger);
            var sqlRDayOfRoutes = new DayOfRoutesRepoisitory(_logger);

            var turnover = await sqlRTurnover.ById(turnoverId);

            result.TurnoverName = turnover.Name;
            var direction = await sqlRDirection.ById(turnover.DirectionId);

            result.DirectionName = direction?.Name;

            var turnoversDays = await sqlRDayOfRoutes.DaysByTurnoverId(turnoverId);

            result.Days = turnoversDays.Select(x => x.Day).ToList();

            return(result);
        }
        public async Task <DictionaryCrudResponse> DirectionCrud(DictionaryCrudRequest input)
        {
            var data = input.Direction;

            if (data == null && input.IdToDelete == null)
            {
                throw new ValidationException("Не распарсилось");
            }

            var sqlR = new DirectionsRepository(_logger);

            if (input?.IdToDelete != null)
            {
                await sqlR.Delete((int)input.IdToDelete);

                return(new DictionaryCrudResponse {
                    IsDeleted = true, Direction = data
                });
            }

            var all = await sqlR.GetAll();

            if (all.Any(x => x.Name.Equals(input.Direction.Name)))
            {
                throw new ValidationException(Error.AlreadyAddWithThisName);
            }

            if (data?.Id == 0)
            {
                var item = await sqlR.Add(data);

                return(new DictionaryCrudResponse {
                    IsAdd = true, Direction = item
                });
            }
            else
            {
                var item = await sqlR.Update(data);

                return(new DictionaryCrudResponse {
                    IsUpdated = true, Direction = item
                });
            }
        }
Beispiel #5
0
        public async Task <string> CreateRecipeToDatabase(string name, int prepareTime, string description, string ingridientName, string ingridientAmount, string ingridientUnit, string imgUrl, Prj4databaseContext context)
        {
            RecipeQuery recipeQuery = new RecipeQuery
            {
                SearchRecipe = name
            };
            var queryResult = await recipeQuery.Execute(context);

            if (queryResult.Any())
            {
                return("Opskrift findes allerede");
            }
            Recipe recipe = new Recipe
            {
                Name     = name,
                CookTime = prepareTime,
                ImgSrc   = imgUrl,
                Servings = 4
            };

            RecipeRepository recipeRepository = new RecipeRepository(context);

            recipeRepository.Insert(recipe);
            recipeRepository.Save();

            string[] descriptionData = description.Split(';', StringSplitOptions.RemoveEmptyEntries);
            int      sizeDescription = descriptionData.Length;
            var      directions      = new Directions[sizeDescription];

            for (int i = 0; i < sizeDescription; i++)
            {
                directions[i] = new Directions {
                    Description = descriptionData[i], RecipeId = recipe.RecipeId
                };
            }

            DirectionsRepository directionsRepository = new DirectionsRepository(context);

            foreach (var direc in directions)
            {
                directionsRepository.Insert(direc);
            }
            directionsRepository.Save();
            var ingredientLists = new IngredientList
            {
                RecipeId = recipe.RecipeId,
            };
            IngredientListRepository ingredientListRepository = new IngredientListRepository(context);

            ingredientListRepository.Insert(ingredientLists);
            ingredientListRepository.Save();
            string[] nameSplit      = ingridientName.Split(';', StringSplitOptions.RemoveEmptyEntries);
            string[] amountSplit    = ingridientAmount.Split(';', StringSplitOptions.RemoveEmptyEntries);
            string[] unitSplit      = ingridientUnit.Split(';', StringSplitOptions.RemoveEmptyEntries);
            int      sizeIngridient = nameSplit.Length;
            var      ingridients    = new Ingredient[sizeIngridient];
            var      produkt        = await context.Set <Product>().Where(p => p.Name.Contains("a")).Take(1).ToListAsync();


            for (int i = 0; i < sizeIngridient; i++)
            {
                double.TryParse(amountSplit[i], out var amountDouble);
                ingridients[i] = new Ingredient
                {
                    Name             = nameSplit[i],
                    Amount           = amountDouble,
                    AmountUnit       = unitSplit[i],
                    ProductId        = produkt[0].ProductId,
                    IngredientListId = ingredientLists.IngredientListId
                };
            }
            IngredientRepository ingredientRepository = new IngredientRepository(context);

            foreach (var ingridient in ingridients)
            {
                ingredientRepository.Insert(ingridient);
            }
            ingredientRepository.Save();

            return(HtmlToRecipe(name, prepareTime, description, ingridientName, ingridientAmount, ingridientUnit, imgUrl));
        }