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