private MeetingTimes BuildRequestBody(Meeting meeting, string startTime, string endTime)
{
var result = new MeetingTimes
{
MeetingDuration = "PT30M",
Attendees = new List<MeetingTimes.Attendee>(),
TimeConstraint = new TimeConstraint
{
Timeslots = new List<MeetingTimeSlot>()
},
LocationConstraint = new LocationConstraint()
{
Locations = new List<Location>()
}
};
foreach (var a in meeting.Attendees)
{
if (!a.EmailAddress.IsEqualTo(meeting.Organizer.EmailAddress))
{
result.Attendees.Add(new MeetingTimes.Attendee
{
EmailAddress = a.EmailAddress
});
}
}
var date = meeting.Start.ToLocalTime();
var dateString = date.DateToApiString();
var timeSlot = new MeetingTimeSlot
{
Start = new MeetingTimeSlot.TimeDescriptor
{
Date = dateString,
Time = startTime,
TimeZone = TimeZoneInfo.Local.Id
},
End = new MeetingTimeSlot.TimeDescriptor
{
Date = dateString,
Time = endTime,
TimeZone = TimeZoneInfo.Local.Id
}
};
result.TimeConstraint.Timeslots.Add(timeSlot);
if (!string.IsNullOrEmpty(meeting.Location.DisplayName))
{
result.LocationConstraint.Locations.Add(new Location
{
DisplayName = meeting.Location.DisplayName
});
}
return result;
}
public async Task<ReturnModel<MeetingModel>> Create (MeetingModel meetingModel)
{
var result = new ReturnModel<MeetingModel> { Status = true };
using(var session = new UnitOfWork<FoodMenuEntities>())
{
var MeetingRepository = session.GetRepository<IMeetingRepository>();
var meeting = new Meeting();
meeting.Id = meetingModel.Id;
meeting.ClientId = meetingModel.ClientId;
meeting.Date = meetingModel.Date;
meeting.Weight = meetingModel.Weight;
meeting.Water = meetingModel.Water;
meeting.Muscle = meetingModel.Muscle;
meeting.FatPercentage = meetingModel.FatPercentage;
meeting.MeetingIndex = meetingModel.MeetingIndex;
meeting.ArmMuscleMeasurement = meetingModel.ArmMuscleMeasurement;
meeting.ArmNOMuscleMeasurement = meetingModel.ArmNOMuscleMeasurement;
meeting.HipMeasurement = meetingModel.HipMeasurement;
meeting.StomachMeasurement = meetingModel.StomachMeasurement;
meeting.ThighMeasurement = meetingModel.ThighMeasurement;
meeting.FrontHandFat = meetingModel.FrontHandFat;
meeting.BackHandFat = meetingModel.BackHandFat;
meeting.ThighFat = meetingModel.ThighFat;
meeting.BackFat = meetingModel.BackFat;
meeting.FatAvrg = meetingModel.FatAvrg;
MeetingRepository.Add(meeting);
await session.SaveChangesAsync();
meetingModel.Id = meeting.Id;
result.Result = meetingModel;
return result;
}
}
public void Add_can_add_a_new_meeting()
{
// Arrange
var meetingRepository = new MeetingRepository(activeSessionManager);
var meeting = new Meeting()
{
Title = "Test Meeting",
Description = "Sample Description",
StartTime = DateTime.Parse("1/1/2009"),
EndTime = DateTime.Parse("1/1/2009"),
Presenter = "Tim Barcz",
Facility = new Facility() {
Address = new Address()
{
Street = "123 Oak Street",
City="Cedar Rapids",
Region = "Iowa",
ZipCode = "52402"
},
Description = "Sample Facility",
Name = "Test Facility",
ImageUrl = "http://www.google.com"
}
};
// Act
meetingRepository.Add(meeting);
// Assert
Assert.That(meeting.MeetingId, Is.GreaterThan(0));
}
public override void Revert(Meeting meeting)
{
var meetingHistory = meeting.MeetingHistories.OrderByDescending(m => m.OperationDate).FirstOrDefault();
if (meetingHistory != null)
{
meeting.State = (int) meetingHistory.CurrentState;
}
}
public async Task<Meeting> CreateEvent(Meeting meeting)
{
string uri = "events/";
var newMeeting = await new HttpHelper().PostItemAsync<Meeting>(uri, meeting);
return newMeeting;
}
public async Task<Meeting> UpdateEvent(Meeting meeting)
{
string uri = "events/" + meeting.Id;
var newMeeting = await new HttpHelper().PatchItemAsync<Meeting>(uri, meeting);
return newMeeting;
}
public ActionResult Edit(Meeting meeting)
{
if(!ModelState.IsValid)
return View(meeting);
_meetingRepo.Save(meeting);
return RedirectToAction("List");
}
public void AddAttendee_increases_attendee_count()
{
var meeting = new Meeting();
var returnedAttendee = meeting.AddGuestAttendee("*****@*****.**", "Tim", "Barcz");
Assert.That(meeting.AttendeeCount, Is.EqualTo(1));
Assert.That(meeting.Attendees.First(), Is.EqualTo(returnedAttendee));
}
private void Record_Add(object sender, RoutedEventArgs e)
{
Meeting m = new Meeting();
m.dateX = DateDatePicker.SelectedDate ?? default(DateTime);
m.notesX = NotesTextBox.Text;
m.insert();
this.Close();
}
public Meeting Schedule(Id meetingId, MeetingDate on, Id venue, Id speaker, Capacity capacity)
{
if (on == null)
throw new ArgumentNullException("on", "A meeting must have a date to be scheduled");
Tickets tickets = _overbookingPolicy.AllocateTickets(capacity);
var meeting = new Meeting(on, venue, speaker, tickets, new Version(), meetingId);
meeting.OpenForRegistration();
return meeting;
}
static void Main(string[] args)
{
PreRegistration prereg;
using (var uow = UoWFactory.Create())
{
var rep = uow.Create();
prereg = new PreRegistration();
prereg.Text = "First pre registration";
prereg.Text1 = "Additional text";
var k = rep.Create<PreRegistration>(prereg);
uow.Commit();
}
var meeting = new Meeting();
meeting.Location = "Location 1";
prereg.Text = "Update preregistratioon text";
prereg.Meeting = meeting;
meeting.PreRegistrations.Add(prereg);
var prereg1 = new PreRegistration();
prereg1.Text = "New pre registratoob";
prereg1.Meeting = meeting;
meeting.PreRegistrations.Add(prereg1);
using (var uow = UoWFactory.Create())
{
var repository = uow.Create();
var updatedMeeting = repository.UpdateGraph(meeting);
uow.Commit();
}
//meeting.PreRegistrations.AddRange(new List<PreRegistration>() { prereg, prereg1 });
//using (var uow = UoWFactory.Create())
//{
// context.ChangeTracker.AttachGraph(meeting);
// prereg1.Text1 = "lkjalkjslkjslkjslkjlsj";
// meeting.PreRegistrations.Remove(prereg1);
// context.SaveChanges();
//}
//using (var context = new EF7BloggContext())
//{
// context.Remove(prereg1);
// context.SaveChanges();
//}
}
public void AddAttendee_should_add_the_meeting_to_the_list_of_attended_meetings_for_the_member()
{
// Arrange
var meeting = new Meeting();
var member = new Member();
// Act
meeting.AddAttendee(member);
// Assert
Assert.That(member.AttendedMeetings.Contains(meeting));
Assert.That(member.AttendedMeetings[0].Attendees.OfType<MemberAttendee>().Any(attendee=>attendee.Member == member));
}
public void AddAttendee_should_accept_a_user_to_be_added()
{
// Arrange
var meeting = new Meeting();
var member = new Member();
// Act
var attendee = meeting.AddAttendee(member) as MemberAttendee;
// Assert
Assert.That(attendee, Is.Not.Null);
Assert.That(attendee.Meeting, Is.EqualTo(meeting));
Assert.That(attendee.Member, Is.EqualTo(member));
}
public void GetAllMeetings()
{
var repository = GetMeetingRepository();
var meeting = new Meeting { Description = "a meeting", Title = "The Title" };
repository.Add(meeting);
repository.Add(meeting);
repository.Add(meeting);
var meetings = repository.GetAllMeetings();
Assert.True(meetings.Count >= 3);
}
public void AddAttendee_should_have_the_original_dateRegistered_when_promoted()
{
// Arrange
var stubMeeting = new Meeting();
const string email = "*****@*****.**";
const string firstname = "FirstName";
const string lastname = "LastName";
var stubMember = new Member() { Email = email };
// Act
var firstAttendee = stubMeeting.AddGuestAttendee(email, firstname, lastname); // first, add the guest
var secondAttendee = stubMeeting.AddAttendee(stubMember) as PromotedAttendee; // second, add the member with the same email
// Assert
Assert.That(secondAttendee.DateRegistered, Is.EqualTo(firstAttendee.DateRegistered));
}
/// <summary>
/// Gets current meeting associated with the context
/// </summary>
/// <returns>meeting</returns>
public Meeting GetCurrentMeeting()
{
var result = this.currentMeeting;
if (result == null)
{
lock (this.syncRoot)
{
if (this.currentMeeting == null)
{
this.currentMeeting = this.LoadMeeting(this.GetCurrentUserToken<SampleUserToken>().UserId, this.CurrentMeetingId);
}
result = this.currentMeeting;
}
}
return result;
}
public void AddAttendee_should_accept_a_guest_registration()
{
// Arrange
var stubMeeting = new Meeting();
const string email = "*****@*****.**";
const string firstname = "FirstName";
const string lastname = "LastName";
// Act
var attendee = stubMeeting.AddGuestAttendee(email, firstname, lastname) as GuestAttendee;
// Assert
Assert.That(attendee, Is.Not.Null);
Assert.That(attendee.Meeting, Is.EqualTo(stubMeeting));
Assert.That(attendee.Email, Is.EqualTo(email));
Assert.That(attendee.FirstName, Is.EqualTo(firstname));
Assert.That(attendee.LastName, Is.EqualTo(lastname));
}
public static Meeting GetMeetingForDB(MeetingFromXML xmlMeeting)
{
var meeting = new Meeting()
{
BetSlipType = xmlMeeting.BetslipType,
Code = xmlMeeting.Code,
Country = xmlMeeting.Country,
Course = RaceCourseController.BuildCourse(xmlMeeting.Venue),
JetBetCode = int.Parse(xmlMeeting.Number),
MDate = xmlMeeting.Date,
MeetingStatus = xmlMeeting.Status,
Name = xmlMeeting.Name,
Penetrometer = xmlMeeting.Penetrometer,
RaceType = xmlMeeting.Type,
TrackDirection = xmlMeeting.TrackDirection,
Venue = xmlMeeting.Venue
};
return meeting;
}
public static Race BuildRaceForDB(RaceFromXML xmlRace, Meeting meeting = null)
{
var race = new Race()
{
Class = ClassController.GetClass(xmlRace.Class),
Distance = int.Parse(xmlRace.Length),
NormTime = xmlRace.NormalTime,
OverseasNumber = xmlRace.OverseasNumber,
RaceName = xmlRace.Name,
RaceNum = int.Parse(xmlRace.Number),
RaceStatus = xmlRace.Status,
Stake = xmlRace.Stake,
TrackCondition = xmlRace.Track,
Venue = xmlRace.Venue,
Weather = xmlRace.Weather,
Meeting = meeting
};
return race;
}
public void GetMeetingsBetween()
{
var repository = GetMeetingRepository();
var meeting1 = new Meeting { Title = "1", StartTime = DateTime.Now.AddDays(-32), EndTime = DateTime.Now.AddDays(-32).AddHours(2) };
var meeting2 = new Meeting { Title = "2", StartTime = DateTime.Now.AddDays(-12), EndTime = DateTime.Now.AddDays(-12).AddHours(2) };
var meeting3 = new Meeting { Title = "3", StartTime = DateTime.Now.AddDays(12), EndTime = DateTime.Now.AddDays(12).AddHours(2) };
var meeting4 = new Meeting { Title = "4", StartTime = DateTime.Now.AddDays(32), EndTime = DateTime.Now.AddDays(32).AddHours(2) };
repository.Add(meeting1);
repository.Add(meeting2);
repository.Add(meeting3);
repository.Add(meeting4);
var upcomingMeetings = repository.GetMeetingsBetween(DateTime.Now.AddDays(-20), DateTime.Now.AddDays(20));
Assert.False(upcomingMeetings.Any(x => x.Title == "1"));
Assert.True(upcomingMeetings.Any(x => x.Title == "2"));
Assert.True(upcomingMeetings.Any(x => x.Title == "3"));
Assert.False(upcomingMeetings.Any(x => x.Title == "4"));
}
public void Update(Meeting meeting)
{
var savedMeeting = AllMeetings.FirstOrDefault(x => x.MeetingId == meeting.MeetingId);
if(meeting.Attendees.SequenceEqual(savedMeeting.Attendees))
{
xmlRepository.Update(meeting, meeting.MeetingId);
return;
}
var attendees = meeting.Attendees;
var uniques = attendees
.Union(savedMeeting.Attendees)
.GroupBy(x => x.Email)
.ToDictionary(x => x.Key, x => x.First());
meeting.Attendees = uniques.Values.ToList();
xmlRepository.Update(meeting, meeting.MeetingId);
}
public void Add_can_insert_a_Meeting_with_a_Facility()
{
var repository = GetMeetingRepository();
var meeting = new Meeting
{
Description = "no",
Facility = new Facility
{
Description = "ok",
Address = new Address
{
City = "Cedar Rapids"
}
}
};
repository.Add(meeting);
Assert.That(meeting.Facility.Address.City, Is.EqualTo("Cedar Rapids"));
}
public void MeetingData_can_be_created_from_Meeting()
{
var meeting = new Meeting
{
Description = "description",
EndTime = endTime,
Facility = facility,
MeetingId = 1234567,
Presenter = "presenter",
StartTime = startTime,
Title = "title"
};
var meetingData = meeting.ToMeetingData();
Assert.That(meeting.Description, Is.EqualTo(meetingData.Description));
Assert.That(meeting.MeetingId, Is.EqualTo(meetingData.MeetingId));
Assert.That(meeting.Presenter, Is.EqualTo(meetingData.Presenter));
Assert.That(meeting.Title, Is.EqualTo(meetingData.Title));
Assert.That(meeting.Facility.FacilityId, Is.EqualTo(meetingData.FacilityId));
Assert.That(meeting.EndTime, Is.EqualTo(meetingData.EndTime));
Assert.That(meeting.StartTime, Is.EqualTo(meetingData.StartTime));
}
public List <Tip> GetTipsAboutPersonForMeeting(Meeting meeting, Contact contact, bool isCloseToTheMeeting)
{
return(DB.GetTipsAboutPersonForMeeting(meeting, contact, isCloseToTheMeeting));
}
public async Task <ActionResult <Meeting> > Update([FromBody] Meeting dto)
{
return(await _meetingService.UpdateMeetingAsync(dto));
}
public async Task <IActionResult> CreateNew([Required][FromBody] MeetingDTO request)
{
if (request.ReadAccess > request.JoinAccess)
{
return(BadRequest("Read access must not be higher than join access"));
}
if (request.ExpectedDuration != null && (request.ExpectedDuration.Value < TimeSpan.FromMinutes(1) ||
request.ExpectedDuration.Value > TimeSpan.FromMinutes(650)))
{
return(BadRequest($"Invalid expected duration, got value: {request.ExpectedDuration}"));
}
if (request.JoinGracePeriod < TimeSpan.FromSeconds(0) ||
request.JoinGracePeriod > TimeSpan.FromMinutes(200))
{
return(BadRequest("Invalid join grace period"));
}
if (request.StartsAt <= DateTime.UtcNow + TimeSpan.FromMinutes(1))
{
return(BadRequest("Can't create a meeting that would have started already"));
}
var access = GetCurrentUserAccess();
if (request.JoinAccess > access)
{
return(BadRequest("Can't create a meeting you couldn't join due to join restriction"));
}
if (await database.Meetings.FirstOrDefaultAsync(m => m.Name == request.Name) != null)
{
return(BadRequest("A meeting with that name already exists"));
}
var user = HttpContext.AuthenticatedUserOrThrow();
var meeting = new Meeting()
{
Name = request.Name,
Description = request.Description,
ReadAccess = request.ReadAccess,
JoinAccess = request.JoinAccess,
JoinGracePeriod = request.JoinGracePeriod,
StartsAt = request.StartsAt,
ExpectedDuration = request.ExpectedDuration,
OwnerId = user.Id,
ChairmanId = user.Id,
};
await database.Meetings.AddAsync(meeting);
await database.ActionLogEntries.AddAsync(new ActionLogEntry()
{
Message = $"New meeting ({meeting.Name}) created, scheduled to start at {meeting.StartsAt}",
PerformedById = user.Id,
});
await database.SaveChangesAsync();
logger.LogInformation("New meeting ({Id}) created by {Email}", meeting.Id, user.Email);
return(Ok());
}
public async Task AddAsync(string userId, ApplicationUser user, int rating, string description, string meetingId, Meeting meeting)
{
Feedback feedback = new Feedback
{
UserId = userId,
User = user,
Rating = rating,
Description = description,
MeetingId = meetingId,
Meeting = meeting,
CreatedOn = DateTime.Now,
};
feedback.Id = Guid.NewGuid().ToString();
await this.feedbackRepository.AddAsync(feedback);
await this.feedbackRepository.SaveChangesAsync();
}
public void Add(Meeting meeting)
{
context.Meetings.Add(meeting);
}
/// <summary>
/// Get list card attachment having list of favorite rooms along with buttons to manage favorites, book meeting for other rooms and refresh list.
/// </summary>
/// <param name="rooms">Rooms schedule response object.</param>
/// <param name="startUTCDateTime">Start date time of meeting.</param>
/// <param name="endUTCDateTime">End date time of meeting.</param>
/// <param name="timeZone">User time zone.</param>
/// <param name="activityReferenceId">Unique GUID related to activity Id from ActivityEntities table.</param>
/// <returns>List card attachment having favorite rooms of user.</returns>
public static Attachment GetFavoriteRoomsListAttachment(RoomScheduleResponse rooms, DateTime startUTCDateTime, DateTime endUTCDateTime, string timeZone, string activityReferenceId = null)
{
ListCard card = new ListCard
{
Title = Strings.RoomAvailability,
Items = new List <ListItem>(),
Buttons = new List <CardAction>(),
};
// For first run, user configuration will be null.
if (timeZone != null)
{
var startTime = TimeZoneInfo.ConvertTimeFromUtc(startUTCDateTime, TimeZoneInfo.FindSystemTimeZoneById(timeZone));
var endTime = TimeZoneInfo.ConvertTimeFromUtc(endUTCDateTime, TimeZoneInfo.FindSystemTimeZoneById(timeZone));
card.Title = string.Format(CultureInfo.CurrentCulture, "{0} | {1} - {2}", Strings.RoomAvailability, startTime.ToString("t", CultureInfo.CurrentCulture), endTime.ToString("t", CultureInfo.CurrentCulture));
}
ListItem room = new ListItem();
Meeting meeting;
if (rooms?.Schedules.Count > 0)
{
foreach (var item in rooms.Schedules)
{
string availability;
string availabilityColor;
// Schedule will be null in case room is deleted from exchange but sync service still gets room from Graph API as Graph takes time to reflect deleted item.
if (item.ScheduleItems != null && item.ScheduleItems.Count == 0)
{
availability = Strings.Available;
availabilityColor = GreenColorCode;
}
else
{
availability = Strings.Unavailable;
availabilityColor = RedColorCode;
}
var subtitle = string.Format(CultureInfo.CurrentCulture, "{0} | <b><font color='{1}'>{2}</font></b>", item.BuildingName, availabilityColor, availability);
meeting = new Meeting
{
EndDateTime = DateTime.SpecifyKind(endUTCDateTime, DateTimeKind.Utc).ToString("o"),
RoomEmail = item.ScheduleId,
RoomName = item.RoomName,
StartDateTime = DateTime.SpecifyKind(startUTCDateTime, DateTimeKind.Utc).ToString("o"),
BuildingName = item.BuildingName,
Status = availability,
Text = BotCommands.CreateMeeting,
};
card.Items.Add(new ListItem
{
Id = item.ScheduleId,
Title = item.RoomName,
Subtitle = subtitle,
Type = "person",
Tap = new CardAction {
Type = ActionTypes.MessageBack, Text = BotCommands.CreateMeeting, Title = BotCommands.CreateMeeting, Value = JsonConvert.SerializeObject(meeting)
},
});
}
}
else
{
room = new ListItem
{
Title = Strings.NoFavoriteRooms,
Type = "section",
};
}
card.Items.Add(room);
CardAction addFavoriteButton = new TaskModuleAction(Strings.ManageFavorites, new { data = JsonConvert.SerializeObject(new AdaptiveTaskModuleCardAction {
Text = BotCommands.ShowFavoriteTaskModule, ActivityReferenceId = activityReferenceId
}) });
card.Buttons.Add(addFavoriteButton);
CardAction otherRoomButton = new TaskModuleAction(Strings.OtherRooms, new { data = JsonConvert.SerializeObject(new AdaptiveTaskModuleCardAction {
Text = BotCommands.ShowOtherRoomsTaskModule, ActivityReferenceId = activityReferenceId
}) });
card.Buttons.Add(otherRoomButton);
CardAction bookRoomNowButton = new TaskModuleAction(Strings.BookRoomNow, new { data = JsonConvert.SerializeObject(new AdaptiveTaskModuleCardAction {
Text = BotCommands.BookAMeetingNow, ActivityReferenceId = activityReferenceId
}) });
card.Buttons.Add(bookRoomNowButton);
if (rooms?.Schedules.Count > 0)
{
CardAction refreshListButton = new CardAction
{
Title = Strings.Refresh,
Type = ActionTypes.MessageBack,
Text = BotCommands.RefreshList,
Value = JsonConvert.SerializeObject(new AdaptiveTaskModuleCardAction {
Text = BotCommands.RefreshList, ActivityReferenceId = activityReferenceId
}),
};
card.Buttons.Add(refreshListButton);
}
var attachment = new Attachment()
{
ContentType = "application/vnd.microsoft.teams.card.list",
Content = card,
};
return(attachment);
}
protected async Task <IEnumerable <MeetingTimeCandidate> > GetAllTimeCandidates(Meeting meeting)
{
using (new Loading(this))
{
return(await GraphService.FindMeetingTimes(meeting));
}
}
protected void SendRunningLate(Meeting meeting)
{
NavigateToEmail(meeting, OData.ReplyAll, GetString("RunningLate"));
}
protected void NavigateToAttachments(IEnumerable <FileAttachment> attachments, Meeting meeting)
{
UI.NavigateTo("Attachments", Tuple.Create(attachments, meeting.Id, meeting.IsOrganizer));
}
public string SourcefilePath(Meeting meeting)
{
return(Path.Combine(WorkfolderPath(meeting), meeting.SourceFilename));
}
public Meeting Add(Meeting entity)
{
_context.Add <Meeting>(entity);
_context.SaveChanges();
return(entity);
}
public SelectedMeetingDto(Meeting meeting, string courseName)
{
Meeting = meeting;
CourseName = courseName;
}
public DbEntityEntry <Meeting> Entry(Meeting meeting)
{
return(Context.Entry(meeting));
}
public Meeting ToEntity()
{
var meeting = new Meeting
{
MeetingID = MeetingID,
Title = Title,
Start = Start,
StartTimezone = StartTimezone,
End = End,
EndTimezone = EndTimezone,
Description = Description,
IsAllDay = IsAllDay,
RecurrenceRule = RecurrenceRule,
RecurrenceException = RecurrenceException,
RecurrenceID = RecurrenceID,
RoomID = RoomID
};
return meeting;
}
public async Task <IActionResult> Edit(int id, [Bind("ID,MeetingDate,OptionalRestHymnTitle")] Meeting meeting)
{
if (id != meeting.ID)
{
return(NotFound());
}
meeting.Ward = GetSelectedWard("WardSelect");
meeting.FastAndTestimonyMeeting = (Request.Form["FastMeeting"].Count > 0);
meeting.Presiding = GetSelectedMember("PresidingSelect");
meeting.ConductingLeader = GetSelectedMember("ConductingSelect");
meeting.Chorister = GetSelectedMember("ChoristerSelect");
meeting.Organist = GetSelectedMember("OrganistSelect");
meeting.OpeningHymn = GetSelectedHymn("OpeningHymnSelect");
meeting.OpeningPrayerMember = GetSelectedMember("OpeningPrayerSelect");
if (Request.Form["Announcements"].Count > 0)
{
meeting.Announcements = Request.Form["Announcements"][0];
}
meeting.SacramentHymn = GetSelectedHymn("SacramentHymnSelect");
if (Request.Form["RestHymnSelect"].Count > 0)
{
meeting.OptionalRestHymnTitle = Request.Form["RestHymnSelect"][0];
}
meeting.OptionalRestHymnMember = GetSelectedMember("RestHymnMemberSelect");
meeting.ClosingHymn = GetSelectedHymn("ClosingHymnSelect");
meeting.ClosingPrayerMember = GetSelectedMember("ClosingPrayerSelect");
if (ModelState.IsValid)
{
try
{
_context.Update(meeting);
// Remove Speakers
var sp = _context.Speakers.Where(obj => obj.Meeting.Equals(meeting));
foreach (Speaker element in sp)
{
Debug.WriteLine("Speaker ID : {0}", element.ID);
_context.Speakers.Remove(element);
}
//await _context.SaveChangesAsync();
// Add Speakers
int count = Request.Form["SpeakerMember"].Count;
for (int i = 0; i < count; i++)
{
Speaker s = new Speaker
{
Meeting = meeting,
Member = _context.Members.Find(int.Parse(Request.Form["SpeakerMember"][i])),
Topic = Request.Form["SpeakerTopic"][i],
Minutes = int.Parse(Request.Form["SpeakerMinutes"][i]),
};
_context.Speakers.Add(s);
}
// End add
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MeetingExists(meeting.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(meeting));
}
public IHttpActionResult PutMeeting(int id, Meeting meeting)
{
throw new NotImplementedException();
}
public UI14OnePhaseReopening()
{
CurrentMeeting = new Meeting();
InitializeComponent();
}
public void Attach(Meeting meeting)
{
context.Meetings.Attach(meeting);
}
private async Task<EventMessage> GetEventInvitation(Meeting meeting)
{
string uri = BuildInvitationsUri(meeting);
var invites = await new HttpHelper().GetItemsAsync<EventMessage>(uri);
var orderedInvites = invites.OrderBy(x => x.CreatedDateTime);
var invite = orderedInvites.FirstOrDefault(x => x.Type.EqualsCaseInsensitive("#microsoft.graph.eventMessage"));
return invite;
}
public void DoWork(Meeting meeting)
{
// TODO - Send alerts
meeting.WorkStatus = WorkStatus.Alerted;
}
private void BuildFilter(StringBuilder sb, Meeting meeting)
{
sb.Append(string.Format("Subject eq '{0}'", meeting.Subject));
AddTimeStamp(sb, meeting);
}
public MeetingContactsVM(Meeting meeting, CWTPaginatedList <spDesktopDataAdmin_SelectMeetingContacts_v1Result> contacts)
{
Meeting = meeting;
Contacts = contacts;
}
public IActionResult AddMeeting(Meeting meeting)
{
if (HttpContext.Session.GetString("FNAME") != null)
{
ViewBag.positionid = HttpContext.Session.GetString("POSITIONID");
ViewBag.firstname = HttpContext.Session.GetString("FNAME");
ViewBag.teacherid = HttpContext.Session.GetString("TEACHERID");
ViewBag.adminid = HttpContext.Session.GetString("ADMINID");
ViewBag.studentid = HttpContext.Session.GetString("STUDENTID");
int ids = Convert.ToInt32(ViewBag.studentid);
int countMsg = _context.tblInbox.Count(x => x.studentid == ids);
HttpContext.Session.SetString("countMsg", Convert.ToString(countMsg));
ViewBag.numberofmsg = HttpContext.Session.GetString("countMsg");
List <Meeting> listofmeeting = _context.tblMeeting.ToList();
//ViewBag.Listofteacher = ListOfTeachers;
List <Student> listofstudent = _context.tblStudent.ToList();
List <MeetingTime> listofmeetingtime = _context.tblMeetingTime.ToList();
List <Teacher> ListOfTeachers = _context.tblTeacher.ToList();
ViewBag.ListOfTeachers = ListOfTeachers;
ViewBag.listofmeetingtime = listofmeetingtime;
var joinedtable = from me in listofmeeting
join s in listofstudent on me.studentid equals s.studentid
join mt in listofmeetingtime on me.meetingtimeid equals mt.meetingtimeid
join t in ListOfTeachers on me.teacherid equals t.teacherid
select new NewVM {
listofstudent = s, listofmeeting = me, listofmeetingtime = mt, ListOfTeachers = t
};
Meeting m = new Meeting();
var checker = joinedtable.Where(x => x.ListOfTeachers.teacherid == meeting.teacherid && x.listofmeeting.dateofmeeting == meeting.dateofmeeting && x.listofmeetingtime.meetingtimeid == meeting.meetingtimeid).FirstOrDefault();
if (checker == null)
{
m.studentid = Convert.ToInt32(ViewBag.studentid);
m.requestedtime = DateTime.Now;
DateTime dateofmeeting = meeting.dateofmeeting.Date;
m.dateofmeeting = dateofmeeting;
m.meetingtimeid = meeting.meetingtimeid;
m.teacherid = meeting.teacherid;
m.status = "Incomplete";
m.about = meeting.about;
_context.Add(m);
_context.SaveChanges();
TempData["success"] = "Your appointment scheduled successfully";
//ViewBag.positionid = HttpContext.Session.GetString("POSITIONID");
return(RedirectToAction("Create"));
}
else
{
TempData["duprecord"] = "This time slot is already booked. Try Again!";
return(RedirectToAction("Create"));
}
}
else
{
return(RedirectToAction("Index", "Signin"));
}
}
public UI14OnePhaseReopening(Tendering t)
{
CurrentTendering = t;
CurrentMeeting = DataManagement.SearchOrCreateMeeting(t, MeetingType);
InitializeComponent();
}
public static void Seed(this FriendsOrganizerDbContext dbContext)
{
if (!dbContext.Friends.Any())
{
var newFriends = new List <Friend>()
{
new Friend()
{
FirstName = "John", LastName = "Dow", Email = "*****@*****.**"
},
new Friend()
{
FirstName = "Jayne", LastName = "Dow", Email = "*****@*****.**"
},
new Friend()
{
FirstName = "Tom", LastName = "Cat", Email = "*****@*****.**"
},
new Friend()
{
FirstName = "Jerry", LastName = "Mouce", Email = "*****@*****.**"
}
};
dbContext.Friends.AddRange(newFriends);
dbContext.SaveChanges();
}
if (!dbContext.ProgrammingLanguages.Any())
{
var newProgrammingLanguages = new List <ProgrammingLanguage>()
{
new ProgrammingLanguage()
{
Name = "C#"
},
new ProgrammingLanguage()
{
Name = "Java"
},
new ProgrammingLanguage()
{
Name = "F#"
},
new ProgrammingLanguage()
{
Name = "C++"
},
new ProgrammingLanguage()
{
Name = "C"
},
};
dbContext.ProgrammingLanguages.AddRange(newProgrammingLanguages);
dbContext.SaveChangesAsync();
}
if (!dbContext.FriendsPhonesNumbers.Any())
{
var newPhoneNumber = new FriendPhoneNumber()
{
PhoneNumber = "+35988765342", FriendId = dbContext.Friends.FirstOrDefault().Id
};
dbContext.FriendsPhonesNumbers.AddAsync(newPhoneNumber);
dbContext.SaveChangesAsync();
}
if (!dbContext.Meetings.Any())
{
var newMeetingNumber = new Meeting()
{
Title = "Watching Socker",
StartAt = DateTime.Now.Date,
EndAt = DateTime.Now.Date,
FriendMeetings = new List <FriendMeeting>()
{
new FriendMeeting()
{
FriendId = dbContext.Friends.FirstOrDefault().Id,
}
}
};
dbContext.Meetings.AddAsync(newMeetingNumber);
dbContext.SaveChangesAsync();
}
}
public void PostMeeting([FromBody] Meeting meeting)
{
meeting.Id = Guid.NewGuid();
context.Meeting.Add(meeting);
context.SaveChanges();
}
public void SaveMeeting(Meeting input)
{
_strategy.SaveMeeting(_context, input);
}
public async Task<IEnumerable<MeetingTimeCandidate>> GetMeetingTimeCandidates(Meeting meeting, string startTime, string endTime)
{
var body = BuildRequestBody(meeting, startTime, endTime);
string uri = "https://outlook.office365.com/api/beta/me/findmeetingtimes";
var candidates = await new HttpHelper().PostItemAsync<MeetingTimes, MeetingTimeCandidates> (uri, body);
return candidates == null ? Enumerable.Empty<MeetingTimeCandidate>(): candidates.Value;
}
public Meeting Create(Meeting t)
{
return(mc.Create(t));
}
public async Task<EventMessage> CreateInvitationResponse(Meeting meeting, string action)
{
var invite = await GetEventInvitation(meeting);
string responseUri = BuildResponseUri(invite.Id, action);
var reply = await new HttpHelper().PostItemAsync<EventMessage>(responseUri);
return reply;
}
public bool RemoveMeeting(Meeting meeting)
{
return(RemoveMeeting(meeting.IDMeeting));
}
private string BuildInvitationsUri(Meeting meeting)
{
StringBuilder sb = new StringBuilder("MailFolders");
sb.Append(meeting.IsOrganizer ? "/SentItems/" : "/Inbox/");
sb.Append("Messages");
sb.Append("?$filter=");
BuildFilter(sb, meeting);
return sb.ToString();
}
public Meeting Read(Meeting t)
{
return(mc.Read(t));
}
private void AddTimeStamp(StringBuilder sb, Meeting meeting)
{
sb.Append(" and ");
sb.Append("CreatedDateTime").Append(" gt ");
sb.Append(meeting.CreatedDateTime);
}
public Meeting Update(Meeting t)
{
return(mc.Update(t));
}
public Meeting Delete(Meeting t)
{
return(mc.Delete(t));
}
private void WriteMeeting(Meeting meeting, Dictionary <string, int> groupIndexDict, SheetModifier modifier)
{
var horizOffset = 2;
var vertOffset = 3;
var weekDayToIntDict = new Dictionary <DayOfWeek, int>()
{
{ DayOfWeek.Monday, 0 },
{ DayOfWeek.Tuesday, 1 },
{ DayOfWeek.Wednesday, 2 },
{ DayOfWeek.Thursday, 3 },
{ DayOfWeek.Friday, 4 },
{ DayOfWeek.Saturday, 5 },
{ DayOfWeek.Sunday, 6 }
};
foreach (var group in meeting.Groups)
{
var data = $"{meeting.Discipline}, {meeting.Location}, {meeting.Teacher?.Name}";
var rowNumOff = weekDayToIntDict[meeting.MeetingTime.Day] * 12 + vertOffset;
var rowNum = meeting.MeetingTime.TimeSlotIndex * 2 + rowNumOff;
var rowsInMeeting = 1;
if (meeting.WeekType == WeekType.Even)
{
rowNum++;
}
if (meeting.WeekType == WeekType.Any)
{
rowsInMeeting = 2;
}
var colNum = groupIndexDict[group.GroupName] * 2 + horizOffset;
var columnsInMeeting = 1;
if (group.GroupPart == GroupPart.Part2 || group.GroupPart == GroupPart.Part3)
{
colNum++;
}
if (group.GroupPart == GroupPart.FullGroup)
{
columnsInMeeting = 2;
}
Console.WriteLine($"rowNumOff: {rowNumOff}");
Console.WriteLine($"C: {colNum} R:{rowNum} C: {colNum + columnsInMeeting - 1} R: {rowNum + rowsInMeeting - 1}");
modifier
.WriteRange((rowNum, colNum), new List <List <string> >()
{
new List <string>()
{
data
}
})
.AddBorders((rowNum, colNum), (rowNum + rowsInMeeting - 1, colNum + columnsInMeeting - 1), new Color()
{
Green = 1
});
if (rowsInMeeting == 2 || columnsInMeeting == 2)
{
modifier.MergeCell((rowNum, colNum), (rowNum + rowsInMeeting - 1, colNum + columnsInMeeting - 1));
}
}
}
