public async Task <IActionResult> Create([Bind("ProgramName")] ProgramCreateModel programCreateModel)
        {
            if (ModelState.IsValid)
            {
                var result = ProgramMappings.ToProgramEntity(programCreateModel);
                var beforeCreatedProgam = _repository.Query <Core.Library.Entities.Program>().FirstOrDefault(x => x.Name == result.Name);
                if (beforeCreatedProgam != null)
                {
                    _logger.LogWarning($"User {_user} tried to create existing program {result.Name}");
                    TempData["ErrorMessage"] = "Ši programa jau yra sukurta";
                    return(RedirectToAction(nameof(Create)));
                }
                await _repository.InsertAsync <Core.Library.Entities.Program>(result);

                _logger.LogInformation($"User {_user} created program {result.Name}");
                return(RedirectToAction(nameof(Index)));
            }
            _logger.LogError($"Error with ModelState validation. User {_user} ");
            return(View(programCreateModel));
        }
        public async Task <IActionResult> CreateNewCity([Bind("CityName")] CityCreateModel cityCreateModel)
        {
            if (ModelState.IsValid)
            {
                var result            = ProgramMappings.ToCityEntity(cityCreateModel);
                var beforeCreatedCity = _repository.Query <City>().FirstOrDefault(x => x.Name == result.Name);
                if (beforeCreatedCity != null)
                {
                    _logger.LogWarning($"User {_user} tried to create existing city {result.Name}");
                    TempData["ErrorMessage"] = "Šis miestas jau yra sukurtas";
                    return(RedirectToAction(nameof(CreateNewCity)));
                }
                await _repository.InsertAsync <City>(result);

                _logger.LogInformation($"User {_user} created city {result.Name}");
                return(RedirectToAction(nameof(Index)));
            }
            _logger.LogError($"Error with ModelState validation. User {_user} ");
            return(View(cityCreateModel));
        }
        public async Task <IActionResult> Index()
        {
            ProgramViewModel programViewModel = new ProgramViewModel();

            var programResult = await _repository.Query <Core.Library.Entities.Program>().ToListAsync();

            List <ProgramCreateModel> programsList = new List <ProgramCreateModel>();

            programResult.ForEach(program => programsList.Add(ProgramMappings.ToProgramListViewModel(program)));
            programViewModel.ProgramNames = programsList;

            var cities = await _repository.Query <City>().ToListAsync();

            List <CityCreateModel> citiesList = new List <CityCreateModel>();

            cities.ForEach(city => citiesList.Add(ProgramMappings.ToCityListViewModel(city)));
            programViewModel.CityNames = citiesList;

            _logger.LogInformation($"{programsList.Count()} programs and {citiesList.Count()} cities exist in view. User {_user}");
            return(View(programViewModel));
        }