/// <summary>
/// Gets the session info dto.
/// </summary>
/// <param name="session">The session.</param>
/// <returns>SessionInfoDto.</returns>
public static SessionInfoDto GetSessionInfoDto(SessionInfo session)
{
var dto = new SessionInfoDto
{
Client = session.Client,
DeviceId = session.DeviceId,
DeviceName = session.DeviceName,
Id = session.Id.ToString("N"),
LastActivityDate = session.LastActivityDate,
NowPlayingPositionTicks = session.NowPlayingPositionTicks,
SupportsRemoteControl = session.SupportsRemoteControl,
IsPaused = session.IsPaused,
NowViewingContext = session.NowViewingContext,
NowViewingItemId = session.NowViewingItemId,
NowViewingItemName = session.NowViewingItemName,
NowViewingItemType = session.NowViewingItemType,
ApplicationVersion = session.ApplicationVersion
};
if (session.NowPlayingItem != null)
{
dto.NowPlayingItem = DtoBuilder.GetBaseItemInfo(session.NowPlayingItem);
}
if (session.User != null)
{
dto.UserId = session.User.Id.ToString("N");
dto.UserName = session.User.Name;
}
return(dto);
}
public Task SendPlaybackStoppedNotification(SessionInfoDto sessionInfo, CancellationToken cancellationToken)
{
return(SendMessages(new WebSocketMessage <SessionInfoDto>
{
MessageType = "PlaybackStopped",
Data = sessionInfo
}, cancellationToken));
}
public Task SendSessionEndedNotification(SessionInfoDto sessionInfo, CancellationToken cancellationToken)
{
return(SendMessagesInternal(new WebSocketMessage <SessionInfoDto>
{
MessageType = "SessionEnded",
Data = sessionInfo
}, cancellationToken));
}
private bool SaveLapTelemetrySync(ILapInfo lapInfo)
{
if (_sessionInfoDto == null)
{
_sessionInfoDto = CreateSessionInfo(lapInfo);
}
return(TrySaveLap(lapInfo));
}
public Task SendPlaybackStoppedNotification(SessionInfoDto sessionInfo, CancellationToken cancellationToken)
{
var socket = GetActiveSocket();
return(socket.SendAsync(new WebSocketMessage <SessionInfoDto>
{
MessageType = "PlaybackStopped",
Data = sessionInfo
}, cancellationToken));
}
private void ReinitializeViewMode(SessionInfoDto sessionInfoDto)
{
_lapSelectionViewModel.Clear();
_loadedLaps.Clear();
_lapSelectionViewModel.TrackName = string.IsNullOrEmpty(sessionInfoDto.LayoutName) ? sessionInfoDto.TrackName : $"{sessionInfoDto.TrackName} - {sessionInfoDto.LayoutName}";
_lapSelectionViewModel.CarName = sessionInfoDto.CarName;
_lapSelectionViewModel.SessionTime = sessionInfoDto.SessionRunDateTime;
_lapSelectionViewModel.SimulatorName = sessionInfoDto.Simulator;
AddLapsFromSession(sessionInfoDto);
}
private void DeleteSession(SessionInfoDto sessionInfoDto, IOpenWindowViewModel openWindowViewModel)
{
if (_loadedSessions.FirstOrDefault(x => x.Id == sessionInfoDto.Id) != null)
{
MessageBox.Show("Sessions is currently opened. Unable to delete opened session.", "Session Opened", MessageBoxButton.OK, MessageBoxImage.Information);
return;
}
_telemetryLoadController.DeleteSession(sessionInfoDto);
openWindowViewModel.RefreshRecentCommand.Execute(null);
}
public Task <SessionInfoDto> AddRecentSessionAsync(SessionInfoDto sessionInfoDto)
{
if (!_loadedSessions.Contains(sessionInfoDto.Id))
{
_loadedSessions.Add(sessionInfoDto.Id);
sessionInfoDto.LapsSummary.ForEach(x => _knownLaps.Add(x.Id));
}
sessionInfoDto.LapsSummary.ForEach(FillCustomDisplayName);
_telemetryViewsSynchronization.NotifySessionAdded(sessionInfoDto);
return(Task.FromResult(sessionInfoDto));
}
private void SetSessionDetails(SessionInfoDto selectedClient)
{
if (selectedClient.NowPlayingPositionTicks.HasValue && selectedClient.NowPlayingItem != null && selectedClient.NowPlayingItem.RunTimeTicks.HasValue)
{
PlayedTicks = selectedClient.NowPlayingPositionTicks;
PlayedPercentage = ((double)selectedClient.NowPlayingPositionTicks / (double)selectedClient.NowPlayingItem.RunTimeTicks) * 100;
}
IsPaused = selectedClient.IsPaused;
IsMuted = selectedClient.IsMuted;
}
private void InitializeViewModel(SessionInfoDto sessionInfo)
{
_fakeDrivers.Clear();
string formattedTrackName = FormatTrackName(sessionInfo.TrackName, sessionInfo.LayoutName);
_mapAvailable = _mapsLoader.TryLoadMap(sessionInfo.Simulator, formattedTrackName, out _lastMap);
if (_mapAvailable)
{
MapViewViewModel.LoadTrack(_lastMap);
}
}
public virtual SessionInfoDto GetSessionInfo()
{
var session = _sessionManager.GetSession();
var user = session.GetUser();
var result = new SessionInfoDto();
if (user != null)
{
result.User = Mapper.Map <UserOutputDto>(user);
}
return(result);
}
public async Task <SessionInfoDto> LoadRecentSessionAsync(SessionInfoDto sessionInfoDto)
{
await CloseAllOpenedSessions();
_cachedTelemetries.Clear();
if (!_loadedSessions.Contains(sessionInfoDto.Id))
{
_loadedSessions.Add(sessionInfoDto.Id);
sessionInfoDto.LapsSummary.ForEach(x => _knownLaps.Add(x.Id));
}
sessionInfoDto.LapsSummary.ForEach(FillCustomDisplayName);
_telemetryViewsSynchronization.NotifyNewSessionLoaded(sessionInfoDto);
return(sessionInfoDto);
}
public async Task <SessionInfoDto> LoadRecentSessionAsync(string sessionIdentifier)
{
try
{
SessionInfoDto sessionInfoDto = await Task.Run(() => _telemetryRepository.OpenRecentSession(sessionIdentifier));
return(await LoadRecentSessionAsync(sessionInfoDto));
}
catch (Exception ex)
{
Logger.Error(ex, "Error while loading session");
}
return(null);
}
private SessionInfoDto CreateSessionInfo(ILapInfo lapInfo)
{
SessionInfoDto sessionInfoDto = new SessionInfoDto()
{
CarName = lapInfo.Driver.CarName,
Id = SessionIdentifier,
TrackName = lapInfo.Driver.Session.LastSet.SessionInfo.TrackInfo.TrackName,
LayoutName = lapInfo.Driver.Session.LastSet.SessionInfo.TrackInfo.TrackLayoutName,
LayoutLength = lapInfo.Driver.Session.LastSet.SessionInfo.TrackInfo.LayoutLength.InMeters,
PlayerName = lapInfo.Driver.Name,
Simulator = lapInfo.Driver.Session.LastSet.Source,
SessionRunDateTime = DateTime.Now,
LapsSummary = new List <LapSummaryDto>(),
SessionType = lapInfo.Driver.Session.SessionType.ToString()
};
return(sessionInfoDto);
}
public SessionInfoDto GetSessionInfoDto(SessionInfo session)
{
var dto = new SessionInfoDto
{
Client = session.Client,
DeviceId = session.DeviceId,
DeviceName = session.DeviceName,
Id = session.Id,
LastActivityDate = session.LastActivityDate,
NowPlayingPositionTicks = session.PlayState.PositionTicks,
SupportsRemoteControl = session.SupportsRemoteControl,
IsPaused = session.PlayState.IsPaused,
IsMuted = session.PlayState.IsMuted,
NowViewingContext = session.NowViewingContext,
NowViewingItem = session.NowViewingItem,
ApplicationVersion = session.ApplicationVersion,
CanSeek = session.PlayState.CanSeek,
QueueableMediaTypes = session.QueueableMediaTypes,
PlayableMediaTypes = session.PlayableMediaTypes,
RemoteEndPoint = session.RemoteEndPoint,
AdditionalUsers = session.AdditionalUsers,
SupportedCommands = session.SupportedCommands,
UserName = session.UserName,
NowPlayingItem = session.NowPlayingItem,
PlayState = session.PlayState
};
if (session.UserId.HasValue)
{
dto.UserId = session.UserId.Value.ToString("N");
var user = _userManager.GetUserById(session.UserId.Value);
if (user != null)
{
dto.UserPrimaryImageTag = GetImageCacheTag(user, ImageType.Primary);
}
}
return(dto);
}
private async Task ArchiveSession(IOpenWindowViewModel openWindowViewModel, SessionInfoDto sessionInfoDto)
{
try
{
openWindowViewModel.IsBusy = true;
await _telemetryLoadController.ArchiveSession(sessionInfoDto);
openWindowViewModel.RefreshRecentCommand.Execute(null);
MessageBox.Show("Session Archived", "Success", MessageBoxButton.OK, MessageBoxImage.Information);
}
catch (Exception ex)
{
Logger.Error(ex, "Error while archiving session");
MessageBox.Show("Session Archivation failed", "Failure", MessageBoxButton.OK, MessageBoxImage.Warning);
}
finally
{
openWindowViewModel.IsBusy = false;
}
}
public SessionInfoDto GetSessionInfoDto(SessionInfo session)
{
var dto = new SessionInfoDto
{
Client = session.Client,
DeviceId = session.DeviceId,
DeviceName = session.DeviceName,
Id = session.Id.ToString("N"),
LastActivityDate = session.LastActivityDate,
NowPlayingPositionTicks = session.NowPlayingPositionTicks,
SupportsRemoteControl = session.SupportsRemoteControl,
IsPaused = session.IsPaused,
IsMuted = session.IsMuted,
NowViewingContext = session.NowViewingContext,
NowViewingItemId = session.NowViewingItemId,
NowViewingItemName = session.NowViewingItemName,
NowViewingItemType = session.NowViewingItemType,
ApplicationVersion = session.ApplicationVersion,
CanSeek = session.CanSeek,
QueueableMediaTypes = session.QueueableMediaTypes,
PlayableMediaTypes = session.PlayableMediaTypes,
RemoteEndPoint = session.RemoteEndPoint,
AdditionalUsers = session.AdditionalUsers
};
if (session.NowPlayingItem != null)
{
dto.NowPlayingItem = GetBaseItemInfo(session.NowPlayingItem);
}
if (session.UserId.HasValue)
{
dto.UserId = session.UserId.Value.ToString("N");
}
dto.UserName = session.UserName;
return(dto);
}
public void NotifySessionAdded(SessionInfoDto sessionInfoDto)
{
TelemetrySessionArgs args = new TelemetrySessionArgs(sessionInfoDto);
SessionAdded?.Invoke(this, args);
}
private async Task AddSession(SessionInfoDto sessionInfoDto)
{
_addWindowViewModel.IsOpenWindowVisible = false;
await _telemetryLoadController.AddRecentSessionAsync(sessionInfoDto);
}
private void TelemetryViewsSynchronizationOnNewSessionLoaded(object sender, TelemetrySessionArgs e)
{
_loadedSessions.Clear();
_loadedSessions.Add(e.SessionInfoDto);
_lastOpenedSession = e.SessionInfoDto;
}
public void DeleteSession(SessionInfoDto sessionInfoDto)
{
_telemetryRepository.DeleteSession(sessionInfoDto);
}
public async Task OpenSessionFolder(SessionInfoDto sessionInfoDto)
{
await _telemetryRepository.OpenSessionFolder(sessionInfoDto);
}
public async Task ArchiveSession(SessionInfoDto sessionInfoDto)
{
await _telemetryRepository.ArchiveSessions(sessionInfoDto);
}
public TelemetrySessionArgs(SessionInfoDto sessionInfoDto)
{
SessionInfoDto = sessionInfoDto;
}
private void AddLapsFromSession(SessionInfoDto sessionInfoDto)
{
AddLaps(sessionInfoDto.LapsSummary);
}
public Task SendPlaybackStoppedNotification(SessionInfoDto sessionInfo, CancellationToken cancellationToken)
{
return(Task.FromResult(true));
}
private async Task OpenSessionFolder(SessionInfoDto sessionInfoDto)
{
await _telemetryLoadController.OpenSessionFolder(sessionInfoDto);
}