public async Task <ActionResult <Response> > UpdateProject(Guid projectId, AddProjectViewModel accountViewModel) { if (!ModelState.IsValid) { return(Ok(new Response { Successful = "true", Msg = ModelState.Values.ToString(), Data = null })); } try { var convertProjectId = projectId.ToString().ToUpper(); var userId = HttpContext.User.Claims.First(c => c.Type == "uid").Value.ToString(); var role = await AzureService.FindUserRole(userId); if (role != "admin") { return(StatusCode(403)); } await AzureService.UpdateProject(convertProjectId, accountViewModel); return(Ok(new Response { Msg = "ok" })); } catch (Exception ex) { return(StatusCode(500, ex.Message)); } }
public void NewProject(AddProjectViewModel addProject, string userName) { DataTable tbTechList = new DataTable(); tbTechList.Columns.Add("Id", typeof(int)); using (SqlConnection SQLConnect = new SqlConnection(configuration.GetConnectionString("DefaultConnection"))) { if (addProject.TechList != null) { addProject.TechList.ForEach(x => tbTechList.Rows.Add(x)); SQLConnect.Execute("Exec Project_Add @Title=@T, @Description=@D, @TechList=@L, @UserName=@U, @NewMembers=@M", new { T = addProject.Title, D = addProject.Description, L = tbTechList.AsTableValuedParameter("TechnologyList"), U = userName, M = addProject.NewMembers }); } else { SQLConnect.Execute("Exec Project_Add @Title=@T, @Description=@D, @UserName=@U, @NewMembers=@M", new { T = addProject.Title, D = addProject.Description, U = userName, M = addProject.NewMembers }); } } }
public IHttpActionResult Add(AddProjectViewModel model) { var jobSeeker = this.data.JobSeekerProfiles.All() .FirstOrDefault(x => x.UserId == this.CurrentUserId); if (jobSeeker == null) { return this.BadRequest("You must be a job seeker to delete a project"); } if (model != null && ModelState.IsValid) { var project = AutoMapper.Mapper.Map<Project>(model); this.data.Projects.Add(project); this.data.SaveChanges(); model.Id = project.Id; jobSeeker.Projects.Add(project); this.data.SaveChanges(); return this.Ok(model); } return this.BadRequest(); }
public void AddProjectTest() { //Arrange - pierwsza faza unit testa //AddProject metoda wymaga parametru AddProjectViewModel, wiec tworzymy jakeigos dla testow AddProjectViewModel addProjectViewModel = new AddProjectViewModel { Title = "unit test title", Description = "unit test description" }; //Act - druga faza unit testu //wykonujemy metode ktora testujemy var result = _projectController.AddProject(addProjectViewModel); //Assert - trzecia faza unit testu - weryfikacja //weryfikujemy ze metoda NewProject faka dla repository byla uruchomiona z paramterem ktory jest rowny zmiennej addProjectViewModel. I zostala uruchomiona tylko raz. A.CallTo(() => _repository.NewProject(A <AddProjectViewModel> .That.Matches(a => a == addProjectViewModel), A <string> .Ignored)).MustHaveHappened(Repeated.Exactly.Once); Assert.NotNull(result); var actionResult = (RedirectToActionResult)result; Assert.AreEqual("Project", actionResult.ControllerName); Assert.AreEqual("ShowProjectsGrid", actionResult.ActionName); }
public void AddProjectModelStateErrorTest() { using (var mock = AutoMock.GetLoose()) { mock.Mock <IRepository <Client> >() .Setup(c => c.GetList()) .Returns(GetSampleClients()); var identity = new GenericIdentity("test_user"); identity.AddClaim(new Claim("http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier", Guid.NewGuid().ToString())); var principal = new GenericPrincipal(identity, new[] { "user" }); var httpCtxStub = new Mock <HttpContextBase>(); httpCtxStub.SetupGet(p => p.User).Returns(principal); var controllerCtx = new ControllerContext { HttpContext = httpCtxStub.Object }; _homeController = mock.Create <HomeController>(); _homeController.ModelState.AddModelError("key", "error message"); _homeController.ControllerContext = controllerCtx; var viewModel = new AddProjectViewModel() { Project = new Project() }; var result = _homeController.Add(viewModel); Assert.IsInstanceOf <ViewResult>(result); } }
public AddProjectView() { addProjectViewModel = new AddProjectViewModel(this); InitializeComponent(); this.DataContext = addProjectViewModel; }
public void AddValidProjectTest() { using (var mock = AutoMock.GetLoose()) { mock.Mock <IValidator <Project> >() .Setup(v => v.Validate(It.IsAny <Project>())) .Returns(true); var identity = new GenericIdentity("test_user"); identity.AddClaim(new Claim("http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier", Guid.NewGuid().ToString())); var principal = new GenericPrincipal(identity, new[] { "user" }); var httpCtxStub = new Mock <HttpContextBase>(); httpCtxStub.SetupGet(p => p.User).Returns(principal); var controllerCtx = new ControllerContext { HttpContext = httpCtxStub.Object }; _homeController = mock.Create <HomeController>(); _homeController.ControllerContext = controllerCtx; var viewModel = new AddProjectViewModel() { Project = new Project() }; var result = _homeController.Add(viewModel); var routeResult = result as RedirectToRouteResult; Assert.AreEqual("Index", (string)routeResult?.RouteValues["action"]); } }
public async Task <IActionResult> AddProject(AddProjectViewModel addProjectViewModel) { if (!ModelState.IsValid) { return(View()); } var projectForCreation = new ProjectForCreation() { Name = addProjectViewModel.Name, Revenue = addProjectViewModel.Revenue }; var serializedProjectForCreation = JsonConvert.SerializeObject(projectForCreation); // call the API var httpClient = await this.projectHttpClient.GetClient(); var response = await httpClient.PostAsync( $"api/projects", new StringContent(serializedProjectForCreation, Encoding.Unicode, "application/json")) .ConfigureAwait(false); if (response.IsSuccessStatusCode) { return(RedirectToAction("Index")); } throw new Exception($"A problem happened while calling the API: {response.ReasonPhrase}"); }
public bool AddProject(string userId, AddProjectViewModel project) { var owner = freelancerDb.Owners.FirstOrDefault(t => t.User.Id == userId); if (owner == null) { return(false); } var requiredSkills = GetSkillsBySkillNames(project.RequiredSkill); var newProject = new Project { ProjectId = Guid.NewGuid().ToString(), Owner = owner, Description = project.Description, Title = project.Title, MaxPrice = double.Parse(project.MaxPrice), MinPrice = double.Parse(project.MinPrice), Status = Status.Pending }; newProject.ProjectSkill = AddProjectSkillsBySkills(requiredSkills, newProject); freelancerDb.Projects.Add(newProject); freelancerDb.SaveChanges(); return(true); }
public async Task <ActionResult <Response> > AddProject([FromBody] AddProjectViewModel accountViewModel) { if (!ModelState.IsValid) { return(Ok(new Response { Successful = "true", Msg = ModelState.Values.ToString(), Data = null })); } try { var userId = HttpContext.User.Claims.First(c => c.Type == "uid").Value.ToString(); var role = await AzureService.FindUserRole(userId); //if (role != "admin") //{ // return StatusCode(403); //} string projectId = await AzureService.AddProject(accountViewModel); await AzureService.AddProjectManagerByUserId(projectId, userId); return(Ok(new Response { Msg = "ok" })); } catch (Exception ex) { return(StatusCode(500, ex.Message)); } }
//Send user to "add project" form public IActionResult AddProject() { AddProjectViewModel addProjectViewModel = new AddProjectViewModel(context.Clients.ToList()); addProjectViewModel.Projects = context.Projects.ToList(); return(View(addProjectViewModel)); }
public ActionResult Add() { var viewModel = new AddProjectViewModel(); viewModel.Project.UserId = User.Identity.GetUserId(); viewModel.Init(_clientsRepository.GetList()); return(View(viewModel)); }
public IActionResult AddProject(AddProjectViewModel vm) { // Get the userId through user manager and call the Add Project method to create a new project and add the required information to the association table int userId = Convert.ToInt32(userMgr.GetUserId(HttpContext.User)); projectDAO.AddProject(vm.project, userId); return(RedirectToAction("Index", "Projects")); }
public IActionResult AddProject(string userId) { var viewModel = new AddProjectViewModel { UserId = userId }; return(View(viewModel)); }
public virtual ActionResult Edit(int id) { Project project = _projectService.Get(id); AddProjectViewModel viewModel = Mapper.Map <AddProjectViewModel>(project); ViewBag.Title = ViewTitles.EditProject; SetupSelectLists(viewModel); return(View(MVC.Projects.Views.Add, viewModel)); }
public AddProjectView() { this.InitializeComponent(); vm = new AddProjectViewModel(); this.DataContext = vm; dtpStartButton.MinValue = DateTime.Now; dtpEndButton.MinValue = DateTime.Now; }
public IActionResult Edit(int?id) { var project = _repo.GetProject(id); var projectViewModel = new AddProjectViewModel { ProjectID = project.ProjectID, Description = project.Description, Name = project.Name }; return(View(projectViewModel)); }
public async Task <IActionResult> Add(AddProjectViewModel model) { if (!ModelState.IsValid) { return(View(model)); } var command = this.unitOfWork.Create <AddProjectCommand>(); var response = await command.ExecuteAsync(model); return(RedirectToAction("Index", "Projects")); }
public async Task <IActionResult> Project([FromBody] AddProjectViewModel AddProjectViewModel) { if (!ModelState.IsValid) { return(Ok(new { code = 0, msg = BadRequest(ModelState).Value })); } _context.Project.Add(new Project { Name = AddProjectViewModel.Name, CreateTime = DateTime.Now }); await _context.SaveChangesAsync(); return(Ok(new { code = 1, msg = "ok" })); }
public ActionResult AddProject(AddProjectViewModel newProjectViewModel) { if (ModelState.IsValid) { Project newProjectEntity = mapper.Map <AddProjectViewModel, Project>(newProjectViewModel); newProjectEntity.IsEnabled = true; dbContext.Projects.Add(newProjectEntity); dbContext.SaveChanges(); return(RedirectToAction("Index")); } return(View()); }
public IActionResult Edit(AddProjectViewModel projectViewModel) { if (ModelState.IsValid) { var project = _repo.GetProject(projectViewModel.ProjectID); project.Name = projectViewModel.Name; project.Description = projectViewModel.Description; _repo.EditProject(project); return(Redirect("/Projects")); } return(View(projectViewModel)); }
public void Constructor_ExistingItem_EditPageContextLoadFail() { // Arrange var existingProject = new Project() { Name = "Test Project 123456789" }; // Act viewModel = new AddProjectViewModel(existingProject); // Assert Assert.NotEqual("Edit Project", viewModel.Title); }
public IActionResult Create([FromBody] AddProjectViewModel addProject) { if (ModelState.IsValid) { var project = new Project { Name = addProject.Name, Description = addProject.Description }; _repo.CreateNewProject(project); return(Redirect("/Projects")); } return(View(addProject)); }
public IActionResult AddProject(AddProjectViewModel model) { Student student = _studentService.GetOrderById(model.StudentId); Project project = new Project() { Id = model.Id, Title = model.Title, EstimatedTime = model.EstimatedTime, TimeSpend = model.TimeSpend, Student = student }; _projectService.AddNewProject(project); return(View()); }
public ActionResult Create(AddProjectViewModel newProjectViewModel) { try { // TODO: Add insert logic here var addProjectEntity = mapper.Map <AddProjectViewModel, Project>(newProjectViewModel); context.Projects.Add(addProjectEntity); context.SaveChanges(); return(RedirectToAction("Index")); } catch { return(View()); } }
public void Constructor_ExistingItem_EditPageContextLoaded() { // Arrange var existingProject = new Project() { Name = "Test Project 123456789" }; new ProjectRepository().SaveItemAsync(existingProject).Wait(); // Act viewModel = new AddProjectViewModel(existingProject); // Assert Assert.Equal("Test Project 123456789", viewModel.Item.Name); Assert.Equal("Edit Project", viewModel.Title); }
public async Task <IHttpActionResult> AddProject([FromBody] AddProjectViewModel model) { if (model == null) { model = new AddProjectViewModel(); Validate(model); } if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var project = await _projectDomain.AddProjectAsync(model); return(Ok(project)); }
public ActionResult Edit(AddProjectViewModel model) { try { if (ModelState.IsValid) { var projectEntity = mapper.Map <AddProjectViewModel, Project>(model); context.SaveChanges(); return(RedirectToAction("Index")); } return(View(model)); } catch { return(View("EditProject")); } }
public ActionResult New([Bind(Include = "Name, SuperiorID, Start, Finish, ProjectMembers")] AddProjectViewModel project) { if (Session["EmployeeID"] == null) { Session["PleaseLogin"] = true; return(RedirectToAction("", "Home")); } var permutil = new PermissionUtil(); if (permutil.IsAdministrator((int)Session["JobPosition"])) { if (project.Finish != null && project.Start > project.Finish) { ModelState.AddModelError("Start", "Data rozpoczęcia jest późniejsza niż data zakończenia projektu."); PopulateSuperiorsList(); return(View()); } var projectToAdd = new Projects(); projectToAdd.Name = project.Name; projectToAdd.SuperiorID = project.SuperiorID; projectToAdd.Start = project.Start; projectToAdd.Finish = project.Finish; projectToAdd.CreatedBy = (int)Session["EmployeeID"]; projectToAdd.CreationDate = DateTime.Now; projectToAdd.ProjectStateID = 1; // TODO: Change this magic value ctx.Projects.Add(projectToAdd); ctx.SaveChanges(); foreach (var emplID in project.ProjectMembers) { var pm = new ProjectMembers() { ProjectID = projectToAdd.ProjectID, EmployeeID = emplID }; ctx.ProjectMembers.Add(pm); } ctx.SaveChanges(); return(RedirectToAction("Overview", "Project")); } return(RedirectToAction("Overview", "Project")); }
public virtual ActionResult Edit(int id, AddProjectViewModel viewModel) { Project project = _projectService.Get(id); if (ModelState.IsValid) { project.Name = viewModel.Name; var editedExperts = viewModel.Users; var originalExperts = project.Experts.Select(x => x.UserId); var newExperts = editedExperts.Except(originalExperts).ToArray(); var removedExperts = originalExperts.Except(editedExperts).ToArray(); if (project.FinalAssessment != null && (newExperts.Any() || removedExperts.Any())) { ModelState.AddModelError(string.Empty, ApplicationStrings.CannotEditExpertsOnGeneratedFinal); } else { foreach (var item in removedExperts) { var removedExpert = project.Experts.FirstOrDefault(x => x.UserId == item); var removedAssessment = project.Assessments.FirstOrDefault(x => x.ExpertId == item); project.Experts.Remove(removedExpert); project.Assessments.Remove(removedAssessment); } foreach (var item in newExperts) { project.Experts.Add(_userService.Get(item)); _projectService.SetExpertAssessments(project); } _projectService.Update(project); TempData.AddFlash(ApplicationStrings.ProjectAdded); return(RedirectToAction(MVC.Projects.Index())); } } SetupSelectLists(viewModel); ViewBag.Title = ViewTitles.EditProject; return(View(MVC.Projects.Views.Add, viewModel)); }
/// <summary> /// <inheritdoc /> /// </summary> /// <param name="model"></param> /// <param name="cancellationToken"></param> /// <returns></returns> public virtual async Task <Project> AddProjectAsync(AddProjectViewModel model, CancellationToken cancellationToken = default(CancellationToken)) { // Project name cannot be duplicated var projects = _unitOfWork.Projects.Search(); projects = projects.Where(x => x.Name.Equals(model.Name, StringComparison.InvariantCultureIgnoreCase)); var project = await projects.FirstOrDefaultAsync(cancellationToken); if (project != null) { throw new HttpException((int)HttpStatusCode.Conflict, HttpMessages.ProjectAlreadyExist); } project = new Project(model.UserId, model.Name, model.Description, model.StatedTime, model.FinishedTime); _unitOfWork.Projects.Insert(project); await _unitOfWork.CommitAsync(); return(project); }
public virtual ActionResult Add(AddProjectViewModel viewModel) { if (ModelState.IsValid) { var domainModel = Mapper.Map <Project>(viewModel); domainModel.AssessmentQuestionCount = 10; domainModel.Experts = new List <User>(); foreach (var item in viewModel.Users) { domainModel.Experts.Add(_userService.Get(item)); } _projectService.Add(domainModel); TempData.AddFlash(ApplicationStrings.ProjectAdded); return(RedirectToAction(MVC.Projects.Index())); } SetupSelectLists(viewModel); ViewBag.Title = ViewTitles.AddProject; return(View(viewModel)); }