public static void Merge(int checkpointId)
{
using (var context = new Entities())
{
var timestamps = context.Runtimes.Where(runtime => runtime.CheckpointID == checkpointId && !runtime.IsDeleted).OrderBy(runtime => runtime.Runtime1).ToList();
var startnumbers = context.CheckpointOrders.Where(startnumber => startnumber.CheckpointID == checkpointId && !startnumber.IsDeleted).OrderBy(startnumber => startnumber.OrderNumber).ToList();
var raceintermediates = context.RaceIntermediates.Where(intermediate => intermediate.CheckpointID == checkpointId).ToList();
//Removes exicting entries in the database
foreach (var intermediate in raceintermediates)
{
context.DeleteObject(intermediate);
}
context.SaveChanges();
//Creates new entries
int i = 0;
foreach (var timestamp in timestamps)
{
if (startnumbers.Count < i + 1)
break;
Merge(checkpointId, startnumbers[i].ID, timestamp.RuntimeID);
i++;
}
}
var checkpoint = CheckpointModel.getById(checkpointId);
RaceIntermediateModel.MergeAthletes(checkpoint.RaceId.Value);
}
/// <summary>
/// Deletes the runtime.
/// </summary>
/// <param name="runtimeid">The runtimeid.</param>
public static void DeleteRuntime(int runtimeid)
{
using (var ctx = new Entities())
{
var runtimeToDelete = ctx.Runtimes.Where(runt => runt.RuntimeID == runtimeid).Single();
runtimeToDelete.IsDeleted = true;
ctx.SaveChanges();
}
}
/// <summary>
/// Deletes the raceintermediate.
/// </summary>
/// <param name="cpid">The cpid.</param>
/// <param name="cpOrderid">The cp orderid.</param>
public static void DeleteRaceintermediate(int cpid, int cpOrderid)
{
using (var context = new Entities())
{
var raceintermediateToDelete = context.RaceIntermediates.Where(raceintermediate => raceintermediate.CheckpointID == cpid && raceintermediate.CheckpointOrderID == cpOrderid).SingleOrDefault();
//raceintermediateToDelete.IsDeleted = true;
RuntimeModel.DeleteRuntime(raceintermediateToDelete.RuntimeId);
CheckpointOrderModel.DeleteCheckpointOrder(raceintermediateToDelete.CheckpointOrderID);
context.DeleteObject(raceintermediateToDelete);
context.SaveChanges();
}
}
public static TimerModel Create()
{
TimerModel timerModel = new TimerModel();
using (var ctx = new Entities())
{
Timer timer = new Timer();
ctx.Timers.AddObject(timer);
ctx.SaveChanges();
timerModel.Id = ctx.Timers.OrderByDescending(tmr => tmr.TimerID).First().TimerID;
}
return timerModel;
}
public static CheckpointOrderModel Create(int checkpointId, int startingNumber, int orderNumber)
{
CheckpointOrderModel checkpointOrderModel = new CheckpointOrderModel();
using (var ctx = new Entities())
{
CheckpointOrder checkpointOrder = new CheckpointOrder();
checkpointOrder.CheckpointID = checkpointId;
checkpointOrder.StartingNumber = startingNumber;
checkpointOrder.StartingNumber = (ctx.CheckpointOrders.OrderByDescending(chkpnt => chkpnt.CheckpointID).First().CheckpointID) + 1;
ctx.CheckpointOrders.AddObject(checkpointOrder);
ctx.SaveChanges();
checkpointOrder.ID = (int)ctx.CheckpointOrders.OrderByDescending(chkpnt => chkpnt.CheckpointID).First().CheckpointID;
}
return checkpointOrderModel;
}
public void Get_Next_OrderNumber_In_Ascending_Order_After_Inserting_StartNumber()
{
CheckpointOrderModel testCheckpointOrder = null;
int ordernum1 = 0, ordernum2 = 0;
int checkpointId = 1;
int startnum1 = 4, startnum2 = 5;
Entities context = new Entities();
Given("We have a CheckpointOrder", () =>
{
testCheckpointOrder = new CheckpointOrderModel();
});
When("We insert start number", () =>
{
using (var ctxTest = new Entities())
{
if (ctxTest.CheckpointOrders.Any(chkpnt => (chkpnt.StartingNumber == startnum1 && chkpnt.CheckpointID == checkpointId)))
{
var checkpointOrderToDelete = ctxTest.CheckpointOrders.Where(checkpointOrder => (checkpointOrder.StartingNumber == startnum1 && checkpointOrder.CheckpointID == checkpointId)).Single();
ctxTest.CheckpointOrders.DeleteObject(checkpointOrderToDelete);
ctxTest.SaveChanges();
}
}
testCheckpointOrder.AddCheckpointOrderDB(checkpointId, startnum1);
ordernum1 = (int)(context.CheckpointOrders.Where(chkpnt => chkpnt.CheckpointID == checkpointId).OrderByDescending(ordnum => ordnum.OrderNumber).First().OrderNumber);
});
Then("We should have next order number in ascending order in database", () =>
{
using (var ctxTest = new Entities())
{
if (ctxTest.CheckpointOrders.Any(chkpnt => (chkpnt.StartingNumber == startnum2 && chkpnt.CheckpointID == checkpointId)))
{
var checkpointOrderToDelete = ctxTest.CheckpointOrders.Where(checkpointOrder => (checkpointOrder.StartingNumber == startnum2 && checkpointOrder.CheckpointID == checkpointId)).Single();
ctxTest.CheckpointOrders.DeleteObject(checkpointOrderToDelete);
ctxTest.SaveChanges();
}
}
testCheckpointOrder.AddCheckpointOrderDB(checkpointId, startnum2);
ordernum2 = (int)(context.CheckpointOrders.Where(chkpnt => chkpnt.CheckpointID == checkpointId).OrderByDescending(ordnum => ordnum.OrderNumber).First().OrderNumber);
ordernum2.ShouldBe(ordernum1 + 1);
});
}
public static bool Delete(this List<RaceIntermediate> intermediates)
{
try
{
using (var context = new Entities())
{
foreach (var intermediate in intermediates)
{
context.DeleteObject(intermediate);
}
context.SaveChanges();
}
return true;
}
catch (Exception)
{
return false;
}
}
public static void EditRuntime(int runtimeid, int h, int m, int s, int ms)
{
TimeSpan ts = new TimeSpan(0, h, m, s, ms);
using (var ctx = new Entities())
{
Runtime runtimeDb = ctx.Runtimes.Single(runtimeTemp => runtimeTemp.RuntimeID == runtimeid);
runtimeDb.Runtime1 = Convert.ToInt32(ts.TotalMilliseconds);
ctx.SaveChanges();
}
}
public void It_Should_Be_Possible_To_Update_A_CheckpointOrder_To_The_Database()
{
CheckpointOrder origCheckpointOrder = new CheckpointOrder();
origCheckpointOrder.CheckpointID = 1;
origCheckpointOrder.StartingNumber = 1;
var id = 0;
var startnumber = 0;
using (var ctxTest = new Entities())
{
if (ctxTest.CheckpointOrders.Any(chkpnt => (chkpnt.StartingNumber == origCheckpointOrder.StartingNumber && chkpnt.CheckpointID == origCheckpointOrder.CheckpointID)))
{
var checkpointOrderToDelete = ctxTest.CheckpointOrders.Where(checkpointOrder => (checkpointOrder.StartingNumber == origCheckpointOrder.StartingNumber && checkpointOrder.CheckpointID == origCheckpointOrder.CheckpointID)).Single();
ctxTest.CheckpointOrders.DeleteObject(checkpointOrderToDelete);
ctxTest.SaveChanges();
}
}
CheckpointOrder updatedCheckpointOrder = origCheckpointOrder;
Given("we have a checkpointOrder", () =>
{
checkpointOrderModel.AddCheckpointOrderDB((int)origCheckpointOrder.CheckpointID, (int)origCheckpointOrder.StartingNumber);
var ctxTest = new Entities();
id = ctxTest.CheckpointOrders.Where(checkpointOrder => (checkpointOrder.StartingNumber == origCheckpointOrder.StartingNumber && checkpointOrder.CheckpointID == origCheckpointOrder.CheckpointID)).Single().ID;
});
When("we update the checkpointOrder", () =>
{
updatedCheckpointOrder.CheckpointID = 1;
updatedCheckpointOrder.StartingNumber = 2;
checkpointOrderModel.UpdateCheckpointOrderDB((int)id, (int)updatedCheckpointOrder.StartingNumber);
var ctxTest = new Entities();
startnumber = (int)(ctxTest.CheckpointOrders.Where(checkpointOrder => (checkpointOrder.StartingNumber == origCheckpointOrder.StartingNumber && checkpointOrder.ID == id)).Single().StartingNumber);
});
Then("the values should be different", () =>
{
updatedCheckpointOrder.StartingNumber.ShouldBe(startnumber);
});
}
private int CreateDbEntity(Entities context)
{
Athlete athlete = new Athlete();
updateProperties(athlete);
context.Athletes.AddObject(athlete);
context.SaveChanges();
return athlete.ID;
}
/// <summary>
/// Deletes the given athlete.
/// </summary>
/// <param name="runtimeid">The runtimeid.</param>
public void DeleteFromDb()
{
using (var ctx = new Entities())
{
var rowToDelete = ctx.Athletes.Where(runt => runt.ID == Id).Single();
ctx.Athletes.DeleteObject(rowToDelete);
ctx.SaveChanges();
}
SetDefaultId();
}
public void ConnectToRace(int raceId)
{
Entities context = new Entities();
RaceAthlete raceAthlete = new RaceAthlete();
raceAthlete.AthleteId = Id;
raceAthlete.RaceId = raceId;
if (StartNumber.HasValue) raceAthlete.Startnumber = StartNumber.Value;
context.RaceAthletes.AddObject(raceAthlete);
context.SaveChanges();
}
public void TestSetup()
{
ctxDBTest = new Entities();
newEvent = new EventModel("TestEvent", DateTime.Today);
newEvent.Save();
newRace = new RaceModel("RaceModelTestRace", new DateTime(2009, 2, 3));
newRace.EventId = newEvent.EventId;
newRace.Save();
raceDB = new Race();
raceDB.EventId = newEvent.EventId;
raceDB.Name = "TestingRaceModel";
raceDB.Distance = 200;
raceDB.StartDate = DateTime.Parse("10/03/2020");
ctxDBTest.Races.AddObject(raceDB);
ctxDBTest.SaveChanges();
}
public void A_DateTime_Value_In_Db_Should_Equal_The_Actual_DateTime_Value()
{
ITimeU.Models.Timer t = null;
Entities context = null;
Given("we have a timer database entry with a start time", () =>
{
t = new ITimeU.Models.Timer();
t.StartTime = new DateTime(2010, 8, 5, 23, 45, 40, 799);
});
When("we save the timer to the database", () =>
{
context = new Entities();
context.Timers.AddObject(t);
context.SaveChanges();
});
Then("the start time should be the same in the timer and in the database", () =>
{
var tDb = context.Timers.Single(tmr => tmr.TimerID == t.TimerID);
tDb.StartTime.ShouldBe(t.StartTime);
});
}
public void Setting_A_Timers_Start_Time_Should_Be_Rounded_Also_When_Saving_To_Db()
{
ITimeU.Models.Timer t = null;
Given("we have a timer database entry with a start time set to 42.972 seconds", () =>
{
t = new ITimeU.Models.Timer();
t.StartTime = new DateTime(2010, 8, 5, 23, 45, 42, 972);
});
When("we save the timer entry to database and retrieve it back", () =>
{
var context = new Entities();
context.Timers.AddObject(t);
context.SaveChanges();
});
Then("the time should be rounded to 43 seconds and 0 milliseconds", () =>
{
TimerModel timerDb = TimerModel.GetTimerById(t.TimerID);
timerDb.StartTime.Value.Second.ShouldBe(43);
timerDb.StartTime.Value.Millisecond.ShouldBe(0);
});
}
public void Save()
{
using (var ctx = new Entities())
{
CheckpointOrder checkpointOrder = ctx.CheckpointOrders.Single(chkpnt => chkpnt.ID == ID);
checkpointOrder.CheckpointID = this.CheckpointID;
checkpointOrder.StartingNumber = this.StartingNumber;
checkpointOrder.OrderNumber = this.OrderNumber;
ctx.SaveChanges();
}
}
public void StartNumber_Should_Be_Added_In_Database()
{
CheckpointOrderModel testCheckpointOrder = null;
int checkpointId = 1;
int startingNumber = 100;
using (var ctxTest = new Entities())
{
if (ctxTest.CheckpointOrders.Any(chkpnt => (chkpnt.StartingNumber == startingNumber && chkpnt.CheckpointID == checkpointId)))
{
var checkpointOrderToDelete = ctxTest.CheckpointOrders.Where(checkpointOrder => (checkpointOrder.StartingNumber == startingNumber && checkpointOrder.CheckpointID == checkpointId)).Single();
ctxTest.CheckpointOrders.DeleteObject(checkpointOrderToDelete);
ctxTest.SaveChanges();
}
}
Given("We have CheckpointOrder model ", () =>
{
testCheckpointOrder = new CheckpointOrderModel();
});
When("We insert a new start number", () =>
{
testCheckpointOrder.AddCheckpointOrderDB(checkpointId, startingNumber);
});
Then("Start Number should be saved in database", () =>
{
//Entities contextDB = new Entities();
//var startNum = contextDB.CheckpointOrders.Where
// (chkpntid => (chkpntid.CheckpointID == checkpointId && chkpntid.StartingNumber == startingNumber)).
// Select(startnum => startnum.StartingNumber);
//startNum.ShouldBe(startingNumber);
Entities contextDB = new Entities();
int startNum = (int) (contextDB.CheckpointOrders.
Where(chkpntid =>
(chkpntid.CheckpointID == checkpointId && chkpntid.StartingNumber == startingNumber)).
Single().StartingNumber);
startNum.ShouldBe(startingNumber);
});
}
private void CheckAndDeletelDuplicateRace(Race existingRace)
{
using (var ctxDel = new Entities())
{
if (ctxDel.Races.Any(race => (race.Name == existingRace.Name && race.Distance == existingRace.Distance && race.StartDate == existingRace.StartDate)))
{
var DelRace = ctxDel.Races.Where(race => (race.Name == existingRace.Name && race.Distance == existingRace.Distance && race.StartDate == existingRace.StartDate)).Single();
ctxDel.DeleteObject(DelRace);
ctxDel.SaveChanges();
}
}
}
private void DeleteUpdated(string name, int distance, DateTime date)
{
using (var ctxDel = new Entities())
{
if (ctxDel.Races.Any(race => (race.Name == name && race.Distance == distance && race.StartDate == date)))
{
var DelRace = ctxDel.Races.Where(race => (race.Name == name && race.Distance == distance && race.StartDate == date)).Single();
ctxDel.DeleteObject(DelRace);
ctxDel.SaveChanges();
}
}
}
public void Delete()
{
using (var context = new Entities())
{
var model = context.AthleteClasses.Where(athleteclass => athleteclass.ID == Id).Single();
context.DeleteObject(model);
context.SaveChanges();
}
}
/// <summary>
/// Saves a list of athletes to the database.
/// </summary>
/// <param name="athletes">The list of athletes to save.</param>
public static void SaveToDb(List<AthleteModel> athletes)
{
Entities context = new Entities();
foreach (AthleteModel athlete in athletes)
athlete.SaveToDb();
context.SaveChanges();
}
public void Update()
{
using (var context = new Entities())
{
var model = context.AthleteClasses.Where(athleteclass => athleteclass.ID == Id).Single();
model.Name = Name;
context.SaveChanges();
}
}
public void Delete()
{
using (var context = new Entities())
{
var athleteToDelete = context.Athletes.Where(athlete => athlete.ID == Id).Single();
athleteToDelete.IsDeleted = true;
context.SaveChanges();
}
}
public void Update()
{
using (var context = new Entities())
{
var runtimedb = context.Runtimes.Single(rtime => rtime.RuntimeID == Id);
runtimedb.IsMerged = IsMerged;
runtimedb.Runtime1 = Runtime;
context.SaveChanges();
}
}
public void RemoveFromRace(int raceid)
{
using (var ctx = new Entities())
{
var athleteToRemove = ctx.RaceAthletes.Where(ra => ra.AthleteId == Id && ra.RaceId == raceid).SingleOrDefault();
ctx.RaceAthletes.DeleteObject(athleteToRemove);
ctx.SaveChanges();
}
}
private static void SaveToDb(Runtime runtimeDb)
{
var ctx = new Entities();
ctx.Runtimes.AddObject(runtimeDb);
ctx.SaveChanges();
}
private void updateDbEntity(Entities context)
{
Athlete athlete = context.Athletes.Single(enitity => enitity.ID == Id);
updateProperties(athlete);
context.SaveChanges();
}
//public void InsertRace(Race races)
//{
// using (var ctxDB = new Entities())
// {
// races.IsDeleted = false;
// ctxDB.Races.AddObject(races);
// ctxDB.SaveChanges();
// }
//}
public void UpdateRaceName(string name)
{
using (var ctxDB = new Entities())
{
var select = ctxDB.Races.Where(race => race.RaceID == RaceId).Single();
select.Name = name;
ctxDB.SaveChanges();
}
}
public void Save()
{
using (var ctx = new Entities())
{
Timer timer = ctx.Timers.Single(tmr => tmr.TimerID == Id);
timer.StartTime = this.StartTime;
if (this.EndTime.HasValue)
timer.EndTime = this.EndTime;
ctx.SaveChanges();
}
}
public static void EditRuntime(int runtimeid, int newRuntime)
{
using (var ctx = new Entities())
{
Runtime runtimeDb = ctx.Runtimes.Single(runtimeTemp => runtimeTemp.RuntimeID == runtimeid);
runtimeDb.Runtime1 = newRuntime;
ctx.SaveChanges();
}
}
