public atriumDB.ProcessRow ParentProcess(atriumDB.ProcessRow pr, bool active)
{
if (pr.IsFirstActivityIdNull())
{
return(null);
}
else
{
string[] parents = pr.Thread.Split('-');
for (int i = parents.Length - 2; i >= 0; i--)
{
atriumDB.ProcessRow pr1 = myProcessDT.FindByProcessId(Convert.ToInt32(parents[i]));
if (pr1 != null)
{
if (!active)
{
return(pr1);
}
else if (pr1.Active)
{
return(pr1);
}
}
}
return(null);
}
}
public atriumDB.ProcessRow Load(int ProcessId)
{
atriumDB.ProcessRow pr = myProcessDT.FindByProcessId(ProcessId);
if (pr == null)
{
if (myA.AtMng.AppMan.UseService)
{
Fill(myA.AtMng.AppMan.AtriumX().ProcessLoad(ProcessId, myA.AtMng.AppMan.AtriumXCon));
}
else
{
try
{
Fill(myDAL.Load(ProcessId));
}
catch (System.Runtime.Serialization.SerializationException x)
{
RecoverDAL();
Fill(myDAL.Load(ProcessId));
}
}
pr = myProcessDT.FindByProcessId(ProcessId);
}
return(pr);
}
internal void CheckMove(atriumDB.ProcessRow pr)
{
//need to check permissions on current process
if (!CanDelete(pr))
{
throw new AtriumException(Properties.Resources.YouNeedDeletePermissionOnTheProcessToMoveIt);
}
//don't move a create file process
//ActivityConfig.SeriesRow sr = myA.AtMng.acMng.DB.Series.FindBySeriesId(pr.SeriesId);
//if(!sr.AllowMove)
//if (sr.CreatesFile)
// throw new AtriumException("You can't move an activity on a process that creates the file.");
//don't move a process that is threaded - ie a child process
//if (pr.Thread.Contains("-"))
// throw new AtriumException("You cannot move an activity that is on a process directly related to another process.");
////don't move a process that has child processes
//foreach (atriumDB.ProcessRow prr in myA.AtMng.GetFile(pr.FileId, false).DB.Process)
//{
// if (prr.Thread.StartsWith(pr.Thread) && prr.ProcessId != pr.ProcessId)
// throw new AtriumException("You can't move an activity that is on the process that created the file (or is a top-level process in the file.");
//}
}
//public ACEngine Add(DateTime acDate, ActivityConfig.ACSeriesRow acSeries, atriumDB.ProcessRow process, bool adHoc, atriumDB.ActivityRow prevAc, string conversationIndex)
//{
// if (myACE != null)
// throw new AtriumException("You cannot enter more than one activity at a time on a file.");
// myACE = new ACEngine(FM, acDate, acSeries, process, adHoc, conversationIndex, prevAc, ConnectorType.NextStep, null, 0, ACEngine.RevType.Nothing);
// return myACE;
//}
public ACEngine Add(DateTime acDate, ActivityConfig.ACSeriesRow acSeries, atriumDB.ProcessRow process, bool adHoc, atriumDB.ActivityRow prevAc)
{
if (myACE != null)
{
throw new AtriumException("You cannot enter more than one activity at a time on a file.");
}
myACE = new ACEngine(FM, acDate, acSeries, process, adHoc, null, prevAc, ConnectorType.NextStep, null, 0, ACEngine.RevType.Nothing, null);
return(myACE);
}
protected override void AfterAdd(DataRow row)
{
atriumDB.ProcessRow dr = (atriumDB.ProcessRow)row;
string ObjectName = this.myProcessDT.TableName;
dr.ProcessId = myA.AtMng.PKIDGet(ObjectName, 10);
dr.Active = false;
dr.Thread = dr.ProcessId.ToString();
dr.Paused = false;
}
private static bool TestForProcessMatch(atriumDB.ProcessRow pr, atriumDB.ActivityRow prevAc)
{
bool match = true;
if (prevAc == null)
{
return(match);
}
if (pr != null)
{
match = false;
if (pr.Thread.StartsWith(prevAc.ProcessRow.Thread) | prevAc.ProcessRow.Thread.StartsWith(pr.Thread))
{
match = true;
}
}
return(match);
}
internal void CompleteAllOnProcess(atriumDB.ProcessRow pr1, int procid)
{
AllowEdit = true;
foreach (atriumDB.ProcessRow pr in myA.DB.Process.Select("ProcessId=" + pr1.ProcessId.ToString() + " or Thread like '" + pr1.Thread + "-%' or '" + pr1.Thread + "' like Thread+'%' "))
{
if (pr.ProcessId != procid)
{
foreach (atriumDB.ActivityRow ar in pr.GetActivityRows())
{
foreach (atriumDB.ActivityBFRow abr in ar.GetActivityBFRows())
{
if (abr.Completed == false && abr.ACBFId != USERBFID)
{
abr.Completed = true;
}
}
}
}
}
AllowEdit = false;
}
public void SetActive(atriumDB.ProcessRow pr)
{
foreach (atriumDB.ActivityRow ar in pr.GetActivityRows())
{
foreach (atriumDB.ActivityBFRow abr in ar.GetActivityBFRows())
{
if (!abr.Completed & !(abr.ACBFId == ActivityBFBE.USERBFID | abr.isMail))
{
if (!pr.Active)
{
pr.Active = true;
}
return;
}
}
}
if (pr.Active)
{
pr.Active = false;
}
}
public ACEngine Add(DateTime acDate, ActivityConfig.ACSeriesRow acSeries, atriumDB.ProcessRow process, bool adHoc, atriumDB.ActivityRow prevAc, ConnectorType action, Stack <ParentChildStep> _flowQ, int revId, ACEngine.RevType revType, string conversationIndex, DataRow contextRow)
{
//if (_flowQ != null)
// flowQ = _flowQ;
if (myACE != null)
{
throw new AtriumException("You cannot enter more than one activity at a time on a file.");
}
ConnectorType ct;
if (action == ConnectorType.Reply | action == ConnectorType.ReplyAll | action == ConnectorType.Forward)
{
ct = action;
}
else
{
ct = ConnectorType.NextStep;
}
myACE = new ACEngine(FM, acDate, acSeries, process, adHoc, conversationIndex, prevAc, ct, _flowQ, revId, revType, contextRow);
return(myACE);
}
//not used CJW 2014-2-19
//public Dictionary<int, CurrentFlow> NextSteps(atriumDB.ActivityRow ar)
//{
// currentFlows = new Dictionary<int, CurrentFlow>();
// atriumDB.ProcessRow pr = ar.ProcessRow;
// CurrentFlow ap = NextSteps(pr);
// if (ap.NextSteps.Count > 0)
// currentFlows.Add(pr.ProcessId, ap);
// return currentFlows;
//}
private CurrentFlow NextSteps(atriumDB.ProcessRow pr)
{
flowQ = null;
fileProcesses.Clear();
activeProcesses.Clear();
foreach (atriumDB.ProcessRow pr1 in myFM.CurrentFile.GetProcessRows())
{
fileProcesses.Add(pr1.ProcessId, pr1.SeriesId);
if (pr1.Active)
{
activeProcesses.Add(pr1.ProcessId, pr1.SeriesId);
}
}
if (pr == null)
{
throw new Exception("Activity process is null. Contact the system administrator");
}
CurrentFlow ap;
if (!pr.Active)//& currentFlows.Count>0
{
atriumDB.ProcessRow prparent = FM.GetProcess().ParentProcess(pr, true);
if (prparent == null)
{
ap = new CurrentFlow();
ap.Process = pr;
}
else
{
ap = currentFlows[prparent.ProcessId];
}
}
else
{
ap = new CurrentFlow();
ap.Process = pr;
}
topAP = ap;
currentAP = ap;
foreach (atriumDB.ActivityRow ar in pr.GetActivityRows())
{
ActivityConfig.ACSeriesRow asr = myFM.AtMng.acMng.DB.ACSeries.FindByACSeriesId(ar.ACSeriesId);
NextSteps(currentAP, asr, ar);
/*
* foreach (ActivityConfig.ACDependencyRow acdr in asr.GetACDependencyRowsByPreviousSteps())
* {
* //do not remove step if it was enabled
* if (!acdr.Enable & ap.NextSteps.Contains(acdr.ACSeriesRowByPreviousSteps))
* ap.NextSteps.Remove(acdr.ACSeriesRowByPreviousSteps);
* }
*/
}
//a bit of a kluge
//check for branch only and remove
int removeid = 0;
foreach (NextStep ns in ap.NextSteps.Values)
{
if (ns.acs.StepType == (int)StepType.Branch && ns.Children.NextSteps.Count == 0)
{
removeid = ns.acs.ACSeriesId;
}
}
if (removeid != 0)
{
ap.NextSteps.Remove(removeid);
}
return(ap);
}
public void CreateAC(int acseriesId, DateTime acDate, string ctxTable, int ctxId, int revId, ACEngine.RevType revType)
{
//get context process
atriumDB.ProcessRow pr = null;
if (ctxTable != null)
{
foreach (atriumDB.ProcessContextRow pcr in FM.DB.ProcessContext)
{
if (pcr.LinkTable == ctxTable && pcr.LinkId == ctxId)
{
pr = pcr.ProcessRow;
break;
}
}
}
ActivityConfig.ACSeriesRow acsr = FM.AtMng.acMng.DB.ACSeries.FindByACSeriesId(acseriesId);
AcSeriesOKToAdd.Clear();
Dictionary <int, atriumBE.CurrentFlow> activeProcesses = this.Workflow.NextSteps();
Workflow.EnabledProcesses();
Workflow.AvailableProcesses();
if (AcSeriesOKToAdd.Contains(acsr))
{
//atriumDB.ActivityRow prevAc = null;
NextStep ns = null;
foreach (atriumBE.CurrentFlow ap in activeProcesses.Values)
{
ns = LoadNextSteps(acseriesId, ap);
//test for process match
if (ns != null)
{
bool match = TestForProcessMatch(pr, ns.prevAc);
if (ns != null && ns.prevAc != null && match)
{
break;
}
}
}
if (ns == null || ns.prevAc == null)
{
activeProcesses = this.Workflow.EnabledProcesses();
foreach (atriumBE.CurrentFlow ap in activeProcesses.Values)
{
ns = LoadNextSteps(acseriesId, ap);
if (ns != null)
{
bool match = TestForProcessMatch(pr, ns.prevAc);
if (ns != null && ns.prevAc != null && match)
{
break;
}
}
}
}
this.DoAutoAC(ns, acsr, revId, revType, acDate);
}
else
{
throw new AtriumException("You cannot perform this activity on this file");
}
}
internal void DoACAllSteps(atriumDB.ActivityRow prevAC, ActivityConfig.ACSeriesRow asr, int revId, ACEngine.RevType revType, DateTime acDate, out ACEngine ace, out atriumDB.ActivityRow newAC, Stack <ParentChildStep> _flowQ, string conversationIndex)
{
atriumDB.ProcessRow pr = null;
if (prevAC != null)
{
pr = prevAC.ProcessRow;
}
ace = Add(acDate, asr, pr, false, prevAC, ConnectorType.NextStep, _flowQ, revId, revType, conversationIndex, null);
ace.ctx = ctx;
newAC = ace.NewActivity;
if (ace.HasRel0)
{
ace.DoStep(ACEngine.Step.RelatedFields0, true);
}
if (ace.HasRel1)
{
ace.DoStep(ACEngine.Step.RelatedFields1, true);
}
if (ace.HasRel2)
{
ace.DoStep(ACEngine.Step.RelatedFields2, true);
}
if (ace.HasRel3)
{
ace.DoStep(ACEngine.Step.RelatedFields3, true);
}
if (ace.HasRel4)
{
ace.DoStep(ACEngine.Step.RelatedFields4, true);
}
if (ace.HasRel5)
{
ace.DoStep(ACEngine.Step.RelatedFields5, true);
}
if (ace.HasRel6)
{
ace.DoStep(ACEngine.Step.RelatedFields6, true);
}
if (ace.HasRel7)
{
ace.DoStep(ACEngine.Step.RelatedFields7, true);
}
if (ace.HasRel8)
{
ace.DoStep(ACEngine.Step.RelatedFields8, true);
}
if (ace.HasRel9)
{
ace.DoStep(ACEngine.Step.RelatedFields9, true);
}
if (ace.HasTimeline)
{
ace.DoStep(ACEngine.Step.Timeline, true);
}
if (ace.HasDoc & !SkipDoc)
{
docDB.DocumentRow dr = (docDB.DocumentRow)ace.relTables["Document0"][0].Row;
//if (TemplateCode != null) //only set the template if it is provided
// dr.templateCode = TemplateCode;
ace.DocumentDefaults(revId != 0);
// if (dr.DocContentRow == null)
//FM.GetDocMng().GetDocContent().Load(dr.DocRefId, dr.CurrentVersion);
Doc0 = dr.DocContentRow.ContentsAsText;
}
else
{
ace.FM.GetDocMng().DB.RejectChanges();
ace.relTables.Remove("Document0");
ace.NewActivity.SetDocIdNull();
}
if (ace.HasBilling)
{
ace.DoStep(ACEngine.Step.Billing, true);
}
}
/// <summary>
/// Moves a process to another file
/// </summary>
/// <param name="pr">process to move</param>
/// <param name="toFile">Target file</param>
private void Move(atriumDB.ProcessRow pr, int toFileId, atriumDB.ActivityRow splitOn)
{
FileManager toFM = myA.AtMng.GetFile(toFileId);
//need to check permissions on target file
if (!toFM.GetProcess().CanAdd(toFM.CurrentFile))
{
throw new AtriumException(Properties.Resources.YouNeedAddProcessPermissionOnTheDestinationFile);
}
CheckMove(pr);
//this needs to be here
myA.GetActivity().LoadByProcessId(pr.ProcessId);
//sort activities by thread
atriumDB.ActivityRow[] ars = (atriumDB.ActivityRow[])myA.DB.Activity.Select("processid=" + pr.ProcessId.ToString(), "ConversationIndex");
atriumDB.ProcessRow newPr = null;
int oldFileid = pr.FileId;
bool moveProc = false;
if (splitOn != null && ars.Length > 1 && ars[0].ActivityId != splitOn.ActivityId)
{
//create new process for split thread
newPr = (atriumDB.ProcessRow)Add(myA.CurrentFile);
newPr.Active = pr.Active;
//newPr.CurrentStep = pr.CurrentStep;
newPr.NameE = pr.NameE;
newPr.NameF = pr.NameF;
newPr.SeriesId = pr.SeriesId;
//newPr.Thread = pr.Thread;
}
else
{
pr.FileId = toFileId;
pr.Thread = pr.ProcessId.ToString();
moveProc = true;
foreach (atriumDB.ProcessContextRow pcr in pr.GetProcessContextRows())
{
pcr.FileId = toFileId;
}
}
//move all activties on process
foreach (atriumDB.ActivityRow par in pr.GetActivityRows())
{
if (splitOn == null || par.ConversationIndex.CompareTo(splitOn.ConversationIndex) >= 0)
{
myA.GetActivity()._Move(par, toFileId);
if (newPr != null)
{
par.ProcessId = newPr.ProcessId;
}
}
}
if (moveProc)
{
FileManager fmOld = myA.AtMng.GetFile(oldFileid);
atriumDB.ProcessRow prOld = fmOld.DB.Process.FindByProcessId(pr.ProcessId);
if (prOld != null)
{
prOld.Delete();
prOld.AcceptChanges();
}
}
}
internal atriumDB.ProcessRow[] FindAllProcess(atriumDB.ProcessRow pr1, int currentProcid)
{
return((atriumDB.ProcessRow[])myA.DB.Process.Select("(ProcessId=" + pr1.ProcessId.ToString() + " or Thread like '" + pr1.Thread + "-%') and processid<>" + currentProcid.ToString()));
}
