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)); }