public async Task CanCreateSessionAsync()
{
var authorizedClient = SystemTestExtension.GetTokenAuthorizeHttpClient(_factory);
var createSessionCommand = new CreateSessionCommand
{
CreateSessionModels = new List <CreateSessionCommandModel>
{
new CreateSessionCommandModel
{
ClassroomId = 1,
GameId = 1,
Name = "test"
}
}
};
var serializedSessionCommand = JsonConvert.SerializeObject(createSessionCommand);
// The endpoint or route of the controller action.
var httpResponse = await authorizedClient.PostAsync(requestUri : "/Session",
content : new StringContent(content: serializedSessionCommand,
encoding: Encoding.UTF8,
mediaType: StringConstants.ApplicationJson));
// Must be successful.
httpResponse.EnsureSuccessStatusCode();
Assert.True(httpResponse.IsSuccessStatusCode);
Assert.Equal(HttpStatusCode.Created, httpResponse.StatusCode);
}
public async Task StartTracking(string code)
{
// Get current user id
var userId = HttpContextHelper.GetCurrentUserId();
// Get vehicle by code
var getUserVehicleQuery = _serviceProvider.GetRequiredService <GetUserVehicleQuery>();
var vehicle = await getUserVehicleQuery.Execute(new GetUserVehicleViewModel()
{
UserId = userId,
Code = code
});
var command = new CreateSessionCommand()
{
Id = Guid.NewGuid(),
UserId = vehicle.UserId,
VehicleId = vehicle.Id
};
// Create new session
var createSessionCommandHandler = _serviceProvider.GetRequiredService <CreateSessionCommandHandler>();
await createSessionCommandHandler.Handle(command);
// Store this session to cache
await _cacheService.Store <TrackingSession>(Schema.SESSION_SCHEMA, $"{vehicle.UserId.ToString()}_{vehicle.Code}",
new TrackingSession()
{
SessionId = command.Id,
VehicleId = command.VehicleId
});
}
public Task <HttpResponseMessage> Post([FromBody] dynamic body)
{
var validate = _serviceSession.GetAllByCoachingProcess(Guid.Parse((string)body.coachingProcess.id));
foreach (var item in validate)
{
if (item.StartTime == (TimeSpan)body.startTime && item.Date == (DateTime)body.date)
{
return(CreateResponse(HttpStatusCode.BadRequest, null));
}
}
var listJob = _serviceJob.AddJobToSession(body.job);
var coachingProcess = _serviceCoachingProcess.GetOne(Guid.Parse((string)body.coachingProcess.id));
var user = _serviceUser.GetOne((string)body.idUser);
var commandSession = new CreateSessionCommand(
coachingProcess,
(string)body.theme,
user,
(DateTime)body.date,
(TimeSpan)body.startTime,
(TimeSpan)body.endTime,
(ESessionClassification)body.classification,
(string)body.observation,
listJob
);
var session = _serviceSession.Create(commandSession);
_serviceEvaluationCoach.AddToSession(body.coach, session.Id);
_serviceEvaluationCoachee.AddToSession(body.coachee, session.Id);
return(CreateResponse(HttpStatusCode.Created, session));
}
public async Task <CreateSessionResponse> CreateSeesion([FromRoute][NotNull] string username)
{
var command = new CreateSessionCommand
{
Username = username
};
return(await _commandDispatcher.DispatchAsync <CreateSessionCommand, CreateSessionResponse>(command));
}
private async Task SignInAsync(User user)
{
var command = new CreateSessionCommand(user.Id);
command = await new CreateSessionCommandHandler(this._sessionRepository).HandleAsync(command);
var identity = new ClaimsIdentity(Options.AuthenticationType);
identity.AddClaim(new Claim("sessionId", command.Id.ToString()));
identity.AddClaim(new Claim("name", (user.Username).ToString()));
await _context.HttpContext.SignInAsync(new ClaimsPrincipal(identity));
}
public Session Create(CreateSessionCommand command)
{
var session = new Session(command.Theme, command.Date, command.StartTime, command.EndTime, command.Classification, command.CoachingProcess, command.User, command.Job, command.Coach, command.Coachee, command.Observation);
session.Validate();
_repositorySession.Create(session);
if (Commit())
{
return(session);
}
return(null);
}
public async Task <ActionResult <CreateSessionResponse> > Create(
[FromBody] CreateSessionCommand commandDTO
)
{
var command = new Create.Command(
commandDTO.Genres,
commandDTO.Name
);
Logger.LogDebug("create session");
var result = await Mediator.Send(command);
return(Ok(result));
}
public async Task <IActionResult> Login(CreateSessionCommand command)
{
var session = await _mediator.Send(command);
if (session != null)
{
return(Ok(new
{
token = session.Token,
expiration = session.Expiration
}));
}
return(Unauthorized("Username or password is incorrect!"));
}
public async Task <ActionResult <CreateSessionResponse> > Update(
[FromBody] CreateSessionCommand commandDTO,
[FromRoute] string id
)
{
Logger.LogDebug($"Update session with id {id}");
var command = new Update.Command(
id,
commandDTO.Genres,
commandDTO.Name
);
var result = await Mediator.Send(command);
return(Ok(result));
}
public ActionResult Create(int?projectId, CreateSessionViewModelPost create)
{
Request.ThrowIfDifferentReferrer();
if (projectId.HasValue)
{
var project = _database.Projects
.FilterById(projectId.Value)
.SingleOrDefault();
var currentUser = _userManager.FindById(User.Identity.GetUserId());
if (CheckProjectAccessRights(nameof(projectId), project, currentUser))
{
if (ModelState.IsValid &&
PathNameValidation.CheckContainsNoForbiddenPathCharacters(ModelState, nameof(create.Name), create.Name) &&
CheckSessionNameIsAlreadyInUse(nameof(create.Name), project, create.Name) &&
(create.UseProjectDefinitionTemplate ||
SessionDefinitionValidation.CheckDefinitionTemplateJson(ModelState, nameof(create.Definition), create.Definition)))
{
var command = new CreateSessionCommand()
{
Name = create.Name,
StartTime = create.StartTime,
Length = create.Length,
Definition = create.UseProjectDefinitionTemplate ? null : create.Definition,
Project = project,
};
_dispatcher.Dispatch(command);
return(RedirectToAction(nameof(ProjectController.Details), ProjectController.ControllerName, new { projectId = projectId }));
}
var newCreate = Mapper.Map <CreateSessionViewModel>(create);
newCreate.ProjectId = project.Id;
return(View(newCreate));
}
return(HttpNotFound());
}
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
public async Task <ActionResult <ResponseModel <CreateSessionModel> > > Post([FromBody] CreateSessionCommand command)
{
try
{
command.CreatedBy = Claims[ClaimTypes.Sid].ToInt();
command.TenantId = Guid.Parse(Claims[ClaimTypes.UserData]);
var createSessionModel = await Mediator.Send(command);
return(Created($"api/session/{createSessionModel.Items}", createSessionModel));
}
catch (ObjectAlreadyExistsException ex)
{
return(Conflict(new ResponseModel <CreateSessionModel>(new Error(HttpStatusCode.Conflict, ex))));
}
catch
{
return(StatusCode(HttpStatusCode.InternalServerError.ToInt()));
}
}
public async Task <CommandResult <int> > CreateSession(CreateSessionCommand cmd)
{
var conferenceId = _db.GetActiveConference().Id;
var currentUserId = cmd.CurrentUserId;
var session = new Session()
{
ConferenceId = conferenceId,
Description = cmd.Description,
OrganizationId = cmd.OrganizationId,
Overview = cmd.Overview,
RequestedTimeFrame = cmd.RequestedTimeFrame,
SpeakerId = currentUserId
};
var entity = _db.Sessions.Add(session).Entity;
await _db.SaveChangesAsync();
return(CommandResult <int> .Success(cmd, entity.Id));
}
public async Task ShouldGetModelForValidInformation()
{
var command = new CreateSessionCommand
{
CreatedBy = _adminUserId,
TenantId = _tenantId,
CreateSessionModels = new List <CreateSessionCommandModel>
{
new CreateSessionCommandModel
{
ClassroomId = _classroomId,
GameId = _gameId,
Name = "test"
}
}
};
var sessionResponseModel = await _commandHandler.Handle(command, CancellationToken.None);
Assert.Null(sessionResponseModel.Errors);
Assert.True(sessionResponseModel.Items.Single().Count > 0);
}
public async Task <ActionResult <SessionResultResponse> > CreateSession(CreateSessionCommand command)
{
var result = await Mediator.Send(command);
return(CreatedAtAction(nameof(Get), new { id = result.Id }, result));
}
public async Task <IActionResult> Create(CreateSessionCommand command)
{
await _mediator.Send(command);
return(RedirectToAction(nameof(Index)));
}
public async Task <ActionResult <Guid> > Create(CreateSessionCommand command)
{
return(await Mediator.Send(command));
}
public async Task <IActionResult> CreateSession([FromBody] CreateSessionCommand command) => await HandleCommandAsync(command, _commandService.CreateSession);
