public async Task <ActionResult <CarMake> > PostCarMake(CarMake carMake)
{
_context.carmake.Add(carMake);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetCarMake", new { id = carMake.MakeId }, carMake));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Country,Name")] CarMake carMake)
{
if (id != carMake.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(carMake);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CarMakeExists(carMake.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(carMake));
}
public int ManageCarMake(CarMake carMakeObj)
{
if (carMakeObj != null)
{
var existingCarMake = _context.CarMakes
.Where(x => x.MakeName.ToLower().Equals(carMakeObj.MakeName.ToLower()))
.FirstOrDefault();
if (existingCarMake != null)
{
existingCarMake.MakeName = carMakeObj.MakeName;
_context.SaveChanges();
return(existingCarMake.Id);
}
else
{
_context.CarMakes.Add(carMakeObj);
_context.SaveChanges();
return(carMakeObj.Id);
}
}
else
{
return(0);
}
}
public async Task <IActionResult> PutCarMake(string id, CarMake carMake)
{
if (id != carMake.MakeId)
{
return(BadRequest());
}
_context.Entry(carMake).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CarMakeExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public ActionResult Makes(CarMake carMake)
{
if (string.IsNullOrEmpty(carMake.MakeName))
{
ModelState.AddModelError("error", "Please enter a new make");
}
var repo = AdminFactory.GetRepo();
if (ModelState.IsValid)
{
try
{
carMake.User = User.Identity.Name;
carMake.MakeName = carMake.MakeName.Substring(0, 1).ToUpper() + carMake.MakeName.Substring(1);
repo.AddMake(carMake);
}
catch (Exception ex)
{
throw ex;
}
var model = repo.GetCarMakesWUsers();
return(View("Makes", model));
}
else
{
var model = repo.GetCarMakesWUsers();
return(View(model));
}
}
private Dictionary <CarMake, List <string> > GetCarMakeAndModelsByCarMake(CarMake make)
{
Dictionary <CarMake, List <string> > result = new Dictionary <CarMake, List <string> >();
switch (make)
{
case CarMake.Alfa:
result.Add(this.CarMake, new List <string>()
{
"157", "Mito", "Julieta"
});
break;
case CarMake.Audi:
result.Add(this.CarMake, new List <string>()
{
"A3", "A4", "A5"
});
break;
case CarMake.BWM:
result.Add(this.CarMake, new List <string>()
{
"318", "320", "520"
});
break;
case CarMake.Benz:
result.Add(this.CarMake, new List <string>()
{
"A class", "B class", "C class", "S500"
});
break;
case CarMake.Citroen:
result.Add(this.CarMake, new List <string>()
{
"C1", "C2", "Cactus"
});
break;
case CarMake.Dacia:
result.Add(this.CarMake, new List <string>()
{
"Sandero", "Duster"
});
break;
case CarMake.Fiat:
result.Add(this.CarMake, new List <string>()
{
"Punto", "Grande punto"
});
break;
default:
break;
}
return(result);
}
public IEnumerable <CarMake> GetAll()
{
List <CarMake> makes = new List <CarMake>();
using (var cn = new SqlConnection(Settings.GetConnectionString()))
{
SqlCommand cmd = new SqlCommand("CarMakesSelectAll", cn);
cmd.CommandType = CommandType.StoredProcedure;
cn.Open();
using (SqlDataReader dr = cmd.ExecuteReader())
{
while (dr.Read())
{
CarMake currentRow = new CarMake();
currentRow.MakeId = (short)dr["MakeId"];
currentRow.Name = dr["Name"].ToString();
makes.Add(currentRow);
}
}
}
return(makes);
}
public CarMake GetById(short makeId)
{
CarMake make = null;
using (var cn = new SqlConnection(Settings.GetConnectionString()))
{
SqlCommand cmd = new SqlCommand("CarMakesSelectById", cn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@MakeId", makeId);
cn.Open();
using (SqlDataReader dr = cmd.ExecuteReader())
{
if (dr.Read())
{
make = new CarMake();
make.MakeId = (short)dr["MakeId"];
make.Name = dr["Name"].ToString();
}
}
}
return(make);
}
public IActionResult Create(CarMake makeInfo)
{
if (ModelState.IsValid)
{
var carMakeExists = db.CarMakes.Any(c => c.Name == makeInfo.Name);
if (carMakeExists)
{
ModelState.AddModelError(string.Empty, "This car make already exists!");
return(View(makeInfo));
}
var make = this.makeFactory.CreateVehicle(makeInfo);
//var carMake = new CarMake()
//{
// Name = make.Name,
// Country = make.Country,
//
//};
db.CarMakes.Add((CarMake)make);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(makeInfo));
}
public List <CarMake> GetMakes()
{
List <CarMake> makes = new List <CarMake>();
using (var cn = new SqlConnection(Settings.GetConnectionString()))
{
SqlCommand cmd = new SqlCommand("CarSelectMakes", cn);
cmd.CommandType = CommandType.StoredProcedure;
cn.Open();
using (SqlDataReader dr = cmd.ExecuteReader())
{
while (dr.Read())
{
CarMake currentRow = new CarMake();
currentRow.CarMakeId = (int)dr["CarMakeId"];
currentRow.CarMakeName = dr["Make"].ToString();
currentRow.DateCreated = (DateTime)dr["Date Added"];
makes.Add(currentRow);
}
}
}
return(makes);
}
public IHttpActionResult PutCarMake(int id, CarMake carMake)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
if (id != carMake.ID)
{
return BadRequest();
}
db.Entry(carMake).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!CarMakeExists(id))
{
return NotFound();
}
else
{
throw;
}
}
return StatusCode(HttpStatusCode.NoContent);
}
public async Task <bool> AddCar(CarAnnounceModel announce)
{
try
{
CarMake carMake = await _dbContext.CarMakes.FindAsync(announce.CarMakeId);
CarModel carModel = await _dbContext.CarModels.FindAsync(announce.CarModelId);
DateTime addedDate = DateTime.Now;
Car unicodeCar = await _dbContext.Cars.FindAsync(_dbContext.Cars.Max(c => c.Id));
string unicode = (Int32.Parse(unicodeCar.AnnounceUniqueCode) + 1).ToString();
Car car = new Car(carMake, carModel, announce.CarYear)
{
AnnounceAddedDate = addedDate,
AnnounceTypeId = announce.AnnounceTypeId,
Price = announce.Price,
CityId = announce.CityId,
Description = announce.Description,
PersonTypeId = announce.PersonTypeId,
Email = announce.Email,
PhoneNumber = announce.PhoneNumber,
CarBodyTypeId = announce.CarBodyTypeId,
CarKilometer = announce.CarKilometer,
CarMotor = announce.CarMotor,
CarMotorStrength = announce.CarMotorStrength,
Color = announce.Color,
Condition = announce.CarCondition,
AnnounceUniqueCode = unicode,
TransmissionId = announce.TransmissionId,
SpeedBoxId = announce.SpeedBoxId,
FuelTypeId = announce.FuelTypeId,
};
await _dbContext.Cars.AddAsync(car);
foreach (var autoEquipmentId in announce.AutoEquipmentId)
{
CarAutoEquipment carAutoEquipment = new CarAutoEquipment
{
CarId = car.Id,
AutoEquipmentId = autoEquipmentId,
};
await _dbContext.CarAutoEquipments.AddAsync(carAutoEquipment);
}
//car files upload start
AddDataPhoto(announce.Paths, car.Id, "lib/images/transport/car", FindTable.Car);
//car files upload end
await _dbContext.SaveChangesAsync();
}
catch (Exception exp)
{
throw exp;
}
return(true);
}
public IHttpActionResult Post(CarMake make)
{
_context.CarMakes.Add(make);
_context.SaveChanges();
return(CreatedAtRoute("DefaultApi", new { id = make.Id }, make));
}
public List <Models.Tables.CarMake> GetCarMakesWUsers()
{
List <Models.Tables.CarMake> list = new List <Models.Tables.CarMake>();
var makeView = new Models.Tables.CarMake();
using (_ctx = new GuildCarsEntities())
{
var carMakes = _ctx.GetCarMake();
foreach (var make in carMakes)
{
CarMake carMake = new CarMake();
carMake.CarMakeId = make.CarMakeId;
carMake.MakeName = make.MakeName;
carMake.User = make.User;
carMake.DateAdded = make.DateAdded;
makeView = MakeView.Make(carMake);
list.Add(makeView);
}
}
return(list);
}
public ActionResult DeleteConfirmed(int id)
{
CarMake carMake = db.CarMakes.Find(id);
db.CarMakes.Remove(carMake);
db.SaveChanges();
return(RedirectToAction("Index"));
}
protected override ICommandResult ExecuteAction(CreateCarMakeModel item)
{
CarMake carMake = this.mapping.Map <CarMake>(item);
CarMake result = this.service.Save(carMake);
return(this.Success(result));
}
public void CreateMake(CarMake newMake)
{
newMake.DateAdded = DateTime.Now;
newMake.User = dealerDb.Users.SingleOrDefault(m => m.Id == newMake.User.Id);
dealerDb.CarMake.Add(newMake);
dealerDb.SaveChanges();
}
public async Task <ActionResult> DeleteConfirmed(string id)
{
CarMake carMake = await db.CarMakes.FindAsync(id);
db.CarMakes.Remove(carMake);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public ActionResult Edit(CarMake carmake)
{
if (ModelState.IsValid)
{
db.Entry(carmake).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(carmake));
}
public IMotorVehicleMake CreateVehicle(IMotorVehicleMake makeInfo)
{
var carMake = new CarMake()
{
Name = makeInfo.Name,
Country = makeInfo.Country
};
return(carMake);
}
public IHttpActionResult GetCarMake(int id)
{
CarMake carMake = db.CarMakes.Find(id);
if (carMake == null)
{
return NotFound();
}
return Ok(carMake);
}
public IActionResult Delete(CarMake make)
{
var makeToDelete = db.CarMakes.FirstOrDefault(cm => cm.Id == make.Id);
db.CarMakes.Remove(makeToDelete);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void DeleteCarMake(int id)
{
CarMake carMakeObj = _context.CarMakes.Find(id);
if (carMakeObj != null)
{
_context.CarMakes.Remove(carMakeObj);
_context.SaveChanges();
}
}
private async Task CreateCarMakeAsync(CarMake carMake)
{
var existingCarMake = _ctx.CarMakes.FirstOrDefault(cm => cm.Name == carMake.Name);
if (existingCarMake == null)
{
_ctx.CarMakes.Add(carMake);
await _ctx.SaveChangesAsync();
}
}
public Car(int kmPassed, CarMake make, DateTime dateOfProduction, bool isRegistered, FuelType fuelType)
{
Id = _id++;
KilometersPassed = kmPassed;
CarMake = make;
YearOfProduction = dateOfProduction;
IsRegistered = isRegistered;
FuelType = fuelType;
CarMakeWithModels = GetCarMakeAndModelsByCarMake(make);
}
//
// GET: /CarMake/Delete/5
public ActionResult Delete(int id = 0)
{
CarMake carmake = db.CarMakes.Find(id);
if (carmake == null)
{
return(HttpNotFound());
}
return(View(carmake));
}
public ActionResult Edit([Bind(Include = "CarMakeID,Description")] CarMake carMake)
{
if (ModelState.IsValid)
{
db.Entry(carMake).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(carMake));
}
public async Task <ActionResult> Edit([Bind(Include = "MakeId,MkDesc")] CarMake carMake)
{
if (ModelState.IsValid)
{
db.Entry(carMake).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(carMake));
}
public async Task <IActionResult> Create([Bind("Id,Country,Name")] CarMake carMake)
{
if (ModelState.IsValid)
{
_context.Add(carMake);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(carMake));
}
public ActionResult Create([Bind(Include = "CarMakeID,Description")] CarMake carMake)
{
if (ModelState.IsValid)
{
db.CarMakes.Add(carMake);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(carMake));
}
public void DisplayCarMake(CarMake car)
{
MessageBox.Show(car.ToString(), "This car is a:");
}
