public async Task <CommentDto> Handle(Command request, CancellationToken cancellationToken) { var activity = await _unitOfWork.ActivityRepo.FindFirstAsync(request.ActivityId, cancellationToken); if (activity == null) { throw new CustomException(System.Net.HttpStatusCode.BadRequest, new { Activity = "Not Found" }); } var user = await _unitOfWork.IdentityUserRepo.FindFirstAsync(request.UserName, cancellationToken); if (user == null) { throw new CustomException(System.Net.HttpStatusCode.BadRequest, new { User = "******" }); } DataModel.Comment comment = _mapperHelper.Map <Command, DataModel.Comment>(request); comment.AuthorId = user.AppUser.Id; _unitOfWork.CommentRepo.Add(comment); int insertCnt = await _unitOfWork.SaveAsync(cancellationToken); if (insertCnt > 0) { comment.Activity = activity; comment.Author = user.AppUser; CommentDto commentDto = _mapperHelper.Map <DataModel.Comment, CommentDto>(comment); commentDto.UserImage = _photoAccessor.PreparePhotoUrl(commentDto.MainPhotoCloudFileName); return(commentDto); } throw new Exception("Problem saving changes to database"); }
public async Task <AuthorModel> GetAllAuthorsAsync(FilterAuthorModel filterModel) { var responseModel = new AuthorModel(); if (filterModel == null) { responseModel.Errors.Add(Constants.Errors.InvalidData); return(responseModel); } var repositoryModel = _mapperHelper.Map <FilterAuthorModel, DataFilter.BaseFilterModel>(filterModel); if (repositoryModel == null) { responseModel.Errors.Add(Constants.Errors.OccuredProcessing); return(responseModel); } var authors = await _authorRepository.GetAllAuthorsAsync(repositoryModel); foreach (var author in authors.Collection) { var itemModel = _mapperHelper.Map <AuthorDataModel, AuthorModelItem>(author); if (itemModel == null) { responseModel.Errors.Add(Constants.Errors.OccuredProcessing); continue; } responseModel.Items.Add(itemModel); } responseModel.ItemsCount = authors.CollectionCount; return(responseModel); }
public async Task <UserDto> Handle(Query request, CancellationToken cancellationToken) { IdentityUser identityUser = await _unitOfWork.IdentityUserRepo.FindFirstAsync(request.UserName, cancellationToken); if (identityUser == null) { throw new CustomException(HttpStatusCode.BadRequest); } //If recently expired token is matching with token in request please return recently generated token //This will be the case when two concurrent http request comes from same client and one request updates refresh token else if (request.RefreshToken == identityUser.PreviousRefreshToken && identityUser.PreviousRefreshTokenExpiry > HelperFunc.GetCurrentDateTime()) { return(_mapperHelper.Map <IdentityUser, UserDto>(identityUser)); } //Check if current refresh token is matching and valid else if (request.RefreshToken == identityUser.RefreshToken && identityUser.RefreshTokenExpiry > HelperFunc.GetCurrentDateTime()) { //If current valid token is expired, generate new token and return it. //else return existing token that is still valid. if (request.RefreshToken == identityUser.RefreshToken) { identityUser.PreviousRefreshToken = identityUser.RefreshToken; identityUser.PreviousRefreshTokenExpiry = HelperFunc.GetCurrentDateTime().AddMinutes(_PREVIOUS_REFRESH_TOKEN_EXPIRES_IN_SEC); identityUser.RefreshToken = _jwtGenerator.CreateRefreshToken(); identityUser.RefreshTokenExpiry = HelperFunc.GetCurrentDateTime().AddDays(_REFRESH_TOKEN_EXPIRS_IN_DAYS); _unitOfWork.IdentityUserRepo.Update(identityUser); await _unitOfWork.SaveAsync(cancellationToken); } return(_mapperHelper.Map <IdentityUser, UserDto>(identityUser)); } throw new CustomException(HttpStatusCode.BadRequest); }
public async Task <BaseModel> SignUpAsync(UserRegistrationModel userRegModel) { var responseModel = new BaseModel(); if (userRegModel == null || string.IsNullOrWhiteSpace(userRegModel.FirstName) || string.IsNullOrWhiteSpace(userRegModel.LastName) || string.IsNullOrWhiteSpace(userRegModel.Email)) { responseModel.Errors.Add(Constants.Errors.InvalidData); return(responseModel); } var existedUser = await _userRepository.GetUserByEmailAsync(userRegModel.Email); if (existedUser != null) { responseModel.Errors.Add(Constants.Errors.UserExisted); return(responseModel); } var user = _mapperHelper.Map <UserRegistrationModel, ApplicationUser>(userRegModel); user.UserName = $"{user.FirstName}{user.LastName}"; user.Image = userRegModel.Image; var result = (await _userRepository.SignUpAsync(user, userRegModel.Password)).ToList(); if (result.Any()) { responseModel.Errors = result.Select(x => x.Description).ToList(); } return(responseModel); }
public Task <Unit> Handle(Command request, CancellationToken cancellationToken) { Domain.Item model = _mapperHelper.Map <Command, Domain.Item>(request); _unitOfWork.ItemRepo.Save(model); _unitOfWork.Commit(); return(Task.FromResult(Unit.Value)); }
public async Task <Unit> Handle(Command request, CancellationToken cancellationToken) { //Get existing activity from database DataModel.Activity dbActivity = await _unitOfWork.ActivityRepo.FindFirstAsync(request.ActivityId, cancellationToken); //Keep existing value as if user is not passing it from front end request.Category ??= dbActivity.Category; request.City ??= dbActivity.City; request.Date ??= dbActivity.Date; request.Description ??= dbActivity.Description; request.Title ??= dbActivity.Title; request.Venue ??= dbActivity.Venue; DataModel.Activity activity = _mapperHelper.Map <Command, DataModel.Activity>(request); _unitOfWork.ActivityRepo.Update(activity); int cnt = await _unitOfWork.SaveAsync(cancellationToken); if (cnt > 0) { return(Unit.Value); } throw new Exception("Problem saving changes to database"); }
public async Task <Guid> Handle(Command request, CancellationToken cancellationToken) { DataModel.Activity activity = _mapperHelper.Map <Command, DataModel.Activity>(request); //Generate new Id for new Entity activity.Id = Guid.NewGuid(); _unitOfWork.ActivityRepo.Add(activity); UserActivity hostAttendee = new UserActivity { Activity = activity, IsHost = true, DateJoined = HelperFunc.GetCurrentDateTime(), AppUserId = _userAccessor.GetCurrentUserId() }; _unitOfWork.UserActivityRepo.Add(hostAttendee); int insertCnt = await _unitOfWork.SaveAsync(cancellationToken); if (insertCnt > 0) { return(activity.Id); } throw new Exception("Problem saving changes to database"); }
private DataModel.Photo CreatePhotoModel(Command request, PhotoDto photoUploadResult) { DataModel.Photo photo = _mapperHelper.Map <Command, DataModel.Photo>(request); photo.Id = photoUploadResult.Id; photo.AppUserId = _userAccessor.GetCurrentUserId(); photo.CloudFileName = photoUploadResult.CloudFileName; return(photo); }
public async Task <ActivityDto> Handle(Query request, CancellationToken cancellationToken) { DataModel.Activity dbResult = await _unitOfWork.ActivityRepo.FindFirstAsync(request.ActivityId, cancellationToken); var response = _mapperHelper.Map <DataModel.Activity, ActivityDto>(dbResult); return(response); }
public async Task <UserDto> Handle(Command command, CancellationToken cancellationToken) { await Validate(command); AppUser appUser = _mapperHelper.Map <Command, AppUser>(command); _unitOfWork.AppUserRepo.Add(appUser); int insertCnt = await _unitOfWork.SaveAsync(cancellationToken); if (insertCnt > 0) { return(_mapperHelper.Map <AppUser, UserDto>(appUser)); } throw new Exception("Problem saving changes to database"); }
public async Task <PrintingEditionModel> CreatePrintingEditionAsync(PrintingEditionModelItem printingEditionsModelItem) { var responseModel = ValidateData(printingEditionsModelItem); if (responseModel.Errors.Any()) { return(responseModel); } var printingEdition = _mapperHelper.Map <PrintingEditionModelItem, PrintingEdition>(printingEditionsModelItem); printingEdition.Price = _currencyConverterHelper.Convert(printingEditionsModelItem.Currency, Enums.Currency.USD, printingEditionsModelItem.Price); printingEdition.Currency = Enums.Currency.USD; var authorsId = printingEditionsModelItem.Authors.Select(x => x.Id).ToArray(); if (authorsId == null || !authorsId.Any()) { responseModel.Errors.Add(Constants.Errors.InvalidData); return(responseModel); } var createResult = await _printingEditionRepository.CreateAsync(printingEdition); if (createResult.Equals(0)) { responseModel.Errors.Add(Constants.Errors.FailedCreate); return(responseModel); } var createAuthorsInPrintingEditionResult = await _authorInPrintingEditionRepository.CreateAuthorsInPrintingEditionAsync(printingEdition.Id, authorsId); if (createAuthorsInPrintingEditionResult.Equals(0)) { responseModel.Errors.Add(Constants.Errors.FailedCreate); return(responseModel); } return(responseModel); }
public async Task <UserDto> Handle(Query query, CancellationToken cancellationToken) { Guid userId = _userAccessor.GetCurrentUserId(); string userName = _userAccessor.GetCurrentUserName(); AppUser user = await _unitOfWork.AppUserRepo.FindFirstAsync(e => e.Id == userId, new List <string> { nameof(AppUser.Photos), nameof(AppUser.IdentityUser) }, cancellationToken); return(_mapperHelper.Map <AppUser, UserDto>(user)); }
public async Task <UserModel> GetAllUsersAsync(FilterUserModel filterModel) { var userModel = new UserModel(); var repositoryModel = _mapperHelper.Map <FilterUserModel, DataFilter.FilterUserModel>(filterModel); if (repositoryModel == null) { userModel.Errors.Add(Constants.Errors.OccuredProcessing); return(userModel); } var filteringUsers = await _userRepository.GetFilteredDataAsync(repositoryModel); if (filteringUsers == null) { userModel.Errors.Add(Constants.Errors.OccuredProcessing); return(userModel); } foreach (var user in filteringUsers.Collection) { var userModelItem = user.MapToModel <UserModelItem>(); if (userModelItem == null) { userModel.Errors.Add(Constants.Errors.OccuredProcessing); continue; } userModel.Items.Add(userModelItem); } userModel.ItemsCount = filteringUsers.CollectionCount; return(userModel); }
public async Task <ProfileDto> ReadProfile(Guid appUserId, CancellationToken cancellationToken) { AppUser appUser = await _unitOfWork.AppUserRepo.GetUserProfile(appUserId, cancellationToken); ProfileDto profileDto = _mapperHelper.Map <AppUser, ProfileDto>(appUser); profileDto.FollowersCount = await _unitOfWork.UserFollowerRepo.GetFollowersCountAsync(appUserId, cancellationToken); profileDto.FollowingCount = await _unitOfWork.UserFollowerRepo.GetFollowingCountAsync(appUserId, cancellationToken); profileDto.Following = await _unitOfWork.UserFollowerRepo .HasAnyAsync(f => f.Follower.Id == _userAccessor.GetCurrentUserId() && f.UserId == appUserId, cancellationToken); return(profileDto); }
public async Task <string> Handle(Command request, CancellationToken cancellationToken) { Guid appUserId = _userAccessor.GetCurrentUserId(); AppUser dbAppUser = await _unitOfWork.AppUserRepo.FindFirstAsync(e => e.Id == appUserId, null, cancellationToken); await Validate(request, dbAppUser.Id); AppUser appUser = _mapperHelper.Map <Command, AppUser>(request); appUser.Id = dbAppUser.Id; _unitOfWork.AppUserRepo.Update(appUser); int insertCnt = await _unitOfWork.SaveAsync(cancellationToken); if (insertCnt > 0) { return(appUser.DisplayName); } throw new Exception("Problem saving changes to database"); }
public async Task <UserDto> Handle(Command request, CancellationToken cancellationToken) { IdentityUser identityUser = await _unitOfWork.IdentityUserRepo.FindFirstAsync(request.UserName, cancellationToken); if (identityUser == null) { throw new CustomException(HttpStatusCode.Unauthorized); } if (_cryptoHelper.GenerateHash(request.Password, identityUser.Salt) == identityUser.Passoword) { identityUser.PreviousRefreshToken = null; identityUser.PreviousRefreshTokenExpiry = null; identityUser.RefreshToken = _jwtGenerator.CreateRefreshToken(); identityUser.RefreshTokenExpiry = HelperFunc.GetCurrentDateTime().AddDays(30); _unitOfWork.IdentityUserRepo.Update(identityUser); await _unitOfWork.SaveAsync(cancellationToken); return(_mapperHelper.Map <IdentityUser, UserDto>(identityUser)); } throw new CustomException(HttpStatusCode.Unauthorized); }
public async Task <OrderModel> GetOrdersAsync(FilterOrderModel filterOrder, string userId) { var responseModel = new OrderModel(); var repositoryFilter = _mapperHelper.Map <FilterOrderModel, DataFilter.FilterOrderModel>(filterOrder); if (!long.TryParse(userId, out long _userId) || _userId == 0) { responseModel.Errors.Add(Constants.Errors.UserNotFound); return(responseModel); } var orders = await _orderRepository.GetAllOrdersAsync(repositoryFilter, _userId); responseModel.ItemsCount = orders.CollectionCount; foreach (var order in orders.Collection) { var orderModelItem = order.MapToModel(); responseModel.Items.Add(orderModelItem); } return(responseModel); }
public async Task <List <VehicleEncyclopedia> > GetWotEncyclopediaVehiclesAsync() { var tankopedia = await _webApiClient.GetResponse <Dictionary <string, WotEncyclopediaVehiclesResponse> >( _requestBuilder.BaseAddress, _requestBuilder.BuildRequestUrl(RequestType.EncyclopediaVehicles, new RequestParameter { ParameterType = ParameterType.Fields, ParameterValue = "tank_id,name,tier,nation,type,description,is_premium,cost,images,next_tanks" })); var allVehicles = tankopedia.Values.ToList(); allVehicles.AddMarkI(); allVehicles.AddHetzerKame(); return(_mapper.Map <List <WotEncyclopediaVehiclesResponse>, List <VehicleEncyclopedia> >(allVehicles)); }
public Task <Dto.Item> Handle(Query request, CancellationToken cancellationToken) { Domain.Item dbResponse = _unitOfWork.ItemRepo.Find(request.Name); return(Task.FromResult(_mapperHelper.Map <Domain.Item, Dto.Item>(dbResponse))); }