public async Task <IActionResult> Edit(int id, [Bind("VehicleCategoryId,Name")] VehicleCategory vehicleCategory)
{
if (id != vehicleCategory.VehicleCategoryId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(vehicleCategory);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!VehicleCategoryExists(vehicleCategory.VehicleCategoryId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(vehicleCategory));
}
/// <summary>
/// Add /Update Vehicle Category
/// </summary>
public VehicleCategory SaveVehicleCategory(VehicleCategory vehicleCategory)
{
VehicleCategory dbVersion = vehicleCategoryRepository.Find(vehicleCategory.VehicleCategoryId);
//Code Duplication Check
if (vehicleCategoryRepository.VehicleCategoryCodeDuplicationCheck(vehicleCategory))
{
throw new CaresException(Resources.FleetPool.VehicleCategory.VehicleCategoryCodeDuplicationError);
}
//UPDATE
if (dbVersion != null)
{
UpdateVehicleCategoryPropertie(vehicleCategory, dbVersion);
vehicleCategoryRepository.Update(dbVersion);
} //ADD
else
{
dbVersion = new VehicleCategory();
SetVehicleCategoryProperties(vehicleCategory, dbVersion);
vehicleCategoryRepository.Add(dbVersion);
}
vehicleCategoryRepository.SaveChanges();
return(vehicleCategoryRepository.Find(dbVersion.VehicleCategoryId));
}
public async Task <ActionResult <VehicleCategory> > PostVehicleCategory(VehicleCategory vehicleCategory)
{
_context.VehicleCategories.Add(vehicleCategory);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetVehicleCategory", new { id = vehicleCategory.Id }, vehicleCategory));
}
public async Task UpdatePreventsDuplicateNames()
{
var mock = new Mock <IVehicleCategoryRepo>();
mock.Setup(m => m.FindByName("cat")).ReturnsAsync(new VehicleCategory()
{
Id = Guid.NewGuid(), Name = "cat"
});
var repo = mock.Object;
var service = new VehicleCategoryService(
new VehicleCategoryNameUniqueSpecification(repo),
new VehicleCategoryNotInUseSpecification(repo),
repo
);
var user = new User("auth0", "*****@*****.**", "username");
var updatingCat = new VehicleCategory()
{
Id = Guid.NewGuid(),
Name = "old"
};
await Assert.ThrowsExceptionAsync <SpecificationException>(
async() => await service.Update(
updatingCat,
new VehicleCategoryUpdate(
"cat"
)
)
);
}
/// <summary>
/// Initializes a new instance of the <see cref="VehicleModelInfo" /> class.
/// </summary>
private VehicleModelInfo(int type, string name, VehicleCategory category)
: this()
{
Type = (VehicleModelType)type;
Name = name;
Category = category;
}
public async Task UpdateSetsNameAndDescription()
{
var mock = new Mock <IVehicleCategoryRepo>();
var repo = mock.Object;
var service = new VehicleCategoryService(
new VehicleCategoryNameUniqueSpecification(repo),
new VehicleCategoryNotInUseSpecification(repo),
repo
);
var user = new User("auth0", "*****@*****.**", "username");
var cat = new VehicleCategory()
{
Name = "old",
Description = "oldDesc"
};
await service.Update(
cat,
new VehicleCategoryUpdate(
"new",
"newDesc"
)
);
Assert.AreEqual(cat.Name, "new");
Assert.AreEqual(cat.Description, "newDesc");
}
public async Task DeleteThrowsErrorIfInUse()
{
var mock = new Mock <IVehicleCategoryRepo>();
mock.Setup(m => m.IsInUse(It.IsAny <VehicleCategory>())).ReturnsAsync(true);
var repo = mock.Object;
var service = new VehicleCategoryService(
new VehicleCategoryNameUniqueSpecification(repo),
new VehicleCategoryNotInUseSpecification(repo),
repo
);
var cat = new VehicleCategory()
{
Name = "cat"
};
var user = new User("auth0", "*****@*****.**", "username");
await Assert.ThrowsExceptionAsync <SpecificationException>(
async() => {
await service.Delete(
cat
);
}
);
}
//--------------- METHODS -----------------
/// <summary>
/// Creates a new <see cref="VehicleType"/> using the <see cref="CreateVehicleTypeServiceModel"/>.
/// If such <see cref="VehicleType"/> already exists in the database, fetches it's (int)<c>Id</c> and returns it.
/// If such <see cref="VehicleType"/> doesn't exist in the database, adds it and return it's (int)<c>Id</c>.
/// </summary>
/// <param name="model">Service model with <c>Name</c>, <c>VehicleCategory</c> and <c>Description</c></param>
/// <returns>VehicleType ID</returns>
public async Task <int> CreateAsync(CreateVehicleTypeServiceModel model)
{
VehicleCategory vehicleCategory = (VehicleCategory)model.VehicleCategoryId;
int vehicleTypeId = this.dbContext.VehicleTypes.Where(x => x.Name == model.Name &&
x.VehicleCategory == vehicleCategory)
.Select(x => x.Id)
.FirstOrDefault();
if (vehicleTypeId != 0) // If vehicleTypeId is different than 0 (int default value), vehicleType with such name already exists, so return it's id.
{
return(vehicleTypeId);
}
VehicleType vehicleType = new VehicleType
{
Name = model.Name,
VehicleCategory = vehicleCategory,
Description = model.Description,
};
await this.dbContext.VehicleTypes.AddAsync(vehicleType);
await this.dbContext.SaveChangesAsync();
return(vehicleType.Id);
}
public async Task <IActionResult> PutVehicleCategory(Guid id, VehicleCategory vehicleCategory)
{
if (id != vehicleCategory.Id)
{
return(BadRequest());
}
_context.Entry(vehicleCategory).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!VehicleCategoryExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public ActionResult DeleteConfirmed(int id)
{
VehicleCategory vehicleCategory = db.VehicleCategories.Find(id);
db.VehicleCategories.Remove(vehicleCategory);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public VehicleCategory Post(VehicleCategory vehicleCategory)
{
if (vehicleCategory == null || !ModelState.IsValid)
{
throw new HttpException((int)HttpStatusCode.BadRequest, "Invalid Request");
}
return(vehicleCategoryService.SaveVehicleCategory(vehicleCategory.CreateFromm()).CreateFromm());
}
public async Task <bool> IsInUse(VehicleCategory entity)
{
using (var conn = OpenConnection()) {
int configCount = await conn.ExecuteScalarAsync <int>(@"select count(*) from service_configurations where vehicle_category_id = @Id", entity);
return(configCount > 0);
}
}
public async Task Delete(VehicleCategory entity)
{
using (var conn = OpenConnection()) {
await conn.ExecuteAsync(
@"delete from vehicle_categories where id = @Id;", entity
);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="VehicleModelInfo" /> class.
/// </summary>
private VehicleModelInfo(int type, string name, VehicleCategory category, int seatCount)
: this()
{
Type = (VehicleModelType)type;
Name = name;
Category = category;
SeatCount = seatCount;
}
public async Task Update(VehicleCategory entity)
{
using (var conn = OpenConnection()) {
await conn.ExecuteAsync(
@"update vehicle_categories set name = @Name, description = @Description where id = @Id",
entity
);
}
}
public async Task Add(VehicleCategory entity)
{
using (var conn = OpenConnection()) {
await conn.ExecuteAsync(
@"insert into vehicle_categories (id, user_id, name, description) values (@Id, @UserId, @Name, @Description);",
entity
);
}
}
/// <summary>
/// Set newly created Vehicle Category object Properties in case of adding
/// </summary>
private void SetVehicleCategoryProperties(VehicleCategory vehicleCategory, VehicleCategory dbVersion)
{
dbVersion.RecLastUpdatedBy = dbVersion.RecCreatedBy = vehicleCategoryRepository.LoggedInUserIdentity;
dbVersion.RecLastUpdatedDt = dbVersion.RecCreatedDt = DateTime.Now;
dbVersion.VehicleCategoryCode = vehicleCategory.VehicleCategoryCode;
dbVersion.VehicleCategoryName = vehicleCategory.VehicleCategoryName;
dbVersion.VehicleCategoryDescription = vehicleCategory.VehicleCategoryDescription;
dbVersion.UserDomainKey = vehicleCategoryRepository.UserDomainKey;
}
public Boolean Delete(VehicleCategory vehicleCategory)
{
if (vehicleCategory == null || !ModelState.IsValid)
{
throw new HttpException((int)HttpStatusCode.BadRequest, "Invalid Request");
}
vehicleCategoryService.DeleteVehicleCategory(vehicleCategory.VehicleCategoryId);
return(true);
}
/// <summary>
/// update Vehicle Category object Properties in case of updation
/// </summary>
protected void UpdateVehicleCategoryPropertie(VehicleCategory vehicleCategory, VehicleCategory dbVersion)
{
dbVersion.RecLastUpdatedBy = vehicleCategoryRepository.LoggedInUserIdentity;
dbVersion.RecLastUpdatedDt = DateTime.Now;
dbVersion.RowVersion = dbVersion.RowVersion + 1;
dbVersion.VehicleCategoryCode = vehicleCategory.VehicleCategoryCode;
dbVersion.VehicleCategoryName = vehicleCategory.VehicleCategoryName;
dbVersion.VehicleCategoryDescription = vehicleCategory.VehicleCategoryDescription;
}
public ActionResult CreateVehicleCategory(VehicleCategory model)
{
if (ModelState.IsValid)
{
db.VehicleCategories.Add(model);
db.SaveChanges();
return(RedirectToAction("VehicleCategoryList"));
}
return(View(model));
}
/// <summary>
/// Create entity from web model
/// </summary>
public static Cares.Models.DomainModels.VehicleCategory CreateFromm(this VehicleCategory source)
{
return(new Cares.Models.DomainModels.VehicleCategory
{
VehicleCategoryId = source.VehicleCategoryId,
VehicleCategoryCode = source.VehicleCategoryCode,
VehicleCategoryName = source.VehicleCategoryName,
VehicleCategoryDescription = source.VehicleCategoryDescription
});
}
public ActionResult Edit([Bind(Include = "Id,Category,Size")] VehicleCategory vehicleCategory)
{
if (ModelState.IsValid)
{
db.Entry(vehicleCategory).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(vehicleCategory));
}
public async Task <IActionResult> Create([Bind("VehicleCategoryId,Name")] VehicleCategory vehicleCategory)
{
if (ModelState.IsValid)
{
_context.Add(vehicleCategory);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(vehicleCategory));
}
public void TestVehicleCategories()
{
List <VehicleCategory> vehicleCategories = AppDb.GetVehicleCategories().ToList();
if (vehicleCategories.Any())
{
VehicleCategory first = vehicleCategories.First();
VehicleCategory response = AppDb.GetVehicleCategory(first.Id);
}
}
public ActionResult Create([Bind(Include = "Id,Category,Size")] VehicleCategory vehicleCategory)
{
if (ModelState.IsValid)
{
db.VehicleCategories.Add(vehicleCategory);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(vehicleCategory));
}
public VehicleDetailsPage(Vehicle vehicle)
{
this.vehicle = vehicle;
InitializeComponent();
BindingContext = this.vehicle;
HasBeenPurchasedSwitch.IsToggled = this.vehicle.HasBeenPurchased;
if (this.vehicle.CostBucks > 0)
{
CostBucksLabel.Text = String.Format("Cost(Bucks): {0:N0}B", this.vehicle.CostBucks);
}
else
{
CostBucksLabel.Text = "Cost(Bucks): N/A";
}
if (this.vehicle.CostCredits > 0)
{
CostCreditsLabel.Text = String.Format("Cost(Credits): {0:N0}CC", this.vehicle.CostBucks);
}
else
{
CostCreditsLabel.Text = "Cost(Credits): N/A";
}
UnlockLevelLabel.Text = "Unlock level: " + (this.vehicle.LevelToUnlock > 0 ? this.vehicle.LevelToUnlock.ToString() : "N/A");
TopSpeedKmhLabel.Text = "Top speed (Kmh): " + (this.vehicle.TopSpeedKMh > 0 ? this.vehicle.TopSpeedKMh.ToString() : "N/A");
TopSpeedMphLabel.Text = "Top speed (Mph): " + (this.vehicle.TopSpeedKMh > 0 ? (this.vehicle.TopSpeedKMh / 1.609f).ToString() : "N/A");
PowerBHPLabel.Text = "Bhp: " + (this.vehicle.PowerBHP > 0 ? this.vehicle.PowerBHP.ToString() : "N/A");
VehicleCategory currentVehicleCategory = LoadedData.VehicleCategories[vehicle.VehicleCategory.VehicleActualTypes];
RatingLabel.Text = "Rating: " + this.vehicle.Rating.ToString() + "/" + currentVehicleCategory.MaximumRating.ToString();
VehicleCategories category = this.vehicle.VehicleActualCategory;
string categoryString = category.GetDescription();
VehicleTypeOverall types = this.vehicle.VehicleActualTypeOverall;
string typesString = types.GetDescription();
CategoryLabel.Text = "Category: " + categoryString + "/" + currentVehicleCategory.Name + "/" + typesString;
SeasonPassExclusiveLabel.Text = "Season pass exclusive: " + (this.vehicle.SeasonPassExclusive ? "Yes" : "No");
HasBeenPurchasedSwitch.Toggled += Switch_Toggled;
}
public void ReturnCorrectVehicleRate_When_VehicleCatCIsPassed(VehicleCategory vehicleCategory)
{
var expectedResult = new VehicleRatesModel
{
DayLightRates = 12,
NightlyRates = 8
};
VehicleRatesModel actualResult = _vehicleRatesService.GetRatesByVehicleCategory(vehicleCategory);
Assert.AreEqual(expectedResult.DayLightRates, actualResult.DayLightRates);
Assert.AreEqual(expectedResult.NightlyRates, actualResult.NightlyRates);
}
/// <summary>
/// Delete Vehicle Category by id
/// </summary>
public void DeleteVehicleCategory(long vehicleCategoryId)
{
VehicleCategory dbversion = vehicleCategoryRepository.Find((int)vehicleCategoryId);
ValidateBeforeDeletion(vehicleCategoryId);
if (dbversion == null)
{
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture,
"Vehicle Category with Id {0} not found!", vehicleCategoryId));
}
vehicleCategoryRepository.Delete(dbversion);
vehicleCategoryRepository.SaveChanges();
}
// update category button work
private void btnupdatecategorydetails_Click(object sender, EventArgs e)
{
try
{
if (txtboxdetailcategory.Text.ToString() == "")
{
RadMessageBox.Show("Enter Required Fields");
return;
}
else if (txtboxcatid.Text.ToString() == "")
{
RadMessageBox.Show("Please Select the Cell with Data");
return;
}
VehicleCategory vehicleCategory = new VehicleCategory()
{
VehicleCategoryId = Convert.ToInt32(txtboxcatid.Text.ToString()),
Name = txtboxdetailcategory.Text.ToString().ToUpper()
};
if (new VehicelCategoryBusiness().UpdateVehicleCategory(vehicleCategory))
{
RadMessageBox.Show("updated");
txtboxdetailcategory.Clear();
btnupdatecategorydetails.Enabled = false;
btndltcategorydetails.Enabled = false;
comboboxdataInitialize();
}
else
{
RadMessageBox.Show("Failed");
}
}
catch (Exception exception)
{
if (!File.Exists(logpath))
{
File.Create(logpath).Dispose();
using (TextWriter textWriter = new StreamWriter(logpath))
{
textWriter.WriteLine("Update Vehicle Category Error:" + exception.Message);
}
}
else if (File.Exists(logpath))
{
using (TextWriter textWriter = new StreamWriter(logpath))
{
textWriter.WriteLine("Update Vehicle Category Error:" + exception.Message);
}
}
}
}
// GET: VehicleCategories/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
VehicleCategory vehicleCategory = db.VehicleCategories.Find(id);
if (vehicleCategory == null)
{
return(HttpNotFound());
}
return(View(vehicleCategory));
}
/// <summary>
/// Initializes a new instance of the <see cref="VehicleModelInfo" /> class.
/// </summary>
private VehicleModelInfo(int type, string name, VehicleCategory category)
: this()
{
Type = (VehicleModelType) type;
Name = name;
Category = category;
}
