public ActionResult Edit(BikeModel bkm)
{
//Retrieve the Holiday, we are supposed to Edit and Send it on the same create Page
//We will use SQL Reader to get the Holiday List from DB
SqlCommand BikeList = new SqlCommand("UPDATE Bikes SET BikeName=@BikeName, BikeDetails=@BikeDetails where BikeID=@BikeID", traincoreCon);
BikeList.Parameters.AddWithValue("@BikeID", bkm.BikeID);
BikeList.Parameters.AddWithValue("@BikeName", bkm.BikeName);
BikeList.Parameters.AddWithValue("@BikeDetails", bkm.BikeDetails);
try
{
traincoreCon.Open();
BikeList.Connection = traincoreCon;
int result = BikeList.ExecuteNonQuery();
ViewBag.Feedback = "The record updated successfully";
}
catch (SqlException ex)
{
ViewBag.Feedback = $"{ex.ErrorCode}, {ex.Message} occurred";
}
catch (Exception ex)
{
ViewBag.Feedback = $"{ex.Message} occurred";
}
finally
{
if (BikeList.Connection.State == ConnectionState.Open)
{
traincoreCon.Close();
}
}
return(View("~/Areas/admin/Views/Bikes/Edit.cshtml"));
}
public ActionResult DeleteConfirmed(int id)
{
BikeModel bikeModel = db.bikeRepository.findBike(id);
db.bikeRepository.delete(bikeModel);
return(RedirectToAction("Index"));
}
public ActionResult Delete(int BikeID, bool?Confirm)
{
BikeModel bm = new BikeModel();
if (Confirm == true)
{
SqlCommand cmd = new SqlCommand("Delete From Bikes where Bikeid=@BikeID");
cmd.Parameters.Add("@BikeID", SqlDbType.Int).Value = BikeID;
cmd.Connection = traincoreCon;
try
{
traincoreCon.Open();
cmd.ExecuteNonQuery();
ViewBag.Feedback = $"Item with {BikeID} deleted";
}
catch (SqlException ex)
{ ViewBag.Feedback = $"{ex.ErrorCode}, {ex.Message} occurred"; }
catch (Exception ex)
{ ViewBag.Feedback = $"{ex.Message} occurred"; }
finally
{
if (cmd.Connection.State == ConnectionState.Open)
{
traincoreCon.Close();
}
}
}
else
{
bm.BikeID = BikeID;
}
return(View("~/Areas/admin/Views/Bikes/Delete.cshtml", bm));
}
public async Task EMICalculate_PositiveTestcase()
{
Mock <IModelManager> mockObject = new Mock <IModelManager>();
mockObject.Setup(x => x.CalculateEmi(It.IsAny <double>(), It.IsAny <int>())).Returns(1234.56);
BikeModel bikeModel = new BikeModel
{
BrandName = "",
BikeName = "herohonda",
BikePrice = 1234567,
DiscBrakes = 2,
BikeCC = 120,
Milage = 35
};
mockObject.Setup(x => x.GetBikeDetails(It.IsAny <int>())).ReturnsAsync(bikeModel);
CustomerController customerController = new CustomerController(mockObject.Object);
customerController.TempData["id"] = 2;
var response = await customerController.EMICalculate(2);
var result = response as RedirectToRouteResult;
Assert.IsInstanceOfType(result, typeof(RedirectToRouteResult));
Assert.AreEqual(1234.56, customerController.TempData["EMI"]);
Assert.AreEqual(result.RouteValues["action"], "PurchaseByEMI");
}
public async Task <ActionResult> PurchaseEMI()
{
int bikeId = (int)TempData["id"];
int months = (int)TempData["Months"];
var customerModel = await _modelManager.GetCustomer(User.Identity.Name);
BikeModel bikeModel = await _modelManager.GetBikeDetails(bikeId);
double emi = _modelManager.CalculateEmi(bikeModel.BikePrice, months);
TransactionModel transactionModel = new TransactionModel
{
CustomerId = customerModel.CustomerId,
BikeId = bikeId,
BikePrice = bikeModel.BikePrice,
EMIMonths = months,
EMI = emi
};
ViewBag.Customer = customerModel;
ViewBag.EMI = emi;
ViewBag.Months = months;
await _modelManager.AddTransaction(transactionModel);
return(View(bikeModel));
}
public void DeleteBike(BikeModel bikeModel)
{
if (bikeModel is null)
{
throw new ArgumentNullException(nameof(bikeModel));
}
_context.Bikes.Remove(bikeModel);
}
public void AddBike(BikeModel bike)
{
if (bike is null)
{
throw new ArgumentNullException(nameof(bike));
}
_context.Bikes.Add(bike);
}
public ActionResult Edit([Bind(Include = "ID,BikeModelName,Mark,Price")] BikeModel bikeModel)
{
if (ModelState.IsValid)
{
db.bikeRepository.update(bikeModel);
return(RedirectToAction("Index"));
}
return(View(bikeModel));
}
private IList <BikeModel> init()
{
IList <BikeModel> bikes = new List <BikeModel>();
for (int i = 0; i < 10; i++)
{
bikes.Add(BikeModel.build());
}
return(bikes);
}
public async Task AddBike_PositiveTest()
{
BikeModel bikeModel = new BikeModel();
Mock <IModelManager> mockObject = new Mock <IModelManager>();
mockObject.Setup(x => x.AddBike(bikeModel));
var api = new AdminController(mockObject.Object);
var res = (RedirectToRouteResult)await api.AddBike(bikeModel);
Assert.AreEqual(res.RouteValues["action"], "AddBike");
}
public async Task <ActionResult> EMICalculate(int months)
{
int bikeId = (int)TempData["id"];
BikeModel bikeModel = await _modelManager.GetBikeDetails(bikeId);
double emi = _modelManager.CalculateEmi(bikeModel.BikePrice, months);
TempData["Months"] = months;
TempData["EMI"] = emi;
return(RedirectToAction("PurchaseByEMI", new { bikeId = bikeId }));
}
public bool delete(BikeModel bike)
{
foreach (BikeModel bikee in _bikes)
{
if (bike.ID == bikee.ID)
{
_bikes.Remove(bike);
return(true);
}
}
return(false);
}
public async Task <ActionResult> AddBike(BikeModel bikeModel)
{
if (bikeModel != null)
{
await _modelManager.AddBike(bikeModel);
TempData["message"] = "Bike Added!!!";
return(RedirectToAction("AddBike"));
}
else
{
return(View("null"));
}
}
public async Task DeleteBike_NegativeTest()
{
BikeModel bikeModel = new BikeModel();
bikeModel.BikeId = -1;
Mock <IModelManager> mockObject = new Mock <IModelManager>();
AdminController adminController = new AdminController(mockObject.Object);
mockObject.Setup(x => x.DeleteBike(-1));
var status = adminController.DeleteBike(-1);
var res = (RedirectToRouteResult)await adminController.DeleteBike(0);
Assert.AreNotEqual(res.RouteValues["action"], "GetBike");
}
// GET: BikeModels/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
BikeModel bikeModel = db.bikeRepository.findBike(id);
if (bikeModel == null)
{
return(HttpNotFound());
}
return(View(bikeModel));
}
public async Task UpdateBike_NullTest()
{
int id = 1;
BikeModel bikeModel = new BikeModel();
bikeModel = null;
Mock <IModelManager> mockObject = new Mock <IModelManager>();
mockObject.Setup(x => x.GetUpdate(id)).ReturnsAsync(bikeModel);
AdminController adminController = new AdminController(mockObject.Object);
var actionResult = adminController.UpdateBike(id);
var Bikes = (RedirectToRouteResult)await actionResult;
Assert.AreEqual(Bikes.RouteValues["action"], "GetBikes");
}
public void OnModelUpdate(BikeModel model)
{
this.cadence = model.cadence;
this.wattsPerHour = model.wattsPerHour;
speedController.SetSpeedInKmh(model.speed);
heartBeatController.SetHeartRate(model.heartRate);
// test if idle state ?
/*
* heartBeatController.SetHeartRate(0);
* speedController.SetSpeedInKmh(0);
* cadenceText.text = "...";
* powerText.text = "...";
*/
}
public IList <BikeModel> update(BikeModel bike)
{
foreach (BikeModel bikee in _bikes)
{
if (bikee.ID == bike.ID)
{
bikee.ID = bike.ID;
bikee.Mark = bike.Mark;
bikee.Price = bike.Price;
bikee.BikeModelName = bike.BikeModelName;
bikee.Type = bike.Type;
return(_bikes);
}
}
return(_bikes);
}
public async Task <IHttpActionResult> ApproveBikeModel(int id)
{
BikeModel mobile = await db.BikeModels.FindAsync(id);
if (mobile == null)
{
return(NotFound());
}
if (mobile.status == "a")
{
return(BadRequest("Already approved"));
}
mobile.status = "a";
await db.SaveChangesAsync();
return(Ok("approved"));
}
public IActionResult AddBike([FromBody] BikeModel bm)
{
//TODO: Добавить кол-во великов
Station st = appCtx.Stations.FirstOrDefault(s => s.Id == bm.StationId);
if (st != null)
{
Bike bk = new Bike {
StationId = bm.StationId, Station = st
};
appCtx.Bikes.Add(bk);
appCtx.SaveChanges();
return(Ok());
}
return(BadRequest(new { errorText = "Invalid StationId" }));
}
public async Task AddBike_NullTest()
{
BikeModel bikeModel = new BikeModel()
{
BikeName = "Hero"
};
Mock <IModelManager> mockObject = new Mock <IModelManager>();
bikeModel = null;
mockObject.Setup(x => x.AddBike(bikeModel));
var api = new AdminController(mockObject.Object);
var res = api.AddBike(bikeModel);
var response = await res as ViewResult;
Assert.AreEqual(response.ViewName, "null");
}
public async Task CustomerChoice_PositiveTest()
{
BikeModel bikeModel = new BikeModel()
{
BikeName = "herohonda",
BikePrice = 1234567,
DiscBrakes = 2,
BikeCC = 120,
Milage = 35
};
BrandModel brandModel = new BrandModel()
{
BrandName = "hero"
};
Mock <IModelManager> mockObject = new Mock <IModelManager>();
mockObject.Setup(x => x.CustomerChoice(brandModel.BrandName)).ReturnsAsync(new List <BikeModel>()
{
new BikeModel
{
BikeName = "herohonda",
BikePrice = 1234567,
DiscBrakes = 2,
BikeCC = 120,
Milage = 35
}
});
CustomerController customerController = new CustomerController(mockObject.Object);
var actionResult = await customerController.CustomerChoice(brandModel.BrandName) as ViewResult;
var models = (IEnumerable <BikeModel>)actionResult.Model;
foreach (BikeModel item in models)
{
Assert.AreEqual(item.BikeId, bikeModel.BikeId);
Assert.AreEqual(item.BikeName, bikeModel.BikeName);
Assert.AreEqual(item.BikeCC, bikeModel.BikeCC);
Assert.AreEqual(item.BikePrice, bikeModel.BikePrice);
Assert.AreEqual(item.DiscBrakes, bikeModel.DiscBrakes);
Assert.AreEqual(item.Milage, bikeModel.Milage);
}
}
public async Task <ActionResult> UpdateBike(int BikeId)
{
if (BikeId != 0)
{
BikeModel bikeModel = await _modelManager.GetUpdate(BikeId);
if (bikeModel == null)
{
return(RedirectToAction("GetBikes"));
}
else
{
return(View(bikeModel));
}
}
else
{
return(RedirectToAction("GetBikes"));
}
}
public async Task <ActionResult> FullPurchase(int bikeId)
{
BikeModel bikeModel = await _modelManager.GetBikeDetails(bikeId);
var customerModel = await _modelManager.GetCustomer(User.Identity.Name);
TransactionModel transactionModel = new TransactionModel
{
CustomerId = customerModel.CustomerId,
BikeId = bikeId,
BikePrice = bikeModel.BikePrice
};
// TempData.Keep("CustumerId");
ViewBag.Customer = customerModel;
ViewBag.transc = bikeModel;
await _modelManager.AddTransaction(transactionModel);
return(View());
}
public async Task UpdateBike_NegativeTest()
{
int id = 0;
BikeModel bikeModel = new BikeModel
{
BikeId = 1,
BikeName = "HeroPro",
BikeCC = 110,
Milage = 40,
BikePrice = 23568
};
Mock <IModelManager> mockObject = new Mock <IModelManager>();
mockObject.Setup(x => x.GetUpdate(id)).ReturnsAsync(bikeModel);
AdminController adminController = new AdminController(mockObject.Object);
var actionResult = adminController.UpdateBike(id);
var Bikes = (RedirectToRouteResult)await actionResult;
Assert.AreEqual(Bikes.RouteValues["action"], "GetBikes");
}
public async Task <IHttpActionResult> UpdateBikeModel(BikeModel mob)
{
if (User.Identity.IsAuthenticated)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
mob.addedBy = User.Identity.GetUserId();
mob.time = DateTime.UtcNow;
mob.status = "a";
try
{
db.Entry(mob).State = EntityState.Modified;
}
catch (Exception e)
{
string s = e.ToString();
}
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 ActionResult List()
{
List <BikeModel> bl = new List <BikeModel>();
SqlCommand Holidays = new SqlCommand("Select * from Bikes", traincoreCon);
try
{
traincoreCon.Open();
Holidays.Connection = traincoreCon;
SqlDataReader rdr = Holidays.ExecuteReader();
while (rdr.Read())
{
BikeModel Bik = new BikeModel();
Bik.BikeID = (int)rdr["BikeID"];
Bik.BikeName = rdr["BikeName"].ToString();
Bik.BikeDetails = rdr["BikeDetails"].ToString();
bl.Add(Bik);
}
}
catch (SqlException ex)
{
ViewBag.Feedback = $"{ex.ErrorCode}, {ex.Message} occurred";
}
catch (Exception ex)
{
ViewBag.Feedback = $"{ex.Message} occurred";
}
finally
{
if (Holidays.Connection.State == ConnectionState.Open)
{
traincoreCon.Close();
}
}
return(View("~/Areas/admin/Views/Bikes/Index.cshtml", bl));
}
public async Task <IHttpActionResult> DeleteBikeModel(int id)
{
if (User.Identity.IsAuthenticated)
{
BikeModel bid = await db.BikeModels.FindAsync(id);
if (bid == null)
{
return(NotFound());
}
db.BikeModels.Remove(bid);
var ads = db.Ads.Where(x => x.BikeAd.BikeModel1.Id.Equals(id));
foreach (var ad in ads)
{
db.Ads.Remove(ad);
}
await db.SaveChangesAsync();
return(Ok(bid));
}
return(BadRequest());
}
public ActionResult Edit(int BikeID)
{
//Retrieve the Holiday, we are supposed to Edit and Send it on the same create Page
//We will use SQL Reader to get the Holiday List from DB
SqlCommand listHolidayList = new SqlCommand("Select * from Bikes where BikeID=@BikeID", traincoreCon);
listHolidayList.Parameters.AddWithValue("@BikeID", BikeID);
BikeModel bm = new BikeModel();
try
{
traincoreCon.Open();
listHolidayList.Connection = traincoreCon;
SqlDataReader rdr = listHolidayList.ExecuteReader();
while (rdr.Read())
{
bm.BikeID = (int)rdr["BikeID"];
bm.BikeName = rdr["BikeName"].ToString();
bm.BikeDetails = rdr["BikeDetails"].ToString();
}
}
catch (SqlException ex)
{
ViewBag.Feedback = $"{ex.ErrorCode}, {ex.Message} occurred";
}
catch (Exception ex)
{
ViewBag.Feedback = $"{ex.Message} occurred";
}
finally
{
if (listHolidayList.Connection.State == ConnectionState.Open)
{
traincoreCon.Close();
}
}
return(View("~/Areas/admin/Views/Bikes/Edit.cshtml", bm));
}
public async Task GetBike_NegativeTest()
{
BikeModel bikeModel = new BikeModel()
{
BikeId = 1,
BikeName = "HeroPro",
BikeCC = 110,
Milage = 40,
BikePrice = 23568
};
Mock <IModelManager> mockObject = new Mock <IModelManager>();
mockObject.Setup(x => x.GetBike()).ReturnsAsync(new List <BikeModel>()
{
new BikeModel
{
BikeId = 1,
BikeName = "HeroPro",
BikeCC = 110,
Milage = 40,
BikePrice = 23568
},
new BikeModel
{
BikeId = 2,
BikeName = "HeroPr",
BikeCC = 120,
Milage = 40,
BikePrice = 23568
}
});
AdminController adminController = new AdminController(mockObject.Object);
var responce = await adminController.GetBike() as ViewResult;
var list = responce.Model as List <BikeModel>;
Assert.AreNotEqual(list.Count, 1);
}
