protected override void Seed(Data.ApplicationDbContext context)
{
var cursus1 = new Cursus {
Id = 1, Duur = "5 dagen", Code = "ABC", Titel = "cursus 1"
};
var cursus2 = new Cursus {
Id = 2, Duur = "3 dagen", Code = "KLM", Titel = "cursus 2"
};
var cursus3 = new Cursus {
Id = 3, Duur = "2 dagen", Code = "XYZ", Titel = "cursus 3"
};
context.Cursussen.AddOrUpdate(x => x.Id,
cursus1, cursus2, cursus3
);
context.CursusInstanties.AddOrUpdate(x => x.Id,
new CursusInstantie {
Id = 1, StartDatum = new DateTime(2010, 10, 10), Cursus = cursus1
},
new CursusInstantie {
Id = 2, StartDatum = new DateTime(2011, 11, 11), Cursus = cursus1
},
new CursusInstantie {
Id = 3, StartDatum = new DateTime(2010, 05, 05), Cursus = cursus2
},
new CursusInstantie {
Id = 4, StartDatum = new DateTime(2010, 08, 08), Cursus = cursus3
},
new CursusInstantie {
Id = 5, StartDatum = new DateTime(2012, 12, 12), Cursus = cursus2
}
);
}
public async Task <IActionResult> PutCursus(int id, Cursus cursus)
{
if (id != cursus.CursusID)
{
return(BadRequest());
}
_unitOfWork.RepoCursus.Update(cursus);
try
{
await _unitOfWork.Save();
}
catch (DbUpdateConcurrencyException)
{
if (!CursusExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void VoegCursusToe(Cursus cursus)
{
if (!cursussen.Contains(cursus))
{
cursussen.Add(cursus);
}
}
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='cursus'>
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <object> PostAsync(this ICASService operations, Cursus cursus = default(Cursus), CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.PostWithHttpMessagesAsync(cursus, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
public static List <Cursus> GetCursussen()
{
// create a sql connection
SqlConnection connection = DALConnection.GetConnectionByName("Reader");
// create a list for storing data in it
List <Cursus> coursesList = new List <Cursus>();
// write a sql query
string sqlQuery = "SELECT CursusId, Naam, Niveau, Toelichting, Categorie FROM Cursus";
// execute the sql query
SqlCommand command = new SqlCommand(sqlQuery, connection);
SqlDataReader reader = command.ExecuteReader();
// read data from DB
while (reader.Read())
{
Cursus course = new Cursus();
course.Id = (int)reader["CursusId"];
course.Naam = Convert.ToString(reader["Naam"]);
course.Niveau = Convert.ToInt32(reader["Niveau"]);
course.Toelichting = Convert.ToString(reader["Toelichting"]);
course.Categorie = (DeelnemerCategorie)reader["Categorie"];
// add data to thr list
coursesList.Add(course);
}
// close all open connections
reader.Close();
DALConnection.CloseSqlConnection(connection);
return(coursesList);
}
public void TestFind()
{
using (var repo = new CursusRepository(new DatabaseContext(_options)))
{
//Arrange
var cursus = new Cursus()
{
Cursuscode = "test",
Duur = 5,
Titel = "Name"
};
var cursusInstantie = new CursusInstantie()
{
Startdatum = new DateTime(2016, 10, 10),
Cursus = cursus
};
//Act
repo.Insert(cursusInstantie);
var res = repo.Find(1);
}
using (var repo = new CursusRepository(new DatabaseContext(_options)))
{
//Assert
var result = repo.Find(1);
Assert.AreEqual("test", result.Cursus.Cursuscode);
Assert.AreEqual(5, result.Cursus.Duur);
Assert.AreEqual("Name", result.Cursus.Titel);
}
}
public void TestAdd()
{
using (var repo = new CursusRepository(new DatabaseContext(_options)))
{
//Arrange
var cursus = new Cursus()
{
Cursuscode = "test",
Duur = 5,
Titel = "Name"
};
var cursusInstantie = new CursusInstantie()
{
Startdatum = new DateTime(2016, 10, 10),
Cursus = cursus
};
//Act
repo.Insert(cursusInstantie);
}
using (var repo = new CursusRepository(new DatabaseContext(_options)))
{
Assert.AreEqual(1, repo.Count());
}
}
public async Task <ActionResult <Cursus> > PostCursus(Cursus cursus)
{
_unitOfWork.RepoCursus.Create(cursus);
await _unitOfWork.Save();
return(CreatedAtAction("GetCursus", new { id = cursus.CursusID }, cursus));
}
public void TestGetCursusFromName()
{
int cursusId = 1;
Cursus cursus = Database.GetInstance().GetCursusFromId(cursusId);
Assert.AreEqual(cursus.StartDate, DateTime.ParseExact("20191208", "yyyyMMdd", CultureInfo.InvariantCulture, DateTimeStyles.None));
}
public static List <Cursus> GetCursussen()
{
List <Cursus> cursussen = new List <Cursus>();
SqlConnection connection = DALConnection.openConnectieDB();
DALConnection.openConnectieDB();
StringBuilder sbquery = new StringBuilder();
sbquery.Append("SELECT CursusId, Naam, Niveau, Toelichting, Categorie FROM Cursus;");
String sql = sbquery.ToString();
SqlCommand command = new SqlCommand(sql, connection);
SqlDataReader reader = command.ExecuteReader();
while (reader.Read())
{
Cursus cursus = LeesCursus(reader);
cursussen.Add(cursus);
}
reader.Close();
DALConnection.sluitConnectieDB(connection);
return(cursussen);
}
public void CursusPutTest()
{
using (var repo = new CursusRepositoryMock())
{
Assert.AreEqual(0, repo.TimesUpdateCalled);
var target = new CursusController(repo);
var cursus = new Cursus()
{
Cursuscode = "test",
Duur = 5,
Titel = "C# testing"
};
var cursusInstantie = new CursusInstantie()
{
Startdatum = new DateTime(2016, 10, 10),
Cursus = cursus
};
target.Put(cursusInstantie);
Assert.AreEqual(1, repo.TimesUpdateCalled);
Assert.AreEqual(cursusInstantie, repo.UpdateLastCallContent);
}
}
public async Task <IActionResult> Edit(int id, [Bind("CursusID,Naam,StandaardPrijs,HuidigePrijs,CursusBeschrijvingID,Afbeelding,Gecertificieerd,BeschikbaarheidInMaanden,DocentID")] Cursus cursus)
{
if (id != cursus.CursusID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(cursus);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CursusExists(cursus.CursusID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["CursusBeschrijvingID"] = new SelectList(_context.Set <CursusBeschrijving>(), "CursusBeschrijvingID", "CursusBeschrijvingID", cursus.CursusBeschrijvingID);
ViewData["DocentID"] = new SelectList(_context.Docenten, "DocentID", "DocentNaam", cursus.DocentID);
return(View(cursus));
}
public void InsertCursusFaalendDuplicate()
{
using (var repo = new CursusRepositoryMock())
{
//Arrange
var target = new CursusController(repo);
var cursus = new Cursus()
{
Cursuscode = "test",
Duur = 5,
Titel = "C# testing"
};
var cursusInstantie = new CursusInstantie()
{
Startdatum = new DateTime(2016, 10, 10),
Cursus = cursus
};
target.Post(cursusInstantie);
//Act
var result = target.Post(cursusInstantie);
//Assert
Assert.AreEqual(2, repo.TimesInsertCalled);
Assert.IsInstanceOfType(result, typeof(BadRequestObjectResult));
}
}
public void InsertCursusFaalendDuplicateErrorMessage()
{
using (var repo = new CursusRepositoryMock())
{
var target = new CursusController(repo);
var cursus = new Cursus()
{
Cursuscode = "test",
Duur = 5,
Titel = "C# testing"
};
var cursusInstantie = new CursusInstantie()
{
Startdatum = new DateTime(2016, 10, 10),
Cursus = cursus
};
target.Post(cursusInstantie);
//Act
var result = target.Post(cursusInstantie);
//Assert
Assert.AreEqual(2, repo.TimesInsertCalled);
Assert.IsInstanceOfType(result, typeof(BadRequestObjectResult));
var testResult = (result as BadRequestObjectResult).Value;
Assert.AreEqual("This key already exist", (testResult as Foutmelding).ErrorMessage);
}
}
public void CursistInsertDeleteThenGetAllCount0()
{
using (var repo = new CursistRepository(new DatabaseContext(_options)))
{
//Arrange
var cursus = new Cursus()
{
Cursuscode = "test",
Duur = 5,
Titel = "C# testing"
};
var cursusInstantie = new CursusInstantie()
{
Startdatum = new DateTime(2016, 10, 15),
Cursus = cursus
};
Cursist cursist = new Cursist()
{
Voornaam = "Kees",
Achternaam = "Koning",
CursusInstantieID = 1
};
//Act
repo.Insert(cursist);
repo.Delete(1);
var result = repo.FindAll();
//Assert
Assert.IsInstanceOfType(result, typeof(IEnumerable <Cursist>));
Assert.AreEqual(0, result.Count());
}
}
private CursusBuilder()
{
_cursus = new Cursus
{
Id = _random.Next()
};
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Naam")] Cursus cursus)
{
if (id != cursus.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(cursus);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CursusExists(cursus.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(cursus));
}
public IActionResult Post([FromBody] Cursus cursus)
{
// Check if given cursus is valid
if (!ModelState.IsValid)
{
var error = new ErrorMessage(ErrorTypes.BadRequest, "Modelstate invalid");
return(BadRequest(error));
}
try
{
// Insert cursus
_cursusRepository.Insert(cursus);
return(Ok());
}
catch (DbUpdateException due)
{
Debug.WriteLine(due);
var error = new ErrorMessage(ErrorTypes.DuplicateKey, "This key already exist", "Use a non-existing key");
return(BadRequest(error));
}
catch (Exception e)
{
Debug.WriteLine(e);
var error = new ErrorMessage(ErrorTypes.Unknown, "Oops, something went wrong");
return(NotFound(error));
}
}
private List <CursusInstantie> TestData()
{
var date1 = new DateTime(2020, 2, 2);
var date2 = new DateTime(2020, 4, 4);
var date3 = new DateTime(2020, 3, 5);
var cursus1 = new Cursus()
{
Id = 1, Titel = "unittest", Duur = 5
};
var cursus2 = new Cursus()
{
Id = 2, Titel = "mvc", Duur = 5
};
var testObject1 = new CursusInstantie()
{
Id = 1, StartDatum = date1, Cursus = cursus1
};
var testObject2 = new CursusInstantie()
{
Id = 2, StartDatum = date2, Cursus = cursus2
};
var testObject3 = new CursusInstantie()
{
Id = 3, StartDatum = date3, Cursus = cursus2
};
var testList = new List <CursusInstantie>()
{
testObject1, testObject2, testObject3
};
return(testList);
}
public async Task <ActionResult> Create([Bind(Include = "Id,IdSession,Titre ,DateDebut,DateFin")] Cursus cursus, HttpPostedFileBase Image)
{
if (ModelState.IsValid)
{
if (Image != null && Image.ContentLength > 0)
{
var fileName = Path.GetFileName(Image.FileName);
var path = Path.Combine(("~/images/cursus/"), fileName);
//Image.SaveAs(path);
cursus.Image = path;
}
if (cursus.Image == null)
{
cursus.Image = ".net.png";
}
db.Cursus.Add(cursus);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(cursus));
}
public void TestFindAllCursuses()
{
using (var repo = new CursusRepository(new DatabaseContext(_options)))
{
var cursus = new Cursus()
{
Titel = "Cursus1",
Code = "C1",
Dagen = 3,
};
repo.Insert(cursus);
cursus = new Cursus()
{
Titel = "Cursus2",
Code = "C2",
Dagen = 3,
};
repo.Insert(cursus);
}
using (var repo = new CursusRepository(new DatabaseContext(_options)))
{
Assert.AreEqual(2, repo.Count());
}
}
public void VoegMeerdereCursusInstantiesVindSlechts1ContentCheckNonSame()
{
using (var repo = new CursusRepository(new DatabaseContext(_options)))
{
//Arrange
var cursus = new Cursus()
{
Cursuscode = "test",
Duur = 5,
Titel = "C# testing"
};
var cursusInstantie = new CursusInstantie()
{
Startdatum = new DateTime(2016, 10, 15),
Cursus = cursus
};
repo.Insert(cursusInstantie);
var cursusInstantie2 = new CursusInstantie()
{
Startdatum = new DateTime(2016, 3, 10),
Cursus = cursus
};
repo.Insert(cursusInstantie2);
DateTime targetDateStart = new DateTime(2016, 10, 10);
DateTime targetDateEind = new DateTime(2016, 10, 17);
//Act
var result = repo.FindBy(c => c.Startdatum >= targetDateStart && c.Startdatum < targetDateEind);
//Assert
Assert.AreEqual(targetDateStart.AddDays(5), result.First().Startdatum);
}
}
public async Task <ActionResult <Cursus> > PostCursus(Cursus cursus)
{
_context.cursussen.Add(cursus);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetCursus", new { id = cursus.Id }, cursus));
}
public void GetCursusInstantieByWeek_ShouldReturnCursusInstanties()
{
int cursusWeek = 28; // Week number matches CursusInstantie StartDatum.
int cursusYear = 2020;
Cursus cursus = new Cursus {
Id = 1, Duur = 5, Titel = "Java Persistence API", Code = "JPA"
};
CursusInstantie cursusInstantie = new CursusInstantie()
{
StartDatum = new DateTime(06 / 07 / 2020),
CursusId = cursus.Id,
Cursus = cursus
};
IEnumerable <CursusInstantie> cursusInstantieList = new List <CursusInstantie> {
cursusInstantie
};
Task <IEnumerable <CursusInstantie> > getByWeekAndYearMethodResponse = Task.FromResult(cursusInstantieList);
_cursusInstantierepository.Setup(cir => cir.GetByWeekAndYear(cursusWeek, cursusYear))
.Returns(getByWeekAndYearMethodResponse);
Task <IEnumerable <CursusInstantieViewModel> > actualResponse = _cursusInstantieController.GetCursusInstantieByWeek(cursusWeek, cursusYear);
Assert.IsNotNull(actualResponse);
Assert.IsInstanceOfType(actualResponse, typeof(Task <IEnumerable <CursusInstantieViewModel> >));
Assert.IsTrue(actualResponse.Result.Count() == 1);
}
public async Task <IActionResult> PutCursus(int id, Cursus cursus)
{
if (id != cursus.Id)
{
return(BadRequest());
}
_context.Entry(cursus).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CursusExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void SetUp()
{
Cursus csharp = new Cursus();
AbstractPerson student1 = PersonFactory.Create("Tom", null, null, csharp);
AbstractPerson student2 = PersonFactory.Create("Lys", null, null, csharp);
AbstractPerson student3 = PersonFactory.Create("Nathaniel", null, null, csharp);
List <AbstractPerson> _students = new List <AbstractPerson>();
_students.Add(student1);
_students.Add(student2);
_students.Add(student3);
//List<AbstractPerson> _instructors = new List<AbstractPerson>();
AbstractPerson _instructor = PersonFactory.Create("Instructor1", _students);
/*Cursus csharp = new Cursus();
* _students = new List<AbstractPerson>
* {
* new Students("Tom",csharp),
* new Students("Lys", csharp),
* new Students("Nathaniel",csharp)
* };
*
* _instructors = new List<AbstractPerson>
* {
* new Instructor("Instructor", _students)
* };
*
* _lead = new LeadInstructor("Chef", _instructors);*/
}
public async Task <Cursus> CreateAsync(Cursus cursus)
{
_context.Cursussen.Add(cursus);
await _context.SaveChangesAsync();
return(cursus);
}
public void TestCreateStudents()
{
Cursus csharp = new Cursus();
AbstractPerson student = PersonFactory.Create("Dan");
string typeName = typeof(Students).ToString();
Assert.AreEqual(typeName, student.GetType().ToString());
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
Cursus cursus = await db.Cursus.FindAsync(id);
db.Cursus.Remove(cursus);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
private async Task <CursusInstantie> InstantiateCursusInstantieObject(int index, string[] processedText)
{
string cursusCode = _textFileToAttributeConverterService.ConvertCode(index, processedText);
Cursus cursus = await _cursusRepository.FirstOrDefaultAsync(ci => ci.Code == cursusCode);
return(new CursusInstantie
{
StartDatum = _textFileToAttributeConverterService.ConvertStartdatum(index, processedText),
CursusId = cursus.Id
});
}
