private string ProcessOperandProperty(OperandProperty operandProperty, string alias)
{
var operandPropertyName = operandProperty.PropertyName;
if (operandPropertyName.StartsWith(ConcatOperandOperator.OPERAND_PREFIX))
{
return("CONCAT_SMART(" +
operandPropertyName
.Remove(ConcatOperandOperator.OPERAND_PREFIX)
.Split(ConcatOperandOperator.PROPERTY_DELIMETER)
.ToString(x => alias + "." + x, ", ") +
")");
}
if (operandPropertyName.StartsWith(FirstNbytesOperandOperator.OPERAND_PREFIX))
{
var query = operandPropertyName.Remove(FirstNbytesOperandOperator.OPERAND_PREFIX)
.Split(FirstNbytesOperandOperator.DELIMETER);
if (query.Length == 2)
{
return("FIRST_NBYTES({0}.{1}, {2})".FillWith(alias, query[0], query[1]));
}
}
return(alias + "." + operandPropertyName);
}
protected override void Process(OperandProperty theOperand)
{
base.Process(theOperand);
theOperand.PropertyName =
CaptionHelper.GetFullMemberCaption(XafTypesInfo.Instance.FindTypeInfo(objectType),
theOperand.PropertyName);
}
protected override void Process(OperandProperty operand) {
base.Process(operand);
IMemberInfo memberInfo = objectTypeInfo.FindMember(operand.PropertyName);
if(memberInfo.MemberTypeInfo.IsDomainComponent) {
operand.PropertyName = operand.PropertyName + "." + memberInfo.MemberTypeInfo.KeyMember.Name;
}
}
void DefaultNewRow(int _RowHandle)
{
var x = (XPLiteObject)detailsGV.GetRow(_RowHandle);
//x?.SetMemberValue(parms.DetailsKeyName, masterKeyObject);
var left = new OperandProperty(parms.DetailsKeyName).PropertyName;
switch (parms.KeyType)
{
case KeyTypeEnum.Int:
x?.SetMemberValue(left, ((int)masterKeyObject));
break;
case KeyTypeEnum.Long:
x?.SetMemberValue(left, ((long)masterKeyObject));
break;
case KeyTypeEnum.String:
x?.SetMemberValue(left, $"'{masterKeyObject.ToString()}'");
break;
case KeyTypeEnum.Object:
var defaultObj = ((XPBaseObject)masterKeyObject).This;
x?.SetMemberValue(left, defaultObj);
break;
default:
break;
}
}
public override String[] GetUsersInRole(String roleName)
{
if (String.IsNullOrEmpty(roleName))
{
throw new ProviderException("Role name cannot be empty or null.");
}
if (!RoleExists(roleName))
{
throw new ProviderException("Role does not exist.");
}
string[] users;
using (Session session = XpoHelper.GetNewSession()) {
XPView xpvUsers = new XPView(session, typeof(XpoUser),
new CriteriaOperatorCollection()
{
OperandProperty.Parse("UserName")
},
new GroupOperator(
GroupOperatorType.And,
new BinaryOperator("ApplicationName", ApplicationName, BinaryOperatorType.Equal),
new ContainsOperator("Roles", new BinaryOperator("RoleName", roleName, BinaryOperatorType.Equal))));
List <String> usersList = new List <String>();
for (int i = 0; i < xpvUsers.Count; i++)
{
usersList.Add(xpvUsers[i][0].ToString());
}
users = usersList.ToArray();
}
return(users);
}
public override String[] FindUsersInRole(String roleName, String userNameToMatch)
{
String[] users;
if (!RoleExists(roleName))
{
throw new ProviderException("Role does not exist.");
}
using (Session session = XpoHelper.GetNewSession()) {
CriteriaOperator theCriteria = CriteriaOperator.Parse("ApplicationName = ? and contains(UserName, ?) and Roles[RoleName = ?]", ApplicationName, userNameToMatch, roleName);
XPView xpvUsers = new XPView(session, typeof(XpoUser), new CriteriaOperatorCollection()
{
OperandProperty.Parse("UserName")
}, theCriteria);
List <String> usersList = new List <String>();
for (int i = 0; i < xpvUsers.Count; i++)
{
usersList.Add(xpvUsers[i][0].ToString());
}
users = usersList.ToArray();
}
return(users);
}
public override String[] GetRolesForUser(String username)
{
if (String.IsNullOrEmpty(username))
{
throw new ProviderException("User name cannot be empty or null.");
}
String[] roles;
using (Session session = XpoHelper.GetNewSession()) {
XPView xpvRoles = new XPView(session, typeof(XpoRole),
new CriteriaOperatorCollection()
{
OperandProperty.Parse("RoleName")
},
new GroupOperator(
GroupOperatorType.And,
new BinaryOperator("ApplicationName", ApplicationName, BinaryOperatorType.Equal),
new ContainsOperator("Users", new BinaryOperator("UserName", username, BinaryOperatorType.Equal))));
List <String> rolesList = new List <String>();
for (int i = 0; i < xpvRoles.Count; i++)
{
rolesList.Add(xpvRoles[i][0].ToString());
}
roles = rolesList.ToArray();
}
return(roles);
}
private void RetrieveLines(int journalId)
{
TransJournal journal = unitOfWork1.FindObject <TransJournal>(CriteriaOperator.Parse($" JournalId = {journalId}"));
journalLinesGV.InitNewRow += (s, e) =>
{
var gv = (s as GridView);
((TransJournalLine)gv.GetRow(e.RowHandle)).JournalId = journal;
};
journalLinesXPC.LoadingEnabled = false;
CriteriaOperator filter = new OperandProperty("JournalId") == new OperandValue(journalId);
journalLinesXPC.Criteria = filter;
journalLinesXPC.LoadingEnabled = true;
journalLinesXPC.Load();
//Rebind to journal header
if (journalLinesXPC != null && this.textEdit4.DataBindings.Count == 0)
{
this.textEdit4.DataBindings.Add(new Binding("EditValue", this.journalXPC, "Decription", true));
this.textEdit3.DataBindings.Add(new Binding("EditValue", this.journalXPC, "LocationId.LocationName", true));
this.textEdit2.DataBindings.Add(new Binding("EditValue", this.journalXPC, "TransDate", true));
this.textEdit1.DataBindings.Add(new Binding("EditValue", this.journalXPC, "ShiftId.ShiftName", true));
}
}
protected override void Process(OperandProperty theOperand)
{
base.Process(theOperand);
theOperand.PropertyName =
CaptionHelper.GetFullMemberCaption(XafTypesInfo.Instance.FindTypeInfo(objectType),
theOperand.PropertyName);
}
private static Condition Binary(BinaryOperator binaryOperator)
{
OperandProperty opProperty = binaryOperator.LeftOperand as OperandProperty;
OperandValue opValue = binaryOperator.RightOperand as OperandValue;
if (ReferenceEquals(binaryOperator, null) || ReferenceEquals(opValue, null))
{
return(null);
}
switch (binaryOperator.OperatorType)
{
case BinaryOperatorType.Equal:
return(new Condition(opProperty.PropertyName, Operator.Equals, opValue.Value));
case BinaryOperatorType.NotEqual:
return(new Condition(opProperty.PropertyName, Operator.DoesntEquals, opValue.Value));
case BinaryOperatorType.Greater:
return(new Condition(opProperty.PropertyName, Operator.IsGreaterThan, opValue.Value));
case BinaryOperatorType.Less:
return(new Condition(opProperty.PropertyName, Operator.IsLessThan, opValue.Value));
case BinaryOperatorType.LessOrEqual:
return(new Condition(opProperty.PropertyName, Operator.IsLessThanOrEqualto, opValue.Value));
case BinaryOperatorType.GreaterOrEqual:
return(new Condition(opProperty.PropertyName, Operator.IsGreaterThanOrEqualto, opValue.Value));
default:
throw new FilterException(string.Format(Resource.UnsupportedOperatorError, binaryOperator.OperatorType, "binary"));
}
}
private static Condition Function(FunctionOperator functionOperator)
{
if (ReferenceEquals(functionOperator, null))
{
return(null);
}
OperandProperty opProperty = functionOperator.Operands.Count == 3
? functionOperator.Operands[1] as OperandProperty : functionOperator.Operands[0] as OperandProperty;
OperandValue opValue = functionOperator.Operands.Count > 1
? functionOperator.Operands.Count == 3
? functionOperator.Operands[2] as OperandValue
: functionOperator.Operands[1] as OperandValue
: null;
switch (functionOperator.OperatorType)
{
case FunctionOperatorType.Contains:
return(new Condition(opProperty.PropertyName, Operator.Contains, opValue.Value));
case FunctionOperatorType.StartsWith:
return(new Condition(opProperty.PropertyName, Operator.StartsWith, opValue.Value));
case FunctionOperatorType.EndsWith:
return(new Condition(opProperty.PropertyName, Operator.EndsWith, opValue.Value));
case FunctionOperatorType.IsNullOrEmpty:
return(new Condition(opProperty.PropertyName, Operator.IsNullOrEmpty));
default:
throw new FilterException(string.Format(Resource.UnsupportedOperatorError, functionOperator.OperatorType, "function"));
}
}
protected override object Visit(OperandProperty theOperand)
{
IFieldProjectStrategy projectionStrategy = ServiceManager.Instance.GetService <IFieldProjectStrategy>();
theOperand.PropertyName = projectionStrategy.UnProject(theOperand.PropertyName);
return(base.Visit(theOperand));
}
static Dictionary <string, FilterItem> CreateStandardFilters()
{
var result = new Dictionary <string, FilterItem>();
var status = new OperandProperty("is_enable");
result.CreateItem("is_enable", (CriteriaOperator)(status == new OperandValue(DataListUtil.EnumStatus.Disabled)));
return(result);
}
private static FunctionOperator createOperandProperty(string property, FunctionOperatorType operatorType)
{
CriteriaOperatorCollection operands = new CriteriaOperatorCollection();
OperandProperty propertyOperand = new OperandProperty(property);
operands.Add(propertyOperand);
return(new FunctionOperator(operatorType, operands));
}
public override CriteriaOperator Visit(OperandProperty theOperand)
{
if (PropertiesToremove.Contains(theOperand.PropertyName))
{
return(null);
}
return(theOperand);
}
protected override CriteriaOperator Visit(OperandProperty theOperand)
{
if (theOperand.PropertyName.EndsWith("!"))
{
return(new OperandProperty(theOperand.PropertyName.Substring(0, theOperand.PropertyName.Length - 1)));
}
return(base.Visit(theOperand));
}
public AggregateOperand(OperandProperty fCollectionProperty, CriteriaOperator fCondition,
CriteriaOperator fAggregatedExpression, Aggregate fAggregateType)
{
CollectionProperty = fCollectionProperty;
Condition = fCondition;
AggregatedExpression = fAggregatedExpression;
AggregateType = fAggregateType;
}
public static CriteriaOperator GetCriteriaByText(string text, string columnName, GroupOperatorType groupOperatorType)
{
var ids = text.Split(';');
var operandProp = new OperandProperty(columnName);
var criteriaList = Enumerable.Range(0, ids.Length).Select(s => new FunctionOperator(FunctionOperatorType.Contains, operandProp, ids[s]));
var criteria = new GroupOperator(groupOperatorType, criteriaList);
return(criteria);
}
protected override void Process(OperandProperty theOperand) {
if (AggregateLevel == 0 && !theOperand.PropertyName.EndsWith("!")) {
string probeLookupFieldName = theOperand.PropertyName + '!';
if (existingLookupFieldNames.Contains(probeLookupFieldName)) {
theOperand.PropertyName = probeLookupFieldName;
}
}
base.Process(theOperand);
}
protected void Page_Load(object sender, EventArgs e)
{
ASPxGridView1.DataBind();
if (!IsPostBack && !IsCallback)
{
ASPxGridView1.GroupBy(ASPxGridView1.Columns["TimeSpan"]);
CriteriaOperator filter = new OperandProperty("TimeSpan") == new OperandValue(new TimeSpan(1, 0, 0));
ASPxGridView1.FilterExpression = filter.ToString();
}
}
private CriteriaOperator GetGroupFilter(IEnumerable <GridViewGroupInfo> groupInfoList)
{
CriteriaOperator groupFilter = null;
foreach (GridViewGroupInfo groupInfo in groupInfoList)
{
groupFilter &= new OperandProperty(groupInfo.FieldName) == new OperandValue(groupInfo.KeyValue);
}
return(groupFilter);
}
static Dictionary <string, FilterItem> CreateEmployeeStandardFilters()
{
var result = new Dictionary <string, FilterItem>();
var status = new OperandProperty("Status");
result.CreateItem("All", null);
result.CreateItem("Salaried", (CriteriaOperator)(status == new OperandValue(EmployeeStatus.Salaried)));
result.CreateItem("Commission", (CriteriaOperator)(status == new OperandValue(EmployeeStatus.Commission)));
result.CreateItem("Contract", (CriteriaOperator)(status == new OperandValue(EmployeeStatus.Contract)));
return(result);
}
static Dictionary <string, FilterItem> CreateCustomerStandardFilters()
{
var result = new Dictionary <string, FilterItem>();
var state = new OperandProperty("BillingAddress.State");
result.CreateItem("All", null);
result.CreateItem("Illinois", (CriteriaOperator)(state == "IL"));
result.CreateItem("California", (CriteriaOperator)(state == "CA"));
result.CreateItem("Arizona", (CriteriaOperator)(state == "AR"));
result.CreateItem("Georgia", (CriteriaOperator)(state == "GA"));
return(result);
}
public virtual CriteriaOperator Visit(AggregateOperand theOperand)
{
OperandProperty operand = theOperand.CollectionProperty.Accept(this) as OperandProperty;
CriteriaOperator condition = theOperand.Condition.Accept(this) as CriteriaOperator;
CriteriaOperator expression = theOperand.AggregatedExpression.Accept(this) as CriteriaOperator;
if (object.ReferenceEquals(condition, null) || object.ReferenceEquals(expression, null) || object.ReferenceEquals(operand, null))
{
return(null);
}
return(new AggregateOperand(operand, expression, theOperand.AggregateType, condition));
}
static Dictionary <string, FilterItem> CreateTaskStandardFilters()
{
var result = new Dictionary <string, FilterItem>();
var date = new OperandProperty("DueDate");
var status = new OperandProperty("Status");
result.CreateItem("All", null);
result.CreateItem("Pending", date <= DateTime.Now.Date & status != new OperandValue(EmployeeTaskStatus.Completed));
result.CreateItem("Deferred", (CriteriaOperator)(status == new OperandValue(EmployeeTaskStatus.Deferred)));
result.CreateItem("Completed", (CriteriaOperator)(status == new OperandValue(EmployeeTaskStatus.Completed)));
return(result);
}
private void FreeJoinCompositeCriteria_Execute(object sender, SimpleActionExecuteEventArgs e)
{
Session session = (this.Application.CreateObjectSpace() as XPObjectSpace).Session;
CriteriaOperator joinCriteria =
new OperandProperty("^.EmployeeID") == new OperandProperty("EmployeeID");
JoinOperand joinOperand =
new JoinOperand("Orders", joinCriteria, Aggregate.Count, new OperandProperty("EmployeeID"));
BinaryOperator criteria =
new BinaryOperator(joinOperand, new OperandValue(50), BinaryOperatorType.Greater);
XPCollection <Employee> employees =
new XPCollection <Employee>(session, criteria);
}
static Dictionary <string, FilterItem> CreateProductStandardFilters()
{
var result = new Dictionary <string, FilterItem>();
var category = new OperandProperty("Category");
var name = new OperandProperty("Name");
result.CreateItem("All", null);
result.CreateItem("Video Players", (CriteriaOperator)(category == "VideoPlayers"));
result.CreateItem("Plasma TVs", category == "Televisions" & new FunctionOperator(FunctionOperatorType.Contains, name, "Plasma"));
result.CreateItem("LCD TVs", category == "Televisions" & new FunctionOperator(FunctionOperatorType.Contains, name, "LCD"));
return(result);
}
public FilteringModule()
{
this.InitializeComponent();
grid.ExpandAllGroups();
var orderDate = new OperandProperty("UnboundOrderDate");
var unitPrice = new OperandProperty("UnitPrice");
var today = DateTime.Today;
var nextMonth = today.AddMonths(1);
var filter = orderDate >= new DateTime(today.Year, today.Month, 1) & orderDate < new DateTime(nextMonth.Year, nextMonth.Month, 1);
grid.FilterCriteria = filter;
}
protected override object Visit(OperandProperty theOperand)
{
if (_entityType.GetProperties().All(p => p.Name != theOperand.PropertyName))
{
var mappings = GridViewExtension.GetColumnFieldMapping(_entityType.Name);
if (mappings != null && mappings.Any(m => m.FieldNameMapping == theOperand.PropertyName))
{
var mapping = mappings.First(m => m.FieldNameMapping == theOperand.PropertyName);
theOperand.PropertyName = mapping.FiledClrPath;
}
}
return(base.Visit(theOperand));
}
protected override CriteriaOperator Visit(OperandProperty theOperand)
{
var column = table.GetColumn(theOperand.PropertyName);
if (column != null)
{
return(new QueryOperand(table.GetColumn(theOperand.PropertyName), alias));
}
else
{
return(null);
}
}
/// <summary>
/// Finds the application object by replication key.
/// </summary>
/// <param name="classType">Type of the class.</param>
/// <param name="reference">The reference.</param>
/// <param name="objectSpace">The object space.</param>
/// <returns>Application object</returns>
private static object findApplicationObjectByReplicationKey(Type classType,
IObjectReference reference, IObjectSpace objectSpace)
{
object result = null;
var modelClass = XafDeltaModule.XafApp.FindModelClass(classType);
if (modelClass != null && reference.ReplicationKey != null)
{
var replicationKeyMember = ExtensionsHelper.GetReplicationKeyMember(modelClass.TypeInfo);
var replicationKeyIsCaseInsensitive = modelClass.ReplicationKeyIsCaseInsensitive();
var replicationKeyIsSpaceInsensitive = modelClass.ReplicationKeyIsSpaceInsensitive();
if (replicationKeyMember != null)
{
CriteriaOperator opLeft = new OperandProperty(replicationKeyMember.Name);
CriteriaOperator opRight = new OperandValue(reference.ReplicationKey);
if (replicationKeyIsCaseInsensitive)
{
opLeft = new FunctionOperator(FunctionOperatorType.Upper, opLeft);
opRight = new FunctionOperator(FunctionOperatorType.Upper, opRight);
}
if (replicationKeyIsSpaceInsensitive)
{
opLeft = new FunctionOperator(FunctionOperatorType.Replace, opLeft,
new OperandValue(" "), new OperandValue(String.Empty));
opRight = new FunctionOperator(FunctionOperatorType.Replace, opRight,
new OperandValue(" "), new OperandValue(String.Empty));
}
var keyCriteria = new BinaryOperator(opLeft, opRight, BinaryOperatorType.Equal);
if (replicationKeyMember.MemberInfo.IsAliased)
{
var list = objectSpace.CreateCollection(modelClass.TypeInfo.Type);
result = (from c in list.Cast <object>()
let objKeyValue = replicationKeyMember.MemberInfo.GetValue(c)
where keysMatches(objKeyValue, reference.ReplicationKey,
replicationKeyIsCaseInsensitive, replicationKeyIsSpaceInsensitive)
select c).FirstOrDefault();
}
else
{
result = objectSpace.FindObject(classType, keyCriteria, true);
}
}
}
return(result);
}
private static Condition Between(BetweenOperator betweenOperator)
{
OperandProperty opProperty = betweenOperator.TestExpression as OperandProperty;
OperandValue opValue = betweenOperator.BeginExpression as OperandValue;
OperandValue opValue2 = betweenOperator.EndExpression as OperandValue;
var listType = typeof(List <>).MakeGenericType(opValue.Value.GetType());
var list = Activator.CreateInstance(listType, 2);
var method = listType.GetMethod("Add");
method.Invoke(list, new object[] { opValue.Value });
method.Invoke(list, new object[] { opValue2.Value });
return(new Condition(opProperty.PropertyName, Operator.IsBetween, list));
}
static void Main(string[] args)
{
try
{
DevExpress.Xpo.Metadata.ReflectionClassInfo.SuppressSuspiciousMemberInheritanceCheck = true;
XpoDefault.ConnectionString = MSSqlConnectionProvider.GetConnectionString(".", "sa", "123", "testdb");
using (var session = new Session())
{
var testDetailWithPolymorphicAssociations = session.GetObjectByKey <TestDetailWithPolymorphicAssociations>(2);
var criteria = new OperandProperty("MasterType") == new OperandValue("X");
var collectionOfTestDetailWithPolymorphicAssociations = new XPCollection <TestDetailWithPolymorphicAssociations>(session, criteria);
foreach (var item in collectionOfTestDetailWithPolymorphicAssociations)
{
Debug.WriteLine($"{{Id:{item.Id}, MasterType:\"{item.MasterType}\", TestMasterX.Id:{item.TestMasterX.Id}, Val:\"{item.Val}\"}}");
}
var collectionOfTestMasterX = new XPCollection <TestMasterX>(session);
foreach (var item in collectionOfTestMasterX)
{
Debug.WriteLine($"{{Id:{item.Id}, Val:\"{item.Val}\"}}");
foreach (TestDetailWithPolymorphicAssociations _item_ in item.TestDetailWithPolymorphicAssociations)
{
Debug.WriteLine($"{{Id:{_item_.Id}, MasterType:\"{_item_.MasterType}\", TestMasterX.Id:{_item_.TestMasterX.Id}, Val:\"{_item_.Val}\"}}");
}
}
var testMasterX = new TestMasterX(session);
testMasterX.Save();
testMasterX.Val = testMasterX.Id.ToString();
testDetailWithPolymorphicAssociations = new TestDetailWithPolymorphicAssociations(session);
testDetailWithPolymorphicAssociations.MasterType = "X";
testDetailWithPolymorphicAssociations.Val = $"{testDetailWithPolymorphicAssociations.MasterType}({testMasterX.Id})";
testMasterX.TestDetailWithPolymorphicAssociations.Add(testDetailWithPolymorphicAssociations);
testMasterX.Save();
}
}
catch (CannotLoadObjectsException eException)
{
Console.WriteLine(eException.GetType().FullName + Environment.NewLine + "Message: " + eException.Message + Environment.NewLine + (eException.InnerException != null && !string.IsNullOrEmpty(eException.InnerException.Message) ? "InnerException.Message" + eException.InnerException.Message + Environment.NewLine : string.Empty) + "StackTrace:" + Environment.NewLine + eException.StackTrace);
}
catch (Exception eException)
{
Console.WriteLine(eException.GetType().FullName + Environment.NewLine + "Message: " + eException.Message + Environment.NewLine + (eException.InnerException != null && !string.IsNullOrEmpty(eException.InnerException.Message) ? "InnerException.Message" + eException.InnerException.Message + Environment.NewLine : string.Empty) + "StackTrace:" + Environment.NewLine + eException.StackTrace);
}
}
/// <summary>
/// Finds the application object by replication key.
/// </summary>
/// <param name="classType">Type of the class.</param>
/// <param name="reference">The reference.</param>
/// <param name="objectSpace">The object space.</param>
/// <returns>Application object</returns>
private static object findApplicationObjectByReplicationKey(Type classType,
IObjectReference reference, IObjectSpace objectSpace)
{
object result = null;
var modelClass = XafDeltaModule.XafApp.FindModelClass(classType);
if (modelClass != null && reference.ReplicationKey != null)
{
var replicationKeyMember = ExtensionsHelper.GetReplicationKeyMember(modelClass.TypeInfo);
var replicationKeyIsCaseInsensitive = modelClass.ReplicationKeyIsCaseInsensitive();
var replicationKeyIsSpaceInsensitive = modelClass.ReplicationKeyIsSpaceInsensitive();
if (replicationKeyMember != null)
{
CriteriaOperator opLeft = new OperandProperty(replicationKeyMember.Name);
CriteriaOperator opRight = new OperandValue(reference.ReplicationKey);
if (replicationKeyIsCaseInsensitive)
{
opLeft = new FunctionOperator(FunctionOperatorType.Upper, opLeft);
opRight = new FunctionOperator(FunctionOperatorType.Upper, opRight);
}
if (replicationKeyIsSpaceInsensitive)
{
opLeft = new FunctionOperator(FunctionOperatorType.Replace, opLeft,
new OperandValue(" "), new OperandValue(String.Empty));
opRight = new FunctionOperator(FunctionOperatorType.Replace, opRight,
new OperandValue(" "), new OperandValue(String.Empty));
}
var keyCriteria = new BinaryOperator(opLeft, opRight, BinaryOperatorType.Equal);
if(replicationKeyMember.MemberInfo.IsAliased)
{
var list = objectSpace.CreateCollection(modelClass.TypeInfo.Type);
result = (from c in list.Cast<object>()
let objKeyValue = replicationKeyMember.MemberInfo.GetValue(c)
where keysMatches(objKeyValue, reference.ReplicationKey,
replicationKeyIsCaseInsensitive, replicationKeyIsSpaceInsensitive)
select c).FirstOrDefault();
}
else
result = objectSpace.FindObject(classType, keyCriteria, true);
}
}
return result;
}
/// <summary>
/// Преобразование указанного значения в строку формата Variant
/// </summary>
/// <param name="value">Значение</param>
/// <returns>Строка, представляющее значение в формате Variant</returns>
/// <exception cref="ArgumentException">Значение не поддерживает интерфейс IConvertible</exception>
public static string ValueToString(object value)
{
if (value == null) return null;
string typeString, valueString;
if (value is IConvertible)
{
typeString = Type.GetTypeCode(value.GetType()).ToString();
valueString = Convert.ToString(value, CultureInfo.InvariantCulture);
}
else
throw new ArgumentException();
object t = new OperandProperty(typeString);
object v = new OperandValue(valueString);
return string.Concat(t.ToString(), ":", v.ToString());
}
protected override object Visit(OperandProperty theOperand)
{
return base.Visit(theOperand);
}
public object Visit(OperandProperty theOperand)
{
return BooleanCriteriaStateObject.Value;
}
object IClientCriteriaVisitor.Visit(OperandProperty theOperand)
{
EvaluatorProperty property = PropertyCache[theOperand];
object objectResult = contexts[property.UpDepth].GetPropertyValue(property);
if(objectResult == null)
return null;
#if !SL
IList list = objectResult as IList;
if(list == null) {
IListSource listSource = objectResult as IListSource;
if(listSource != null) {
if(listSource.ContainsListCollection)
list = listSource.GetList();
}
}
if(list != null && list is ITypedList) {
switch(list.Count) {
case 0:
return null;
default:
throw new ArgumentException("single row expected at '" + theOperand.PropertyName + "', provided: " + list.Count.ToString());
case 1:
return list[0];
}
}
#endif
return objectResult;
}
private static CriteriaOperator ProcessSimpleNullExpression(OperandProperty property, ExpressionType expressionType)
{
if (expressionType == ExpressionType.Equal)
return property.IsNull();
if (expressionType == ExpressionType.NotEqual)
return property.IsNotNull();
throw new Exception("Cannot supply null value to operator " + expressionType);
}
/// <summary>
/// Получение выражения запроса
/// </summary>
/// <param name="fieldRef"></param>
/// <returns></returns>
public override CriteriaOperator GetExpression()
{
var fieldRef = new OperandProperty(FilterColumn.Property);
if (Value.BCheckBoxNull.HasValue)
{
if (!Value.BCheckBoxNull.Value)
{
return new UnaryOperator(UnaryOperatorType.IsNull, new OperandProperty(FilterColumn.Property));
}
else
{
return new UnaryOperator(UnaryOperatorType.Not, new UnaryOperator(UnaryOperatorType.IsNull, new OperandProperty(FilterColumn.Property)));
}
}
if (Value.SelectedTab == 0)
{
DateTime? obj = Value.DateTimeEdit1Value;
if (!obj.HasValue)
return null;
Operators op = (Operators)comboBox1.Items[Value.ComboBox1SelectedIndex];
return BuildQueryExpression(op, fieldRef, obj.Value);
}
else if (Value.SelectedTab == 1)
{
DateTime? o1 = Value.DateTimeEdit2Value;
DateTime? o2 = Value.DateTimeEdit3Value;
if (o1.HasValue)
{
if (o2.HasValue)
{
Operators op1 = Operators.Invert((Operators)comboBox2.Items[Value.ComboBox2SelectedIndex]);
Operators op2 = (Operators)comboBox3.Items[Value.ComboBox3SelectedIndex];
return new GroupOperator(GroupOperatorType.And,
BuildQueryExpression(op1, fieldRef, o1.Value),
BuildQueryExpression(op2, fieldRef, o2.Value));
}
else
{
// введено только первое значение
Operators op = Operators.Invert((Operators)comboBox2.Items[Value.ComboBox2SelectedIndex]);
return BuildQueryExpression(op, fieldRef, o1.Value);
}
}
else if (o2 != null)
{
// введено только второе значение
Operators op = (Operators)comboBox3.Items[Value.ComboBox3SelectedIndex];
return BuildQueryExpression(op, fieldRef, o2.Value);
}
else
{
// ничего не введено
return null;
}
}
else if (Value.SelectedTab == 2)
{
DateTime? obj = null;
switch (Value.ComboBoxConditionSelectedIndex)
{
case 0:
// сегодня
DateTime today = DateTime.Today;
obj = today;
break;
case 1:
// первое число
DateTime first = new DateTime(DateTime.Today.Year, DateTime.Today.Month, 1);
obj = first;
break;
case 2:
// последнее число
DateTime last = new DateTime(DateTime.Today.Year, DateTime.Today.Month, 1);
last = last.AddMonths(1).AddDays(-1);
obj = last;
break;
}
if (!obj.HasValue)
return null;
if (Value.EditShiftYearValue.HasValue)
obj = obj.Value.AddYears(Value.EditShiftYearValue.Value);
if (Value.EditShiftMonthValue.HasValue)
obj = obj.Value.AddMonths(Value.EditShiftMonthValue.Value);
if (Value.EditShiftDayValue.HasValue)
obj = obj.Value.AddDays(Value.EditShiftDayValue.Value);
Operators op = (Operators)comboBoxOperators2.Items[Value.ComboBoxOperators2SelectedIndex];
return BuildQueryExpression(op, fieldRef, obj.Value);
}
else if (Value.SelectedTab == 3)
{
DateTime? obj = Value.ExactDateTimeEditValue;
if (!obj.HasValue)
return null;
Operators op = (Operators)operatorsComboBox.Items[Value.ComboBox4SelectedIndex];
return new BinaryOperator(fieldRef, new OperandValue(obj.Value), op.GetOperators()[0]);
}
else
{
return null;
}
}
public virtual object Visit(OperandProperty theOperand)
{
if(theOperand.PropertyName.IndexOf('.') < 0
#if !SL
&& Properties.Find(theOperand.PropertyName, false) == null
#endif
&& !EvaluatorProperty.GetIsThisProperty(theOperand.PropertyName)) {
throw new InvalidPropertyPathException(string.Format(CultureInfo.InvariantCulture, FilteringExceptionsText.ExpressionEvaluatorInvalidPropertyPath, theOperand.ToString()));
}
return null;
}
private static OperandProperty AddKeyProperty(ITypeInfo pti, OperandProperty op)
{
return new OperandProperty(op.PropertyName + "." + pti.KeyMember.Name);
}
private string ProcessOperandProperty(OperandProperty operandProperty, string alias)
{
var operandPropertyName = operandProperty.PropertyName;
if (operandPropertyName.StartsWith(ConcatOperandOperator.OPERAND_PREFIX))
{
return "CONCAT_SMART(" +
operandPropertyName
.Remove(ConcatOperandOperator.OPERAND_PREFIX)
.Split(ConcatOperandOperator.PROPERTY_DELIMETER)
.ToString(x => alias + "." + x, ", ") +
")";
}
if (operandPropertyName.StartsWith(FirstNbytesOperandOperator.OPERAND_PREFIX))
{
var query = operandPropertyName.Remove(FirstNbytesOperandOperator.OPERAND_PREFIX)
.Split(FirstNbytesOperandOperator.DELIMETER);
if (query.Length == 2)
{
return "FIRST_NBYTES({0}.{1}, {2})".FillWith(alias, query[0], query[1]);
}
}
return alias + "." + operandPropertyName;
}
protected override string FormatOperandProperty(OperandProperty operand)
{
return operand.PropertyName;
}
public object Visit(OperandProperty theOperand){
return theOperand;
}
protected CriteriaOperator GetFilterCriterion(ComboBoxEdit pi, BaseEdit e, bool IsField, string FieldName)
{
if (this.IsFilterExist(pi, e))
{
OperandProperty opLeft = new OperandProperty(this.column.FieldName);
int num = this.OperationNumber(pi.SelectedItem);
if (num < 0)
{
return null;
}
switch (((ExpressionOperators) this.operators[0, num]))
{
case ExpressionOperators.Equals:
return (CriteriaOperator) (opLeft == this.GetRightOperand(e, IsField, FieldName));
case ExpressionOperators.NotEquals:
return (CriteriaOperator) (opLeft != this.GetRightOperand(e, IsField, FieldName));
case ExpressionOperators.Greater:
return (CriteriaOperator) (opLeft > this.GetRightOperand(e, IsField, FieldName));
case ExpressionOperators.GreaterOrEqual:
return (CriteriaOperator) (opLeft >= this.GetRightOperand(e, IsField, FieldName));
case ExpressionOperators.Less:
return (CriteriaOperator) (opLeft < this.GetRightOperand(e, IsField, FieldName));
case ExpressionOperators.LessOrEqual:
return (CriteriaOperator) (opLeft <= this.GetRightOperand(e, IsField, FieldName));
case ExpressionOperators.Blanks:
return opLeft.IsNull();
case ExpressionOperators.NonBlanks:
return opLeft.IsNotNull();
case ExpressionOperators.Like:
return new BinaryOperator(opLeft, this.PatchLikeOperand(this.GetRightOperand(e, IsField, FieldName)), BinaryOperatorType.Like);
//暂时未处理
//case ExpressionOperators.NotLike:
// return CriteriaOperator.op_LogicalNot(new BinaryOperator(opLeft, this.PatchLikeOperand(this.GetRightOperand(e, IsField, FieldName)), BinaryOperatorType.Like));
}
}
return null;
}
public override Object Visit(OperandProperty operand)
{
string result = operand.PropertyName;
if (!String.IsNullOrWhiteSpace(operand.PropertyName))
{
result = currentTableName + "." + operand.PropertyName;
}
return new CriteriaToStringVisitResult(result);
}
public static EvaluatorProperty Create(OperandProperty property)
{
return new EvaluatorProperty(property.PropertyName);
}
/// <summary>
/// Построить выражение
/// </summary>
/// <param name="op">Оператор</param>
/// <param name="fieldRef">Поле</param>
/// <param name="o">Значение</param>
/// <returns></returns>
protected CriteriaOperator BuildQueryExpression(Operators op, OperandProperty fieldRef, DateTime o)
{
if (op == Operators.NotEqual)
{
return new BinaryOperator(new FunctionOperator(FunctionOperatorType.GetDate, fieldRef), new OperandValue(o), BinaryOperatorType.NotEqual);
}
else if (op.Binary)
{
return new GroupOperator(op.Or ? GroupOperatorType.Or : GroupOperatorType.And,
new BinaryOperator(new FunctionOperator(FunctionOperatorType.GetDate, fieldRef), new OperandValue(o), op.GetOperators()[0]),
new BinaryOperator(new FunctionOperator(FunctionOperatorType.GetDate, fieldRef), new OperandValue(o), op.GetOperators()[1])
);
}
else
{
return new BinaryOperator(new FunctionOperator(FunctionOperatorType.GetDate, fieldRef), new OperandValue(o), op.GetOperators()[0]);
}
}
public EvaluatorProperty this[OperandProperty property]
{
get {
EvaluatorProperty result;
if(!store.TryGetValue(property, out result)) {
result = EvaluatorProperty.Create(property);
store.Add(property, result);
}
return result;
}
}
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(OperandProperty theOperand)
{
return evaluatorCore.Visit(theOperand);
}
/// <summary>
/// Получить выражение фильтра
/// </summary>
/// <param name="fieldRef">Ссылка на поле запроса</param>
/// <returns>Выражение фильтра</returns>
public override CriteriaOperator GetExpression()
{
if (Value.Nulls.HasValue)
{
if (Value.Nulls.Value)
{
return new UnaryOperator(UnaryOperatorType.IsNull, new OperandProperty(FilterColumn.Property));
}
else
{
return new UnaryOperator(UnaryOperatorType.Not, new UnaryOperator(UnaryOperatorType.IsNull, new OperandProperty(FilterColumn.Property)));
}
}
else
{
string filter = GetFilterText();
if (string.IsNullOrEmpty(filter))
return null;
else
{
CriteriaOperator field = new OperandProperty(FilterColumn.Property);
if (!Value.CaseSensitive)
{
return new BinaryOperator(new FunctionOperator(FunctionOperatorType.Upper, field), new OperandValue(filter.ToUpper()), BinaryOperatorType.Like);
}
else
{
return new BinaryOperator(field, new OperandValue(filter), BinaryOperatorType.Like);
}
}
}
}
/// <summary>
/// Получение выражения запроса
/// </summary>
/// <param name="fieldRef"></param>
/// <returns></returns>
public override CriteriaOperator GetExpression()
{
var fieldRef = new OperandProperty(FilterColumn.Property);
if (Value.BCheckBoxNull.HasValue)
{
if (!Value.BCheckBoxNull.Value)
{
return new UnaryOperator(UnaryOperatorType.IsNull, new OperandProperty(FilterColumn.Property));
}
else
{
return new UnaryOperator(UnaryOperatorType.Not, new UnaryOperator(UnaryOperatorType.IsNull, new OperandProperty(FilterColumn.Property)));
}
}
else
{
if (Value.BCheckedListBox == null) return null;
var type = Type;
if (type.IsGenericType && type.GetGenericTypeDefinition().FullName == "System.Nullable`1" && type.GenericTypeArguments[0].IsEnum)
{
type = type.GenericTypeArguments[0];
}
EnumDescriptor ed = new EnumDescriptor(type);
List<string> items = new List<string>();
for (int i = 0; i < Value.BCheckedListBox.Length; i++)
{
if (Value.BCheckedListBox[i])
{
items.Add((string)checkedListBox1.Items[i]);
}
}
if (items.Count == 0) return null;
int val = 0;
bool flags = false;
bool flag_none = false;
// Определение на флаговый атрибут
Type enumType = type.UnderlyingSystemType;
Object[] attrs = enumType.GetCustomAttributes(typeof(FlagsAttribute), false);
if (attrs.Length > 0)
{
flags = true;
}
// Используется ли значение "никакой" в фильтре флага
if (flags)
{
foreach (var enumValue in Enum.GetValues(type))
{
if ((int)enumValue == 0)
{
flag_none = true;
break;
}
}
}
CriteriaOperator[] values = null;
if (flag_none)
{
// Для значения "никакой" используется обычное условие равенства фильтруемого поля нулю
values = new CriteriaOperator[1];
values[0] = new BinaryOperator(fieldRef, new OperandValue(0), BinaryOperatorType.Equal);
}
else
{
if (!flags)
{
values = new CriteriaOperator[items.Count];
}
else
{
values = new CriteriaOperator[1];
}
for (int i = 0; i < items.Count; i++)
{
object enumVal = null;
foreach (var enumValue in Enum.GetValues(type))
{
if (ed.GetCaption(enumValue) == items[i])
{
enumVal = enumValue;
break;
}
}
if (flags)
{
val |= (int)enumVal;
}
else
values[i] = new BinaryOperator(fieldRef, new OperandValue(enumVal), BinaryOperatorType.Equal);
}
if (flags)
{
values[0] = new BinaryOperator(fieldRef, new OperandValue(val), BinaryOperatorType.Equal);
}
}
return GroupOperator.Or(values);
}
}
