//GET
public ActionResult AddImage(int?id)
{
try
{
var vehicle = db.Vehicles.FirstOrDefault(x => x.Id == id);
if (vehicle != null)
{
string make = vehicle.Make;
string vModel = vehicle.Model;
string year = vehicle.Year.ToString();
string item = year + " " + make + " " + vModel;
ViewBag.stringDescription = item;
}
VehicleImage image = new VehicleImage();
return(View(image));
}
catch (Exception ex)
{
var errorService = new ErrorService(db);
errorService.logError(ex);
throw (ex);
}
}
public ActionResult Create([Bind(Include = "VehicleId,Model,Registraion,EngineCapacity," +
"Price,SteerTypeId,MileAges,GearTypeId,FuelTypeId,ColorOfVehicleId,VehicleTypeId")]
Vehicle vehicle, IEnumerable <HttpPostedFileBase> httpPostedFileBases)
{
IEnumerable <HttpPostedFileBase> httpPostedFile = httpPostedFileBases;
if (ModelState.IsValid)
{
db.Vehicles.Add(vehicle);
db.SaveChanges();
if (httpPostedFile != null)
{
foreach (var afile in httpPostedFile)
{
VehicleImage aVehicleImage = new VehicleImage();
Stream stream = afile.InputStream;
BinaryReader brd = new BinaryReader(stream);
byte[] bytes = brd.ReadBytes((int)stream.Length);
aVehicleImage.VehicleId = vehicle.VehicleId;
aVehicleImage.VehicleImages = bytes;
db.VehicleImages.Add(aVehicleImage);
db.SaveChanges();
}
}
return(RedirectToAction("Index"));
}
ViewBag.ColorOfVehicleId = new SelectList(db.ColorOfVehilces, "ColorOfVehicleId", "ColorOfVehicleName", vehicle.ColorOfVehicleId);
ViewBag.FuelTypeId = new SelectList(db.FuelTypes, "FuelTypeId", "FuelTypeName", vehicle.FuelTypeId);
ViewBag.GearTypeId = new SelectList(db.GearTypes, "GearTypeId", "GearTypeName", vehicle.GearTypeId);
ViewBag.SteerTypeId = new SelectList(db.SteerTypes, "SteerTypeId", "SteerTypeName", vehicle.SteerTypeId);
ViewBag.VehicleTypeId = new SelectList(db.TypesOfVehicles, "VehicleTypeId", "VehicleTypeName", vehicle.VehicleTypeId);
return(View(vehicle));
}
public ActionResult AddImage(int id, VehicleImage model, HttpPostedFileBase imageFile)
{
try
{
var db = new AutoScoutDBContext();
//var vehicle = db.Vehicles.FirstOrDefault(x => x.Id == vehicleId);
Vehicle vehicle = db.Vehicles.Find(id);
if (vehicle != null)
{
string make = vehicle.Make;
string vModel = vehicle.Model;
string year = vehicle.Year.ToString();
string item = year + " " + make + " " + vModel;
ViewBag.stringDescription = item;
}
if (imageFile != null)
{
var service = new ImageManagementService(db);
service.AssignImageToVehicle(id, imageFile);
}
return(RedirectToAction("Edit", new { id = id }));;
}
catch (Exception ex)
{
var errorService = new ErrorService(db);
errorService.logError(ex);
throw (ex);
}
}
public IHttpActionResult PutVehicleImage(int id, VehicleImage item)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != item.Id)
{
return(BadRequest());
}
db.VehicleImages.Update(item);
try
{
db.Complete();
}
catch (DbUpdateConcurrencyException)
{
if (!VehicleImageExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <IHttpActionResult> UploadImage(long vehicleId)
{
try
{
var fileName = "MobileUpload-";
var extention = ".png"; // retur
var date = DateTime.Now.Year + "y-" + DateTime.Now.Month + "m-" + DateTime.Now.Day + "d-" +
DateTime.Now.Hour + "h-" + DateTime.Now.Minute + "m-" + DateTime.Now.Second + "s";
fileName = fileName + date + extention;
var path = Path.Combine(HttpContext.Current.Server.MapPath("~/VehicleAttachments/"), fileName);
bool isExists = Directory.Exists(path);
if (!isExists)
{
System.IO.Directory.CreateDirectory(path);
}
var rootUrl = Request.RequestUri.AbsoluteUri.Replace(Request.RequestUri.AbsolutePath, String.Empty);
rootUrl = Request.Headers.Host;
var response = new HttpResponseMessage(HttpStatusCode.OK);
if (Request.Content.IsMimeMultipartContent())
{
var streamProvider = new AutoMaxMultipartFormDataStreamProvider(path, fileName);
var result = await Request.Content.ReadAsMultipartAsync(streamProvider).ContinueWith <List <FileDesc> >(t =>
{
if (t.IsFaulted || t.IsCanceled)
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
var fileInfo = streamProvider.FileData.Select(i =>
{
var info = new FileInfo(i.LocalFileName);
return(new FileDesc(info.FullName, fileName, "http://" + rootUrl + "/" + fileName, info.Length / 1024, info.Extension, 0));
}).ToList();
return(fileInfo);
});
VehicleImage img = new VehicleImage();
img.ImagePath = fileName;
img.VehicleID = vehicleId;
img.CreatedBy = 1;
img.UpdatedBy = 1;
img.CreatedDate = DateTime.Now;
img.UpdatedDate = DateTime.Now;
db.VehicleImages.Add(img);
return(Ok(fileName));
}
else
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotAcceptable, "This request is not properly formatted"));
}
}
catch (Exception ex)
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotAcceptable, "This request is not properly formatted"));
}
}
public AddfourTypeVehicleImagesResponse addfourTypeVehicleImages(VehicleImage vehicleImage, string token)
{
AddfourTypeVehicleImagesResponse result = null;
try
{
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(ConstantData.ApiURL.ToString() + "AgreementMobile/SaveVehicleViewImages");
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
var myContent = JsonConvert.SerializeObject(vehicleImage);
var buffer = Encoding.UTF8.GetBytes(myContent);
var byteContent = new ByteArrayContent(buffer);
byteContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
var response = client.PostAsync(client.BaseAddress, byteContent).Result;
if (response.IsSuccessStatusCode)
{
var responseStream = response.Content.ReadAsStringAsync().Result;
result = JsonConvert.DeserializeObject <AddfourTypeVehicleImagesResponse>(responseStream);
}
}
}
catch (Exception ex)
{
throw ex;
}
return(result);
}
public void AssignImageToVehicle(int vehicleId, HttpPostedFileBase imageFile)
{
try
{
if (imageFile != null)
{
//create a byte array of appopriate length
var imageBytes = new byte[imageFile.ContentLength];
//convert image file to byte array and assign to imageBytes
imageFile.InputStream.Read(imageBytes, 0, imageFile.ContentLength);
//create new vehicle image, assign VehicleId to Id of Vehicle of which the image belongs
var vehicleImage = new VehicleImage
{
VehicleId = vehicleId,
ImageBytes = imageBytes,
};
//add new vehicle image to database table - VehicleImages, ans save
db.VehicleImages.Add(vehicleImage);
db.SaveChanges();
}
}
catch (Exception ex)
{
var errorService = new ErrorService(db);
errorService.logError(ex);
throw (ex);
}
}
public ActionResult DeleteConfirmed(int id)
{
VehicleImage vehicleimage = db.VehicleImages.Find(id);
db.VehicleImages.Remove(vehicleimage);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Edit(Vehicle vehicle, HttpPostedFileBase ImagePath, HttpPostedFileBase ImagePath2, HttpPostedFileBase ImagePath3)
{
ConvertToBase64 convertToBase = new ConvertToBase64();
if (ModelState.IsValid)
{
if (vehicle.Images == null)
{
vehicle.Images = new List <VehicleImage>();
}
if (ImagePath != null)
{
if (ImagePath.ContentLength > 0)
{
VehicleImage Img = new VehicleImage
{
vehicle = vehicle
};
vehicle.Images.Add(convertToBase.ConvertImageToByte(Img, ImagePath));
}
}
if (ImagePath2 != null)
{
if (ImagePath2.ContentLength > 0)
{
VehicleImage Img = new VehicleImage
{
vehicle = vehicle
};
vehicle.Images.Add(convertToBase.ConvertImageToByte(Img, ImagePath2));
}
}
if (ImagePath3 != null)
{
if (ImagePath3.ContentLength > 0)
{
VehicleImage Img = new VehicleImage
{
vehicle = vehicle
};
vehicle.Images.Add(convertToBase.ConvertImageToByte(Img, ImagePath3));
}
}
db.Entry(vehicle).State = EntityState.Modified; //update vehicle
db.SaveChanges(); //save chnages
return(RedirectToAction("manage"));
}
return(View(vehicle));
}
public JsonResult UploadVehicleImages()
{
try
{
var vehicleId = Convert.ToInt32(Request.Form["vehicleId"]);
var dbVehicle = db.Vehicles.Find(vehicleId);
if (dbVehicle == null)
{
throw new Exception("Could not find the vehicle");
}
var totalImages = Convert.ToInt32(Request.Form["imgCount"]);
for (int i = 0; i < Request.Files.Count; i++)
{
var dbImage = new Image()
{
Path = "something"
};
db.Images.Add(dbImage);
db.SaveChanges();
var img = Request.Files[i];
var imgExtension = Path.GetExtension(img.FileName);
var imgNameToStoreInDb = $"img_veh_{vehicleId}_{dbImage.Id}{imgExtension}";
var rootPath = Server.MapPath(ApplicationWideData.StorageRootPath);
var serverPath = Path.Combine(rootPath, imgNameToStoreInDb);
img.SaveAs(serverPath);
dbImage = db.Images.Find(dbImage.Id);
dbImage.Path = imgNameToStoreInDb;
db.Entry(dbImage).State = EntityState.Modified;
db.SaveChanges();
var vehicleImage = new VehicleImage
{
ImageId = dbImage.Id,
VehicleId = dbVehicle.Id
};
db.VehicleImages.Add(vehicleImage);
db.SaveChanges();
}
var statusObj = new
{
status = "success",
exceptionOccurred = "false",
filesUploaded = Request.Files.Count
};
return(Json(statusObj, JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
var statusObj = new
{
status = "error",
exceptionOccurred = "true",
exceptionMessage = ex.Message
};
return(Json(statusObj, JsonRequestBehavior.AllowGet));
}
}
public async Task Should_CreateVehicleInDB_WhenPostRequestIsSubmitted()
{
// GIVEN the service is running and there are no vehicles in vehicle list
var testServer = new TestServer(hostBuilder);
var client = testServer.CreateClient();
var db = testServer.Services.GetRequiredService <DatabaseContext>();
await db.Database.EnsureDeletedAsync();
FileStream fs = File.Open("../../../Resources/sedan-car-front-2.png", FileMode.Open);
MemoryStream ms = new MemoryStream();
fs.CopyTo(ms);
string imageBase64Data =
Convert.ToBase64String(ms.ToArray());
string imageDataURL =
string.Format("data:image/jpg;base64,{0}",
imageBase64Data);
var vehicleImage = new VehicleImage {
Id = 1, VehicleId = 1, ImageData = imageDataURL
};
ms.Close();
fs.Close();
await ms.DisposeAsync();
await fs.DisposeAsync();
var vehicle1 = new Vehicle
{
Id = 1,
VIN = "4Y1SL65848Z411439",
Make = "Toyota",
Model = "Corolla",
Year = 1997,
Miles = 145000,
Color = "Silver",
SellingPrice = 2000,
UserId = 1,
Status = Vehicle.StatusCode.Inventory,
VehicleImages = new List <VehicleImage> {
vehicleImage
}
};
await AppendJWTHeader(db, client);
// WHEN a POST request is submitted to the vehicle db
await client.PostAsJsonAsync("/Vehicle", vehicle1);
// THEN the response body should return the amount of vehicles in db
var dbVehicle = db.Vehicles.Include(v => v.VehicleImages).FirstOrDefault(t => t.Id == vehicle1.Id);
dbVehicle.User = null;
dbVehicle.Should().BeEquivalentTo(vehicle1);
await db.Database.EnsureDeletedAsync();
}
public bool AddImage(VehicleImage model)
{
if (model == null)
{
return(false);
}
_repository.Add(model);
_unitOfWork.Commit();
return(true);
}
public void VehicleImage_ShouldBeInstantiated()
{
//Given
//When
VehicleImage vehicleImage = new VehicleImage();
//Then
vehicleImage.Should().NotBeNull();
}
public ActionResult Edit([Bind(Include = "VehicleImageId,VehicleImages,VehicleId")] VehicleImage vehicleimage)
{
if (ModelState.IsValid)
{
db.Entry(vehicleimage).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.VehicleId = new SelectList(db.Vehicles, "VehicleId", "Model", vehicleimage.VehicleId);
return(View(vehicleimage));
}
public IHttpActionResult GetVehicleImage(int id)
{
VehicleImage item = db.VehicleImages.Get(id);
if (item == null)
{
return(NotFound());
}
return(Ok(item));
}
public ActionResult Create([Bind(Include = "VehicleImageId,VehicleImages,VehicleId")] VehicleImage vehicleimage)
{
if (ModelState.IsValid)
{
db.VehicleImages.Add(vehicleimage);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.VehicleId = new SelectList(db.Vehicles, "VehicleId", "Model", vehicleimage.VehicleId);
return(View(vehicleimage));
}
public ActionResult AddVehicle(VMVehicle vMVehicle)
{
try
{
VehicleDetail vehicleDetail = new VehicleDetail();
vehicleDetail.VehicleName = vMVehicle.VehicleName;
vehicleDetail.VehicleNo = vMVehicle.VehicleNo;
vehicleDetail.BrandId = vMVehicle.BrandId;
vehicleDetail.CategoryId = vMVehicle.CategoryId;
vehicleDetail.ColorId = vMVehicle.ColorId;
vehicleDetail.Euronum = vMVehicle.Euronum;
vehicleDetail.Kilometers = vMVehicle.Kilometers;
vehicleDetail.RegistrationYear = vMVehicle.RegistrationYear;
vehicleDetail.Price = vMVehicle.Price;
vehicleDetail.Weight = vMVehicle.Weight;
vehicleDetail.NoOfSeats = vMVehicle.NoOfSeats;
vehicleDetail.IsSold = vMVehicle.IsSold;
vehicleDetail.SoldDate = vMVehicle.SoldDate;
vehicleDetail.IsActive = vMVehicle.IsActive;
vehicleDetail.IsDelete = vMVehicle.IsDelete;
vehicleDetail.CreatedDate = vMVehicle.CreatedDate;
vehicleDetail.ModifiedDate = vMVehicle.ModifiedDate;
vehicleDetail.CreatedBy = vMVehicle.CreatedBy;
vehicleDetail.ModifiedBy = vMVehicle.ModifiedBy;
db.VehicleDetails.Add(vehicleDetail);
foreach (HttpPostedFileBase file in vMVehicle.VehicleImage1)
{
VehicleImage vehicleImage = new VehicleImage();
vehicleImage.VehicleImage1 = vMVehicle.VehicleImage1;
string VFileName = Path.GetFileNameWithoutExtension(file.FileName);
string VImageExtension = Path.GetExtension(file.FileName);
VFileName = VFileName + DateTime.Now.ToString("yymmssff") + VImageExtension;
vehicleImage.VehicleImgName = "~/VehicleImages/" + VFileName;
VFileName = Path.Combine(Server.MapPath("~/VehicleImages/"), VFileName);
file.SaveAs(VFileName);
vehicleDetail.VehicleId = vehicleImage.VehicleId;
db.VehicleImages.Add(vehicleImage);
}
db.SaveChanges();
return(RedirectToAction("Index"));
}
catch
{
ViewBag.CategoryId = new SelectList(db.Categories, "CategoryId", "CategoryName");
ViewBag.BrandId = new SelectList(db.Brands, "BrandId", "BrandName");
ViewBag.ColorId = new SelectList(db.Colors, "ColorId", "ColorName");
return(View());
}
}
public IHttpActionResult PostVehicleImage(VehicleImage item)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.VehicleImages.Add(item);
db.Complete();
return(CreatedAtRoute("DefaultApi", new { id = item.Id }, item));
}
public long Add(IVehicleImage Image)
{
VehicleImage image = new VehicleImage();
image.SRId = Image.SRId;
image.ImageBytes = Image.ImageBytes;
image.Date = Image.Date;
image.Order = Image.Order;
context.VehicleImages.Add(image);
context.SaveChanges();
return(image.Id);
}
private bool VehicleImageExists(int id)
{
VehicleImage item = db.VehicleImages.Get(id);
if (item == null)
{
return(false);
}
else
{
return(true);
}
}
public IHttpActionResult SaveVehicle(Vehicle vehicle)
{
var getuser = new VehicleRepository().Add(vehicle);
VehicleImage img = new VehicleImage();
img.ImageName = "test";
img.VechicleId = vehicle.Id;
img.IsDeleted = false;
vehicle.VehicleImages.Add(img);
return(Json(new { data = vehicle.Id, message = "Saved!", success = "false" }));
}
public IHttpActionResult DeleteVehicleImage(int id)
{
VehicleImage item = db.VehicleImages.Get(id);
if (item == null)
{
return(NotFound());
}
db.VehicleImages.Remove(item);
db.Complete();
return(Ok(item));
}
// GET: /VehicleImage/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
VehicleImage vehicleimage = db.VehicleImages.Find(id);
if (vehicleimage == null)
{
return(HttpNotFound());
}
return(View(vehicleimage));
}
protected void GvMyVehicles_RowCommand(object sender, GridViewCommandEventArgs e)
{
if (e.CommandName == "Page")
{
return;
}
string[] args = e.CommandArgument.ToString().Split(',');
int VehicleId = Convert.ToInt32(args[0]);
int FinId = Convert.ToInt32(args[1]);
switch (e.CommandName)
{
case "Edit":
Response.Redirect("viewmycarad.aspx?id=" + e.CommandArgument);
break;
case "Remove":
VehicleImage imgs = VehicleImage.SelectByVehicleId(VehicleId);
if (imgs != null)
{
if (Directory.Exists(Server.MapPath(imgs.ImgPath)))
{
Directory.Delete(Server.MapPath(imgs.ImgPath));
}
}
if (CustomerVehicleInfo.Delete(VehicleId))
{
GvMyVehicles.DataBind();
ScriptManager.RegisterStartupScript(Page, Page.GetType(), "Info", "alert('Your vehicle #" + e.CommandArgument + " has been deleted.');", true);
}
else
{
ScriptManager.RegisterStartupScript(Page, Page.GetType(), "Info", "alert('Failed deleteing vehicle #" + e.CommandArgument + ".');", true);
}
break;
case "Sold":
ChangeStatus(FinId, VehicleId, "Sold");
break;
case "SoldButMore":
ChangeStatus(FinId, VehicleId, "Sold but more");
break;
default:
break;
}
}
//Delete an unwanted vehicle image for an inventory vehicle
public void DeleteVehicleImageFromInventoryVehicle(VehicleImage image)
{
try
{
db.VehicleImages.Remove(image);
db.SaveChanges();
}
catch (Exception ex)
{
var errorService = new ErrorService(db);
errorService.logError(ex);
throw (ex);
}
}
// GET: /VehicleImage/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
VehicleImage vehicleimage = db.VehicleImages.Find(id);
if (vehicleimage == null)
{
return(HttpNotFound());
}
ViewBag.VehicleId = new SelectList(db.Vehicles, "VehicleId", "Model", vehicleimage.VehicleId);
return(View(vehicleimage));
}
public AddfourTypeVehicleImagesResponse addfourTypeVehicleImages(VehicleImage vehicleImage, string token)
{
AddfourTypeVehicleImagesResponse response = null;
try
{
response = agreementService.addfourTypeVehicleImages(vehicleImage, token);
}
catch (Exception ex)
{
throw ex;
}
return(response);
}
public async Task <Response> Add(VehicleImage vehicleImage, IFormFile file)
{
var fileUploadResult = await FileUploadService.Upload(file, "img/cars/");
if (fileUploadResult.IsSuccess == false)
{
return(Response.Fail(fileUploadResult.Message));
}
vehicleImage.ImageUrl = fileUploadResult.Data.Url;
Context.VehicleImage.Add(vehicleImage);
Context.SaveChanges();
return(Response.Success("Araç resmi başarıyla kaydedildi"));
}
//GET
public ActionResult AddImage(int?id)
{
var vehicle = db.Vehicles.FirstOrDefault(x => x.Id == id);
if (vehicle != null)
{
string make = vehicle.Make;
string vModel = vehicle.Model;
string year = vehicle.Year.ToString();
string item = year + " " + make + " " + vModel;
ViewBag.stringDescription = item;
}
VehicleImage image = new VehicleImage();
return(View(image));
}
public void AddRange(List <VehicleImage> Images)
{
List <VehicleImage> images = new List <VehicleImage>();
foreach (var Image in Images)
{
VehicleImage image = new VehicleImage();
image.SRId = Image.SRId;
image.ImageBytes = Image.ImageBytes;
image.Date = Image.Date;
image.Order = Image.Order;
images.Add(image);
}
context.VehicleImages.AddRange(images);
context.SaveChanges();
}
