public CriteriaOperator Visit(InOperator theOperator)
{
UpdatePropertyName(theOperator.LeftOperand);
ToValue(theOperator.Operands);
return(theOperator);
}
private List<ITreeNode> GetAllChildTreeNodes(InOperator inOperator, string propertyName) {
var allTreeNodes = new List<ITreeNode>();
XPCollection treeNodes = GetTreeNodes(propertyName, inOperator);
if (treeNodes != null)
allTreeNodes = treeNodes.Cast<ITreeNode>().ToList().GetAllTreeNodes();
return allTreeNodes.Distinct().ToList();
}
public void FixInvokedBussinessObjects(Session session, XPCollection <BusinessObject> invokedBussinessObjects)
{
if (invokedBussinessObjects == null || invokedBussinessObjects.Count == 0)
{
return;
}
CriteriaOperator criteria_0 = CriteriaOperator.Parse("not(IsNull(FinancialTransactionDimId))");
CriteriaOperator criteria_1 = new InOperator("FinancialTransactionDimId.RefId", invokedBussinessObjects.Select(i => i.RefId));
CriteriaOperator criteria_2 = new BinaryOperator("RowStatus", 0, BinaryOperatorType.Greater);
CriteriaOperator criteria = new GroupOperator(GroupOperatorType.And, criteria_0, criteria_1, criteria_2);
CorrespondFinancialAccountDim defaultCorrespondAccDim = CorrespondFinancialAccountDim.GetDefault(session, CorrespondFinancialAccountDimEnum.NAAN_DEFAULT);
XPCollection <FinancialActualPriceDetail> neededToBeFixList = new XPCollection <FinancialActualPriceDetail>(session, criteria);
FinancialActualPriceSummary_Fact fact = null;
if (neededToBeFixList != null && neededToBeFixList.Count > 0)
{
foreach (FinancialActualPriceDetail detail in neededToBeFixList)
{
fact = detail.FinancialActualPriceSummary_FactId;
detail.RowStatus = Utility.Constant.ROWSTATUS_DELETED;
detail.Save();
fact.Save();
}
}
}
public byte[] ExportObject(string KeyMemberName, string ReportDisplayName)
{
ArrayList keys = new ArrayList
{
_currentObject.Session.GetKeyValue(_currentObject)
};
using (MemoryStream stream = new MemoryStream()) {
CriteriaOperator criteria = new InOperator(KeyMemberName, keys);
XtraReport report = Report(ReportDisplayName);
if (_reportDataSourceHelper != null)
{
_reportDataSourceHelper.SetupReport(report, null, criteria, true, null, true);
}
else
{
_reportV2DataSourceHelper.SetupReport(report, null, criteria, true, null, true);
}
report.ExportToPdf(stream, new PdfExportOptions {
ShowPrintDialogOnOpen = false
});
stream.Seek(0, SeekOrigin.Begin);
return(stream.ToArray());
}
}
WebDataSource WebDataSource(Type resourceType, ListView filterView)
{
var criteria = new InOperator(filterView.ObjectTypeInfo.KeyMember.Name,
filterView.SelectedObjects.Cast <object>().Select(o => ObjectSpace.GetKeyValue(o)));
return(new WebDataSource(ObjectSpace, Application.TypesInfo.FindTypeInfo(resourceType), ObjectSpace.CreateCollection(resourceType, criteria)));
}
public object Visit(InOperator theOperator)
{
UpdatePropertyName(theOperator.LeftOperand);
ToValue(theOperator.Operands);
return(theOperator);
}
private void HistoryData()
{
var projectList = DynamicDataServiceContext.GetObjects("Project", new BinaryOperator("ManagerId", AuthorizationManager.CurrentUserId), null);
CriteriaOperator filter = new BinaryOperator("OwnerId", AuthorizationManager.CurrentUserId);
if (projectList != null && projectList.Count > 0)
{
List <object> projectIds = new List <object>();
foreach (var projectItem in projectList)
{
projectIds.Add(projectItem.AsDyanmic().ProjectId);
}
filter = new InOperator("ProjectId", projectIds);
}
var managerExtraColumns = new Dictionary <string, string>
{
{ "ProjectName", "Project == null?null:Project.Name" },
{ "IterationName", "ProjectIteration == null?null:ProjectIteration.Name" },
{ "TaskTimeHistories", "TaskTimeHistories" }
};
var projectTasks = DynamicDataServiceContext.GetObjects("ProjectTask", filter, managerExtraColumns);
foreach (var taskItem in projectTasks)
{
var taskDyanmic = taskItem.AsDyanmic();
IList taskTimeHistoryList = taskDyanmic.TaskTimeHistories as IList;
AddItems(taskTimeHistoryList, taskDyanmic);
}
}
public static bool IsExistXpoObject <T>(Session dbSession, string fieldName, object value, BinaryOperatorType type, params short[] rowStatuses)
{
Session session = null;
try
{
CriteriaOperator rowStatusCriteria = null;
if (rowStatuses.Length > 0)
{
rowStatusCriteria = new InOperator("RowStatus", rowStatuses.ToList());
}
CriteriaOperator fieldCriteria = new BinaryOperator(fieldName, value, type);
CriteriaOperator criteria = CriteriaOperator.And(fieldCriteria, rowStatusCriteria);
session = dbSession;
var result = session.GetObjects(session.GetClassInfo(typeof(T)), criteria, null, 0, false, true);
if (result != null && result.Count > 0)
{
return(true);
}
else
{
return(false);
}
}
catch (Exception)
{
throw;
}
return(false);
}
public void UpdateCollectionCriteria(List <string> list)
{
string propertyName = PersistentBase.Fields.ObjectType.TypeName.PropertyName;
var inOperator = new InOperator(propertyName, GetPermissionTypeNames());
View.CollectionSource.Criteria["CustomPermisssions"] = inOperator;
}
private CriteriaOperator GetPredicate()
{
CriteriaOperator filter = null;
if (TechnicianIds.Count > 0)
{
filter &= new InOperator("TechnicianId", TechnicianIds);
}
if (OwnerIds.Count > 0)
{
filter &= new InOperator("OwnerId", OwnerIds);
}
if (statusItem.EditValue != null && statusItem.EditValue.ToString() != "-1")
{
filter &= new BinaryOperator("StatusCode", statusItem.EditValue);
}
if (DataRangeValue != null)
{
DateTime startDate, endDate;
GetDataRange(DataRangeValue, out startDate, out endDate);
filter &= new BinaryOperator("CreatedOn", endDate, BinaryOperatorType.LessOrEqual);
GroupOperator nestedGroup = new GroupOperator(new OperandProperty("ClosedTime").IsNotNull(),
new BinaryOperator("ClosedTime", startDate, BinaryOperatorType.GreaterOrEqual),
new BinaryOperator("ClosedTime", endDate, BinaryOperatorType.LessOrEqual));
nestedGroup.OperatorType = GroupOperatorType.And;
GroupOperator group = new GroupOperator(new UnaryOperator(UnaryOperatorType.IsNull, "ClosedTime"), nestedGroup);
group.OperatorType = GroupOperatorType.Or;
filter &= group;
}
return(filter);
}
private XPCollection GetTreeNodes(string propertyName, InOperator inOperator) {
Type memberType = View.ObjectTypeInfo.FindMember(propertyName).MemberType;
string keyName = XafTypesInfo.Instance.FindTypeInfo(memberType).KeyMember.Name;
InOperator clone = inOperator.Clone();
((OperandProperty)clone.LeftOperand).PropertyName = keyName;
return new XPCollection(((ObjectSpace)ObjectSpace).Session, memberType, clone);
}
private XPCollection GetTreeNodes(string propertyName, InOperator inOperator)
{
Type memberType = View.ObjectTypeInfo.FindMember(propertyName).MemberType;
string keyName = XafTypesInfo.Instance.FindTypeInfo(memberType).KeyMember.Name;
InOperator clone = inOperator.Clone();
((OperandProperty)clone.LeftOperand).PropertyName = keyName;
return(new XPCollection(((XPObjectSpace)ObjectSpace).Session, memberType, clone));
}
protected void FilterOutNonSelectedRows(ASPxGridView gridView, bool selectedRows)
{
CriteriaOperator selectionCriteria = new InOperator(gridView.KeyFieldName, gridView.GetSelectedFieldValues(gridView.KeyFieldName));
if (!selectedRows)
{
selectionCriteria = selectionCriteria.Not();
}
gridView.FilterExpression = (GroupOperator.Combine(GroupOperatorType.And, selectionCriteria)).ToString();
}
private void DeleteObjects(XPObjectSpace objSpace, IList objs, XPClassInfo classInfo)
{
var inOp = new InOperator(
objSpace.GetKeyPropertyName(classInfo.ClassType),
objs);
var deleter = new BatchDeleter(objSpace);
deleter.Delete(classInfo, inOp);
}
protected override void OnBeforeCreateDocument(DashboardInteractionController interactionController, DashboardReportViewItem dashboardReportViewItem, ListViewFilteringArgs listViewFilteringArgs)
{
base.OnBeforeCreateDocument(interactionController, dashboardReportViewItem, listViewFilteringArgs);
var reportDataTypeMember = ((IModelDashboardViewFilterReport)((IModelDashboardViewItemEx)dashboardReportViewItem.Model).Filter).ReportDataTypeMember;
var report = (XafReport)dashboardReportViewItem.Report;
var propertyName = PropertyName(report, reportDataTypeMember);
var criteria = new InOperator(propertyName, interactionController.Getkeys(listViewFilteringArgs.DataSourceListView));
report.SetFilteringObject(new LocalizedCriteriaWrapper(report.DataType, criteria));
}
object ICriteriaVisitor.Visit(InOperator theOperator)
{
List <string> operands = new List <string>();
foreach (CriteriaOperator operand in theOperator.Operands)
{
operands.Add(operand.Accept(this).ToString());
}
return(string.Format("{0} in {1}", theOperator.LeftOperand.Accept(this).ToString(),
string.Join(", ", operands.ToArray())));
}
protected override void OnBeforeCreateDocument(DashboardInteractionController interactionController, DashboardReportViewItem dashboardReportViewItem, ListViewFilteringArgs listViewFilteringArgs)
{
base.OnBeforeCreateDocument(interactionController, dashboardReportViewItem, listViewFilteringArgs);
var objectTypeInfo = Application.TypesInfo.FindTypeInfo(((IReportDataV2)dashboardReportViewItem.ReportData).DataType);
var reportDataTypeMember = GetReportDataTypeMember(((IModelDashboardViewItemEx)dashboardReportViewItem.Model), objectTypeInfo);
var report = dashboardReportViewItem.Report;
var criteria = new InOperator(reportDataTypeMember, interactionController.Getkeys(listViewFilteringArgs.DataSourceListView));
report.FilterString = new LocalizedCriteriaWrapper(objectTypeInfo.Type, criteria).CriteriaOperator.ToString();
report.CreateDocument(false);
}
private List <ITreeNode> GetAllChildTreeNodes(InOperator inOperator, string propertyName)
{
var allTreeNodes = new List <ITreeNode>();
XPCollection treeNodes = GetTreeNodes(propertyName, inOperator);
if (treeNodes != null)
{
allTreeNodes = treeNodes.Cast <ITreeNode>().ToList().GetAllTreeNodes();
}
return(allTreeNodes.Distinct().ToList());
}
public static bool HistoryData(IObjectSpace objectSpace, List <TaskTimeHistory> projectTaskList)
{
bool isManager = false;
var projectList = (List <Katrin.Domain.Impl.Project>)objectSpace.GetObjects("Project", new BinaryOperator("ManagerId", AuthorizationManager.CurrentUserId), null);
CriteriaOperator filter = null;
if (projectList != null && projectList.Count > 0)
{
List <object> projectIds = new List <object>();
foreach (var projectItem in projectList)
{
projectIds.Add(projectItem.ProjectId);
}
filter = new InOperator("ProjectId", projectIds);
isManager = true;
}
CriteriaOperator historyFilter = new BinaryOperator("CreatedById", AuthorizationManager.CurrentUserId, BinaryOperatorType.Equal);
var taskTimeHistories = (List <Katrin.Domain.Impl.TaskTimeHistory>)objectSpace.GetObjects("TaskTimeHistory", historyFilter, null);
if (taskTimeHistories.Count <= 0 && !isManager)
{
return(isManager);
}
historyFilter = new InOperator("TaskId", taskTimeHistories.Select(c => c.TaskId).ToList());
if (isManager)
{
filter |= historyFilter;
}
else
{
filter = historyFilter;
}
var managerExtraColumns = new Dictionary <string, string>
{
{ "Project", "Project" },
{ "ProjectIteration", "ProjectIteration" },
{ "TaskTimeHistories", "TaskTimeHistories" }
};
var projectTasks = objectSpace.GetBatchObjects("ProjectTask", filter, managerExtraColumns);
foreach (var taskItem in projectTasks)
{
Katrin.Domain.Impl.ProjectTask task = ConvertData.Convert <Katrin.Domain.Impl.ProjectTask>(taskItem);
var historyList = task.TaskTimeHistories.ToList();
if (!isManager)
{
historyList = historyList.Where(c => c.CreatedById == AuthorizationManager.CurrentUserId).ToList();
}
AddTaskItems(historyList, task, projectTaskList);
}
return(isManager);
}
protected virtual CriteriaOperator VisitIn(InOperator theOperator)
{
CriteriaOperator leftOperand = this.AcceptOperator(theOperator.LeftOperand);
CriteriaOperatorCollection operands = this.VisitOperands(theOperator.Operands);
if (object.ReferenceEquals(theOperator.LeftOperand, leftOperand) &&
object.ReferenceEquals(theOperator.Operands, operands))
{
return(theOperator);
}
return(new InOperator(leftOperand, operands));
}
object ICriteriaVisitor <object> .Visit(InOperator theOperator)
{
Process(theOperator);
if (!ReferenceEquals(theOperator.LeftOperand, null))
{
theOperator.LeftOperand.Accept(this);
}
foreach (CriteriaOperator @operator in theOperator.Operands)
{
@operator.Accept(this);
}
return(null);
}
public void ShouldBeValueInSet([Range(0, 5)] int value)
{
// Given
var list = new[] { 0, 1, 2 };
var filter = new InOperator(EntityType, IntField, list);
var entity = new FilterTestEntity {
IntField = value
};
// When
var isSatisfy = filter.IsSatisfiedBy(entity);
// Then
Assert.AreEqual(list.Contains(value), isSatisfy);
}
public BusinessObject GetOldestUnprocessedObject(Session session, Guid jobId, List <int> ObjectType)
{
BusinessObject oldestObject = null;
try
{
ETLJob etlJob = session.GetObjectByKey <ETLJob>(jobId);
if (etlJob == null)
{
return(null);
}
ETLLogBO etlLogBO = new ETLLogBO();
XPCollection <ETLBusinessObject> etlBusinessObjectCollection = etlLogBO.GetChangedIssuedDateETLBusinessObject(session, jobId);
if (etlBusinessObjectCollection != null && etlBusinessObjectCollection.Count() != 0)
{
etlBusinessObjectCollection.Sorting.Add(new SortProperty("BusinessObject.IssuedDateTimeStamp", SortingDirection.Ascending));
ETLBusinessObject oldestETLBusinessObject = etlBusinessObjectCollection.FirstOrDefault();
etlBusinessObjectCollection = etlLogBO.GetNewerETLBusinessObject(session, jobId, oldestETLBusinessObject.BusinessObjectIssuedDateTimeStamp);
foreach (ETLBusinessObject EBO in etlBusinessObjectCollection)
{
EBO.RowStatus = -2;
EBO.Save();
}
oldestETLBusinessObject.RowStatus = -2;
oldestETLBusinessObject.Save();
}
CriteriaOperator criteria_0 = new InOperator("ObjectType", ObjectType);
CriteriaOperator criteria_1 = new BinaryOperator("RowStatus", 0, BinaryOperatorType.Greater);
CriteriaOperator criteria = new GroupOperator(GroupOperatorType.And, criteria_0, criteria_1);
XPCollection <BusinessObject> businessObjectCollection = new XPCollection <BusinessObject>(session, criteria);
businessObjectCollection.Sorting.Add(new SortProperty("ObjectIssueDate", SortingDirection.Ascending));
businessObjectCollection.Sorting.Add(new SortProperty("IssuedDateTimeStamp", SortingDirection.Ascending));
foreach (BusinessObject bo in businessObjectCollection)
{
if (NeedToBeProcessed(session, bo.BusinessObjectId, jobId))
{
return(bo);
}
}
}
catch (Exception)
{
throw;
}
return(oldestObject);
}
protected void BuildColumnFilter(GridColumn gridColumn, RepositoryItemCheckedComboBoxEdit checkedComboBoxEdit)
{
var typeFilterList = checkedComboBoxEdit.Items.Cast <CheckedListBoxItem>()
.Where(p => p.CheckState == CheckState.Checked)
.Select(p => (string)p.Value).ToList();
if (typeFilterList.Count == 0)
{
gridColumn.FilterInfo = null;
return;
}
var containsOp = new InOperator(gridColumn.FieldName, typeFilterList);
gridColumn.FilterInfo = new ColumnFilterInfo(containsOp);
}
private IEnumerable GetTaskHistory(DateTime startDate, DateTime endDate, List <object> taskListId)
{
if (taskListId.Count <= 0)
{
return(null);
}
CriteriaOperator filter = new BinaryOperator("RecordOn", startDate, BinaryOperatorType.GreaterOrEqual);
filter &= new BinaryOperator("RecordOn", endDate, BinaryOperatorType.LessOrEqual);
if (taskListId.Count > 0)
{
filter &= new InOperator("TaskId", taskListId);
}
return(DynamicDataServiceContext.GetBatchObjects("TaskTimeHistory", filter, null));
}
public XPCollection <InventoryLedger> getTransactionInventoryLedgers(Session session, Guid InventoryId, Guid ItemUnitId)
{
try
{
AccountingPeriod currentAP = AccountingPeriodBO.getCurrentAccountingPeriod(session);
//if (currentAP == null)
// return null;
XPCollection <InventoryTransaction> ITLst = new XPCollection <InventoryTransaction>(session);
//ITLst.Criteria = CriteriaOperator.And(
// new BinaryOperator("AccountingPeriodId", currentAP, BinaryOperatorType.Equal),
// new BinaryOperator("RowStatus", 0, BinaryOperatorType.Greater)
// );
ITLst.Criteria = new BinaryOperator("RowStatus", 1, BinaryOperatorType.GreaterOrEqual);
if (ITLst == null || ITLst.Count == 0)
{
return(null);
}
if (ITLst == null || ITLst.Count == 0)
{
return(null);
}
CriteriaOperator criteriaIN = new InOperator("InventoryTransactionId", ITLst);
XPCollection <InventoryLedger> ILLst = new XPCollection <InventoryLedger>(session);
ILLst.Criteria = CriteriaOperator.And(
new InOperator("InventoryTransactionId", ITLst),
new BinaryOperator("ItemUnitId!Key", ItemUnitId, BinaryOperatorType.Equal),
new BinaryOperator("InventoryId!Key", InventoryId, BinaryOperatorType.Equal),
new BinaryOperator("RowStatus", 1, BinaryOperatorType.GreaterOrEqual)
);
SortingCollection sortCollection = new SortingCollection();
sortCollection.Add(new SortProperty("IssueDate", DevExpress.Xpo.DB.SortingDirection.Descending));
sortCollection.Add(new SortProperty("CreateDate", DevExpress.Xpo.DB.SortingDirection.Descending));
sortCollection.Add(new SortProperty("UpdateDate", DevExpress.Xpo.DB.SortingDirection.Descending));
ILLst.Sorting = sortCollection;
return(ILLst);
}
catch (Exception e)
{
return(null);
}
}
protected override object Visit(InOperator theOperator)
{
var leftOperand = theOperator.LeftOperand;
GroupOperator group = new GroupOperator();
group.OperatorType = GroupOperatorType.Or;
foreach (var operand in theOperator.Operands)
{
BinaryOperator criteria = new BinaryOperator();
criteria.OperatorType = BinaryOperatorType.Equal;
criteria.LeftOperand = leftOperand;
criteria.RightOperand = operand;
group.Operands.Add(criteria);
}
return(group);
}
private static Condition In(InOperator inOperator)
{
var values = (inOperator.Operands as CriteriaOperatorCollection).OfType <ConstantValue>().Select(x => x.Value).ToList();
var listType = typeof(List <>).MakeGenericType(values.FirstOrDefault().GetType());
var list = Activator.CreateInstance(listType, values.Count);
var method = listType.GetMethod("Add");
for (int i = 0; i < values.Count; i++)
{
method.Invoke(list, new object[] { values[i] });
}
OperandProperty property = inOperator.LeftOperand as OperandProperty;
return(new Condition(property.PropertyName, Operator.In, list));
}
void OnListViewFiltering(object sender, ListViewFilteringArgs listViewFilteringArgs)
{
var dashboardViewItem = listViewFilteringArgs.DashboardViewItem;
var dashboardReportViewItem = dashboardViewItem as DashboardReportViewItem;
if (dashboardReportViewItem != null)
{
listViewFilteringArgs.Handled = true;
var dashboardInteractionController = ((DashboardInteractionController)sender);
var report = (dashboardReportViewItem).Report;
var reportDataTypeMember = ((IModelDashboardViewFilterReport)listViewFilteringArgs.Model.Filter).ReportDataTypeMember;
var propertyName = PropertyName(report, reportDataTypeMember);
var criteria = new InOperator(propertyName, dashboardInteractionController.Getkeys(listViewFilteringArgs.DataSourceListView));
report.SetFilteringObject(new LocalizedCriteriaWrapper(report.DataType, criteria));
report.CreateDocument(true);
}
}
public void FixInvokedBussinessObjects(Session session, XPCollection <DAL.System.Log.BusinessObject> invokedBussinessObjects)
{
if (invokedBussinessObjects == null || invokedBussinessObjects.Count == 0)
{
return;
}
CriteriaOperator criteria_0 = CriteriaOperator.Parse("not(IsNull(FinancialTransactionDimId))");
CriteriaOperator criteria_1 = new InOperator("FinancialTransactionDimId.RefId", invokedBussinessObjects.Select(i => i.RefId));
CriteriaOperator criteria_2 = new BinaryOperator("RowStatus", 0, BinaryOperatorType.Greater);
CriteriaOperator criteria = new GroupOperator(GroupOperatorType.And, criteria_0, criteria_1, criteria_2);
CorrespondFinancialAccountDim defaultAccDim = CorrespondFinancialAccountDim.GetDefault(session, CorrespondFinancialAccountDimEnum.NAAN_DEFAULT);
XPCollection <FinancialPrepaidExpenseDetail> neededToBeFixList = new XPCollection <FinancialPrepaidExpenseDetail>(session, criteria);
FinancialPrepaidExpenseSummary_Fact fact = null;
if (neededToBeFixList != null && neededToBeFixList.Count > 0)
{
foreach (FinancialPrepaidExpenseDetail detail in neededToBeFixList)
{
fact = detail.FinancialPrepaidExpenseSummary_FactId;
detail.RowStatus = Utility.Constant.ROWSTATUS_DELETED;
detail.Save();
//if (defaultAccDim != null && detail.CorrespondFinancialAccountDimId != null
// && detail.CorrespondFinancialAccountDimId.Code.Equals(defaultAccDim.Code))
//{
// fact.CreditSum -= detail.Credit;
// fact.DebitSum -= detail.Debit;
//}
//fact.EndCreditBalance
// = fact.BeginCreditBalance +
// fact.CreditSum -
// fact.DebitSum;
//fact.EndDebitBalance
// = fact.BeginDebitBalance +
// fact.DebitSum -
// fact.CreditSum;
//fact.Save();
}
}
}
public override void FixInvokedBussinessObjects(DevExpress.Xpo.Session session, DevExpress.Xpo.XPCollection <DAL.System.Log.BusinessObject> invokedBussinessObjects)
{
if (invokedBussinessObjects == null || invokedBussinessObjects.Count == 0)
{
return;
}
CriteriaOperator criteria_0 = CriteriaOperator.Parse("not(IsNull(FinancialTransactionDimId))");
CriteriaOperator criteria_1 = new InOperator("FinancialTransactionDimId.RefId", invokedBussinessObjects.Select(i => i.RefId));
CriteriaOperator criteria_2 = new BinaryOperator("RowStatus", 0, BinaryOperatorType.Greater);
CriteriaOperator criteria = new GroupOperator(GroupOperatorType.And, criteria_0, criteria_1, criteria_2);
CorrespondFinancialAccountDim defaultCorrespondAccDim = CorrespondFinancialAccountDim.GetDefault(session, CorrespondFinancialAccountDimEnum.NAAN_DEFAULT);
XPCollection <GoodsInInventoryDetail> neededToBeFixList = new XPCollection <GoodsInInventoryDetail>(session, criteria);
GoodsInInventorySummary_Fact fact = null;
if (neededToBeFixList != null && neededToBeFixList.Count > 0)
{
foreach (GoodsInInventoryDetail detail in neededToBeFixList)
{
fact = detail.GoodsInInventorySummary_FacftId;
detail.RowStatus = Utility.Constant.ROWSTATUS_DELETED;
detail.Save();
//fact.CreditSum = fact.GoodsInInventoryDetails.Where(i => i.RowStatus == 1
// && i.Credit > 0 && i.CorrespondFinancialAccountDimId == defaultCorrespondAccDim).Sum(d => d.Credit);
//fact.DebitSum = fact.GoodsInInventoryDetails.Where(i => i.RowStatus == 1
// && i.Debit > 0 && i.CorrespondFinancialAccountDimId == defaultCorrespondAccDim).Sum(d => d.Debit);
//fact.EndCreditBalance
// = fact.BeginCreditBalance +
// fact.CreditSum -
// fact.DebitSum;
//fact.EndDebitBalance
// = fact.BeginDebitBalance +
// fact.DebitSum -
// fact.CreditSum;
//fact.Save();
}
}
}
private IEnumerable GetTaskHistory(DateTime recordDate, List <Guid> taskListId)
{
DateTime startDate = Utils.Date.WeekBegin(recordDate);
DateTime endDate = Utils.Date.WeekEnd(recordDate);
if (taskListId.Count <= 0)
{
return(null);
}
CriteriaOperator filter = new BinaryOperator("RecordOn", startDate, BinaryOperatorType.GreaterOrEqual);
filter &= new BinaryOperator("RecordOn", endDate, BinaryOperatorType.LessOrEqual);
if (taskListId.Count > 0)
{
filter &= new InOperator("TaskId", taskListId);
}
return(DynamicDataServiceContext.GetObjects("TaskTimeHistory", filter, null));
}
public override Object Visit(InOperator theOperator)
{
return new CriteriaToStringVisitResult(Process(theOperator.LeftOperand).Result + " " + GetInText() + " {" + ProcessToCommaDelimitedList(theOperator.Operands) + "}");
}
public object Visit(InOperator theOperator){
return theOperator;
}
private string ProcessInOperator(InOperator inOperator, string alias)
{
return InterpritateFilter(inOperator.LeftOperand, alias) + " IN (" + ProcessOperands(inOperator.Operands) + ")";
}
public virtual object Visit(InOperator theOperator)
{
Validate(theOperator.LeftOperand);
Validate(theOperator.Operands);
return null;
}
public object Visit(InOperator theOperator)
{
return BooleanCriteriaStateObject.Logical;
}
public object Visit(InOperator theOperator) {
UpdatePropertyName(theOperator.LeftOperand);
ToValue(theOperator.Operands);
return theOperator;
}
Object yyparse (yyInput yyLex) {
if (yyMax <= 0) yyMax = 256;
int yyState = 0;
int [] yyStates = new int[yyMax];
Object yyVal = null;
Object [] yyVals = new Object[yyMax];
int yyToken = -1;
int yyErrorFlag = 0;
int yyTop = 0;
goto skip;
yyLoop:
yyTop++;
skip:
for(;; ++yyTop) {
if(yyTop >= yyStates.Length) {
int[] i = new int[yyStates.Length + yyMax];
yyStates.CopyTo(i, 0);
yyStates = i;
Object[] o = new Object[yyVals.Length + yyMax];
yyVals.CopyTo(o, 0);
yyVals = o;
}
yyStates[yyTop] = yyState;
yyVals[yyTop] = yyVal;
yyDiscarded:
for(;;) {
int yyN;
if ((yyN = yyDefRed[yyState]) == 0) {
if(yyToken < 0)
yyToken = yyLex.advance() ? yyLex.token() : 0;
if((yyN = yySindex[yyState]) != 0 && ((yyN += yyToken) >= 0)
&& (yyN < yyTable.Length) && (yyCheck[yyN] == yyToken)) {
yyState = yyTable[yyN];
yyVal = yyLex.value();
yyToken = -1;
if (yyErrorFlag > 0) -- yyErrorFlag;
goto yyLoop;
}
if((yyN = yyRindex[yyState]) != 0 && (yyN += yyToken) >= 0
&& yyN < yyTable.Length && yyCheck[yyN] == yyToken)
yyN = yyTable[yyN];
else
switch(yyErrorFlag) {
case 0:
yyerror("syntax error");
goto case 1;
case 1: case 2:
yyErrorFlag = 3;
do {
if((yyN = yySindex[yyStates[yyTop]]) != 0
&& (yyN += Token.yyErrorCode) >= 0 && yyN < yyTable.Length
&& yyCheck[yyN] == Token.yyErrorCode) {
yyState = yyTable[yyN];
yyVal = yyLex.value();
goto yyLoop;
}
} while (--yyTop >= 0);
yyerror("irrecoverable syntax error");
goto yyDiscarded;
case 3:
if (yyToken == 0)
yyerror("irrecoverable syntax error at end-of-file");
yyToken = -1;
goto yyDiscarded;
}
}
int yyV = yyTop + 1 - yyLen[yyN];
yyVal = yyV > yyTop ? null : yyVals[yyV];
switch(yyN) {
case 1:
#line 54 "grammar.y"
{ result = new CriteriaOperator[0]; }
break;
case 2:
#line 55 "grammar.y"
{ result = ((List<CriteriaOperator>)yyVals[-1+yyTop]).ToArray(); }
break;
case 3:
#line 59 "grammar.y"
{ yyVal = new List<CriteriaOperator>(new CriteriaOperator[] {(CriteriaOperator)yyVals[0+yyTop]}); }
break;
case 4:
#line 60 "grammar.y"
{ yyVal = yyVals[-2+yyTop]; ((List<CriteriaOperator>)yyVal).Add((CriteriaOperator)yyVals[0+yyTop]); }
break;
case 5:
#line 64 "grammar.y"
{ yyVal = yyVals[0+yyTop]; }
break;
case 6:
#line 65 "grammar.y"
{
OperandProperty prop2 = (OperandProperty)yyVals[-2+yyTop];
OperandProperty prop4 = (OperandProperty)yyVals[0+yyTop];
prop2.PropertyName = '<' + prop2.PropertyName + '>' + prop4.PropertyName;
yyVal = prop2;
}
break;
case 7:
#line 74 "grammar.y"
{ yyVal = yyVals[0+yyTop]; }
break;
case 8:
#line 75 "grammar.y"
{ yyVal = new OperandProperty("^"); }
break;
case 9:
#line 79 "grammar.y"
{ yyVal = yyVals[0+yyTop]; }
break;
case 10:
#line 80 "grammar.y"
{
OperandProperty prop1 = (OperandProperty)yyVals[-2+yyTop];
OperandProperty prop3 = (OperandProperty)yyVals[0+yyTop];
prop1.PropertyName += '.' + prop3.PropertyName;
yyVal = prop1;
}
break;
case 11:
#line 89 "grammar.y"
{
AggregateOperand agg = (AggregateOperand)yyVals[0+yyTop];
yyVal = JoinOperand.JoinOrAggreagate((OperandProperty)yyVals[-2+yyTop], null, agg.AggregateType, agg.AggregatedExpression);
}
break;
case 12:
#line 93 "grammar.y"
{
AggregateOperand agg = (AggregateOperand)yyVals[0+yyTop];
yyVal = JoinOperand.JoinOrAggreagate((OperandProperty)yyVals[-5+yyTop], (CriteriaOperator)yyVals[-3+yyTop], agg.AggregateType, agg.AggregatedExpression);
}
break;
case 13:
#line 97 "grammar.y"
{
AggregateOperand agg = (AggregateOperand)yyVals[0+yyTop];
yyVal = JoinOperand.JoinOrAggreagate((OperandProperty)yyVals[-4+yyTop], null, agg.AggregateType, agg.AggregatedExpression);
}
break;
case 14:
#line 101 "grammar.y"
{ yyVal = JoinOperand.JoinOrAggreagate((OperandProperty)yyVals[-3+yyTop], (CriteriaOperator)yyVals[-1+yyTop], Aggregate.Exists, null); }
break;
case 15:
#line 102 "grammar.y"
{ yyVal = JoinOperand.JoinOrAggreagate((OperandProperty)yyVals[-2+yyTop], null, Aggregate.Exists, null); }
break;
case 18:
#line 110 "grammar.y"
{ yyVal = new AggregateOperand((OperandProperty)null, (CriteriaOperator)null, Aggregate.Count, null); }
break;
case 19:
#line 111 "grammar.y"
{ yyVal = new AggregateOperand((OperandProperty)null, (CriteriaOperator)null, Aggregate.Exists, null); }
break;
case 20:
#line 112 "grammar.y"
{ yyVal = new AggregateOperand((OperandProperty)null, (CriteriaOperator)null, Aggregate.Count, null); }
break;
case 21:
#line 113 "grammar.y"
{ yyVal = new AggregateOperand((OperandProperty)null, (CriteriaOperator)null, Aggregate.Exists, null); }
break;
case 22:
#line 114 "grammar.y"
{ yyVal = new AggregateOperand((OperandProperty)null, (CriteriaOperator)yyVals[-1+yyTop], Aggregate.Min, null); }
break;
case 23:
#line 115 "grammar.y"
{ yyVal = new AggregateOperand((OperandProperty)null, (CriteriaOperator)yyVals[-1+yyTop], Aggregate.Max, null); }
break;
case 24:
#line 116 "grammar.y"
{ yyVal = new AggregateOperand((OperandProperty)null, (CriteriaOperator)yyVals[-1+yyTop], Aggregate.Avg, null); }
break;
case 25:
#line 117 "grammar.y"
{ yyVal = new AggregateOperand((OperandProperty)null, (CriteriaOperator)yyVals[-1+yyTop], Aggregate.Sum, null); }
break;
case 26:
#line 121 "grammar.y"
{ yyVal = yyVals[0+yyTop]; }
break;
case 27:
#line 122 "grammar.y"
{
string paramName = (string)yyVals[0+yyTop];
if(string.IsNullOrEmpty(paramName)) {
OperandValue param = new OperandValue();
resultParameters.Add(param);
yyVal = param;
} else {
bool paramNotFound = true;
foreach(OperandValue v in resultParameters) {
OperandParameter p = v as OperandParameter;
if(ReferenceEquals(p, null))
continue;
if(p.ParameterName != paramName)
continue;
paramNotFound = false;
resultParameters.Add(p);
yyVal = p;
break;
}
if(paramNotFound) {
OperandParameter param = new OperandParameter(paramName);
resultParameters.Add(param);
yyVal = param;
}
}
}
break;
case 28:
#line 148 "grammar.y"
{ yyVal = yyVals[0+yyTop]; }
break;
case 29:
#line 149 "grammar.y"
{ yyVal = yyVals[0+yyTop]; }
break;
case 30:
#line 150 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Multiply ); }
break;
case 31:
#line 151 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Divide ); }
break;
case 32:
#line 152 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Plus ); }
break;
case 33:
#line 153 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Minus ); }
break;
case 34:
#line 154 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Modulo ); }
break;
case 35:
#line 155 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.BitwiseOr ); }
break;
case 36:
#line 156 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.BitwiseAnd ); }
break;
case 37:
#line 157 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.BitwiseXor ); }
break;
case 38:
#line 158 "grammar.y"
{
yyVal = new UnaryOperator( UnaryOperatorType.Minus, (CriteriaOperator)yyVals[0+yyTop] );
try {
if(yyVals[0+yyTop] is OperandValue) {
OperandValue operand = (OperandValue)yyVals[0+yyTop];
if(operand.Value is Int32) {
operand.Value = -(Int32)operand.Value;
yyVal = operand;
break;
} else if(operand.Value is Int64) {
operand.Value = -(Int64)operand.Value;
yyVal = operand;
break;
} else if(operand.Value is Double) {
operand.Value = -(Double)operand.Value;
yyVal = operand;
break;
} else if(operand.Value is Decimal) {
operand.Value = -(Decimal)operand.Value;
yyVal = operand;
break;
} else if(operand.Value is Int16) {
operand.Value = -(Int16)operand.Value;
yyVal = operand;
break;
} else if(operand.Value is SByte) {
operand.Value = -(SByte)operand.Value;
yyVal = operand;
break;
}
}
} catch {}
}
break;
case 39:
#line 191 "grammar.y"
{ yyVal = new UnaryOperator( UnaryOperatorType.Plus, (CriteriaOperator)yyVals[0+yyTop] ); }
break;
case 40:
#line 192 "grammar.y"
{ yyVal = new UnaryOperator( UnaryOperatorType.BitwiseNot, (CriteriaOperator)yyVals[0+yyTop] ); }
break;
case 41:
#line 193 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Equal); }
break;
case 42:
#line 194 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.NotEqual); }
break;
case 43:
#line 195 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Greater); }
break;
case 44:
#line 196 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Less); }
break;
case 45:
#line 197 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.GreaterOrEqual); }
break;
case 46:
#line 198 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.LessOrEqual); }
break;
case 47:
#line 199 "grammar.y"
{ yyVal = new BinaryOperator( (CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Like); }
break;
case 48:
#line 200 "grammar.y"
{ yyVal = new UnaryOperator(UnaryOperatorType.Not, new BinaryOperator( (CriteriaOperator)yyVals[-3+yyTop], (CriteriaOperator)yyVals[0+yyTop], BinaryOperatorType.Like)); }
break;
case 49:
#line 201 "grammar.y"
{ yyVal = new UnaryOperator(UnaryOperatorType.Not, (CriteriaOperator)yyVals[0+yyTop]); }
break;
case 50:
#line 202 "grammar.y"
{ yyVal = GroupOperator.And((CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop]); }
break;
case 51:
#line 203 "grammar.y"
{ yyVal = GroupOperator.Or((CriteriaOperator)yyVals[-2+yyTop], (CriteriaOperator)yyVals[0+yyTop]); }
break;
case 52:
#line 204 "grammar.y"
{ yyVal = yyVals[-1+yyTop]; }
break;
case 53:
#line 205 "grammar.y"
{ yyVal = new UnaryOperator(UnaryOperatorType.IsNull, (CriteriaOperator)yyVals[-2+yyTop]); }
break;
case 54:
#line 206 "grammar.y"
{ yyVal = new UnaryOperator(UnaryOperatorType.Not, new UnaryOperator(UnaryOperatorType.IsNull, (CriteriaOperator)yyVals[-3+yyTop])); }
break;
case 55:
#line 207 "grammar.y"
{ yyVal = new InOperator((CriteriaOperator)yyVals[-2+yyTop], (IEnumerable<CriteriaOperator>)yyVals[0+yyTop]); }
break;
case 56:
#line 208 "grammar.y"
{ yyVal = new BetweenOperator((CriteriaOperator)yyVals[-6+yyTop], (CriteriaOperator)yyVals[-3+yyTop], (CriteriaOperator)yyVals[-1+yyTop]); }
break;
case 57:
#line 209 "grammar.y"
{ yyVal = new UnaryOperator(UnaryOperatorType.IsNull, (CriteriaOperator)yyVals[-1+yyTop]); }
break;
case 58:
#line 210 "grammar.y"
{ yyVal = new FunctionOperator(FunctionOperatorType.IsNull, (CriteriaOperator)yyVals[-3+yyTop], (CriteriaOperator)yyVals[-1+yyTop]); }
break;
case 59:
#line 211 "grammar.y"
{ FunctionOperator fo = new FunctionOperator((FunctionOperatorType)yyVals[-1+yyTop], (IEnumerable<CriteriaOperator>)yyVals[0+yyTop]); lexer.CheckFunctionArgumentsCount(fo.OperatorType, fo.Operands.Count); yyVal = fo; }
break;
case 60:
#line 212 "grammar.y"
{ yyVal = null; }
break;
case 61:
#line 216 "grammar.y"
{ yyVal = yyVals[-1+yyTop]; }
break;
case 62:
#line 217 "grammar.y"
{ yyVal = new List<CriteriaOperator>(); }
break;
case 63:
#line 221 "grammar.y"
{
List<CriteriaOperator> lst = new List<CriteriaOperator>();
lst.Add((CriteriaOperator)yyVals[0+yyTop]);
yyVal = lst;
}
break;
case 64:
#line 226 "grammar.y"
{
List<CriteriaOperator> lst = (List<CriteriaOperator>)yyVals[-2+yyTop];
lst.Add((CriteriaOperator)yyVals[0+yyTop]);
yyVal = lst;
}
break;
#line default
}
yyTop -= yyLen[yyN];
yyState = yyStates[yyTop];
int yyM = yyLhs[yyN];
if(yyState == 0 && yyM == 0) {
yyState = yyFinal;
if(yyToken < 0)
yyToken = yyLex.advance() ? yyLex.token() : 0;
if(yyToken == 0)
return yyVal;
goto yyLoop;
}
if(((yyN = yyGindex[yyM]) != 0) && ((yyN += yyState) >= 0)
&& (yyN < yyTable.Length) && (yyCheck[yyN] == yyState))
yyState = yyTable[yyN];
else
yyState = yyDgoto[yyM];
goto yyLoop;
}
}
}
public object Visit(InOperator theOperator)
{
object left = Accept(theOperator.LeftOperand);
foreach (CriteriaOperator op in theOperator.Operands)
{
if (Compare(left, Accept(op), true) == 0)
{
return true;
}
}
return false;
}
/// <contentfrom cref="ICriteriaVisitor.Visit(InOperator)"/>
public object Visit(InOperator theOperator)
{
theOperator.LeftOperand = Process(theOperator.LeftOperand);
Process(theOperator.Operands);
return theOperator;
}
/// <contentfrom cref="ICriteriaVisitor.Visit(InOperator)"/>
public object Visit(InOperator theOperator)
{
Process(theOperator.LeftOperand);
Process(theOperator.Operands);
return null;
}
void ApplyCondition(SelectStatement statement, FilterProviderBase providerBase, string nodeAlias) {
var objectType = GetObjectType(statement.TableName);
if (FilteredByKey(statement, objectType)) return;
CriteriaOperator condition = null;
if (providerBase.FilterValue is IList) {
CriteriaOperator criteriaOperator = ((IEnumerable)providerBase.FilterValue).Cast<object>().Aggregate<object, CriteriaOperator>(null, (current, value)
=> current | (
value == null
? (CriteriaOperator)new QueryOperand(providerBase.FilterMemberName, nodeAlias).IsNull()
: new QueryOperand(providerBase.FilterMemberName, nodeAlias) == new OperandValue( value)));
criteriaOperator = new GroupOperator(criteriaOperator);
condition = criteriaOperator;
} else
condition = new QueryOperand(providerBase.FilterMemberName, nodeAlias) == (providerBase.FilterValue == null ? null : providerBase.FilterValue.ToString());
if (objectType != null)
{
var typeInfo = XafTypesInfo.CastTypeToTypeInfo(objectType);
if (typeInfo.OwnMembers.FirstOrDefault(x=>x.Name == "ObjectType") != null)
{
var excludes = new List<Type>();
foreach (var item in _BaseTypesDictionary.Where(x => x.Value == typeInfo).Select(x => x.Key))
{
if (FilterProviderManager.GetFilterProvider(item.Type,providerBase.FilterMemberName,StatementContext.Select) == null)
excludes.Add(item.Type);
}
if (excludes.Count > 0)
{
var table = XafTypesInfo.XpoTypeInfoSource.GetEntityClassInfo(typeof(XPObjectType)).Table;
statement.SubNodes.Add(new JoinNode(table,"OT",JoinType.Inner){Condition = new QueryOperand("ObjectType",statement.Alias) == new QueryOperand("OId","OT")});
condition |= new InOperator(new QueryOperand("TypeName","OT"),excludes.Select(x=>new OperandValue( x.FullName)).ToArray());
}
}
}
statement.Condition &= new GroupOperator(condition);
}
object ICriteriaVisitor.Visit(InOperator theOperator)
{
object val = Process(theOperator.LeftOperand);
foreach(CriteriaOperator op in theOperator.Operands)
if(Compare(val, Process(op), true) == 0)
return GetBool(true);
return GetBool(false);
}
public object Visit(InOperator theOperator)
{
BooleanCriteriaState leftRes = Process(theOperator.LeftOperand);
if (leftRes == BooleanCriteriaState.Logical) throw new ArgumentException(MustBeArithmetical);
foreach (CriteriaOperator co in theOperator.Operands) {
BooleanCriteriaState coRes = Process(co);
if (coRes == BooleanCriteriaState.Logical) throw new ArgumentException(MustBeArithmetical);
}
return BooleanCriteriaStateObject.Logical;
}
protected override void Process(InOperator theOperator)
{
base.Process(theOperator);
var leftOperand = theOperator.LeftOperand as QueryOperand;
if (!object.ReferenceEquals(leftOperand, null))
{
if (leftOperand.ColumnName == _KeyColumnName && leftOperand.NodeAlias == _NodeAlias)
_ContainsKey = true;
}
}
