/// <summary>
/// This creates an auditlog (history) for the watcher and custom field manipulations
/// </summary>
/// <param name="context"></param>
/// <param name="issueId"></param>
/// <param name="issueProjectId"></param>
/// <param name="customField"></param>
/// <param name="beforeValue"></param>
/// <param name="afterValue"></param>
/// <param name="userId"></param>
/// <param name="username"></param>
public void CreateAuditlog(GeminiContext context, int issueId, int issueProjectId, CustomFieldDataDto customField, string beforeValue, string afterValue, int userId, string username)
{
try
{
IssueAuditManager issueAuditManager = new IssueAuditManager(GeminiApp.Cache(), GeminiApp.UserContext(), context);
UserManager userManager = new UserManager(GeminiApp.Cache(), GeminiApp.UserContext(), context);
IssueAudit audit = issueAuditManager.GetIssueAuditObject(issueId, issueProjectId);
audit.UserId = userId;
audit.Fullname = username;
if (customField == null)
{
issueAuditManager.LogChange(audit, ItemAttributeVisibility.AssociatedWatchers,
string.Empty, string.Empty, beforeValue, afterValue);
}
else
{
issueAuditManager.LogChange(audit, ItemAttributeVisibility.AssociatedCustomFields, customField.Entity.CustomFieldId.ToString(),
string.Empty, string.Empty, beforeValue, afterValue);
}
}
catch (Exception exception)
{
GeminiApp.LogException(exception, false, exception.Message);
}
}
/// <summary>
/// Adds a watcher if it has the same domain as the email address. Only if user is not watcher as on this task.
/// </summary>
/// <param name="context"></param>
/// <param name="domain"></param>
/// <param name="issueParam"></param>
/// <param name="userId"></param>
/// <param name="username"></param>
/// <param name="createAudit"></param>
private void AddWatcherFromDomain(GeminiContext context, string domain, IssueDto issueParam, int userId, string username, bool createAudit)
{
try
{
IssueDto issue = issueParam;
Helper helper = new Helper();
UserManager usermanager = new UserManager(GeminiApp.Cache(), GeminiApp.UserContext(), context);
List <UserDto> users = usermanager.GetActiveUsers();
foreach (UserDto user in users)
{
// Only if not already watcher on this task
if (!issue.Entity.Watchers.Contains(user.Entity.Id.ToString()))
{
string activeUserDomain = helper.FindDomain(user.Entity.Email);
if (domain == activeUserDomain)
{
issue.Entity.AddWatcher(user.Entity.Id);
if (createAudit)
{
string watcher = user.Entity.Fullname;
helper.CreateAuditlog(context, issue.Id, issue.Project.Id, null, "", watcher, userId, username);
}
}
}
}
}
catch (Exception exception)
{
GeminiApp.LogException(exception, false, exception.Message);
}
}
/// <summary>
/// This creates an auditlog for the custom field manipulations
/// </summary>
/// <param name="context"></param>
/// <param name="issueId"></param>
/// <param name="issueProjectId"></param>
/// <param name="customField"></param>
/// <param name="beforeValue"></param>
/// <param name="afterValue"></param>
public void CreateAuditlog(GeminiContext context, int issueId, int issueProjectId, CustomFieldDataDto customField, string beforeValue, string afterValue)
{
IssueAuditManager issueAuditManager = new IssueAuditManager(GeminiApp.Cache(), GeminiApp.UserContext(), context);
IssueAudit audit = issueAuditManager.GetIssueAuditObject(issueId, issueProjectId);
issueAuditManager.LogChange(audit, ItemAttributeVisibility.AssociatedCustomFields, customField.Entity.CustomFieldId.ToString(),
string.Empty, string.Empty, beforeValue, afterValue);
}
/// <summary>
/// Checks the disabled users and executes the MergeAndDelete-Method
/// </summary>
/// <param name="issueManager"></param>
public void CheckDisabledUsers(IssueManager issueManager)
{
UserManager userManager = new UserManager(GeminiApp.Cache(), GeminiApp.UserContext(), issueManager.GeminiContext);
var allUsers = userManager.GetAll();
DateTime currentDate = DateTime.Now;
var time = GetAppConfigSettings("disabledForDays").Value;
int days = Convert.ToInt32(time);
foreach (var user in allUsers)
{
if (user.Entity.Active == false)
{
var activeUserIndex = GetActiveUsersFromOrganisation(issueManager, user.Entity);
DateTime lastupdateIncludeMonths = user.Entity.Revised.AddDays(days);
int disabledUserId = user.Entity.Id;
if (activeUserIndex.Count != 0 && lastupdateIncludeMonths < DateTime.Now)
{
string firstActiveUserOrganisation = activeUserIndex[0];
foreach (var activeUser in allUsers)
{
if (activeUser.Entity.Username == firstActiveUserOrganisation)
{
try
{
MergeAndDelete(activeUser.Entity, user.Entity, disabledUserId, userManager);
break;
}
catch (Exception e)
{
string message = string.Format("Folgender User konnte nicht gemerged oder gelöscht werden: {0} ", user.Entity.Fullname);
GeminiApp.LogException(e, false, message);
}
}
}
}
else if (lastupdateIncludeMonths < DateTime.Now)
{
foreach (var activeUser in allUsers)
{
if (activeUser.Entity.Username == GetAppConfigSettings("defaultUser").Value)
{
try
{
MergeAndDelete(activeUser.Entity, user.Entity, disabledUserId, userManager);
break;
}
catch (Exception e)
{
string message = string.Format("Folgender User konnte nicht gemerged oder gelöscht werden: {0} ", user.Entity.Fullname);
GeminiApp.LogException(e, false, message);
}
}
}
}
}
}
}
/// <summary>
/// The complete procedure to find, notify and unlock the locked user.
/// </summary>
/// <param name="issueManager"></param>
/// <returns></returns>
public override bool Run(IssueManager issueManager)
{
UserManager userManager = new UserManager(GeminiApp.Cache(), GeminiApp.UserContext(), issueManager.GeminiContext);
List <UserDto> users = userManager.GetActiveUsers();
foreach (UserDto user in users)
{
if (user.Entity.Locked == true)
{
DateTime currentTime = DateTime.Now;
SendMail(user.Entity, currentTime, GetUnlockTime(user.Entity), issueManager);
UnlockUser(issueManager, user.Entity, currentTime);
}
}
return(true);
}
/// <summary>
/// Check if the "Fremd-ID"-field is ""
/// Then it checks if the ID is in the description
/// if there is no ID, then it checks in the comment section
/// </summary>
/// <param name="args">Properties of the task</param>
/// <returns>args.Issue</returns>
public IssueDto BeforeUpdateFull(IssueDtoEventArgs args)
{
try
{
List <IssueCommentDto> comments = args.Issue.Comments;
string description = args.Issue.Description;
string fieldName = GetAppConfigValue("customFieldName");
CustomFieldDataDto fremdIDField = args.Issue.CustomFields.Find(field => field.Name.Equals(fieldName));
if (fremdIDField.Entity.Data == "")
{
if (FindID(description) != "")
{
string beforeValue = fremdIDField.Entity.Data;
string valueIdDescription = FindID(description);
string fieldValue = fremdIDField.Entity.Data = valueIdDescription;
CreateAuditlog(args.Context, args.Issue.Entity.Id, args.Issue.Entity.ProjectId, fremdIDField, beforeValue, fieldValue);
}
else
{
foreach (IssueCommentDto comment in comments)
{
string valueIdComment = FindID(comment.Entity.Comment);
if (valueIdComment != "")
{
string fieldValue = fremdIDField.Entity.Data = valueIdComment;
IssueManager issueManager = new IssueManager(GeminiApp.Cache(), GeminiApp.UserContext(), args.Context);
issueManager.Update(args.Issue);
CreateAuditlog(args.Context, args.Issue.Entity.Id, args.Issue.Entity.ProjectId, fremdIDField, "", fieldValue);
break;
}
}
}
}
}
catch (Exception e)
{
int issueID = args.Issue.Id;
string message = string.Format("IssueID: {0}", issueID);
GeminiApp.LogException(e, false, message);
}
return(args.Issue);
}
private ActionResult GetSummaryByVersion(ReportOptions options)
{
var reportManager = new ReportManager(GeminiApp.Cache(), UserContext, GeminiContext);
var list = new List <ProjectDto>(options.ProjectIds.Count());
list.AddRange(options.ProjectIds.Select(id => ProjectManager.Get(id)));
var SummaryByVersion = reportManager.GetSummaryByVersion(list);
foreach (var Summary in SummaryByVersion)
{
Summary.FilterName = "versions";
}
var resultModel = new ReportResultModel {
UserContext = UserContext, Results = SummaryByVersion, Title = GetResource(ResourceKeys.Versions), Flag = options.SummaryChart.GetValueOrDefault(), ProjectIds = options.ProjectIds
}; //TODO add new key for this
return(Json(JsonResponse(options, RenderPartialViewToString(this, AppManager.Instance.GetAppUrl(AppGuid, "views/_SummaryItem.cshtml"), resultModel))));
}
/// <summary>
/// Get active users from the same domain/organisation as the disabled user
/// </summary>
/// <param name="issueManager"></param>
/// <param name="user"></param>
/// <returns></returns>
public List <string> GetActiveUsersFromOrganisation(IssueManager issueManager, User user)
{
UserManager userManager = new UserManager(GeminiApp.Cache(), GeminiApp.UserContext(), issueManager.GeminiContext);
List <UserDto> activeUsers = userManager.GetActiveUsers();
string DisabledUserDomain = FindDomain(user.Email);
List <string> activeUserList = new List <string>();
foreach (var activeUser in activeUsers)
{
string ActiveUserDomain = FindDomain(activeUser.Entity.Email);
if (DisabledUserDomain == ActiveUserDomain)
{
activeUserList.Add(activeUser.Entity.Username);
}
}
activeUserList.Sort();
return(activeUserList);
}
/// <summary>
/// This method unlocks the user
/// It sets the user.entity.locked status to false, when the next run time is greater than the unlock time.
/// </summary>
/// <param name="issueManager"></param>
/// <param name="entity"></param>
public void UnlockUser(IssueManager issueManager, User entity, DateTime currentTime)
{
try
{
IGlobalConfigurationWidgetStore dataStore = issueManager.GeminiContext.GlobalConfigurationWidgetStore;
int intervalMinutes = Convert.ToInt32(GetInterval(dataStore).IntervalInMinutes);
DateTime timeToUnlock = GetUnlockTime(entity);
DateTime nextRunTime = currentTime + new TimeSpan(0, intervalMinutes, 0);
if (timeToUnlock < nextRunTime)
{
UserManager userManager = new UserManager(GeminiApp.Cache(), GeminiApp.UserContext(), issueManager.GeminiContext);
entity.Locked = false;
userManager.Update(entity);
LogDebugMessage("Benutzer: " + entity.Fullname + " entsperrt.");
}
}
catch (Exception exception)
{
GeminiApp.LogException(exception, false, exception.Message);
}
}
/// <summary>
/// Add the domain to the custom field, and create an auditlog if it hasn't just been created.
/// </summary>
/// <param name="args"></param>
/// <param name="createAudit"></param>
/// <returns></returns>
private IssueDto AddDomain(IssueDtoEventArgs args, bool createAudit)
{
try
{
IssueDto issue = args.Issue;
Helper helper = new Helper();
if ((issue.CustomFields.Count > 0) && (!issue.CustomFields.Find(field => field.Name.Equals(helper.GetAppConfigValue("customFieldNameDomain"))).ToString().Equals(null)))
{
CustomFieldDataDto erstellerOEField = issue.CustomFields.Find(field => field.Name.Equals(helper.GetAppConfigValue("customFieldNameDomain")));
// If there is no domain in the OE-Field yet
// Depending on whether you want users to manually change the OE-Field or not, .FormattedData or .Entity.Data could be chosen.
if (string.IsNullOrEmpty(erstellerOEField.Entity.Data))
{
string maildomain = helper.FindDomain(issue.OriginatorData);
// If no email address in OriginatorData present, take email address from creator user
if (string.IsNullOrEmpty(maildomain))
{
UserManager userManager = new UserManager(GeminiApp.Cache(), GeminiApp.UserContext(), args.Context);
int userId;
// If created via another user
if (issue.Entity.ReportedBy > 0)
{
userId = issue.Entity.ReportedBy;
}
// If not
else
{
userId = args.User.Id;
}
UserDto creatorUser = userManager.Get(userId);
maildomain = helper.FindDomain(creatorUser.Entity.Email);
}
// OriginatorData has email address, no more actions required
string beforeValue = erstellerOEField.FormattedData;
erstellerOEField.Entity.Data = maildomain;
erstellerOEField.FormattedData = maildomain;
// Keep in mind that args.Issue / issue / erstellerOEField are reference types, not value types
// Create auditlog if being called from BeforeUpdateFull with the auditlog flag
if (createAudit)
{
// beforeValue -> previous value (args.Issue FormattedData -> previous value)
// issue FormattedData -> new value (alternatively erstellerOEField.FormattedData)
if (!beforeValue.Equals(helper.GetFormattedDataErstellerOE(issue)))
{
IssueManager issueManager = new IssueManager(GeminiApp.Cache(), GeminiApp.UserContext(), args.Context);
helper.CreateAuditlog(args.Context, args.Issue.Entity.Id, args.Issue.Entity.ProjectId, erstellerOEField, beforeValue, erstellerOEField.FormattedData, args.User.Id, args.User.Fullname);
}
}
}
return(issue);
}
return(args.Issue);
}
catch (Exception exception)
{
GeminiApp.LogException(exception, false, exception.Message);
return(args.Issue);
}
}
