private static void InitUsers(ApplicationDbContext context)
{
var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(context));
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(context));
roleManager.Create(new IdentityRole {
Name = Consts.Consts.AdminRole
});
roleManager.Create(new IdentityRole {
Name = Consts.Consts.UserRole
});
foreach (var userRole in ConstantHelper.GetConstantFields(new CommonRoles()))
{
if (context.Roles.Any(r => r.Name == userRole.Value))
{
continue;
}
var role = new IdentityRole {
Name = userRole.Value
};
roleManager.Create(role);
}
var userHelper = new UserHelper(context);
var emails = new List <string>();
foreach (var profile in Profiles)
{
var email = profile[1] + EmailDomain;
var user = userHelper.GetUser(email);
emails.Add(email);
if (user != null)
{
continue;
}
user = new ApplicationUser
{
FirstName = profile[0],
LastName = profile[1],
Email = email,
UserName = email,
EmailConfirmed = true,
DateCreated = DateTime.Now
};
userManager.Create(user, UserPasswrod);
context.SaveChanges();
if (AdminEmails.Contains(user.Email))
{
userManager.AddToRole(user.Id, Consts.Consts.AdminRole);
userManager.AddToRole(user.Id, CommonRoles.GlobalAdmin);
}
userManager.AddToRole(user.Id, Consts.Consts.UserRole);
}
context.SaveChanges();
}
private static Expression PredefinedAtom_StringLike(ParseTreeNode root, string methodName, CompilerState state)
{
Expression value;
Expression pattern;
var method = PrepareStringInstanceMethodCall(methodName, ExpressionTreeExtensions.UnwindTupleExprList(root), state, out value, out pattern);
var constValue = value as ConstantExpression;
var constPattern = pattern as ConstantExpression;
if (!ReferenceEquals(constValue, null) && !ReferenceEquals(constPattern, null))
{
return(constValue.Value == null || constPattern.Value == null
? Expression.Constant(false)
: ConstantHelper.TryEvalConst(root, method, constValue, constPattern, Expression.Constant(StringComparison.OrdinalIgnoreCase)));
}
Expression target = Expression.Call(value, method, pattern, Expression.Constant(StringComparison.OrdinalIgnoreCase));
if (target.Type == typeof(Int32))
{
target = Expression.GreaterThanOrEqual(target, Expression.Constant(0, target.Type));
}
return(Expression.Condition(
Expression.ReferenceEqual(Expression.Constant(null), value), Expression.Constant(false),
Expression.Condition(
Expression.ReferenceEqual(Expression.Constant(null), pattern), Expression.Constant(false),
target)));
}
private static Expression PredefinedAtom_Convert(ParseTreeNode root, CompilerState state)
{
root.RequireChildren(2);
var arg1Node = root.RequireChild(null, 1, 0, 0);
var value = state.ParentRuntime.Analyze(arg1Node, state).RemoveNullability();
var arg2Node = root.RequireChild("string", 1, 0, 1);
var targetType = RequireSystemType(arg2Node);
// maybe we don't have to change type, or simply cast the numeric type?
Expression adjusted;
if (ExpressionTreeExtensions.TryAdjustReturnType(root, value, targetType, out adjusted))
{
return(adjusted);
}
if (value.IsString())
{
// or maybe they are asking to convert Base64 string into binary value?
if (targetType.IsBinary())
{
return(ConstantHelper.TryEvalConst(root, targetType.GetConstructor(new[] { typeof(string) }), value));
}
// maybe we can parse string to a number?
if ((targetType.IsNumeric() || targetType.IsDateTime() || targetType.IsTimeSpan() || targetType.IsGuid()))
{
var parseMethod = ReflectionHelper.GetOrAddMethod1(targetType, "Parse", value.Type);
return(ConstantHelper.TryEvalConst(root, parseMethod, value));
}
}
// maybe we can generate a string from a number or other object?
if (targetType.IsString())
{
if (value.IsBinary())
{
var toStringMethod = ReflectionHelper.GetOrAddMethod1(value.Type, "ToBase64String", value.Type);
return(ConstantHelper.TryEvalConst(root, toStringMethod, value));
}
else
{
var toStringMethod = ReflectionHelper.GetOrAddMethod0(value.Type, "ToString");
return(ConstantHelper.TryEvalConst(root, toStringMethod, value));
}
}
// seems like cast does not apply, let's use converter
try
{
var convertMethod = ReflectionHelper.GetOrAddMethod1(typeof(Convert), "To" + targetType.Name, value.Type);
return(ConstantHelper.TryEvalConst(root, convertMethod, value));
}
catch
{
throw new CompilationException(string.Format("There is no conversion from type {0} to type {1}", value.Type.FullName, targetType.FullName), arg2Node);
}
}
// GET: Resource
public ActionResult Js(string name)
{
string strScript = string.Empty;
if ("Constant" == name)
{
strScript = ConstantHelper.GetScript();
}
return(JavaScript(strScript));
}
private static Expression PredefinedAtom_ToDateTime(ParseTreeNode root, CompilerState state)
{
root.RequireChildren(2);
var argNodes = root.RequireChild(null, 1, 0);
if (argNodes.ChildNodes.Count == 3 || argNodes.ChildNodes.Count == 6 || argNodes.ChildNodes.Count == 7)
{
var args = new Expression[argNodes.ChildNodes.Count];
var typeArray = new Type[args.Length];
var typeInt32 = typeof(Int32);
for (var i = 0; i < args.Length; i++)
{
var node = argNodes.RequireChild(null, i);
var expr = ExpressionTreeExtensions.AdjustReturnType(node, state.ParentRuntime.Analyze(node, state), typeInt32);
args[i] = expr;
typeArray[i] = typeInt32;
}
var ctr = typeof(DateTime).GetConstructor(typeArray);
if (ctr == null)
{
throw new Exception(string.Format("Could not locate datetime constructor with {0} int arguments", typeArray.Length));
}
return(ConstantHelper.TryEvalConst(root, ctr, args));
}
if (argNodes.ChildNodes.Count == 2)
{
var arg1Node = root.RequireChild(null, 1, 0, 0);
var valueString = state.ParentRuntime.Analyze(arg1Node, state).RemoveNullability();
valueString.RequireString(arg1Node);
var arg2Node = root.RequireChild(null, 1, 0, 1);
var formatString = state.ParentRuntime.Analyze(arg2Node, state).RemoveNullability();
formatString.RequireString(arg2Node);
return(ConstantHelper.TryEvalConst(root, ReflectionHelper.DateTimeParseExact,
valueString, formatString, Expression.Constant(null, typeof(IFormatProvider))));
}
if (argNodes.ChildNodes.Count == 1)
{
var arg1Node = root.RequireChild(null, 1, 0, 0);
var value = state.ParentRuntime.Analyze(arg1Node, state).RemoveNullability();
value.RequireInteger(arg1Node);
var dateTimeFromBinary = ReflectionHelper.GetOrAddMethod1(typeof(DateTime), "FromBinary", typeof(Int64));
return(ConstantHelper.TryEvalConst(root, dateTimeFromBinary, value));
}
throw new CompilationException("ToDateTime has four overloads: with two, three, six and seven arguments", root);
}
private Expression BuildBetweenExpression(ParseTreeNode root, CompilerState state)
{
root.RequireChildren(6);
var variableNode = root.ChildNodes[0];
var notOpt = root.RequireChild("notOpt", 1);
root.RequireChild("between", 2);
root.RequireChild("and", 4);
var argument = Analyze(variableNode, state).RemoveNullability();
var leftNode = root.ChildNodes[3];
var leftExpr = Analyze(leftNode, state);
leftExpr.RequireNonVoid(leftNode);
leftExpr = ExpressionTreeExtensions.AdjustReturnType(leftNode, leftExpr, argument.Type);
var rightNode = root.ChildNodes[5];
var rightExpr = Analyze(rightNode, state);
rightExpr.RequireNonVoid(rightNode);
rightExpr = ExpressionTreeExtensions.AdjustReturnType(rightNode, rightExpr, argument.Type);
Expression lower, upper;
if (argument.IsString())
{
lower = ConstantHelper.TryEvalConst(leftNode, PrepareStringComparison(leftNode, leftExpr, argument), Expression.Constant(0), ExpressionType.LessThanOrEqual);
upper = ConstantHelper.TryEvalConst(rightNode, PrepareStringComparison(rightNode, rightExpr, argument), Expression.Constant(0), ExpressionType.GreaterThanOrEqual);
}
else
{
lower = ConstantHelper.TryEvalConst(leftNode, argument, leftExpr, ExpressionType.GreaterThanOrEqual);
upper = ConstantHelper.TryEvalConst(rightNode, argument, rightExpr, ExpressionType.LessThanOrEqual);
}
var result = ConstantHelper.TryEvalConst(root, lower, upper, ExpressionType.AndAlso);
if (notOpt.ChildNodes.Count > 0)
{
result = ConstantHelper.TryEvalConst(root, result, ExpressionType.Not);
}
return(result);
}
private static Expression PredefinedAtom_Cast(ParseTreeNode root, CompilerState state)
{
root.RequireChildren(2);
var arg1Node = root.RequireChild(null, 1, 0, 0);
var value = state.ParentRuntime.Analyze(arg1Node, state).RemoveNullability();
var arg2Node = root.RequireChild("string", 1, 0, 1);
var targetType = RequireSystemType(arg2Node);
if (value.IsVoid())
{
return(ExpressionTreeExtensions.GetDefaultExpression(targetType));
}
// bluntly attempt to convert the type; will throw if types are not compatible
return(ConstantHelper.TryEvalConst(root, value, ExpressionType.Convert, targetType));
}
private static Expression PredefinedAtom_IsDefault(ParseTreeNode root, CompilerState state)
{
var funArgs = ExpressionTreeExtensions.UnwindTupleExprList(root.RequireChild("exprList", 1, 0));
funArgs.RequireChildren(1);
var arg1Node = funArgs.ChildNodes[0];
var value = state.ParentRuntime.Analyze(arg1Node, state).RemoveNullability();
if (value.IsString())
{
if (value is ConstantExpression)
{
return(Expression.Constant(string.IsNullOrEmpty((string)((ConstantExpression)value).Value), typeof(Boolean)));
}
return(Expression.Call(ReflectionHelper.StringIsNullOrEmpty, value));
}
return(ConstantHelper.TryEvalConst(root, value, Expression.Default(value.Type), ExpressionType.Equal));
}
private Expression BuildIsNullPredicate(ParseTreeNode root, CompilerState state, bool compareIsNull)
{
var value = state.ParentRuntime.Analyze(root, state);
// IS NULL
if (compareIsNull)
{
return(value.Type.IsNullableType()
? ConstantHelper.TryEvalConst(root, ConstantHelper.TryEvalConst(root, value.Type.GetField("HasValue"), value), ExpressionType.Not, typeof(bool))
: value.Type.IsValueType
? Expression.Constant(false)
: ConstantHelper.TryEvalConst(root, value, Expression.Constant(null), ExpressionType.Equal));
}
// IS NOT NULL
return(value.Type.IsNullableType()
? ConstantHelper.TryEvalConst(root, value.Type.GetField("HasValue"), value)
: value.Type.IsValueType
? Expression.Constant(true)
: ConstantHelper.TryEvalConst(root, value, Expression.Constant(null), ExpressionType.NotEqual));
}
private static void AddInitialRoles(IdentityContext context)
{
Dictionary <string, string> roles = ConstantHelper.GetDisplayNamesDictionary <RoleNames>();
foreach (var role in roles)
{
if (context.Roles.Any(x => x.Name == role.Key))
{
continue;
}
context.Roles.Add(new ApplicationRole
{
Id = Guid.NewGuid().ToString(),
Name = role.Key,
Title = role.Value,
Description = "Lorem ipsum dolor sit a met."
});
context.SaveChanges();
}
}
private static Expression PrepareStringComparison(ParseTreeNode root, Expression leftExpr, Expression rightExpr)
{
var compare = ReflectionHelper.StringComparerCompare;
return(ConstantHelper.TryEvalConst(root, compare, Expression.Constant(StringComparer.OrdinalIgnoreCase), leftExpr, rightExpr));
}
private Expression BuildUnaryExpression(ParseTreeNode root, CompilerState state)
{
root.RequireChildren(2, 4);
ParseTreeNode targetNode;
string op;
if (root.ChildNodes.Count == 2)
{
targetNode = root.ChildNodes[1];
op = root.ChildNodes[0].Token.ValueString;
}
else
{
// we should have IS NULL or IS NOT NULL operator here
targetNode = root.ChildNodes[0];
var k1 = root.RequireChild("is", 1).Term.Name;
var k2 = root.RequireChild(null, 2).Term.Name;
var k3 = root.ChildNodes.Count == 4 ? root.RequireChild(null, 3).Term.Name : null;
if (0 != StringComparer.OrdinalIgnoreCase.Compare(k1, "is") ||
(k3 == null && 0 != StringComparer.OrdinalIgnoreCase.Compare(k2, "null")) ||
(k3 != null && (0 != StringComparer.OrdinalIgnoreCase.Compare(k2, "not") || 0 != StringComparer.OrdinalIgnoreCase.Compare(k3, "null")))
)
{
throw new CompilationException("IS NULL or IS NOT NULL expected", root);
}
op = k3 == null ? "is null" : "is not null";
}
switch (op)
{
case "-":
{
var target = Analyze(targetNode, state).RemoveNullability();
target.RequireNumeric(targetNode);
return(ConstantHelper.TryEvalConst(root, target, ExpressionType.Negate, target.Type));
}
case "+":
{
var target = Analyze(targetNode, state).RemoveNullability();
target.RequireNumeric(targetNode);
return(target);
}
case "~":
{
var target = Analyze(targetNode, state).RemoveNullability();
target.RequireInteger(targetNode);
return(ConstantHelper.TryEvalConst(root, target, ExpressionType.Not, target.Type));
}
case "is null":
return(BuildIsNullPredicate(targetNode, state, true));
case "is not null":
return(BuildIsNullPredicate(targetNode, state, false));
default:
{
var target = Analyze(targetNode, state).RemoveNullability();
if (0 == StringComparer.OrdinalIgnoreCase.Compare("not", op))
{
target.RequireBoolean(targetNode);
return(ConstantHelper.TryEvalConst(root, target, ExpressionType.Not, target.Type));
}
throw new CompilationException(
string.Format(
"Unary operator {0} not supported for type {1}", op, target.Type.FullName), root);
}
}
}
public static async Task <List <SendDataMailAccount> > GetMailAccounts()
{
var sqlConStr = ConstantHelper.GetConnectionString();
List <SendDataMailAccount> sendDataMailAccountList = new List <SendDataMailAccount>();
try
{
using (SqlConnection connectionQueryData = new SqlConnection(sqlConStr))
{
if (connectionQueryData.State == System.Data.ConnectionState.Closed)
{
connectionQueryData.Open();
}
#region Execute Command
var selectQuery = @"
SELECT [MAILACCOUNTID]
,[MAILACCOUNTTITLE]
,[MAILSERVERNAME]
,[MAILACCOUNTNAME]
,[MAILACCOUNTPASSWORD]
,[MAILPOP3PORT]
,[MAILSMTPPORT]
,[FROMMAILADDRESS]
FROM [dbo].[PLG_SENDDATA_MAILACCOUNT]
WHERE ACTIVE = 1 AND ISDEFAULT = 1
";
using (SqlCommand command = new SqlCommand(selectQuery, connectionQueryData))
{
DataTable dataTable = new DataTable();
// create data adapter
SqlDataAdapter da = new SqlDataAdapter(command);
// this will query your database and return the result to your datatable
da.Fill(dataTable);
for (int i = 0; i < dataTable.Rows.Count; i++)
{
var id = Int32.Parse(dataTable.Rows[i]["MAILACCOUNTID"].ToString());
var title = dataTable.Rows[i]["MAILACCOUNTTITLE"]?.ToString();
var serverName = dataTable.Rows[i]["MAILSERVERNAME"]?.ToString();
var accountName = dataTable.Rows[i]["MAILACCOUNTNAME"]?.ToString();
var accountPass = dataTable.Rows[i]["MAILACCOUNTPASSWORD"]?.ToString();
var pop3Port = Int32.Parse(dataTable.Rows[i]["MAILPOP3PORT"].ToString());
var smptpPort = Int32.Parse(dataTable.Rows[i]["MAILSMTPPORT"].ToString());
var fromAddress = dataTable.Rows[i]["FROMMAILADDRESS"]?.ToString();
var sendDataMailAccount = new SendDataMailAccount()
{
AccountId = id,
AccountName = accountName,
AccountPass = accountPass,
Active = 1,
FromMailAddress = fromAddress,
MailPop3Port = pop3Port,
MailSmtpPort = smptpPort,
ServerName = serverName,
Title = title
};
sendDataMailAccountList.Add(sendDataMailAccount);
}
}
#endregion
try
{
connectionQueryData.Close();
}
catch (Exception)
{
}
}
}
catch (Exception ex)
{
//TODO:Log
}
return(sendDataMailAccountList);
}
public static async Task <int> InsertSendDataItem(SendDataItem sendDataDetail)
{
try
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
var conStr = ConstantHelper.GetConnectionString();
using (SqlConnection connection = new SqlConnection(conStr))
{
if (connection.State == System.Data.ConnectionState.Closed)
{
connection.Open();
}
#region commandStr
var insertCommand = @"
INSERT INTO [dbo].[PLG_SENDDATA_ITEMS]
([SCHED_NAME]
,[JOB_NAME]
,[JOB_GROUP]
,[TRIGGER_NAME]
,[TRIGGER_GROUP]
,[TYPE]
,[FROM]
,[RECIPIENTLIST]
,[CC]
,[BCC]
,[REPLYTO]
,[BODY]
,[SENTDATE]
,[ERRORMSG]
,[ACTIVE]
,[CREATEDDATE])
VALUES
(@SCHED_NAME
,@JOB_NAME
,@JOB_GROUP
,@TRIGGER_NAME
,@TRIGGER_GROUP
,@TYPE
,@FROM
,@RECIPIENTLIST
,@CC
,@BCC
,@REPLYTO
,@BODY
,@SENTDATE
,@ERRORMSG
,1
,@CREATEDDATE)
";
#endregion
#region Execute Command
using (SqlCommand command = new SqlCommand(insertCommand, connection))
{
command.Parameters.AddWithValue("@SCHED_NAME", sendDataDetail.ScheduleName);
command.Parameters.AddWithValue("@JOB_NAME", sendDataDetail.JobName);
command.Parameters.AddWithValue("@JOB_GROUP", sendDataDetail.JobGroup);
command.Parameters.AddWithValue("@TRIGGER_NAME", sendDataDetail.TriggerName);
command.Parameters.AddWithValue("@TRIGGER_GROUP", sendDataDetail.TriggerGroup);
command.Parameters.AddWithValue("@TYPE", sendDataDetail.Type);
command.Parameters.AddWithValue("@FROM", sendDataDetail.From);
command.Parameters.AddWithValue("@RECIPIENTLIST", sendDataDetail.Recipient);
command.Parameters.AddWithValue("@CC", sendDataDetail.Cc);
command.Parameters.AddWithValue("@BCC", sendDataDetail.Bcc);
command.Parameters.AddWithValue("@BODY", sendDataDetail.Body);
if (string.IsNullOrEmpty(sendDataDetail.ReplyTo) == false)
{
command.Parameters.AddWithValue("@REPLYTO", sendDataDetail.ReplyTo);
}
else
{
command.Parameters.AddWithValue("@REPLYTO", DBNull.Value);
}
if (sendDataDetail.SentDate.HasValue)
{
command.Parameters.AddWithValue("@SENTDATE", sendDataDetail.SentDate);
}
else
{
command.Parameters.AddWithValue("@SENTDATE", DBNull.Value);
}
if (string.IsNullOrEmpty(sendDataDetail.ErrorMsg) == false)
{
command.Parameters.AddWithValue("@ERRORMSG", sendDataDetail.ErrorMsg);
}
else
{
command.Parameters.AddWithValue("@ERRORMSG", DBNull.Value);
}
command.Parameters.AddWithValue("@CREATEDDATE", sendDataDetail.CreatedDate);
var res = await command.ExecuteNonQueryAsync();
stopwatch.Stop();
if (res < 1)
{
LoggerService.GetLogger(ConstantHelper.JobLog).Log(new LogItem()
{
LoggerName = ConstantHelper.JobLog,
Title = "InsertSendDataItem Executed",
Message = "InsertSendDataItem Executed",
LogItemProperties = new List <LogItemProperty>()
{
new LogItemProperty("ServiceName", ConstantHelper.JobLog),
new LogItemProperty("ActionName", "InsertSendDataItem"),
new LogItemProperty("FormData", sendDataDetail),
new LogItemProperty("ElapsedTimeAssn", stopwatch.Elapsed.TotalSeconds),
},
Exception = new ArgumentException("Insert Failed !"),
LogLevel = LogLevel.Error
});
}
else
{
LoggerService.GetLogger(ConstantHelper.JobLog).Log(new LogItem()
{
LoggerName = ConstantHelper.JobLog,
Title = "InsertSendDataItem Executed",
Message = "InsertSendDataItem Executed",
LogItemProperties = new List <LogItemProperty>()
{
new LogItemProperty("ServiceName", ConstantHelper.JobLog),
new LogItemProperty("ActionName", "InsertSendDataItem"),
new LogItemProperty("ElapsedTimeAssn", stopwatch.Elapsed.TotalSeconds),
},
LogLevel = LogLevel.Trace
});
}
return(res);
}
#endregion
}
}
catch (Exception ex)
{
LoggerService.GetLogger(ConstantHelper.JobLog).Log(new LogItem()
{
LoggerName = ConstantHelper.JobLog,
Title = "InsertSendDataItem Error",
Message = ex.Message,
LogItemProperties = new List <LogItemProperty>()
{
new LogItemProperty("ServiceName", ConstantHelper.JobLog),
new LogItemProperty("ActionName", "InsertSendDataItem"),
new LogItemProperty("FormData", sendDataDetail),
},
LogLevel = LogLevel.Error,
Exception = ex
});
return(-1);
}
}
private Expression BuildBinaryExpression(ParseTreeNode root, CompilerState state)
{
root.RequireChildren(3);
var leftNode = root.ChildNodes[0];
var leftExpr = Analyze(leftNode, state);
var op = GetBinaryOperator(root.ChildNodes[1]);
if (op == "in" || op == "not in")
{
return(BuildInclusionExpression(root, leftExpr, op, state));
}
var rightNode = root.ChildNodes[2];
var rightExpr = Analyze(rightNode, state);
if (!ExpressionTreeExtensions.TryAdjustVoid(ref leftExpr, ref rightExpr))
{
throw new CompilationException("This operation is not defined when both arguments are void", root);
}
Expression expr;
leftExpr = leftExpr.RemoveNullability();
rightExpr = rightExpr.RemoveNullability();
if (leftExpr.IsDateTime() && rightExpr.IsDateTime() ||
leftExpr.IsTimeSpan() && rightExpr.IsTimeSpan())
{
#region DateTime and DateTime, or TimeSpan and TimeSpan
switch (op)
{
case "+":
if (leftExpr.IsDateTime() && rightExpr.IsDateTime())
{
throw new CompilationException("Datetime values cannot be added to one another", root);
}
expr = ConstantHelper.TryEvalConst(root, leftExpr, rightExpr, ExpressionType.Add);
break;
case "-":
expr = ConstantHelper.TryEvalConst(root, leftExpr, rightExpr, ExpressionType.Subtract);
break;
case "=":
expr = ConstantHelper.TryEvalConst(root, leftExpr, rightExpr, ExpressionType.Equal);
break;
case "!=":
case "<>":
expr = ConstantHelper.TryEvalConst(root, leftExpr, rightExpr, ExpressionType.NotEqual);
break;
case ">":
expr = ConstantHelper.TryEvalConst(root, leftExpr, rightExpr, ExpressionType.GreaterThan);
break;
case "<":
expr = ConstantHelper.TryEvalConst(root, leftExpr, rightExpr, ExpressionType.LessThan);
break;
case "<=":
case "!>":
expr = ConstantHelper.TryEvalConst(root, leftExpr, rightExpr, ExpressionType.LessThanOrEqual);
break;
case ">=":
case "!<":
expr = ConstantHelper.TryEvalConst(root, leftExpr, rightExpr, ExpressionType.GreaterThanOrEqual);
break;
default:
throw new CompilationException("Binary operator not supported for datetime values: " + op, root.ChildNodes[1]);
}
#endregion
}
else if (leftExpr.IsDateTime() && rightExpr.IsTimeSpan())
{
#region DateTime and TimeSpan or TimeSpan and DateTime
switch (op)
{
case "+":
expr = ConstantHelper.TryEvalConst(root, leftExpr, rightExpr, ExpressionType.Add);
break;
case "-":
expr = ConstantHelper.TryEvalConst(root, leftExpr, rightExpr, ExpressionType.Subtract);
break;
default:
throw new CompilationException("Binary operator not supported for datetime and timespan: " + op, root.ChildNodes[1]);
}
#endregion
}
else if (leftExpr.IsTimeSpan() && rightExpr.IsDateTime())
{
#region TimeSpan and DateTime
switch (op)
{
case "+":
expr = ConstantHelper.TryEvalConst(root, rightExpr, leftExpr, ExpressionType.Add);
break;
default:
throw new CompilationException("Binary operator not supported for timespan and datetime: " + op, root.ChildNodes[1]);
}
#endregion
}
else if (leftExpr.IsString() && rightExpr.IsString())
{
#region String and String
switch (op)
{
case "+":
var concat = ReflectionHelper.StringConcat;
expr = ConstantHelper.TryEvalConst(root, concat, leftExpr, rightExpr);
break;
case "=":
case "!=":
case "<>":
expr = PrepareStringEquality(root, leftExpr, rightExpr);
if (op[0] != '=')
{
expr = ConstantHelper.TryEvalConst(root, expr, ExpressionType.Not, expr.Type);
}
break;
case ">":
expr = ConstantHelper.TryEvalConst(root, PrepareStringComparison(root, leftExpr, rightExpr), Expression.Constant(0), ExpressionType.GreaterThan);
break;
case "<":
expr = ConstantHelper.TryEvalConst(root, PrepareStringComparison(root, leftExpr, rightExpr), Expression.Constant(0), ExpressionType.LessThan);
break;
case "<=":
case "!>":
expr = ConstantHelper.TryEvalConst(root, PrepareStringComparison(root, leftExpr, rightExpr), Expression.Constant(0), ExpressionType.LessThanOrEqual);
break;
case ">=":
case "!<":
expr = ConstantHelper.TryEvalConst(root, PrepareStringComparison(root, leftExpr, rightExpr), Expression.Constant(0), ExpressionType.GreaterThanOrEqual);
break;
case "like":
throw new CompilationException("Instead of LIKE, use predefined functions StartsWith, EndsWith and Contains", root.ChildNodes[1]);
default:
throw new CompilationException("Binary operator not supported for strings: " + op, root.ChildNodes[1]);
}
#endregion
}
else if (leftExpr.IsNumeric() && rightExpr.IsNumeric())
{
#region Numeric and Numeric
ExpressionTreeExtensions.AdjustArgumentsForBinaryOperation(ref leftExpr, ref rightExpr, root);
switch (op)
{
case "+":
expr = ConstantHelper.TryEvalConst(root, leftExpr, rightExpr, ExpressionType.Add);
break;
case "-":
expr = ConstantHelper.TryEvalConst(root, leftExpr, rightExpr, ExpressionType.Subtract);
break;
case "*":
expr = ConstantHelper.TryEvalConst(root, leftExpr, rightExpr, ExpressionType.Multiply);
break;
case "/":
expr = ConstantHelper.TryEvalConst(root, leftExpr, rightExpr, ExpressionType.Divide);
break;
case "%":
expr = ConstantHelper.TryEvalConst(root, leftExpr, rightExpr, ExpressionType.Modulo);
break;
case "&":
expr = ConstantHelper.TryEvalConst(root, leftExpr, rightExpr, ExpressionType.And);
break;
case "|":
expr = ConstantHelper.TryEvalConst(root, leftExpr, rightExpr, ExpressionType.Or);
break;
case "^":
expr = ConstantHelper.TryEvalConst(root, leftExpr, rightExpr, ExpressionType.ExclusiveOr);
break;
case "<":
expr = ConstantHelper.TryEvalConst(root, leftExpr, rightExpr, ExpressionType.LessThan);
break;
case "<=":
case "!>":
expr = ConstantHelper.TryEvalConst(root, leftExpr, rightExpr, ExpressionType.LessThanOrEqual);
break;
case ">":
expr = ConstantHelper.TryEvalConst(root, leftExpr, rightExpr, ExpressionType.GreaterThan);
break;
case ">=":
case "!<":
expr = ConstantHelper.TryEvalConst(root, leftExpr, rightExpr, ExpressionType.GreaterThanOrEqual);
break;
case "=":
expr = ConstantHelper.TryEvalConst(root, leftExpr, rightExpr, ExpressionType.Equal);
break;
case "!=":
case "<>":
expr = ConstantHelper.TryEvalConst(root, leftExpr, rightExpr, ExpressionType.NotEqual);
break;
default:
throw new CompilationException("Binary operator not supported yet for numerics: " + op, root.ChildNodes[1]);
}
#endregion
}
else if (leftExpr.IsBoolean() && rightExpr.IsBoolean())
{
#region Boolean and Boolean
switch (op)
{
case "and":
expr = ConstantHelper.TryEvalConst(root, leftExpr, rightExpr, ExpressionType.AndAlso);
break;
case "or":
expr = ConstantHelper.TryEvalConst(root, leftExpr, rightExpr, ExpressionType.OrElse);
break;
case "xor":
expr = ConstantHelper.TryEvalConst(root, leftExpr, rightExpr, ExpressionType.ExclusiveOr);
break;
case "=":
expr = ConstantHelper.TryEvalConst(root, leftExpr, rightExpr, ExpressionType.Equal);
break;
case "!=":
case "<>":
expr = ConstantHelper.TryEvalConst(root, leftExpr, rightExpr, ExpressionType.NotEqual);
break;
default:
throw new CompilationException("Binary operator not supported yet for booleans: " + op, root.ChildNodes[1]);
}
#endregion
}
else
{
throw new CompilationException(string.Format("Binary operator {0} is not yet supported for types {1} and {2}",
op, leftExpr.Type.FullName, rightExpr.Type.FullName), root.ChildNodes[1]);
}
return(expr);
}
public override void Execute(int eventCode, object message)
{
switch (eventCode)
{
case UIEvent.Player_Hide_State:
Invoke("HideUI", 0.5f);
break;
case UIEvent.Player_Ready:
//显示准备文本框
if (userCharacterDto == null)
{
break;
}
int userId = (int)message;
if (userCharacterDto.Id == userId)
{
ReadyState(true);
}
break;
case UIEvent.Player_Leave:
if (userCharacterDto == null)
{
break;
}
//玩家离开隐藏面板
int leaveUserId = (int)message;
if (userCharacterDto.Id == leaveUserId)
{
ReadyState(false);
SetPanelActive(false);
userCharacterDto = null;
}
break;
case UIEvent.Player_Enter:
//玩家进入房间
if (userCharacterDto == null)
{
break;
}
int enterUserId = (int)message;
if (userCharacterDto.Id == enterUserId)
{
SetPanelActive(true);
}
break;
case UIEvent.Player_Chat:
{
if (userCharacterDto == null)
{
break;
}
ChatDto chatDto = message as ChatDto;
if (userCharacterDto.Id == chatDto.UserId)
{
var text = ConstantHelper.GetChatText(chatDto.Type);
ShowChat(text);
}
break;
}
case UIEvent.Player_Change_Identity:
{
if (userCharacterDto == null)
{
break;
}
GrabDto dto = message as GrabDto;
if (userCharacterDto.Id == dto.UserId)
{
SetIdentity(1);
}
break;
}
}
}
private Expression BuildInclusionExpression(ParseTreeNode root, Expression leftExpr, string op, CompilerState state)
{
root.RequireChildren(3);
var rightNodeList = ExpressionTreeExtensions.UnwindTupleExprList(root.ChildNodes[2]);
if (rightNodeList.Term.Name == "Id")
{
throw new CompilationException("Parameterized IN statement is not yet supported, consider using function SetContains", rightNodeList);
}
if (rightNodeList.Term.Name != "exprList")
{
throw new CompilationException("Argument for IN operator must be a list of expressions", root);
}
// Expression text is not supposed to be used to pass tens and hundreds of thousands of IDs in plain text.
// Use parameters for large argument sets.
rightNodeList.RequireChildren(1, 1000);
leftExpr = leftExpr.RemoveNullability();
// compile a method to enumerate values in the argument set
var valueEnumerator = ReflectionHelper.EnumerateValues.MakeGenericMethod(leftExpr.Type);
// invoke enumerator, output is a hashset
object matchingSet;
try
{
matchingSet = valueEnumerator.Invoke(null, new object[] { this, rightNodeList, state });
}
catch (TargetInvocationException e)
{
if (e.InnerException == null)
{
throw;
}
throw e.InnerException;
}
// how many items do we have there?
var countProperty = matchingSet.GetType().GetProperty("Count", BindingFlags.Instance | BindingFlags.Public);
var count = (int)(countProperty.GetValue(matchingSet));
Expression contains;
var leftArgConst = leftExpr as ConstantExpression;
if (leftArgConst != null)
{
// since list is constant and argument is constant, let's just evaluate it
var setContainsMethod = ReflectionHelper.GetOrAddMethod1(matchingSet.GetType(), "Contains", leftExpr.Type);
try
{
contains = Expression.Constant(setContainsMethod.Invoke(matchingSet, new[] { leftArgConst.Value }), typeof(bool));
}
catch (TargetInvocationException e)
{
if (e.InnerException == null)
{
throw;
}
throw e.InnerException;
}
}
else
{
var threshold = leftExpr.IsInteger() ? 15 : 5;
// for small sets of values, just create a chain of IF/THEN/ELSE statements
if (count <= threshold)
{
var isString = leftExpr.IsString();
var enumeratorMethod = ReflectionHelper.GetOrAddMethod0(matchingSet.GetType(), "GetEnumerator");
IEnumerator enumerator;
try
{
enumerator = (IEnumerator)enumeratorMethod.Invoke(matchingSet, null);
}
catch (TargetInvocationException e)
{
if (e.InnerException == null)
{
throw;
}
throw e.InnerException;
}
contains = null;
while (enumerator.MoveNext())
{
var next = isString
? PrepareStringEquality(rightNodeList, leftExpr, Expression.Constant(enumerator.Current, leftExpr.Type))
: Expression.Equal(leftExpr, Expression.Constant(enumerator.Current, leftExpr.Type));
contains = contains == null ? next : Expression.OrElse(contains, next);
}
}
else
{
// for larger sets, wire our matchingSet into this expression as constant reference
// it will be kept alive by garbage collector, and will be collected when expression is collected
var setContainsMethod = ReflectionHelper.GetOrAddMethod1(matchingSet.GetType(), "Contains", leftExpr.Type);
contains = Expression.Call(Expression.Constant(matchingSet), setContainsMethod, leftExpr);
}
}
if (op.StartsWith("not "))
{
contains = ConstantHelper.TryEvalConst(root, contains, ExpressionType.Not, typeof(bool));
}
return(contains);
}
private static Expression PrepareStringEquality(ParseTreeNode root, Expression leftExpr, Expression rightExpr)
{
var equals = ReflectionHelper.StringComparerEquals;
return(ConstantHelper.TryEvalConst(root, equals, Expression.Constant(StringComparer.OrdinalIgnoreCase), leftExpr, rightExpr));
}
