public async Task <IActionResult> CreateProjectFromTable([Bind("Id,Name")] Project project)
{
if (!User.IsInRole("Demo"))
{
if (ModelState.IsValid)
{
_context.Add(project);
await _context.SaveChangesAsync();
ProjectUser record = new ProjectUser {
UserId = _userManager.GetUserId(User), ProjectId = project.Id
};
_context.ProjectUsers.Add(record);
await _context.SaveChangesAsync();
return(RedirectToAction("Index", "Projects"));
}
return(View(project));
}
else
{
TempData["DemoLockout"] = "Your changes will not be saved. To make changes to the database please log in as a full user.";
return(RedirectToAction("Index", "Projects"));
}
}
public async Task <IActionResult> AddProjectAsync([FromBody] ProjectAc project)
{
if (ModelState.IsValid)
{
var createdBy = _userManager.GetUserId(User);
ProjectAc projectAc = await _projectRepository.CheckDuplicateProjectAsync(project);
if (!string.IsNullOrEmpty(projectAc.Name) && !string.IsNullOrEmpty(projectAc.SlackChannelName))
{
int projectId = await _projectRepository.AddProjectAsync(project, createdBy);
foreach (var applicationUser in project.ApplicationUsers)
{
ProjectUser projectUser = new ProjectUser();
projectUser.ProjectId = projectId;
projectUser.UserId = applicationUser.Id;
projectUser.CreatedBy = createdBy;
projectUser.CreatedDateTime = DateTime.UtcNow;
await _projectRepository.AddUserProjectAsync(projectUser);
}
return(Ok(project));
}
else
{
return(Ok(project));
}
}
else
{
return(BadRequest());
}
}
public ActionResult SaveProject(Project project)
{
var userID = User.Identity.GetUserId();
var user = _context.Users.SingleOrDefault(u => u.ApplicationUserId == userID);
if (project.ID == 0)
{
project.DataAdded = DateTime.Now;
_context.Projects.Add(project);
var userProject = new ProjectUser();
userProject.ProjectId = project.ID;
userProject.UserId = user.Id;
_context.ProjectUsers.Add(userProject);
}
else
{
var projectInDb = _context.Projects.Single(c => c.ID == project.ID);
projectInDb.Name = project.Name;
projectInDb.Notes = project.Notes;
projectInDb.DataAdded = DateTime.Now;
}
_context.SaveChanges();
return(RedirectToAction("ProjectList", "ProjectPage"));
}
// todo get all
public static bool AddUser(ref ProjectUser model, out string strErrorMsg)
{
strErrorMsg = "";
if (IsUserNameExist(model.Name))
{
strErrorMsg = ConstDefineBll.NameExist;
return(false);
}
using (GLedDbEntities ent = new GLedDbEntities())
{
ProjectUser newinfo = new ProjectUser()
{
Id = model.Id,
MgrProjectId = model.MgrProjectId,
Name = model.Name,
Password = model.Password,
RefOrgId = model.RefOrgId,
RefGroupId = model.RefGroupId,
CreateDt = DateTime.Now,
UpdateDt = DateTime.Now
};
ent.ProjectUser.Add(newinfo);
ent.SaveChanges();
model.Id = newinfo.Id;
}
return(true);
}
public async Task <IActionResult> UserManagement(ProjectUserModification model)
{
var projectUsers = _context.ProjectUsers.Where(p => p.ProjectId == model.ProjectId);
var projectUsersList = projectUsers.ToList();
if (ModelState.IsValid)
{
foreach (string userId in model.AddIds ?? new string[] { })
{
var projectUser = new ProjectUser();
projectUser.ProjectId = model.ProjectId;
projectUser.UserId = userId;
_context.ProjectUsers.Add(projectUser);
await _context.SaveChangesAsync().ConfigureAwait(false);
}
foreach (string userId in model.DeleteIds ?? new string[] { })
{
var ToBeRemoved = projectUsersList.Where(p => p.UserId == userId).Single();
_context.ProjectUsers.Remove(ToBeRemoved);
await _context.SaveChangesAsync().ConfigureAwait(false);
}
}
return(RedirectToAction("Details", "Projects", new { id = model.ProjectId }));
}
public async Task <IActionResult> Edit(
int id,
[Bind("UserId,ProjectId,AddProjectUsers,RemoveProjectUsers")]
ProjectUser projectUser)
{
if (id != projectUser.ProjectId)
{
return(this.NotFound( ));
}
if (this.ModelState.IsValid)
{
try
{
this.context.Update(projectUser);
await this.context.SaveChangesAsync( ).ConfigureAwait(false);
}
catch (DbUpdateConcurrencyException) when(!this.ProjectUserExists(projectUser.ProjectId))
{
return(this.NotFound( ));
}
return(this.RedirectToAction(nameof(this.Index)));
}
this.ViewData["ProjectId"] = new SelectList(this.context.Projects, "Id", "Name", projectUser.ProjectId);
this.ViewData["UserId"] = new SelectList(this.context.HeimdallUsers, "Id", "Id", projectUser.UserId);
return(this.View(projectUser));
}
public async Task Repository_AddTask_Test()
{
//arrange
MapperHelper.InitializeMapper();
var vm = new TaskAddEditViewModel()
{
Name = "test task",
Comment = "test comment",
PriorityId = Priority.High
};
var user = new ProjectUser
{
Id = "qwer"
};
var contextMock = new Mock <IProjectContext>();
var dbsetMock = CreateDbSetMock(new List <TaskModel>());
contextMock.Setup(x => x.Tasks).Returns(dbsetMock.Object);
var userServiceMock = new Mock <IUserService>();
userServiceMock.Setup(x => x.GetUserById(It.IsAny <string>()))
.Returns(Task.FromResult(user));
var repository = new TaskRepository(contextMock.Object, userServiceMock.Object);
//act
var result = await repository.AddEditTask(vm);
//assert
Assert.IsTrue(result);
Assert.AreEqual(1, contextMock.Object.Tasks.Count(), "Object wasn't added to DbSet");
Assert.IsNotNull(contextMock.Object.Tasks.SingleOrDefault(), "Object was added to DbSet more than one time");
}
private static void AddServices(ProjectUser user)
{
// normal user
user.services = new Services();
user.services.document_management = new DocumentManagement()
{
access_level = AccessLevel.user
};
// admin user?
if (user.docs_access != null && user.docs_access.Equals("admin", StringComparison.InvariantCultureIgnoreCase))
{
user.services.document_management = new DocumentManagement()
{
access_level = AccessLevel.admin
};
}
if (user.pm_access != null && user.pm_access.Equals("admin", StringComparison.InvariantCultureIgnoreCase))
{
user.services.project_administration = new ProjectAdministration()
{
access_level = AccessLevel.admin
};
}
}
public GenericServiceResult CreateNewProject(string userId, CreateProjectViewModel model)
{
try
{
ProjectSettings projectSettings = new ProjectSettings
{
AccessToChangeProject = (int)model.AccessToChangeProject,
AccessToDeleteBoard = (int)model.AccessToDeleteBoard,
AccessToCreateBoard = (int)model.AccessToCreateBoard
};
Project project = new Project {
Title = model.Title, About = model.About, Settings = projectSettings
};
User user = unitOfWork.UserManager.Users.FirstOrDefault(x => x.Id == userId);
ProjectUser projectUser = new ProjectUser {
Project = project, Role = (int)ProjectRoles.Administrator, User = user
};
unitOfWork.ProjectUser.Create(projectUser);
return(GenericServiceResult.Success);
}
catch
{
return(GenericServiceResult.Error);
}
}
public int Update(ProjectUser pu)
{
var prUS = db.ProjectUsers.Where(a => a.LoginID == pu.LoginID && a.ProjectID == pu.ProjectID).SingleOrDefault <ProjectUser>();
prUS.IsAdmin = pu.IsAdmin;
return(db.SaveChanges());
}
public GenericServiceResult RemoveUserFromProject(string userId, string userIdToRemove, int projectId)
{
try
{
bool canUserChangeProject = CanUserChangeProject(userId, projectId);
if (!canUserChangeProject)
{
return(GenericServiceResult.AccessDenied);
}
ProjectUser projectUser = unitOfWork.ProjectUser.GetFirstOrDefaultWhere(p => p.ProjectId == projectId && p.UserId == userIdToRemove);
unitOfWork.ProjectUser.Delete(projectUser.Id);
string projectTitle = unitOfWork.Projects.Get(projectId).Title;
NotificationMessage message = new NotificationMessage
{
Title = $"{projectTitle}",
Message = "You were removed from project.",
Link = null,
ObjectId = projectId,
Initiator = userId,
SendTo = userIdToRemove
};
Notifyer.Notify(message);
return(GenericServiceResult.Success);
}
catch
{
return(GenericServiceResult.Error);
}
}
public ProjectMemberViewData(ProjectUser projectUser)
{
Id = projectUser.Id;
UserId = projectUser.User.Id;
Name = projectUser.User.FullName;
Role = projectUser.ProjectRole.Name;
}
public ActionResult Create(Project project, List <int> myTechnologies)
{
try
{
project.ID_Author = (int)Session["userID"];
project.DateCreated = DateTime.Now;
project.WIP = 2;
db.Projects.Add(project);
db.SaveChanges();
if (myTechnologies != null)
{
AddTechnologies(myTechnologies, project.ID);
}
ProjectUser projectUser = new ProjectUser();
projectUser.ID_User = project.ID_Author;
projectUser.ID_Project = project.ID;
db.ProjectUsers.Add(projectUser);
db.SaveChanges();
return(RedirectToAction("SetProject", "Home", new { id = project.ID }));
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
ViewBag.CreateError = "Došlo k chybě. Opakujte prosím akci.";
}
ViewBag.technologies = new MultiSelectList(db.Technologies.ToList(), "ID", "Name");
ViewBag.myTechnologies = new MultiSelectList(db.Technologies.Where(s => s.ID == 0), "ID", "Name");
return(View(project));
}
public async Task <RequestResponse> Handle(AddUserToProjectCommand request, CancellationToken cancellationToken)
{
try
{
if (request.UserId < 1 || request.ProjectId < 1)
{
throw new Exception("Model is not valid");
}
var existEntity = _dbContext.ProjectUsers.SingleOrDefault(x => x.ProjectId == request.ProjectId && x.UserId == request.UserId);
if (existEntity != null)
{
throw new Exception("Entity already exist");
}
var entity = new ProjectUser
{
UserId = request.UserId,
ProjectId = request.ProjectId,
};
_dbContext.ProjectUsers.Add(entity);
await _dbContext.SaveChangesAsync(cancellationToken);
return(RequestResponse.Success());
}
catch (Exception ex)
{
return(RequestResponse.Error(new Exception("There was an error assigning an user to a project", ex)));
}
}
public ActionResult AddUser(int ProjectId, string UserId)
{
var ProjectUser = new ProjectUser()
{
ProjectId = ProjectId, UserId = UserId
};
if (ModelState.IsValid)
{
if (!db.ProjectUsers.Any(p => p.ProjectId == ProjectId && p.UserId == UserId))
{
db.ProjectUsers.Add(ProjectUser);
db.SaveChanges();
return(RedirectToAction("Info", new { id = ProjectId }));
}
else
{
ViewBag.message = "User Already there";
return(RedirectToAction("Info", new { id = ProjectId }));
}
}
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(db));
var users = roleManager.FindByName("Developer").Users.Select(u => u.UserId).ToList();
var developers = db.Users.Where(e => users.Contains(e.Id)).ToList();
ViewBag.ProjectId = new SelectList(db.Projects, "Id", "Name");
ViewBag.UserId = new SelectList(developers, "Id", "UserName");
return(View(ProjectUser));
}
public async Task <string> HandleInvitation(HandleInvitationDto request, CancellationToken cancellationToken)
{
Project selectedProject = await _projectRepository.Get(request.ProjectId, cancellationToken);
if (selectedProject == null)
{
return(ErrorMessages.NonexistentProject);
}
Invitation toBeRemovedInvitation =
await _projectRepository.GetInvitation(request.ProjectId, request.CollaboratorId, request.OwnerId);
if (toBeRemovedInvitation == null)
{
return(ErrorMessages.NonexistentInvitation);
}
await _projectRepository.RemoveInvitation(toBeRemovedInvitation);
if (request.Accepted == 1)
{
ProjectUser projectUserLink =
ProjectUser.CreateProjectUser(request.ProjectId, request.CollaboratorId, selectedProject);
await _projectRepository.AddProjectUser(projectUserLink, cancellationToken);
}
return(SuccessMessages.Success);
}
public IHttpActionResult PutProjectUser(int id, ProjectUser projectUser)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != projectUser.User_ID)
{
return(BadRequest());
}
db.Entry(projectUser).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!ProjectUserExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
private void button6_Click(object sender, EventArgs e)
{
// add group user
string strParmaInfo = "";
GlareLedServices2.GLSysMgrSoapClient cl = new GlareLedServices2.GLSysMgrSoapClient();
ProjectUser userMod = new ProjectUser()
{
Id = 0,
MgrProjectId = 1,
RefGroupId = 1,
RefOrgId = 1,
Name = "projectname",
Password = "******"
};
string strInfo = JsonStrObjConver.Obj2JsonStr(userMod, typeof(ProjectUser));
RequestModelString obj2 = new RequestModelString()
{
Info = strInfo,
reqDt = DateTime.Now,
TockId = ConstDefineTestWebapi.TockIdEnableTest
};
strParmaInfo = JsonStrObjConver.Obj2JsonStr(obj2, typeof(RequestModelString));
string strResult = cl.AddProjectUser(strParmaInfo);
MessageBox.Show(strResult);
}
public IHttpActionResult PostProjectUser(ProjectUser projectUser)
{
db.ProjectUsers.Add(projectUser);
db.SaveChanges();
return(CreatedAtRoute("DefaultApi", new { id = projectUser.User_ID }, projectUser));
}
public static object[] LoadProjectUsers()
{
StringBuilder sb = new StringBuilder();
Int16 devCount = 0;
//get total amount of developers assigned to project
List <MembershipUser> users = ProjectsDB.GetProjectUsers(ProjectsDB.GetProject(project_id));
List <ProjectUser> all_users = new List <ProjectUser>();
try
{
project this_project = ProjectsDB.GetProject(project_id);
devCount = (Int16)users.Count;
foreach (MembershipUser user in users)
{
ProjectUser new_user = new ProjectUser()
{
Username = user.UserName,
User_id = user.ProviderUserKey.ToString(),
Ticket_count = TicketsDB.GetUserProjectTicketCount(this_project, user),
Remove_button = String.Format("<input type='button' value='X' data-user='******' class='RemoveUserFromProject' onclick='RemoveUserFromProject(this);'/>", user.ProviderUserKey)
};
all_users.Add(new_user);
}
}
catch (Exception ex)
{
LogsDB.AddLog("Error building project developers table", LogsDB.GetLogType("error").id, project_id, ex);
}
return(new object[] { all_users, devCount });
}
private void SaveProjectUsers(Project model, string teamList)
{
var userList = teamList.Split(',');
var projUserList = new List <ProjectUser>();
foreach (var user in userList)
{
var projectUserModel = new ProjectUser()
{
UserName = user.Trim(),
ProjectId = model.Id
};
projUserList.Add(projectUserModel);
}
if (!projUserList.Exists(
u => String.Equals(u.UserName, User.Identity.Name, StringComparison.CurrentCultureIgnoreCase)))
{
var projectUserModel = new ProjectUser()
{
UserName = User.Identity.Name,
ProjectId = model.Id
};
projUserList.Add(projectUserModel);
}
db.ProjectUser.AddRange(projUserList);
db.SaveChanges();
}
private void Create()
{
string Id = Request["Id"];
Project pEnt = Project.Find(Id);
IList <ProjectUser> puEnts = ProjectUser.FindAllByProperty(ProjectUser.Prop_ProjectId, Id);
pEnt.Status = "已下达";
pEnt.DoUpdate();
foreach (ProjectUser puEnt in puEnts)
{
ExamineTask etEnt = new ExamineTask();
etEnt.ProjectId = Id;
etEnt.ProjectUserId = puEnt.Id;//str ProjectUser 的主键
etEnt.MajorName = puEnt.MajorName;
etEnt.PlanBackTime = Convert.ToDateTime(Request["BackTime"]);
etEnt.State = "未结束";
etEnt.CreateId = WebPortalService.CurrentUserInfo.UserID;
etEnt.CreateName = WebPortalService.CurrentUserInfo.UserID;
etEnt.CreateTime = DateTime.Now;
etEnt.DoCreate();
Expert eEnt = Expert.Find(puEnt.UserId);
//发送邮件
try
{
//string url = "http://192.168.15.81:7007/ConsultationManage/ExamineOpinionEdit.aspx?ExamineTaskId=" + etEnt.Id;
//PhoneMessage.SendWebMail("*****@*****.**", eEnt.Email, "审查任务", "项目名称:【" + pEnt.ProjectName + "】 专业：" + eEnt.MajorName + "，填写审查意见请点击此链接：" + url, "fpxt", "000000", "mail.nerin.com");
}
catch (Exception ex)
{
}
}
}
public async void TestGetProjectUsersByTeamLeaderId()
{
string userId = await CreateMockAndUserAsync();
ProjectAc projectac = new ProjectAc()
{
Name = _stringConstant.Name,
IsActive = _stringConstant.IsActive,
TeamLeader = new UserAc {
FirstName = _stringConstant.FirstName
},
TeamLeaderId = userId,
CreatedBy = _stringConstant.CreatedBy
};
var projectId = await _projectRepository.AddProjectAsync(projectac, _stringConstant.CreatedBy);
ProjectUser projectUser = new ProjectUser()
{
ProjectId = projectId,
UserId = userId,
CreatedBy = userId,
CreatedDateTime = DateTime.UtcNow,
};
await _projectRepository.AddUserProjectAsync(projectUser);
var projectUsers = await _userRepository.GetProjectUsersByTeamLeaderIdAsync(userId);
Assert.Equal(2, projectUsers.Count);
}
public async Task <IActionResult> PostProjectUser([FromBody] ProjectUser projectUser)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.ProjectUser.Add(projectUser);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (ProjectUserExists(projectUser.ProjectId))
{
return(new StatusCodeResult(StatusCodes.Status409Conflict));
}
else
{
throw;
}
}
return(CreatedAtAction("GetProjectUser", new { id = projectUser.ProjectId }, projectUser));
}
private void button4_Click(object sender, EventArgs e)
{
try
{
if (ListDataGridViewSource.Any(s => s.Type == "PM"))
{
foreach (var a in ListDataGridViewSource)
{
ProjectUser pt = new ProjectUser();
pt.ProjectId = AddNewProject.ProjectID;
pt.UserId = a.UserId;
pt.Type = a.Type == "PM" ? ProjectUserType.PM : ProjectUserType.Billable;
projectUsers.Add(pt);
}
this.Close();
}
else
{
MessageBox.Show("Dự án cần ít nhất 1 PM, vui lòng chỉnh sửa lại");
}
}
catch (Exception ex)
{
MessageBox.Show("Có lỗi");
}
}
public void Delete(string userId, int projectId)
{
ProjectUser projectUser = db.ProjectUsers.First(pu => pu.ApplicationUserId == userId && pu.ProjectId == projectId);
db.ProjectUsers.Remove(projectUser);
db.SaveChanges();
}
public async Task GetTeamMembersAsync()
{
string userId = await CreateMockAndUserAsync();
ProjectAc projectac = new ProjectAc()
{
Name = _stringConstant.Name,
SlackChannelName = _stringConstant.SlackChannelName,
IsActive = _stringConstant.IsActive,
TeamLeader = new UserAc {
FirstName = _stringConstant.FirstName
},
TeamLeaderId = userId,
CreatedBy = _stringConstant.CreatedBy
};
var projectId = await _projectRepository.AddProjectAsync(projectac, _stringConstant.CreatedBy);
ProjectUser projectUser = new ProjectUser()
{
ProjectId = projectId,
UserId = userId,
CreatedBy = userId,
CreatedDateTime = DateTime.UtcNow,
};
await _projectRepository.AddUserProjectAsync(projectUser);
var userRole = await _userRepository.GetTeamMembersAsync(userId);
Assert.Equal(2, userRole.Count());
}
public async Task <IActionResult> PutProjectUser([FromRoute] int id, [FromBody] ProjectUser projectUser)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != projectUser.Id)
{
return(BadRequest());
}
_context.Entry(projectUser).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProjectUserExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(Ok(projectUser));
}
public async Task GetProjectUserBySlackChannelNameAsync()
{
string userId = await CreateMockAndUserAsync();
ProjectAc projectac = new ProjectAc();
projectac.Name = _stringConstant.Name;
projectac.SlackChannelName = _stringConstant.SlackChannelName;
projectac.IsActive = _stringConstant.IsActive;
projectac.TeamLeader = new UserAc {
FirstName = _stringConstant.FirstName
};
projectac.TeamLeaderId = _stringConstant.TeamLeaderId;
projectac.CreatedBy = _stringConstant.CreatedBy;
int projectId = await _projectRepository.AddProjectAsync(projectac, _stringConstant.CreatedBy);
ProjectUser projectUser = new ProjectUser()
{
ProjectId = projectId,
UserId = userId,
CreatedBy = userId,
CreatedDateTime = DateTime.UtcNow,
};
await _projectRepository.AddUserProjectAsync(projectUser);
var projectUsers = await _userRepository.GetProjectUserBySlackChannelNameAsync(projectac.SlackChannelName);
Assert.Equal(projectUsers.Count, 1);
}
public async Task ChangeUserRoleAsync(string senderUserId, int projectId, string userId, AppUserRoleDto newRoleDto)
{
AppUserRole senderRole = await GetRoleIfMember(senderUserId, projectId);
if (!senderRole.HasPermissionsToChangeRoleOfMember())
{
throw new ForbiddenResponseException("You haven't permissions to change roles of members in this project");
}
AppUserRole currRole = await _puRepo.GetRoleOfMember(userId, projectId);
AppUserRole newRole = _mapper.Map <AppUserRoleDto, AppUserRole>(newRoleDto);
if (!senderRole.CanChangeRoleOfMember(currRole, newRole))
{
throw new ForbiddenResponseException($"You cannot change role from {currRole.Name} to {newRole.Name}.");
}
if (newRole.IsScrumMaster() && await _puRepo.DoesExistScrumMasterInProjectAsync(projectId))
{
throw new ForbiddenResponseException("Only one Scrum Master can be on project");
}
ProjectUser pu = new ProjectUser()
{
ProjectId = projectId,
UserId = userId,
UserRoleId = newRole.Id
};
await _puRepo.UpdateRecordAsync(pu);
}
public override void AddUserToProject(out int id, string username, string projectRole, Project project)
{
var user = SEOMembershipManager.GetUser(username);
var projectRoleObj = GetProjectRoleByName(projectRole);
if (projectRoleObj == null) throw new ProjectRoleNameMustExistException("the project role must exist " + projectRole);
if (projectRoleObj.IdRoleType != (Int32)RoleType.ProjectRole) throw new ProjectRoleNameMustExistException("the project role must exist " + projectRole);
using (var tran = new TransactionScope(_connName))
{
var projectUser = new ProjectUser
{
Project = project,
ProjectRole = projectRoleObj,
SEOToolsetUser = user,
Enabled = true,
MonitorEmails = false
};
var ds = DSProjectUser.Create(_connName);
ds.Insert(projectUser);
tran.Commit();
id = projectUser.Id;
}
}
