public async Task <IDataResult <TokenModel> > SignInAsync(SignInModel signInModel)
{
var validation = new SignInModelValidator().Validate(signInModel);
if (validation.IsError)
{
return(DataResult <TokenModel> .Error(validation.Message));
}
var signedInModel = await UserRepository.SignInAsync(signInModel);
validation = SignInService.Validate(signedInModel, signInModel);
if (validation.IsError)
{
return(DataResult <TokenModel> .Error(validation.Message));
}
var userLogModel = new UserLogModel(signedInModel.Id, LogType.SignIn);
await UserLogApplicationService.AddAsync(userLogModel);
await UnitOfWork.SaveChangesAsync();
var tokenModel = SignInService.CreateToken(signedInModel);
return(DataResult <TokenModel> .Success(tokenModel));
}
public async Task <IDataResult <Int64> > AddAsync(AddUserModel addUserModel)
{
if (addUserModel is null)
{
throw new ArgumentNullException(nameof(addUserModel));
}
var validation = new AddUserModelValidator().Validate(addUserModel);
if (validation.IsError)
{
return(DataResult <Int64> .Error(validation.Message));
}
addUserModel.SignIn = _signInService.CreateSignIn(addUserModel.SignIn);
var userEntity = UserFactory.Create(addUserModel);
userEntity.Add();
await _userRepository.AddAsync(userEntity).ConfigureAwait(false);
await _unitOfWork.SaveChangesAsync().ConfigureAwait(false);
return(DataResult <Int64> .Success(userEntity.Id));
}
public async Task <DataResult <ClaimsPrincipal> > Handle(Command request, CancellationToken cancellationToken)
{
Model.Domain.User user = await _signInManager.UserManager.FindByEmailAsync(request.Email);
if (user == null)
{
return(DataResult <ClaimsPrincipal> .Error(PolishReadableMessage.Auth.WrongLoginOrPassword));
}
SignInResult resultPassword =
await _signInManager.CheckPasswordSignInAsync(user, request.Password, false);
if (resultPassword.Succeeded)
{
if (user.EmailConfirmed)
{
user.UtcOffsetInMinutes = request.UtcOffsetInMinutes;
_context.Update(user);
await _context.SaveChangesAsync(cancellationToken);
await _signInManager.SignInAsync(user, request.RememberMe);
ClaimsPrincipal claimsPrincipal = await _signInManager.CreateUserPrincipalAsync(user);
return(DataResult <ClaimsPrincipal> .Success(claimsPrincipal));
}
return(DataResult <ClaimsPrincipal> .Error(PolishReadableMessage.Auth.AccountNotActive));
}
return(DataResult <ClaimsPrincipal> .Error(PolishReadableMessage.Auth.WrongLoginOrPassword));
}
public async Task <DataResult <CourseDto> > GetByIdAsync(string id)
{
var course = await _courseCollection.Find <Course>(x => x.Id == id).FirstOrDefaultAsync();
if (course == null)
{
return(DataResult <CourseDto> .Error("Course not found", StatusCode.NotFound));
}
return(DataResult <CourseDto> .Success(_mapper.Map <CourseDto>(course), StatusCode.Ok));
}
public async Task <IDataResult <int> > AddAsync(CustomerViewModel entityViewModel)
{
IResult validation = new CustomerViewModelValidator().Validate(entityViewModel);
if (validation.IsError)
{
return(DataResult <int> .Error(validation.Message));
}
return(await base.AddAsync(entityViewModel));
}
public async Task <DataResult <BasketDto> > GetBasket(string userId)
{
var basket = await _redisManager.GetDb().StringGetAsync(userId);
if (string.IsNullOrEmpty(basket))
{
return(DataResult <BasketDto> .Error("Basket not found", StatusCode.NotFound));
}
return(DataResult <BasketDto> .Success(JsonSerializer.Deserialize <BasketDto>(basket), StatusCode.Ok));
}
public async Task <DataResult <CategoryDto> > GetByIdAsync(string id)
{
var category = await _categoryCollection.Find <Category>(x => x.Id == id).FirstOrDefaultAsync();
if (category == null)
{
return(DataResult <CategoryDto> .Error("Category not found", StatusCode.NotFound));
}
return(DataResult <CategoryDto> .Success(_mapper.Map <CategoryDto>(category), StatusCode.Ok));
}
public async Task <IDataResult <int> > Question3(InputDocumentViewModal inputDocumentViewModal)
{
IResult validation = new Question3ViewModalValitor().Validate(inputDocumentViewModal);
if (validation.IsError)
{
return(DataResult <int> .Error(validation.Message));
}
//If the XML document is given here is passed then return a status of ‘0’ – which means the document was structured correctly.
return(DataResult <int> .Success("0"));
//return DataResult<int>.Success(await _service.Question3(_mapper.Map<InputDocument>(inputDocumentViewModal)));
}
public async Task <JsonResult> Remove([FromBody] Remove.Command cmd, CancellationToken token)
{
try
{
await _mediator.Send(cmd, token);
TempData[Messages.SuccessMessage] = "Pokój został usunięty";
return(Json(DataResult.Success()));
}
catch (RemoveRoomException e)
{
return(Json(DataResult.Error(e.Message)));
}
}
public async Task <DataResult <ViewModel> > Handle(Query request, CancellationToken cancellationToken)
{
Model.Domain.Pass pass = await _context.Passes.Where(x => x.Id == request.Id).FirstOrDefaultAsync(cancellationToken);
if (pass is null)
{
return(DataResult <ViewModel> .Error(PolishReadableMessage.Pass.NotFound));
}
var serializedParent = JsonConvert.SerializeObject(PassDto.FromPass(pass));
ViewModel viewModel = JsonConvert.DeserializeObject <ViewModel>(serializedParent);
viewModel.MemberId = request.RedirectMemberId;
return(DataResult <ViewModel> .Success(viewModel));
}
public async Task <DataResult <int> > Handle(Command request, CancellationToken cancellationToken)
{
User participant = await _context.Users.Where(x => x.Id == request.ParticipantId).FirstOrDefaultAsync(cancellationToken);
if (participant is null)
{
return(DataResult <int> .Error(PolishReadableMessage.Presence.ParticipantNotFound));
}
ClassTime classTime = await _context.ClassTimes
.Where(x => x.Id == request.ClassTimeId)
.Include(x => x.PresenceParticipants)
.FirstOrDefaultAsync(cancellationToken);
if (classTime is null)
{
return(DataResult <int> .Error(PolishReadableMessage.Presence.ClassNotFound));
}
var makeUpClassTime = await _context.ParticipantPresences
.Include(x => x.ClassTime)
.Where(x => x.ParticipantId == request.ParticipantId)
.Where(x => !x.WasPresence)
.Where(x => x.PresenceType == PresenceType.None)
.Where(x => x.ClassTime.StartDate < classTime.StartDate)
.OrderBy(x => x.ClassTime.StartDate)
.FirstOrDefaultAsync(cancellationToken);
if (makeUpClassTime is null)
{
return(DataResult <int> .Error(PolishReadableMessage.Presence.MakeUpClassNotFound));
}
ClassTimeAggregate classTimeAggregate = ClassTimeAggregate.FromState(classTime);
ParticipantClassTime participantClassTime = classTimeAggregate.AddParticipant(participant, makeUpClassTime);
participantClassTime.WasPresence = true;
await _context.AddAsync(participantClassTime, cancellationToken);
_context.Update(makeUpClassTime);
_context.Update(classTimeAggregate.State);
await _context.SaveChangesAsync(cancellationToken);
return(DataResult <int> .Success(makeUpClassTime.Id));
}
public async Task <DataResult <int> > Handle(Command request, CancellationToken cancellationToken)
{
ParticipantClassTime participantClassTime = await _context.ParticipantPresences
.Where(x => x.ParticipantId == request.ParticipantId && x.ClassTimeId == request.ClassTimeId)
.FirstOrDefaultAsync(cancellationToken);
if (participantClassTime is null)
{
return(DataResult <int> .Error(PolishReadableMessage.Presence.ParticipantNotFound));
}
participantClassTime.WasPresence = request.IsPresence;
_context.Update(participantClassTime);
await _context.SaveChangesAsync(cancellationToken);
return(DataResult <int> .Success(participantClassTime.Id));
}
public async Task <DataResult <ViewModel> > Handle(Query request, CancellationToken cancellationToken)
{
ParticipantGroupClass member = await _context.GroupClassMembers
.Where(x => x.Id == request.MemberId)
.Include(x => x.Passes)
.Include(x => x.User)
.FirstOrDefaultAsync(cancellationToken);
if (member is null)
{
return(DataResult <ViewModel> .Error(PolishReadableMessage.Member.NotFound));
}
ViewModel viewModel = ViewModel.FromMember(member);
return(DataResult <ViewModel> .Success(viewModel));
}
public async Task <DataResult <ParticipantDetail> > Handle(Query request, CancellationToken cancellationToken)
{
if (string.IsNullOrEmpty(request.Id))
{
return(DataResult <ParticipantDetail> .Error(PolishReadableMessage.Anchors.NotFound));
}
ParticipantDetail participantDetail = await _context.Users.Where(x => x.Id == request.Id)
.Select(x => ParticipantDetail.FromUser(x))
.FirstOrDefaultAsync(cancellationToken);
if (participantDetail is null)
{
return(DataResult <ParticipantDetail> .Error(PolishReadableMessage.Anchors.NotFound));
}
return(DataResult <ParticipantDetail> .Success(participantDetail));
}
public async Task <DataResult <GroupClassDetail> > Handle(Query request, CancellationToken cancellationToken)
{
Model.Domain.GroupClass groupClass = await _context.GroupClass
.Include(x => x.GroupLevel)
.Include(x => x.Room)
.Include(x => x.Anchors)
.ThenInclude(x => x.User)
.Include(x => x.ClassDaysOfWeek)
.FirstOrDefaultAsync(x => x.Id == request.Id, cancellationToken);
if (groupClass is null)
{
return(DataResult <GroupClassDetail> .Error(PolishReadableMessage.GroupClass.NotFound));
}
GroupClassDetail groupClassDetail = GroupClassDetail.From(groupClass, request.UtcOffsetInMinutes);
return(DataResult <GroupClassDetail> .Success(groupClassDetail));
}
public async Task <DataResult <UpdateViewModel> > Handle(Query request, CancellationToken cancellationToken)
{
Model.Domain.GroupClass groupClass = await _context.GroupClass.Where(x => x.Id == request.GroupId)
.Include(x => x.Anchors)
.Include(x => x.Room)
.Include(x => x.Participants)
.ThenInclude(x => x.User)
.Include(x => x.ClassDaysOfWeek)
.FirstOrDefaultAsync(cancellationToken);
if (groupClass is null)
{
return(DataResult <UpdateViewModel> .Error(PolishReadableMessage.GroupClass.NotFound));
}
UpdateViewModel updateViewModel = UpdateViewModel.FromGroupClass(groupClass, request.UtcOffsetInMinutes).AsEdit();
return(DataResult <UpdateViewModel> .Success(updateViewModel));
}
public async Task <IDataResult <long> > AddAsync(AddUserModel addUserModel)
{
var validation = new AddUserModelValidator().Validate(addUserModel);
if (validation.IsError)
{
return(DataResult <long> .Error(validation.Message));
}
addUserModel.SignIn = SignInService.CreateSignIn(addUserModel.SignIn);
var userEntity = UserFactory.Create(addUserModel);
userEntity.Add();
await UserRepository.AddAsync(userEntity);
await UnitOfWork.SaveChangesAsync();
return(DataResult <long> .Success(userEntity.Id));
}
public async Task <DataResult <int> > Handle(Command request, CancellationToken cancellationToken)
{
ClassTime classTime = await _context.ClassTimes
.Include(x => x.PresenceParticipants)
.ThenInclude(x => x.MakeUpParticipant)
.Where(x => x.Id == request.ClassTimeId)
.Include(x => x.PresenceParticipants)
.FirstOrDefaultAsync(cancellationToken);
if (classTime is null)
{
return(DataResult <int> .Error(PolishReadableMessage.Presence.ClassNotFound));
}
ParticipantClassTime participantClassTime = classTime.PresenceParticipants.FirstOrDefault(x => x.ParticipantId == request.ParticipantId);
if (participantClassTime is null)
{
return(DataResult <int> .Error(PolishReadableMessage.Presence.ParticipantNotFound));
}
if (participantClassTime.PresenceType != PresenceType.MakeUp)
{
return(DataResult <int> .Error(PolishReadableMessage.Presence.RemoveWrongType));
}
ClassTimeAggregate classTimeAggregate = ClassTimeAggregate.FromState(classTime);
participantClassTime.MakeUpParticipant.PresenceType = PresenceType.None;
_context.Update(participantClassTime.MakeUpParticipant);
classTimeAggregate.RemoveParticipant(participantClassTime.ParticipantId);
_context.Update(classTimeAggregate.State);
await _context.SaveChangesAsync(cancellationToken);
return(DataResult <int> .Success(participantClassTime.MakeUpParticipant.Id));
}
public async Task <DataResult <bool> > Delete(string userId)
{
var status = await _redisManager.GetDb().KeyDeleteAsync(userId);
return(status ? DataResult <bool> .Success(true, StatusCode.Ok) : DataResult <bool> .Error("Basket could not found", StatusCode.NotFound));
}
public async Task <DataResult <bool> > SaveOrUpdate(BasketDto basketDto)
{
var status = await _redisManager.GetDb().StringSetAsync(basketDto.UserId, JsonSerializer.Serialize(basketDto));
return(status ? DataResult <bool> .Success(true, StatusCode.Ok) : DataResult <bool> .Error("Basket could not save or update", StatusCode.Failed));
}
