public async Task <IDataResult <TokenModel> > SignInAsync(SignInModel signInModel)
{
var validation = new SignInModelValidator().Validate(signInModel);
if (validation.Failed)
{
return(DataResult <TokenModel> .Fail(validation.Message));
}
var signModel = await _userRepository.SignInAsync(signInModel);
validation = _authService.Validate(signModel, signInModel);
if (validation.Failed)
{
return(DataResult <TokenModel> .Fail(validation.Message));
}
var userLogModel = UserLogFactory.Create(signModel);
await _userLogApplicationService.AddAsync(userLogModel);
var tokenModel = _authService.CreateToken(signModel);
return(DataResult <TokenModel> .Success(tokenModel));
}
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 <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 Task <IDataResult <EdifactViewModal> > Question1(EdifactViewModal edifactViewModal)
{
var lines = edifactViewModal.Message.Split('\''); // splits at the apostrophe character
foreach (string line in lines)
{
var pieces = line.Split('+', ':'); // splits at both of those characters
//DoSomething(pieces);
}
return((Task <IDataResult <EdifactViewModal> >) DataResult <EdifactViewModal> .Success(edifactViewModal));
}
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 <IEnumerable <CountryModel> > > GetCountriesAsync()
{
var countries = await _countryRepository.ListAsync();
return(DataResult <IEnumerable <CountryModel> > .Success(countries
.OrderBy(c => c.Country)
.Select(c => new CountryModel
{
Id = c.Id,
Country = c.Country,
CountryCode = c.CountryCode
})));
}
public DataResult Delete(int id)
{
try
{
notebookManager.dataSource.Delete(id);
}
catch (DataSourceException e)
{
return(DataResult.Failure(e.Message));
}
return(DataResult.Success());
}
public DataResult Update(Notebook notebook)
{
try
{
notebookManager.dataSource.Update(notebook);
}
catch (DataSourceException e)
{
return(DataResult.Failure(e.Message));
}
return(DataResult.Success());
}
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 <IDataResult <long> > CreatePostAsync(PostModel post)
{
var user = _userRepository.FirstOrDefault(u => u.Id == post.UserId);
PointEntity point = await _pointRepository.FirstOrDefaultWhereIncludeAsync(p => p.Id == post.Marker.Id, p => p.Posts);
if (point is null)
{
point = new PointEntity
{
Coordinate = new Coordinate
{
Latitude = post.Marker.Latitude,
Longitude = post.Marker.Longitude
}
};
await _pointRepository.AddAsync(point);
point.User = user;
}
var newPost = new PostEntity
{
Message = post.Message,
Recommended = post.Recommended,
PostDate = DateTime.UtcNow,
Location = post.Location
};
await _postRepository.AddAsync(newPost);
newPost.Point = point;
newPost.User = user;
_tagRepository.CreateTags(post.Tags, user.Id);
await _unitOfWork.SaveChangesAsync();
var postTags = _tagRepository.GetTagsByNames(post.Tags);
await _postTagRepository.AddRangeAsync(postTags.Select(t => new PostTagEntity
{
PostId = newPost.Id,
TagId = t.Id
}));
await _unitOfWork.SaveChangesAsync();
return(DataResult <long> .Success(newPost.Id));
}
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 <PassMessage> > SetAsPresence(Command command, CancellationToken token)
{
switch (command.PresenceType)
{
case PresenceType.Member:
{
DataResult <int> result = await _mediator.Send(command, token);
Pass.UsePass.Command usePass = new Pass.UsePass.Command
{
ParticipantClassTimeId = result.Data
};
DataResult <PassMessage> dataResult = await _mediator.Send(usePass, token);
return(dataResult);
}
case PresenceType.Help:
var helpCommand = new AddNewUserToClassTime.Help.Command()
{
ParticipantId = command.ParticipantId,
ClassTimeId = command.ClassTimeId
};
await _mediator.Send(helpCommand, token);
return(DataResult <PassMessage> .Success(PassMessage.Success("")));
default:
var makeUpCommand = new AddNewUserToClassTime.MakeUp.Command()
{
ParticipantId = command.ParticipantId,
ClassTimeId = command.ClassTimeId
};
DataResult <int> makeUpResult = await _mediator.Send(makeUpCommand, token);
Pass.UsePass.Command usePassForMakeUp = new Pass.UsePass.Command
{
ParticipantClassTimeId = makeUpResult.Data
};
return(DataResult <PassMessage> .Success(PassMessage.Success("")));
}
}
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));
}
private async Task <DataResult <T> > DeserializeResponse <T>(HttpResponseMessage response)
{
if (!response.IsSuccessStatusCode)
{
return(DataResult <T> .Failed(describer.RequestError(response.StatusCode.ToString(), response.Content.ToString())));
}
var jsonString = await response.Content.ReadAsStringAsync();
if (jsonString.Contains("error"))
{
return(DataResult <T> .Failed(describer.RequestError(response.StatusCode.ToString(), jsonString)));
}
var data = JsonConvert.DeserializeObject <T>(jsonString);
return(DataResult <T> .Success(data));
}
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 DataResult Authenticate(string username, string password)
{
try
{
Web.Models.Token response = ChronicyWebApi.Shared.Authenticate(username, password);
if (response.HasError)
{
return(DataResult.Failure(response.ErrorMessage));
}
}
catch (WebApiException e)
{
InformationDispatcher.Default.Dispatch(e, DebugLogContext.Current);
return(DataResult.Failure("Could not authenticate"));
}
return(DataResult.Success());
}
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 <List <CalendarEvent> > > Handle(Query request, CancellationToken cancellationToken)
{
request.Start = request.Start.ToUniversalTime();
request.End = request.End.ToUniversalTime();
List <CalendarEvent> calendarEvents = await _context.ClassTimes
.Where(x => x.StartDate >= request.Start)
.Where(x => x.StartDate <= request.End)
.Select(x => new CalendarEvent()
{
Id = x.Id.ToString(),
Start = x.StartDate.AddMinutes(request.UtcOffsetInMinutes).ToString("s"),
End = x.EndDate.AddMinutes(request.UtcOffsetInMinutes).ToString("s"),
Title = $"{x.GroupClass.Name} ({x.Room.Name}) {x.NumberOfClass} / {x.NumberOfClasses}",
BackgroundColor = $"#{x.Room.HexColor}",
Editable = true
}).ToListAsync(cancellationToken);
return(DataResult <List <CalendarEvent> > .Success(calendarEvents));
}
private async Task <DataResult <List <CourseDto> > > CourseListPreparation(List <Course> courses)
{
var coursesDto = _mapper.Map <List <CourseDto> >(courses);
if (coursesDto.Any())
{
foreach (var item in coursesDto)
{
var result = await _categoryService.GetByIdAsync(item.CategoryId);
if (result.IsSuccess)
{
item.Category = result.Data;
}
}
}
return(DataResult <List <CourseDto> > .Success(_mapper.Map <List <CourseDto> >(courses), StatusCode.Ok));
}
public async Task <DataResult <PresenceInGroupDto> > Handle(Query request, CancellationToken cancellationToken)
{
var presenceForGroup = await _context.ParticipantPresences.Join(_context.ClassTimes, time => time.ClassTimeId, time => time.Id,
(relation, classTime) => new { classTime.GroupClassId, classTime.StartDate, relation })
.Where(x => x.GroupClassId == request.GroupClassId)
.Select(x => new { x.relation, x.StartDate })
.Join(_context.Users, anonymous => anonymous.relation.ParticipantId, user => user.Id,
(anonymous, user) => new
{
ParticipantName = $"{user.FirstName} {user.LastName}",
Type = anonymous.relation.PresenceType,
WasPresence = anonymous.relation.WasPresence,
Date = anonymous.StartDate,
ParticipantId = anonymous.relation.ParticipantId,
ClassTimeId = anonymous.relation.ClassTimeId
}).ToListAsync(cancellationToken);
List <string> columns = await _context.ClassTimes.Where(x => x.GroupClassId == request.GroupClassId)
.OrderBy(x => x.StartDate).Select(x => x.StartDate.ToString("dd.MM")).ToListAsync(cancellationToken);
List <PresenceInGroupDto.Participant> presenceDtos = presenceForGroup.GroupBy(x => x.ParticipantId).Select(x => new PresenceInGroupDto.Participant()
{
ParticipantName = x.FirstOrDefault()?.ParticipantName,
ParticipantId = x.Key,
PresenceValues = x.OrderBy(s => s.Date).Select(s => new PresenceInGroupDto.PresenceValue
{
Id = s.ClassTimeId,
Value = s.WasPresence,
PresenceType = s.Type,
Date = s.Date.ToString("dd.MM")
}).ToList(),
}).ToList();
return(DataResult <PresenceInGroupDto> .Success(new PresenceInGroupDto
{
ParticipantsPresence = presenceDtos,
Columns = columns
}));
}
public async Task <DataResult <NewParticipantDto> > Handle(Query request, CancellationToken cancellationToken)
{
bool isAnyAbsent = await _context.ParticipantPresences
.Include(x => x.ClassTime)
.Where(x => x.ParticipantId == request.UserId)
.Where(x => x.PresenceType == PresenceType.None)
.Where(x => !x.WasPresence)
.Where(x => x.ClassTime.StartDate < DateTime.Now)
.AnyAsync(cancellationToken);
NewParticipantDto newParticipant = await _context.Users.Where(x => x.Id == request.UserId)
.Select(x => new NewParticipantDto()
{
Name = $"{x.FirstName} {x.LastName} ({x.Email.HashEmail()})",
Id = x.Id
}).FirstOrDefaultAsync(cancellationToken);
newParticipant.WasAbsent = isAnyAbsent;
return(DataResult <NewParticipantDto> .Success(newParticipant));
}
public async Task <IDataResult <long> > AddAsync(AddUserModel addUserModel)
{
var validation = new AddUserModelValidator().Validate(addUserModel);
if (validation.Failed)
{
return(DataResult <long> .Fail(validation.Message));
}
var authModel = _authService.CreateAuth(addUserModel.SignIn);
var userEntity = UserFactory.Create(addUserModel, authModel);
userEntity.Add();
await _userRepository.AddAsync(userEntity);
await _unitOfWork.SaveChangesAsync();
return(DataResult <long> .Success(userEntity.Id));
}
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 <IDataResult <IEnumerable <MarkerModel> > > GetMarkerWithPostsNearAsync(Coordinate center, double radius, long userId)
{
var markersInRadius = await _pointRepository.GetPointsInRadius(center, radius);
await _pointRepository.IncrementPointViews(markersInRadius.Select(p => p.Id));
await _unitOfWork.SaveChangesAsync();
var postsIds = markersInRadius.SelectMany(m => m.Posts.Select(p => p.Id)).ToList();
var posts = await _postRepository.Posts
.AsNoTracking()
.Include(p => p.Likes)
.Include(p => p.Point)
.Include(p => p.Tags)
.Include(p => p.User)
.ThenInclude(u => u.Avatar)
.Where(p => postsIds.Contains(p.Id))
.ToListAsync();
var existedTags = await _tagRepository.ListAsync();
return(DataResult <IEnumerable <MarkerModel> > .Success(markersInRadius.Select(m =>
new MarkerModel
{
Id = m.Id,
Latitude = m.Coordinate.Latitude,
Longitude = m.Coordinate.Longitude,
Posts = posts.Where(p => p.Point.Id == m.Id)
.Select(p =>
{
var returnPost = CreatePostModel(p);
returnPost.Liked = p.Likes.Any(like => like.UserId == userId);
returnPost.TimesLiked = p.Likes.Count;
returnPost.Editable = p.User.Id == userId;
returnPost.Tags = existedTags.Where(t => p.Tags.Any(pt => pt.TagId == t.Id)).Select(t => t.Tag);
return returnPost;
})
})));
}
public async Task <IDataResult <ProfileModel> > GetAsync(long id)
{
var user = await _userRepository.FirstOrDefaultWhereIncludeAsync(u => u.Id == id,
u => u.Country,
u => u.Avatar,
user => user.Posts);
return(DataResult <ProfileModel> .Success(new ProfileModel
{
Id = user.Id,
Username = user.Username,
Email = user.Email.Address,
Phone = user.PhoneNumber,
About = user.About,
Gender = user.Gender,
Country = user.Country?.Country,
Avatar = user.Avatar?.Avatar,
CountryId = user.Country?.Id ?? 0,
RegistrationDate = user.RegisterDate,
PostsNumber = user.Posts.Count
}));
}
public async Task <IDataResult <TokenModel> > SignInAsync(SignInModel signInModel)
{
var validation = new SignInModelValidator().Validate(signInModel);
if (validation.Failed)
{
return(DataResult <TokenModel> .Fail(validation.Message));
}
var authEntity = await _authRepository.GetByLoginAsync(signInModel.Login);
validation = Validate(authEntity, signInModel);
if (validation.Failed)
{
return(DataResult <TokenModel> .Fail(validation.Message));
}
var tokenModel = CreateToken(authEntity);
return(DataResult <TokenModel> .Success(tokenModel));
}
