async Task SaveValuesAsync(IDialogContext context, RegisterForm registration)
{
MeetingData mtgData = await new MeetingState().GetAsync(context.Activity) ?? new MeetingData();
using (var ctx = new MeetingContext())
{
User user =
await
(from usr in ctx.Users
where usr.UserID == mtgData.UserDBID ||
usr.Email == registration.Email
select usr)
.SingleOrDefaultAsync();
if (user == null)
{
user = new User
{
Email = registration.Name,
Name = registration.Email
};
ctx.Users.Add(user);
}
else
{
user.Name = registration.Name;
user.Email = registration.Email;
}
await ctx.SaveChangesAsync();
}
await context.PostAsync("Registration succeeded!");
}
public IHttpActionResult getPrevMeetingItemListbyId(int Id)
{
using (var entities = new MeetingContext())
{
//get the last meeting of the type
var meeting = entities.Meetings.OrderByDescending(x => x.DateofMeeting).FirstOrDefault(x => x.MeetingTypeId == Id);
if (meeting == null)
{
return(NotFound());
}
else
{
var meeting_data = (from m in entities.Meetings
join mi in entities.MeetingItems on m.Id equals mi.MeetingId
join mis in entities.MeetingItemStatuses on mi.Id equals mis.MeetingItemId
where m.Name == meeting.Name
select new
{
meetingtypeId = m.MeetingTypeId,
meetingname = m.Name,
meetingId = m.Id,
meetingitemId = mi.Id,
meetingitemresponsible = mi.Responsible,
meetingitemdescription = mi.Description,
meetingitemduedate = mi.DueDate,
meetingitemstatus = mis.status,
meetingitemstatusupdatedate = mis.dateOfStatusUpdate,
}).OrderByDescending(x => x.meetingitemId).ThenByDescending(y => y.meetingitemstatusupdatedate).ToList();
var data = meeting_data.GroupBy(x => x.meetingitemId).Select(y => y.OrderByDescending(d => d.meetingitemstatusupdatedate).FirstOrDefault()).ToList();
return(Ok(data));
}
}
}
async Task SaveValuesAsync(IDialogContext context, AppointmentForm appointment)
{
MeetingData mtgData = await new MeetingState().GetAsync(context.Activity) ?? new MeetingData();
using (var ctx = new MeetingContext())
{
ctx.Appointments.Add(
new Appointment
{
UserID = mtgData.UserDBID,
VenueID =
(from venue in venues
where venue.Name == appointment.Venue
select venue.VenueID)
.Single(),
Time = new DateTime(
appointment.Date.Year, appointment.Date.Month, appointment.Date.Day,
appointment.Time.Hour, appointment.Time.Minute, 0)
});
await ctx.SaveChangesAsync();
}
await context.PostAsync("Venue added!");
}
public IHttpActionResult getAllMeetingItems()
{
using (var entities = new MeetingContext())
{
var meetingitemlist = (from m in entities.Meetings
join mi in entities.MeetingItems on m.Id equals mi.MeetingId
join mis in entities.MeetingItemStatuses on mi.Id equals mis.MeetingItemId
orderby mi.MeetingId descending
select new
{
meetingtypeId = m.MeetingTypeId,
meetingname = m.Name,
meetingId = m.Id,
meetingitemId = mi.Id,
meetingitemresponsible = mi.Responsible,
meetingitemdescription = mi.Description,
meetingitemduedate = mi.DueDate,
meetingitemstatus = mis.status,
meetingitemstatusupdatedate = mis.dateOfStatusUpdate,
}).ToList();
if (meetingitemlist == null)
{
return(BadRequest("No Meetingg items exist"));
}
else
{
return(Ok(meetingitemlist));
}
}
}
public async Task StartAsync(IDialogContext context)
{
using (var ctx = new MeetingContext())
{
venues =
await
(from venue in ctx.Venues
select new VenueModel
{
VenueID = venue.VenueID,
Name = venue.Name
})
.Take(5)
.ToListAsync();
}
string message = "Which venue would you like?";
string retry = "Please select a venue in the list.";
var promptOptions =
new PromptOptions <string>(
prompt: message,
retry: retry,
options: venues.Select(v => v.Name).ToList(),
speak: message,
retrySpeak: retry);
PromptDialog.Choice(context, VenueReceivedAsync, promptOptions);
}
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 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 getMeetingItemsById(int Id)
{
using (var entities = new MeetingContext())
{
var meeting = entities.Meetings.FirstOrDefault(x => x.Id == Id);
if (meeting == null)
{
return(BadRequest("No meeting items exist for meeting"));
}
else
{
var meetingitems = (from mi in entities.MeetingItems
join mis in entities.MeetingItemStatuses on mi.Id equals mis.MeetingItemId into mi_mis
from ms in mi_mis.DefaultIfEmpty()
where mi.MeetingId == Id
select new
{
meetingitemId = mi.Id,
meetingitemresponsible = mi.Responsible,
meetingitemdescription = mi.Description,
meetingitemduedate = mi.DueDate,
meetingitemstatus = ms == null?"":ms.status,
});
return(Ok(meetingitems.ToList()));
}
}
}
public IHttpActionResult getAllMeetings()
{
using (var entities = new MeetingContext())
{
var meetinglist = entities.Meetings.ToList();
return(Ok(meetinglist));
}
}
public ActionResult Create()
{
using (var context = new MeetingContext())
{
ViewBag.locations = context.Locations.ToList();
}
return(View());
}
public IForm <AppointmentForm> BuildForm()
{
return(new FormBuilder <AppointmentForm>()
.Message("I have a couple quick questions.")
.Field(nameof(SetReminder))
.Field(nameof(ReminderMinutes), apptFrm => SetReminder)
.Field(new FieldReflector <AppointmentForm>(nameof(Venue))
.SetType(null)
.SetFieldDescription("Please select venue")
.SetDefine(async(appointmentForm, field) =>
{
using (var ctx = new MeetingContext())
{
if (venues == null)
{
venues =
await
(from venue in ctx.Venues
select new VenueModel
{
VenueID = venue.VenueID,
Name = venue.Name
})
.Take(5)
.ToListAsync();
}
}
foreach (var venue in venues)
{
field
.AddDescription(venue.Name, venue.Name)
.AddTerms(venue.Name, Language.GenerateTerms(venue.Name, 6));
}
return true;
}))
.Field(nameof(Date))
.Field(
name: nameof(Time),
validate: async(appointmentForm, field) =>
{
var result = new ValidateResult {
IsValid = true, Value = field
};
DateTime time = (DateTime)field;
if (time.Hour < 8 || time.Hour > 17)
{
result.Feedback = "Meeting times should be between 8:00am and 5:00pm.";
result.IsValid = false;
}
return await Task.FromResult(result);
})
.OnCompletion(SaveValuesAsync)
.Build());
}
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 PopulateConductingDropDownList(MeetingContext _context,
object selectedMember = null)
{
var memberQuery = from d in _context.Bishopric
orderby d.name // Sort by name.
select d;
BishopricNameSL = new SelectList(memberQuery.AsNoTracking(),
"BishopricID", "name", selectedMember);
}
private static void ClearTestDb(MeetingContext context)
{
if (context.Database.IsSqlite())
{
context.Database.OpenConnection();
}
context.Database.EnsureDeleted();
context.Database.EnsureCreated();
}
public ApplicationUser GetUserById(Guid id)
{
ApplicationUser user = null;
using (var db = new MeetingContext())
{
}
return user;
}
// GET: Meeting
public ActionResult Index()
{
List <Meeting> meetings;
using (var context = new MeetingContext())
{
context.Configuration.LazyLoadingEnabled = false;
meetings = context.Meetings.ToList();
}
return(View(meetings));
}
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 getMeetingbyName(string name)
{
using (var entities = new MeetingContext())
{
var meeting = entities.Meetings.FirstOrDefault(x => x.Name == name);
if (meeting == null)
{
return(NotFound());
}
else
{
return(Ok(meeting));
}
}
}
public IHttpActionResult getMeetingTypes()
{
using (var entities = new MeetingContext())
{
var meetingtypelist = entities.MeetingTypes.ToList();
if (meetingtypelist == null)
{
return(BadRequest("No meeting types exist in the database"));
}
else
{
return(Ok(meetingtypelist));
}
}
}
async Task SaveValuesAsync(IDialogContext context, VenueForm venue)
{
using (var ctx = new MeetingContext())
{
ctx.Venues.Add(
new Venue
{
Name = venue.Name,
Address = venue.Address
});
await ctx.SaveChangesAsync();
}
await context.PostAsync("Venue added!");
}
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 getMeetingsandItemswithStatus(string name)
{
using (var entities = new MeetingContext())
{
var meeting = entities.Meetings.FirstOrDefault(x => x.Name == name);
var meeting_data = (from m in entities.Meetings
where m.Name == name
join items in entities.MeetingItems on m.Id equals items.MeetingId
select new { meetingname = m.Name, meetingitemdescription = items.Description }).ToList();
if (meeting_data == null)
{
return(NotFound());
}
else
{
return(Ok(meeting_data));
}
}
}
async Task RegisterDialogResumedAsync(IDialogContext context, IAwaitable <Registration> result)
{
Registration registration = await result;
IActivity activity = context.Activity;
var mtgState = new MeetingState();
MeetingData mtgData = await mtgState.GetAsync(activity) ?? new MeetingData();
using (var ctx = new MeetingContext())
{
User user =
await
(from usr in ctx.Users
where usr.UserID == mtgData.UserDBID ||
usr.Email == registration.Email
select usr)
.SingleOrDefaultAsync();
if (user == null)
{
user = new User
{
Email = registration.Name,
Name = registration.Email
};
ctx.Users.Add(user);
}
else
{
user.Name = registration.Name;
user.Email = registration.Email;
}
await ctx.SaveChangesAsync();
}
await context.PostAsync("Registration succeeded!");
context.Wait(MessageReceivedAsync);
}
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 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);
}
}
async Task <string> HandleEmailResponseAsync(Activity activity, MeetingData mtgData)
{
string userEmail = activity.Text;
using (var ctx = new MeetingContext())
{
User user =
await
(from usr in ctx.Users
where usr.UserID == mtgData.UserDBID ||
usr.Email == userEmail
select usr)
.SingleOrDefaultAsync();
if (user == null)
{
user = new User
{
Email = userEmail,
Name = userEmail
};
ctx.Users.Add(user);
}
else
{
user.Email = userEmail;
}
await ctx.SaveChangesAsync();
mtgData.UserChannelID = activity.From.Id;
mtgData.UserDBID = user.UserID;
}
mtgData.Method = nameof(HandleNameResponseAsync);
return("What is your name?");
}
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"));
}
