/// <summary>
/// مقدار پارامتر قانون پرسنل را برمی گرداند
/// </summary>
/// <param name="currentDate">تاریخ جاری</param>
/// <param name="person">پرسنل</param>
/// <param name="ruleIdentifier">کد قانون</param>
/// <param name="parameterName">نام پارامتر</param>
/// <returns>مقدار پارامتر</returns>
private object GetRuleParameter(DateTime currentDate, Person person, int ruleIdentifier, string parameterName)
{
try
{
if (person.AssignedRuleList != null)
{
AssignedRule ar = person.AssignedRuleList.Where(x => x.FromDate <= currentDate && x.ToDate >= currentDate && x.IdentifierCode == ruleIdentifier).FirstOrDefault();
if (ar != null)
{
EntityRepository <AssignRuleParameter> paramRep = new EntityRepository <AssignRuleParameter>();
IList <AssignRuleParameter> paramList = paramRep.Find(x => x.Rule.ID == ar.RuleId).ToList();
AssignRuleParameter asp = paramList.Where(x => x.FromDate <= currentDate && x.ToDate >= currentDate).FirstOrDefault();
if (asp != null)
{
RuleParameter parameter = asp.RuleParameterList.Where(x => x.Name.ToLower().Equals(parameterName.ToLower())).FirstOrDefault();
if (parameter != null)
{
return(parameter.Value);
}
}
}
}
return(null);
}
catch (Exception ex)
{
BaseBusiness <Entity> .LogException(ex, "BUserInfo", "GetRuleParameter");
throw ex;
}
}
public RuleResult Execute(RuleParameter parameter)
{
var result = base.Execute(parameter);
if (!result.Succeeded)
{
return(result);
}
var userMap = Resolve <IUserMapService>().GetParentMapFromCache(base.OrderUser.Id);
var map = userMap.ParentMap.DeserializeJson <List <ParentMap> >();
if (map == null || map.Count == 0)
{
return(RuleResult.Failure("未找到触发会员的Parent Map."));
}
// 一级分润
var shareUser = GetShareUser(map[0].UserId);
var shareAmount = Config.OneFixed;
ToResult(shareAmount, shareUser, ref result);
// 二级分润
if (map.Count > 1)
{
shareUser = GetShareUser(map[1].UserId);
shareAmount = Config.TwoFixed;
ToResult(shareAmount, shareUser, ref result);
}
return(result);
}
public void ProcessCommands(string inputCommandsStr)
{
Initialize();
_inputCommandIds = new Queue <string>(inputCommandsStr.Split(','));
while (_inputCommandIds.Count > 0)
{
string command = _inputCommandIds.Dequeue();
int.TryParse(command.Trim(), out int commandIdInt);
CommandType commandId = (CommandType)commandIdInt;
_ruleParameter = new RuleParameter()
{
ExistingCommandIds = _currentCommandList,
NewCommandId = commandId,
ClothingCommands = _clothingCommands,
};
if (AreRulesSatisfied())
{
_currentCommandList.Add(commandId);
_output.Add(GetResponse(commandId));
}
else
{
_output.Add("fail");
break;
}
}
}
public void BuildExpressionForRuleTest()
{
var reSettings = new ReSettings();
var objBuilderFactory = new RuleExpressionBuilderFactory(reSettings, new RuleExpressionParser(reSettings));
var builder = objBuilderFactory.RuleGetExpressionBuilder(RuleExpressionType.LambdaExpression);
var ruleParameters = new RuleParameter[] {
new RuleParameter("RequestType", "Sales"),
new RuleParameter("RequestStatus", "Active"),
new RuleParameter("RegistrationStatus", "InProcess")
};
Rule mainRule = new Rule();
mainRule.RuleName = "rule1";
mainRule.Operator = "And";
mainRule.Rules = new List <Rule>();
Rule dummyRule = new Rule();
dummyRule.RuleName = "testRule1";
dummyRule.RuleExpressionType = RuleExpressionType.LambdaExpression;
dummyRule.Expression = "RequestType == \"vod\"";
mainRule.Rules.Add(dummyRule);
var func = builder.BuildDelegateForRule(dummyRule, ruleParameters);
Assert.NotNull(func);
Assert.Equal(typeof(RuleResultTree), func.Method.ReturnType);
}
public bool Apply(RuleParameter param, object paramValue, object inputValue)
{
Require.NotNull(param, "param");
Require.NotNull(paramValue, "paramValue");
Require.NotNull(inputValue, "inputValue");
return(paramValue.ToString().Contains(inputValue.ToString(), StringComparison.OrdinalIgnoreCase));
}
public bool IsValid(RuleParameter ruleParameter)
{
if (ruleParameter.ExistingCommandIds.Contains(ruleParameter.NewCommandId))
{
return(false);
}
return(true);
}
public bool IsValid(RuleParameter ruleParameter)
{
if (ruleParameter.NewCommandId == CommandType.PUT_FOOT_WEAR && !ruleParameter.ExistingCommandIds.Contains(CommandType.PUT_PANTS))
{
return(false);
}
return(true);
}
public bool Apply(RuleParameter param, object paramValue, object inputValue)
{
if (paramValue is String && inputValue is String)
{
return((paramValue as String).Equals((inputValue as String), StringComparison.OrdinalIgnoreCase));
}
return(paramValue.Equals(inputValue));
}
public bool IsValid(RuleParameter ruleParameter)
{
if (ruleParameter.NewCommandId == CommandType.PUT_SOCKS)
{
return(false);
}
return(true);
}
public bool Apply(RuleParameter param, object paramValue, object inputValue)
{
Require.NotNull(param, "param");
Require.NotNull(paramValue, "paramValue");
Require.That(paramValue is IComparable, "paramValue", "Require comparable parameter value.");
Require.NotNull(inputValue, "inputValue");
Require.That(inputValue is IComparable, "inputValue", "Require comparable input value.");
return(((IComparable)paramValue).CompareTo((IComparable)inputValue) > 0);
}
/// <summary>
/// Declares a fact based on the property, and adds it to the cache
/// </summary>
/// <typeparam name="T">The fact type</typeparam>
/// <param name="property">The property referencing the fact</param>
/// <param name="parameter">The parameter for this fact</param>
void DeclareFact <T>(PropertyInfo property, RuleParameter <T> parameter)
where T : class
{
string name = property.Name;
var fact = new RuleFact <T>(name, parameter);
Fact <T> propertyValue = fact;
property.SetValue(this, propertyValue);
_factCache[name] = fact;
}
public async Task ExecuteRule_ReturnsProperErrorOnMissingRuleParameter(string ruleFileName)
{
var re = GetRulesEngine(ruleFileName);
var input1 = new RuleParameter("customName",GetInput1());
var input2 = new RuleParameter("input2",GetInput2());
var input3 = new RuleParameter("input3",GetInput3());
List<RuleResultTree> result = await re.ExecuteAllRulesAsync("inputWorkflow", input1,input2, input3);
Assert.NotNull(result);
Assert.IsType<List<RuleResultTree>>(result);
Assert.Contains(result.First().ChildResults, c => c.ExceptionMessage.Contains("Unknown identifier 'input1'"));
}
// 此方法用于获取自定义条件参数的值
private string GetCustomerCompnay(RuleParameter parameter, object dataContext)
{
var order = (Order)dataContext;
// 返回其 "Company" 这个 CustomField 的值
var field = order.Customer.CustomFields.FirstOrDefault(f => f.Name == "Company");
if (field == null)
{
return(null);
}
return(field.Value);
}
public BaseRuleParameter GetRuleParameter(DateTime currentDate, decimal ruleId, string paramName)
{
GTS.Clock.Infrastructure.Repository.EntityRepository <AssignRuleParameter> paramRep = new GTS.Clock.Infrastructure.Repository.EntityRepository <AssignRuleParameter>();
IList <AssignRuleParameter> paramList = paramRep.Find(x => x.Rule.ID == ruleId).ToList();
AssignRuleParameter asp = paramList.Where(x => x.FromDate <= currentDate && x.ToDate >= currentDate).FirstOrDefault();
if (asp != null)
{
RuleParameter parameter = asp.RuleParameterList.Where(x => x.Name.ToLower().Equals(paramName.ToLower())).FirstOrDefault();
return(parameter);
}
return(null);
}
public RuleResult Execute(RuleParameter parameter)
{
var result = base.Execute(parameter);
if (!result.Succeeded)
{
return(result);
}
var shareUser = GetShareUser(ShareTrade.UserId);
var shareAmount = base.BaseFenRunAmount * Config.Radio;
ToResult(shareAmount, shareUser, ref result);
return(result);
}
/// <summary>
/// رینج تاریخ پارامتر را بهمراه پارامتر بروزرسانی میکند
/// اگر تعداد پارامتر ارسالی کمتر از تعداد ذخیره شده در دیتابیس کمتر بود آنگاه پارامترهای موجود در دیتابیس ذخیره میگردد
/// بدلیل انجام عملیات جانبی تباید کلاینت مستقیما از متد
/// SaveChnages استفاده کند
/// </summary>
/// <param name="parameters">پارامترهای مقداردهی شده از طرف کلاینت - کلیه پارامتر ها باید دارای شناسه معتبر باشند</param>
/// <param name="assignParamId">شناسه رینج تاریخ پارامترها</param>
/// <param name="fromDate">تاریخ شروع رینج</param>
/// <param name="toDate">تاریخ پایان رینج</param>
/// <returns>شناسه رینج پارامتر</returns>
public decimal UpdateParameter(IList <RuleParameter> parameters, decimal assignParamId, DateTime fromDate, DateTime toDate)
{
try
{
AssignRuleParameter assign = new AssignRuleParameter();
assign.ID = assignParamId;
assign.FromDate = fromDate;
assign.ToDate = toDate;
assign.Rule = workingRule;
assign.RuleParameterList = new List <RuleParameter>();
IList <RuleParameter> orginList = this.GetRuleParameters(assignParamId);
foreach (RuleParameter param in orginList)
{
if (parameters.Where(x => x.ID == param.ID).Count() == 1)
{
RuleParameter p = parameters.Where(x => x.ID == param.ID).First();
if (p.Type == RuleParamType.Time && p.ContinueOnTomorrow)
{
p.Value = Utility.ToString(Utility.ToInteger(p.Value) + 1440);
}
param.Value = p.Value;
param.ContinueOnTomorrow = p.ContinueOnTomorrow;
assign.RuleParameterList.Add(param);
}
else
{
assign.RuleParameterList.Add(param);
}
}
base.SaveChanges(assign, UIActionType.EDIT);
return(assign.ID);
}
catch (Exception ex)
{
LogException(ex, "BRuleParameter", "UpdateParameter");
throw ex;
}
}
/// <summary>
/// بعد از درج انتساب قانون به پارامتر باید پارامترها نیز درچ شوند که
/// این سرویس این کار را انجام میدهد
/// </summary>
/// <param name="assignRuleParameterID">شناسه انتساب قانون به پارامتر</param>
/// <param name="ruleID">شناسه قانون</param>
public void InitilizeParameters(decimal assignRuleParameterID, decimal ruleID)
{
decimal[] a = new decimal[1] {
ruleID
};
IList <RuleTemplateParameter> list = base.NHibernateSession.QueryOver <RuleTemplateParameter>()
.WhereRestrictionOn(x => x.RuleTemplateId)
.IsInG <Object>(NHibernateSession.QueryOver <Rule>()
.Select(Projections.ProjectionList()
.Add(Projections.Property <Rule>(r => r.TemplateId)))
.WhereRestrictionOn(x => x.ID)
.IsIn(a)
.List <object>())
.List <RuleTemplateParameter>();
EntityRepository <RuleParameter> paramRep = new EntityRepository <RuleParameter>(false);
foreach (RuleTemplateParameter param in list)
{
RuleParameter ruleParam = new RuleParameter();
ruleParam.Name = param.Name;
ruleParam.Title = param.Title;
ruleParam.Type = param.Type;
ruleParam.AssignRuleParameter = new AssignRuleParameter()
{
ID = assignRuleParameterID
};
if (param.Type == RuleParamType.Numeric || param.Type == RuleParamType.Time)
{
ruleParam.Value = "0";
}
else
{
ruleParam.Value = String.Format("{0:yyyy/mm/dd}", Utility.Utility.GTSMinStandardDateTime);
}
paramRep.Save(ruleParam);
}
}
public async Task Can_Get_Rules()
{
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
List <Workflow>?workflow = JsonConvert.DeserializeObject <List <Workflow> >(GetFileText());
RulesEngine.RulesEngine bre = new RulesEngine.RulesEngine(workflow.ToArray());
var rp1 = new RuleParameter("todayInfo", new WeatherInfo("Klart vejr", 25));
var rp2 = new RuleParameter("yesterdayInfo", new WeatherInfo("Regn", 10));
var location = "Kolding";
RuleResultTree?result = (await bre.ExecuteAllRulesAsync("WeatherForecast", rp1, rp2)).FirstOrDefault(r => r.IsSuccess);
if (result != null && result.Rule.SuccessEvent != null)
{
var text = string.Format(result.Rule.SuccessEvent, location, "0");
Assert.NotNull(text);
}
}
public RuleParameterModel(RuleParameter param)
: this()
{
Name = param.Name;
DisplayName = param.Name;
ValueType = param.ValueType.FullName;
IsNumberValue = param.ValueType.IsNumericType();
foreach (var @operator in param.SupportedOperators)
{
SupportedOperators.Add(new ComparisonOperatorModel(@operator));
}
if (param.ValueSource != null)
{
Values = param.ValueSource.GetValues(param).Select(x => new SelectListItem
{
Text = x.Key,
Value = x.Value
})
.ToList();
}
}
public static void Main(string[] Args)
{
Console.WriteLine("------------------------------------------------------");
Console.WriteLine("Executing Sample from File: DOFraudFilters.cs");
Console.WriteLine("------------------------------------------------------");
// Create the Data Objects.
// Create the User data object with the required user details.
UserInfo User = new UserInfo("<user>", "<vendor>", "<partner>", "<password>");
// Create the Payflow Connection data object with the required connection details.
// The PAYFLOW_HOST property is defined in the App config file.
PayflowConnectionData Connection = new PayflowConnectionData();
// Create a new Invoice data object with the Amount, Billing Address etc. details.
Invoice Inv = new Invoice();
// Set Amount.
Currency Amt = new Currency(new decimal(51.00));
Inv.Amt = Amt;
Inv.PoNum = "PO12345";
Inv.InvNum = "INV12345";
// Set the Billing Address details.
BillTo Bill = new BillTo();
Bill.BillToStreet = "677 Main St.";
Bill.BillToZip = "12345";
Inv.BillTo = Bill;
CustomerInfo CustInfo = new CustomerInfo();
CustInfo.CustIP = "10.1.1.1"; // IP Velocity Filter
Inv.CustomerInfo = CustInfo;
// Create a new Payment Device - Credit Card data object.
// The input parameters are Credit Card Number and Expiration Date of the Credit Card.
CreditCard CC = new CreditCard("5105105105105100", "0115");
CC.Cvv2 = "444";
// Create a new Tender - Card Tender data object.
CardTender Card = new CardTender(CC);
///////////////////////////////////////////////////////////////////
// Create a new Sale Transaction with purchase price ceiling amount filter set to $50.
SaleTransaction Trans = new SaleTransaction(
User, Connection, Inv, Card, PayflowUtility.RequestId);
// Set the Verbosity of the transaction to HIGH to get maximum information in the response.
Trans.Verbosity = "HIGH";
// Submit the Transaction
Response Resp = Trans.SubmitTransaction();
// Display the transaction response parameters.
if (Resp != null)
{
// Get the Transaction Response parameters.
TransactionResponse TrxnResponse = Resp.TransactionResponse;
if (TrxnResponse != null)
{
Console.WriteLine("RESULT = " + TrxnResponse.Result);
Console.WriteLine("PNREF = " + TrxnResponse.Pnref);
Console.WriteLine("RESPMSG = " + TrxnResponse.RespMsg);
Console.WriteLine("AUTHCODE = " + TrxnResponse.AuthCode);
Console.WriteLine("AVSADDR = " + TrxnResponse.AVSAddr);
Console.WriteLine("AVSZIP = " + TrxnResponse.AVSZip);
Console.WriteLine("IAVS = " + TrxnResponse.IAVS);
Console.WriteLine("HOSTCODE = " + TrxnResponse.HostCode);
Console.WriteLine("PROCAVS = " + TrxnResponse.ProcAVS);
Console.WriteLine("CVV2MATCH = " + TrxnResponse.CVV2Match);
}
// Get the Fraud Response parameters.
FraudResponse FraudResp = Resp.FraudResponse;
// Display Fraud Response parameter
if (FraudResp != null)
{
Console.WriteLine("PREFPSMSG = " + FraudResp.PreFpsMsg);
Console.WriteLine("POSTFPSMSG = " + FraudResp.PostFpsMsg);
// The following lines of code dealing with PreXmlData and PostXmlData will return all th rules
// that were triggered by the Fraud Service. For Example, let's assume the both AVS and CSC (CVV2)
// failed, the FraudResp.PostFpsMsg would something similar to:
// "Review: More than one rule was triggered for Review".
//
// The Fps_PreXmlData is returned as an Xml string. This is converted into Data Objects
// with the object hierarchy as shown below:
// FpsXmlData
// >>>>>>>>> List of Rule objects
// >>>>>>>>>>>>>>>>>> List of RuleVendorParm objects.
FpsXmlData PreXmlData = FraudResp.Fps_PreXmlData;
if (PreXmlData != null)
{
// Get the list of Rules.
ArrayList RulesList = PreXmlData.Rules;
if (RulesList != null && RulesList.Count > 0)
{
IEnumerator RulesEnum = RulesList.GetEnumerator();
Rule DORule = null;
// Loop through the list of Rules.
while (RulesEnum.MoveNext())
{
DORule = (Rule)RulesEnum.Current;
Console.WriteLine("------------------------------------------------------");
Console.WriteLine("PRE-XML DATA");
Console.WriteLine("------------------------------------------------------");
Console.WriteLine("Rule Number = " + DORule.Num.ToString());
Console.WriteLine("Rule Id = " + DORule.RuleId);
Console.WriteLine("Rule Alias = " + DORule.RuleAlias);
Console.WriteLine("Rule Description = " + DORule.RuleDescription);
Console.WriteLine("Action = " + DORule.Action);
Console.WriteLine("Triggered Message = " + DORule.TriggeredMessage);
// Get the list of Rule Vendor Parameters.
ArrayList RuleVendorParmsList = DORule.RuleVendorParms;
if (RuleVendorParmsList != null && RuleVendorParmsList.Count > 0)
{
IEnumerator RuleParametersEnum = RuleVendorParmsList.GetEnumerator();
// Loop through the list of Rule Parameters.
while (RuleParametersEnum.MoveNext())
{
RuleParameter DORuleParam = (RuleParameter)RuleParametersEnum.Current;
Console.WriteLine("Number = " + DORuleParam.Num.ToString());
Console.WriteLine("Name = " + DORuleParam.Name);
Console.WriteLine("Type = " + DORuleParam.Type);
Console.WriteLine("Value = " + DORuleParam.Value);
}
}
}
}
// The Fps_PostXmlData is returned as an Xml string. This is converted into Data Objects
// with the object hierarchy as shown below:
// FpsXmlData
// >>>>>>>>> List of Rule objects
// >>>>>>>>>>>>>>>>>> List of RuleVendorParm objects.
FpsXmlData PostXmlData = FraudResp.Fps_PostXmlData;
if (PostXmlData != null)
{
// Get the list of Rules.
ArrayList PostRulesList = PostXmlData.Rules;
if (PostRulesList != null && PostRulesList.Count > 0)
{
IEnumerator RulesEnum = PostRulesList.GetEnumerator();
Rule DORule = null;
// Loop through the list of Rules.
while (RulesEnum.MoveNext())
{
DORule = (Rule)RulesEnum.Current;
Console.WriteLine("------------------------------------------------------");
Console.WriteLine("POST-XML DATA");
Console.WriteLine("------------------------------------------------------");
Console.WriteLine("Rule Number = " + DORule.Num.ToString());
Console.WriteLine("Rule Id = " + DORule.RuleId);
Console.WriteLine("Rule Alias = " + DORule.RuleAlias);
Console.WriteLine("Rule Description = " + DORule.RuleDescription);
Console.WriteLine("Action = " + DORule.Action);
Console.WriteLine("Triggered Message = " + DORule.TriggeredMessage);
// Get the list of Rule Vendor Parameters.
ArrayList RuleVendorParmsList = DORule.RuleVendorParms;
if (RuleVendorParmsList != null && RuleVendorParmsList.Count > 0)
{
IEnumerator RuleParametersEnum = RuleVendorParmsList.GetEnumerator();
// Loop through the list of Rule Parameters.
while (RuleParametersEnum.MoveNext())
{
RuleParameter DORuleParam = (RuleParameter)RuleParametersEnum.Current;
Console.WriteLine("Number = " + DORuleParam.Num.ToString());
Console.WriteLine("Name = " + DORuleParam.Name);
Console.WriteLine("Type = " + DORuleParam.Type);
Console.WriteLine("Value = " + DORuleParam.Value);
}
}
}
}
}
}
// Display the response.
Console.WriteLine(Environment.NewLine + PayflowUtility.GetStatus(Resp));
// Get the Transaction Context and check for any contained SDK specific errors (optional code).
Context TransCtx = Resp.TransactionContext;
if (TransCtx != null && TransCtx.getErrorCount() > 0)
{
Console.WriteLine(Environment.NewLine + "Transaction Errors = " + TransCtx.ToString());
}
Console.WriteLine("Press Enter to Exit ...");
Console.ReadLine();
}
}
}
public bool Apply(RuleParameter param, object paramValue, object inputValue)
{
return(!ComparisonOperators.GreaterThanOrEqual.Apply(param, paramValue, inputValue));
}
public SwitchCaseRule(RuleParameter parameter)
{
Parameter = parameter;
}
public void VisitRuleParameter(RuleParameter ruleParameter)
{
}
public RuleCategory CopyRuleCategory(decimal ruleCatId)
{
RuleCategory ruleCat = this.GetByID(ruleCatId);
RuleCategory newRuleCat = new RuleCategory();
if (BLanguage.CurrentSystemLanguage == LanguagesName.Parsi)
{
newRuleCat.Name = String.Format("کپی {0}", ruleCat.Name);
}
else
{
newRuleCat.Name = String.Format("Copy Of {0}", ruleCat.Name);
}
newRuleCat.IsRoot = false;
newRuleCat.Discription = ruleCat.Discription;
newRuleCat.CustomCode = ruleCat.CustomCode;
#region Parent
newRuleCat.Parent = this.GetRoot();
#endregion
#region Child
ruleCat.ChildList = new List <RuleCategory>();
foreach (RuleCategory child in ruleCat.ChildList)
{
RuleCategory ch = new RuleCategory();
ch.ID = child.ID;
ruleCat.ChildList.Add(ch);
}
#endregion
#region Rule
newRuleCat.RuleList = new List <Rule>();
foreach (Rule rule in ruleCat.RuleList)
{
Rule r = new Rule();
r.Category = newRuleCat;
r.IdentifierCode = rule.IdentifierCode;
r.IsPeriodic = rule.IsPeriodic;
r.Name = rule.Name;
r.Order = rule.Order;
r.Script = rule.Script;
r.TemplateId = rule.TemplateId;
r.TypeId = rule.TypeId;
r.IsForcible = rule.IsForcible;
#region Assign Rule Param
r.AssignRuleParamList = new List <AssignRuleParameter>();
if (rule.HasParameter)
{
IList <AssignRuleParameter> AssignRuleParamList = this.AssignRuleParameterRep.GetAssigneRuleParametersListByRuleID(rule.ID);
foreach (AssignRuleParameter assginParam in AssignRuleParamList)
{
AssignRuleParameter ass = new AssignRuleParameter();
ass.FromDate = assginParam.FromDate;
ass.ToDate = assginParam.ToDate;
ass.Rule = r;
#region Rule Parameter
ass.RuleParameterList = new List <RuleParameter>();
foreach (RuleParameter param in assginParam.RuleParameterList)
{
RuleParameter rp = new RuleParameter();
rp.Name = param.Name;
rp.Title = param.Title;
rp.Type = param.Type;
rp.Value = param.Value;
rp.AssignRuleParameter = ass;
ass.RuleParameterList.Add(rp);
}
#endregion
r.AssignRuleParamList.Add(ass);
}
}
#endregion
newRuleCat.RuleList.Add(r);
}
#endregion
//NHibernateSessionManager.Instance.ClearSession();
NHibernateSessionManager.Instance.GetSession().Evict(ruleCat);
this.SaveChanges(newRuleCat, UIActionType.ADD);
return(new RuleCategory()
{
ID = newRuleCat.ID, Name = newRuleCat.Name
});
}
public RuleFact(string name, RuleParameter <T> parameter)
{
_parameter = parameter;
_name = name;
}
private object GetParametersList_RuleParameters(UIActionType uam, string strParametersList)
{
object ParametersList = null;
switch (uam)
{
case UIActionType.ADD:
ParametersList = new List <RuleTemplateParameter>();
break;
case UIActionType.EDIT:
ParametersList = new List <RuleParameter>();
break;
}
if (strParametersList != string.Empty)
{
JavaScriptSerializer jsSerializer = new JavaScriptSerializer();
object[] ParamsBatchs = (object[])jsSerializer.DeserializeObject(strParametersList);
foreach (object paramBatch in ParamsBatchs)
{
Dictionary <string, object> paramDic = (Dictionary <string, object>)paramBatch;
decimal ParameterID = decimal.Parse(paramDic["ID"].ToString());
string ParameterName = paramDic["Name"].ToString();
string ParameterTitle = paramDic["Title"].ToString();
RuleParamType ParameterType = (RuleParamType)Enum.ToObject(typeof(RuleParamType), int.Parse(paramDic["Type"].ToString()));
bool IsParameterValueInNextDay = false;
string ParameterValue = string.Empty;
switch (ParameterType)
{
case RuleParamType.Date:
ParameterValue = this.LangProv.GetSysDateTime(paramDic["Value"].ToString()).ToShortDateString();
break;
case RuleParamType.Time:
string TimeValue = string.Empty;
if (paramDic["Value"].ToString().Contains("+"))
{
TimeValue = paramDic["Value"].ToString().Replace("+", string.Empty);
IsParameterValueInNextDay = true;
}
else
{
TimeValue = paramDic["Value"].ToString();
}
ParameterValue = this.CreateTimeString_RuleParameters(TimeValue, RuleParametersTimeState.Set);
break;
default:
ParameterValue = paramDic["Value"].ToString();
break;
}
switch (uam)
{
case UIActionType.ADD:
RuleTemplateParameter ruleTemplateParameter = new RuleTemplateParameter();
ruleTemplateParameter.ID = ParameterID;
ruleTemplateParameter.Name = ParameterName;
ruleTemplateParameter.Title = ParameterTitle;
ruleTemplateParameter.Type = ParameterType;
ruleTemplateParameter.Value = ParameterValue;
ruleTemplateParameter.ContinueOnTomorrow = IsParameterValueInNextDay;
((List <RuleTemplateParameter>)ParametersList).Add(ruleTemplateParameter);
break;
case UIActionType.EDIT:
RuleParameter ruleParameter = new RuleParameter();
ruleParameter.ID = ParameterID;
ruleParameter.Name = ParameterName;
ruleParameter.Title = ParameterTitle;
ruleParameter.Type = ParameterType;
ruleParameter.Value = ParameterValue;
ruleParameter.ContinueOnTomorrow = IsParameterValueInNextDay;
((List <RuleParameter>)ParametersList).Add(ruleParameter);
break;
}
}
}
return(ParametersList);
}
public bool Apply(RuleParameter param, object paramValue, object inputValue)
{
return(!ComparisonOperators.Contains.Apply(param, paramValue, inputValue));
}
