private PXFilterRow[] ReadFilters(int?filterId)
{
if (filterId == null)
{
return(null);
}
var filterCache = View.Graph.Caches[typeof(FilterRow)];
var res = new List <PXFilterRow>();
foreach (FilterRow row in PXSelect <FilterRow,
Where <FilterRow.filterID, Equal <Required <FilterRow.filterID> > > > .
Select(View.Graph, filterId))
{
var item = new PXFilterRow(row.DataField,
(PXCondition)row.Condition,
filterCache.GetValueExt <FilterRow.valueSt>(row.ValueSt),
filterCache.GetValueExt <FilterRow.valueSt2>(row.ValueSt2))
{
OpenBrackets = row.OpenBrackets ?? 0,
CloseBrackets = row.CloseBrackets ?? 0,
OrOperator = row.Operator == 1
};
res.Add(item);
}
return(res.ToArray());
}
private bool IsItemRuleTrue(IBqlTable item, EPAssignmentRule rule)
{
if (item is EPEmployee && rule.FieldName.Equals(typeof(EPEmployee.workgroupID).Name, StringComparison.InvariantCultureIgnoreCase))
{
return(IsEmployeeInWorkgroup((EPEmployee)item, rule));
}
currentItem = item;
Type viewType = BqlCommand.Compose(typeof(Select <>), item.GetType());
PXView itemView = new PXView(this, false, BqlCommand.CreateInstance(viewType),
(PXSelectDelegate)getItemRecord);
if (rule.Condition == null)
{
return(false);
}
PXFilterRow filter = new PXFilterRow(
rule.FieldName,
(PXCondition)rule.Condition.Value,
GetFieldValue(item, rule.FieldName, rule.FieldValue),
null);
int startRow = 0;
int totalRows = 0;
List <object> result = itemView.Select(null, null, null, null, null, new PXFilterRow[] { filter }, ref startRow, 1, ref totalRows);
return(result.Count > 0);
}
private PXFilterRow CheckEmployeeInWorkgroup(EPEmployee employee, EPRuleBaseCondition rule)
{
var filter = new PXFilterRow()
{
DataField = typeof(EPCompanyTree.description).Name,
Condition = (PXCondition)rule.Condition.Value,
Value = rule.Value,
Value2 = null
};
PXSelectBase <EPCompanyTree> select = new PXSelectJoin <EPCompanyTree,
InnerJoin <EPCompanyTreeMember, On <EPCompanyTree.workGroupID, Equal <EPCompanyTreeMember.workGroupID> > >,
Where <EPCompanyTreeMember.userID, Equal <Required <EPCompanyTreeMember.userID> >,
And <EPCompanyTreeMember.active, Equal <True> > > >(this);
int startRow = 0;
int totalRows = 0;
var result = select.View.Select(null, new object[] { employee.UserID }, null, null, null, new PXFilterRow[] { filter }, ref startRow, 1, ref totalRows);
return(new PXFilterRow()
{
DataField = typeof(EPEmployee).Name + "__" + typeof(EPEmployee.bAccountID).Name,
Condition = result.Count > 0
? PXCondition.ISNOTNULL
: PXCondition.ISNULL,
Value = null,
Value2 = null
});
}
private IEnumerable GenerateFilters(Table item, List <EPRuleBaseCondition> conditions)
{
foreach (var condition in conditions)
{
Type entityType = GraphHelper.GetType(condition.Entity);
PXFilterRow filter;
if (condition.Entity.Equals(typeof(EPEmployee).FullName, StringComparison.InvariantCultureIgnoreCase) &&
condition.FieldName.Equals(typeof(EPEmployee.workgroupID).Name, StringComparison.InvariantCultureIgnoreCase))
{
var employee = _Graph.Caches[entityType].Current;
filter = CheckEmployeeInWorkgroup((EPEmployee)employee, condition);
}
else
{
filter = new PXFilterRow()
{
DataField = entityType.Name + "__" + condition.FieldName,
Condition = (PXCondition)(condition.Condition ?? 0),
Value = condition.IsField == true
? EvaluateField(item, condition.Value)
: condition.Value,
Value2 = condition.Value2
};
}
object val = filter.Value;
var cache = _Graph.Caches[entityType];
try
{
try
{
cache.RaiseFieldUpdating(condition.FieldName, null, ref val);
}
finally
{
filter.Value = val;
}
}
catch
{
filter.UseExt = true;
}
if (condition.OpenBrackets != null)
{
filter.OpenBrackets = condition.OpenBrackets.Value;
}
if (condition.CloseBrackets != null)
{
filter.CloseBrackets = condition.CloseBrackets.Value;
}
filter.OrOperator = condition.Operator == 1;
yield return(filter);
}
}
private bool IsAttributeRuleTrue(object item, EPAssignmentRule rule)
{
string field = rule.FieldName.Substring(0, rule.FieldName.Length - "_Attribute".Length - 1);
CSAttribute attribute = PXSelectReadonly <CSAttribute> .Search <CSAttribute.attributeID>(this, field);
if (attribute == null || rule.Condition == null)
{
//Field Name is not a valid question.
return(false);
}
var noteId = new EntityHelper(_Graph).GetEntityNoteID(item);
CSAnswers ans = PXSelect <CSAnswers,
Where <CSAnswers.refNoteID, Equal <Required <CSAnswers.refNoteID> >,
And <CSAnswers.attributeID, Equal <Required <CSAnswers.attributeID> > > > > .Select(_Graph ?? this, noteId, field);
if (ans == null)
{
//Answer for the given question doesnot exist.
switch (rule.Condition.Value)
{
case (int)PXCondition.ISNULL:
return(true);
case (int)PXCondition.ISNOTNULL:
return(false);
case (int)PXCondition.EQ:
return(string.IsNullOrEmpty(rule.FieldValue));
case (int)PXCondition.NE:
return(!string.IsNullOrEmpty(rule.FieldValue));
}
return(false);
}
this.currentAttribute = ans;
PXFilterRow filter = new PXFilterRow(typeof(CSAnswers.value).Name, (PXCondition)rule.Condition.Value, rule.FieldValue, null);
int startRow = 0;
int totalRows = 0;
List <object> result = attributeView.Select(null, null, null, null, null, new PXFilterRow[] { filter }, ref startRow, 1, ref totalRows);
return(result.Count > 0);
}
private List <PXFilterRow> InitFilters(object refNoteID, int?filterId)
{
var filters = new List <PXFilterRow>();
if (filterId != null)
{
var filterCache = View.Graph.Caches[typeof(FilterRow)];
foreach (FilterRow row in PXSelect <FilterRow,
Where <FilterRow.filterID, Equal <Required <FilterRow.filterID> > > > .
Select(View.Graph, filterId))
{
var item = new PXFilterRow(row.DataField,
(PXCondition)row.Condition,
filterCache.GetValueExt <FilterRow.valueSt>(row.ValueSt),
filterCache.GetValueExt <FilterRow.valueSt2>(row.ValueSt2))
{
OpenBrackets = row.OpenBrackets ?? 0,
CloseBrackets = row.CloseBrackets ?? 0,
OrOperator = row.Operator == 1
};
filters.Add(item);
}
if (filters.Count > 0)
{
filters[0].OpenBrackets += 1;
filters[filters.Count - 1].CloseBrackets += 1;
filters[filters.Count - 1].OrOperator = false;
}
}
filters.Add(new PXFilterRow()
{
DataField = typeof(CRActivity.refNoteID).Name,
Condition = PXCondition.EQ,
Value = refNoteID
});
return(filters);
}
private bool IsEmployeeInWorkgroup(EPEmployee employee, EPAssignmentRule rule)
{
PXFilterRow filter = new PXFilterRow(
typeof(EPCompanyTree.description).Name,
(PXCondition)rule.Condition.Value,
rule.FieldValue,
null);
PXSelectBase <EPCompanyTree> select = new PXSelectJoin <EPCompanyTree,
InnerJoin <EPCompanyTreeMember, On <EPCompanyTree.workGroupID, Equal <EPCompanyTreeMember.workGroupID> > >,
Where <EPCompanyTreeMember.userID, Equal <Required <EPCompanyTreeMember.userID> >,
And <EPCompanyTreeMember.active, Equal <True> > > >(this);
int startRow = 0;
int totalRows = 0;
List <object> result =
select.View.Select(null, new object[] { employee.UserID }, null, null, null, new PXFilterRow[] { filter }, ref startRow, 1, ref totalRows);
//select.SelectSingle(employee.UserID, workgroupID);
return(result.Count > 0);
}
private int RefreshTotal(string screenID, string viewName, out int read, out int unread)
{
read = -1;
unread = -1;
string actualScreenID = PXContext.GetScreenID();
using (new PXPreserveScope())
{
try
{
PXContext.SetScreenID(screenID);
PXGraph graph = CreateGraph(screenID);
if (graph == null || graph.PrimaryView == null)
{
return(-1);
}
if (viewName == null)
{
viewName = graph.PrimaryView;
}
PXView view = graph.Views[viewName];
PXView viewFilters;
PXFilterRow[] filters = null;
if (graph.Views.TryGetValue(viewName + PXFilterableAttribute.FilterHeaderName, out viewFilters))
{
foreach (FilterHeader fHeader in viewFilters.SelectMulti())
{
if (fHeader.IsDefault == true)
{
int s = 0;
int t = 0;
IList f = graph.ExecuteSelect(viewName + PXFilterableAttribute.FilterRowName, new object[] { fHeader.FilterID },
null, null, null,
new PXFilterRow[] { new PXFilterRow(typeof(FilterRow.isUsed).Name, PXCondition.EQ, true, null) }, ref s, 0, ref t) as IList;
if (f != null && f.Count > 0)
{
filters = new PXFilterRow[f.Count];
PXCache frc = graph.Caches[typeof(FilterRow)];
for (int i = 0; i < f.Count; i++)
{
FilterRow r = (FilterRow)f[i];
var filter = new PXFilterRow(r.DataField, (PXCondition)r.Condition, frc.GetValueExt(r, "ValueSt"), frc.GetValueExt(r, "ValueSt2"));
if (r.OpenBrackets != null)
{
filter.OpenBrackets = r.OpenBrackets.Value;
}
if (r.CloseBrackets != null)
{
filter.CloseBrackets = r.CloseBrackets.Value;
}
filter.OrOperator = r.Operator == 1;
filters[i] = filter;
}
}
break;
}
}
}
int start = 0;
int total = 0;
read = -1;
unread = -1;
using (var scope = new PXFieldScope(view, typeof(CRActivity.noteID), typeof(EPView.status)))
foreach (object record in view.Select(null, null, null, null, null, filters, ref start, 101, ref total))
{
PXResult result = record as PXResult;
if (result != null)
{
EPView v = result.GetItem <EPView>();
if (v != null)
{
if (v.Status != null && v.Status == EPViewStatusAttribute.VIEWED)
{
read += 1;
}
else
{
unread += 1;
}
}
}
}
if (read != -1 || unread != -1)
{
read += 1;
unread += 1;
}
return(total);
}
finally
{
PXContext.SetScreenID(actualScreenID);
}
}
}
public override List<object> Select(object[] currents, object[] parameters, object[] searches, string[] sortcolumns, bool[] descendings, PXFilterRow[] filters, ref int startRow, int maximumRows, ref int totalRows)
{
return _Records;
}
