internal async Task <Tuple <Status, string> > AddVehicle(PublicVehicleViewModel model)
{
int makeId = dBase.Vehicle_Makes.FirstOrDefault(make => make.Make_Name == model.Make).Make_ID;
Vehicle added = dBase.Vehicles.Add(new Vehicle()
{
Vehicle_ID = model.Vehicle_ID,
Available = true,
Rentable = true,
Mileage = model.Mileage,
Vehicle_Type_ID = dBase.Vehicle_Types.FirstOrDefault(carModel => carModel.Make_ID == makeId).Vehicle_Type_ID,
//Create FrontEnd User Selection & Change Default Branch insertion
Branch_ID = 1
});
if (added != null)
{
await dBase.SaveChangesAsync();
return(new Tuple <Status, string>(Status.Success, $"{model.Make} Successfully Added !"));
}
else
{
return(new Tuple <Status, string>(Status.Failure, "Something Went Wrong !!!"));
}
}
public bool EmptyViewModelCheck(PublicVehicleViewModel queryVehicle)
{
if ((queryVehicle.Gear_Type == null || queryVehicle.Gear_Type == "") && queryVehicle.Year == 0 && queryVehicle.Make == "" && queryVehicle.Model == "")
{
return(true);
}
return(false);
}
/// <summary>
/// Compare The Search Conditions And Text To Set Entity
/// </summary>
/// <param name="srchText"></param>
/// <param name="car"></param>
/// <param name="model"></param>
/// <returns>boolean</returns>
private bool PublicSearchParameters(string srchText, Vehicle car, PublicVehicleViewModel model)
{
if (srchText == null)
{
srchText = "";
}
//bool condition1 = AvailableAndRentable(car);
//if (!condition1) { return false; }
bool condition2 = GearMatches(car.Vehicle_Types.Gear_Type, model.Gear_Type);
if (!condition2)
{
return(false);
}
bool condition3 = YearMatches(car.Vehicle_Types.Year, model.Year);
if (!condition3)
{
return(false);
}
bool condition4 = MakeMatches(car.Vehicle_Types.Vehicle_Makes.Make_Name, model.Make);
if (!condition4)
{
return(false);
}
bool condition5 = ModelMatches(car.Vehicle_Types.Vehicle_Models.Model_Name, model.Model);
if (!condition5)
{
return(false);
}
bool condition6 = TextMatchesMakeOrModel(srchText, car.Vehicle_Types.Vehicle_Makes.Make_Name, car.Vehicle_Types.Vehicle_Models.Model_Name);
if (!condition6)
{
return(false);
}
if (/*condition1 &&*/ condition2 && condition3 && condition4 && condition5 && condition6)
{
return(true);
}
return(false);
}
public async Task <IHttpActionResult> TryDeleteType(string type)
{
PublicVehicleViewModel model = JsonConvert.DeserializeObject <PublicVehicleViewModel>(type);
Tuple <Status, string> responce = await store.TryDeleteType(model);
if (responce.Item1 == Status.Success)
{
return(Content(HttpStatusCode.OK, responce.Item2));
}
else
{
return(Content(HttpStatusCode.NotAcceptable, responce.Item2));
}
}
private bool checkRentals(PublicVehicleViewModel vehicleModel, RentalModel _dates)
{
IQueryable <Rental> lst = dBase.Rentals.Where(id => id.Vehicle_ID == vehicleModel.Vehicle_ID);
if (lst != null)
{
foreach (Rental item in lst)
{
if (_dates.Start_Date < item.Start_Date && _dates.Return_Date < item.Start_Date && item.Returned_Date != null)
{
return(false);
}
}
}
return(true);
}
internal async Task <PublicVehicleViewModel> GetVehicleByID(int id)
{
PublicVehicleViewModel car = new PublicVehicleViewModel();
await Task.Run(() =>
{
var vehicle = ConvertDBModelToViewModel(dBase.Vehicles.FirstOrDefault(x => x.Vehicle_ID == id));
car = vehicle;
});
if (car != null)
{
return(car);
}
else
{
return(null);
}
}
public async Task <IHttpActionResult> AddVehicle(PublicVehicleViewModel model)
{
if (model.Mileage != 0 && model.Vehicle_ID != 0)
{
Tuple <Status, string> responce = await store.AddVehicle(model);
if (responce.Item1 == Status.Success)
{
return(Content(HttpStatusCode.OK, responce.Item2));
}
else
{
return(Content(HttpStatusCode.NotAcceptable, responce.Item2));
}
}
else
{
return(Content(HttpStatusCode.Forbidden, "Please Fill Valid Details"));
}
}
internal async Task <Tuple <PublicVehicleViewModel, VehicleStateModel> > GetVehicleWithStateByID(int id)
{
PublicVehicleViewModel car = new PublicVehicleViewModel();
Vehicle vhcle = new Vehicle();
await Task.Run(() =>
{
vhcle = dBase.Vehicles.FirstOrDefault(x => x.Vehicle_ID == id);
car = ConvertDBModelToViewModel(vhcle);
});
if (car != null)
{
return(new Tuple <PublicVehicleViewModel, VehicleStateModel>(car, new VehicleStateModel()
{
Available = vhcle.Available, Rentable = vhcle.Rentable
}));
}
else
{
return(null);
}
}
internal async Task <Tuple <Status, string> > TryDeleteType(PublicVehicleViewModel model)
{
Vehicle_Types chosenType = dBase.Vehicle_Types.FirstOrDefault(type =>
(
type.Vehicle_Models.Model_Name == model.Model &&
type.Vehicle_Makes.Make_Name == model.Make &&
type.Year == model.Year &&
type.Gear_Type == model.Gear_Type
));
int typeId = chosenType.Vehicle_Type_ID;
bool vehicles = false,
rentals = false;
if (dBase.Vehicles.FirstOrDefault(carModel => carModel.Vehicle_Types.Vehicle_Type_ID == typeId) != null)
{
vehicles = true;
}
if (dBase.Rentals.FirstOrDefault(carModel => carModel.Vehicle.Vehicle_Type_ID == typeId) != null)
{
rentals = true;
}
if (vehicles || rentals)
{
string error = concatErrorString(vehicles, rentals);
return(new Tuple <Status, string>(Status.Failure, error));
}
else
{
dBase.Vehicle_Types.Remove(chosenType);
await dBase.SaveChangesAsync();
return(new Tuple <Status, string>(Status.Success, model + " Deleted"));
}
}
