public static async Task Run(
[TimerTrigger("%SessionizeReadModelSyncSchedule%")]
TimerInfo timer,
ILogger log,
[BindConferenceConfig]
ConferenceConfig conference,
[BindKeyDatesConfig]
KeyDatesConfig keyDates,
[BindSessionsConfig]
SessionsConfig sessions,
[BindSessionizeSyncConfig]
SessionizeSyncConfig sessionize
)
{
if (keyDates.Before(x => x.StopSyncingSessionsFromDate) || keyDates.After(x => x.StopSyncingAgendaFromDate))
{
log.LogInformation("SessionizeAgendaSync sync not active");
return;
}
using (var httpClient = new HttpClient())
{
var apiClient = new SessionizeApiClient(httpClient, sessionize.AgendaApiKey);
var(sessionsRepo, presentersRepo) = await sessions.GetRepositoryAsync();
await SyncService.Sync(apiClient, sessionsRepo, presentersRepo, log, new DateTimeProvider(), conference.ConferenceInstance);
}
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", Route = null)]
HttpRequest req,
ILogger log,
[BindConferenceConfig]
ConferenceConfig conference,
[BindFeedbackConfig]
FeedbackConfig feedbackConfig,
[BindSessionsConfig]
SessionsConfig sessionsConfig)
{
var(conferenceFeedbackRepo, sessionFeedbackRepo) = await feedbackConfig.GetRepositoryAsync();
var conferenceFeedback = await conferenceFeedbackRepo.GetAllAsync(conference.ConferenceInstance);
var sessionFeedback = await sessionFeedbackRepo.GetAllAsync(conference.ConferenceInstance);
var(sessionsRepo, presentersRepo) = await sessionsConfig.GetRepositoryAsync();
var sessions = await sessionsRepo.GetAllAsync(conference.ConferenceInstance);
var presenters = await presentersRepo.GetAllAsync(conference.ConferenceInstance);
var feedback = new
{
Conference = conferenceFeedback.OrderBy(x => x.Timestamp).Select(x => new
{
x.Timestamp,
x.Rating,
x.Liked,
x.ImprovementIdeas
}),
Sessions = sessions.Select(x => x.GetSession())
.Select(s => new
{
s.Id,
s.Title,
Presenters = string.Join(", ", s.PresenterIds.Select(pId => presenters.Single(p => p.Id == pId)).Select(x => x.Name)),
Feedback = sessionFeedback.OrderBy(x => x.Timestamp).Where(x => x.SessionName.ToLowerInvariant().Contains(s.Title.ToLowerInvariant())).Select(x => new
{
x.Timestamp,
x.Rating,
x.Liked,
x.ImprovementIdeas
})
})
};
var settings = new JsonSerializerSettings();
settings.ContractResolver = new DefaultContractResolver();
return(new JsonResult(feedback, settings));
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = null)]
HttpRequest req,
ILogger log,
[BindConferenceConfig]
ConferenceConfig conference,
[BindKeyDatesConfig]
KeyDatesConfig keyDates,
[BindSessionsConfig]
SessionsConfig sessionsConfig)
{
if (keyDates.Before(x => x.SubmissionsAvailableToDate))
{
log.LogWarning("Attempt to access GetAgenda endpoint before they are available at {availableDate}.", keyDates.SubmissionsAvailableToDate);
return(new StatusCodeResult(404));
}
var(sessionsRepo, presentersRepo) = await sessionsConfig.GetRepositoryAsync();
var sessions = await sessionsRepo.GetAllAsync(conference.ConferenceInstance);
var presenters = await presentersRepo.GetAllAsync(conference.ConferenceInstance);
var agenda = sessions.Select(x => x.GetSession())
.Select(s => new Session
{
Id = s.Id.ToString(),
Title = s.Title,
Abstract = s.Abstract,
Format = s.Format,
Level = s.Level,
Tags = s.Tags,
Presenters = s.PresenterIds.Select(pId => presenters.Where(p => p.Id == pId).Select(p => p.GetPresenter()).Select(p => new Presenter
{
Id = p.Id.ToString(),
Name = p.Name,
Tagline = p.Tagline,
Bio = p.Bio,
ProfilePhotoUrl = p.ProfilePhotoUrl,
TwitterHandle = p.TwitterHandle,
WebsiteUrl = p.WebsiteUrl
}).Single()).ToArray()
})
.OrderBy(x => x.Title)
.ToArray();
var settings = new JsonSerializerSettings();
settings.ContractResolver = new DefaultContractResolver();
return(new JsonResult(agenda, settings));
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)]
HttpRequestMessage req,
ILogger log,
[BindConferenceConfig]
ConferenceConfig conference,
[BindKeyDatesConfig]
KeyDatesConfig keyDates,
[BindFeedbackConfig]
FeedbackConfig feedbackConfig,
[BindSessionsConfig]
SessionsConfig sessionsConfig
)
{
var feedback = await req.Content.ReadAsAsync <FeedbackRequest>();
// Within feedback window
if (keyDates.Before(x => x.FeedbackAvailableFromDate) || keyDates.After(x => x.FeedbackAvailableToDate))
{
log.LogWarning("Attempt to access SubmitFeedback endpoint outside of allowed window of {start} -> {end}.", keyDates.FeedbackAvailableFromDate, keyDates.FeedbackAvailableToDate);
return(new StatusCodeResult((int)HttpStatusCode.NotFound));
}
// Valid feedback
if (string.IsNullOrWhiteSpace(feedback.Likes) && string.IsNullOrWhiteSpace(feedback.ImprovementIdeas))
{
log.LogWarning("Attempt to access SubmitFeedback endpoint with invalid feedback details from {DeviceId}", feedback.DeviceId);
return(new StatusCodeResult((int)HttpStatusCode.BadRequest));
}
var(conferenceFeedbackRepo, sessionFeedbackRepo) = await feedbackConfig.GetRepositoryAsync();
if (feedback.IsConferenceFeedback)
{
// Save conference feedback
log.LogInformation("Successfully received conference feedback for from DeviceId {DeviceId}; persisting...", feedback.DeviceId);
var feedbackToPersist = new ConferenceFeedbackEntity(
conference.ConferenceInstance,
feedback.Name,
feedback.Rating.ToString(),
feedback.Likes,
feedback.ImprovementIdeas,
feedback.DeviceId.ToString());
await conferenceFeedbackRepo.CreateAsync(feedbackToPersist);
}
else
{
// valid Session existed
var(sessionsRepo, presentersRepo) = await sessionsConfig.GetRepositoryAsync();
var allSessions = await sessionsRepo.GetAllAsync(conference.ConferenceInstance);
var allPresenters = await presentersRepo.GetAllAsync(conference.ConferenceInstance);
var sessionRow = allSessions.First(s => s != null && feedback.SessionId == s.Id.ToString());
if (sessionRow == null && !feedback.IsConferenceFeedback)
{
log.LogWarning("Attempt to submit to SubmitFeedback endpoint with invalid SessionId {SessionId} from {DeviceId}", feedback.SessionId, feedback.DeviceId);
return(new StatusCodeResult((int)HttpStatusCode.BadRequest));
}
var session = sessionRow.GetSession();
var presenterNames = string.Join(", ", session.PresenterIds.Select(pId => allPresenters.Single(p => p.Id == pId)).Select(x => x.Name));
// Save feedback
log.LogInformation("Successfully received feedback for {SessionId} from DeviceId {DeviceId}; persisting...", feedback.SessionId, feedback.DeviceId);
var feedbackToPersist = new SessionFeedbackEntity(
session.Id.ToString(),
conference.ConferenceInstance,
feedback.Name,
feedback.Rating.ToString(),
feedback.Likes,
feedback.ImprovementIdeas,
$"{session.Title} - {presenterNames}",
feedback.DeviceId.ToString());
await sessionFeedbackRepo.CreateAsync(feedbackToPersist);
}
return(new StatusCodeResult((int)HttpStatusCode.NoContent));
}
