1342 lines
60 KiB
C#
1342 lines
60 KiB
C#
using EnVisage.Models;
|
|
using NLog;
|
|
using OptimaJet.Workflow.Core.Runtime;
|
|
using Prevu.Core.Audit.Model;
|
|
using Prevu.Core.Audit.Model.ResponseModels;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using OptimaJet.Workflow.Core;
|
|
|
|
namespace EnVisage.Code.BLL
|
|
{
|
|
public class WorkFlowManager
|
|
{
|
|
protected readonly Logger Logger = LogManager.GetCurrentClassLogger();
|
|
public bool UseWorkFlow { get; set; }
|
|
private EnVisageEntities dbContext = null;
|
|
private bool isLocalContext = false;
|
|
public WorkFlowManager(EnVisageEntities dbcntx)
|
|
{
|
|
if (dbcntx == null)
|
|
{
|
|
dbContext = new EnVisageEntities();
|
|
isLocalContext = true;
|
|
}
|
|
else
|
|
{
|
|
dbContext = dbcntx;
|
|
isLocalContext = false;
|
|
}
|
|
this.UseWorkFlow = true;
|
|
}
|
|
#region Workflow Contacts
|
|
public List<WorkFlowContactModel> GetContacts(Guid ParentId, WorkFlowContactNotificationType ntype)
|
|
{
|
|
var rt = new List<WorkFlowContactModel>();
|
|
var contacts = this.dbContext.WorkFlowContacts.Where(x => x.PartentId == ParentId && x.NotificationType == (int) ntype).ToList();
|
|
foreach(var c in contacts)
|
|
{
|
|
rt.Add(new WorkFlowContactModel()
|
|
{
|
|
Id = c.Id,
|
|
ContactId = c.ContactId,
|
|
ContactType = c.ContactType,
|
|
ParentId = c.PartentId
|
|
});
|
|
}
|
|
return rt;
|
|
}
|
|
//public List<WorkFlowContactModel> GetContacts(Guid ParentId)
|
|
//{
|
|
// var rt = new List<WorkFlowContactModel>();
|
|
// var contacts = this.dbContext.WorkFlowContacts.Where(x => x.PartentId == ParentId).ToList();
|
|
// foreach (var c in contacts)
|
|
// {
|
|
// rt.Add(new WorkFlowContactModel()
|
|
// {
|
|
// Id = c.Id,
|
|
// ContactId = c.ContactId,
|
|
// ContactType = c.ContactType,
|
|
// ParentId = c.PartentId
|
|
// });
|
|
// }
|
|
// return rt;
|
|
//}
|
|
public List<Guid> GetContactList(Guid ParentId, WorkFlowContactNotificationType type )
|
|
{
|
|
var rt = new List<Guid>();
|
|
var contacts = this.dbContext.WorkFlowContacts.Where(x => x.PartentId == ParentId && x.NotificationType ==(int) type).ToList();
|
|
foreach (var c in contacts)
|
|
{
|
|
rt.Add(c.ContactId);
|
|
}
|
|
return rt;
|
|
}
|
|
public List<string> GetNotificationStates(Guid ContactParentId, WorkFlowContactNotificationType type)
|
|
{
|
|
var rt = new List<string>();
|
|
var wfstates = this.dbContext.WorkFlowContacts.Where(x => x.PartentId == ContactParentId && x.NotificationType == (int) type).Select(y => y.NotificationToWorkFlowStates).ToList();
|
|
foreach(var c in wfstates)
|
|
{
|
|
foreach(var s in c)
|
|
{
|
|
if (!rt.Contains(s.State))
|
|
rt.Add(s.State);
|
|
}
|
|
}
|
|
return rt;
|
|
}
|
|
public List<WorkFlowContactDetails> GetContactTeamDetails(Guid parentId, WorkFlowContactNotificationType type, string state)
|
|
{
|
|
var rt = new List<WorkFlowContactDetails>();
|
|
var contacts = GetContacts(parentId, type);
|
|
|
|
var teamId = Guid.Empty;
|
|
var teamName = dbContext.Teams.Where(x => x.Id == parentId).Select(x => x.Name).FirstOrDefault() ?? "";
|
|
|
|
var userIds = contacts.Select(q => q.ContactId);
|
|
var users = dbContext.AspNetUsers.Where(x => userIds.Select(q => q.ToString()).Contains(x.Id)).ToDictionary(q => q.Id);
|
|
var roles = dbContext.User2WorkFlowRole.Where(x => userIds.Contains(x.RoleId)).ToList();
|
|
|
|
var notificationToWorkFlowStates = dbContext.NotificationToWorkFlowStates.Where(x => userIds.Contains(x.WorkFlowContactId)).ToList();
|
|
|
|
foreach (var c in contacts)
|
|
{
|
|
// scenario is in wf (state==null) and there are no records for this state in the notification state table
|
|
if (!string.IsNullOrEmpty(state) && !notificationToWorkFlowStates.Any(x => x.State == state && x.WorkFlowContactId == c.Id))
|
|
continue;
|
|
//scenario is not in wf and we have notification state records
|
|
if (string.IsNullOrEmpty(state) && notificationToWorkFlowStates.Any(x => x.WorkFlowContactId == c.Id))
|
|
continue;
|
|
|
|
if (type == WorkFlowContactNotificationType.TeamScenarioAdd)
|
|
{
|
|
teamId = parentId;
|
|
}
|
|
if (c.ContactType == WorkFlowContactType.User.GetHashCode())
|
|
{
|
|
var id = c.ContactId.ToString();
|
|
AspNetUser user;
|
|
users.TryGetValue(id, out user);
|
|
if (!string.IsNullOrEmpty(user?.Id))
|
|
{
|
|
rt.Add(new WorkFlowContactDetails()
|
|
{
|
|
EmailAddress = user.Email,
|
|
FirstName = user.FirstName,
|
|
LastName = user.LastName,
|
|
UserId=Guid.Parse(user.Id),
|
|
TeamId=teamId,
|
|
TeamName=teamName
|
|
|
|
});
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var wfRoles = roles.Where(x => x.RoleId == c.ContactId).ToList();
|
|
foreach(var role in wfRoles)
|
|
{
|
|
if (role.AspNetUser != null)
|
|
{
|
|
if (role.AspNetUser.User2Team.Any(x=>x.TeamId == parentId))
|
|
rt.Add(new WorkFlowContactDetails()
|
|
{
|
|
EmailAddress = role.AspNetUser.Email,
|
|
FirstName = role.AspNetUser.FirstName,
|
|
LastName = role.AspNetUser.LastName,
|
|
UserId = Guid.Parse(role.AspNetUser.Id),
|
|
TeamId = teamId,
|
|
TeamName = teamName
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return rt;
|
|
}
|
|
public List<WorkFlowContactDetails> GetContactProjectDetails(Guid PartentId)
|
|
{
|
|
var rt = new List<WorkFlowContactDetails>();
|
|
var contacts = GetContacts(PartentId, WorkFlowContactNotificationType.None);
|
|
foreach (var c in contacts)
|
|
{
|
|
if (c.ContactType == WorkFlowContactType.User.GetHashCode())
|
|
{
|
|
var id = c.ContactId.ToString();
|
|
var user = this.dbContext.AspNetUsers.Where(x => x.Id == id).FirstOrDefault();
|
|
if (user != null)
|
|
{
|
|
if (SecurityManager.CheckProjectPermission(Guid.Parse(user.Id), PartentId, AccessLevel.Write, this.dbContext))
|
|
rt.Add(new WorkFlowContactDetails()
|
|
{
|
|
|
|
EmailAddress = user.Email,
|
|
FirstName = user.FirstName,
|
|
LastName = user.LastName,
|
|
UserId = Guid.Parse(user.Id),
|
|
|
|
});
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var wfRoles = this.dbContext.User2WorkFlowRole.Where(x => x.RoleId == c.ContactId).ToList();
|
|
foreach (var role in wfRoles)
|
|
{
|
|
if (role.AspNetUser != null)
|
|
{
|
|
if (SecurityManager.CheckProjectPermission(Guid.Parse(role.AspNetUser.Id), PartentId,AccessLevel.Write,this.dbContext))
|
|
rt.Add(new WorkFlowContactDetails()
|
|
{
|
|
EmailAddress = role.AspNetUser.Email,
|
|
FirstName = role.AspNetUser.FirstName,
|
|
LastName = role.AspNetUser.LastName,
|
|
UserId = Guid.Parse(role.AspNetUser.Id)
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return rt;
|
|
}
|
|
public List<WorkFlowContactDetails> GetContactDetails(Guid PartentId, WorkFlowContactNotificationType ntype,Guid? ProjectId)
|
|
{
|
|
var rt = new List<WorkFlowContactDetails>();
|
|
var contacts = GetContacts(PartentId,ntype);
|
|
foreach (var c in contacts)
|
|
{
|
|
if (c.ContactType == WorkFlowContactType.User.GetHashCode())
|
|
{
|
|
var id = c.ContactId.ToString();
|
|
var user = this.dbContext.AspNetUsers.Where(x => x.Id == id).FirstOrDefault();
|
|
if (user != null)
|
|
{
|
|
|
|
rt.Add(new WorkFlowContactDetails()
|
|
{
|
|
EmailAddress = user.Email,
|
|
FirstName = user.FirstName,
|
|
LastName = user.LastName,
|
|
UserId = Guid.Parse(user.Id),
|
|
|
|
});
|
|
}
|
|
}
|
|
else if (c.ContactType == WorkFlowContactType.WorkFlowGroup.GetHashCode())
|
|
{
|
|
var wfRoles = this.dbContext.User2WorkFlowRole.Where(x => x.RoleId == c.ContactId).ToList();
|
|
foreach (var role in wfRoles)
|
|
{
|
|
if (role.AspNetUser != null)
|
|
{
|
|
|
|
rt.Add(new WorkFlowContactDetails()
|
|
{
|
|
EmailAddress = role.AspNetUser.Email,
|
|
FirstName = role.AspNetUser.FirstName,
|
|
LastName = role.AspNetUser.LastName,
|
|
UserId = Guid.Parse(role.AspNetUser.Id)
|
|
});
|
|
}
|
|
}
|
|
}
|
|
else if (c.ContactType == WorkFlowContactType.UserGroup.GetHashCode())
|
|
{
|
|
string id = c.ContactId.ToString();
|
|
var sysRoles = this.dbContext.AspNetRoles.Where(x => x.Id == id).ToList();
|
|
foreach (var role in sysRoles)
|
|
{
|
|
if (role.AspNetUsers != null)
|
|
{
|
|
foreach (var u in role.AspNetUsers)
|
|
{
|
|
rt.Add(new WorkFlowContactDetails()
|
|
{
|
|
EmailAddress = u.Email,
|
|
FirstName = u.FirstName,
|
|
LastName = u.LastName,
|
|
UserId = Guid.Parse(u.Id)
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (c.ContactType == WorkFlowContactType.InternalContact.GetHashCode())
|
|
{
|
|
var InternalContacts = this.dbContext.Contact2Project.Where(x => x.ShowId == ProjectId).ToList();
|
|
foreach (var ic in InternalContacts)
|
|
{
|
|
if (ic.Contact.Type == (int) ContactType.CompanyContact)
|
|
{
|
|
var user = this.dbContext.AspNetUsers.FirstOrDefault(x => x.Email == ic.Contact.Email);
|
|
if (user != null)
|
|
{
|
|
rt.Add(new WorkFlowContactDetails()
|
|
{
|
|
EmailAddress = user.Email,
|
|
FirstName = user.FirstName,
|
|
LastName = user.LastName,
|
|
UserId = Guid.Parse(user.Id)
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
return rt;
|
|
}
|
|
public List<WorkFlowContactDetails> GetContactDetails(string RoleName, Guid ParentId, WorkFlowApprovalType type)
|
|
{
|
|
var rt = new List<WorkFlowContactDetails>();
|
|
var users = this.dbContext.User2WorkFlowRole.Where(x => x.WorkFlowRole.RoleName == RoleName).Select(x => x.AspNetUser).ToList();
|
|
foreach (var user in users)
|
|
{
|
|
bool ok = false;
|
|
if (type == WorkFlowApprovalType.Team)
|
|
ok = this.dbContext.User2Team.Any(x => x.TeamId == ParentId && x.UserId == user.Id);
|
|
else
|
|
ok = SecurityManager.CheckProjectPermission(Guid.Parse(user.Id), ParentId, AccessLevel.Write, dbContext);
|
|
if (ok)
|
|
rt.Add(new WorkFlowContactDetails()
|
|
{
|
|
EmailAddress = user.Email,
|
|
FirstName = user.FirstName,
|
|
LastName = user.LastName,
|
|
UserId = Guid.Parse(user.Id)
|
|
});
|
|
}
|
|
return rt;
|
|
}
|
|
public List<WorkFlowContactDetails> GetContactDetails(string RoleName)
|
|
{
|
|
var rt = new List<WorkFlowContactDetails>();
|
|
var wfRoles = this.dbContext.User2WorkFlowRole.Where(x => x.WorkFlowRole.RoleName == RoleName).ToList();
|
|
foreach (var role in wfRoles)
|
|
{
|
|
if (role.AspNetUser != null)
|
|
{
|
|
rt.Add(new WorkFlowContactDetails()
|
|
{
|
|
EmailAddress = role.AspNetUser.Email,
|
|
FirstName = role.AspNetUser.FirstName,
|
|
LastName = role.AspNetUser.LastName,
|
|
UserId = Guid.Parse(role.AspNetUser.Id)
|
|
});
|
|
}
|
|
}
|
|
return rt;
|
|
}
|
|
|
|
//public List<WorkFlowContactDetails> GetContactDetails(Guid PartentId, string RoleName)
|
|
//{
|
|
// var rt = new List<WorkFlowContactDetails>();
|
|
// var contacts = GetContacts(PartentId);
|
|
// foreach (var c in contacts)
|
|
// {
|
|
// if (c.ContactType == WorkFlowContactType.WorkFlowGroup.GetHashCode())
|
|
// {
|
|
// var wfRoles = this.dbContext.User2WorkFlowRole.Where(x => x.RoleId == c.ContactId && x.WorkFlowRole.RoleName == RoleName).ToList();
|
|
// foreach (var role in wfRoles)
|
|
// {
|
|
// if (role.AspNetUser != null)
|
|
// {
|
|
// rt.Add(new WorkFlowContactDetails()
|
|
// {
|
|
// EmailAddress = role.AspNetUser.Email,
|
|
// FirstName = role.AspNetUser.FirstName,
|
|
// LastName = role.AspNetUser.LastName,
|
|
// UserId = Guid.Parse(role.AspNetUser.Id)
|
|
// });
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
// return rt;
|
|
//}
|
|
public void SaveContacts(StatusModel model)
|
|
{
|
|
//clear out old contacts
|
|
this.DeleteContacts(model.Id);
|
|
if (model.NotifyOnProjectChange)
|
|
if (model.ChangeNotificationContacts.Count > 0)
|
|
this.SaveContacts(model.ChangeNotificationContacts, null, model.Id, WorkFlowContactNotificationType.ProjectUpdate);
|
|
if (model.NotifyOnProjectCreate)
|
|
if (model.CreateNotificationContacts.Count > 0)
|
|
this.SaveContacts(model.CreateNotificationContacts, null, model.Id, WorkFlowContactNotificationType.ProjectCreate);
|
|
if (model.NotifyOnProjectDelete)
|
|
if (model.DeleteNotificationContacts.Count > 0)
|
|
this.SaveContacts(model.DeleteNotificationContacts, null, model.Id, WorkFlowContactNotificationType.ProjectDelete);
|
|
}
|
|
public void SaveContacts(TypeModel model)
|
|
{
|
|
//clear out old contacts
|
|
this.DeleteContacts(model.Id);
|
|
if (model.NotifyOnProjectChange)
|
|
if (model.ChangeNotificationContacts.Count > 0)
|
|
this.SaveContacts(model.ChangeNotificationContacts, null,model.Id, WorkFlowContactNotificationType.ProjectUpdate);
|
|
if (model.NotifyOnProjectCreate)
|
|
if (model.CreateNotificationContacts.Count > 0)
|
|
this.SaveContacts(model.CreateNotificationContacts, null, model.Id, WorkFlowContactNotificationType.ProjectCreate);
|
|
if (model.NotifyOnProjectDelete)
|
|
if (model.DeleteNotificationContacts.Count > 0)
|
|
this.SaveContacts(model.DeleteNotificationContacts, null, model.Id, WorkFlowContactNotificationType.ProjectDelete);
|
|
}
|
|
|
|
public void SaveContacts(List<Guid> contacts, List<string> states, Guid ParentId, WorkFlowContactNotificationType notifyType)
|
|
{
|
|
if (contacts == null)
|
|
contacts = new List<Guid>();
|
|
bool hasChanges=DeleteContacts(ParentId);
|
|
foreach (var c in contacts)
|
|
{
|
|
var wfContactId = Guid.NewGuid();
|
|
var id = c.ToString();
|
|
var user = this.dbContext.AspNetUsers.Where(x => x.Id == id).FirstOrDefault();
|
|
var wfGroup = this.dbContext.WorkFlowRoles.Where(x => x.Id == c).FirstOrDefault();
|
|
var userGroup = this.dbContext.AspNetRoles.Where(x => x.Id == id).FirstOrDefault();
|
|
if (c == Utils.internalContactRoleGuid)
|
|
{
|
|
var wfContact = new WorkFlowContact()
|
|
{
|
|
ContactId = c,
|
|
ContactType = WorkFlowContactType.InternalContact.GetHashCode(),
|
|
PartentId = ParentId,
|
|
Id = wfContactId,
|
|
NotificationType = (int) notifyType
|
|
};
|
|
this.dbContext.WorkFlowContacts.Add(wfContact);
|
|
hasChanges = true;
|
|
|
|
}
|
|
else if (user != null && !string.IsNullOrEmpty(user.Id))
|
|
{
|
|
var wfContact = new WorkFlowContact()
|
|
{
|
|
ContactId = c,
|
|
ContactType = WorkFlowContactType.User.GetHashCode(),
|
|
PartentId = ParentId,
|
|
Id = wfContactId,
|
|
NotificationType=(int) notifyType
|
|
};
|
|
this.dbContext.WorkFlowContacts.Add(wfContact);
|
|
hasChanges = true;
|
|
}
|
|
else if (wfGroup != null && wfGroup.Id != Guid.Empty)
|
|
{
|
|
var wfContact = new WorkFlowContact()
|
|
{
|
|
ContactId = c,
|
|
ContactType = WorkFlowContactType.WorkFlowGroup.GetHashCode(),
|
|
PartentId = ParentId,
|
|
Id = wfContactId,
|
|
NotificationType = (int) notifyType
|
|
};
|
|
this.dbContext.WorkFlowContacts.Add(wfContact);
|
|
hasChanges = true;
|
|
|
|
|
|
}
|
|
else if (userGroup != null && ! string.IsNullOrEmpty(userGroup.Id))
|
|
{
|
|
var wfContact = new WorkFlowContact()
|
|
{
|
|
ContactId = c,
|
|
ContactType = WorkFlowContactType.UserGroup.GetHashCode(),
|
|
PartentId = ParentId,
|
|
Id = wfContactId,
|
|
NotificationType = (int) notifyType
|
|
};
|
|
this.dbContext.WorkFlowContacts.Add(wfContact);
|
|
hasChanges = true;
|
|
}
|
|
if (states != null && states.Count > 0)
|
|
{
|
|
foreach(string s in states)
|
|
{
|
|
var wfContactState = new NotificationToWorkFlowState()
|
|
{
|
|
Id = Guid.NewGuid(),
|
|
State = s,
|
|
WorkFlowContactId = wfContactId
|
|
};
|
|
this.dbContext.NotificationToWorkFlowStates.Add(wfContactState);
|
|
hasChanges = true;
|
|
}
|
|
}
|
|
}
|
|
if (this.isLocalContext && hasChanges)
|
|
this.dbContext.SaveChanges();
|
|
}
|
|
public void SaveContacts(List<WorkFlowContactModel> contacts,Guid ParentId)
|
|
{
|
|
if (contacts == null)
|
|
contacts = new List<WorkFlowContactModel>();
|
|
bool hasChanges= DeleteContacts(ParentId);
|
|
foreach(var c in contacts)
|
|
{
|
|
var wfContact = new WorkFlowContact()
|
|
{
|
|
ContactId = c.ContactId,
|
|
ContactType = c.ContactType,
|
|
PartentId = ParentId,
|
|
Id = Guid.NewGuid()
|
|
};
|
|
this.dbContext.WorkFlowContacts.Add(wfContact);
|
|
hasChanges = true;
|
|
}
|
|
if (this.isLocalContext && hasChanges)
|
|
this.dbContext.SaveChanges();
|
|
}
|
|
public bool DeleteContacts(Guid ParentId)
|
|
{
|
|
bool hasChanges = false;
|
|
var contacts = this.dbContext.WorkFlowContacts.Where(x => x.PartentId == ParentId).ToList();
|
|
if (contacts.Count > 0)
|
|
{
|
|
foreach(var c in contacts)
|
|
{
|
|
if (c.NotificationToWorkFlowStates != null && c.NotificationToWorkFlowStates.Count > 0)
|
|
this.dbContext.NotificationToWorkFlowStates.RemoveRange(c.NotificationToWorkFlowStates.ToList());
|
|
}
|
|
this.dbContext.WorkFlowContacts.RemoveRange(contacts);
|
|
hasChanges = true;
|
|
}
|
|
if (this.isLocalContext && hasChanges)
|
|
{
|
|
this.dbContext.SaveChanges();
|
|
hasChanges = false;
|
|
}
|
|
return hasChanges;
|
|
}
|
|
#endregion
|
|
#region WorkFlowModel
|
|
public bool RecordExists(string code, Guid Id)
|
|
{
|
|
return this.dbContext.WorkflowSchemes.Any(x => x.Code == code && x.Id != Id);
|
|
}
|
|
|
|
public Guid save(WorkFlowModel m, Guid UserId)
|
|
{
|
|
bool isNew = false;
|
|
if (m.Id == Guid.Empty)
|
|
{
|
|
isNew = true;
|
|
m.Id = Guid.NewGuid();
|
|
}
|
|
if (isNew)
|
|
{
|
|
var schemea = getNewSchemeRecord();
|
|
var workFlowRec = new WorkflowScheme()
|
|
{
|
|
Id = m.Id.Value,
|
|
isActive = m.isActive,
|
|
isDefault = m.isDefault,
|
|
ProcessType = m.DomainId,
|
|
Code = m.Code,
|
|
Name = m.Name,
|
|
CreatedBy = UserId,
|
|
DateCreated = DateTime.Now,
|
|
Scheme = schemea,
|
|
isTemplate = false
|
|
};
|
|
this.dbContext.WorkflowSchemes.Add(workFlowRec);
|
|
}
|
|
else
|
|
{
|
|
var wfrec = this.dbContext.WorkflowSchemes.Where(x => x.Id == m.Id).FirstOrDefault();
|
|
wfrec.isActive = m.isActive;
|
|
wfrec.isDefault = m.isDefault;
|
|
wfrec.ProcessType = m.DomainId;
|
|
wfrec.Code = m.Code;
|
|
wfrec.Name = m.Name;
|
|
wfrec.UpdatedBy = UserId;
|
|
wfrec.UpdateDate = DateTime.Now;
|
|
this.dbContext.Entry(wfrec).State = System.Data.Entity.EntityState.Modified;
|
|
}
|
|
if (m.isDefault)
|
|
reSetDefaults(m.DomainId, m.Id.Value);
|
|
if (this.isLocalContext)
|
|
this.dbContext.SaveChanges();
|
|
return m.Id.Value;
|
|
}
|
|
private string getNewSchemeRecord()
|
|
{
|
|
var Scheme = this.dbContext.WorkflowSchemes.Where(x => x.isTemplate == true).Select(x => x.Scheme).FirstOrDefault();
|
|
return Scheme;
|
|
}
|
|
private void reSetDefaults(int ProcessType, Guid Id)
|
|
{
|
|
var defaults=this.dbContext.WorkflowSchemes.Where(x => x.ProcessType == ProcessType && x.isDefault && x.Id != Id).ToList();
|
|
foreach(var d in defaults)
|
|
{
|
|
d.isDefault = false;
|
|
this.dbContext.Entry(d).State = System.Data.Entity.EntityState.Modified;
|
|
}
|
|
}
|
|
public void Delete(WorkFlowModel model)
|
|
{
|
|
var schemea=this.dbContext.WorkflowProcessSchemes.Where(x => x.Id == model.SchemeId).FirstOrDefault();
|
|
if (schemea != null)
|
|
this.dbContext.WorkflowProcessSchemes.Remove(schemea);
|
|
var wfheader = this.dbContext.WorkflowSchemes.Where(x => x.Id == model.Id).FirstOrDefault();
|
|
if (wfheader != null)
|
|
{
|
|
var t2w = this.dbContext.Type2WorkFlowScheme.Where(x => x.WorkFlowSchemeId == wfheader.Id).ToList();
|
|
if (t2w != null && t2w.Count > 0)
|
|
this.dbContext.Type2WorkFlowScheme.RemoveRange(t2w);
|
|
this.dbContext.WorkflowSchemes.Remove(wfheader);
|
|
}
|
|
if (this.isLocalContext)
|
|
this.dbContext.SaveChanges();
|
|
|
|
}
|
|
public WorkFlowModel Load(Guid? Id)
|
|
{
|
|
|
|
var wf = dbContext.WorkflowSchemes.Where(x => x.Id == Id.Value).FirstOrDefault();
|
|
if (wf != null && wf.Id != Guid.Empty)
|
|
{
|
|
var rt = new WorkFlowModel()
|
|
{
|
|
Id = wf.Id,
|
|
DomainId = wf.ProcessType,
|
|
isDefault = wf.isDefault,
|
|
ItemsInWorkFlow = GetInstanaceCount(wf.Code),
|
|
Name = wf.Code,
|
|
isActive = wf.isActive
|
|
|
|
};
|
|
rt.WorkFlowRoles = this.getRolesByName();
|
|
return rt;
|
|
}
|
|
else {
|
|
var rt = new WorkFlowModel();
|
|
rt.WorkFlowRoles = this.getRolesByName();
|
|
return rt;
|
|
}
|
|
}
|
|
public int GetInstanaceCount(string schemeCode)
|
|
{
|
|
var schemeId = this.dbContext.WorkflowProcessSchemes.Where(x => x.SchemeCode == schemeCode).Select(x => x.Id).FirstOrDefault();
|
|
if (schemeId != null && schemeId != Guid.Empty)
|
|
return this.dbContext.WorkflowProcessInstances.Where(x => x.SchemeId == schemeId).Distinct().Count();
|
|
return 0;
|
|
}
|
|
public WorkFlowModel LoadNewScheme()
|
|
{
|
|
return new WorkFlowModel()
|
|
{
|
|
Id = Guid.Empty,
|
|
Name = "new"
|
|
};
|
|
}
|
|
public IQueryable<WorkFlowModel> WorkFlowModelBasicQuery
|
|
{
|
|
get
|
|
{
|
|
|
|
var roles = this.getRolesByName();
|
|
return from c in dbContext.VW_WorkflowModelView.AsNoTracking().Where(x => x.isTemplate == false)
|
|
|
|
select new WorkFlowModel()
|
|
{
|
|
Id = c.Id,
|
|
DomainId = c.ProcessType,
|
|
isDefault = c.isDefault,
|
|
ItemsInWorkFlow =(c.totalRecordInWorkFlow.HasValue?c.totalRecordInWorkFlow.Value:0),
|
|
Name = c.Name,
|
|
isActive = c.isActive,
|
|
WorkFlowRoles= roles
|
|
};
|
|
}
|
|
}
|
|
#endregion
|
|
#region WorkflowEngineCommands
|
|
public void DoWorkFlowAction(List<WorkFlowCommand> actions, Guid ScenarioId, Guid userid,string schemeCode, List<Guid> updatedTeams)
|
|
{
|
|
if (updatedTeams == null)
|
|
updatedTeams = new List<Guid>();
|
|
if (!isProcessExists(ScenarioId))
|
|
CreateDocinstance(userid, ScenarioId, schemeCode);
|
|
|
|
if (actions != null)
|
|
{
|
|
foreach (var wfActions in actions)
|
|
{
|
|
if (wfActions.Selected)
|
|
{
|
|
(new NotificationManager(this.dbContext)).RemoveNotification(userid, ScenarioId);
|
|
bool cmdExed = ExecuteCommand(ScenarioId, wfActions.command, userid.ToString(), "TeamUpdates", updatedTeams);
|
|
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
public void SetWorkFlowState(List<WorkFlowState> states, Guid ScenarioId, Guid userid, string schemeCode)
|
|
{
|
|
if (!isProcessExists(ScenarioId))
|
|
CreateDocinstance(userid, ScenarioId, schemeCode);
|
|
|
|
if (states != null)
|
|
{
|
|
foreach (var state in states)
|
|
{
|
|
if (state.Selected)
|
|
{
|
|
this.SetState(userid, ScenarioId, null, state);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
public string getScenarioSchemeName(Guid ScenarioID)
|
|
{
|
|
var schemeId = this.dbContext.WorkflowProcessInstances.Where(x => x.Id == ScenarioID).Select(y => y.SchemeId).FirstOrDefault();
|
|
if (!schemeId.HasValue)
|
|
return null;
|
|
return this.dbContext.WorkflowProcessSchemes.Where(x => x.Id == schemeId.Value).Select(x => x.SchemeCode).FirstOrDefault();
|
|
//if (!string.IsNullOrEmpty(code))
|
|
// return this.dbContext.WorkflowSchemes.Where(x => x.Code == code).Select(x => x.Name).FirstOrDefault();
|
|
return null;
|
|
|
|
}
|
|
public void RemoveFormWorkFlow(Guid DocumentId)
|
|
{
|
|
if (!this.isProcessExists(DocumentId))
|
|
return;
|
|
WorkFlowEngine.Runtime(dbContext.Database.Connection.ConnectionString).DeleteInstance(DocumentId);
|
|
var approvals = this.dbContext.WorkFlowParallelApprovals.Where(x => x.ProcessId == DocumentId).ToList();
|
|
this.dbContext.WorkFlowParallelApprovals.RemoveRange(approvals);
|
|
var documentstring = DocumentId.ToString();
|
|
var projectId = this.dbContext.Scenarios.Where(x => x.Id == DocumentId).Select(x => x.ParentId).FirstOrDefault();
|
|
if (!projectId.HasValue)
|
|
projectId = Guid.Empty;
|
|
var projectIdStr = projectId.Value.ToString();
|
|
var notifications = this.dbContext.Notifications.Where(x => (x.IdinLink == DocumentId || x.Link.Contains(documentstring) ||
|
|
x.IdinLink == projectId.Value || x.Link.Contains(projectIdStr)) && x.WorkFlowState != null);
|
|
this.dbContext.Notifications.RemoveRange(notifications);
|
|
if (this.isLocalContext)
|
|
this.dbContext.SaveChanges();
|
|
|
|
}
|
|
public WorkFlowState GetCurrentState(Guid DocumentId)
|
|
{
|
|
if (DocumentId == Guid.Empty)
|
|
return null;
|
|
if (!this.isProcessExists(DocumentId))
|
|
return null;
|
|
var so = WorkFlowEngine.Runtime(dbContext.Database.Connection.ConnectionString).GetCurrentState(DocumentId);
|
|
if (so != null)
|
|
return new WorkFlowState()
|
|
{
|
|
Id = Guid.NewGuid(),
|
|
HasChanges = false,
|
|
Selected = false,
|
|
state = so.Name
|
|
};
|
|
else
|
|
return null;
|
|
}
|
|
public List<WorkFlowState> GetProjectStates(Guid DocumentId)
|
|
{
|
|
var rt =new List<WorkFlowState>();
|
|
if (DocumentId == Guid.Empty)
|
|
return rt;
|
|
|
|
var ScenarioIds =this.dbContext.Scenarios.Where(x => x.ParentId == DocumentId && x.Type == (int) ScenarioType.Portfolio).Select(y => y.Id).ToList();
|
|
foreach (var ScenarioId in ScenarioIds)
|
|
{
|
|
if (!this.isProcessExists(ScenarioId))
|
|
continue;
|
|
var so = WorkFlowEngine.Runtime(dbContext.Database.Connection.ConnectionString).GetCurrentState(ScenarioId);
|
|
if (so != null)
|
|
rt.Add(new WorkFlowState()
|
|
{
|
|
Id = Guid.NewGuid(),
|
|
HasChanges = false,
|
|
Selected = false,
|
|
state = so.Name
|
|
});
|
|
}
|
|
return rt;
|
|
}
|
|
public bool isProcessExists(Guid processId)
|
|
{
|
|
return WorkFlowEngine.Runtime(dbContext.Database.Connection.ConnectionString).IsProcessExists(processId);
|
|
}
|
|
public void CreateDocinstance(Guid userId, Guid DocumentId, string schemeCode)
|
|
{
|
|
WorkFlowEngine.Runtime(dbContext.Database.Connection.ConnectionString).CreateInstance(schemeCode, DocumentId, userId.ToString(), null);
|
|
}
|
|
public void SetState(Guid UserId, Guid Documentid, Dictionary<string, object> parms, WorkFlowState stateModel)
|
|
{
|
|
if (parms == null)
|
|
parms = new Dictionary<string, object>();
|
|
WorkFlowEngine.Runtime(dbContext.Database.Connection.ConnectionString).SetState(Documentid, UserId.ToString(), UserId.ToString(), stateModel.state, parms);
|
|
}
|
|
public IEnumerable<WorkflowState> GetStates(string SchemeaCode)
|
|
{
|
|
return WorkFlowEngine.Runtime(dbContext.Database.Connection.ConnectionString).GetAvailableStateToSet(SchemeaCode, null);
|
|
}
|
|
public bool ExecuteCommand( Guid DocumentId, string cmdName, Guid UserId)
|
|
{
|
|
return ExecuteCommand(DocumentId, cmdName, UserId.ToString(), null, string.Empty );
|
|
}
|
|
public bool ExecuteCommand(Guid DocumentId, string cmdName, string UserId, string ParmName, List<Guid> ParmValue)
|
|
{
|
|
try
|
|
{
|
|
var commands = WorkFlowEngine.Runtime(dbContext.Database.Connection.ConnectionString).GetAvailableCommands(DocumentId, UserId);
|
|
var command =
|
|
commands.FirstOrDefault(
|
|
c => c.CommandName.Equals(cmdName, StringComparison.CurrentCultureIgnoreCase));
|
|
if (command == null)
|
|
return false;
|
|
if (command.Parameters.Count(p => p.ParameterName == ParmName) == 1)
|
|
command.Parameters.Single(p => p.ParameterName == ParmName).Value = ParmValue ?? new List<Guid>();
|
|
WorkFlowEngine.Runtime(dbContext.Database.Connection.ConnectionString).ExecuteCommand(command, UserId, UserId);
|
|
return true;
|
|
}
|
|
catch (Exception dd)
|
|
{
|
|
var sb = DateTime.Now.ToString() + ": " + dd.Message;
|
|
var logger = LogManager.GetCurrentClassLogger();
|
|
if (logger != null)
|
|
logger.Fatal(sb.ToString());
|
|
}
|
|
return false;
|
|
}
|
|
public bool ExecuteCommand( Guid DocumentId, string cmdName, string UserId, string ParmName, string ParmValue)
|
|
{
|
|
try
|
|
{
|
|
var commands = WorkFlowEngine.Runtime(dbContext.Database.Connection.ConnectionString).GetAvailableCommands(DocumentId, UserId);
|
|
var command =
|
|
commands.FirstOrDefault(
|
|
c => c.CommandName.Equals(cmdName, StringComparison.CurrentCultureIgnoreCase));
|
|
if (command == null)
|
|
return false;
|
|
if (command.Parameters.Count(p => p.ParameterName == ParmName) == 1)
|
|
command.Parameters.Single(p => p.ParameterName == ParmName).Value = ParmValue ?? string.Empty;
|
|
WorkFlowEngine.Runtime(dbContext.Database.Connection.ConnectionString).ExecuteCommand(command, UserId, UserId);
|
|
return true;
|
|
}
|
|
catch (Exception dd)
|
|
{
|
|
var sb = DateTime.Now.ToString() + ": " + dd.Message;
|
|
var logger = LogManager.GetCurrentClassLogger();
|
|
if (logger != null)
|
|
logger.Fatal(sb.ToString());
|
|
}
|
|
return false;
|
|
}
|
|
public List<WorkFlowState> GetWorkFlowStates(string schemeaName)
|
|
{
|
|
var schemeaId = this.dbContext.WorkflowSchemes.Where(x => x.Name == schemeaName).Select(x => x.Id).FirstOrDefault();
|
|
return GetWorkFlowStates(schemeaId);
|
|
}
|
|
public List<WorkFlowState> GetWorkFlowStates(Guid schemeaId)
|
|
{
|
|
var rt = new List<WorkFlowState>();
|
|
var schemeaCode = this.dbContext.WorkflowSchemes.Where(x => x.Id == schemeaId).Select(x => x.Code).FirstOrDefault();
|
|
if (string.IsNullOrEmpty(schemeaCode))
|
|
return rt;
|
|
var states = GetStates(schemeaCode);
|
|
|
|
foreach(var state in states)
|
|
{
|
|
rt.Add(new WorkFlowState()
|
|
{
|
|
Id = Guid.NewGuid(),
|
|
HasChanges = false,
|
|
Selected = false,
|
|
state = state.Name
|
|
});
|
|
}
|
|
return rt;
|
|
}
|
|
public List<WorkFlowState> getStatesForProcess(string SchemeName)
|
|
{
|
|
var rt = new List<WorkFlowState>();
|
|
var schemas = this.dbContext.WorkflowSchemes.Where(x => x.isActive != false && (x.Name == SchemeName || x.Code == SchemeName)).Select(x => x.Id).ToList();
|
|
foreach (var s in schemas)
|
|
{
|
|
var states = this.GetWorkFlowStates(s);
|
|
foreach (var state in states)
|
|
{
|
|
if (!rt.Any(x => x.state == state.state))
|
|
rt.Add(state);
|
|
}
|
|
}
|
|
return rt;
|
|
|
|
}
|
|
public List<WorkFlowState> getAllStates()
|
|
{
|
|
var rt = new List<WorkFlowState>();
|
|
var schemas = this.dbContext.WorkflowSchemes.Where(x => x.isActive != false && x.isTemplate == false).Select(x => x.Id).ToList();
|
|
foreach(var s in schemas)
|
|
{
|
|
var states = this.GetWorkFlowStates(s);
|
|
foreach(var state in states)
|
|
{
|
|
if (!rt.Any(x => x.state == state.state))
|
|
rt.Add(state);
|
|
}
|
|
}
|
|
return rt;
|
|
}
|
|
public List<WorkFlowCommand> GetWorkFlowCommands(Guid DocumentId, Guid userId, bool ignoreNoOption =false)
|
|
{
|
|
List<WorkFlowCommand> rt = new List<WorkFlowCommand>();
|
|
try
|
|
{
|
|
bool canSave = false;
|
|
var cmds = GetAvailableCommands(userId, DocumentId, ignoreNoOption);
|
|
foreach (var cmd in cmds)
|
|
{
|
|
|
|
canSave = (cmd.CommandName.ToLower().Equals("approved")) || (cmd.CommandName.ToLower().Equals("rejected")) ||
|
|
(cmd.CommandName.ToLower().Equals("counter"));
|
|
var cmdObj = new WorkFlowCommand()
|
|
{
|
|
command = cmd.CommandName,
|
|
Selected = false,
|
|
Id = DocumentId,
|
|
HasChanges = canSave
|
|
};
|
|
rt.Add(cmdObj);
|
|
}
|
|
|
|
}
|
|
catch (Exception dd)
|
|
{
|
|
var sb = DateTime.Now.ToString() + ": " + dd.Message;
|
|
var logger = LogManager.GetCurrentClassLogger();
|
|
if (logger != null)
|
|
logger.Fatal(sb.ToString());
|
|
}
|
|
return rt;
|
|
}
|
|
public List<WorkFlowCommandModel> GetAvailableCommands(Guid UserId, Guid documentid, bool ignoreNoOption=false)
|
|
{
|
|
if (!isProcessExists(documentid))
|
|
return new List<WorkFlowCommandModel>();
|
|
|
|
List<WorkFlowCommandModel> rt = new List<WorkFlowCommandModel>();
|
|
var cmds = WorkFlowEngine.Runtime(dbContext.Database.Connection.ConnectionString).GetAvailableCommands(documentid, UserId.ToString());
|
|
//see if the user has already completed approval for this wf item at this step
|
|
//if so they have no other commands to exec
|
|
var exec_cmds=this.dbContext.WorkFlowParallelApprovals.Where(x => x.ProcessId == documentid && x.UserId == UserId && x.IsActive == true && x.Approved == true).ToList();
|
|
if (!ignoreNoOption)
|
|
rt.Add(new WorkFlowCommandModel()
|
|
{
|
|
CommandName = "No Change"
|
|
});
|
|
foreach (var c in cmds)
|
|
{
|
|
if (exec_cmds.Any(x => x.StepName == c.CommandName))
|
|
return new List<WorkFlowCommandModel>();
|
|
rt.Add(new WorkFlowCommandModel()
|
|
{
|
|
Classifier = c.Classifier.GetHashCode(),
|
|
CommandName = c.CommandName,
|
|
Identities = c.Identities.ToList(),
|
|
IsForSubprocess = c.IsForSubprocess,
|
|
LocalizedName = c.LocalizedName,
|
|
Parameters = ConvertParms(c.Parameters),
|
|
ProcessId = c.ProcessId,
|
|
ValidForActivityName = c.ValidForActivityName,
|
|
ValidForStateName = c.ValidForStateName
|
|
|
|
});
|
|
}
|
|
return rt;
|
|
}
|
|
private List<WorkFlowParameter> ConvertParms(IEnumerable<CommandParameter> parms)
|
|
{
|
|
List<WorkFlowParameter> rt = new List<WorkFlowParameter>();
|
|
foreach (var p in parms)
|
|
{
|
|
rt.Add(new WorkFlowParameter()
|
|
{
|
|
DefaultValue = p.DefaultValue,
|
|
isRequired = p.IsRequired,
|
|
LocalizedName = p.LocalizedName,
|
|
ParameterName = p.ParameterName,
|
|
Type = p.Type,
|
|
TypeName = p.TypeName,
|
|
Value = p.Value
|
|
});
|
|
}
|
|
return rt;
|
|
}
|
|
|
|
#endregion
|
|
#region rolesModel
|
|
public IQueryable<WorkFlowRoleModel> WorkFlowRoleModelBasicQuery
|
|
{
|
|
get
|
|
{
|
|
|
|
|
|
return from c in dbContext.VW_WorkflowRoleModelView.AsNoTracking()
|
|
|
|
select new WorkFlowRoleModel()
|
|
{
|
|
Id = c.Id,
|
|
RoleName = c.RoleName,
|
|
UserCount = (c.UsersInRole.HasValue ? c.UsersInRole.Value : 0),
|
|
};
|
|
}
|
|
}
|
|
public bool UserInAnyRole(string email, List<string> roleNames)
|
|
{
|
|
if (roleNames.Count == 0)
|
|
return true;
|
|
var roles = this.dbContext.User2WorkFlowRole.Where(x => x.AspNetUser.Email == email).Select(x => x.WorkFlowRole).ToList();
|
|
foreach(var r in roleNames)
|
|
if (roles.Any(x => x.RoleName == r))
|
|
return true;
|
|
return false;
|
|
|
|
}
|
|
public List<string> getRolesByName()
|
|
{
|
|
return this.dbContext.WorkFlowRoles.Select(x => x.RoleName).ToList();
|
|
}
|
|
public List<string> getAllRolesByName()
|
|
{
|
|
var wfRoles = getRolesByName();
|
|
var aspRoles = this.dbContext.AspNetRoles.Select(x => x.Name).ToList();
|
|
wfRoles.AddRange(aspRoles);
|
|
// var aspnetUsers = this.dbContext.AspNetUsers.Where(x => x.Type == (int) UserType.Active).Select(x => x.FirstName + " " + x.LastName);
|
|
return wfRoles;
|
|
}
|
|
public bool RoleRecordExists(string RoleName, Guid Id)
|
|
{
|
|
bool exists= this.dbContext.WorkFlowRoles.Any(x => x.RoleName == RoleName && x.Id != Id);
|
|
if (exists)
|
|
return exists;
|
|
exists = this.dbContext.AspNetRoles.Any(x => x.Name == RoleName);
|
|
return exists;
|
|
}
|
|
public void DeleteRole(WorkFlowRoleModel model)
|
|
{
|
|
var u2rs = this.dbContext.User2WorkFlowRole.Where(x => x.RoleId == model.Id).ToList();
|
|
if (u2rs != null && u2rs.Count > 0)
|
|
this.dbContext.User2WorkFlowRole.RemoveRange(u2rs);
|
|
var wfrm=this.dbContext.WorkFlowRoles.Where(x => x.Id == model.Id).FirstOrDefault();
|
|
if (wfrm != null)
|
|
this.dbContext.WorkFlowRoles.Remove(wfrm);
|
|
if (this.isLocalContext)
|
|
this.dbContext.SaveChanges();
|
|
|
|
}
|
|
public WorkFlowRoleModel LoadRole(Guid? Id)
|
|
{
|
|
var wf = dbContext.WorkFlowRoles.Where(x => x.Id == Id.Value).FirstOrDefault();
|
|
if (wf != null && wf.Id != Guid.Empty)
|
|
return new WorkFlowRoleModel()
|
|
{
|
|
Id = wf.Id,
|
|
RoleName=wf.RoleName,
|
|
UserCount=wf.User2WorkFlowRole.Count
|
|
|
|
};
|
|
else
|
|
return new WorkFlowRoleModel();
|
|
}
|
|
public Guid saveRole(WorkFlowRoleModel m)
|
|
{
|
|
bool isNew = false;
|
|
if (m.Id == Guid.Empty)
|
|
{
|
|
isNew = true;
|
|
m.Id = Guid.NewGuid();
|
|
}
|
|
if (isNew)
|
|
{
|
|
|
|
var workFlowRoleRec = new WorkFlowRole()
|
|
{
|
|
Id = m.Id.Value,
|
|
RoleName=m.RoleName
|
|
};
|
|
this.dbContext.WorkFlowRoles.Add(workFlowRoleRec);
|
|
}
|
|
else
|
|
{
|
|
var wfrec = this.dbContext.WorkFlowRoles.Where(x => x.Id == m.Id).FirstOrDefault();
|
|
wfrec.RoleName = m.RoleName;
|
|
this.dbContext.Entry(wfrec).State = System.Data.Entity.EntityState.Modified;
|
|
}
|
|
if (this.isLocalContext)
|
|
this.dbContext.SaveChanges();
|
|
return m.Id.Value;
|
|
}
|
|
public Dictionary<Guid,bool> GetProjectApproversForRole(Guid ProjectId, string step,Guid WorkFlowProcessId,string workflowRole)
|
|
{
|
|
var rt = new Dictionary<Guid, bool>();
|
|
var usersInRole=this.dbContext.vw_User2WorkFlowRoles.Where(x => x.RoleName == workflowRole).ToList();
|
|
var approvedAlready = this.dbContext.WorkFlowParallelApprovals.Where(x => x.ProcessId == WorkFlowProcessId && x.StepName== step && x.IsActive).ToList();
|
|
foreach(var user in usersInRole)
|
|
{
|
|
var userID = Guid.Parse(user.Id);
|
|
if (!SecurityManager.CheckProjectPermission(userID, ProjectId, AccessLevel.Write, dbContext))
|
|
continue;
|
|
var alreadApproved= approvedAlready.Where(x => x.UserId == userID).Select(y => y.Approved).FirstOrDefault();
|
|
if (!rt.ContainsKey(userID))
|
|
{
|
|
if (alreadApproved != null)
|
|
rt.Add(userID, alreadApproved.Value);
|
|
else {
|
|
rt.Add(userID, false);
|
|
this.dbContext.WorkFlowParallelApprovals.Add(new WorkFlowParallelApproval()
|
|
{
|
|
Id = Guid.NewGuid(),
|
|
Approved = false,
|
|
IsActive = true,
|
|
ProcessId = WorkFlowProcessId,
|
|
StepName = step,
|
|
GroupId = null,
|
|
UserId = userID
|
|
});
|
|
|
|
}
|
|
}
|
|
}
|
|
var approvelRecsToRemove = approvedAlready.Where(x => !rt.Keys.Contains(x.UserId)).ToList();
|
|
foreach(var a in approvelRecsToRemove)
|
|
{
|
|
this.dbContext.WorkFlowParallelApprovals.Remove(a);
|
|
this.dbContext.Entry(a).State = System.Data.Entity.EntityState.Deleted;
|
|
}
|
|
if (this.isLocalContext)
|
|
this.dbContext.SaveChanges();
|
|
return rt;
|
|
}
|
|
public Dictionary<Guid, bool> GetTeamApproversForRole(Guid teamId, string step, Guid WorkFlowProcessId, string workflowRole)
|
|
{
|
|
var rt = new Dictionary<Guid, bool>();
|
|
var usersInRole = this.dbContext.vw_User2Team2WorkflowRoleContactInfo.Where(x => x.RoleName == workflowRole && x.TeamId == teamId).ToList();
|
|
var approvedAlready = this.dbContext.WorkFlowParallelApprovals.Where(x => x.ProcessId == WorkFlowProcessId && x.StepName == step && x.IsActive && x.GroupId == teamId).ToList();
|
|
foreach (var user in usersInRole)
|
|
{
|
|
var userID = Guid.Parse(user.Id);
|
|
var alreadApproved = approvedAlready.Where(x => x.UserId == userID).Select(y => y.Approved).FirstOrDefault();
|
|
if (!rt.ContainsKey(userID))
|
|
{
|
|
if (alreadApproved != null)
|
|
rt.Add(userID, alreadApproved.Value);
|
|
else {
|
|
rt.Add(userID, false);
|
|
this.dbContext.WorkFlowParallelApprovals.Add(new WorkFlowParallelApproval()
|
|
{
|
|
Id = Guid.NewGuid(),
|
|
Approved = false,
|
|
IsActive = true,
|
|
ProcessId = WorkFlowProcessId,
|
|
StepName = step,
|
|
GroupId = teamId,
|
|
UserId = userID
|
|
});
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
var approvelRecsToRemove = approvedAlready.Where(x => !rt.Keys.Contains(x.UserId) && x.GroupId == teamId).ToList();
|
|
foreach (var a in approvelRecsToRemove)
|
|
{
|
|
this.dbContext.WorkFlowParallelApprovals.Remove(a);
|
|
this.dbContext.Entry(a).State = System.Data.Entity.EntityState.Deleted;
|
|
}
|
|
if (this.isLocalContext)
|
|
this.dbContext.SaveChanges();
|
|
return rt;
|
|
}
|
|
public Dictionary<Guid, bool> GetCostCenterApproversForRole(Guid teamId, string step, Guid WorkFlowProcessId, string workflowRole,Guid CostCenter)
|
|
{
|
|
var rt = new Dictionary<Guid, bool>();
|
|
var usersInRole = this.dbContext.vw_User2Team2WorkflowRoleContactInfo.Where(x => x.RoleName == workflowRole && x.TeamId == teamId).ToList();
|
|
var approvedAlready = this.dbContext.WorkFlowParallelApprovals.Where(x => x.ProcessId == WorkFlowProcessId && x.StepName == step && x.IsActive).ToList();
|
|
foreach (var user in usersInRole)
|
|
{
|
|
var userID = Guid.Parse(user.Id);
|
|
var alreadApproved = approvedAlready.Where(x => x.UserId == userID).Select(y => y.Approved).FirstOrDefault();
|
|
if (!rt.ContainsKey(userID))
|
|
{
|
|
if (alreadApproved != null)
|
|
rt.Add(userID, alreadApproved.Value);
|
|
else {
|
|
rt.Add(userID, false);
|
|
this.dbContext.WorkFlowParallelApprovals.Add(new WorkFlowParallelApproval()
|
|
{
|
|
Id = Guid.NewGuid(),
|
|
Approved = false,
|
|
IsActive = true,
|
|
ProcessId = WorkFlowProcessId,
|
|
StepName = step,
|
|
GroupId = CostCenter,
|
|
UserId = userID
|
|
});
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
//var approvelRecsToRemove = approvedAlready.Where(x => !rt.Keys.Contains(x.UserId) && x.GroupId == CostCenter).ToList();
|
|
//foreach (var a in approvelRecsToRemove)
|
|
//{
|
|
// this.dbContext.WorkFlowParallelApprovals.Remove(a);
|
|
// this.dbContext.Entry(a).State = System.Data.Entity.EntityState.Deleted;
|
|
//}
|
|
if (this.isLocalContext)
|
|
this.dbContext.SaveChanges();
|
|
return rt;
|
|
}
|
|
public void SetApprovalValue(Guid UserId, bool approved, Guid ProcessId, string step, WorkFlowApprovalType approvalType, Guid ProjectId)
|
|
{
|
|
|
|
var creditIds = this.dbContext.ScenarioDetail.Where(x => x.ParentID == ProcessId).Select(x => x.ExpenditureCategory.CreditId).Distinct().ToList();
|
|
var ECLists = dbContext.ScenarioDetail.Where(x => x.ParentID == ProcessId).Select(x => x.ExpenditureCategoryId).Distinct().ToList();
|
|
if (approvalType == WorkFlowApprovalType.AllTeam || approvalType == WorkFlowApprovalType.Team || approvalType == WorkFlowApprovalType.COSTCENTER || approvalType == WorkFlowApprovalType.TeamToEC)
|
|
{
|
|
var groupId = Guid.Empty;
|
|
var teamsInProject = new List<Guid>();
|
|
if (approvalType == WorkFlowApprovalType.Team)
|
|
teamsInProject = this.dbContext.Team2Project.Where(x => x.ProjectId == ProjectId).Select(x => x.Team.Id).ToList();
|
|
else if (approvalType == WorkFlowApprovalType.AllTeam)
|
|
teamsInProject = this.dbContext.Teams.Select(x => x.Id).ToList();
|
|
else if (approvalType == WorkFlowApprovalType.COSTCENTER)
|
|
teamsInProject = dbContext.Teams.Where(x => creditIds.Contains((x.CostCenterId.HasValue ? x.CostCenterId.Value : Guid.Empty))).Select(x => x.Id).ToList();
|
|
else if (approvalType == WorkFlowApprovalType.TeamToEC)
|
|
teamsInProject = dbContext.VW_TeamResource.Where(x => ECLists.Contains(x.ExpenditureCategoryId)).Select(x => x.TeamId).Distinct().ToList();
|
|
|
|
string userid = UserId.ToString();
|
|
var user2Teams = this.dbContext.vw_User2Team2WorkflowRoleContactInfo.Where(x => x.Id == userid && teamsInProject.Contains(x.TeamId)).ToList();
|
|
foreach (var user2Team in user2Teams) {
|
|
if (approvalType == WorkFlowApprovalType.Team || approvalType == WorkFlowApprovalType.AllTeam || approvalType == WorkFlowApprovalType.TeamToEC)
|
|
groupId = user2Team.TeamId;
|
|
else if (approvalType == WorkFlowApprovalType.COSTCENTER)
|
|
{
|
|
var tmpG = this.dbContext.Teams.Where(x => x.Id == user2Team.TeamId).Select(x => x.CostCenterId).FirstOrDefault();
|
|
if (tmpG.HasValue && tmpG.Value != Guid.Empty)
|
|
groupId = tmpG.Value;
|
|
else
|
|
groupId = Guid.Empty;
|
|
}
|
|
var approvelRec = this.dbContext.WorkFlowParallelApprovals.Where(x => x.ProcessId == ProcessId && x.UserId == UserId && x.StepName == step && x.GroupId == groupId && x.IsActive).FirstOrDefault();
|
|
if (approvelRec == null)
|
|
{
|
|
approvelRec = new WorkFlowParallelApproval()
|
|
{
|
|
Id = Guid.NewGuid(),
|
|
UserId = UserId,
|
|
ProcessId = ProcessId,
|
|
Approved = approved,
|
|
StepName = step,
|
|
GroupId = groupId,
|
|
DateApproved = DateTime.Now,
|
|
IsActive = true
|
|
};
|
|
this.dbContext.WorkFlowParallelApprovals.Add(approvelRec);
|
|
this.dbContext.Entry(approvelRec).State = System.Data.Entity.EntityState.Added;
|
|
}
|
|
else
|
|
{
|
|
approvelRec.Approved = approved;
|
|
approvelRec.IsActive = true;
|
|
approvelRec.DateApproved = DateTime.Now;
|
|
this.dbContext.Entry(approvelRec).State = System.Data.Entity.EntityState.Modified;
|
|
}
|
|
ClearApprovelNotificiation(ProcessId, groupId, UserId);
|
|
}
|
|
}
|
|
else if (approvalType == WorkFlowApprovalType.Project)
|
|
{
|
|
var approvelRec = this.dbContext.WorkFlowParallelApprovals.Where(x => x.ProcessId == ProcessId && x.UserId == UserId && x.StepName == step && x.IsActive).FirstOrDefault();
|
|
if (approvelRec == null)
|
|
{
|
|
approvelRec = new WorkFlowParallelApproval()
|
|
{
|
|
Id = Guid.NewGuid(),
|
|
UserId = UserId,
|
|
ProcessId = ProcessId,
|
|
Approved = approved,
|
|
StepName = step,
|
|
GroupId = null,
|
|
DateApproved = DateTime.Now,
|
|
IsActive = true
|
|
};
|
|
this.dbContext.WorkFlowParallelApprovals.Add(approvelRec);
|
|
this.dbContext.Entry(approvelRec).State = System.Data.Entity.EntityState.Added;
|
|
}
|
|
else
|
|
{
|
|
approvelRec.Approved = approved;
|
|
approvelRec.IsActive = true;
|
|
approvelRec.DateApproved = DateTime.Now;
|
|
this.dbContext.Entry(approvelRec).State = System.Data.Entity.EntityState.Modified;
|
|
}
|
|
|
|
|
|
}
|
|
else if (approvalType == WorkFlowApprovalType.ADHOC)
|
|
{
|
|
var approvelRec = this.dbContext.WorkFlowParallelApprovals.Where(x => x.ProcessId == ProcessId && x.UserId == UserId && x.StepName == step && x.IsActive).FirstOrDefault();
|
|
if (approvelRec == null)
|
|
{
|
|
approvelRec = new WorkFlowParallelApproval()
|
|
{
|
|
Id = Guid.NewGuid(),
|
|
UserId = UserId,
|
|
ProcessId = ProcessId,
|
|
Approved = approved,
|
|
StepName = step,
|
|
GroupId = null,
|
|
DateApproved = DateTime.Now,
|
|
IsActive = true
|
|
};
|
|
this.dbContext.WorkFlowParallelApprovals.Add(approvelRec);
|
|
this.dbContext.Entry(approvelRec).State = System.Data.Entity.EntityState.Added;
|
|
}
|
|
else
|
|
{
|
|
approvelRec.Approved = approved;
|
|
approvelRec.IsActive = true;
|
|
approvelRec.DateApproved = DateTime.Now;
|
|
this.dbContext.Entry(approvelRec).State = System.Data.Entity.EntityState.Modified;
|
|
}
|
|
}
|
|
if (this.isLocalContext)
|
|
this.dbContext.SaveChanges();
|
|
}
|
|
private void ClearApprovelNotificiation(Guid ProcessId, Guid groupId, Guid UserId)
|
|
{
|
|
|
|
string ProcessIdstr = ProcessId.ToString();
|
|
var notifications = this.dbContext.Notifications.Where(x => x.IdinLink == ProcessId || x.Link.Contains(ProcessIdstr)).ToList();
|
|
foreach (var n in notifications)
|
|
{
|
|
if (n.WorkFlowState == null)
|
|
continue;
|
|
if (!this.dbContext.WorkFlowParallelApprovals.Any(x => x.GroupId == groupId && x.ProcessId == ProcessId && x.UserId == n.ParentId))
|
|
continue;
|
|
|
|
if (n.ParentId != UserId)
|
|
{
|
|
this.dbContext.Notifications.Remove(n);
|
|
this.dbContext.Entry(n).State = System.Data.Entity.EntityState.Deleted;
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
}
|
|
}
|