public Task <bool> updateNotificationsAsync(object notif)
{
if (notif is AmountConstraint)
{
AmountConstraint castedNotif = (AmountConstraint)notif;
var existingNotif = _context.AmountConstraint
.Where(x => x.NotificationId == castedNotif.NotificationId)
.FirstOrDefault();
if (existingNotif != null)
{
existingNotif.Min = castedNotif.Min;
existingNotif.Max = castedNotif.Max;
_context.SaveChanges();
}
else
{
return(Task.FromResult(false));
}
}
else if (notif is TimeConstraint)
{
TimeConstraint castedNotif = (TimeConstraint)notif;
var existingNotif = _context.TimeConstraint
.Where(x => x.NotificationId == castedNotif.NotificationId)
.FirstOrDefault();
if (existingNotif != null)
{
existingNotif.TimeIn = castedNotif.TimeIn;
existingNotif.TimeOut = castedNotif.TimeOut;
_context.SaveChanges();
}
else
{
return(Task.FromResult(false));
}
}
else if (notif is LocationConstraint)
{
LocationConstraint castedNotif = (LocationConstraint)notif;
var existingNotif = _context.LocationConstraint
.Where(x => x.NotificationId == castedNotif.NotificationId)
.FirstOrDefault();
if (existingNotif != null)
{
existingNotif.Location = castedNotif.Location;
_context.SaveChanges();
}
else
{
return(Task.FromResult(false));
}
}
return(Task.FromResult(true));
}
private static FindMeetingTimeRequest GetFindMeetingTimeRequest(MeetingRoom m, IEnumerable <Staff> staff, int duration)
{
var req = new FindMeetingTimeRequest();
req.returnSuggestionReasons = "true";
// attendees
var attendees = new List <Attendee>();
attendees.Add(new Attendee()
{
type = "required",
emailAddress = new EmailAddress()
{
address = m.RoomName + "@xinsnake.onmicrosoft.com"
}
});
foreach (var s in staff)
{
attendees.Add(new Attendee()
{
type = "required",
emailAddress = new EmailAddress()
{
name = s.displayName,
address = s.mail
}
});
}
req.attendees = attendees;
// time constraint
var timeSlots = new List <Timeslot>();
timeSlots.Add(DateHelper.GetNextMeetingTimeslot());
var tc = new TimeConstraint()
{
activityDomain = "unrestricted",
timeslots = timeSlots
};
req.timeConstraint = tc;
// timespan
var timeSpan = TimeSpan.FromMinutes(duration);
req.meetingDuration = XmlConvert.ToString(timeSpan);
return(req);
}
public async Task <MeetingTimeSuggestionsResult> FindMeetingSuggestion(FindRoomRequest request)
{
List <Attendee> attendees = new List <Attendee>();
// Adding placeholder user to be able to remove the
// Required flag on the user looking for available rooms.
// An empty collection causes findMeetingTimes to look for free time slots for only the organizer.
if (!string.IsNullOrEmpty(WebConfigurationManager.AppSettings["PlaceholderAttendeeEmail"]))
{
attendees = new List <Attendee>()
{
new Attendee()
{
EmailAddress = new EmailAddress()
{
Address = WebConfigurationManager.AppSettings["PlaceholderAttendeeEmail"]
}
}
};
}
var locationConstraint = new LocationConstraint()
{
IsRequired = true,
SuggestLocation = true,
};
var timeConstraint = new TimeConstraint()
{
ActivityDomain = ActivityDomain.Unrestricted,
Timeslots = new List <TimeSlot>()
{
new TimeSlot()
{
Start = new DateTimeTimeZone()
{
DateTime = request.From.ToString(),
TimeZone = "UTC"
},
End = new DateTimeTimeZone()
{
DateTime = request.To.ToString(),
TimeZone = "UTC"
}
}
}
};
return(await _graphClient.Me.FindMeetingTimes(attendees, TimeConstraint : timeConstraint, MeetingDuration : new Duration(request.Duration), IsOrganizerOptional : attendees.Any(), LocationConstraint : locationConstraint)
.Request()
.PostAsync());
}
public string GetKey(object o)
{
TimeConstraint val = o as TimeConstraint; // guaranteed to be not null (CanConvert)
switch (val.Mode)
{
case TimeConstraintMode.Before:
return("before");
case TimeConstraintMode.Since:
return("since");
default:
throw new InvalidOperationException("Unhandled time constraint mode");
}
}
public async Task <List <TimeConstraint> > GetTimeConstraints(List <UserToNotifications> notifArray)
{
List <TimeConstraint> timeConstraints = new List <TimeConstraint>();
List <TimeConstraint> testC = new List <TimeConstraint>();
foreach (var z in notifArray)
{
testC = _context.TimeConstraint.Where(x => x.NotificationId == z.NotificationId).ToList();
if (testC.Count > 0)
{
TimeConstraint temp = _context.TimeConstraint.Where(x => x.NotificationId == z.NotificationId).ToList()[0];
timeConstraints.Add(temp);
}
}
return(timeConstraints);
}
private async Task <MeetingTimeSuggestionsResult> FindMeetingTimesAsync(IEnumerable <AttendeeBase> attendees, TimeConstraint timeConstraint = null, bool isOrgnizerOptional = true)
{
try
{
var suggestion = await _graphClient.Me.FindMeetingTimes(attendees, timeConstraint : timeConstraint, isOrganizerOptional : isOrgnizerOptional).Request().PostAsync();
return(suggestion);
}
catch (ServiceException ex)
{
throw GraphClient.HandleGraphAPIException(ex);
}
}
private async Task <MeetingTimeSuggestionsResult> FindMeetingSuggestions(DateTimeTimeZone start, DateTimeTimeZone end)
{
var timeZone = User.GetUserGraphTimeZone();
var attendees = new List <AttendeeBase>()
{
new AttendeeBase
{
Type = AttendeeType.Required,
EmailAddress = new EmailAddress
{
Name = "seetharam konda",
Address = "*****@*****.**"
}
}
};
var locationConstraint = new LocationConstraint
{
IsRequired = false,
SuggestLocation = false,
Locations = new List <LocationConstraintItem>()
{
new LocationConstraintItem
{
ResolveAvailability = false,
DisplayName = "Conf room Hood"
}
}
};
var timeConstraint = new TimeConstraint
{
ActivityDomain = ActivityDomain.Work,
TimeSlots = new List <TimeSlot>()
{
new TimeSlot
{
Start = start,
End = end
//Start = new DateTimeTimeZone
//{
// DateTime = "2019-04-16T09:00:00",
// TimeZone = "Pacific Standard Time"
//},
//End = new DateTimeTimeZone
//{
// DateTime = "2019-04-18T17:00:00",
// TimeZone = "Pacific Standard Time"
//}
}
}
};
var isOrganizerOptional = false;
var meetingDuration = new Duration("PT1H");
var returnSuggestionReasons = true;
var minimumAttendeePercentage = (double)100;
MeetingTimeSuggestionsResult x = await _graphClient.Me
.FindMeetingTimes(attendees, locationConstraint, timeConstraint, meetingDuration, null, isOrganizerOptional, returnSuggestionReasons, minimumAttendeePercentage)
.Request()
.Header("Prefer", "outlook.timezone=\"India Standard Time\"")
.PostAsync();
return(x);
}
public string Convert(object o)
{
TimeConstraint val = o as TimeConstraint;
return(val.ContainerId);
}
public async Task <List <MeetingTimeCandidate> > FindMeetingTime()
{
// Get the group id.
//var group = await graphClient.Groups[id].Request().GetAsync();
User me = await graphClient.Me.Request().Select("mail,userPrincipalName").GetAsync();
//Build the list of attendees
List <Attendee> attendees = new List <Attendee>();
Attendee attendee = new Attendee();
EmailAddress mailaddress1 = new EmailAddress();
mailaddress1.Address = me.Mail;
attendee.EmailAddress = mailaddress1;
attendees.Add(attendee);
//Build the list of locationcontraints
LocationConstraint location = new LocationConstraint();
location.IsRequired = false;
location.SuggestLocation = false;
List <LocationConstraintItem> locationConstraints = new List <LocationConstraintItem>();
locationConstraints.Add(new LocationConstraintItem {
DisplayName = "", LocationEmailAddress = "*****@*****.**"
});
//Build the duration
Duration duration = new Duration("PT1H");
TimeConstraint timeConstraint = new TimeConstraint();
List <TimeSlot> timeSlots = new List <TimeSlot>();
TimeSlot slot1 = new TimeSlot();
Microsoft.Graph.DateTimeTimeZone start = new Microsoft.Graph.DateTimeTimeZone();
start.DateTime = @"2017-06-10T15:30:00.000";
start.TimeZone = @"W. Europe Standard Time";
Microsoft.Graph.DateTimeTimeZone end = new Microsoft.Graph.DateTimeTimeZone();
end.DateTime = @"2017-06-14T18:00:00.000";
end.TimeZone = @"W. Europe Standard Time";
slot1.Start = start;
slot1.End = end;
timeSlots.Add(slot1);
timeConstraint.Timeslots = timeSlots;
//Execute the request
var request = graphClient.Me.FindMeetingTimes(attendees, location, timeConstraint, duration, 3, false, false, 50).Request();
MeetingTimeSuggestionsResult meetingSuggestions = await request.PostAsync();
List <MeetingTimeCandidate> meetingTimeCandidates = new List <MeetingTimeCandidate>();
// Create model objects
foreach (MeetingTimeSuggestion meetingJson in meetingSuggestions.MeetingTimeSuggestions)
{
MeetingTimeCandidate candidate = new MeetingTimeCandidate
{
Confidence = meetingJson.Confidence.Value,
MeetingTimeSlotStart = meetingJson.MeetingTimeSlot.Start.DateTime,
MeetingTimeSlotEnd = meetingJson.MeetingTimeSlot.End.DateTime,
OrganizerAvailability = meetingJson.OrganizerAvailability.Value.ToString() ?? string.Empty,
SuggestionHint = meetingJson.SuggestionReason
};
meetingTimeCandidates.Add(candidate);
}
return(meetingTimeCandidates);
}
public Task <bool> DeleteNotificationAsync(object notif)
{
if (notif is AmountConstraint)
{
AmountConstraint castedNotif = (AmountConstraint)notif;
var existingNotif = _context.AmountConstraint
.Where(x => x.NotificationId == castedNotif.NotificationId)
.FirstOrDefault();
var existingJoin = _context.UserToNotifications
.Where(y => y.NotificationId == castedNotif.NotificationId)
.FirstOrDefault();
if (existingNotif != null)
{
_context.AmountConstraint.Remove(existingNotif);
_context.UserToNotifications.Remove(existingJoin);
_context.SaveChanges();
}
else
{
return(Task.FromResult(false));
}
}
else if (notif is TimeConstraint)
{
TimeConstraint castedNotif = (TimeConstraint)notif;
var existingNotif = _context.TimeConstraint
.Where(x => x.NotificationId == castedNotif.NotificationId)
.FirstOrDefault();
var existingJoin = _context.UserToNotifications
.Where(y => y.NotificationId == castedNotif.NotificationId)
.FirstOrDefault();
if (existingNotif != null)
{
_context.TimeConstraint.Remove(existingNotif);
_context.UserToNotifications.Remove(existingJoin);
_context.SaveChanges();
}
else
{
return(Task.FromResult(false));
}
}
else if (notif is LocationConstraint)
{
LocationConstraint castedNotif = (LocationConstraint)notif;
var existingNotif = _context.LocationConstraint
.Where(x => x.NotificationId == castedNotif.NotificationId)
.FirstOrDefault();
var existingJoin = _context.UserToNotifications
.Where(y => y.NotificationId == castedNotif.NotificationId)
.FirstOrDefault();
if (existingNotif != null)
{
_context.LocationConstraint.Remove(existingNotif);
_context.UserToNotifications.Remove(existingJoin);
_context.SaveChanges();
}
else
{
return(Task.FromResult(false));
}
}
return(Task.FromResult(true));
}
/// <summary>
/// Adds a new TimeConstraint notification rule to database context
/// </summary>
/// <param name="newNotif"></param>
/// <returns>true or false from Task</returns>
public Task <TimeConstraint> AddTimeNotification(TimeConstraint newNotif)
{
_context.TimeConstraint.Add(newNotif);
_context.SaveChanges();
return(Task.FromResult(newNotif));
}
/// <summary>
/// Gets the user available times.
/// </summary>
/// <param name="ssoToken">The sso access token used to make request against graph apis.</param>
/// <param name="constraints">The time constraint for finding free times.</param>
/// <param name="organizer">The organizer the ssoToken belongs to.</param>
/// <param name="azureADSettings">The Azure AD application settings.</param>
/// <param name="maxTimeSlots">The maximum number of time slots to return.</param>
/// <param name="emailAddresses">Emails.</param>
/// <returns>A <see cref="Task{TResult}"/> representing the result of the asynchronous operation.</returns>
public static async Task<Dictionary<string, List<TimeBlock>>> GetAvailableTimeSlotsAsync(string ssoToken, IEnumerable<TimeSlot> constraints, AgentAvailability organizer, AzureADSettings azureADSettings, int? maxTimeSlots = null, IEnumerable<string> emailAddresses = null)
{
// setup graph client
var authProvider = CreateOnBehalfOfProvider(azureADSettings, new[] { "Calendars.Read" });
GraphServiceClient graphServiceClient = new GraphServiceClient(authProvider);
// define the time constraints
var timeConstaint = new TimeConstraint
{
ActivityDomain = ActivityDomain.Work,
TimeSlots = constraints,
};
// add the attendees
var attendees = new List<AttendeeBase>();
foreach (var address in emailAddresses)
{
var attendee = new AttendeeBase
{
Type = AttendeeType.Required,
EmailAddress = new EmailAddress
{
Address = address,
},
};
attendees.Add(attendee);
}
bool isMe = emailAddresses.Count() == 0;
try
{
// perform the graph call for find meeting times
var result = await graphServiceClient.Me.FindMeetingTimes(timeConstraint: timeConstaint, maxCandidates: maxTimeSlots, attendees: attendees, isOrganizerOptional: !isMe, minimumAttendeePercentage: 10)
.Request()
.WithUserAssertion(new UserAssertion(ssoToken))
.PostAsync();
// return an empty collection if EmptySuggestionsReason returned
if (!result.EmptySuggestionsReason.Equals(string.Empty))
{
return new Dictionary<string, List<TimeBlock>>();
}
// pivot the results from timeblock centric to user centric
Dictionary<string, List<TimeBlock>> dictionary = new Dictionary<string, List<TimeBlock>>();
foreach (var timeslot in result.MeetingTimeSuggestions.ToList())
{
if (isMe)
{
if (timeslot.OrganizerAvailability != FreeBusyStatus.Free)
{
continue;
}
if (!dictionary.ContainsKey(organizer.Emailaddress))
{
dictionary.Add(organizer.Emailaddress, new List<TimeBlock>());
}
dictionary[organizer.Emailaddress].Add(new TimeBlock()
{
StartDateTime = timeslot.MeetingTimeSlot.Start.ToDateTimeOffset().ToUniversalTime(),
EndDateTime = timeslot.MeetingTimeSlot.End.ToDateTimeOffset().ToUniversalTime(),
});
}
else
{
foreach (var agent in timeslot.AttendeeAvailability)
{
if (agent.Availability.GetValueOrDefault(FreeBusyStatus.Unknown) != FreeBusyStatus.Free)
{
continue;
}
if (!dictionary.ContainsKey(agent.Attendee.EmailAddress.Address))
{
dictionary.Add(agent.Attendee.EmailAddress.Address, new List<TimeBlock>());
}
dictionary[agent.Attendee.EmailAddress.Address].Add(new TimeBlock()
{
StartDateTime = timeslot.MeetingTimeSlot.Start.ToDateTimeOffset().ToUniversalTime(),
EndDateTime = timeslot.MeetingTimeSlot.End.ToDateTimeOffset().ToUniversalTime(),
});
}
}
}
return dictionary;
}
catch (Exception)
{
return new Dictionary<string, List<TimeBlock>>();
}
}
public MeetingTimes()
{
Attendees = new List <AttendeeBase>();
TimeConstraint = new TimeConstraint();
}
public async Task <List <TimeSlot> > FindMeetingTimes(string attendees, double duration)
{
try
{
var graphClient = GetAuthenticatedClient();
List <string> attendeeEmails = await GetAttendeesEmails(attendees);
var attendeeList = new List <AttendeeBase>();
foreach (string email in attendeeEmails)
{
attendeeList.Add(
new AttendeeBase
{
Type = AttendeeType.Required,
EmailAddress = new EmailAddress
{
Address = email
}
});
}
var timeConstraint = new TimeConstraint
{
ActivityDomain = ActivityDomain.Work,
TimeSlots = new List <TimeSlot>()
{
new TimeSlot
{
Start = new DateTimeTimeZone
{
DateTime = DateTime.Now.ToString(),
TimeZone = "Pacific Standard Time"
},
End = new DateTimeTimeZone
{
DateTime = DateTime.Now.AddDays(5).ToString(),
TimeZone = "P Standard Time"
}
}
}
};
var meetingDuration = new Duration(System.Xml.XmlConvert.ToString(TimeSpan.FromHours(duration)));
var minimumAttendeePercentage = 100;
HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", _token);
var body = new
{
attendeeList,
meetingDuration,
minimumAttendeePercentage
};
HttpResponseMessage response = await client.PostAsJsonAsync(
"https://graph.microsoft.com/v1.0/me/findMeetingTimes", body); //call findMeetingTimes graph API
response.EnsureSuccessStatusCode();
var meetingTimeSuggestionsResult = await response.Content.ReadAsAsync <MeetingTimeSuggestionsResult>();
var timeSuggestions = new List <TimeSlot>();
foreach (MeetingTimeSuggestion meetingTimeSuggestion in meetingTimeSuggestionsResult.MeetingTimeSuggestions)
{
timeSuggestions.Add(meetingTimeSuggestion.MeetingTimeSlot);
}
return(timeSuggestions);
}
catch (Exception e)
{
throw e;
}
}
private async void CalendarInviteButton_Click(object sender, RoutedEventArgs e)
{
// Call app specific code to subscribe to the service. For example:
//BigTextArea.Text = PersonName.Text;
try
{
GraphServiceClient graphClient = ProviderManager.Instance.GlobalProvider.Graph;
var user = await graphClient.Users[PersonEmail.Text.ToString()]
.Request()
.GetAsync();
var attendees = new List <AttendeeBase>()
{
new AttendeeBase
{
EmailAddress = new EmailAddress
{
Address = user.Mail,
Name = user.DisplayName
},
Type = AttendeeType.Required
}
};
var timeConstraint = new TimeConstraint
{
TimeSlots = new List <TimeSlot>()
{
new TimeSlot
{
Start = new DateTimeTimeZone
{
DateTime = "2020-07-12T19:58:00.557Z",
TimeZone = "Pacific Standard Time"
},
End = new DateTimeTimeZone
{
DateTime = "2020-07-19T19:58:00.557Z",
TimeZone = "Pacific Standard Time"
}
}
}
};
var locationConstraint = new LocationConstraint
{
IsRequired = false,
SuggestLocation = true,
Locations = new List <LocationConstraintItem>()
{
new LocationConstraintItem
{
DisplayName = "Conf Room 32/1368",
LocationEmailAddress = "*****@*****.**"
}
}
};
var meetingDuration = new Microsoft.Graph.Duration("PT1H");
MeetingTimeSuggestionsResult response = await graphClient.Me
.FindMeetingTimes(attendees, null, null, meetingDuration, null, null, null, null)
//.FindMeetingTimes(attendees, locationConstraint, timeConstraint, meetingDuration, null, null, null, null)
.Request()
.PostAsync();
if (response.MeetingTimeSuggestions.Count() == 0)
{
BigTextArea.Text = "No common meeting time found";
}
else
{
var StartTime = response.MeetingTimeSuggestions.First().MeetingTimeSlot.Start;
var EndTime = response.MeetingTimeSuggestions.First().MeetingTimeSlot.End;
// Calendar Invite
var @event = new Event
{
Subject = "My Calendar Invite via code",
Start = StartTime,
End = EndTime,
Attendees = new List <Attendee>()
{
new Attendee
{
EmailAddress = new EmailAddress
{
Address = user.Mail,
Name = user.DisplayName
},
Type = AttendeeType.Required
}
},
IsOnlineMeeting = true,
OnlineMeetingProvider = OnlineMeetingProviderType.TeamsForBusiness
};
await graphClient.Me.Events
.Request()
.AddAsync(@event);
var dateconvertinstance = new GraphDateTimeTimeZoneConverter();
BigTextArea.Text = "Calendar invite sent from " + dateconvertinstance.Convert(StartTime, null, null, null) + " to " + dateconvertinstance.Convert(EndTime, null, null, null) + "\n\n" +
"Please check your calendar for teams meeting.";
}
}
catch (Microsoft.Graph.ServiceException ex)
{
if (ex.Error.Code == "Request_ResourceNotFound")
{
BigTextArea.Text = "This user does not exit in the directory";
}
else
{
BigTextArea.Text = "Error message - \n" + ex.Message;
}
}
}
public MeetingTimes()
{
Attendees = new List<AttendeeBase>();
TimeConstraint = new TimeConstraint();
}
