public ActionResult Create([Bind(Include = "MeetingItemStatusId,PersonId,MeetingId,MeetingItemId,CurrentStatus,ActionRequired,DateUpdated")] MeetingItemStatus meetingitemstatus)
{
if (ModelState.IsValid)
{
_db.MeetingItemStatuses.Add(meetingitemstatus);
_db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.MeetingId = new SelectList(_db.Meetings, "MeetingId", "MeetingDescription", meetingitemstatus.MeetingId);
ViewBag.MeetingItemId = new SelectList(_db.MeetingItems, "MeetingItemId", "MeetingItemDescription", meetingitemstatus.MeetingItemId);
ViewBag.PersonId = new SelectList(_db.Persons, "PersonId", "FirstName", meetingitemstatus.PersonId);
return(View(meetingitemstatus));
}
public User AddUser(User user)
{
_context.Users.Add(user);
_context.SaveChanges();
return(user);
}
public void SaveOriginalFile(string caseName, DbContextOptions options)
{
var meeting = GetOriginalMeetingfromJson();
using (var context = new MeetingContext(options))
{
context.Database.EnsureDeleted();
context.Database.EnsureCreated();
strategy.SaveMeeting(context, meeting);
context.SaveChanges();
}
using (var context = new MeetingContext(options))
{
var insertedMeeting = context.Meetings.Find(meeting.Id);
context.Entry(insertedMeeting)
.Collection(b => b.Races)
.Load();
Assert.Equal(3, insertedMeeting.Races.Count());
var trackingEntities = context.ChangeTracker.Entries <Race>().Count();
Assert.Equal(3, trackingEntities);
Assert.Equal(insertedMeeting.Id, insertedMeeting.Races.First().MeetingId);
}
}
public Room AddRoom(Room room)
{
_context.Rooms.Add(room);
_context.SaveChanges();
return(room);
}
public IHttpActionResult createMeetingType([FromBody] MeetingType meetingType)
{
if (meetingType == null)
{
return(BadRequest("Meeting type sent to server is empty"));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
else
{
using (var entities = new MeetingContext())
{
var m = entities.MeetingTypes.FirstOrDefault(x => x.Name.ToLower() == meetingType.Name.ToLower());
//meetingtype does not exist
if (m == null)
{
entities.MeetingTypes.Add(meetingType);
entities.SaveChanges();
return(Created("Unknown URL", meetingType));
}
else
{
return(BadRequest("Meeting Type already exists in database"));
}
}
}
}
public IHttpActionResult Post([FromBody] MeetingItemStatus status)
{
if (status == null)
{
return(BadRequest("Empty status object sent"));
}
if (ModelState.IsValid)
{
using (var entities = new MeetingContext())
{
status.dateOfStatusUpdate = DateTime.Now;
entities.MeetingItemStatuses.Add(status);
try
{
entities.SaveChanges();
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
return(Created("Created", status));
}
}
else
{
return(BadRequest(ModelState));
}
}
public IHttpActionResult Post([FromBody] Meeting meeting)
{
if (meeting == null)
{
return(BadRequest("Empty Meeting object sent"));
}
if (ModelState.IsValid)
{
using (var entities = new MeetingContext())
{
var meetingtype = entities.MeetingTypes.FirstOrDefault(x => x.Id == meeting.MeetingTypeId);
//check if have meetings for the meetingtype
if (entities.Meetings.Where(x => x.MeetingTypeId == meeting.MeetingTypeId).FirstOrDefault() == null)
{
meeting.Name = meetingtype.Name + "-1";
}
else
{
//get last meeting of that type by date
var lastMeetingOfType = entities.Meetings.Where(x => x.MeetingTypeId == meeting.MeetingTypeId).OrderByDescending(y => y.DateofMeeting).FirstOrDefault();
//Get Name of new meeting eg Finance-1, Finance-2
var meetingtypeName = lastMeetingOfType.Name.Split('-')[0];
var prevMeetingNumber = Int32.Parse(lastMeetingOfType.Name.Split('-')[1]);
var newMeetingNumber = prevMeetingNumber + 1;
var newMeetingName = meetingtypeName + "-" + newMeetingNumber.ToString();
meeting.Name = newMeetingName;
}
meeting.DateofMeeting = DateTime.Now;
entities.Meetings.Add(meeting);
entities.SaveChanges();
return(Created("Created", meeting));
/*
* //get just saved meeting
* var meetingCurrent = entities.Meetings.FirstOrDefault(x => x.Name == meeting.Name);
*
*
* //Previous meeting item list
* var prevmeetingitems = entities.MeetingItems.Where(x => x.MeetingId == lastMeetingOfType.Id).ToList();
* //Update the meetingId foreach meetingitem from the previous meeting
* foreach(var item in prevmeetingitems)
* {
* item.MeetingId = meetingCurrent.Id;
*
* entities.SaveChanges();
* }
*/
}
}
else
{
return(BadRequest(ModelState));
}
}
public void ShouldBeBrokenInMemoryProviderFK(string caseName, DbContextOptions options)
{
var meeting = GetOriginalMeetingfromJson();
using (var context = new MeetingContext(options))
{
ClearTestDb(context);
strategy.SaveMeeting(context, meeting);
context.SaveChanges();
Assert.True(meeting.Id > 0);
var race = meeting.Races.First();
context.Attach(race);
race.MeetingId = 5000;
var ex = Record.Exception(() => context.SaveChanges());
Assert.IsType <DbUpdateException>(ex);
Assert.Contains("FOREIGN KEY", ex.InnerException.Message);
}
}
public void NaiveScenarioSaveAndUpdateSourceAndSaveAgain(string caseName, DbContextOptions options)
{
var meeting = GetOriginalMeetingfromJson();
using (var context = new MeetingContext(options))
{
context.Database.EnsureDeleted();
context.Database.EnsureCreated();
strategy.SaveMeeting(context, meeting);
context.SaveChanges();
}
// Another JsonFile with additional race
meeting = GetOriginalMeetingfromJson();
Race newRace = CreateNewRace();
// Apply changes to first to emulate second file
meeting.Date = meeting.Date.AddDays(2);
var RaceId = meeting.Races[0].OuterId;
meeting.Races[0].Name = "DDDD";
meeting.Races.Add(newRace);
using (var context = new MeetingContext(options))
{
var trackingEntities = context.ChangeTracker.Entries().Count();
Assert.Equal(0, trackingEntities);
var insertedMeeting = context.Meetings.AsNoTracking()
.Include(b => b.Races).First(m => m.OuterId == meeting.OuterId);
Debug.WriteLine($"Meeting new graph {meeting.Id} {meeting.OuterId}");
strategy.SaveMeeting(context, meeting);
context.SaveChanges();
}
using (var context = new MeetingContext(options))
{
var trackingEntities = context.ChangeTracker.Entries().Count();
Assert.Equal(0, trackingEntities);
var insertedMeeting = context.Meetings.AsNoTracking()
.Include(b => b.Races).First(m => m.OuterId == meeting.OuterId);
Assert.Equal(4, insertedMeeting.Races.Count());
Assert.Equal("DDDD", insertedMeeting.Races.First(l => l.OuterId == RaceId).Name);
trackingEntities = context.ChangeTracker.Entries().Count();
Assert.Equal(0, trackingEntities);
}
}
public void SaveMeeting(MeetingContext context, Meeting input)
{
var graph = context.Meetings.AsNoTracking()
// .Include(b => b.Races)
.FirstOrDefault(m => m.OuterId == input.OuterId);
if (graph != null)
{
context.Meetings.Remove(graph);
context.SaveChanges();
}
context.Add(input);
}
public IHttpActionResult PostNewMeeting(string name, int year, int month, int day, int hour, int min)
{
Meeting meet = new Meeting();
meet.Name = name;
meet.Time = Convert.ToDateTime(String.Concat(year, "-", month, "-", day, " ", hour, ":", min));
meet.State = true;
db.Meetings.Add(meet);
db.SaveChanges();
return(Ok());
}
public void CanInsertMeetingIntoDb(string caseName, DbContextOptions options)
{
using (var context = new MeetingContext(options))
{
context.Database.EnsureDeleted();
context.Database.EnsureCreated();
var meeting = CreateTestMeeting("Hahahaha");
Debug.WriteLine($"Default Samurai Id {meeting.Id}");
context.Meetings.Add(meeting);
var efDefaultId = meeting.Id;
Debug.WriteLine($"EF Default Samurai Id {efDefaultId}");
context.SaveChanges();
Debug.WriteLine($"DB assigned Samurai Id {meeting.Id}");
Assert.NotEqual(efDefaultId, meeting.Id);
}
}
public void CanInsertMeetingWithSaveChanges(string caseName, DbContextOptions options)
{
using (var context = new MeetingContext(options))
{
context.Database.EnsureDeleted();
context.Database.EnsureCreated();
var meeting = new Meeting
{
Name = "Be-Be-Be"
};
context.Meetings.Add(meeting);
context.SaveChanges();
}
using (var context2 = new MeetingContext(options))
{
Assert.Equal(1, context2.Meetings.Count());
}
}
public IHttpActionResult Put(int Id, [FromBody] MeetingItem item)
{
using (var entities = new MeetingContext())
{
var entity = entities.MeetingItems.FirstOrDefault(x => x.Id == Id);
if (entity == null)
{
return(NotFound());
}
else
{
entity.Description = item.Description;
entity.DueDate = item.DueDate;
entity.MeetingId = item.MeetingId;
entity.Responsible = item.Responsible;
entities.SaveChanges();
return(Ok(entity));
}
}
}
public IHttpActionResult createMeetingItem([FromBody] MeetingItem item)
{
if (item == null)
{
return(BadRequest("Meeting Item is empty"));
}
if (ModelState.IsValid)
{
using (var entities = new MeetingContext())
{
entities.MeetingItems.Add(item);
entities.SaveChanges();
return(Created("MeetingItem", item));
}
}
else
{
return(BadRequest(ModelState));
}
}
public ActionResult Create(Meeting meeting)
{
using (var contex = new MeetingContext())
{
using (var db = contex.Database.BeginTransaction())
{
try
{
meeting.Location = contex.Locations.Find(meeting.Location.Id);
contex.Meetings.Add(meeting);
contex.SaveChanges();
db.Commit();
}
catch (Exception e)
{
Console.WriteLine(e);
db.Rollback();
throw;
}
}
}
return(RedirectToAction("Index"));
}
public void Run()
{
_logger.LogInformation($"This is a console application for {_config.Title}");
_logger.LogInformation("Begin parsing jsonFile");
var raceData = _jsonService.ParseOriginalSample();
System.Console.WriteLine(raceData);
_logger.LogInformation("End parsing");
_logger.LogInformation("Begin transforming to domain entity");
var meeting = _jsonService.Transform(raceData);
_logger.LogInformation("End transforming");
using (var context = new MeetingContext(_options))
{
context.Database.EnsureCreated();
var service = new MeetingService(context, _strategy);
service.SaveMeeting(meeting);
context.SaveChanges();
}
var meeting2 = _jsonService.Transform(raceData);
using (var context = new MeetingContext(_options))
{
var service = new MeetingService(context, _strategy);
service.SaveMeeting(meeting2);
context.SaveChanges();
}
System.Console.ReadKey();
}
public void Commit()
{
_context.SaveChanges();
}
public static void Initialize(IServiceProvider serviceProvider)
{
using (var context = new MeetingContext(
serviceProvider.GetRequiredService <
DbContextOptions <MeetingContext> >()))
{
if (context.Meeting.Any())
{
return; // DB has been seeded
}
context.Meeting.AddRange(
new Meeting
{
MeetingDate = DateTime.Parse("2019-12-08"),
Conductor = "Jeff Hansen",
OpeningHymnNumber = 201,
SacramentHymnNumber = 100,
RestHymnNumber = 20,
ClosingHymn = 300,
OpeningPrayer = "Frank Heart",
ClosingPrayer = "Katie Larsen",
SpeakerOne = "Mike Jones",
SpeakerTwo = "Ryan Sawyer",
SpeakerThree = "John Armstrong"
},
new Meeting
{
MeetingDate = DateTime.Parse("2019-11-03"),
Conductor = "Mike Barns",
OpeningHymnNumber = 89,
SacramentHymnNumber = 82,
RestHymnNumber = 102,
ClosingHymn = 92,
OpeningPrayer = "Fred Hinzer",
ClosingPrayer = "Zack Manchester"
},
new Meeting
{
MeetingDate = DateTime.Parse("2019-11-10"),
Conductor = "Jeff Hansen",
OpeningHymnNumber = 203,
SacramentHymnNumber = 93,
RestHymnNumber = 83,
ClosingHymn = 73,
OpeningPrayer = "Kevin Heart",
ClosingPrayer = "Bryce Willson",
SpeakerOne = "Magnum Jenkins",
SpeakerTwo = "Anthony Stark",
SpeakerThree = "Bruce Wayne"
},
new Meeting
{
MeetingDate = DateTime.Parse("2019-11-17"),
Conductor = "Mike Barns",
OpeningHymnNumber = 304,
SacramentHymnNumber = 204,
RestHymnNumber = 104,
ClosingHymn = 94,
OpeningPrayer = "Steve Rogers",
ClosingPrayer = "Katie Larsen",
SpeakerOne = "Diana Prince ",
SpeakerTwo = "Natasha Romanoff",
SpeakerThree = "Bill Jensen"
}
);
context.SaveChanges();
}
}
