private bool IsEmployeeInWorkgroup(EPEmployee employee, EPAssignmentRule rule)
{
object workgroupID = null;
PXCache sourceCache = this.Caches[typeof(EPEmployee)];
object copy = sourceCache.CreateCopy(employee);
if (rule.FieldValue != null)
{
sourceCache.SetValueExt(copy, rule.FieldName, rule.FieldValue);
}
else
{
object newValue;
sourceCache.RaiseFieldDefaulting(rule.FieldName, copy, out newValue);
sourceCache.SetValue(copy, rule.FieldName, newValue);
}
workgroupID = sourceCache.GetValue(copy, rule.FieldName);
PXSelectBase <EPCompanyTreeMember> select = new PXSelect <EPCompanyTreeMember,
Where <EPCompanyTreeMember.userID, Equal <Required <EPCompanyTreeMember.userID> >,
And <EPCompanyTreeMember.workGroupID, Equal <Required <EPCompanyTreeMember.workGroupID> >,
And <EPCompanyTreeMember.active, Equal <True> > > > >(this);
EPCompanyTreeMember member = select.SelectSingle(employee.UserID, workgroupID);
return(member != null);
}
public override object Evaluate(PXCache cache, object item, Dictionary <Type, object> pars)
{
string classID = (string)pars[typeof(ClassID)];
CRContactClass cls = PXSelect <CRContactClass, Where <CRContactClass.classID, Equal <Required <CRContactClass.classID> > > > .Select(cache.Graph, classID);
if (cls == null)
{
return(null);
}
PXSelectBase <EPCompanyTreeMember> cmd = new PXSelectJoin <EPCompanyTreeMember,
InnerJoin <EPCompanyTreeH, On <EPCompanyTreeMember.workGroupID, Equal <EPCompanyTreeH.workGroupID> > >,
Where <EPCompanyTreeMember.userID, Equal <Required <EPCompanyTreeMember.userID> > > >(cache.Graph);
if (cls.DefaultWorkgroupID != null && cls.OwnerIsCreatedUser != true)
{
return(cls.DefaultWorkgroupID);
}
else if (cls.DefaultWorkgroupID != null && cls.OwnerIsCreatedUser == true)
{
cmd.WhereAnd <Where <EPCompanyTreeH.parentWGID, Equal <Required <EPCompanyTreeH.parentWGID> > > >();
EPCompanyTreeMember m = cmd.SelectSingle(cache.Graph.Accessinfo.UserID, cls.DefaultWorkgroupID);
return(m.With(_ => _.WorkGroupID));
}
else if (cls.DefaultWorkgroupID == null && cls.OwnerIsCreatedUser == true && cls.DefaultOwnerWorkgroup == true)
{
EPCompanyTreeMember m = cmd.SelectSingle(cache.Graph.Accessinfo.UserID);
return(m.With(_ => _.WorkGroupID));
}
else
{
return(null);
}
}
public override void Verify(PXCache cache, object item, List <object> pars, ref bool?result, ref object value)
{
string classID = (string)Calculate <ClassID>(cache, item);
CRContactClass cls = PXSelect <CRContactClass, Where <CRContactClass.classID, Equal <Required <CRContactClass.classID> > > > .Select(cache.Graph, classID);
if (cls == null)
{
return;
}
PXSelectBase <EPCompanyTreeMember> cmd = new PXSelectJoin <EPCompanyTreeMember,
InnerJoin <EPCompanyTreeH, On <EPCompanyTreeMember.workGroupID, Equal <EPCompanyTreeH.workGroupID> > >,
Where <EPCompanyTreeMember.userID, Equal <Required <EPCompanyTreeMember.userID> > > >(cache.Graph);
if (cls.DefaultWorkgroupID != null && cls.OwnerIsCreatedUser != true)
{
value = cls.DefaultWorkgroupID;
}
else if (cls.DefaultWorkgroupID != null && cls.OwnerIsCreatedUser == true)
{
cmd.WhereAnd <Where <EPCompanyTreeH.parentWGID, Equal <Required <EPCompanyTreeH.parentWGID> > > >();
EPCompanyTreeMember m = cmd.SelectSingle(cache.Graph.Accessinfo.UserID, cls.DefaultWorkgroupID);
value = m.With(_ => _.WorkGroupID);
}
else if (cls.DefaultWorkgroupID == null && cls.OwnerIsCreatedUser == true && cls.DefaultOwnerWorkgroup == true)
{
EPCompanyTreeMember m = cmd.SelectSingle(cache.Graph.Accessinfo.UserID);
value = m.With(_ => _.WorkGroupID);
}
else
{
value = null;
}
}
protected virtual void EPCompanyTreeMember_RowDeleted(PXCache cache, PXRowDeletedEventArgs e)
{
EPCompanyTreeMember row = e.Row as EPCompanyTreeMember;
if (row == null || row.WorkGroupID == null)
{
return;
}
Items.Cache.IsDirty = true;
}
protected virtual void EPCompanyTreeMember_WorkGroupID_FieldDefaulting(PXCache sender, PXFieldDefaultingEventArgs e)
{
EPCompanyTreeMember row = e.Row as EPCompanyTreeMember;
if (row == null)
{
return;
}
e.NewValue = this.CurrentSelected.WorkGroupID ?? 0;
e.Cancel = true;
}
protected virtual IEnumerable members()
{
Caches[typeof(EPCompanyTreeMember)].AllowInsert = Folders.Current.ParentWGID != null && Folders.Current != null;
Caches[typeof(EPCompanyTreeMember)].AllowDelete = Folders.Current.ParentWGID != null;
Caches[typeof(EPCompanyTreeMember)].AllowUpdate = Folders.Current.ParentWGID != null;
if (Folders.Current != null)
{
foreach (var res in
PXSelectJoin <EPCompanyTreeMember,
LeftJoin <EPEmployee, On <EPEmployee.userID, Equal <EPCompanyTreeMember.userID> >,
LeftJoin <EPEmployeePosition, On <EPEmployeePosition.employeeID, Equal <EPEmployee.bAccountID>,
And <EPEmployeePosition.isActive, Equal <True> > >,
LeftJoin <Users, On <Users.pKID, Equal <EPCompanyTreeMember.userID> > > > >,
Where <EPCompanyTreeMember.workGroupID, Equal <Required <EPCompanyTreeMember.workGroupID> > > > .Select(this, Folders.Current.WorkGroupID))
{
EPCompanyTreeMember _companyTreeMember = res[typeof(EPCompanyTreeMember)] as EPCompanyTreeMember;
EPEmployee _employeer = res[typeof(EPEmployee)] as EPEmployee;
Users _user = res[typeof(Users)] as Users;
EPEmployeePosition _ePEmployeeposision = res[typeof(EPEmployeePosition)] as EPEmployeePosition;
if (_companyTreeMember.UserID != null)
{
if (_user == null)
{
this.Caches[typeof(EPCompanyTreeMember)].RaiseExceptionHandling <EPCompanyTreeMember.userID>(_companyTreeMember, null, new PXSetPropertyException(PX.Objects.EP.Messages.UserDeleted, PXErrorLevel.Warning));
}
else if (_user.State != Users.state.Active && _user.State != Users.state.Online)
{
this.Caches[typeof(EPCompanyTreeMember)].RaiseExceptionHandling <EPCompanyTreeMember.userID>(_companyTreeMember, null, new PXSetPropertyException(PX.Objects.EP.Messages.UserIsInactive, PXErrorLevel.Warning));
}
if (_employeer == null)
{
this.Caches[typeof(EPEmployee)].RaiseExceptionHandling <EPEmployee.acctCD>(_employeer, null, new PXSetPropertyException(PX.Objects.EP.Messages.EmployeeDeleted, PXErrorLevel.Warning));
}
else if (_employeer.Status == null)
{
this.Caches[typeof(EPEmployee)].RaiseExceptionHandling <EPEmployee.acctCD>(_employeer, null, new PXSetPropertyException(PX.Objects.EP.Messages.Employeedeattach, PXErrorLevel.Warning));
}
else if (_employeer.Status != BAccount.status.Active)
{
this.Caches[typeof(EPEmployee)].RaiseExceptionHandling <EPEmployee.acctCD>(_employeer, null, new PXSetPropertyException(PX.Objects.EP.Messages.EmployeeIsInactive, PXErrorLevel.Warning));
}
}
yield return(new PXResult <EPCompanyTreeMember, EPEmployee, EPEmployeePosition>(_companyTreeMember, _employeer, _ePEmployeeposision));
}
}
}
protected virtual void EPCompanyTreeMember_UserID_FieldVerifying(PXCache cache, PXFieldVerifyingEventArgs e)
{
EPCompanyTreeMember doc = e.Row as EPCompanyTreeMember;
if (doc == null)
{
return;
}
Guid pkid = new Guid();
if (!Guid.TryParse(e.NewValue.ToString(), out pkid))
{
throw new PXSetPropertyException(PX.Objects.EP.Messages.UserCannotBeFound);
}
}
protected virtual void EPCompanyTreeMember_Active_FieldUpdated(PXCache sender, PXFieldUpdatedEventArgs e)
{
EPCompanyTreeMember row = (EPCompanyTreeMember)e.Row;
if (row == null)
{
return;
}
string res = "";
foreach (EPAssignmentMap map in PXSelectJoin <EPAssignmentMap,
InnerJoin <EPAssignmentRoute, On <EPAssignmentRoute.assignmentMapID, Equal <EPAssignmentMap.assignmentMapID> > >,
Where <EPAssignmentRoute.ownerID, Equal <Required <EPAssignmentRoute.ownerID> > > > .
Select(this, row.UserID))
{
if (map == null)
{
throw new PXException(Objects.EP.Messages.WorkgroupIsInUse);
}
string MapType = "";
if (map.MapType == EPMapType.Assignment)
{
MapType = Objects.EP.Messages.Assignment;
}
else
{
MapType = Objects.EP.Messages.Approval;
}
EPEmployee Employee = PXSelect <EPEmployee,
Where <EPEmployee.userID, Equal <Required <EPEmployee.userID> > > > .Select(this, row.UserID);
if (Employee != null)
{
res = res + string.Format(Objects.EP.Messages.EmployeeIsInUseAtAssignmentMapPart1, Employee.AcctName, MapType, map.Name) + "\n";
}
}
if (!String.IsNullOrEmpty(res))
{
sender.RaiseExceptionHandling <EPCompanyTreeMember.userID>(row, row.UserID, new PXSetPropertyException(res + "\n" + Objects.EP.Messages.EmployeeIsInUseAtAssignmentMapPart2, PXErrorLevel.RowWarning));
}
}
private void UpdateOwner(object row)
{
EPCompanyTreeMember curr = (EPCompanyTreeMember)row;
if (curr.IsOwner == true)
{
foreach (EPCompanyTreeMember item in Members.Select(curr.WorkGroupID))
{
if (item.IsOwner != true || item.UserID == curr.UserID)
{
continue;
}
item.IsOwner = false;
Members.Cache.Update(item);
}
}
Members.View.RequestRefresh();
}
private void FillOwnerWorkgroup(ref Guid?OwnerID, ref int?WorkgroupID)
{
if (WorkgroupID != null && OwnerID != null)
{
EPCompanyTreeMember member =
PXSelectJoin <
EPCompanyTreeMember,
InnerJoin <EPCompanyTreeH,
On <EPCompanyTreeH.workGroupID, Equal <EPCompanyTreeMember.workGroupID> >,
InnerJoin <EPEmployee,
On <EPEmployee.userID, Equal <EPCompanyTreeMember.userID> > > >,
Where <EPCompanyTreeH.parentWGID, Equal <Required <EPCompanyTreeH.parentWGID> >,
And <EPCompanyTreeMember.userID, Equal <Required <EPCompanyTreeMember.userID> > > > >
.SelectWindowed(this, 0, 1, WorkgroupID, OwnerID);
if (member != null)
{
WorkgroupID = member.WorkGroupID;
}
else
{
OwnerID = null;
}
}
if (WorkgroupID != null && OwnerID == null)
{
EPCompanyTreeMember owner =
PXSelectJoin <
EPCompanyTreeMember,
InnerJoin <EPEmployee,
On <EPEmployee.userID, Equal <EPCompanyTreeMember.userID> > >,
Where <EPCompanyTreeMember.workGroupID, Equal <Required <EPCompanyTreeMember.workGroupID> >,
And <EPCompanyTreeMember.isOwner, Equal <boolTrue> > > >
.Select(this, WorkgroupID);
if (owner != null)
{
OwnerID = owner.UserID;
}
}
}
private IEnumerable <ApproveInfo> GetEmployeesByFilter(Table item, EPRule rule, List <EPRuleBaseCondition> conditions)
{
Type resultViewType = typeof(Select5 <
EPEmployee,
LeftJoin <Address,
On <Address.addressID, Equal <EPEmployee.defAddressID> >,
LeftJoin <Contact,
On <Contact.contactID, Equal <EPEmployee.defContactID> >,
LeftJoin <EPCompanyTreeMember,
On <EPCompanyTreeMember.userID, Equal <EPEmployee.userID> > > > >,
Aggregate <GroupBy <EPEmployee.bAccountID> > >);
PXView itemView = new PXView(this, false, BqlCommand.CreateInstance(resultViewType));
PXFilterRow[] filters = GenerateFilters(item, conditions).ToArray <PXFilterRow>();
int startRow = 0;
int totalRows = 0;
using (new PXFieldScope(itemView))
{
IEnumerable <PXResult <EPEmployee, Address, Contact, EPCompanyTreeMember> > resultset = itemView
.Select(null, null, null, null, null, filters, ref startRow, 0, ref totalRows)
.Select(_ => (PXResult <EPEmployee, Address, Contact, EPCompanyTreeMember>)_);
foreach (PXResult <EPEmployee, Address, Contact, EPCompanyTreeMember> res in resultset)
{
EPEmployee employee = res;
EPCompanyTreeMember treeMember = res;
yield return(new ApproveInfo()
{
OwnerID = employee.UserID,
WorkgroupID = rule.WorkgroupID,
RuleID = rule.RuleID,
StepID = rule.StepID,
WaitTime = rule.WaitTime
});
}
}
}
protected virtual IEnumerable members(
[PXInt]
int?WorkGroupID)
{
this.Members.Cache.AllowInsert = (WorkGroupID != null);
CurrentSelected.WorkGroupID = WorkGroupID;
foreach (PXResult <EPCompanyTreeMember, EPEmployee, Users> res in PXSelectJoin <EPCompanyTreeMember,
LeftJoin <EPEmployee, On <EPEmployee.userID, Equal <EPCompanyTreeMember.userID> >,
LeftJoin <Users, On <Users.pKID, Equal <EPCompanyTreeMember.userID> > > >,
Where <EPCompanyTreeMember.workGroupID, Equal <Required <EPCompanyTreeMember.workGroupID> > > > .Select(this, WorkGroupID))
{
EPCompanyTreeMember member = res;
EPEmployee emp = res;
Users user = res;
if (string.IsNullOrEmpty(emp.AcctCD))
{
Members.Cache.RaiseExceptionHandling <EPCompanyTreeMember.userID>(member, null, new PXSetPropertyException(PX.Objects.EP.Messages.UserWithoutEmployee, PXErrorLevel.RowWarning, user.Username));
}
yield return(new PXResult <EPCompanyTreeMember, EPEmployee>(member, emp));
}
}
private bool ProcessLevel(Table item, int?assignmentMap, PXResultset <EPAssignmentRoute> routes)
{
PXSelectReadonly <EPAssignmentRoute,
Where <EPAssignmentRoute.assignmentMapID, Equal <Required <EPAssignmentMap.assignmentMapID> >,
And <EPAssignmentRoute.parent, Equal <Required <EPAssignmentRoute.assignmentRouteID> > > >, OrderBy <Asc <EPAssignmentRoute.sequence> > > rs = new PXSelectReadonly <EPAssignmentRoute, Where <EPAssignmentRoute.assignmentMapID, Equal <Required <EPAssignmentMap.assignmentMapID> >, And <EPAssignmentRoute.parent, Equal <Required <EPAssignmentRoute.assignmentRouteID> > > >, OrderBy <Asc <EPAssignmentRoute.sequence> > >(this);
foreach (EPAssignmentRoute route in routes)
{
if (route.AssignmentRouteID == null)
{
continue;
}
path.Add(route.AssignmentRouteID.Value);
if (IsPassed(item, route))
{
if (route.WorkgroupID != null || route.OwnerID != null || route.OwnerSource != null)
{
item.WorkgroupID = route.WorkgroupID;
item.OwnerID = null;
if (route.OwnerSource != null)
{
PXGraph graph = processGraph;
PXCache cache = graph.Caches[typeof(Table)];
string code = PXTemplateContentParser.Instance.Process(route.OwnerSource,
graph,
typeof(Table),
null
);
EPEmployee emp =
PXSelect <EPEmployee, Where <EPEmployee.acctCD, Equal <Required <EPEmployee.acctCD> > > >
.SelectWindowed(this, 0, 1, code);
item.OwnerID = emp != null ? emp.UserID : GUID.CreateGuid(code);
}
if (item.OwnerID == null)
{
item.OwnerID = route.OwnerID;
}
if (route.UseWorkgroupByOwner == true && item.WorkgroupID != null && item.OwnerID != null)
{
EPCompanyTreeMember member =
PXSelectJoin <EPCompanyTreeMember,
InnerJoin <EPCompanyTreeH, On <EPCompanyTreeH.workGroupID, Equal <EPCompanyTreeMember.workGroupID> >,
InnerJoin <EPEmployee, On <EPEmployee.userID, Equal <EPCompanyTreeMember.userID> > > >,
Where <EPCompanyTreeH.parentWGID, Equal <Required <EPCompanyTreeH.parentWGID> >,
And <EPCompanyTreeMember.userID, Equal <Required <EPCompanyTreeMember.userID> > > > >
.SelectWindowed(this, 0, 1, item.WorkgroupID, item.OwnerID);
if (member != null)
{
item.WorkgroupID = member.WorkGroupID;
}
}
if (item.WorkgroupID != null && item.OwnerID == null)
{
EPCompanyTreeMember owner = PXSelectJoin <EPCompanyTreeMember,
InnerJoin <EPEmployee, On <EPEmployee.userID, Equal <EPCompanyTreeMember.userID> > >,
Where <EPCompanyTreeMember.workGroupID, Equal <Required <EPCompanyTreeMember.workGroupID> >,
And <EPCompanyTreeMember.isOwner, Equal <boolTrue> > > > .Select(this, item.WorkgroupID);
if (owner != null)
{
item.OwnerID = owner.UserID;
}
}
PXTrace.WriteInformation(Messages.ProcessRouteSequence, route.Sequence);
return(true);
}
if (route.RouteID != null)
{
return(!path.Contains(route.RouteID.Value) &&
ProcessLevel(item, assignmentMap, PXSelectReadonly <EPAssignmentRoute>
.Search <EPAssignmentRoute.assignmentRouteID>(this, route.RouteID)));
}
PXResultset <EPAssignmentRoute> result = rs.Select(assignmentMap, route.AssignmentRouteID);
return(ProcessLevel(item, assignmentMap, result));
}
}
return(false);
}
