protected virtual async Task <SessionInfo[]> GetUserSessions(
string userId, CancellationToken cancellationToken = default)
{
if (!DbUserIdHandler.TryParse(userId).IsSome(out var dbUserId))
{
return(Array.Empty <SessionInfo>());
}
var dbContext = CreateDbContext();
await using var _1 = dbContext.ConfigureAwait(false);
var tx = await dbContext.Database.BeginTransactionAsync(cancellationToken).ConfigureAwait(false);
await using var _2 = tx.ConfigureAwait(false);
var dbSessions = await Sessions.ListByUser(dbContext, dbUserId, cancellationToken).ConfigureAwait(false);
var sessions = new SessionInfo[dbSessions.Length];
for (var i = 0; i < dbSessions.Length; i++)
{
sessions[i] = SessionConverter.ToModel(dbSessions[i]) !;
}
return(sessions);
}
public HttpResponseMessage Join(int ID, DTO.Character character)
{
string errorResponse = "";
try
{
DTO.Session session = SessionConverter.DomainToDTO(RepositoryProxy.Instance.SessionRepository.AddPlayer(ID, character));
HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.OK);
JObject JSession = JObject.FromObject(session);
response.Content = new System.Net.Http.StringContent(JSession.ToString());
response.Content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
return(response);
}
catch (Exception ex)
{
errorResponse = ex.Message;
}
return(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
public HttpResponseMessage GetSessions(string name)
{
string errorResponse = "";
try
{
List <DTO.Session> sessions = new List <DTO.Session>();
foreach (var s in RepositoryProxy.Instance.SessionRepository.GetPlayerSessions(name))
{
sessions.Add(SessionConverter.DomainToDTO(s));
}
HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.OK);
JArray JSessions = JArray.FromObject(sessions);
response.Content = new System.Net.Http.StringContent(JSessions.ToString());
response.Content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
return(response);
}
catch (Exception ex)
{
errorResponse = ex.Message;
}
return(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
public List <Session> GetAllSessionForAttendee(int userId, DateTime startDate, DateTime endDate)
{
return(SessionConverter.ConvertListFromCore(UnitOfWork.SessionRepository.GetAllSessionForAttendee(userId)
.Where(x => x.SessionDate.HasValue &&
x.SessionDate >= startDate &&
x.SessionDate <= endDate)
.ToList()));
}
private void WebSocketApiSessionsUpdated(object sender, Common.Models.GenericEventArgs <JArray> e)
{
using (var scope = _scopeFactory.CreateScope())
{
var sessionService = scope.ServiceProvider.GetRequiredService <ISessionService>();
var sessions = SessionConverter.ConvertToSessions(e.Argument).ToList();
sessionService.ProcessSessions(sessions);
}
}
/// <summary>
/// Get view model for user profile page
/// </summary>
/// <param name="userId">user id</param>
/// <param name="loggedInUser"></param>
/// <returns>instance of User vm</returns>
public UserProfileVm GetUserProfileVm(int userId, User loggedInUser)
{
User requestedUser = userId == loggedInUser.UserId ? loggedInUser : UserDataAccesor.GetUserById(userId);
CodeReview codeReview = loggedInUser.IsTrainer || loggedInUser.IsManager
? CodeReviewConverter.ConvertFromCore(UnitOfWork.CodeReviewRepository.GetSavedCodeReviewForTrainee(userId, loggedInUser.UserId))
: null;
var commonTags = UnitOfWork.CodeReviewRepository
.GetCommonlyUsedTags(userId, 5)
.Select(skill => new CodeReviewTag
{
CodeReviewTagId = 0,
Skill = new Skill
{
Name = skill.Name,
SkillId = skill.SkillId
}
}).ToList();
if (codeReview != null)
{
codeReview.CodeReviewPreviewHtml = UtilityFunctions.GenerateCodeReviewPreview(codeReview, true);
codeReview.SystemRating = new FeedbackBl().CalculateCodeReviewRating(codeReview);
}
return(new UserProfileVm
{
User = userId == loggedInUser.UserId ? null : requestedUser,
Skills = requestedUser.IsTrainee ? SkillDataAccesor.GetSkillsByUserId(userId) : null,
TraineeSynopsis = requestedUser.IsTrainee ? FeedbackDataAccesor.GetTraineeFeedbackSynopsis(requestedUser.UserId) : null,
Sessions = requestedUser.IsTrainee ? SessionConverter.ConvertListFromCore(UnitOfWork.SessionRepository.GetAllSessionForAttendee(userId)) : null,
Projects = null,
Feedbacks = requestedUser.IsTrainee ? FeedbackDataAccesor.GetUserFeedback(userId, 5) : FeedbackDataAccesor.GetFeedbackAddedByUser(userId),
TrainorSynopsis = requestedUser.IsTrainer || requestedUser.IsManager ? FeedbackDataAccesor.GetTrainorFeedbackSynopsis(requestedUser.UserId) : null,
AllAssignedCourses = requestedUser.IsTrainee ? LearningPathDataAccessor.GetAllCoursesForTrainee(requestedUser.UserId).OrderByDescending(x => x.PercentageCompleted).ToList() : new List <CourseTrackerDetails>(),
SavedCodeReview = codeReview,
CommonTags = commonTags
// SavedCodeReviewData = logedInUser.IsTrainer && (codeReview != null && codeReview.Id > 0) ? UtilityFunctions.GenerateCodeReviewPreview(codeReview, true) : string.Empty
});
}
private PagedResult <Session> GetPagedFilteredSessions(string wildcard, int statusId, int searchSessionId
, int teamId, int pageNumber, int pageSize)
{
var session = UnitOfWork.SessionRepository.GetPagedFilteredSessions(wildcard, (Common.Enumeration.SessionType)statusId, searchSessionId,
teamId, pageNumber, pageSize);
if (session == null)
{
return(new PagedResult <Session>());
}
return(new PagedResult <Session>
{
CurrentPage = session.CurrentPage,
PageCount = session.PageCount,
PageSize = session.PageSize,
RowCount = session.RowCount,
Results = session.Results == null
? new List <Session>()
: SessionConverter.ConvertListFromCore(session.Results.ToList())
});
}
public HttpResponseMessage Create(DTO.Session session)
{
string error = "";
try
{
session = SessionConverter.DomainToDTO(RepositoryProxy.Instance.SessionRepository.Add(session));
HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.OK);
JObject JSession = JObject.FromObject(session);
response.Content = new System.Net.Http.StringContent(JSession.ToString());
response.Content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
return(response);
}
catch (Exception ex)
{
error = ex.Message;
}
HttpResponseMessage errorResponse = new HttpResponseMessage();
errorResponse.StatusCode = HttpStatusCode.BadRequest;
errorResponse.ReasonPhrase = error;
return(errorResponse);
}
// [CommandHandler] inherited
public override async Task SetOptions(
SetSessionOptionsCommand command, CancellationToken cancellationToken = default)
{
var(session, options, baseVersion) = command;
var context = CommandContext.GetCurrent();
if (Computed.IsInvalidating())
{
_ = GetSessionInfo(session, default);
_ = GetOptions(session, default);
return;
}
var dbContext = await CreateCommandDbContext(cancellationToken).ConfigureAwait(false);
await using var _1 = dbContext.ConfigureAwait(false);
var dbSessionInfo = await Sessions.Get(dbContext, session.Id, true, cancellationToken).ConfigureAwait(false);
var sessionInfo = SessionConverter.ToModel(dbSessionInfo);
if (sessionInfo == null)
{
throw new KeyNotFoundException();
}
if (baseVersion.HasValue && sessionInfo.Version != baseVersion.GetValueOrDefault())
{
throw new VersionMismatchException();
}
sessionInfo = sessionInfo with {
LastSeenAt = Clocks.SystemClock.Now,
Options = options,
};
await Sessions.Upsert(dbContext, sessionInfo, cancellationToken).ConfigureAwait(false);
}
/// <summary>
/// method to Add or edit session details
/// </summary>
/// <param name="objSession">instance of session Object</param>
/// <param name="currentUser">instance of Current User</param>
/// <returns>boolean resutt of event's success</returns>
public SessionVm AddNewSession(Session objSession, User currentUser)
{
objSession.IsNeW = (objSession.Id == 0);
objSession.Presenter = currentUser;
DAL.EntityFramework.Session coreSession = SessionConverter.ConvertToCore(objSession);
foreach (var trainee in objSession.SessionAttendees)
{
coreSession.UserSessionMappings.Add(new UserSessionMapping
{
AddedBy = currentUser.UserId,
AddedOn = DateTime.Now,
UserId = trainee.UserId
});
}
UnitOfWork.SessionRepository.Add(coreSession);
UnitOfWork.Commit();
objSession.Id = coreSession.SessionId;
new NotificationBl().AddSessionNotification(objSession);
return(GetSessionOnFilter(1, (int)Common.Enumeration.SessionType.All, coreSession.SessionId, "", currentUser));
}
// [CommandHandler] inherited
public override async Task <SessionInfo> SetupSession(
SetupSessionCommand command, CancellationToken cancellationToken = default)
{
var(session, ipAddress, userAgent) = command;
var context = CommandContext.GetCurrent();
if (Computed.IsInvalidating())
{
var invSessionInfo = context.Operation().Items.Get <SessionInfo>();
if (invSessionInfo == null)
{
return(null !);
}
_ = GetSessionInfo(session, default);
var invIsNew = context.Operation().Items.GetOrDefault(false);
if (invIsNew)
{
_ = GetAuthInfo(session, default);
_ = GetOptions(session, default);
}
if (invSessionInfo.IsAuthenticated)
{
_ = GetUserSessions(invSessionInfo.UserId, default);
}
return(null !);
}
var dbContext = await CreateCommandDbContext(cancellationToken).ConfigureAwait(false);
await using var _1 = dbContext.ConfigureAwait(false);
var dbSessionInfo = await Sessions.Get(dbContext, session.Id, true, cancellationToken).ConfigureAwait(false);
var isNew = dbSessionInfo == null;
var now = Clocks.SystemClock.Now;
var sessionInfo = SessionConverter.ToModel(dbSessionInfo)
?? SessionConverter.NewModel() with {
Id = session.Id
};
sessionInfo = sessionInfo with {
LastSeenAt = now,
IPAddress = string.IsNullOrEmpty(ipAddress) ? sessionInfo.IPAddress : ipAddress,
UserAgent = string.IsNullOrEmpty(userAgent) ? sessionInfo.UserAgent : userAgent,
};
try {
dbSessionInfo = await Sessions.Upsert(dbContext, sessionInfo, cancellationToken).ConfigureAwait(false);
sessionInfo = SessionConverter.ToModel(dbSessionInfo);
context.Operation().Items.Set(sessionInfo); // invSessionInfo
context.Operation().Items.Set(isNew); // invIsNew
return(sessionInfo !);
}
catch (DbUpdateException) {
var scope = context.Items.Get <DbOperationScope <TDbContext> >();
await scope !.Rollback().ConfigureAwait(false);
var readDbContext = CreateDbContext();
await using var __ = readDbContext.ConfigureAwait(false);
dbSessionInfo = await Sessions.Get(readDbContext, session.Id, false, cancellationToken).ConfigureAwait(false);
if (dbSessionInfo == null)
{
throw; // Something is off: it is supposed to be created concurrently
}
sessionInfo = SessionConverter.ToModel(dbSessionInfo);
return(sessionInfo !);
}
}
// Commands
// [CommandHandler] inherited
public override async Task SignIn(
SignInCommand command, CancellationToken cancellationToken = default)
{
var(session, user, authenticatedIdentity) = command;
var context = CommandContext.GetCurrent();
if (Computed.IsInvalidating())
{
_ = GetAuthInfo(session, default);
_ = GetSessionInfo(session, default);
var invSessionInfo = context.Operation().Items.Get <SessionInfo>();
if (invSessionInfo != null)
{
_ = GetUser(invSessionInfo.UserId, default);
_ = GetUserSessions(invSessionInfo.UserId, default);
}
return;
}
if (!user.Identities.ContainsKey(authenticatedIdentity))
#pragma warning disable MA0015
{
throw new ArgumentOutOfRangeException(
$"{nameof(command)}.{nameof(SignInCommand.AuthenticatedIdentity)}");
}
#pragma warning restore MA0015
if (await IsSignOutForced(session, cancellationToken).ConfigureAwait(false))
{
throw Errors.ForcedSignOut();
}
var dbContext = await CreateCommandDbContext(cancellationToken).ConfigureAwait(false);
await using var _1 = dbContext.ConfigureAwait(false);
var isNewUser = false;
var dbUser = await Users
.GetByUserIdentity(dbContext, authenticatedIdentity, cancellationToken)
.ConfigureAwait(false);
if (dbUser == null)
{
(dbUser, isNewUser) = await Users
.GetOrCreateOnSignIn(dbContext, user, cancellationToken)
.ConfigureAwait(false);
if (isNewUser == false)
{
UserConverter.UpdateEntity(user, dbUser);
await dbContext.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
}
}
else
{
user = user with {
Id = DbUserIdHandler.Format(dbUser.Id)
};
UserConverter.UpdateEntity(user, dbUser);
await dbContext.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
}
var dbSessionInfo = await Sessions.GetOrCreate(dbContext, session.Id, cancellationToken).ConfigureAwait(false);
var sessionInfo = SessionConverter.ToModel(dbSessionInfo);
if (sessionInfo !.IsSignOutForced)
{
throw Errors.ForcedSignOut();
}
sessionInfo = sessionInfo with {
LastSeenAt = Clocks.SystemClock.Now,
AuthenticatedIdentity = authenticatedIdentity,
UserId = DbUserIdHandler.Format(dbUser.Id)
};
context.Operation().Items.Set(sessionInfo);
context.Operation().Items.Set(isNewUser);
await Sessions.Upsert(dbContext, sessionInfo, cancellationToken).ConfigureAwait(false);
}
public void ToFrame_CopiesSession()
{
var sessionConverter = new SessionConverter();
var session = JsonSerializer.Deserialize <Session>(SAMPLE_SESSION);
IFrame frame = sessionConverter.ToFrame(session);
Assert.IsNotNull(frame);
Assert.AreEqual("tickleBritches", frame.Client.Name);
Assert.AreEqual(new Vector3(0.26900002f, 4.671f, 52.986004f), frame.Client.Pose.Position);
Assert.AreEqual(new Vector3(0.088000007f, -0.001f, -0.99600005f), frame.Client.Pose.Orientation.Forward);
Assert.AreEqual(new Vector3(-0.99600005f, 0.0f, -0.088000007f), frame.Client.Pose.Orientation.Left);
Assert.AreEqual(new Vector3(0.0f, 1.0f, -0.001f), frame.Client.Pose.Orientation.Up);
Assert.AreEqual("B113374B-A8C5-40B5-9D3D-AFB2B26ECEFE", frame.Match.SessionId);
Assert.AreEqual("127.0.0.1", frame.Match.SessionIp);
Assert.AreEqual(GameStatus.RoundStart, frame.Match.Status);
Assert.AreEqual(164.02505f, frame.Match.GameClock);
Assert.AreEqual(PauseState.Unpausing, frame.Match.PauseState);
Assert.AreEqual(76f, frame.Match.PausedTimer);
Assert.AreEqual(7f, frame.Match.UnpausingTimer);
Assert.AreEqual(frame.OrangeTeam, frame.Match.PausedBy);
Assert.AreEqual(frame.BlueTeam, frame.Match.UnpausedBy);
Assert.IsNotNull(frame.LastScore);
Assert.AreEqual(18.2f, frame.LastScore.DiscSpeed);
Assert.AreEqual(7.4f, frame.LastScore.Distance);
Assert.AreEqual(GoalType.InsideShot, frame.LastScore.GoalType);
Assert.AreEqual(2, frame.LastScore.Points);
Assert.IsNotNull(frame.LastScore.Team);
Assert.AreEqual(TeamColor.Orange, frame.LastScore.Team.Color);
Assert.IsNotNull(frame.LastScore.ScoredBy);
Assert.AreEqual("MrMrsTejada", frame.LastScore.ScoredBy.Name);
Assert.IsNotNull(frame.LastScore.AssistedBy);
Assert.AreEqual("NuclearApple", frame.LastScore.AssistedBy.Name);
Assert.IsNotNull(frame.Disc);
Assert.AreEqual(1, frame.Disc.BounceCount);
Assert.AreEqual(new Vector3(1f, 4.5360003f, 27.500002f), frame.Disc.Pose.Position);
Assert.AreEqual(new Vector3(1f, 2f, 3f), frame.Disc.Velocity);
Assert.IsNotNull(frame.BlueTeam);
Assert.AreEqual(TeamColor.Blue, frame.BlueTeam.Color);
Assert.AreEqual("BLUE TEAM", frame.BlueTeam.Name);
Assert.IsTrue(frame.BlueTeam.HasPossesion);
Assert.AreEqual(14, frame.BlueTeam.Stats.Points);
Assert.AreEqual(54.081879f, frame.BlueTeam.Stats.PossessionTime);
Assert.AreEqual(1, frame.BlueTeam.Stats.Interceptions);
Assert.AreEqual(2, frame.BlueTeam.Stats.Blocks);
Assert.AreEqual(3, frame.BlueTeam.Stats.Steals);
Assert.AreEqual(4, frame.BlueTeam.Stats.Catches);
Assert.AreEqual(5, frame.BlueTeam.Stats.Passes);
Assert.AreEqual(6, frame.BlueTeam.Stats.Saves);
Assert.AreEqual(7, frame.BlueTeam.Stats.Goals);
Assert.AreEqual(15, frame.BlueTeam.Stats.Stuns);
Assert.AreEqual(1, frame.BlueTeam.Stats.Assists);
Assert.AreEqual(7, frame.BlueTeam.Stats.ShotsTaken);
Assert.AreEqual(4, frame.BlueTeam.Players.Count);
var bluePlayer = frame.BlueTeam.Players[0];
Assert.IsNotNull(bluePlayer);
Assert.AreEqual("Carvidsanders", bluePlayer.Name);
Assert.AreEqual(2, bluePlayer.Id);
Assert.AreEqual(352342346675L, bluePlayer.UserId);
Assert.AreEqual(28, bluePlayer.Level);
Assert.AreEqual(69, bluePlayer.Number);
Assert.AreEqual(44, bluePlayer.Ping);
Assert.IsTrue(bluePlayer.HasPossesion);
Assert.IsTrue(bluePlayer.IsStunned);
Assert.IsTrue(bluePlayer.IsBlocking);
Assert.IsTrue(bluePlayer.IsInvulnerable);
Assert.AreEqual(new Vector3(0.73700005f, 4.8530002f, -50.740002f), bluePlayer.Head.Position);
Assert.AreEqual(new Vector3(-0.54500002f, -0.23900001f, -0.80300003f), bluePlayer.Head.Orientation.Forward);
Assert.AreEqual(new Vector3(-0.80400002f, -0.12400001f, 0.58200002f), bluePlayer.Head.Orientation.Left);
Assert.AreEqual(new Vector3(-0.23900001f, 0.96300006f, -0.125f), bluePlayer.Head.Orientation.Up);
Assert.AreEqual(new Vector3(0.73700005f, 4.8530002f, -50.740002f), bluePlayer.Body.Position);
Assert.AreEqual(new Vector3(-0.78300005f, 0.0f, -0.62300003f), bluePlayer.Body.Orientation.Forward);
Assert.AreEqual(new Vector3(-0.62300003f, 0.0020000001f, 0.78300005f), bluePlayer.Body.Orientation.Left);
Assert.AreEqual(new Vector3(0.001f, 1.0f, -0.001f), bluePlayer.Body.Orientation.Up);
Assert.AreEqual(new Vector3(0.85200006f, 4.5930004f, -50.083004f), bluePlayer.LeftHand.Position);
Assert.AreEqual(new Vector3(-0.13000001f, 0.39200002f, 0.91100007f), bluePlayer.LeftHand.Orientation.Forward);
Assert.AreEqual(new Vector3(0.97500002f, 0.21900001f, 0.045000002f), bluePlayer.LeftHand.Orientation.Left);
Assert.AreEqual(new Vector3(-0.18200001f, 0.89300007f, -0.41100001f), bluePlayer.LeftHand.Orientation.Up);
Assert.AreEqual(new Vector3(0.57600003f, 4.4050002f, -50.778004f), bluePlayer.RightHand.Position);
Assert.AreEqual(new Vector3(-0.82000005f, -0.45500001f, 0.34800002f), bluePlayer.RightHand.Orientation.Forward);
Assert.AreEqual(new Vector3(0.333f, 0.116f, 0.93600005f), bluePlayer.RightHand.Orientation.Left);
Assert.AreEqual(new Vector3(-0.46600002f, 0.88300002f, 0.056000002f), bluePlayer.RightHand.Orientation.Up);
Assert.AreEqual(new Vector3(0.045000002f, -0.045000002f, -0.091000006f), bluePlayer.Velocity);
Assert.AreEqual(bluePlayer.Team, frame.BlueTeam);
}
public Session GetSessionWithAttendees(int sessionId)
{
return(SessionConverter.ConvertFromCoreWithAttendees(UnitOfWork.SessionRepository.GetSessionWithAttendees(sessionId)));
}
public SessionBusiness(ISessionRepository sessionRepository, SessionConverter sessionConverter)
{
_sessionRepository = sessionRepository;
_sessionConverter = sessionConverter;
}
