public ProjectMembershipViewModel(
IBackgroundExecutor executor,
IProjectsService projectsService,
IAuthorizationService authorizatorService,
ProjectMembership membership,
MemberProfile member)
{
Init(executor, projectsService, authorizatorService, membership, member);
}
public async Task Should_Add_Project_Membership()
{
ProjectMembership pm = new ProjectMembership();
pm.User = new IdentifiableName { Id = newPMUserId };
pm.Roles = new List<MembershipRole>();
pm.Roles.Add(new MembershipRole { Id = newPMRoleId });
ProjectMembership updatedPM = await redmineManager.CreateObjectAsync<ProjectMembership>(pm, projectId);
Assert.IsNotNull(updatedPM);
}
public void RedmineProjectMembership_ShouldAdd()
{
ProjectMembership pm = new ProjectMembership();
pm.User = new IdentifiableName { Id = newPMUserId };
pm.Roles = new List<MembershipRole>();
pm.Roles.Add(new MembershipRole { Id = newPMRoleId });
ProjectMembership updatedPM = redmineManager.CreateObject<ProjectMembership>(pm, projectId);
Assert.IsNotNull(updatedPM);
}
// this method can only change project memberships
// other changes to the user object will be overwitten
public async Task <User> AddProjectMembershipAsync(User user, ProjectMembership membership)
{
if (user is null)
{
throw new ArgumentNullException(nameof(user));
}
if (membership is null)
{
throw new ArgumentNullException(nameof(membership));
}
var container = await GetContainerAsync()
.ConfigureAwait(false);
if (string.IsNullOrEmpty(((IContainerDocument)user).ETag))
{
var existingUser = await GetAsync(user.Id).ConfigureAwait(false)
?? await AddAsync(user).ConfigureAwait(false);
user = existingUser;
}
return(await AddProjectMembershipSafeAsync(container, user, membership)
.ConfigureAwait(false));
async Task <User> AddProjectMembershipSafeAsync(Container container, User user, ProjectMembership membership)
{
while (true)
{
try
{
user.EnsureProjectMembership(membership);
return(await container.ReplaceItemAsync(
user,
user.Id,
new PartitionKey(Options.TenantName),
new ItemRequestOptions { IfMatchEtag = ((IContainerDocument)user).ETag }).ConfigureAwait(false));
}
catch (CosmosException exc) when(exc.StatusCode == HttpStatusCode.NotFound)
{
// the requested user does not exist anymore - continue
return(null);
}
catch (CosmosException exc) when(exc.StatusCode == HttpStatusCode.PreconditionFailed)
{
// the requested user has changed, get it again before proceeding
user = await GetAsync(user.Id).ConfigureAwait(false);
}
}
}
}
public static bool HasEqualMembership(this User user, ProjectMembership membership)
{
if (user is null)
{
throw new ArgumentNullException(nameof(user));
}
if (membership is null)
{
throw new ArgumentNullException(nameof(membership));
}
return(new ProjectMembershipComparer().Equals(user.ProjectMembership(membership.ProjectId), membership));
}
public void Should_Add_Project_Membership()
{
ProjectMembership pm = new ProjectMembership();
pm.User = new IdentifiableName { Id = NEW_PROJECT_MEMBERSHIP_USER_ID };
pm.Roles = new List<MembershipRole>();
pm.Roles.Add(new MembershipRole { Id = NEW_PROJECT_MEMBERSHIP_ROLE_ID });
ProjectMembership createdPM = redmineManager.CreateObject<ProjectMembership>(pm, PROJECT_IDENTIFIER);
Assert.IsNotNull(createdPM, "Project membership is null.");
Assert.AreEqual(createdPM.User.Id, NEW_PROJECT_MEMBERSHIP_USER_ID, "User is invalid.");
Assert.IsNotNull(createdPM.Roles, "Project membership roles list is null.");
Assert.IsTrue(createdPM.Roles.Exists(r => r.Id == NEW_PROJECT_MEMBERSHIP_ROLE_ID), string.Format("Role id {0} does not exist.", NEW_PROJECT_MEMBERSHIP_ROLE_ID));
}
public void Should_Add_Project_Membership()
{
ProjectMembership pm = new ProjectMembership();
pm.User = new IdentifiableName { Id = USER_ID };
pm.Roles = new List<MembershipRole>();
pm.Roles.Add(new MembershipRole { Id = ROLE_ID });
var updatedPM = redmineManager.CreateObjectAsync<ProjectMembership>(pm, PROJECT_ID);
var delay = Delay(3000);
int index = Task.WaitAny(updatedPM, delay);
if (index == 0)
Assert.IsNotNull(updatedPM.Result, "Project membership is null.");
else
Assert.Fail("Operation timeout.");
}
public override object Deserialize(IDictionary <string, object> dictionary, Type type, JavaScriptSerializer serializer)
{
if (dictionary != null)
{
var projectMembership = new ProjectMembership();
projectMembership.Id = dictionary.GetValue <int>("id");
projectMembership.Group = dictionary.GetValueAsIdentifiableName("group");
projectMembership.Project = dictionary.GetValueAsIdentifiableName("project");
projectMembership.Roles = dictionary.GetValueAsCollection <MembershipRole>("roles");
projectMembership.User = dictionary.GetValueAsIdentifiableName("user");
return(projectMembership);
}
return(null);
}
public async Task Should_Add_Project_Membership()
{
ProjectMembership pm = new ProjectMembership();
pm.User = new IdentifiableName {
Id = newPMUserId
};
pm.Roles = new List <MembershipRole>();
pm.Roles.Add(new MembershipRole {
Id = newPMRoleId
});
ProjectMembership updatedPM = await redmineManager.CreateObjectAsync <ProjectMembership>(pm, projectId);
Assert.IsNotNull(updatedPM);
}
public override object Deserialize(IDictionary<string, object> dictionary, Type type, JavaScriptSerializer serializer)
{
if (dictionary != null)
{
var projectMembership = new ProjectMembership();
projectMembership.Id = dictionary.GetValue<int>(RedmineKeys.ID);
projectMembership.Group = dictionary.GetValueAsIdentifiableName(RedmineKeys.GROUP);
projectMembership.Project = dictionary.GetValueAsIdentifiableName(RedmineKeys.PROJECT);
projectMembership.Roles = dictionary.GetValueAsCollection<MembershipRole>(RedmineKeys.ROLES);
projectMembership.User = dictionary.GetValueAsIdentifiableName(RedmineKeys.USER);
return projectMembership;
}
return null;
}
public void RedmineProjectMembership_ShouldAdd()
{
ProjectMembership pm = new ProjectMembership();
pm.User = new IdentifiableName {
Id = 17
};
pm.Roles = new List <MembershipRole>();
pm.Roles.Add(new MembershipRole {
Id = 4
});
ProjectMembership updatedPM = redmineManager.CreateObject <ProjectMembership>(pm, "9");
Assert.IsNotNull(updatedPM);
}
public override object Deserialize(IDictionary<string, object> dictionary, Type type, JavaScriptSerializer serializer)
{
if (dictionary != null)
{
var projectMembership = new ProjectMembership();
projectMembership.Id = dictionary.GetValue<int>("id");
projectMembership.Group = dictionary.GetValueAsIdentifiableName("group");
projectMembership.Project = dictionary.GetValueAsIdentifiableName("project");
projectMembership.Roles = dictionary.GetValueAsCollection<MembershipRole>("roles");
projectMembership.User = dictionary.GetValueAsIdentifiableName("user");
return projectMembership;
}
return null;
}
public override object Deserialize(IDictionary <string, object> dictionary, Type type, JavaScriptSerializer serializer)
{
if (dictionary != null)
{
var projectMembership = new ProjectMembership();
projectMembership.Id = dictionary.GetValue <int>(RedmineKeys.ID);
projectMembership.Group = dictionary.GetValueAsIdentifiableName(RedmineKeys.GROUP);
projectMembership.Project = dictionary.GetValueAsIdentifiableName(RedmineKeys.PROJECT);
projectMembership.Roles = dictionary.GetValueAsCollection <MembershipRole>(RedmineKeys.ROLES);
projectMembership.User = dictionary.GetValueAsIdentifiableName(RedmineKeys.USER);
return(projectMembership);
}
return(null);
}
public static User UpdateProjectMembership(this User user, ProjectMembership membership)
{
if (user is null)
{
throw new ArgumentNullException(nameof(user));
}
if (membership is null)
{
throw new ArgumentNullException(nameof(membership));
}
var existingMembership = user.ProjectMemberships.FirstOrDefault(m => m.ProjectId == membership.ProjectId);
existingMembership.Role = membership.Role;
existingMembership.Properties = membership.Properties ?? new Dictionary <string, string>();
return(user);
}
public void Should_Add_Project_Membership()
{
ProjectMembership pm = new ProjectMembership();
pm.User = new IdentifiableName {
Id = NEW_PROJECT_MEMBERSHIP_USER_ID
};
pm.Roles = new List <MembershipRole>();
pm.Roles.Add(new MembershipRole {
Id = NEW_PROJECT_MEMBERSHIP_ROLE_ID
});
ProjectMembership createdPM = redmineManager.CreateObject <ProjectMembership>(pm, PROJECT_IDENTIFIER);
Assert.IsNotNull(createdPM, "Project membership is null.");
Assert.AreEqual(createdPM.User.Id, NEW_PROJECT_MEMBERSHIP_USER_ID, "User is invalid.");
Assert.IsNotNull(createdPM.Roles, "Project membership roles list is null.");
Assert.IsTrue(createdPM.Roles.Exists(r => r.Id == NEW_PROJECT_MEMBERSHIP_ROLE_ID), string.Format("Role id {0} does not exist.", NEW_PROJECT_MEMBERSHIP_ROLE_ID));
}
public void Should_Add_Project_Membership()
{
const int NEW_PROJECT_MEMBERSHIP_USER_ID = 2;
const int NEW_PROJECT_MEMBERSHIP_ROLE_ID = 5;
var pm = new ProjectMembership
{
User = new IdentifiableName {Id = NEW_PROJECT_MEMBERSHIP_USER_ID},
Roles = new List<MembershipRole> {new MembershipRole {Id = NEW_PROJECT_MEMBERSHIP_ROLE_ID}}
};
var createdPm = fixture.RedmineManager.CreateObject(pm, PROJECT_IDENTIFIER);
Assert.NotNull(createdPm);
Assert.True(createdPm.User.Id == NEW_PROJECT_MEMBERSHIP_USER_ID, "User is invalid.");
Assert.NotNull(createdPm.Roles);
Assert.True(createdPm.Roles.Exists(r => r.Id == NEW_PROJECT_MEMBERSHIP_ROLE_ID),
string.Format("Role id {0} does not exist.", NEW_PROJECT_MEMBERSHIP_ROLE_ID));
}
public void Should_Add_Project_Membership()
{
const int NEW_PROJECT_MEMBERSHIP_USER_ID = 2;
const int NEW_PROJECT_MEMBERSHIP_ROLE_ID = 5;
var pm = new ProjectMembership
{
User = IdentifiableName.Create <IdentifiableName>(NEW_PROJECT_MEMBERSHIP_USER_ID),
Roles = new List <MembershipRole> {
(MembershipRole)IdentifiableName.Create <MembershipRole>(NEW_PROJECT_MEMBERSHIP_ROLE_ID)
}
};
var createdPm = fixture.RedmineManager.CreateObject(pm, PROJECT_IDENTIFIER);
Assert.NotNull(createdPm);
Assert.True(createdPm.User.Id == NEW_PROJECT_MEMBERSHIP_USER_ID, "User is invalid.");
Assert.NotNull(createdPm.Roles);
//Assert.True(createdPm.Roles.Exists(r => r.Id == NEW_PROJECT_MEMBERSHIP_ROLE_ID),
// string.Format("Role id {0} does not exist.", NEW_PROJECT_MEMBERSHIP_ROLE_ID));
}
public void RemoveProjectMembership(string projectUId, string memberUId, string roleUId)
{
authorizationService.VerifyUserOrPermissionAtProject(memberUId, projectUId, PermissionSets.SCRUM_MASTER);
Project project = GetProject(projectUId);
if (project == null)
{
throw new WebFaultException <string>("Project not found", System.Net.HttpStatusCode.NotFound);
}
ProjectMembership membership = project.Memberships.Where(ms => ms.MemberUId == memberUId && ms.RoleUId == roleUId).SingleOrDefault();
if (membership == null)
{
throw new WebFaultException <string>("Project membership not found", System.Net.HttpStatusCode.NotFound);
}
// if is a SCRUM MASTER membership, checks if is not the only one
if (membership.Role.PermissionSet == (short)PermissionSets.SCRUM_MASTER &&
projectsRepository.GetMembershipCountOf(membership.ProjectUId, PermissionSets.SCRUM_MASTER) == 1)
{
throw new WebFaultException <string>("BRE_CAN_NOT_REMOVE_LAST_SCRUM_MASTER", System.Net.HttpStatusCode.BadRequest);
}
// if the member has tasks already, inactive it only
if (tasksService.DoesMemberHasAnyTaskAtProject(membership.ProjectUId, memberUId))
{
membership.IsActive = false;
membership.InactiveSince = DateTime.Now;
}
// otherwise, delete it
else
{
project.Memberships.Remove(membership);
}
projectsRepository.UpdateProject(project);
}
private void SetRoleAccordingAssignee(Task task, Project project, bool replanItem)
{
if (task.TaskAssigneeUId == null)
{
return;
}
ProjectMembership membership = project.Memberships.Where(ms => ms.MemberUId == task.TaskAssigneeUId && ms.IsActive == true).FirstOrDefault();
if (membership == null)
{
return;
}
string oldRoleUId = task.RoleUId;
task.RoleUId = membership.RoleUId;
if (replanItem)
{
ReplanBacklogItem(task, oldRoleUId, task.PlannedHours);
}
}
public void Should_Delete_Project_Membership()
{
try
{
redmineManager.DeleteObject <ProjectMembership>(DELETED_PROJECT_MEMBERSHIP_ID, null);
}
catch (RedmineException)
{
Assert.Fail("Project membership could not be deleted.");
return;
}
try
{
ProjectMembership projectMembership = redmineManager.GetObject <ProjectMembership>(DELETED_PROJECT_MEMBERSHIP_ID, null);
}
catch (RedmineException exc)
{
StringAssert.Contains(exc.Message, "Not Found");
return;
}
Assert.Fail("Test failed");
}
public void RedmineProjectMembership_ShouldDelete()
{
try
{
redmineManager.DeleteObject <ProjectMembership>(deletedPMId, null);
}
catch (RedmineException)
{
Assert.Fail("Project membership could not be deleted.");
return;
}
try
{
ProjectMembership projectMembership = redmineManager.GetObject <ProjectMembership>(deletedPMId, null);
}
catch (RedmineException exc)
{
StringAssert.Contains(exc.Message, "Not Found");
return;
}
Assert.Fail("Test failed");
}
private void SendInviteMemberEmail(ProjectMembership membership, string serverUrl)
{
try {
Project project = GetProject_skipAuth(membership.ProjectUId);
// get members and attach to the project
mailer.AttachProjectMembers(project);
MemberProfile member = project.Memberships.FirstOrDefault(ms => ms.MemberUId == membership.MemberUId).Member;
if (member.IsContactMember)
{
return;
}
// create body from the template
ReportHelper.Report reports = new ReportHelper.Report();
ReportHelper.ReportConfig reportConfig = new ReportHelper.ReportConfig("EmailNotifications", "member_invited", "");
reportConfig.ReportObjects.Add(project);
reportConfig.ReportVars.Add("RoleName", membership.Role.RoleName);
string body = reports.CreateReportXAML(serverUrl, reportConfig, true);
// subject
string subject = "Join project invitation";
// send it to all project members
bool send = mailer.SendEmail(member.EmailAccount, subject, body);
if (!send)
{
ScrumFactory.Services.Logic.Helper.Log.LogMessage("Invite project email was not send.");
}
}
catch (System.Exception ex) {
ScrumFactory.Services.Logic.Helper.Log.LogError(ex);
}
}
public static ProjectMember MembershipToMember(ProjectMembership projectMember)
{
return new ProjectMember(projectMember);
}
public ProjectMember(ProjectMembership projectMember)
{
this.member = projectMember;
}
public ProjectMember(User user)
{
this.member = new ProjectMembership { User = new IdentifiableName { Id = user.Id, Name = user.CompleteName() } };
}
public ProjectMember(ProjectMembership projectMember)
{
this.member = projectMember;
}
private void Refuse(ProjectMembership membership)
{
executor.StartBackgroundTask(
() => { projectServices.RemoveProjectMembership(membership.ProjectUId, membership.MemberUId, membership.RoleUId); },
() => { RemoveProject(membership); }
);
}
public ProjectMember()
{
this.member = new ProjectMembership { User = new IdentifiableName { Id = 0, Name = "" } };
}
private void ChangeUserEngage(ProjectMembership membership)
{
// can only change my engage
if (autorizator.SignedMemberProfile == null || autorizator.SignedMemberProfile.MemberUId != membership.MemberUId)
return;
executor.StartBackgroundTask(
() => { projectsService.UpdateProjectMembershipAllocation(membership.ProjectUId, membership.MemberUId, membership.RoleUId, (int)membership.DayAllocation); },
() => { });
}
public AssigneeViewModel(ProjectMembership membership)
{
Membership = membership;
Member = membership.Member;
}
private void RemoveUserEngage(ProjectMembership membership)
{
// can only change my engage
if (autorizator.SignedMemberProfile == null || autorizator.SignedMemberProfile.MemberUId != membership.MemberUId)
return;
executor.StartBackgroundTask<ProjectMembership>(
() => {
projectsService.RemoveProjectMembership(membership.ProjectUId, membership.MemberUId, membership.RoleUId);
// if the user already has tasks he will be not removed, just flaged as inative
// so need to get the project again to know whenever it was removed or flagged
// THE GOOD WAY SHOULD BE the REST return it, but dont want to change Services interface at this point
Project p = projectsService.GetProject(Project.ProjectUId);
var removed = p.Memberships.Where(m => m.MemberUId == membership.MemberUId && m.RoleUId == membership.RoleUId).SingleOrDefault();
if (removed != null)
membership.IsActive = removed.IsActive;
return membership;
},
removedMembership => {
UserEngages.Remove(membership);
aggregator.Publish<ProjectMembership>(ScrumFactoryEvent.ProjectMembershipRemoved, removedMembership);
});
}
public void SaveProjectMembership(ProjectMembership membership)
{
using (var context = new ScrumFactoryEntities(this.connectionString)) {
ProjectMembership existMembership = context.ProjectMemberships.SingleOrDefault(m => m.MemberUId == membership.MemberUId && m.ProjectUId == membership.ProjectUId && m.RoleUId == membership.RoleUId);
if (existMembership == null) {
context.ProjectMemberships.AddObject(membership);
} else {
context.AttachTo("ProjectMemberships", existMembership);
context.ApplyCurrentValues<ProjectMembership>("ProjectMemberships", membership);
}
context.SaveChanges();
}
}
private void AfterRemoveMember(ProjectMembership membership)
{
// finds membership vm
Collection<ProjectMembershipViewModel> memberships = membershipViewSource.Source as Collection<ProjectMembershipViewModel>;
ProjectMembershipViewModel membershipVM = memberships.FirstOrDefault(ms => ms.ProjectMembership.MemberUId == membership.MemberUId && ms.ProjectMembership.RoleUId == membership.RoleUId && ms.ProjectMembership.ProjectUId == membership.ProjectUId);
if (membershipVM == null)
return;
// if membership still there and just turned inactive, just refreshs the view
if (membership.IsActive==false) {
membershipVM.ProjectMembership.IsActive = membership.IsActive;
membershipViewSource.View.Refresh();
PublishMemberChanged();
return;
}
// refresh the view
// and removes from the collection (i dont now why we need to do this one, the statment above should have done that)
((IEditableCollectionView)membershipViewSource.View).Remove(membershipVM);
memberships.Remove(membershipVM);
// removes from project
Project.Memberships.Remove(membershipVM.ProjectMembership);
// dispose
membershipVM.Dispose();
PublishMemberChanged();
}
private void AddProjectMembership(MemberProfile member, Role role, int? allocation)
{
ProjectMembership ms = new ProjectMembership() {
MemberUId = member.MemberUId,
Member = member,
IsActive = true,
RoleUId = role.RoleUId,
Role = role,
DayAllocation = allocation,
ProjectUId = Project.ProjectUId
};
executor.StartBackgroundTask(
() => {
projectsServices.AddProjectMembership(ms.ProjectUId, ms);
},
() => {
Collection<ProjectMembershipViewModel> memberships = membershipViewSource.Source as Collection<ProjectMembershipViewModel>;
ProjectMembershipViewModel msVM = memberships.FirstOrDefault(m => m.ProjectMembership.MemberUId == ms.MemberUId && m.ProjectMembership.RoleUId == ms.RoleUId);
if (msVM == null) {
msVM = (ProjectMembershipViewModel)((IEditableCollectionView)membershipViewSource.View).AddNew();
msVM.Init(executor, projectsServices, authorizator, ms, ms.Member);
((IEditableCollectionView)membershipViewSource.View).CommitNew();
memberships.Add(msVM);
Project.Memberships.Add(ms);
}
else {
msVM.ProjectMembership.IsActive = true;
((IEditableCollectionView)membershipViewSource.View).EditItem(msVM);
((IEditableCollectionView)membershipViewSource.View).CommitEdit();
}
msVM.NotifyAdded();
NewMember = null;
((DelegateCommand)ShowJoinDialogCommand).NotifyCanExecuteChanged();
PublishMemberChanged();
});
}
private void RemoveProject(ProjectMembership membership)
{
Project pendingProject = PendingProjects.SingleOrDefault(p => p.Memberships.Any(ms => ms.RoleUId == membership.RoleUId && ms.ProjectUId == membership.ProjectUId));
if(pendingProject==null)
return;
PendingProjects.Remove(pendingProject);
if (PendingProjects.Count == 0)
IsVisible = false;
}
private void Engage(ProjectMembership membership)
{
if (!membership.DayAllocation.HasValue)
membership.DayAllocation = 0;
executor.StartBackgroundTask(
() => { projectServices.UpdateProjectMembershipAllocation(membership.ProjectUId, membership.MemberUId, membership.RoleUId, (int)membership.DayAllocation); },
() => { RemoveProject(membership); }
);
}
private void SendInviteMemberEmail(ProjectMembership membership, string serverUrl)
{
try {
Project project = GetProject_skipAuth(membership.ProjectUId);
// get members and attach to the project
mailer.AttachProjectMembers(project);
MemberProfile member = project.Memberships.FirstOrDefault(ms => ms.MemberUId == membership.MemberUId).Member;
if (member.IsContactMember)
return;
// create body from the template
ReportHelper.Report reports = new ReportHelper.Report();
ReportHelper.ReportConfig reportConfig = new ReportHelper.ReportConfig("EmailNotifications", "member_invited", "");
reportConfig.ReportObjects.Add(project);
reportConfig.ReportVars.Add("RoleName", membership.Role.RoleName);
string body = reports.CreateReportXAML(serverUrl, reportConfig);
// subject
string subject = "Join project invitation";
// send it to all project members
bool send = mailer.SendEmail(member.EmailAccount, subject, body);
if (!send)
ScrumFactory.Services.Logic.Helper.Log.LogMessage("Invite project email was not send.");
}
catch (System.Exception ex) {
ScrumFactory.Services.Logic.Helper.Log.LogError(ex);
}
}
public void AddProjectMembership(string projectUId, ProjectMembership membership)
{
authorizationService.VerifyRequestAuthorizationToken();
// gets the role
Role role = projectsRepository.GetProjectRole(membership.RoleUId);
bool isNotTeamRole = role.PermissionSet != (short)PermissionSets.TEAM;
bool isScrumMaster = MemberHasPermissionAtProject(authorizationService.SignedMemberProfile.MemberUId, projectUId, new PermissionSets[] { PermissionSets.SCRUM_MASTER });
bool isFactoryOwner = authorizationService.SignedMemberProfile.IsFactoryOwner;
// If not a team role, you need to be SM or FACTORY OWNER
if(isNotTeamRole && !isScrumMaster && !isFactoryOwner)
throw new WebFaultException(System.Net.HttpStatusCode.Forbidden);
// if is a Team role any one can join
SetMemberWorkload(membership.MemberUId, membership.ProjectUId, membership.RoleUId, membership.DayAllocation);
// if its myself, dont need to send an email
if (membership.MemberUId == authorizationService.SignedMemberProfile.MemberUId)
return;
// send email at other thread, so all the database query stuff does not lock this return
//string serverUrl = Helper.ReportTemplate.ServerUrl;
//System.Threading.ThreadStart sendMail = delegate { SendInviteMemberEmail(membership, serverUrl); };
//new System.Threading.Thread(sendMail).Start();
SendInviteMemberEmail(membership, Helper.ReportTemplate.ServerUrl);
}
public static ProjectMember MembershipToMember(ProjectMembership projectMember)
{
return(new ProjectMember(projectMember));
}
public int CreateProject(Project project, bool useLastProjectAsModel)
{
authorizationService.VerifyRequestAuthorizationToken();
// creates the project
project.CreateDate = System.DateTime.Now;
project.CreateBy = authorizationService.SignedMemberProfile.MemberUId;
project.Status = (short)ProjectStatus.PROPOSAL_CREATION;
string formatedProjectName = FormatFolderString(project.ProjectName);
string formatedClientName = FormatFolderString(project.ClientName);
try {
if (!String.IsNullOrEmpty(DocRepPath) && String.IsNullOrEmpty(project.DocRepositoryPath))
project.DocRepositoryPath = String.Format(DocRepPath, formatedClientName, formatedProjectName);
}
catch (Exception) { }
// if using other project as model, copy roles from that
if (useLastProjectAsModel) {
Project similarProject = projectsRepository.GetLastSimilarProject(project);
CopyProjectRoles(project, similarProject);
}
// checks if the project has at least one SM role
Role SMRole = project.Roles.Where(r => r.PermissionSet == (short)PermissionSets.SCRUM_MASTER).FirstOrDefault();
if (SMRole == null)
throw new WebFaultException<String>("BRE_NEW_PROJECT_WITHOUT_SM_ROLE", System.Net.HttpStatusCode.BadRequest);
// adds me as owner
ProjectMembership ownerMember = new ProjectMembership();
ownerMember.MemberUId = authorizationService.SignedMemberProfile.MemberUId;
ownerMember.ProjectUId = project.ProjectUId;
ownerMember.RoleUId = SMRole.RoleUId;
ownerMember.DayAllocation = 0;
ownerMember.IsActive = true;
project.Memberships = new List<ProjectMembership>();
project.Memberships.Add(ownerMember);
// saves it
int projectNumber = projectsRepository.InsertProject(project);
// creates project folder
CreateProjectFolder(project);
// run create project hook
RunCreateHook(project);
return projectNumber;
}
private void SetMemberWorkload(string memberUId, string projectUId, string roleUId, int? newAllocation)
{
Project project = GetProject(projectUId);
if (project ==null)
throw new WebFaultException<string>("Project not found", System.Net.HttpStatusCode.NotFound);
int? deltaAllocation = 0;
ProjectMembership membership = project.Memberships.Where(ms => ms.MemberUId == memberUId && ms.RoleUId == roleUId).SingleOrDefault();
if (membership == null) {
membership = new ProjectMembership() { ProjectUId = projectUId, MemberUId = SafeMemberUId(memberUId), RoleUId = roleUId };
if (project.Memberships == null)
project.Memberships = new List<ProjectMembership>();
project.Memberships.Add(membership);
// if is new membership, then the delta is the new allocation
deltaAllocation = newAllocation;
}
else {
// if is a update at a membership, then the delta is the difference (new one - old one)
if (!membership.DayAllocation.HasValue)
deltaAllocation = newAllocation;
else
deltaAllocation = newAllocation - membership.DayAllocation;
}
if (!membership.IsActive)
membership.IsActive = true;
int actualAllocation = projectsRepository.GetMemberDayAllocation(memberUId);
if (actualAllocation + deltaAllocation > 4)
throw new WebFaultException<String>("BRE_INVALID_MEMBER_WORKLOAD", System.Net.HttpStatusCode.BadRequest);
membership.DayAllocation = newAllocation;
projectsRepository.UpdateProject(project);
}
public void AddProjectMembership(string projectUId, ProjectMembership membership)
{
var client = ClientHelper.GetClient(authorizator);
HttpResponseMessage response = client.Post(Url("Projects/" + projectUId + "/Memberships"), new ObjectContent<ProjectMembership>(membership, JsonValueMediaTypeFormatter.DefaultMediaType));
ClientHelper.HandleHTTPErrorCode(response);
}
public void Init(
IBackgroundExecutor executor,
IProjectsService projectsService,
IAuthorizationService authorizatorService,
ProjectMembership membership,
MemberProfile member)
{
this.executor = executor;
this.projectsService = projectsService;
this.authorizator = authorizatorService;
ProjectMembership = membership;
Member = member;
ChangeDayAllocationCommand = new DelegateCommand(ChangeDayAllocation);
SendEmailCommand = new DelegateCommand(SendEmail);
}
