Example #1
0
        public ActionResult CreateCity(CityViewModel city)
        {
            var ncity = new CityRequest()
            {
                Description = city.Description,
                ProvinceId  = city.ProvinceId
            };

            try
            {
                var result = false;
                if (city.Id == 0)
                {
                    result = this.CityService.CreateCity(ncity);
                }

                if (result)
                {
                    return(Redirect("/System/Index"));
                }
                else
                {
                    return(View("../Shared/Error"));
                }
            }
            catch (Exception ex)
            {
                return(View("../Shared/Error"));
            }
        }
Example #2
0
        public IActionResult Create(CityViewModel model, IFormFile file)
        {
            try
            {
                if (file != null && file.Length > 0)
                {
                    var img     = Image.FromStream(file.OpenReadStream());
                    var uploads = Path.Combine(_env.WebRootPath, "images\\Cities");

                    var fileName = Guid.NewGuid() + Path.GetExtension(file.FileName);
                    var filePath = Path.Combine(uploads, fileName);
                    img.Save(filePath);
                    model.City.Logo = fileName;
                }
                else
                {
                    model.City.Logo = "333493fe-9c81-489f-bce3-5d1ba35a8c36.jpg";
                }
                if (ModelState.IsValid)
                {
                    _repoWrapper.City.Create(model.City);
                    _repoWrapper.Save();

                    return(RedirectToAction("CityProfile", "City", new { cityid = model.City.ID }));
                }
                else
                {
                    return(View("Create", model));
                }
            }
            catch (Exception e)
            {
                return(RedirectToAction("HandleError", "Error", new { code = 505 }));
            }
        }
Example #3
0
        public ActionResult Create(CityViewModel model)
        {
            ViewBag.StateId = new SelectList(this.stateService.GetStates(), "Id", "StateName");
            try
            {
                // TODO: Add insert logic here
                if (ModelState.IsValid)
                {
                    var city = AutoMapper.Mapper.Map <City>(model);
                    city.CreatedOn = DateTime.UtcNow;
                    city.UpdatedOn = DateTime.Now;

                    var isSave = cityservice.SaveCity(city);
                    if (isSave > 0)
                    {
                        return(RedirectToAction("Index"));
                    }
                }

                return(View(model));
            }
            catch
            {
                return(View(model));
            }
        }
Example #4
0
        public IActionResult Add([FromBody] CityViewModel cvm)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            try
            {
                // create a new city with the client-sent json data
                var city = new City
                {
                    Name = cvm.Name
                };

                _citiesService.InsertCity(city);

                // return the newly-created company to the client.
                return(new JsonResult(Mapper.Map <City, CityViewModel>(city), DefaultJsonSettings));
            }
            catch (Exception)
            {
                // return the error.
                return(BadRequest(new { Error = "Check that all the fields are valid." }));
            }
        }
        private static void OnCurrentCityPropertyChanged(DependencyObject source, DependencyPropertyChangedEventArgs e)
        {
            CityPopup     popup = source as CityPopup;
            CityViewModel city  = (CityViewModel)e.NewValue;

            popup.txtCity.Text = city != null ? city.ZipCode + " (" + city.Name + ")" : "";
        }
        public async Task <IActionResult> AddCity(CityViewModel model)
        {
            if (this.ModelState.IsValid)
            {
                try
                {
                    await _countryRepository.AddCityAsync(model);

                    return(this.RedirectToAction($"Details/{model.CountryId}"));
                }
                catch (DbUpdateException dbUpdateException)
                {
                    if (dbUpdateException.InnerException.Message.Contains("duplicate"))
                    {
                        ModelState.AddModelError(string.Empty, "There are a record with the same name.");
                    }
                    else
                    {
                        ModelState.AddModelError(string.Empty, dbUpdateException.InnerException.Message);
                    }
                }
                catch (Exception exception)
                {
                    ModelState.AddModelError(string.Empty, exception.Message);
                }
            }

            return(this.View(model));
        }
Example #7
0
        public CityViewModel All()
        {
            CityViewModel vm = new CityViewModel();

            vm.CityList = _cityRepo.Read();
            return(vm);
        }
Example #8
0
        public List <AddressViewModel> GenerateValidAddressViewModel(int quantity, List <CityViewModel> citiesViewModel)
        {
            var city    = new CityViewModel();
            var address = GenerateAddress(quantity);

            var addressesViewModel = new List <AddressViewModel>();

            if (citiesViewModel != null)
            {
                city = TestTools.GetRandomEntityInList <CityViewModel>(citiesViewModel);
            }

            addressesViewModel.AddRange(address.Select(a => new AddressViewModel
            {
                Id         = a.Id,
                Street     = a.Street,
                Number     = a.Number,
                Complement = a.Complement,
                ZipCode    = a.ZipCode,
                District   = a.District,
                CityId     = city.Id,
                CityName   = city.Name
            }));

            return(addressesViewModel);
        }
Example #9
0
        public async Task <IActionResult> Remove(CityViewModel cityViewModel)
        {
            if (!this.ModelState.IsValid)
            {
                return(View());
            }

            var city = await this.cityService.GetCity(cityViewModel.Name);

            if (city == null)
            {
                this.TempData["Error-Message"] = $"City with name {cityViewModel.Name} doesn't exist!";
                return(this.RedirectToAction("Remove", "City"));
            }

            try
            {
                await this.cityService.DeleteCity(cityViewModel.Name);
            }
            catch (EntityDoesntExistException e)
            {
                this.TempData["Error-Message"] = e.Message;
                return(this.RedirectToAction("Remove", "City"));
            }

            this.TempData["Success-Message"] = $"You successfully deleted city with name {cityViewModel.Name}!";

            return(this.RedirectToAction("Remove", "City"));
        }
Example #10
0
        public IHttpActionResult PostNewEmployee(CityViewModel city)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest("Invalid data."));
            }

            using (var ctx = new BikeShopEntities())
            {
                ctx.CITies.Add(new CITY()
                {
                    CITYID         = city.CityID,
                    ZIPCODE        = city.ZipCode,
                    CITY1          = city.CityName,
                    STATE          = city.State,
                    AREACODE       = city.AreaCode,
                    POPULATION1990 = city.Population1990,
                    POPULATION1980 = city.Population1980,
                    COUNTRY        = city.Country,
                    LATITUDE       = city.Latitude,
                    LONGITUDE      = city.Longitude,
                    POPULATIONCDF  = city.PopulationCDF
                });

                ctx.SaveChanges();
            }
            return(Ok());
        }
Example #11
0
        public ActionResult City(CityViewModel city)
        {
            var serializer = new System.Web.Script.Serialization.JavaScriptSerializer();
            var model      = new CityViewModel
            {
                HeaderText         = BackendService.GetValueByTag("site_header_text"),
                FooterAddress      = BackendService.GetValueByTag("official_address"),
                FooterRequisites   = BackendService.GetValueByTag("official_requisites"),
                MainTitle          = BackendService.GetValueByTag("not_official_name"),
                FooterEmail        = BackendService.GetValueByTag("main_email"),
                FooterPhones       = BackendService.GetValueByTag("main_phones"),
                DeliveryNetVersion = BackendService.GetValueByTag("current_server_version"),
                CabinetLink        = BackendService.GetValueByTag("current_admin_app_address"),
                Slogan             = BackendService.GetValueByTag("slogan_title"),
                FooterBody         = BackendService.GetValueByTag("footer_body"),
                Skype          = BackendService.GetValueByTag("main_skype"),
                PageInfo       = PageService.GetByName("city"),
                City           = CityService.GetMain(),
                CityCompanions = CityService.GetCompanions(),
                Id             = city.Id,
                RegionId       = city.RegionId,
                Value          = city.Value,
                Days           = city.Days
            };

            return(View(model));
        }
Example #12
0
        public IHttpActionResult GetEmployee(int id)
        {
            CityViewModel city = null;

            using (var ctx = new BikeShopEntities())
            {
                city = ctx.CITies
                       .Where(c => c.CITYID == id)
                       .Select(c => new CityViewModel()
                {
                    CityID         = c.CITYID,
                    ZipCode        = c.ZIPCODE,
                    CityName       = c.CITY1,
                    State          = c.STATE,
                    AreaCode       = c.AREACODE,
                    Population1990 = c.POPULATION1990,
                    Population1980 = c.POPULATION1980,
                    Country        = c.COUNTRY,
                    Latitude       = c.LATITUDE,
                    Longitude      = c.LONGITUDE,
                    PopulationCDF  = c.POPULATIONCDF
                }).FirstOrDefault <CityViewModel>();
            }
            if (city == null)
            {
                return(NotFound());
            }
            return(Ok(city));
        }
Example #13
0
        public async Task <IActionResult> Add(CityViewModel cityViewModel)
        {
            if (!this.ModelState.IsValid)
            {
                return(View());
            }

            var city = await this.cityService.GetCity(cityViewModel.Name);

            if (city != null)
            {
                this.TempData["Error-Message"] = $"City with name {cityViewModel.Name} already exists!";
                return(this.RedirectToAction("Add", "City"));
            }
            try
            {
                await this.cityService.AddCity(cityViewModel.Name);
            }
            catch (InvalidClientInputException e)
            {
                this.TempData["Error-Message"] = e.Message;
                return(this.RedirectToAction("Add", "City"));
            }
            catch (EntityAlreadyExistsException e)
            {
                this.TempData["Error-Message"] = e.Message;
                return(this.RedirectToAction("Add", "City"));
            }

            this.TempData["Success-Message"] = $"You successfully added city with name {cityViewModel.Name}!";

            return(this.RedirectToAction("Add", "City"));
        }
        public static City ConvertToCity(this CityViewModel cityViewModel)
        {
            City city = new City()
            {
                Id         = cityViewModel.Id,
                Identifier = cityViewModel.Identifier,

                Code    = cityViewModel.Code,
                ZipCode = cityViewModel.ZipCode ?? "",
                Name    = cityViewModel.Name,

                CountryId      = cityViewModel.Country?.Id ?? null,
                RegionId       = cityViewModel.Region?.Id ?? null,
                MunicipalityId = cityViewModel.Municipality?.Id ?? null,

                Active = cityViewModel.IsActive,

                CreatedById = cityViewModel.CreatedBy?.Id ?? null,
                CompanyId   = cityViewModel.Company?.Id ?? null,

                CreatedAt = cityViewModel.CreatedAt,
                UpdatedAt = cityViewModel.UpdatedAt
            };

            return(city);
        }
        public void RemoveTest()
        {
            CityViewModel cityViewModel = new CityViewModel();

            cityViewModel.Cities.Add(new City("NewYork"));
            cityViewModel.Cities.Add(new City("Saratov"));

            bool isTwoCity = cityViewModel.Cities.Count() == 2;

            cityViewModel.SelectedItem = cityViewModel.Cities.FirstOrDefault(c => string.Equals(c.Name, "NewYork"));

            if (cityViewModel.SelectedItem != null)
            {
                cityViewModel.Remove(cityViewModel.SelectedItem);
            }

            bool isNoNewYork = cityViewModel.Cities.FirstOrDefault(c => string.Equals(c.Name, "NewYork")) == null;

            bool isOneCity = cityViewModel.Cities.Count() == 1;

            cityViewModel.SelectedItem = null;
            City.AllCities.Clear();

            Assert.IsTrue(isTwoCity && isNoNewYork && isOneCity);
        }
Example #16
0
        // GET : City/New
        public ActionResult New()
        {
            var cityViewModel = new CityViewModel();

            ViewBag.Title = _cityServices.CheckIsExistingCity(cityViewModel.Id);
            return(View("CityForm", cityViewModel));
        }
Example #17
0
        public CityViewModel All()
        {
            CityViewModel cityViewModel = new CityViewModel();

            cityViewModel.Cities = _cityRepo.Read();
            return(cityViewModel);
        }
Example #18
0
        public ActionResult Index()
        {
            var city = this.cityService.GetCityByName(DefaultCity);

            var model = new CityViewModel()
            {
                Title  = IndexTitle,
                Center = new LocationViewModel()
                {
                    lat = city.Center.Lat,
                    lng = city.Center.Lng
                },
                ZoomLevel = city.ZoomLevel ?? DefaultZoomLevel,
            };

            var locations = city
                            .Locations.Select(location => new LocationViewModel()
            {
                lat = location.Lat,
                lng = location.Lng
            })
                            .ToList();

            model.Stations = locations;

            return(this.View(model));
        }
Example #19
0
 public static HomeViewModel MapHomeToHomeViewModel(Home home)
 {
     return(new HomeViewModel
     {
         Id = home.Id,
         UserId = home.UserId,
         CityId = home.CityId,
         TotalStairCount = home.TotalStairCount,
         Stair = home.Stair,
         BuildingType = home.BuildingType,
         RoomCount = home.RoomCount,
         Area = home.Area,
         Credit = home.Credit,
         LandArea = home.LandArea,
         Address = home.Address,
         HomeTypeId = home.Id,
         HomeImg = home.HomeImg,
         Price = home.Price,
         EstateDocumentType = home.EstateDocumentType,
         AdverTypeId = home.AdverTypeId,
         AboutHome = home.AboutHome,
         SubmittedByAdmin = home.SubmittedByAdmin,
         City = CityViewModel.MapCityToCityViewModel(home.City),
         // User = UserViewModel.MapUserToUserViewModel(home.User),
         HomeType = HomeTypeViewModel.MapHomeTypeToHomeTypeViewModel(home.HomeType),
         AdverType = AdverTypeViewModel.MapAdverTypeToAdverTypeViewModel(home.AdverType)
                     //  Equipments = home.Equipments.Select(x => EquipmentOfHomeViewModel.MapEquipmentOfHomeToEquipmentOfHomeViewModel(x)).ToList()
     });
 }
        public override void ViewDidLoad()
        {
            base.ViewDidLoad();

            _bindings.Initialize(this);
            _viewModel = ViewModelLocator.Instance.City;
        }
        public void AddCityToDb(CityViewModel cityVm, string countryName)
        {
            var country = this.countryRepository
                          .GetAllFiltered(c => c.Name == countryName)
                          .FirstOrDefault();

            if (country == null)
            {
                throw new ArgumentNullException();
            }

            var cityExists = this.cityRepository
                             .GetAllFiltered(c => c.Name == cityVm.Name && c.CountryId == country.Id)
                             .Any();

            if (cityExists)
            {
                throw new InvalidOperationException();
            }

            var city = new City()
            {
                Name      = cityVm.Name,
                CountryId = country.Id
            };

            this.cityRepository.Add(city);
        }
Example #22
0
        private City ViewModelToCity(CityViewModel model)
        {
            var city = new City
            {
                Id        = model.Id,
                Name      = model.Name,
                Locations = new List <Location>(),
                UpdatedBy = User.Identity.Name,

                // TODO: Ersätt med detta:
                //Locations = (model.Locations ?? new List<LocationViewModel>())
                //    .Where(l => l.Selected)
                //    .Select(l => new Location() {Id = l.Id, Name = l.Name})
                //    .ToList()
            };


            if (model.Locations != null)
            {
                foreach (var locationViewModel in model.Locations)
                {
                    if (locationViewModel.Selected)
                    {
                        city.Locations.Add(new Location()
                        {
                            Id   = locationViewModel.Id,
                            Name = locationViewModel.Name
                        });
                    }
                }
            }

            return(city);
        }
Example #23
0
        public async Task <IActionResult> AddEditCity(int id, CityViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return(View("_AddEditCity", model));
            }

            if (id > 0)
            {
                City city = await _unitOfWork.Repository <City>().GetByIdAsync(id);

                if (city != null)
                {
                    city.Name         = model.Name;
                    city.ModifiedDate = DateTime.Now;
                    city.CountryId    = model.CountryId;
                    await _unitOfWork.Repository <City>().UpdateAsync(city);
                }
            }
            else
            {
                City city = new City()
                {
                    Name         = model.Name,
                    ModifiedDate = DateTime.Now,
                    AddedDate    = DateTime.Now,
                    CountryId    = model.CountryId
                };
                await _unitOfWork.Repository <City>().InsertAsync(city);
            }
            return(RedirectToAction(nameof(CityIndex)));
        }
Example #24
0
 public ActionResult AddUpdateCity(CityViewModel cityViewModel)
 {
     try
     {
         //stateViewModels.Insert(0, stateViewModel);
         var cityResult = new ServiceResponseModel();
         if (cityViewModel.Id < 1)
         {
             cityResult = webServices.Post(cityViewModel, "Country/AddUpdateCity");
         }
         else
         {
             cityResult = webServices.Post(cityViewModel, "Country/AddUpdateCity");
         }
         if (cityResult.StatusCode == System.Net.HttpStatusCode.Accepted)
         {
             var reuslt = (new JavaScriptSerializer().Deserialize <int>(cityResult.Data));
             return(RedirectToAction(nameof(CityAll)));
         }
         return(View(cityResult));
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
Example #25
0
        public async Task <IActionResult> AddCity(CityViewModel ModelDto, int ProvinceId, CancellationToken cancellationToken)
        {
            try
            {
                if (String.IsNullOrEmpty(ModelDto.Name.Trim()))
                {
                    return(new JsonResult(new { confirm = false, message = OperationMessage.ModelStateIsNotValid.ToDisplay() }));
                }
                var ListProvince = _CityService.TableNoTracking.Where(e => e.ProvinceId == ProvinceId).ToList();
                if (ListProvince.Any(e => e.Name.Equals(ModelDto.Name.Trim(), StringComparison.OrdinalIgnoreCase)))
                {
                    return(new JsonResult(new { confirm = false, message = OperationMessage.DoestExist.ToDisplay() }));
                }
                var city = new CreateCityDto
                {
                    Name = ModelDto.Name
                };
                var model = city.ToEntity(_mapper);
                model.ProvinceId = ProvinceId;
                await _CityService.AddAsync(model, cancellationToken);

                string name = "'" + model.Name + "'";
                string Url  = "'DeleteCity'";
                return(new JsonResult(new { confirm = true, message = OperationMessage.OperationSucceed.ToDisplay(),
                                            Id = model.Id, Name = model.Name, Url = Url, NameData = name }));
            }
            catch (Exception ex)
            {
                return(new JsonResult(new { confirm = false, message = OperationMessage.OperationFailed.ToDisplay() }));
            }
        }
        public CityListResponse GetCitiesByPage(CityViewModel citiesearchObject, int currentPage = 1, int itemsPerPage = 50)
        {
            CityListResponse     response = new CityListResponse();
            List <CityViewModel> cities   = new List <CityViewModel>();

            using (SqliteConnection db = new SqliteConnection("Filename=SirmiumERPGFC.db"))
            {
                db.Open();
                try
                {
                    SqliteCommand selectCommand = new SqliteCommand(
                        SqlCommandSelectPart +
                        "FROM Cities " +
                        "ORDER BY IsSynced, Id DESC;", db);

                    selectCommand.Parameters.AddWithValue("@ItemsPerPage", itemsPerPage);
                    //selectCommand.Parameters.AddWithValue("@Offset", (currentPage - 1) * itemsPerPage);

                    SqliteDataReader query = selectCommand.ExecuteReader();

                    while (query.Read())
                    {
                        int           counter = 0;
                        CityViewModel dbEntry = new CityViewModel();
                        dbEntry.Id         = SQLiteHelper.GetInt(query, ref counter);
                        dbEntry.Identifier = SQLiteHelper.GetGuid(query, ref counter);
                        dbEntry.Code       = SQLiteHelper.GetString(query, ref counter);
                        dbEntry.Name       = SQLiteHelper.GetString(query, ref counter);
                        dbEntry.IsSynced   = SQLiteHelper.GetBoolean(query, ref counter);
                        dbEntry.UpdatedAt  = SQLiteHelper.GetDateTime(query, ref counter);
                        dbEntry.CreatedBy  = SQLiteHelper.GetCreatedBy(query, ref counter);
                        cities.Add(dbEntry);
                    }


                    selectCommand = new SqliteCommand(
                        "SELECT Count(*) " +
                        "FROM Cities ", db);

                    query = selectCommand.ExecuteReader();

                    if (query.Read())
                    {
                        response.TotalItems = query.GetInt32(0);
                    }
                }
                catch (SqliteException error)
                {
                    MainWindow.ErrorMessage = error.Message;
                    response.Success        = false;
                    response.Message        = error.Message;
                    response.Cities         = new List <CityViewModel>();
                    return(response);
                }
                db.Close();
            }
            response.Success = true;
            response.Cities  = cities;
            return(response);
        }
Example #27
0
        // GET: Customers
        //public async Task<IActionResult> Index()
        //{
        //return View(await _context.Customer.ToListAsync());
        //}

        public async Task <IActionResult> Index(string customerCity, string searchString)
        {
            // Use LINQ to get list of cities
            IQueryable <string> cityQuery = from m in _context.Customer
                                            orderby m.City
                                            select m.City;

            var customers = from m in _context.Customer
                            select m;

            if (!String.IsNullOrEmpty(searchString))
            {
                customers = customers.Where(s => s.Neighborhood.Contains(searchString));
            }

            if (!String.IsNullOrEmpty(customerCity))
            {
                customers = customers.Where(x => x.City == customerCity);
            }

            var customerCityVM = new CityViewModel();

            customerCityVM.city      = new SelectList(await cityQuery.Distinct().ToListAsync());
            customerCityVM.customers = await customers.ToListAsync();

            return(View(customerCityVM));
        }
Example #28
0
        public ActionResult Create(int?relatedEntityId)
        {
            var cityViewModel = new CityViewModel(Status.Active);

            cityViewModel.CulturedCitySelectList = GetCulturedCityList(relatedEntityId);


            if (relatedEntityId != null)
            {
                var selectedEntity = _culturedBaseService.CulturedEntities.Include(x => x.City)
                                     .FirstOrDefault(x => x.Id == relatedEntityId);

                var config = new MapperConfiguration(cfg =>
                {
                    cfg.CreateMap <City, CityViewModel>()
                    .ForMember(dest => dest.Id, opt => opt.Ignore())
                    .ForMember(dest => dest.BaseEntityId, opt => opt.UseValue(selectedEntity?.City.Id))
                    .ForMember(dest => dest.RelatedEntityId, opt => opt.UseValue(relatedEntityId))
                    .ForMember(dest => dest.Status, opt => opt.Ignore());
                });
                var mapper = config.CreateMapper();

                mapper.Map(selectedEntity?.City, cityViewModel);
                cityViewModel.CulturedCitySelectList = GetCulturedCityList();
                return(View("CreateOrUpdate", cityViewModel));
            }


            return(View("CreateOrUpdate", cityViewModel));
        }
        public IEnumerable <City> GetCity()
        {
            CityViewModel city     = _cityService.All();
            var           cityList = city.cityList;

            return(cityList);
        }
        public ActionResult AddCity(CityViewModel viewModel)
        {
            if (string.IsNullOrWhiteSpace(viewModel.Name))
            {
                ModelState.AddModelError("", "Please enter a valid city name");
                return(View());
            }
            if (ModelState.IsValid)
            {
                UnitOfWork unitOfWork = new UnitOfWork();
                City       cityInput  = new City();
                cityInput.Name = viewModel.Name;
                unitOfWork.CityRepository.Save(cityInput);
                bool isAdded = unitOfWork.Save() > 0;
                if (isAdded)
                {
                    TempData["Message"] = "City added successfully";
                }
                else
                {
                    TempData["Message"] = "Ooops something went wrong";
                }
                return(RedirectToAction("Index", "Home"));
            }

            return(RedirectToAction("AddCity", "Home"));
        }
        public NeTreeViewModel(CityViewModel city, NeLevel level, NeTreeBuilderGroupFlags flag)
            : base()
        {
            NeTreeBuilders = new ObservableCollection<NeTreeBuilderViewModel>();
            RootNodes = new ObservableCollection<NeNodeViewModel>();

            Level = level;
            City = city;
        }
Example #32
0
        public ActionResult CreateCity(CityViewModel model)
        {
            try
            {
                int id = model.Create();
                if (id > 0)
                {
                    return RedirectToAction("cities");
                }
            }
            catch (Exception)
            {
            }

            return View(model);
        }
Example #33
0
 public ActionResult AddCity(CityViewModel model)
 {
     if (this.ModelState.IsValid)
     {
         try
         {
             //model.Country = this.countryService.GetCountry(model.CountryId);
             Mapper.CreateMap<CityViewModel, CityDto>();
             var city = Mapper.Map<CityDto>(model);
             this.cityService.CreateCity(city);
             this.cityService.Commit();
         }
         catch (Exception exception)
         {
             this.ViewData["ErrMsg"] = exception.Message;
             this.ViewData["ErrTrace"] = exception.StackTrace;
             return this.View("Error", new {area =""});
         }
     }
     model = new CityViewModel { Countries = this.GetCountries() };
     return this.View(model);
 }
Example #34
0
        public ResultDto<CityViewModel> GenerateCity(int cityWidth, int cityHeight)
        {
            var result = new ResultDto<CityViewModel>();

            var city = _cityFactory.Create(_carFactory, cityWidth, cityHeight);
            if (city != null)
            {

                var cityDto = Mapper.Map<CityDto>(city);
                var passengerDto = Mapper.Map<PassengerDto>(city.Passenger);
                var carDto = Mapper.Map<CarDto>(city.Car);

                var cityPositionsLength = cityWidth * cityHeight;
                cityDto.CityPositionDtos = new CityPositionDto[cityPositionsLength];
                for (int i = 0; i < cityPositionsLength; i++)
                {
                    cityDto.CityPositionDtos[i] = Mapper.Map<CityPositionDto>(city.CityPositions[i]);
                }

                var carPos = carDto.YPos * cityDto.YMax + carDto.XPos;
                var passengerPos = passengerDto.StartingYPos * cityDto.YMax + passengerDto.StartingXPos;

                cityDto.CityPositionDtos[carPos].CarDto = carDto;
                cityDto.CityPositionDtos[passengerPos].PassengerDto = passengerDto;

                var viewModel = new CityViewModel
                {
                    CityDto = cityDto
                };

                result.Data = viewModel;
                result.IsSuccessful = true;
            }

            return result;
        }
Example #35
0
        public CityViewModel CreateCityViewModel(City city, int cityWidth, int cityHeight)
        {
            var cityDto = Mapper.Map<CityDto>(city);
            var passengerDto = Mapper.Map<PassengerDto>(city.Passenger);
            var carDto = Mapper.Map<CarDto>(city.Car);

            var cityPositionsLength = cityWidth * cityHeight;
            cityDto.CityPositionDtos = new CityPositionDto[cityPositionsLength];
            for (int i = 0; i < cityPositionsLength; i++)
            {
                cityDto.CityPositionDtos[i] = Mapper.Map<CityPositionDto>(city.CityPositions[i]);
            }

            var carPos = carDto.YPos * cityDto.YMax + carDto.XPos;
            var passengerPos = passengerDto.StartingYPos * cityDto.YMax + passengerDto.StartingXPos;

            cityDto.CityPositionDtos[carPos].CarDto = carDto;
            cityDto.CityPositionDtos[passengerPos].PassengerDto = passengerDto;

            var viewModel = new CityViewModel
            {
                CityDto = cityDto
            };

            return viewModel;
        }
Example #36
0
 public ActionResult UpdateCity(int id)
 {
     CityViewModel vmState = new CityViewModel();
     vmState.Read(id);
     return View(vmState);
 }
Example #37
0
        public ActionResult UpdateCity(CityViewModel model)
        {
            try
            {
                bool result = model.Update();
                if (result)
                {
                    return RedirectToAction("cities");
                }
            }
            catch (Exception)
            {
            }

            return View(model);
        }
Example #38
0
 public ActionResult CreateCity()
 {
     CityViewModel vmCity = new CityViewModel();
     return View(vmCity);
 }
		/// <summary>
		/// Transforms the current inputs into a city model and adds it to the list.
		/// </summary>
		void AddCity()
		{
			// Check inputs
			if (!CheckInputs())
			{
				ShowInputError();
				return;
			}

			// Create city from inputs
			var city = new CityViewModel (((EditText)FindViewById (Resource.Id.addEditCityZip)).Text, ((EditText)FindViewById (Resource.Id.addEditCityName)).Text, null, 0, 0);

			// Add city to list
			DataHolder.Current.CurrentCity = city;
			DataHolder.Current.CityList.Add(city);
			DataHolder.Current.SaveCityList(this);

			// Finish activity
			Finish();
		}
 public void ChangeCity(CityViewModel city)
 {
     City = city;
 }
Example #41
0
 public ActionResult AddCity()
 {
     var model = new CityViewModel { Countries = this.GetCountries() };
     return this.View(model);
 }
Example #42
0
        public ResultDto<CityViewModel> Tick(CityViewModel cityViewModel)
        {
            var result = new ResultDto<CityViewModel>();
            if (cityViewModel != null)
            {
                var city = _cityFactory.Create(_carFactory, cityViewModel.CityDto.XMax, cityViewModel.CityDto.YMax);
                var destinationPos = city.CityPositions.First(c => c.IsDestinationPosition);
                destinationPos.IsDestinationPosition = false;

                var carDto = cityViewModel.CityDto.CityPositionDtos.First(c => c.CarDto != null).CarDto;
                var passengerDto = cityViewModel.CityDto.CityPositionDtos.First(c => c.PassengerDto != null).PassengerDto;

                var car = city.AddCarToCity(carDto.CarType, carDto.XPos, carDto.YPos);
                var passenger = city.AddPassengerToCity(passengerDto.StartingXPos, passengerDto.StartingYPos, passengerDto.DestinationXPos, passengerDto.DestinationYPos);

                if (car.XPos == passenger.StartingXPos
                    && car.YPos == passenger.StartingYPos)
                {
                    car.PickupPassenger(passenger);
                }

                var hasCarMoved = false;

                DirectionToMove directionToMove = GetDirectionToMove(car, passenger);

                switch (directionToMove)
                {
                    case DirectionToMove.DoNothing:
                        break;
                    case DirectionToMove.Left:
                        car.MoveLeft(passenger);
                        hasCarMoved = true;
                        break;
                    case DirectionToMove.Right:
                        car.MoveRight(passenger);
                        hasCarMoved = true;
                        break;
                    case DirectionToMove.Up:
                        car.MoveUp(passenger);
                        hasCarMoved = true;
                        break;
                    case DirectionToMove.Down:
                        car.MoveDown(passenger);
                        hasCarMoved = true;
                        break;
                    case DirectionToMove.Arrived:
                        if (!car.HasPassenger)
                        {
                            passenger.GetInCar(car);
                        }
                        else
                        {
                            passenger.GetOutOfCar();
                        }
                        break;
                    default:
                        throw new ArgumentOutOfRangeException();
                }

                if (hasCarMoved)
                {
                    Task.Run(() => Get2PointBWebsiteInBytesAsync());
                }

                var newViewModel = CreateCityViewModel(city, cityViewModel.CityDto.XMax, cityViewModel.CityDto.YMax);
                result.Data = newViewModel;
                result.IsSuccessful = true;
            }

            return result;
        }