/// <summary>
/// Initialize the object based on a DataAreaAccessCondition
/// </summary>
/// <param name="access">the DataAreaAccessCondition to clone</param>
internal void Initialize(DataAreaAccessCondition access)
{
Read = access.Read;
Write = access.Write;
Increment = access.Increment;
Decrement = access.Decrement;
}
/// <summary>
/// 初始化
/// </summary>
/// <param name="fieldName">字段名</param>
/// <param name="condition">条件</param>
/// <param name="value">值</param>
/// <param name="join"></param>
public Expression(string fieldName, ConditionEnum condition, object value, JoinEnum join = JoinEnum.And)
{
FieldName = fieldName;
Condition = condition;
Value = value.ToString();
Join = join;
}
public Condition(ConditionEnum condition, object delta, char operateur, AccountUC Account)
{
m_Cond = condition;
m_delta = delta;
m_operateur = operateur;
account = Account;
}
public Condition(ConditionEnum condition, object delta, char operateur, AccountUC Account)
{
m_Cond = condition;
m_delta = delta;
m_operateur = operateur;
account = Account;
}
public HealthPowerCondition(ConditionTargetEnum conditionTarget, ConditionTypeEnum conditionType,
ConditionEnum condition, int value)
{
ConditionTarget = conditionTarget;
ConditionType = conditionType;
Condition = condition;
Value = value;
}
public HealthPowerCondition(ConditionTargetEnum conditionTarget, ConditionTypeEnum conditionType,
ConditionEnum condition, int value)
{
ConditionTarget = conditionTarget;
ConditionType = conditionType;
Condition = condition;
Value = value;
}
/// <summary>
/// 构造方法
/// </summary>
/// <param name="pi">属性</param>
/// <param name="value">值</param>
/// <param name="comparison">比较类型</param>
/// <param name="condition">条件类型</param>
public FilterInfo(PropertyInfo pi, object value, ComparisonEnum comparison = ComparisonEnum.Equal, ConditionEnum condition = ConditionEnum.And)
{
PropertyInfo = pi;
Value = value;
Comparison = comparison;
Condition = condition;
TargetFunc = null;
}
/// <summary>
/// 构造方法
/// </summary>
/// <param name="func">委托方法</param>
/// <param name="value">值</param>
/// <param name="condition">条件类型</param>
private FilterInfo(Func <object, bool> func, object value, ConditionEnum condition = ConditionEnum.And)
{
PropertyInfo = null;
Value = value;
Comparison = ComparisonEnum.Contains;
Condition = condition;
TargetFunc = func;
}
public void Initialize(TrailerAccessCondition access)
{
KeyARead = access.KeyARead;
KeyAWrite = access.KeyAWrite;
KeyBRead = access.KeyBRead;
KeyBWrite = access.KeyBWrite;
AccessBitsRead = access.AccessBitsRead;
AccessBitsWrite = access.AccessBitsWrite;
}
/// <summary>
/// 构造方法
/// </summary>
/// <param name="piName">属性名称</param>
/// <param name="value">值</param>
/// <param name="comparison">比较类型</param>
/// <param name="condition">条件类型</param>
public FilterInfo(string piName, object value, ComparisonEnum comparison = ComparisonEnum.Equal, ConditionEnum condition = ConditionEnum.And)
{
var type = typeof(T);
var pi = type.GetProperty(piName);
PropertyInfo = pi ?? throw new ArgumentNullException($"类型{type.Name}上不存属性{piName}");
Value = value;
Comparison = comparison;
Condition = condition;
TargetFunc = null;
}
/// <summary>
/// Methode permettant de décortiqueer l'int envoyé par la base de données gamesparks.
/// </summary>
public void understandInt()
{
/*
* Cette méthode a pour but de "disséquer" l'entier pour en tirer les informations nécessaires.
* Pas très élégant. Faire un switch case avec des puissances de 10?
*/
if (ConditionCondition == ConditionEnum.OBLIGATOIRE)
{
ActionObligatoire = true;
ConditionCondition = ConditionEnum.NONE;
}
if (intCondition < 0)
{
ActionObligatoire = true;
}
int _intConditionAbs = Mathf.Abs(intCondition);
if (_intConditionAbs < 100)
{
properIntCondition = _intConditionAbs;
}
else if (_intConditionAbs < Mathf.Pow(10, 3))
{
properIntCondition = _intConditionAbs % 100;
TourCondition = (Tour)(_intConditionAbs / Mathf.Pow(10, 2));
}
else if (_intConditionAbs < Mathf.Pow(10, 4))
{
properIntCondition = _intConditionAbs % 100;
if ((int)(_intConditionAbs / Mathf.Pow(10, 2)) % 10 != 0)
{
TourCondition = (Tour)((int)(_intConditionAbs / Mathf.Pow(10, 2)));
}
dependsOnPhase = true;
PhaseCondition = (Player.Phases)((int)(_intConditionAbs / Mathf.Pow(10, 3)) - 1);
}
else
{
properIntCondition = _intConditionAbs % 100;
if ((int)(_intConditionAbs / Mathf.Pow(10, 2)) % 10 != 0)
{
TourCondition = (Tour)((int)(_intConditionAbs / Mathf.Pow(10, 2)));
}
if ((int)(_intConditionAbs / Mathf.Pow(10, 3)) % 10 != 0)
{
dependsOnPhase = true;
PhaseCondition = (Player.Phases)((int)(_intConditionAbs / Mathf.Pow(10, 3)) - 1);
}
ReactionCondition = (Reaction)((int)(_intConditionAbs / Mathf.Pow(10, 4)) - 1);
}
}
protected ISQLElement CreateConditionElement(ConditionEnum condition)
{
switch (condition)
{
case ConditionEnum.AND:
return(new SQLUnaryElement("AND"));
case ConditionEnum.OR:
return(new SQLUnaryElement("OR"));
default:
throw new Exception("Unknown ");
}
}
public override void OnInspectorGUI()
{
DrawDefaultInspector();
CardComponent cardComponent = (CardComponent)target;
GUILayout.Space(20);
condition = (ConditionEnum)EditorGUILayout.EnumPopup("Add Condition:", condition);
if (GUILayout.Button("Create Condition"))
{
cardComponent.AddCondition(condition);
}
}
/// <summary>
/// 取条件语句的左右表达式
/// </summary>
public static ConditionEnum GetConditionRL(string strSrc, out string leftValue, out string rightValue)
{
ConditionEnum conditionType = ConditionEnum.ConditionEnum_Unkown;
leftValue = "";
rightValue = "";
if (strSrc.Contains("=="))
{
leftValue = strSrc.Substring(0, strSrc.IndexOf("==")).Trim();
rightValue = strSrc.Substring(strSrc.IndexOf("==") + 2).Trim();
conditionType = ConditionEnum.ConditionEnum_Eq;
}
else if (strSrc.Contains("!="))
{
leftValue = strSrc.Substring(0, strSrc.IndexOf("!=")).Trim();
rightValue = strSrc.Substring(strSrc.IndexOf("!=") + 2).Trim();
conditionType = ConditionEnum.ConditionEnum_Neq;
}
else if (strSrc.Contains(">="))
{
leftValue = strSrc.Substring(0, strSrc.IndexOf(">=")).Trim();
rightValue = strSrc.Substring(strSrc.IndexOf(">=") + 2).Trim();
conditionType = ConditionEnum.ConditionEnum_GreatOrEq;
}
else if (strSrc.Contains(">"))
{
leftValue = strSrc.Substring(0, strSrc.IndexOf(">")).Trim();
rightValue = strSrc.Substring(strSrc.IndexOf(">") + 1).Trim();
conditionType = ConditionEnum.ConditionEnum_Great;
}
else if (strSrc.Contains("<="))
{
leftValue = strSrc.Substring(0, strSrc.IndexOf("<=")).Trim();
rightValue = strSrc.Substring(strSrc.IndexOf("<=") + 2).Trim();
conditionType = ConditionEnum.ConditionEnum_LessOrEq;
}
else if (strSrc.Contains("<"))
{
leftValue = strSrc.Substring(0, strSrc.IndexOf("<")).Trim();
rightValue = strSrc.Substring(strSrc.IndexOf("<") + 1).Trim();
conditionType = ConditionEnum.ConditionEnum_Less;
}
return(conditionType);
}
private void ParseCondition(string line)
{
line = line.Remove(0, 10);
line = line.Trim();
foreach (char op in operateurs)
{
if (line.IndexOf(op) != -1)
{
ConditionEnum e = ConditionEnum.Null;
string b = line.Substring(0, line.IndexOf(op));
switch (b)
{
case "Aucune":
e = ConditionEnum.Null;
break;
case "LastMap":
e = ConditionEnum.LastMapId;
break;
case "Level":
e = ConditionEnum.Level;
break;
case "Pods":
e = ConditionEnum.Pods;
break;
case "%Pods":
e = ConditionEnum.PodsPercent;
break;
case "Alive":
e = ConditionEnum.Alive;
break;
}
line = line.Remove(0, line.IndexOf(op) + 1);
Condition c = new Condition(e, line, op, Account);
conditions.Add(c);
return;
}
}
}
/// <summary>
/// 加入SQL查詢條件式
/// </summary>
/// <param name="condition">跟前個條件式間的關係式</param>
/// <param name="colName"></param>
/// <param name="relation"></param>
/// <param name="sqlValue"></param>
public void AddCondition(ConditionEnum condition, string colName, RelationEnum relation, string sqlValue)
{
listSQLElement.Add(CreateConditionElement(condition));
listSQLElement.Add(new SQLElement <string>(colName, relation, sqlValue));
}
/// <summary>
/// 加入關係式
/// </summary>
/// <param name="braket"></param>
public void AddUnaryOperator(ConditionEnum cnd)
{
listSQLElement.Add(CreateConditionElement(cnd));
}
public RuneCondition(ConditionEnum conditionEnum, RuneEnum runeEnum, int value)
{
Condition = conditionEnum;
Value = value;
Rune = runeEnum;
}
public DistanceToTarget(ConditionEnum condition, int value)
{
Condition = condition;
Value = value;
}
/// <summary>
/// 增加条件，适用于between
/// </summary>
/// <param name="filedName"></param>
/// <param name="value"></param>
/// <param name="value1"></param>
/// <param name="condition"></param>
/// <returns></returns>
public DataBaseAction SqlWhere(string filedName, object value, object value1, ConditionEnum condition)
{
return(SqlWhere(filedName, value, value1, condition, RelationEnum.Equal));
}
public RuneCondition(ConditionEnum conditionEnum, RuneEnum runeEnum, int value)
{
Condition = conditionEnum;
Value = value;
Rune = runeEnum;
}
/// <summary>
/// le taux de marque permet de calculer la marge directement depuis le prix de vente HT. Pvht * Tmq = la marge
/// </summary>
public static decimal GetSellingAmount(VATEnum iResultTypePrice, decimal iNetMarkRatePercentage, decimal iBuyingAmount, decimal iShippingAmountTTC, decimal iVariableFeePercentage, decimal iFixedFeeAmount, decimal iVATRate, ConditionEnum iCondition)
{
//TVA sur CA
if (iCondition == ConditionEnum.UNUSED)
{
decimal sellingAmountHT = (iBuyingAmount + (iShippingAmountTTC * iVariableFeePercentage / 100) + iFixedFeeAmount) / (1 - iNetMarkRatePercentage / 100 - (1 + iVATRate / 100) * iVariableFeePercentage / 100);
//retourne le TTC
if (iResultTypePrice == VATEnum.TTC)
{
return((sellingAmountHT * (1 + (iVATRate / 100))).Round2());
}
//Retourne le HT
else if (iResultTypePrice == VATEnum.HT)
{
return(sellingAmountHT.Round2());
}
else
{
throw new NotSupportedException(iResultTypePrice.ToStringWithEnumName());
}
//Prht = Paht + Fv + Ff avec Prht = pvht(1-tmq)
//Pvht = (Paht + Lvttc*Tfv +FF)/(1 - tmq - (1+TVA)(Tfv)) avec Pvttc = pvht *(1+TVA)
}
//Tva sur marge
else if (iCondition == ConditionEnum.USED)
{
decimal sellingPriceHT = (iBuyingAmount + (iShippingAmountTTC - iBuyingAmount * (iVATRate / 100)) * (iVariableFeePercentage / 100) + iFixedFeeAmount) / (1 - iNetMarkRatePercentage / 100 - (1 + iVATRate / 100) * iVariableFeePercentage / 100);
//retourne le TTC
if (iResultTypePrice == VATEnum.TTC)
{
return((sellingPriceHT + (sellingPriceHT - iBuyingAmount) * (iVATRate / 100)).Round2());
}
//Retourne le HT
else if (iResultTypePrice == VATEnum.HT)
{
return((sellingPriceHT).Round2());
}
else
{
throw new NotSupportedException(iResultTypePrice.ToStringWithEnumName());
}
//Prht = Paht + Fv + Ff avec Pvttc = Pvht + (pvht - paht)*TVA avec Prht = pvht(1-tmq)
//pvht = Paht + (Lvttc - Paht*TVA)Tfv + Ff)/(1-Tmq - (1+tva)Tfv)
}
else
{
throw new NotSupportedException(iCondition.ToStringWithEnumName());
}
}
public CombatCountCondition(ConditionEnum condition, int value)
{
Condition = condition;
Value = value;
}
/// <summary>
/// Constructeur de la classe Condition
/// </summary>
/// <param name="_condition">La condition</param>
/// <param name="_intCondition">L'entier qui correspond à la condition.</param>
public Condition(ConditionEnum _condition, int _intCondition)
{
ConditionCondition = _condition;
intCondition = _intCondition;
understandInt();
}
public CombatCountCondition(ConditionEnum condition, int value)
{
Condition = condition;
Value = value;
}
/// <summary>
/// 初始化
/// </summary>
/// <param name="fieldName">字段名</param>
/// <param name="condition">条件</param>
/// <param name="value">值</param>
public Expression(string fieldName, ConditionEnum condition, object value)
{
FieldName = fieldName;
Condition = condition;
Value = value.ToString();
}
/// <summary>
/// 验证if条件是否成立
/// 左值可能是 funOrder.Answer().error_code 格式，也可能是DataTable.value格式
/// </summary>
/// <param name="leftData">左值</param>
/// <param name="rightData">右值</param>
/// <param name="conType">成立条件</param>
/// <returns></returns>
private bool ConditionIsTrue(string leftData, string rightData, ConditionEnum conType)
{
bool isTrue = false;
BizFunction leftFun = null;
DataTable dt = new DataTable();
int leftFieldType = LDSdkTag.TypeUnKnown;
//如果数据格式是应答包格式，即funOrder.Answer().error_code，采用如下处理方式
string leftAnswerFieldName = GetAnswerFieldName(leftData, out leftFun);
if (leftFun != null)
{
BizAnswerField bizField = leftFun.Answer.RspFields.FirstOrDefault(o => o.FieldName.Equals(leftAnswerFieldName));
if (bizField != null)
{
leftData = bizField.FieldValue;
leftFieldType = bizField.FieldType;
}
}
//如果数据格式是SQL返回值格式，即DataTable.value，采用如下处理方式
string[] leftDatas = leftData.Split('.');
if (_dataTableCollection.TryGetValue(leftDatas[0].Trim(), out dt))
{
if (dt != null && dt.Rows.Count > 0)
{
leftData = dt.Rows[0][leftDatas[1]].ToString();
leftFieldType = LDSdkTag.TypeString;
}
else
{
leftData = "null";
leftFieldType = LDSdkTag.TypeString;
}
}
BizFunction rightFun = null;
string rightAnswerFieldName = GetAnswerFieldName(leftData, out rightFun);
int rightFieldType = LDSdkTag.TypeUnKnown;
if (rightFun != null)
{
BizAnswerField bizField = rightFun.Answer.RspFields.FirstOrDefault(o => o.FieldName.Equals(rightAnswerFieldName));
if (bizField != null)
{
rightData = bizField.FieldValue;
rightFieldType = bizField.FieldType;
}
}
if (string.IsNullOrWhiteSpace(leftData) || string.IsNullOrWhiteSpace(rightData))
{
return(false);
}
switch (leftFieldType)
{
case LDSdkTag.TypeuInt16:
case LDSdkTag.TypeuInt8:
case LDSdkTag.TypeuInt32:
case LDSdkTag.TypeuInt64:
case LDSdkTag.TypeInt16:
case LDSdkTag.TypeInt8:
case LDSdkTag.TypeInt32:
case LDSdkTag.TypeInt64:
//整数类型统一转为 int64比较
Int64 leftIntData = Int64.Parse(leftData);
#region
switch (rightFieldType)
{
case LDSdkTag.TypeuInt16:
case LDSdkTag.TypeuInt8:
case LDSdkTag.TypeuInt32:
case LDSdkTag.TypeuInt64:
case LDSdkTag.TypeInt16:
case LDSdkTag.TypeInt8:
case LDSdkTag.TypeInt32:
case LDSdkTag.TypeInt64:
case LDSdkTag.TypeString:
case LDSdkTag.TypeVector:
case LDSdkTag.TypeUnKnown:;
//整数类型统一转为 int64比较
Int64 rightIntData = 0;
Int64.TryParse(rightData, out rightIntData);
switch (conType)
{
case ConditionEnum.ConditionEnum_Eq:
isTrue = leftIntData == rightIntData;
break;
case ConditionEnum.ConditionEnum_Neq:
isTrue = leftIntData != rightIntData;
break;
case ConditionEnum.ConditionEnum_Great:
isTrue = leftIntData > rightIntData;
break;
case ConditionEnum.ConditionEnum_GreatOrEq:
isTrue = leftIntData >= rightIntData;
break;
case ConditionEnum.ConditionEnum_Less:
isTrue = leftIntData < rightIntData;
break;
case ConditionEnum.ConditionEnum_LessOrEq:
isTrue = leftIntData <= rightIntData;
break;
}
break;
case LDSdkTag.TypeDouble:
double rightDoubleData = double.Parse(rightData);
switch (conType)
{
case ConditionEnum.ConditionEnum_Eq:
isTrue = Math.Abs((leftIntData - rightDoubleData)) < 0.00001;
break;
case ConditionEnum.ConditionEnum_Neq:
isTrue = Math.Abs((leftIntData - rightDoubleData)) > 0.00001;
break;
case ConditionEnum.ConditionEnum_Great:
isTrue = leftIntData > rightDoubleData;
break;
case ConditionEnum.ConditionEnum_GreatOrEq:
isTrue = leftIntData >= rightDoubleData;
break;
case ConditionEnum.ConditionEnum_Less:
isTrue = leftIntData < rightDoubleData;
break;
case ConditionEnum.ConditionEnum_LessOrEq:
isTrue = leftIntData <= rightDoubleData;
break;
}
break;
}
#endregion
break;
case LDSdkTag.TypeDouble:
double leftDoubleData = double.Parse(leftData);
#region
switch (rightFieldType)
{
case LDSdkTag.TypeuInt16:
case LDSdkTag.TypeuInt8:
case LDSdkTag.TypeuInt32:
case LDSdkTag.TypeuInt64:
case LDSdkTag.TypeInt16:
case LDSdkTag.TypeInt8:
case LDSdkTag.TypeInt32:
case LDSdkTag.TypeInt64:
case LDSdkTag.TypeString:
case LDSdkTag.TypeVector:
case LDSdkTag.TypeUnKnown:
case LDSdkTag.TypeDouble:
//整数类型统一转为 int64比较
double rightDoubleData = 0;
double.TryParse(rightData, out rightDoubleData);
switch (conType)
{
case ConditionEnum.ConditionEnum_Eq:
isTrue = Math.Abs(leftDoubleData - rightDoubleData) < 0.000001;
break;
case ConditionEnum.ConditionEnum_Neq:
isTrue = Math.Abs(leftDoubleData - rightDoubleData) > 0.000001;
break;
case ConditionEnum.ConditionEnum_Great:
isTrue = leftDoubleData > rightDoubleData;
break;
case ConditionEnum.ConditionEnum_GreatOrEq:
isTrue = leftDoubleData >= rightDoubleData;
break;
case ConditionEnum.ConditionEnum_Less:
isTrue = leftDoubleData < rightDoubleData;
break;
case ConditionEnum.ConditionEnum_LessOrEq:
isTrue = leftDoubleData <= rightDoubleData;
break;
}
break;
}
#endregion
break;
case LDSdkTag.TypeString:
case LDSdkTag.TypeVector:
case LDSdkTag.TypeUnKnown:
#region
switch (rightFieldType)
{
case LDSdkTag.TypeuInt16:
case LDSdkTag.TypeuInt8:
case LDSdkTag.TypeuInt32:
case LDSdkTag.TypeuInt64:
case LDSdkTag.TypeInt16:
case LDSdkTag.TypeInt8:
case LDSdkTag.TypeInt32:
case LDSdkTag.TypeInt64:
case LDSdkTag.TypeDouble:
leftDoubleData = 0;
double.TryParse(leftData, out leftDoubleData);
double rightDoubleData = 0;
double.TryParse(rightData, out rightDoubleData);
switch (conType)
{
case ConditionEnum.ConditionEnum_Eq:
isTrue = Math.Abs(leftDoubleData - rightDoubleData) < 0.000001;
break;
case ConditionEnum.ConditionEnum_Neq:
isTrue = Math.Abs(leftDoubleData - rightDoubleData) > 0.000001;
break;
case ConditionEnum.ConditionEnum_Great:
isTrue = leftDoubleData > rightDoubleData;
break;
case ConditionEnum.ConditionEnum_GreatOrEq:
isTrue = leftDoubleData >= rightDoubleData;
break;
case ConditionEnum.ConditionEnum_Less:
isTrue = leftDoubleData < rightDoubleData;
break;
case ConditionEnum.ConditionEnum_LessOrEq:
isTrue = leftDoubleData <= rightDoubleData;
break;
}
break;
default:
switch (conType)
{
case ConditionEnum.ConditionEnum_Eq:
isTrue = leftData.Equals(rightData);
break;
case ConditionEnum.ConditionEnum_Neq:
isTrue = !leftData.Equals(rightData);
break;
case ConditionEnum.ConditionEnum_Great:
isTrue = leftData.CompareTo(rightData) > 0;
break;
case ConditionEnum.ConditionEnum_GreatOrEq:
isTrue = leftData.CompareTo(rightData) >= 0;
break;
case ConditionEnum.ConditionEnum_Less:
isTrue = leftData.CompareTo(rightData) < 0;
break;
case ConditionEnum.ConditionEnum_LessOrEq:
isTrue = leftData.CompareTo(rightData) <= 0;
break;
}
break;
}
#endregion
break;
}
return(isTrue);
}
public DistanceToTarget(ConditionEnum condition, int value)
{
Condition = condition;
Value = value;
}
/// <summary>
/// 增加条件,特殊的类似 in，不等于，大于
/// </summary>
/// <param name="filedName"></param>
/// <param name="value"></param>
/// <param name="relation"></param>
/// <param name="condition"></param>
/// <returns></returns>
public DataBaseAction SqlWhere(string filedName, object value, ConditionEnum condition = ConditionEnum.And, RelationEnum relation = RelationEnum.Equal)
{
return(SqlWhere(filedName, value, null, condition, relation));
}
/// <summary>
/// 运行数据包？
/// </summary>
/// <param name="strBui"></param>
/// <param name="defaultTable"></param>
private void RunMsg(string strBui, DataTable defaultTable)
{
bool note = strBui.Trim().StartsWith("#");
if (note)
{
return;
}
//if开头
bool isIf = strBui.Trim().StartsWith("if ");
if (isIf)
{
string[] strIf = strBui.Trim().Replace("if", "").Trim().Split(':');
if (strIf.Count() != 2)
{
throw new Exception("if 语句不符合规则");
}
string leftValue = "";
string rightValue = "";
//拿出条件判断式的左右两边数据，并且得到条件类型
ConditionEnum conType = UtilTool.GetConditionRL(strIf[0], out leftValue, out rightValue);
if (conType == ConditionEnum.ConditionEnum_Unkown)
{
throw new Exception("if 语句不符合规则");
}
if (ConditionIsTrue(leftValue, rightValue, conType))
{
strBui = strIf[1];
}
else
{
return;
}
}
//set开头
bool isSetValue = strBui.Trim().StartsWith("set");
if (isSetValue)
{
string fieldValue = strBui.Split('=')[1].Trim(); //等号右边值 这个值在哪里赋给变量的？？？？
string fieldName = strBui.Split('=')[0].Split('.')[1].Trim(); //入参名称
//代表功能号的变量，类似funOrder.Answer().error_code中的funOrder
string funVar = strBui.Split('=')[0].Split('.')[0].Replace("set", "").Trim();
BizFunction fun = null;
if (_sendFuncList.TryGetValue(funVar, out fun))
{
BizRequestField bizReq = fun.ReqFields.FirstOrDefault(o => o.FieldName.Equals(fieldName));
if (bizReq != null && bizReq.IsVarValue)
{
//请求参数的值是功能号返回的结果集的，要替换
BizFunction outFun = null;
if (_sendFuncList.TryGetValue(bizReq.VarFunValue, out outFun))
{
BizAnswerField bizAnaswer = outFun.Answer.RspFields.FirstOrDefault(o => o.FieldName.Equals(bizReq.VarFieldName));
if (bizAnaswer != null)
{
bizReq.FieldValue = bizAnaswer.FieldValue;
}
}
}
//郑建翔新增部分逻辑，之前的请求参数是变量只有可能是功能号返回的结果，现在
//有可能是SQL查询回来的结果 2019-09-30
if (bizReq != null && bizReq.IsSqlValue)
{
DataTable dt = null;
if (_dataTableCollection.TryGetValue(bizReq.DataTableName, out dt))
{
if (dt != null && dt.Rows.Count > 0)
{
string columnName = fieldValue.Split('.')[1].Trim();
bizReq.FieldValue = dt.Rows[0][columnName].ToString();
}
else
{
StringBuilder printBu = new StringBuilder();
printBu.Append($"数据集{bizReq.DataTableName}的SQL查询返回结果集为空！");
}
}
}
}
return;
}
bool isSend = strBui.Trim().EndsWith("Send()");
if (isSend)
{
string funVar = strBui.Split('.')[0].Trim();
BizFunction fun = null;
if (_sendFuncList.TryGetValue(funVar, out fun))
{
//发送数据包
SendFastMsgFun(fun, defaultTable);
}
return;
}
bool isSleep = strBui.Trim().StartsWith("sleep");
if (isSleep)
{
string funSleep = strBui.Split('=')[1].Trim();
Thread.Sleep(int.Parse(funSleep));
return;
}
//print开头
bool isPrint = strBui.Trim().StartsWith("Print ");
if (isPrint)
{
//打印到控制台
string printMsg = strBui.Trim().Replace("Print", "").Trim();
string[] printAry = printMsg.Split('&');
StringBuilder printBu = new StringBuilder();
for (int i = 0; i < printAry.Count(); i++)
{
BizFunction fun;
DataTable dt = new DataTable();
string answerFieldName = GetAnswerFieldName(printAry[i], out fun);
if (fun == null)
{
//如果是SQL返回结果集，用如下方法打印
if (_dataTableCollection.TryGetValue(printAry[i].Split('.')[0].Trim(), out dt))
{
if (dt.Rows.Count > 0)
{
printBu.Append(dt.Rows[0][printAry[i].Split('.')[1].Trim()].ToString());
}
else
{
printBu.Append("该SQL查询返回结果集为空！");
}
}
else
{
printBu.Append(printAry[i].Trim('\''));
}
}
else
{
BizAnswerField bizAnswer = fun.Answer.RspFields.FirstOrDefault(o => o.FieldName.Equals(answerFieldName));
if (bizAnswer == null)
{
printBu.Append(printAry[i].Trim('\''));
}
else
{
printBu.Append(bizAnswer.FieldValue);
}
}
}
// PrintHelper.Print.WriteLine(printBu.ToString());
PrintHelper.Print.AppendLine(printBu.ToString());
return;
}
bool isWriteLog = strBui.Trim().StartsWith("WriteLog");
if (isWriteLog)
{
//打印到控制台
string writeLogMsg = strBui.Trim().Replace("WriteLog", "").Trim();
string[] printAry = writeLogMsg.Split('&');
return;
}
if ("Exit".Equals(strBui.Trim()))
{
_exit = true;
return;
}
}
/// <summary>
/// 增加条件
/// </summary>
/// <param name="filedName"></param>
/// <param name="value"></param>
/// <param name="value1"></param>
/// <param name="condition"></param>
/// <returns></returns>
public DataBaseAction SqlWhere(string filedName, object value, object value1, ConditionEnum condition, RelationEnum relation)
{
if (!AppCons.IsParmes || relation == RelationEnum.In)
{
QueryField wherestr = new QueryField()
{
FiledName = filedName,
Value = value,
Value2 = value1,
Condition = condition,
Relation = relation
};
wherestr.Value = GetValueRelation(value, relation);
_whereStr.Append(Sqlcom.CreateWhere(wherestr));
}
else
{
string parmeterName = DbHelper.GetParameterName(filedName);
string parmeterName1 = string.Empty;
if (value1 != null)
{
parmeterName1 = DbHelper.GetParameterName(filedName + "_1");
}
QueryField wherestr = new QueryField()
{
FiledName = filedName,
Value = parmeterName,
Value2 = parmeterName1,
Condition = condition,
Relation = relation
};
AddParmarms(parmeterName, Sqlcom.ConvertToDbType(value), GetValueRelation(value, relation));
if (value1 != null)
{
AddParmarms(parmeterName1, _dbHelper.ConvertToDbType(value1), value1);
}
_whereStr.Append(Sqlcom.CreateWhere(wherestr));
}
return(this);
}
/// <summary>
/// Initializes a new instance of the <see cref="ConditionOption" /> class.
/// </summary>
/// <param name="condition">Condition of an email object that can be used to filter results (required).</param>
/// <param name="value">Expected condition value (required).</param>
public ConditionOption(ConditionEnum condition = default(ConditionEnum), ValueEnum value = default(ValueEnum))
{
this.Condition = condition;
this.Value = value;
}
