public void AddAfter(WorkFlowTemplate template, WorkType existingWorkType, WorkType newWorkType)
{
var workFlowNodeexisting = CreateWorkFlowTypeNode(template, existingWorkType);
var newNodeWorkFlow = CreateWorkFlowTypeNode(template, newWorkType);
AddAfter(template, workFlowNodeexisting, newNodeWorkFlow);
}
private void ValidateAdd(WorkFlowTemplate template, WorkflowWorkTypeNode Node)
{
//vaidate rules for publish and such
if (!CanAddWorkType(template, Node))
{
throw new WorkTypeAlreadyExistInWorkFlowException(Node.Name);
}
}
public void AddWorkType(WorkFlowTemplate template, WorkType workType)
{
//worktype has to be published before allow to add to workflow.
//and workflowtemplate can not be published.
//Use an interface of IValidateAddWorkTypeForWorkFlow.Execute(template,worktype)
var workFlowNode = CreateWorkFlowTypeNode(template, workType);
AddWorkFlowTypeNode(template, workFlowNode);
}
public string StartETicketingSystem(TicketSystem TicketSystem, string Template, string userId)
{
try
{
WorkFlowTemplate WorkFlowTemplate = PSF.Get <WorkFlowTemplate>("TemplateName", Template);
//creating process instance
ProcessInstance pi = new ProcessInstance();
pi.CreatedBy = userId;
pi.DateCreated = DateTime.Now;
pi.TemplateId = WorkFlowTemplate.Id;
pi.Status = "Activated";
PSF.SaveOrUpdate <ProcessInstance>(pi);
long pid = pi.Id;
//create object with the pid for FFExport
TicketSystem.InstanceId = pid;
PSF.SaveOrUpdate <TicketSystem>(TicketSystem);
string ticketNo = "ETicket-" + TicketSystem.Id;
TicketSystem.TicketNo = ticketNo;
PSF.SaveOrUpdate <TicketSystem>(TicketSystem);
IList <WorkFlowStatus> WorkFlowStatusList = PSF.GetList <WorkFlowStatus>("TemplateId", WorkFlowTemplate.Id, "ActivityOrder", 1);
foreach (WorkFlowStatus wfs in WorkFlowStatusList)
{
Activity NextActivity = new Activity();
NextActivity.ActivityName = wfs.WFStatus;
NextActivity.ActivityFullName = wfs.Description;
NextActivity.AppRole = wfs.Performer;
NextActivity.Completed = false;
NextActivity.Available = true;
NextActivity.Assigned = false;
NextActivity.Performer = userId;
NextActivity.TemplateId = WorkFlowTemplate.Id;
NextActivity.InstanceId = pid;
NextActivity.NextActOrder = wfs.NextActOrder;
NextActivity.ActivityOrder = wfs.ActivityOrder;
NextActivity.PreviousActOrder = 1;
NextActivity.ProcessRefId = TicketSystem.Id;
NextActivity.CreatedDate = DateTime.Now;
NextActivity.BranchCode = TicketSystem.BranchCode;
NextActivity.DeptCode = TicketSystem.DeptCode;
if (wfs.IsRejectionRequired == true)
{
NextActivity.IsRejApplicable = true;
}
PSF.SaveOrUpdate <Activity>(NextActivity);
}
return(TicketSystem.TicketNo);
}
catch (Exception) { throw; }
}
public WorkFlowTemplate CreateWorkFlowTemplate(string Name, List <WorkType> workTypes)
{
WorkFlowTemplate template = CreateWorkFlowTemplate(Name);
foreach (WorkType item in workTypes)
{
AddWorkType(template, item);
}
var result = persistor.SaveOrUpdateAndPersist(template);
if (!result.Success)
{
throw new PersistenceTransActionException(string.Format("Unable to save the {0} template", Name));
}
return(template);
}
public WorkFlowTemplate CreateWorkFlowTemplate(string Name)
{
if (nameMgr.IsNameAvailable(workFlowTemplatetypeForNameMgr, Name))
{
nameMgr.RegisterName(workFlowTemplatetypeForNameMgr, Name);
var workflowTemplate = new WorkFlowTemplate(Name);
var result = persistor.SaveOrUpdateAndPersist(workflowTemplate);
if (!result.Success)
{
throw new PersistenceTransActionException(string.Format("Unable to save the {0} template", Name));
}
return(workflowTemplate);
}
throw new NameAlreadyUsedException(Name, workFlowTemplatetypeForNameMgr);
}
public bool CanAddWorkType(WorkFlowTemplate template, WorkType workType)
{
var workFlowNode = CreateWorkFlowTypeNode(template, workType);
return(CanAddWorkType(template, workFlowNode));
}
private bool AbleToEditTemplate(WorkFlowTemplate template)
{
return(true);
}
public WorkFlowInstance CreateWorkFlowInstance(WorkFlowTemplate template, IExternalMessageData messageData)
{
return(null);
}
public void Remove(WorkFlowTemplate template, WorkflowWorkTypeNode workflowWorkTypeNode)
{
template.Remove(workflowWorkTypeNode);
}
public void RemoveLast(WorkFlowTemplate template)
{
template.RemoveLast( );
}
public void AddAfter(WorkFlowTemplate template, WorkflowWorkTypeNode existingWorkflowWorkTypeNode, WorkflowWorkTypeNode newWorkflowWorkFlowTypeNode)
{
ValidateAdd(template, newWorkflowWorkFlowTypeNode);
template.AddAfter(existingWorkflowWorkTypeNode, newWorkflowWorkFlowTypeNode);
}
public void AddLast(WorkFlowTemplate template, WorkType workType)
{
var workFlowNode = CreateWorkFlowTypeNode(template, workType);
AddLast(template, workFlowNode);
}
public void AddLast(WorkFlowTemplate template, WorkflowWorkTypeNode workflowWorkFlowNode)
{
ValidateAdd(template, workflowWorkFlowNode);
template.AddLast(workflowWorkFlowNode);
}
public bool CanAddWorkType(WorkFlowTemplate template, WorkflowWorkTypeNode workflowWorkType)
{
return(template.CanAddWorkType(workflowWorkType));
}
public void Remove(WorkFlowTemplate template, WorkType workType)
{
var workFlowNodeexisting = CreateWorkFlowTypeNode(template, workType);
template.Remove(workFlowNodeexisting);
}
public void Clear(WorkFlowTemplate template)
{
template.Clear( );
}
public bool CompleteActivityTicketSystem(TicketSystem TicketSystem, string Template, string userId, string ActivityName, bool isRejection)
{
bool retValue = false;
try
{
PSF.SaveOrUpdate <TicketSystem>(TicketSystem);
WorkFlowTemplate WorkFlowTemplate = PSF.Get <WorkFlowTemplate>("TemplateName", Template);
//close the current activity
Activity CurrentActivity = PSF.Get <Activity>("InstanceId", TicketSystem.InstanceId, "ActivityName", ActivityName, "Completed", false);
if (CurrentActivity != null)
{
//if current activity doesnt need any rejection and there is no rejection then it will be completed
//otherwise once the rejection resolved then it will be completed
//this need to be obdated as waiting
if (CurrentActivity.IsRejApplicable == true && isRejection == true)
{
CurrentActivity.BranchCode = TicketSystem.BranchCode;
CurrentActivity.DeptCode = TicketSystem.DeptCode;
CurrentActivity.Completed = true;
CurrentActivity.Available = false;
CurrentActivity.Assigned = false;
CurrentActivity.Performer = userId;
PSF.SaveOrUpdate(CurrentActivity);
}
else
{
Activity WaitingAct = PSF.Get <Activity>("WaitingFor", CurrentActivity.Id);
if (WaitingAct != null)
{
CurrentActivity.BranchCode = TicketSystem.BranchCode;
CurrentActivity.DeptCode = TicketSystem.DeptCode;
CurrentActivity.Waiting = false;
PSF.SaveOrUpdate(CurrentActivity);
WaitingAct.Completed = true;
WaitingAct.Assigned = false;
WaitingAct.Available = false;
}
CurrentActivity.BranchCode = TicketSystem.BranchCode;
CurrentActivity.DeptCode = TicketSystem.DeptCode;
CurrentActivity.Completed = true;
CurrentActivity.Available = false;
CurrentActivity.Assigned = false;
CurrentActivity.Performer = userId;
if (CurrentActivity.ActivityName == "CompleteETicket")
{
TicketSystem.IsTicketCompleted = true;
PSF.Update <TicketSystem>(TicketSystem);
ProcessInstance pi = PSF.Get <ProcessInstance>(TicketSystem.InstanceId);
pi.Status = "Completed"; PSF.SaveOrUpdate <ProcessInstance>(pi);
TicketSystem.Status = "Completed";
PSF.SaveOrUpdate <TicketSystem>(TicketSystem);
}
PSF.SaveOrUpdate(CurrentActivity);
}
}
//trigger the next activity //we need to check whether parallel activities are there to complete
//activities that are coming in the next order
IList <WorkFlowStatus> WorkFlowStatusList = PSF.GetList <WorkFlowStatus>("TemplateId", WorkFlowTemplate.Id, "ActivityOrder", CurrentActivity.NextActOrder);
//checking parallel activities get the current order of activities
Dictionary <string, object> WaitCriteria = new Dictionary <string, object>();
WaitCriteria.Add("TemplateId", WorkFlowTemplate.Id);
WaitCriteria.Add("ActivityOrder", CurrentActivity.ActivityOrder);
WaitCriteria.Add("InstanceId", CurrentActivity.InstanceId);
Dictionary <long, IList <Activity> > conditionList = PSF.GetListWithSearchCriteriaCount <Activity>(0, 100, string.Empty, string.Empty, WaitCriteria);
if (conditionList != null && conditionList.Count > 0)
{
IList <Activity> conditionWaitList = conditionList.First().Value;
bool? waiting = false;
foreach (Activity a in conditionWaitList)
{
if (a.Completed == false && waiting == false)
{
waiting = true;
}
}
retValue = true;
if (waiting == true)
{
if (CurrentActivity.IsRejApplicable == true && isRejection == true)
{
}
else
{
return(retValue);
}
}
}
if (WorkFlowStatusList != null && WorkFlowStatusList.Count > 0)
{
//if it is rejection flow then build the logic here
//{logic goes here }
foreach (WorkFlowStatus wfs in WorkFlowStatusList)
{
//Rejection Activity
if (CurrentActivity.IsRejApplicable == true && isRejection == true)
{
WorkFlowStatus wfsRej = PSF.Get <WorkFlowStatus>("TemplateId", WorkFlowTemplate.Id, "RejectionFor", CurrentActivity.ActivityOrder);
if (wfsRej != null)
{
Activity NextActivityRej = new Activity();
NextActivityRej.CreatedDate = DateTime.Now;
NextActivityRej.ActivityName = wfsRej.WFStatus;
if (NextActivityRej.ActivityName == "CompleteETicket")
{
NextActivityRej.Completed = true;
//ProcessInstance pi = PSF.Get<ProcessInstance>(CallManagement.InstanceId);
//pi.Status = "Completed"; PSF.SaveOrUpdate<ProcessInstance>(pi);
TicketSystem.Status = NextActivityRej.ActivityName;
PSF.SaveOrUpdate <TicketSystem>(TicketSystem);
}
else
{
NextActivityRej.Completed = false;
}
NextActivityRej.ActivityFullName = wfsRej.Description;
NextActivityRej.AppRole = wfsRej.Performer;
NextActivityRej.Performer = userId;
NextActivityRej.TemplateId = WorkFlowTemplate.Id;
NextActivityRej.InstanceId = TicketSystem.InstanceId;
NextActivityRej.NextActOrder = wfsRej.NextActOrder;
NextActivityRej.ActivityOrder = wfsRej.ActivityOrder;
NextActivityRej.PreviousActOrder = wfsRej.PreviousActOrder;
NextActivityRej.ProcessRefId = TicketSystem.Id;
NextActivityRej.RejectionFor = CurrentActivity.Id;
NextActivityRej.Completed = false;
NextActivityRej.Available = true;
NextActivityRej.Assigned = false;
NextActivityRej.BranchCode = TicketSystem.BranchCode;
NextActivityRej.DeptCode = TicketSystem.DeptCode;
PSF.SaveOrUpdate <Activity>(NextActivityRej);
TicketSystem.Status = NextActivityRej.ActivityName;
PSF.SaveOrUpdate <TicketSystem>(TicketSystem);
//CurrentActivity.WaitingFor = NextActivityRej.Id;
//PSF.SaveOrUpdate(CurrentActivity);
}
}
else
{
Activity NextActivity = new Activity();
NextActivity.CreatedDate = DateTime.Now;
if (wfs.IsRejectionRequired == true)
{
NextActivity.IsRejApplicable = true;
}
NextActivity.ActivityName = wfs.WFStatus;
NextActivity.ActivityFullName = wfs.Description;
NextActivity.AppRole = wfs.Performer;
NextActivity.Completed = wfs.WFStatus == "Complete" ? true : false;
NextActivity.Available = wfs.WFStatus != "Complete" ? true : false;
//NextActivity.Performer = userId;
NextActivity.TemplateId = WorkFlowTemplate.Id;
NextActivity.InstanceId = TicketSystem.InstanceId;
NextActivity.NextActOrder = wfs.NextActOrder;
NextActivity.ActivityOrder = wfs.ActivityOrder;
NextActivity.PreviousActOrder = wfs.PreviousActOrder;
NextActivity.ProcessRefId = TicketSystem.Id;
NextActivity.Available = true;
NextActivity.Assigned = false;
NextActivity.Completed = false;
NextActivity.BranchCode = TicketSystem.BranchCode;
NextActivity.DeptCode = TicketSystem.DeptCode;
PSF.SaveOrUpdate <Activity>(NextActivity);
TicketSystem.Status = NextActivity.ActivityName;
PSF.SaveOrUpdate <TicketSystem>(TicketSystem);
}
}
retValue = true;
}
return(retValue);
}
catch (Exception)
{
throw;
}
}
public WorkflowWorkTypeNode CreateWorkFlowTypeNode(WorkFlowTemplate template, WorkType workType)
{
return(new WorkflowWorkTypeNode(workType, template));
}
