/// <summary>
/// saves issue to DA-layer
/// preperations are don here
/// </summary>
/// <param name="issueModel"></param>
/// <param name="userId">user who is performing operation (owner)</param>
/// <param name="selfAssessmentValue">self assessment value of issue creator</param>
/// <param name="selfAssessmentDescr">self assessment description of isssue creator</param>
/// <returns></returns>
public int SaveIssue(IssueModel issueModel, int userId, double selfAssessmentValue, string selfAssessmentDescr)
{
Issue issue = issueModel.ToEntity();
int issueId = -1;
if (issue.Parent == -1)
{
issue.Parent = null;
}
if (issue.DependsOn == -1)
{
issue.DependsOn = null;
}
if (issue.Id > 0)
{
issueId = IssueOp.UpdateIssue(issue, userId);
if (issueModel.Status == "CREATING" || issueModel.Status == "BRAINSTORMING1")
{
AccessRightOp.UpdateSelfAssesment(selfAssessmentValue, selfAssessmentDescr, issueModel.Id, userId);
}
return(issueId);
}
else
{
issueId = IssueOp.InsertIssue(issue, userId, selfAssessmentValue, selfAssessmentDescr);
return(issueId);
}
}
/// <summary>
/// returns accessright for user to an issue
/// </summary>
/// <param name="userId"></param>
/// <param name="issueId"></param>
/// <returns></returns>
public AccessRightModel AccessRightOfUserForIssue(int userId, int issueId)
{
AccessRightModel arm = new AccessRightModel();
AccessRightModel ar = arm.ToModel(AccessRightOp.AccessRightOfUserForIssue(userId, issueId));
return(ar);
}
/// <summary>
/// gets access right for iser of issue
/// </summary>
/// <param name="issueId">issue id</param>
/// <param name="userId">user id</param>
/// <returns>AccessRightModel</returns>
public AccessRightModel GetAccessRight(int issueId, int userId)
{
AccessRightModel arm = new AccessRightModel();
arm = arm.ToModel(AccessRightOp.GetAccessRight(issueId, userId));
arm.SelfAssessmentHistory = GetSelfAssessmentHistoryForAr(userId, issueId);
return(arm);
}
/// <summary>
/// returns self assessment changes for issue
/// </summary>
/// <param name="userId">user who is performing operation</param>
/// <param name="issueId">issue id</param>
/// <returns>list of self assessment history entries</returns>
private List <SelfAssessmentHEntry> GetSelfAssessmentHistoryForAr(int userId, int issueId)
{
List <SelfAssessmentHEntry> list = new List <SelfAssessmentHEntry>();
foreach (HAccessRight har in AccessRightOp.GetAccessRightsHistorical(userId, issueId))
{
list.Add(new SelfAssessmentHEntry(har.ChangeDate, Convert.ToDouble(har.SelfAssessmentValue), har.SelfAssesmentDescr));
}
return(list);
}
/// <summary>
/// updates accessrights which user modified
/// </summary>
/// <param name="addedAr">new granted permissions</param>
/// <param name="deletedAr">removed permissions</param>
/// <param name="updatedAr">updated permissions</param>
/// <param name="issueId">Issue for permissions</param>
/// <param name="userId">user who is making changes</param>
public void UpdateAccessRights(List <AccessRightModel> addedAr, List <AccessRightModel> deletedAr, List <AccessRightModel> updatedAr, int issueId, int userId)
{
AccessRightModel arm = new AccessRightModel();
List <AccessRight> dList = arm.ToEntityList(deletedAr);
List <AccessRight> aList = arm.ToEntityList(addedAr);
List <AccessRight> uList = null;
if (updatedAr != null)
{
uList = arm.ToEntityList(updatedAr).Except(dList).Except(aList).ToList();
}
AccessRightOp.UpdateRights(aList, dList, uList, issueId, userId);
}
/// <summary>
/// returns list of access right by IssueId
/// </summary>
/// <param name="issueId"></param>
/// <returns>Accessright with UserId and full Username</returns>
public List <AccessRightModel> GetAccessRightsOfIssue(int issueId)
{
List <AccessRightModel> list = new List <AccessRightModel>();
List <AccessRight> arEntityList = AccessRightOp.GetAccessRightsForIssue(issueId);
string right;
string name;
AccessRightModel arm;
foreach (AccessRight ar in arEntityList)
{
right = ar.Right;
switch (right)
{
case "O":
right = "Owner";
break;
case "C":
right = "Contributor";
break;
case "V":
right = "Viewer";
break;
}
arm = new AccessRightModel();
arm = arm.ToModel(ar);
arm.Right = right;
arm.SelfAssessmentHistory = GetSelfAssessmentHistoryForAr(ar.UserId, issueId);
if (userList == null)
{
list.Add(arm);
}
else
{
arm.Name = userList.Find(x => x.Id == arm.UserId).FirstName + " " + userList.Find(x => x.Id == arm.UserId).LastName;
list.Add(arm);
}
}
return(list);
}
/// <summary>
/// removes an accessright from issue
/// </summary>
/// <param name="accessRight"></param>
/// <param name="userId"></param>
/// <returns></returns>
public bool RemoveAccessRight(AccessRightModel accessRight, int userId)
{
AccessRightModel arm = new AccessRightModel();
return(AccessRightOp.RemoveAccessRight(arm.ToEntity(accessRight), userId));
}
/// <summary>
/// converts inssue model to user issue model
/// </summary>
/// <param name="im">issue model</param>
/// <param name="userId">user who is performing operation</param>
/// <returns>user issue model</returns>
private UserIssueModel GetUserIssueModelFromIssueModel(IssueModel im, int userId)
{
UserIssueModel uim = new UserIssueModel();
int unreadCnt;
List <KeyValuePair <string, int> > unreadInfos;
uim.Issue = im;
uim.SelfAssessmentActionRequired = AccessRightOp.SelfAssessmentActionRequired(im.Id, userId);
uim.CriteriaActionRatingRequired = CriterionOp.CriteriaWeightingActionRequired(im.Id, userId);
uim.EvaluationActionRequired = RatingOp.GetRatingActionRequired(im.Id, userId);
uim.UnreadCoreItems = new List <string>();
unreadInfos = InformationReadOp.GetUnreadInfos(im.Id, userId);
unreadCnt = 0;
foreach (KeyValuePair <string, int> kvp in unreadInfos)
{
if (kvp.Key.StartsWith("Alternative I") || kvp.Key.StartsWith("Issue I") || kvp.Key.StartsWith("Criteria I"))
{
unreadCnt = unreadCnt + kvp.Value;
if (kvp.Value > 0)
{
if (kvp.Key.StartsWith("Alternative Information"))
{
uim.UnreadCoreItems.Add(kvp.Value + " new Alternatives");
}
if (kvp.Key.StartsWith("Issue Information"))
{
uim.UnreadCoreItems.Add(kvp.Value + " new Issue Attributes");
}
if (kvp.Key.StartsWith("Criteria Information"))
{
uim.UnreadCoreItems.Add(kvp.Value + " new Criteria");
}
}
}
}
uim.UnreadCoreItemsCount = unreadCnt;
TagModel tm = new TagModel();
if (uim.Issue.Tags == null || uim.Issue.Tags.Count == 0)
{
uim.Issue.Tags = tm.ToModelList(TagOp.GetIssueTags(uim.Issue.Id), tm);
}
ReviewModel rm = new ReviewModel();
IssueCreating ic = new IssueCreating();
List <UserShortModel> userList = ic.GetAllUsers();
UserShortModel usm;
if (uim.Issue.Status == "FINISHED" || uim.Issue.Status == "CLOSED")
{
uim.Rating = ReviewOp.GetReviewRating(uim.Issue.Id);
uim.Reviews = rm.ToModelList(ReviewOp.GetIssueReviews(uim.Issue.Id), rm);
foreach (ReviewModel reviewModel in uim.Reviews)
{
usm = userList.Find(x => x.Id == reviewModel.UserId);
reviewModel.UserName = usm.FirstName + " " + usm.LastName;
}
}
else
{
uim.Rating = 0.0;
}
return(uim);
}
