protected static ConferenceData GenerateConferenceData(List <SessionResponse> sessions)
{
var startDate = sessions.Min(s => s.StartTime?.Date);
var dayOffsets = sessions.Select(s => s.StartTime?.Date)
.Distinct()
.OrderBy(d => d)
.Select(day => (Offset: (int)Math.Floor((day.Value - startDate)?.TotalDays ?? 0),
day?.DayOfWeek))
.ToList();
var confData = new ConferenceData(dayOffsets.Count);
foreach (var day in dayOffsets)
{
var filterDate = startDate?.AddDays(day.Offset);
confData[day.Offset] = sessions.Where(s => s.StartTime?.Date == filterDate)
.OrderBy(s => s.Track.Name)
.GroupBy(s => s.StartTime)
.OrderBy(g => g.Key);
}
confData.StartDate = startDate;
confData.DayOffsets = dayOffsets;
return(confData);
}
public async Task PatchConference_IsAdmin_ReturnSuccess()
{
// arrange
_factory.CreateUser("Vincent", true).SetupHttpClient(_client);
var conferenceData = new ConferenceData();
conferenceData.Configuration.Moderators.Add("test");
var conferenceId = await CreateConference(conferenceData);
// act
var patch = new JsonPatchDocument <ConferenceData>();
patch.Add(x => x.Configuration.Moderators, "test2");
var response = await _client.PatchAsync($"/v1/conference/{conferenceId}", JsonNetContent.Create(patch));
response.EnsureSuccessStatusCode();
// assert
await AssertConference(conferenceId,
conference =>
{
AssertHelper.AssertScrambledEquals(new[] { "test", "test2" }, conference.Configuration.Moderators);
});
}
private async Task <string> CreateConference(ConferenceData data)
{
var response = await _client.PostAsync("/v1/conference", JsonContent.Create(data));
response.EnsureSuccessStatusCode();
var result = await response.Content.ReadFromJsonAsync <ConferenceCreatedResponseDto>();
Assert.NotNull(result?.ConferenceId);
return(result !.ConferenceId);
}
private async Task <SuccessOrError <Unit> > HandleInternal(PatchConferenceRequest request,
CancellationToken cancellationToken)
{
var(conferenceId, patch) = request;
cancellationToken.ThrowIfCancellationRequested();
var conference = await _conferenceRepo.FindById(conferenceId);
if (conference == null)
{
return(ConferenceError.ConferenceNotFound);
}
var config = ConferenceData.FromConference(conference);
try
{
patch.ApplyTo(config);
}
catch (Exception e)
{
_logger.LogWarning(e, "Json patch failed for conference {conferenceId}", conference.ConferenceId);
return(new FieldValidationError("patch", "An error occurred applying the json patch"));
}
var validationResult = new ConferenceDataValidator().Validate(config);
if (!validationResult.IsValid)
{
return(validationResult.ToError());
}
conference.Configuration = config.Configuration;
conference.Permissions = config.Permissions;
_logger.LogDebug("Json patch succeeded for conference {conferenceId}. Save to database...",
conference.ConferenceId);
var result = await _conferenceRepo.Update(conference);
if (result == OptimisticUpdateResult.Ok)
{
await _mediator.Publish(new ConferencePatchedNotification(conferenceId));
}
return(result switch
{
OptimisticUpdateResult.ConcurrencyException => CommonError.ConcurrencyError,
OptimisticUpdateResult.DeletedException => ConferenceError.ConferenceNotFound,
_ => Unit.Value,
});
public SpeakerItemViewModel(Speaker speaker, ConferenceData conferenceData, IConferenceRepository conferenceRepository, bool getSessions = true)
{
this.speaker = speaker;
if (getSessions)
{
this.Sessions = conferenceData.SessionSpeakerRelations
.Where(r => r.SpeakerId == this.speaker.Id)
.Select(relation => conferenceData.Sessions.First(s => s.Id == relation.SessionId))
.Select(s => new SessionItemViewModel(s, conferenceData, conferenceRepository, false))
.ToList();
}
}
private ConferenceData FillInFavorites(ConferenceData conferenceData)
{
if (conferenceData == null)
{
return(null);
}
foreach (var session in conferenceData.Sessions)
{
session.IsFavorite = this.GetFavorite(session.Id);
}
return(conferenceData);
}
public async override void HandleWatchKitExtensionRequest(UIApplication application, NSDictionary userInfo, Action <NSDictionary> reply)
{
var cd = new ConferenceData();
var sessions = await cd.GetSessionsAsync();
var array = new NSMutableArray((nuint)sessions.Count);
foreach (var session in sessions)
{
var title = string.Format("{0}|{1}", session.DateTime, session.Title);
array.Add(FromObject(title));
}
reply(new NSDictionary("SessionTitle", array));
}
public Task <Result <ConferenceData> > GetCashData()
{
return(Task.Run(() =>
{
try
{
conferenceData = Parser.GetCash();
return new Result <ConferenceData>(conferenceData);
}
catch (Exception ex)
{
return new Result <ConferenceData>(null, true, ex.Message);
}
}));
}
public async Task <ActionResult <ConferenceData> > Get(string conferenceId)
{
var conference = await _conferenceRepo.FindById(conferenceId);
if (conference == null)
{
return(ConferenceError.ConferenceNotFound.ToActionResult());
}
var authResult = await _authorizationService.AuthorizeAsync(User, conference, Operations.Read);
if (!authResult.Succeeded)
{
return(Forbid());
}
return(Ok(ConferenceData.FromConference(conference)));
}
public SessionItemViewModel(Session session, ConferenceData conferenceData, IConferenceRepository conferenceRepository, bool getSpeakers = true)
{
this.session = session;
this.conferenceRepository = conferenceRepository;
this.conferenceData = conferenceData;
this.Track = new TrackItemViewModel(this.session.Track);
if (getSpeakers)
{
this.SpeakerList = this.conferenceData.SessionSpeakerRelations
.Where(r => r.SessionId == this.session.Id)
.Select(relation => this.conferenceData.Speakers
.First(s => s.Id == relation.SpeakerId))
.Select(speaker => new SpeakerItemViewModel(speaker, this.conferenceData, conferenceRepository, true)).ToList();
this.Speakers = string.Join(", ", this.SpeakerList.Select(s => s.Name));
}
var slot = this.conferenceData.Slots.First(s => s.TimeLine == session.TimeLine);
this.StartTime = $"{slot.StartHour:00}:{slot.StartMinute:00}";
this.EndTime = $"{slot.EndHour:00}:{slot.EndMinute:00}";
var room = this.conferenceData.Rooms.FirstOrDefault(r => r.Id == session.RoomId);
if (room != null)
{
this.Room = $"{room.Code:000}";
}
if (this.conferenceData.Days.Count > 0)
{
var dateTimeStart = this.conferenceData.Days[0].Date;
dateTimeStart = dateTimeStart.AddHours(slot.StartHour);
dateTimeStart = dateTimeStart.AddMinutes(slot.StartMinute);
this.StartDateTime = dateTimeStart;
var dateTimeEnd = this.conferenceData.Days[0].Date;
dateTimeEnd = dateTimeEnd.AddHours(slot.EndHour);
dateTimeEnd = dateTimeEnd.AddMinutes(slot.EndMinute);
this.EndDateTime = dateTimeEnd;
}
}
public async Task PatchConference_IsNeitherModeratorNorAdmin_ReturnFailure()
{
// arrange
var user = _factory.CreateUser("Vincent", false).SetupHttpClient(_client);
var conferenceData = new ConferenceData();
conferenceData.Configuration.Moderators.Add("wtf");
var conferenceId = await CreateConference(conferenceData);
// act
var patch = new JsonPatchDocument <ConferenceData>();
patch.Add(x => x.Configuration.Moderators, "test2");
var response = await _client.PatchAsync($"/v1/conference/{conferenceId}", JsonNetContent.Create(patch));
Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode);
}
public Task <Result <List <SectionItem> > > GetSectionItems()
{
return(Task.Run(() =>
{
try
{
if (conferenceData == null)
{
conferenceData = Parser.GetCash();
}
//Separate by sectionName (aka type of speach)
List <Section> data = new List <Section>();
data.AddRange(conferenceData.SectionsFirstDay);
data.AddRange(conferenceData.SectionsSecondDay);
var allSectionNames = RemoveDuplicates(data);
var list = new List <SectionItem>();
foreach (var item in allSectionNames)
{
var allSpeachByTypeName = conferenceData.Speaches.Where(x => x.AreaType == item.Name);
var sectionItem = new SectionItem()
{
SectionArea = item.AreaName,
SectionName = item.Name,
Speachs = allSpeachByTypeName.ToArray()
};
list.Add(sectionItem);
}
return new Result <List <SectionItem> >(list);
}
catch (Exception ex)
{
return new Result <List <SectionItem> >(null, true, ex.Message);
}
}));
}
public async Task PatchConference_RemoveModeratorSoNoModeratorsExist_ReturnErrorAndDontChange()
{
// arrange
_factory.CreateUser("Vincent", true).SetupHttpClient(_client);
var conferenceData = new ConferenceData();
conferenceData.Configuration.Moderators.Add("test");
var conferenceId = await CreateConference(conferenceData);
// act
var patch = new JsonPatchDocument <ConferenceData>();
patch.Remove(x => x.Configuration.Moderators, 0);
var response = await _client.PatchAsync($"/v1/conference/{conferenceId}", JsonNetContent.Create(patch));
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
// assert
await AssertConference(conferenceId, conference => { Assert.Single(conference.Configuration.Moderators); });
}
public async Task <ActionResult <ConferenceCreatedResponseDto> > Create([FromBody] ConferenceData data)
{
var conferenceId = await _mediator.Send(new CreateConferenceRequest(data), HttpContext.RequestAborted);
return(new ConferenceCreatedResponseDto(conferenceId));
}
public static ObservableCollection <SessionGroupViewModel> GroupSessions(IConferenceRepository conferenceRepository, ConferenceData conferenceData, bool favoritesOnly = false)
{
if (conferenceData == null)
{
return(null);
}
var sessionGroupTileInfoList = new List <SessionGroupViewModel>();
var groupHeaders = conferenceData.Slots
.OrderBy(s => (s.StartHour * 100) + s.StartMinute)
.Select(s => $"{s.StartHour:00}:{s.StartMinute:00} - {s.EndHour:00}:{s.EndMinute:00}")
.Distinct()
.ToArray();
var sessionInfos = conferenceData.Sessions
.Where(s => !favoritesOnly || s.IsFavorite)
.Select(s => new SessionItemViewModel(s, conferenceData, conferenceRepository))
.OrderBy(s => s.StartTime);
var groups = new Dictionary <string, SessionGroupViewModel>();
foreach (var header in groupHeaders)
{
var group = new SessionGroupViewModel(header);
sessionGroupTileInfoList.Add(group);
groups[header] = group;
}
foreach (var sessionInfo in sessionInfos)
{
var groupName = $"{sessionInfo.StartTime} - {sessionInfo.EndTime}";
groups[groupName].Sessions.Add(sessionInfo);
}
var sessionGroupTileInfos = new ObservableCollection <SessionGroupViewModel>();
foreach (var sessionGroup in sessionGroupTileInfoList)
{
if (sessionGroup.Sessions.Count > 0)
{
sessionGroupTileInfos.Add(sessionGroup);
}
}
return(sessionGroupTileInfos);
}
public async Task <ServiceResult <ConferenceData> > GetConferenceData(CancellationToken cancellationToken = new CancellationToken())
{
ConferenceData conferenceData = null;
string json = null;
try
{
json = this.cacheService.GetValueOrDefault <string>(ConferenceDataKey);
}
catch (Exception)
{
}
ConferenceData item = null;
if (json != null)
{
try
{
item = JsonConvert.DeserializeObject <ConferenceData>(json);
}
catch (Exception)
{
}
}
if (item != null)
{
conferenceData = item;
if (cancellationToken.IsCancellationRequested)
{
return(this.FillInFavorites(conferenceData));
}
var versionId = conferenceData.Version;
var result = await this.conferenceDataService.GetVersionAsync(cancellationToken);//.ConfigureAwait(false);
int latestVersionId = 0;
if (result.Successful)
{
latestVersionId = result.Value;
}
if (versionId >= latestVersionId)
{
return(this.FillInFavorites(conferenceData));
}
}
else
{
var assembly = typeof(ConferenceRepository).GetTypeInfo().Assembly;
Stream stream = assembly.GetManifestResourceStream("Conference.Common.Data.Resources.DefaultConferenceData.json");
string text = string.Empty;
using (var reader = new System.IO.StreamReader(stream))
{
text = reader.ReadToEnd();
}
if (!string.IsNullOrEmpty(text))
{
try
{
conferenceData = JsonConvert.DeserializeObject <ConferenceData>(text);
var result =
await this.conferenceDataService.GetVersionAsync(cancellationToken);//.ConfigureAwait(false);
int latestVersionId = 0;
if (result.Successful)
{
latestVersionId = result.Value;
}
if (conferenceData.Version >= latestVersionId)
{
return(this.FillInFavorites(conferenceData));
}
}
catch (Exception ex)
{
return(ServiceResult <ConferenceData> .CreateError(ex));
}
}
}
var newData = await this.conferenceDataService.GetConferenceDataAsync(cancellationToken);//.ConfigureAwait(false);
if (newData.Successful)
{
if (conferenceData != null)
{
foreach (var session in conferenceData.Sessions)
{
var targetSession = newData.Value.Sessions.FirstOrDefault(s => s.Id == session.Id);
if (targetSession != null)
{
targetSession.IsFavorite = this.GetFavorite(session.Id);
}
}
}
this.cacheService.AddOrUpdateValue(ConferenceDataKey, JsonConvert.SerializeObject(newData.Value));
}
else
{
newData = conferenceData;
this.cacheService.AddOrUpdateValue(ConferenceDataKey, JsonConvert.SerializeObject(newData.Value));
}
return(this.FillInFavorites(newData));
}
