public async Task <IActionResult> Edit(CarBrandUpdateDTO carBrandUpdateDTO)
{
try
{
if (!ModelState.IsValid)
{
return(View(carBrandUpdateDTO));
}
CarBrand carBrand = new CarBrand
{
Id = carBrandUpdateDTO.Id,
Name = carBrandUpdateDTO.Name
};
var result = await _carBrandService.UpdateAsync(carBrand);
if (result == -1)
{
ModelState.AddModelError("", "Error update");
return(View(carBrandUpdateDTO));
}
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
return(View("Error", ex));
}
}
public override void UpdateNodes()
{
CarModelsVMNode resultAlias = null;
CarBrand brandAlias = null;
CarModel modelAlias = null;
var modelsQuery = UoW.Session.QueryOver <CarModel>(() => modelAlias);
if (OnlyBrand != null)
{
modelsQuery.Where(() => modelAlias.Brand == OnlyBrand);
}
var modelsList = modelsQuery
.JoinAlias(m => m.Brand, () => brandAlias)
.SelectList(list => list
.Select(() => modelAlias.Id).WithAlias(() => resultAlias.Id)
.Select(() => modelAlias.Name).WithAlias(() => resultAlias.ModelName)
.Select(() => brandAlias.Name).WithAlias(() => resultAlias.Brand)
)
.TransformUsing(Transformers.AliasToBean <CarModelsVMNode>())
.List <CarModelsVMNode>();
SetItemsSource(modelsList);
}
public CarView()
{
InitializeComponent();
CarBrand.SetBinding(Image.SourceProperty, new Binding("Car.Brand", source: this));
//if(Car.CarImage_1 != null || Car.CarImage_1.Any())
//{
// var stream1 = new MemoryStream(Car.CarImage_1 ?? new byte[] { });
// CarImage.Source = ImageSource.FromStream(() => stream1);
//}
CarImage.SetBinding(CachedImage.SourceProperty, new Binding("Car.CarImageSource", source: this));
CarName.SetBinding(Label.TextProperty, new Binding("Car.Name", source: this));
//carouselForCarImages.SetBinding(CarouselViewControl.ItemsSourceProperty, new Binding("Car.Images", source: this));
Available.SetBinding(Button.TextProperty, new Binding("Car.Available", BindingMode.Default, new FromBoolToAvailableText(), source: this));
Available.SetBinding(Button.OpacityProperty, new Binding("Car.Available", BindingMode.Default, new FromBoolToAvailableOpacity(), source: this));
Available.SetBinding(Button.BackgroundColorProperty, new Binding("Car.Available", BindingMode.Default, new FromBoolToAvailableBackgroundColor(), source: this));
this.GestureRecognizers.Add(new TapGestureRecognizer
{
Command = new Command(() => {
this.Clicked?.Invoke(this, EventArgs.Empty);
if (Command != null)
{
if (Command.CanExecute(CommandParameter))
{
Command.Execute(CommandParameter);
}
}
})
});
}
public ActionResult <CarBrand> PutCarBrand(int id, [FromBody] CarBrand carBrand)
{
if (!ModelState.IsValid)
{
var natinallity = ModelState[nameof(carBrand.nationality)];
if (natinallity != null && natinallity.Errors.Any())
{
return(BadRequest(natinallity.Errors));
}
}
try
{
return(Ok(carBrandService.UpdateCarBrand(id, carBrand)));
}
catch (NotFoundItemException ex)
{
return(NotFound(ex.Message));
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, ex.Message));
}
}
public IHttpActionResult PutCarBrand(int id, CarBrand carBrand)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != carBrand.id)
{
return(BadRequest());
}
db.Entry(carBrand).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!CarBrandExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
/// <summary>
/// Create a new item in the database, CREATE
/// </summary>
/// <param name="value">Object to create</param>
public void Create(object value)
{
CarBrand carBrand = value as CarBrand;
Model model = value as Model;
Extra extra = value as Extra;
ModelExtraswitch modelExtraswitch = value as ModelExtraswitch;
if (carBrand != null)
{
this.carBrandRepository.Create(carBrand);
}
else if (model != null)
{
this.modelRepository.Create(model);
}
else if (extra != null)
{
this.extraRepository.Create(extra);
}
else if (modelExtraswitch != null)
{
this.modelExtraSwitchRepository.Create(modelExtraswitch);
}
else
{
throw new NoClassException("There is no such a table.", value);
}
}
public async Task <IActionResult> Edit(CarBrandUpdateDTO carBrandUpdateDTO)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
CarBrand carBrand = new CarBrand
{
Id = carBrandUpdateDTO.Id,
Name = carBrandUpdateDTO.Name
};
var result = await _carBrandService.UpdateAsync(carBrand);
if (result == -1)
{
return(BadRequest("Error update"));
}
return(Ok(carBrand));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public static async Task <IEnumerable <CarModel> > FindModelsByBrandIdAsync(this IOrderedQueryable <CarBrand> brands, int brandId)
{
CarBrand brand = await brands
.Include(b => b.CarModels).FirstOrDefaultAsync(b => b.Id == brandId);
return(brand == null ? null : brand.CarModels);
}
private void Drive()
{
Debug.Log("I am a driver, and I will now make a car.");
mCar = new Car();
mCarBrand = CarBrand.Pontiac;
mCar.AddDriver(this);
mCar.AddEngine();
mCar.AddAutomatic();
//mCar.PutInD();
mCar.AddLights();
mCar.AddWheels();
//mCar.AddStandard();
//mCar.PutInFirst();
Michael();
mCar.ActivateKitt();
//mCar.Forward();
//mCar.Darkness();
//mCar.HitTheGas();
//mCar.TurnRight();
//mCar.TurnLeft();
Debug.Log("You are driving a " + mCarBrand);
//because I inherit from Human, I can call this method
LiveAndDie();
Debug.Log("Let's drive!");
//Alex begin here!
}
public void Run()
{
HtmlDocument htmlDocument = new HtmlWeb().Load(WebConstants.BASE_URL + WebConstants.PHOTO_URL);
HtmlNodeCollection brandNodes = htmlDocument.DocumentNode.SelectNodes(WebConstants.BRAND_NODE);
if (brandNodes != null)
{
foreach (HtmlNode tempNode in brandNodes)
{
HtmlNode brandNode = HtmlNode.CreateNode(tempNode.OuterHtml);
string brandUrl = brandNode.SelectSingleNode(WebConstants.LINK_HREF).Attributes[WebConstants.HREF].Value;
char brandAlpha = brandNode.SelectSingleNode(WebConstants.BRAND_ALPHA).InnerText.ToCharArray()[0];
string brandNamePostFix = brandNode.SelectSingleNode(WebConstants.BRAND_NAME_POSTFIX).InnerText;
string brandName = brandNode.InnerText;
brandName = brandName.Substring(1, brandName.Length - brandNamePostFix.Length - 1);
CarBrand carBrand = new CarBrand(brandUrl);
carBrand.Alpha = brandAlpha;
carBrand.Name = brandName;
mCarBrandList.Add(carBrand);
}
}
runBrandTasks();
}
public CarBrand UpdateCarBrand(CarBrand editBrand)
{
var brandToUpdate = carBrands.Single(b => b.id == editBrand.id);
if (editBrand.about != null)
{
brandToUpdate.about = editBrand.about;
}
if (editBrand.url_logo_image != null)
{
brandToUpdate.about = editBrand.url_logo_image;
}
if (editBrand.facebook != null)
{
brandToUpdate.facebook = editBrand.facebook;
}
if (editBrand.name != null)
{
brandToUpdate.name = editBrand.name;
}
if (editBrand.nationality != null)
{
brandToUpdate.nationality = editBrand.nationality;
}
if (editBrand.oficialPage != null)
{
brandToUpdate.oficialPage = editBrand.oficialPage;
}
if (editBrand.ubication != null)
{
brandToUpdate.ubication = editBrand.ubication;
}
return(brandToUpdate);
}
public async Task <IActionResult> Create(CarBrandEditModel model)
{
var fileName = Path.GetFileName(ContentDispositionHeaderValue.Parse(model.PathBrand.ContentDisposition).FileName.Value.Trim('"'));
var fileExt = Path.GetExtension(fileName);
if (!CarBrandsController.AllowedExtensions.Contains(fileExt))
{
this.ModelState.AddModelError(nameof(model.PathBrand), "This file type is prohibited");
}
if (this.ModelState.IsValid)
{
var carBrand = new CarBrand
{
Name = model.Name,
Description = model.Description
};
var attachmentPath = Path.Combine(this.hostingEnvironment.WebRootPath, "attachments/brands", carBrand.Id.ToString("N") + fileExt);
carBrand.PathBrand = $"/attachments/brands/{carBrand.Id:N}{fileExt}";
using (var fileStream = new FileStream(attachmentPath, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.Read))
{
await model.PathBrand.CopyToAsync(fileStream);
}
carBrand.Id = Guid.NewGuid();
this._context.Add(carBrand);
await this._context.SaveChangesAsync();
return(this.RedirectToAction("Index"));
}
return(this.View(model));
}
// The id parameter name should match the DataKeyNames value set on the control
public void CarBrandFormView_UpdateItem(CarBrand carBrand)
{
try
{
// Load the item here, e.g. item = MyDataLayer.Find(id);
if (carBrand == null)
{
// The item wasn't found
ModelState.AddModelError(String.Empty, String.Format("Item with id {0} was not found", carBrand));
return;
}
if (TryUpdateModel(carBrand))
{
// Save changes here, e.g. MyDataLayer.SaveChanges();
Service.SaveCarBrand(carBrand);
Page.SetTempData("Message", "Bilmärken har uppdateras.");
Response.RedirectToRoute("EditCarBrand");
Context.ApplicationInstance.CompleteRequest();
}
}
catch
{
Page.ModelState.AddModelError(String.Empty, "Fel då skulle bilmärken uppdateras.");
}
}
public async Task <IActionResult> Edit(int id, [Bind("CarBrandID,CarBrandName")] CarBrand carBrand)
{
if (id != carBrand.CarBrandID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(carBrand);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CarBrandExists(carBrand.CarBrandID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(carBrand));
}
public async Task <IActionResult> Create(CarBrand brand)
{
if (ModelState.IsValid)
{
var allBrands = await _database.CarBrands.ToListAsync();
if (allBrands.Any(b => b.Name == brand.Name))
{
TempData["carbrand"] = "You cannot add " + brand.Name + " car brand because it already exist!!!";
TempData["notificationType"] = NotificationType.Error.ToString();
return(View("Index"));
}
var _brand = new CarBrand()
{
Name = brand.Name,
CreatedBy = Convert.ToInt32(_session.GetInt32("imouloggedinuserid")),
DateCreated = DateTime.Now,
LastModifiedBy = Convert.ToInt32(_session.GetInt32("imouloggedinuserid")),
DateLastModified = DateTime.Now
};
await _database.CarBrands.AddAsync(_brand);
await _database.SaveChangesAsync();
TempData["carbrand"] = "You have successfully added " + brand.Name + " car brand.";
TempData["notificationType"] = NotificationType.Success.ToString();
return(Json(new { success = true }));
}
return(View("Index"));
}
//Skapar en ny CarBrand i tabellen CarBrand.
public void InsertCarBrand(CarBrand carBrand)
{
// Skapar och initierar ett anslutningsobjekt.
using (SqlConnection conn = CreateConnection())
{
try
{
// Skapar ett SqlCommand-objekt för att exekvera specifierad lagrad procedur.
SqlCommand cmd = new SqlCommand("appSchema.uspInsertCarBrand", conn);
cmd.CommandType = CommandType.StoredProcedure;
// Lägger till de paramterar den lagrade proceduren kräver.
cmd.Parameters.Add("@BrandName", SqlDbType.VarChar, 40).Value = carBrand.BrandName;
// Lägger till de paramterar den lagrade proceduren kräver.
cmd.Parameters.Add("@CarBrandID", SqlDbType.TinyInt, 1).Direction = ParameterDirection.Output;
// Öppnar anslutningen till databasen.
conn.Open();
// Exekvera den lagrade proceduren
cmd.ExecuteNonQuery();
// Hämtar primärnyckelns värde för den nya posten och tilldelar CarBrand-objektet värdet.
carBrand.CarBrandID = (byte)cmd.Parameters["@CarBrandID"].Value;
}
catch
{
throw new ApplicationException("An error occured in the data access layer.");
}
}
}
public static IHost MigrateDatabase(this IHost host)
{
using (var scope = host.Services.CreateScope())
{
using (var appContext = scope.ServiceProvider.GetRequiredService <CarLibraryContext>())
{
try
{
appContext.Database.Migrate();
CarBrand b = new CarBrand {
Name = "Porsche"
};
CarModel c = new CarModel {
Name = "911", CarBrand = b
};
int bC = appContext.CarBrands.Count();
int cC = appContext.CarModels.Count();
if (bC + cC == 0)
{
appContext.CarBrands.Add(b);
appContext.CarModels.Add(c);
appContext.SaveChanges();
}
}
catch (Exception)
{
//Log errors or do anything you think it's needed
throw;
}
}
}
return(host);
}
public async Task <ActionResult <CarBrand> > PostCarBrand(CarBrand carBrand)
{
_context.CarBrands.Add(carBrand);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetCarBrand", new { id = carBrand.Id }, carBrand));
}
//Uppdaterar en CarBrand i tabellen CarBrand.
public void UpdateCarBrand(CarBrand carBrand)
{
// Skapar och initierar ett anslutningsobjekt.
using (SqlConnection conn = CreateConnection())
{
try
{
// Skapar ett SqlCommand-objekt för att exekvera specifierad lagrad procedur.
SqlCommand cmd = new SqlCommand("appSchema.uspUpdateCarBrand", conn);
cmd.CommandType = CommandType.StoredProcedure;
// Lägger till de paramterar den lagrade proceduren kräver.
cmd.Parameters.Add("@BrandName", SqlDbType.VarChar, 40).Value = carBrand.BrandName;
cmd.Parameters.Add("@CarBrandID", SqlDbType.TinyInt, 1).Value = carBrand.CarBrandID;
// Öppnar anslutningen till databasen.
conn.Open();
// ExecuteNonQuery används för att exekvera den lagrade proceduren
cmd.ExecuteNonQuery();
}
catch
{
throw new ApplicationException("An error occured in the data access layer.");
}
}
}
public async Task <IActionResult> PutCarBrand(int id, CarBrand carBrand)
{
if (id != carBrand.Id)
{
return(BadRequest());
}
_context.Entry(carBrand).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CarBrandExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public string this[string propertyName]
{
get
{
switch (propertyName)
{
case "CarBrand":
return(CarBrand.ToString());
case "CarModel":
return(CarModel.ToString());
case "Id":
return(Id.ToString());
case "ProductYear":
return(ProductYear.ToString());
case "Cubicase":
return(Cubicase.ToString());
case "NumberOfDoorId":
return(NumberOfDoorId.ToString());
case "CarBodyId":
return(CarBodyId.ToString());
case "GearshiftId":
return(GearshiftId.ToString());
default:
return("");
}
}
}
public async Task <IActionResult> Edit(int id, CarBrand brand)
{
if (id != brand.CarBrandId)
{
return(RedirectToAction("Index", "Error"));
}
if (ModelState.IsValid)
{
try
{
brand.LastModifiedBy = Convert.ToInt32(_session.GetInt32("imouloggedinuserid"));
brand.DateLastModified = DateTime.Now;
_database.Update(brand);
await _database.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CarBrandExists(brand.CarBrandId))
{
return(NotFound());
}
else
{
throw;
}
}
TempData["carbrand"] = "You have successfully modified " + brand.Name + " car brand.";
TempData["notificationType"] = NotificationType.Success.ToString();
return(Json(new { success = true }));
}
return(View(brand));
}
public async Task <IHttpActionResult> UpdateCarBrand(CarBrand mob)
{
if (User.Identity.IsAuthenticated)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
mob.addedBy = User.Identity.GetUserId();
mob.time = DateTime.UtcNow;
mob.status = "a";
db.Entry(mob).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbEntityValidationException e)
{
string s = e.ToString();
List <string> errorMessages = new List <string>();
foreach (DbEntityValidationResult validationResult in e.EntityValidationErrors)
{
string entityName = validationResult.Entry.Entity.GetType().Name;
foreach (DbValidationError error in validationResult.ValidationErrors)
{
errorMessages.Add(entityName + "." + error.PropertyName + ": " + error.ErrorMessage);
}
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
return(BadRequest("Not login"));
}
public static BrandReadModel ToModel(this CarBrand brand)
{
return(new BrandReadModel()
{
Name = brand.Name,
Id = brand.Id
});
}
public Car(int id, CarBrand brand, string brandModel, int yearOfProduction, int passedKM)
{
ID = id;
Brand = brand;
BrandModel = brandModel;
YearOfProduction = yearOfProduction;
PassedKM = passedKM;
}
public async Task <int> AddAsync(CarBrand carBrand)
{
await _context.CarBrands.AddAsync(carBrand);
await _context.SaveChangesAsync();
return(carBrand.Id);
}
public ActionResult Save(CarPart model)
{
CarPart retval = null;
using (var db = new EfContext())
{
model.PublishDate = DateTime.Now;
if (!string.IsNullOrEmpty(model.Image64))
{
model.Image = Convert.FromBase64String(model.Image64);
}
if (model.CarBrandID == 0)
{
model.CarBrandID = null;
}
if (model.ShopID == 0)
{
model.ShopID = null;
}
if (model.CarBrand == null)
{
model.CarBrand = db.CarBrands.FirstOrDefault();
}
CarBrand cb = db.CarBrands.FirstOrDefault(x => x.Name.Equals(model.CarBrand.Name));
model.CarBrand = cb;
User user = db.Users.Include(x => x.Shop).FirstOrDefault(x => x.ID == model.UserID);
if (user != null)
{
model.Shop = user.Shop;
}
model.Shop.Phone = user.Shop.Phone;
if (model.ID == 0)
{
model.VisitsNumber = 0;
model.PublishDate = DateTime.Now;
retval = db.CarParts.Add(model);
}
else
{
CarPart cpedit = db.CarParts
.FirstOrDefault(x => x.ID == model.ID);
cpedit.LongDescription = model.LongDescription;
cpedit.Name = model.Name;
cpedit.Price = model.Price;
cpedit.ShortDescription = model.ShortDescription;
cpedit.Image = model.Image;
if (cpedit.Quantity == 0 && model.Quantity != 0)
{
SendNotification(cpedit.ID);
}
retval = cpedit;
}
db.SaveChanges();
}
return(Json(retval, JsonRequestBehavior.AllowGet));
}
public bool InsertNewCar(String localDatabase)
{
int vintageNumber = ParseStringToInt(Resources.BazarManager_ParseStringToInt_Vintage, 1900, DateTime.Today.Year);
if (vintageNumber == -1)
{
return(false);
}
int kilometers = ParseStringToInt(Resources.BazarManager_ParseStringToInt_Kilometers, 0, 2000000);
if (kilometers == -1)
{
return(false);
}
int price = ParseStringToInt(Resources.BazarManager_ParseStringToInt_Price, 100, 2000000);
if (price == -1)
{
return(false);
}
int numberOfDoors = ParseStringToInt(Resources.BazarManager_ParseStringToInt_Doors, 0, 15);
if (numberOfDoors == -1)
{
return(false);
}
CarBrand carBrandEnum = ParseStringToEnum <CarBrand>(Resources.BazarManager_ParseStringToEnum_CarBrand);
if (carBrandEnum == 0)
{
return(false);
}
CarType carTypeEnum = ParseStringToEnum <CarType>(Resources.BazarManager_ParseStringToEnum_CarType);
if (carTypeEnum == 0)
{
return(false);
}
Fuel fuelEnum = ParseStringToEnum <Fuel>(Resources.BazarManager_ParseStringToEnum_Fuel);
if (fuelEnum == 0)
{
return(false);
}
Town townEnum = ParseStringToEnum <Town>(Resources.BazarManager_ParseStringToEnum_Town);
if (townEnum == 0)
{
return(false);
}
bool isCrashed = ParseStringToBool(Resources.BazarManager_ParseStringToBool_IsTheCrashed);
Car car = new Car(GetNewId(), vintageNumber, kilometers, carBrandEnum, carTypeEnum, fuelEnum, price, townEnum, numberOfDoors, isCrashed);
_cars.Add(car);
UpdateCarsToDb(localDatabase);
return(true);
}
public ActionResult Update(CarBrand model)
{
CarBrand mrka = _carBrandService.GetById(model.Id);
mrka.BrandName = model.BrandName;
mrka.Description = model.Description;
_carBrandService.Update(mrka);
return(RedirectToAction("List", "CarBrand", new { area = "Admin" }));
}
public static void Main()
{
NissanBuilder nissanBuilder = new();
var director = new Director(nissanBuilder);
director.Implement(false);
CarBrand nissan = nissanBuilder.GetResult();
}
