/// <summary>
/// A Method to delete the car asynchronously.
/// </summary>
/// <returns></returns>
private async Task DeleteCarAsync()
{
using (var a9 = new Asphalt9Entities())
{
using (var transaction = a9.Database.BeginTransaction())
{
try
{
// Finding the requested car from entities.
var carToDelete = a9.Grandes
.FirstOrDefault(item => string.Concat(item.Brand, " ", item.CarName).Equals(Car.FullName));
var imgName = carToDelete?.CarImage;
if (carToDelete != null)
{
// Deleting the car asynchronously.
await DeleteCarAsync(a9, carToDelete, transaction);
// Removing the car from car collection as well as empty the car property.
var currentDispatcher = Application.Current.Dispatcher;
currentDispatcher?.Invoke(() =>
{
if (Car == null)
{
return;
}
CarCollection.Remove(Car);
_car = new Car();
RaisePropertyChanged(nameof(Car));
});
// Notifying that the operation succeeded.
Status = $"{carToDelete.Brand} {carToDelete.CarName} Has Been Deleted Successfully.";
// Avoiding "The Image used by another process" warning issue.
// Not good practice but anyway.
GC.Collect();
GC.WaitForPendingFinalizers();
// Deleting the car image from app images directory.
if (FileHelpers.IsImageExist(imgName))
{
File.Delete(FileHelpers.ImagePath(imgName));
}
}
}
catch
{
// Rolling back adding the car in case an error occurred.
transaction.Rollback();
Status = @"Error occurred while deleting the car!";
}
}
}
}
/// <summary>
/// Check whether the car can be updated.
/// </summary>
/// <param name="sender"></param>
/// <returns></returns>
private bool CanSubmit(object sender)
{
using (var a9 = new Asphalt9Entities())
{
var carToDelete =
a9.Grandes
.SingleOrDefault(item => string.Concat(item.Brand, " ", item.CarName)
.Equals(Car.FullName));
return((carToDelete != null) ? true : false);
}
}
/// <summary>
/// Removing the car from database.
/// </summary>
/// <param name="a9">Asphalt9Entities</param>
/// <param name="carToDelete">Car to delete.</param>
/// <param name="transaction">Transaction.</param>
/// <returns></returns>
private async Task DeleteCarAsync(Asphalt9Entities a9, Grande carToDelete, DbContextTransaction transaction)
{
await Task.Run(() =>
{
// Removing the entity related to the requested car to delete.
a9.Grandes.Remove(carToDelete);
// saving changes.
a9.SaveChanges();
// committing the saved changes into the database.
transaction.Commit();
});
}
/// <summary>
/// Updating the car asynchronously.
/// </summary>
/// <returns></returns>
private async Task ProcessingUpdateAsync()
{
using (var a9 = new Asphalt9Entities())
{
using (var transaction = a9.Database.BeginTransaction())
{
try
{
// Updating the car.
await UpdateCarAsync(a9, Car.FullName);
// Saving the update.
a9.SaveChanges();
// committing the saved changes into the database.
transaction.Commit();
// Saving the input image to app image directory.
if (!FileHelpers.IsImageExist(ImageName))
{
var encoder = new PngBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(CarImage));
var imagePath = FileHelpers.ImagePath(imageName: ImageName);
using (var fileStream = new FileStream(imagePath, FileMode.Create))
{
encoder.Save(fileStream);
}
}
Status = $"{Car.FullName} Has been updated successfully.";
}
catch
{
// Rolling back adding the car in case an error occurred.
transaction.Rollback();
Status = @"Error occurred while updating the car!";
}
}
}
}
/// <summary>
/// Replacing the old properties with new ones.
/// </summary>
/// <param name="a9">Asphalt 9 Entity</param>
/// <param name="CarName">Car name</param>
/// <returns></returns>
private async Task UpdateCarAsync(Asphalt9Entities a9, string CarName)
{
var carToUpdate =
a9.Grandes
.FirstOrDefault(item =>
string.Concat(item.Brand, " ", item.CarName)
.Equals(CarName));
await Task.Run(() =>
{
// Updating Car Information
carToUpdate.Brand = Car.CarBrand;
carToUpdate.CarName = Car.CarName;
carToUpdate.CarClass = Car.CarClass;
carToUpdate.CarType = Car.Type;
carToUpdate.Fuel = Car.Fuel;
carToUpdate.Refill = Car.Refill;
carToUpdate.ReleaseDate = Car.ReleaseDate;
// Updating Max Stats
carToUpdate.MaxDetail.TopSpeed = Car.Performance.MaxTopSpeed;
carToUpdate.MaxDetail.Acceleration = Car.Performance.MaxAcceleration;
carToUpdate.MaxDetail.Handling = Car.Performance.MaxHandling;
carToUpdate.MaxDetail.Nitro = Car.Performance.MaxNitro;
// Updating Stock Stats
carToUpdate.StockDetail.TopSpeed = Car.Performance.StockTopSpeed;
carToUpdate.StockDetail.Acceleration = Car.Performance.StockAcceleration;
carToUpdate.StockDetail.Handling = Car.Performance.StockHandling;
carToUpdate.StockDetail.Nitro = Car.Performance.StockNitro;
// Updating Ranks
carToUpdate.StarRank.FirstStarRank = Car.Ranks.FirstStar;
carToUpdate.StarRank.SecondStarRank = Car.Ranks.SecondStar;
carToUpdate.StarRank.ThirdStarRank = Car.Ranks.ThirdStar;
carToUpdate.StarRank.FourthStarRank = Car.Ranks.FourthStar;
carToUpdate.StarRank.FifthStarRank = Car.Ranks.FifthStar;
carToUpdate.StarRank.SixthStarRank = Car.Ranks.SixthStar;
carToUpdate.StarRank.Max = Car.Ranks.Max;
// Updating Blueprints
carToUpdate.Blueprint.FirstStarBP = Car.Blueprints.FirstStar;
carToUpdate.Blueprint.SecondStarBP = Car.Blueprints.SecondStar;
carToUpdate.Blueprint.ThirdStarBP = Car.Blueprints.ThirdStar;
carToUpdate.Blueprint.FourthStarBP = Car.Blueprints.FourthStar;
carToUpdate.Blueprint.FifthStarBP = Car.Blueprints.FifthStar;
carToUpdate.Blueprint.SixthStarBP = Car.Blueprints.SixthStar;
// Updating Upgrades
carToUpdate.Upgrade.Stage1 = Car.Upgrades.Stage0;
carToUpdate.Upgrade.Stage2 = Car.Upgrades.Stage1;
carToUpdate.Upgrade.Stage3 = Car.Upgrades.Stage2;
carToUpdate.Upgrade.Stage4 = Car.Upgrades.Stage3;
carToUpdate.Upgrade.Stage5 = Car.Upgrades.Stage4;
carToUpdate.Upgrade.Stage6 = Car.Upgrades.Stage5;
carToUpdate.Upgrade.Stage7 = Car.Upgrades.Stage6;
carToUpdate.Upgrade.Stage8 = Car.Upgrades.Stage7;
carToUpdate.Upgrade.Stage9 = Car.Upgrades.Stage8;
carToUpdate.Upgrade.Stage10 = Car.Upgrades.Stage9;
carToUpdate.Upgrade.Stage11 = Car.Upgrades.Stage10;
carToUpdate.Upgrade.Stage12 = Car.Upgrades.Stage11;
carToUpdate.Upgrade.Stage13 = Car.Upgrades.Stage12;
carToUpdate.Upgrade.Total = Car.Upgrades.TotalStagesCost;
// Updating Uncommon Parts
carToUpdate.UncommonPart.Quantity = Car.AdditionalParts.UncommonQuantity;
carToUpdate.UncommonPart.Cost = Car.AdditionalParts.UncommonCost;
carToUpdate.UncommonPart.TotalCost = Car.AdditionalParts.UncommonTotalCost;
// Updating Rare Parts
carToUpdate.RarePart.Quantity = Car.AdditionalParts.RareQuantity;
carToUpdate.RarePart.Cost = Car.AdditionalParts.RareCost;
carToUpdate.RarePart.TotalCost = Car.AdditionalParts.RareTotalCost;
// Updating Epic Parts
carToUpdate.EpicPart.Quantity = Car.AdditionalParts.EpicQuantity;
carToUpdate.EpicPart.Cost = Car.AdditionalParts.EpicCost;
carToUpdate.EpicPart.TotalCost = Car.AdditionalParts.EpicTotalCost;
});
}
/// <summary>
/// Adding the new car asynchronously.
/// </summary>
/// <returns></returns>
private async Task AddCarAsync()
{
using (var a9 = new Asphalt9Entities())
{
using (var transaction = a9.Database.BeginTransaction())
{
try
{
// creating new entity with the given car information by the user.
var newCar = new Grande
{
Brand = Car.CarBrand,
CarName = Car.CarName,
CarClass = Car.CarClass,
CarType = Enum.Parse(typeof(CarType), Car.Type).ToString(),
Fuel = Car.Fuel,
CarImage = string.Concat(Car.CarClass.ToLower(), "_", ImageName),
Refill = Car.Refill,
ReleaseDate = Car.ReleaseDate,
Stars = Car.Stars,
// every single grande entity has the links with other entities via foreign key created in database.
Blueprint = new Entities.Blueprint()
{
FirstStarBP = Car.Blueprints.FirstStar,
SecondStarBP = Car.Blueprints.SecondStar,
ThirdStarBP = Car.Blueprints.ThirdStar,
FourthStarBP = Car.Blueprints.FourthStar,
FifthStarBP = Car.Blueprints.FifthStar,
SixthStarBP = Car.Blueprints.SixthStar,
TotalBP = Car.Blueprints.Total
},
StockDetail = new StockDetail()
{
TopSpeed = Car.Performance.StockTopSpeed,
Acceleration = Car.Performance.StockAcceleration,
Handling = Car.Performance.StockHandling,
Nitro = Car.Performance.StockNitro,
},
MaxDetail = new MaxDetail()
{
TopSpeed = Car.Performance.MaxTopSpeed,
Acceleration = Car.Performance.MaxAcceleration,
Handling = Car.Performance.MaxHandling,
Nitro = Car.Performance.MaxNitro,
},
StarRank = new StarRank()
{
StockStarRank = Car.Ranks.Stock,
FirstStarRank = Car.Ranks.FirstStar,
SecondStarRank = Car.Ranks.SecondStar,
ThirdStarRank = Car.Ranks.ThirdStar,
FourthStarRank = Car.Ranks.FourthStar,
FifthStarRank = Car.Ranks.FifthStar,
SixthStarRank = Car.Ranks.SixthStar,
Max = Car.Ranks.Max
},
Upgrade = new Upgrade()
{
Stage1 = Car.Upgrades.Stage0,
Stage2 = Car.Upgrades.Stage1,
Stage3 = Car.Upgrades.Stage2,
Stage4 = Car.Upgrades.Stage3,
Stage5 = Car.Upgrades.Stage4,
Stage6 = Car.Upgrades.Stage5,
Stage7 = Car.Upgrades.Stage6,
Stage8 = Car.Upgrades.Stage7,
Stage9 = Car.Upgrades.Stage8,
Stage10 = Car.Upgrades.Stage9,
Stage11 = Car.Upgrades.Stage10,
Stage12 = Car.Upgrades.Stage11,
Stage13 = Car.Upgrades.Stage12,
Total = Car.Upgrades.TotalStagesCost
},
UncommonPart = new UncommonPart()
{
Cost = Car.AdditionalParts.UncommonCost,
Quantity = Car.AdditionalParts.UncommonQuantity,
TotalCost = Car.AdditionalParts.UncommonTotalCost
},
RarePart = new RarePart()
{
Cost = Car.AdditionalParts.RareCost,
Quantity = Car.AdditionalParts.RareQuantity,
TotalCost = Car.AdditionalParts.RareTotalCost
},
EpicPart = new EpicPart()
{
Cost = Car.AdditionalParts.EpicCost,
Quantity = Car.AdditionalParts.EpicQuantity,
TotalCost = Car.AdditionalParts.EpicTotalCost
}
};
// here we check if the current car is new or already exist.
if (a9.Grandes
.Any(item => string.Concat(item.Brand, " ", item.CarName) ==
string.Concat(newCar.Brand, " ", newCar.CarName)))
{
Status = "Another car with same name is already exists!";
return;
}
// Adding new Car
a9.Grandes.Add(newCar);
// saving the addition.
a9.SaveChanges();
// Committing the addition of the new car into the database.
transaction.Commit();
// Saving the image into app image directory.
await Task.Run(() =>
{
var encoder = new PngBitmapEncoder();
encoder.Frames.Add(item: BitmapFrame.Create(source: CarImage));
var imagePath = FileHelpers.ImagePath(imageName: newCar.CarImage);
using (var fileStream = new FileStream(path: imagePath, mode: FileMode.Create))
{
encoder.Save(stream: fileStream);
}
});
// Notifying the state of operation.
Status = $"{newCar.Brand} {newCar.CarName} has been added successfully.";
}
catch
{
// Rolling back adding the car in case an error occurred.
transaction.Rollback();
Status = @"Error occurred while adding the car!";
}
}
}
}
/// <summary>
/// Executing a stored procedure asynchronously to get cars.
/// </summary>
/// <param name="carClass">The Class to get cars.</param>
/// <param name="a9">Asphalt 9 Entity</param>
/// <param name="isClass">is class has been provided or not.</param>
/// <returns>A List of cars depending on whether the class has been specified if yes then the list of specified class
/// if not get all available cars.</returns>
public async Task <List <AddCars_Result> > GettingCarsAsync(string carClass, Asphalt9Entities a9, bool isClass = true)
{
return(await a9.Database.SqlQuery <AddCars_Result>(sql : "EXEC AddCars {0}, {1}", carClass, isClass).ToListAsync());
}
/// <summary>
///
/// </summary>
/// <param name="chapter">Career Chapter</param>
/// <param name="a9">Asphalt 9 Entity</param>
/// <param name="isChapter">is chapter has been provided or not.</param>
/// <returns>A List of career chapters depending on whether the chapter has been specified if yes then the list of specified chapter informations
/// if not get all chapters informations.</returns>
public async Task <List <AddChapters_Result> > GettingCareerAsync(int chapter, Asphalt9Entities a9, bool isChapter = true)
{
return(await a9.Database.SqlQuery <AddChapters_Result>(sql : "EXEC AddChapters {0}, {1}", chapter, isChapter).ToListAsync());
}
/// <summary>
/// Executing a stored procedure asynchronously to get the given car informations.
/// </summary>
/// <param name="carName">Car Name</param>
/// <param name="a9">Asphalt 9 Entity</param>
/// <returns>A Task of all informations required for a specific car.</returns>
public async Task <AddCar_Result> GettingCarAsync(string carName, Asphalt9Entities a9)
{
return(await a9.Database.SqlQuery <AddCar_Result>(sql : "EXEC AddCar {0}", carName).FirstOrDefaultAsync());
}
