public bool Remove(T item, OperationDetails od) { var operation = new Operation <T>(item, od); if (!Contains(item)) { return(false); } if (Deletions.Add(operation)) { _setRisk(od.Risk); return(true); } return(false); }
//[ValidateAntiForgeryToken] public async Task <JsonResult> Register(RegisterModel model, int hotelId = 0) { await SetInitialDataAsync(); if (ModelState.IsValid) { UserDTO userDto = new UserDTO { Email = model.Email, Password = model.Password, Surname = model.Surname, Name = model.Name, TelephoneNumber = model.PhoneNumber }; userDto.Role = hotelId != 0 ? "employee" : "user"; OperationDetails operationDetails = await UserService.Create(userDto); if (operationDetails.Succedeed) { if (hotelId != 0) { string userId = operationDetails.Message; await EmployeeService.Create(new EmployeeDTO { ApplicationUserId = userId, HotelId = hotelId }); } var res = new JsonResult { Data = "" }; return(res); } else { ModelState.AddModelError(operationDetails.Property, operationDetails.Message); } } var result = new JsonResult { Data = "error" }; return(result); }
public ActionResult Edit(EditUserViewModel model) { try { var user = GetUser(); if (ModelState.IsValid) { OperationDetails operationDetails = userService.EditUser(user, model.OldPassword, model.NewPassword); ModelState.AddModelError(operationDetails.Property, operationDetails.Message); } } catch (ValidationException ex) { ModelState.AddModelError(ex.Property, ex.Message); } return(View(model)); }
public async Task <ActionResult> SaveVideo(VideoViewModel model) { string virtualSrcPath = "~/Videos/" + User.Identity.Name + "/temporary/videopath/" + model.FileName; string srcPath = Server.MapPath(virtualSrcPath); if (System.IO.File.Exists(srcPath)) { if (ModelState.IsValid) { using (IVideoService videoService = ServiceCreator.CreateVideoService(Connection)) { string virtualDestPath = "~/Content/Videos/" + User.Identity.Name + "/" + model.PlaylistId + "/"; string destPath = Server.MapPath(virtualDestPath); string hashedFileName = model.FileName.GetHashCode() + DateTime.Now.Ticks + ".mp4";; bool isExists = Directory.Exists(destPath); if (!isExists) { Directory.CreateDirectory(destPath); } destPath += hashedFileName; System.IO.File.Copy(srcPath, destPath); System.IO.File.Delete(srcPath); VideoDTO videoDto = new VideoDTO(); videoDto.Name = model.Name; videoDto.IsDeleted = false; videoDto.Description = model.Description; videoDto.UserName = User.Identity.Name; videoDto.Path = virtualDestPath.Substring(1) + hashedFileName; videoDto.PlaylistId = model.PlaylistId; OperationDetails operationDetail = await videoService.AddVideo(videoDto); return(RedirectToAction("PlaylistConcrete", "Playlist", new { playlistId = model.PlaylistId })); } } else { return(AddVideo(model)); } } else { ModelState.AddModelError("FileNotFound", "Can't found your file. Please try to upload it again."); return(AddVideo(model)); } }
public async Task <ActionResult> RemoveUserFromRole(string roleId, string userId, string returnUrl) { //todo id ==null string currentUserId = HttpContext.User.Identity.GetUserId(); OperationDetails operationDetails = await _identityService.RemoveUserFromRole(currentUserId, userId, roleId); if (operationDetails.Succedeed) { TempData["message"] = operationDetails.Message; return(Redirect(string.IsNullOrWhiteSpace(returnUrl) ? Url.Action("Roles") : returnUrl)); } else { TempData["message"] = operationDetails.Message; return(RedirectToAction("Roles")); } }
public async Task <OperationDetails> Update(UserDTO item) { OperationDetails resultOperation; ClientProfile clientProfile = _mapper.Map <UserDTO, ClientProfile>(item); clientProfile = await _database.ProfileRepository.Update(clientProfile); if (clientProfile == null) { resultOperation = new OperationDetails(false, string.Empty, string.Empty); } else { resultOperation = new OperationDetails(true, string.Empty, string.Empty); } return(resultOperation); }
public async Task <ActionResult> AddStoreType(StoreTypeViewModel model) { if (!ModelState.IsValid) { return(View(model)); } StoreTypeDto storeTypeDto = mapper.Map <StoreTypeViewModel, StoreTypeDto>(model); OperationDetails operationDetails = await storeTypeService.AddStoreTypeAsync(storeTypeDto); if (operationDetails.Succedeed) { return(View("SuccessAdd")); } ModelState.AddModelError(operationDetails.Property, operationDetails.Message); return(View(model)); }
public ActionResult AddEpisode(string id, int serialId, string count, string name, DateTime?date) { string message = ""; try { var temp = Convert.ToInt32(id); var temp2 = Convert.ToInt32(count); OperationDetails opDet = serialService.AddEpisode(temp, temp2, name, date); message = opDet.Message; } catch (ValidationException ex) { message = ex.Message; } return(RedirectToAction("SerialInfo", new { id = serialId, message })); }
public async Task <OperationDetails> DeleteItemAsync(TType id, OperationDetails MessageSuccess, OperationDetails MessageFail) { TEntity Item = await repository.FindByIdAsync(id); if (Item == null) { return(MessageFail); } else { await repository.DeleteAsync(id); await repository.SaveChangesAsync(); return(MessageSuccess); } }
// GET: Test/Subscribe public async Task <ActionResult> Subscribe(int?id) { try { // I. Checks. string currentUserId = System.Web.HttpContext.Current.User.Identity.GetUserId(); if (currentUserId == null) { return(RedirectToAction("Login", "Account")); } // Check id. if (!int.TryParse(id.ToString(), out int intId)) { return(RedirectToAction("Index")); } // II. Add a new subscription to DB. if (ModelState.IsValid) { SubscriptionDTO subscriptionDTO = new SubscriptionDTO { UserProfileId = currentUserId, CourseId = intId, SubscriptionPeriod = 1, IsApproved = false }; OperationDetails operationDetails = await SubscriptionService.CreateAsync(subscriptionDTO, currentUserId); if (operationDetails.Succedeed) { return(PartialView("Report", operationDetails)); } else { ModelState.AddModelError(operationDetails.Property, operationDetails.Message); return(PartialView("Report", operationDetails)); } } ViewBag.Message = "Non valid"; return(PartialView()); } catch (Exception ex) { throw new Exception(ex.Message); } }
public async Task CreateUser_EmailNull_ShouldReturnFalseInOperationDetails() { //Arrange var mock = new Mock <IUnitOfWork>(); UserService userService = new UserService(mock.Object); UserDTO userDto = new UserDTO() { Email = null, Id = "id", Password = "******", UserName = "******", Role = "User" }; var expectedOpDet = new OperationDetails(false, "", ""); //Act var actualOpDet = await userService.Create(userDto); //Assert Assert.AreEqual(expectedOpDet.Succeeded, actualOpDet.Succeeded, "True OperationDetails.Succeded result occurred"); }
public async Task <IActionResult> RegisterAsync([FromForm] RegisterUserBindingModel model) { var user = await _userService.GetUserAsync(model.UserName); if (user == null) { var creator = await _userService.GetUserAsync(User?.Identity?.Name); await _userService.CreateUserAsync(model.UserName, model.Password, model.Email, model.Role, creator); return(Ok(OperationDetails.Success($"User '@{model.UserName}' has been registered successfully."))); } else { return(BadRequest(OperationDetails.Error($"User '@{model.UserName}' already exists."))); } }
public async Task <IActionResult> Register(RegisterModel model) { if (ModelState.IsValid) { UserDTO userDto = _mapper.Map <RegisterModel, UserDTO>(model); OperationDetails operationDetails = await _userService.CreateAsync(userDto); if (operationDetails.Succedeed) { bool auth = await _userService.AuthenticateAsync(userDto); return(RedirectToAction("Index", "Home")); } ModelState.AddModelError(operationDetails.Property, operationDetails.Message); } return(View(model)); }
public ActionResult ToAdding(Serial serial) { try { if (ModelState.IsValid) { OperationDetails operationDetails = serialService.Adding(serial.Name, serial.Begin, serial.Picture, serial.Country , serial.Description, serial.Duration, serial.Status); ModelState.AddModelError(operationDetails.Property, operationDetails.Message); return(RedirectToAction("Index", new { message = operationDetails.Message })); } } catch (ValidationException ex) { ModelState.AddModelError(ex.Property, ex.Message); } return(View(serial)); }
public async Task <IActionResult> SetAdStatus(int adId, int adStatus) { ModerationAdIndexViewModel model = new ModerationAdIndexViewModel { AdList = new List <AdDTO>() }; OperationDetails <int> operationDetails = new OperationDetails <int>(false, "", 0); operationDetails = await _adService.SetStatusAd(adId, adStatus); if (!operationDetails.Succedeed) { return(View("Index", model.StatusMessage = operationDetails.Message)); } return(RedirectToAction("Index", adStatus)); }
public async Task<ActionResult> Register(RegisterModel model) { if (!ModelState.IsValid) { return View(model); } UserDto userDto = mapper.Map<RegisterModel, UserDto>(model); userDto.Role = UserRoles.User; OperationDetails operationDetails = await userService.AddUserAsync(userDto); if (operationDetails.Succedeed) { return View("SuccessRegister"); } ModelState.AddModelError(operationDetails.Property, operationDetails.Message); return View(model); }
public async Task <ActionResult> ChangePassword(ChangePasswordViewModel model) { string oldPass = model.OldPassword; string newPass = model.NewPassword; string confirmPass = model.ConfirmPassword; if (newPass == confirmPass) { OperationDetails details = await _profileService.ChangePassword(AuthenticationManager.User.Identity.Name, oldPass, newPass); if (details.Succedeed) { return(RedirectToAction("Index")); } } return(View(model)); }
public async Task <ActionResult> DeletePost(BlogDto model, string url) { var currentUser = User.Identity.GetUserId(); if (model.UserProfileId != currentUser) { return(RedirectToAction("Index", "Blog")); } OperationDetails operationDetails = await BlogService.DeletePost(model.Id); if (!operationDetails.Succedeed) { ModelState.AddModelError(operationDetails.Property, operationDetails.Message); } return(RedirectToAction("Index", "Blog")); }
public IHttpActionResult EditUser(int id, UserDTO userDTO) { if (id != userDTO.Id) { return(BadRequest()); } OperationDetails od = userService.EditUser(userDTO); if (od.Succeeded == false) { return(NotFound()); } else { return(StatusCode(HttpStatusCode.NoContent)); } }
public async Task <ActionResult> _UpdateEmail(UpdateEmailModel model) { if (ModelState.IsValid) { OperationDetails result = await _userManagementService.UpdateUserEmail(UserId, model.Email); if (result.Succeeded) { TempData["PartialMessage"] = result.Message; } else { TempData["PartialMessage"] = result.Message; } } return(PartialView(model)); }
public async Task <OperationDetails> UpdateItemAsync(TEntityDto ItemDto, TType idDto, OperationDetails MessageSuccess, OperationDetails MessageFail) { TEntity ItemEntity = await repository.FindByIdAsync(idDto); if (ItemEntity != null) { ItemEntity = Map <TEntityDto, TEntity>(ItemDto); repository.Update(ItemEntity); await repository.SaveChangesAsync(); return(MessageSuccess); } else { return(MessageFail); } }
public ActionResult Create(CreateOrderViewModel order, HttpPostedFileBase loadImage) { if (ModelState.IsValid) { PictureViewModelBLL picture = null; if (!ReferenceEquals(loadImage, null)) { byte[] image; using (var binaryReader = new BinaryReader(loadImage.InputStream)) { image = binaryReader.ReadBytes(loadImage.ContentLength); } picture = new PictureViewModelBLL { Image = image }; _pictureService.Create(image); _unitOfWork.Save(); } Mapper.Initialize(cfg => cfg.CreateMap <CreateOrderViewModel, OrderViewModelBLL>() .ForMember("CategoryId", opt => opt.MapFrom(c => _categoryService.FindByName(c.Category).Id)) .ForMember("StatusId", opt => opt.MapFrom(c => 1)) .ForMember("AdminStatus", opt => opt.MapFrom(c => false)) .ForMember("UploadDate", opt => opt.MapFrom(c => DateTime.Now)) .ForMember("UserId", opt => opt.MapFrom(c => User.Identity.GetUserId <int>())) .ForMember("PictureId", opt => opt.MapFrom(c => _pictureService.FindByBytes(picture.Image).Value)) ); OrderViewModelBLL orderDto = Mapper.Map <CreateOrderViewModel, OrderViewModelBLL>(order); OperationDetails operationDetails = _orderService.Create(orderDto); _unitOfWork.Save(); if (operationDetails.Succedeed) { return(RedirectToAction("Index")); } ModelState.AddModelError(operationDetails.Property, operationDetails.Message); } ModelState.AddModelError("", "Creation error"); ViewBag.Category = new SelectList(_categoryService.GetAll(), "Name", "Name"); ViewBag.DefaultPath = $"data: image/png; base64, {Convert.ToBase64String(System.IO.File.ReadAllBytes(Server.MapPath(DefaultImageName)))}"; return(View(order)); }
public async Task <OperationDetails <int> > SaveAd( string userName, AdDTO ad, IFormFileCollection productPhotos) { OperationDetails <int> operationDetails = new OperationDetails <int>(false, "", 0); ApplicationUser user = new ApplicationUser(); if (ad == null) { return(new OperationDetails <int>(false, "new Ad can't be null or empty", 0)); } if (String.IsNullOrEmpty(userName)) { return(operationDetails); } user = await _uof.UserRepository.FindUserByUserName(userName); if (user == null) { return(operationDetails); } var newAd = _dataService.TransformingAdDTOToAdEntities(ad); newAd.ApplicationUser = user; if (newAd.AdId == 0) { newAd.AdStatusId = (int)AdStatuses.Activated; newAd.IsModerate = true; operationDetails = await CreateAd(user, newAd, productPhotos); } else { newAd.AdStatusId = (int)AdStatuses.InProgress; newAd.IsModerate = false; operationDetails = await UpdateAd(user, newAd, productPhotos); } return(operationDetails); }
public ActionResult Send(CreateCommentViewModel comment) { if (!User.IsInRole("user")) { throw new Exception("User is not authorized"); } bool commentIsEmpty = comment.Text == null || comment.Text.Equals(string.Empty); Mapper.Initialize(cfg => cfg.CreateMap <CreateCommentViewModel, CommentViewModelBLL>() .ForMember("Date", opt => opt.MapFrom(c => DateTime.Now)) .ForMember("CustomerId", opt => opt.MapFrom(c => User.Identity.GetUserId <int>())) .ForMember("Rating", opt => opt.MapFrom(c => c.Rating.ToCharArray().Where(r => r == '★').Count())) ); CommentViewModelBLL commentDto = Mapper.Map <CreateCommentViewModel, CommentViewModelBLL>(comment); if (ModelState.IsValid) { OperationDetails operationDetails = _commentService.Create(commentDto); _unitOfWork.Save(); if (!operationDetails.Succedeed) { ModelState.AddModelError(operationDetails.Property, operationDetails.Message); } var user = _userService.FindById(comment.PerformerId); if (user.CommentsBll != null) { user.Rating = (int)Math.Round((float)(user.CommentsBll.Select(c => c.Rating).Sum() / user.CommentsBll.Count)); } operationDetails = _userService.Update(user); _unitOfWork.Save(); if (!operationDetails.Succedeed) { ModelState.AddModelError(operationDetails.Property, operationDetails.Message); } } else { throw new Exception("Model is not valid"); } return(RedirectToAction("Details", "Performers", new { id = comment.PerformerId, emptyComment = commentIsEmpty })); }
// Get test results. public async Task <ActionResult> GetCurrentTestResults(int?id) { try { // I. Clear controller properties for processing a test period. TestPeriod = 0; StartTestTime = null; // II. Check. if (AllAnswers.Count == 0 || UserAnswers.Count == 0) { return(RedirectToAction("Index")); } // III.Get the test result. OperationDetails operationDetails = PLRepository.CalculateTestResults(AllAnswers, UserAnswers, TestQuetions, out TestResultViewModel testResult); if (!operationDetails.Succedeed) { return(View("Report", operationDetails)); } // Is the test passed? int firstQuestionId = AllAnswers.FirstOrDefault().Key; CourseDTO courseDTO = (await QuestionService.GetAsync(firstQuestionId)).Topic.Course; testResult.IsPassedTest = testResult.Result > testResult.MaxScore * courseDTO.PassingScore / 100; // Set ViewBag property for a View. ViewBag.CourseName = courseDTO.CourseTitle; // IV.Set testResult properies (Result, MaxScore and TestResultDetails). testResult.Result = testResult.Result * 1000 / testResult.MaxScore; testResult.MaxScore = 1000; foreach (var item in testResult.TestResultDetails) { item.Topic = (await QuestionService.GetAsync(item.QuestionId)).Topic.TopicTitle; item.Question = (await QuestionService.GetAsync(item.QuestionId)).QuestionText; } // V. return(View(testResult)); } catch (Exception ex) { throw new Exception(ex.Message); } }
// ModeratorSuscription/TrialSubscribe public async Task <ActionResult> TrialSubscribe() { try { //I. Check. string currentUserId = System.Web.HttpContext.Current.User.Identity.GetUserId(); if (currentUserId == null) { return(new HttpUnauthorizedResult()); } // II. Create a trial moderator subscription. if (ModelState.IsValid) { SubscriptionForModeratorDTO subscriptionDTO = new SubscriptionForModeratorDTO { UserProfileId = currentUserId, CourseCount = 1, SubscriptionPeriod = 7, IsTrial = true, IsApproved = true }; OperationDetails operationDetails = await SubscriptionForModeratorService.CreateAsync(subscriptionDTO, currentUserId); if (operationDetails.Succedeed) { return(PartialView("Report", operationDetails)); } else { ModelState.AddModelError(operationDetails.Property, operationDetails.Message); return(PartialView("Report", operationDetails)); } } // III. ViewBag.Message = "Non valid"; return(PartialView()); } catch (Exception ex) { throw new Exception(ex.Message); } }
public IHttpActionResult DeleteUser(int id) { UserDTO user = userService.FindUser(id); if (user == null) { return(NotFound()); } OperationDetails od = userService.DeleteUser(id); if (od.Succeeded == false) { return(BadRequest()); } else { return(Ok(user)); } }
public void WrongUserCreationTest(UserDTO userDto) { //Arrange var user = new ApplicationUser { Email = "ok", Roles = { new IdentityUserRole { UserId = "test", RoleId = "test" } }, ClientProfile = new ClientProfile { Name = "test" } }; var mockStore = new Mock <IUserStore <ApplicationUser> >(); mockStore.Setup(x => x.FindByIdAsync(It.IsAny <string>())).Returns(Task.FromResult(user)); mockStore.As <IUserEmailStore <ApplicationUser> >().Setup(x => x.FindByEmailAsync("existed")).Returns(Task.FromResult((ApplicationUser)null)); mockStore.As <IUserPasswordStore <ApplicationUser> >(); mockStore.As <IUserRoleStore <ApplicationUser> >().Setup(x => x.AddToRoleAsync(It.IsAny <ApplicationUser>(), It.IsAny <string>())) .Returns(Task.FromResult(IdentityResult.Success)); mockStore.As <IUserRoleStore <ApplicationUser> >().Setup(x => x.GetRolesAsync(It.IsAny <ApplicationUser>())) .Returns(Task.FromResult((IList <string>) new List <string>())); mockStore.Setup(x => x.CreateAsync(It.IsAny <ApplicationUser>())) .Returns(Task.FromResult(IdentityResult.Success)); var mockDbSet = new Mock <DbSet <ClientProfile> >(MockBehavior.Strict); mockDbSet.Setup(x => x.Add(It.IsAny <ClientProfile>())).Returns(new ClientProfile()); var userManager = new ApplicationUserManager(mockStore.Object); var mock = new Mock <IUnitOfWork>(); mock.Setup(a => a.UserManager).Returns(userManager); //Act var userService = new UserService(mock.Object); OperationDetails result = userService.Create(userDto); //Assert Assert.That(result.Succedeed, Is.False); }
public async Task <ActionResult> Registration(RegistrationViewModel model) { await SetInitialDataAsync(); if (ModelState.IsValid) { UserDTO userDto = new UserDTO { Email = model.Email, Password = model.Password, Address = model.Address, Name = model.Name, Role = "user" }; OperationDetails operationDetails = await UserService.CreateAsync(userDto); if (operationDetails.Succedeed) { UserDTO userDtoWithId = await UserService.FindAsync(userDto.Email, userDto.Password); string code = await UserService.GenerateEmailConfirmationTokenAsync(userDtoWithId.Id); string callBackURL = Url.Action("ConfirmEmail", "Account", new { userId = userDtoWithId.Id, code = code }, protocol: Request.Url.Scheme); StringBuilder confirmingMessage = new StringBuilder(ConfigurationManager.AppSettings["EmailConfirmingMessageStart"]); confirmingMessage.Append("<a href=\""); confirmingMessage.Append(callBackURL); confirmingMessage.Append("\">Press to confirm email. <a/>"); confirmingMessage.Append(ConfigurationManager.AppSettings["EmailConfirmingMessageEnd"]); string subject = ConfigurationManager.AppSettings["Subject"]; await UserService.SendEmailAsync(userDtoWithId.Id, subject, confirmingMessage.ToString()); return(View("DisplayEmail")); } else { ModelState.AddModelError(operationDetails.Property, operationDetails.Message); } } return(View(model)); }
public async Task <OperationDetails <IQueryable <PurchaseDTO> > > GetPurchaseByUserId(string userId) { OperationDetails <IQueryable <PurchaseDTO> > operationDetails = new OperationDetails <IQueryable <PurchaseDTO> > (false, "Что-то пошло не так, проверте данные и повториет позже", null); if (string.IsNullOrEmpty(userId)) { return(operationDetails); } var user = await _uof.UserRepository.FindByIdAsync(userId); if (user == null) { return(operationDetails); } var ads = await _uof.AdRepository.FindAdsByUserId(userId); if (ads == null) { return(operationDetails); } var purchasesDTO = ads.SelectMany(x => x.Purhcases.Select( p => new PurchaseDTO { PurchaseId = p.PurchaseId, TotalCost = p.TotalCost, DateOfPayment = p.DateOfPayment, StartDateService = p.StartDateService, EndDateService = p.EndDateService, IsPayed = p.IsPayed, IsActive = p.IsActive, ServicesId = p.ServicesId, ServiceActiveTimeId = p.ServiceActiveTimeId, AdId = p.AdId })).AsQueryable(); operationDetails = new OperationDetails <IQueryable <PurchaseDTO> >(true, "", purchasesDTO); return(operationDetails); }