protected override void FillUpdateTables(IInputData input)
{
base.FillUpdateTables(input);
foreach (var childInfo in OneToOneTables)
{
var resolver = childInfo.Resolver;
if (!FillingUpdateArgs.Handled.IsHandled(resolver))
{
base.FillUpdateTables(resolver, input, childInfo);
}
DataTable table = resolver.HostTable;
if (table.Rows.Count == 0)
{
switch (childInfo.NoRecordHandler)
{
case NoRecordHandler.None:
break;
case NoRecordHandler.Error:
TkDebug.ThrowToolkitException(string.Format(ObjectUtil.SysCulture,
"一对一子表[{0}]的数据无法对应，请确认", table.TableName), this);
break;
case NoRecordHandler.EmptyRecord:
DataRow row = table.NewRow();
table.Rows.Add(row);
if (input.Style.Style == PageStyle.Update)
{
resolver.SetDefaultValue(row);
}
break;
}
}
}
}
protected void SetStateBasedOnCurrent()
{
JsonTokenType currentObject = Peek();
switch (currentObject)
{
case JsonTokenType.Object:
CurrentState = State.Object;
break;
case JsonTokenType.Array:
CurrentState = State.Array;
break;
case JsonTokenType.Constructor:
CurrentState = State.Constructor;
break;
case JsonTokenType.None:
CurrentState = State.Finished;
break;
default:
TkDebug.ThrowToolkitException("将reader状态设置会原先的对象时，碰到一个并不是期望的JsonType: "
+ currentObject, this);
break;
}
}
public void AddParameter(string name, ParameterDirection direction, TkDataType type,
int size, object value)
{
if (fParamCreated)
{
TkDebug.ThrowToolkitException(string.Format(ObjectUtil.SysCulture,
"存储过程{0}已经执行过了，不能再添加参数了", ProcName), this);
return;
}
StoredProcParameter param = Add(name, direction, type);
if (size > 0)
{
param.Size = size;
}
if (value != null)
{
param.Value = value;
}
fParams.Add(param);
if (DbUtil.IsInputParameter(direction))
{
fInputParams.Add(name, param);
}
if (direction != ParameterDirection.Input)
{
fOutputParams.Add(name, param);
}
}
private static IDisplay GetDisplay(Tk5FieldInfoEx field, IPageData pageData)
{
switch (pageData.Style.Style)
{
case PageStyle.Insert:
case PageStyle.Update:
return(field.Edit.Display.CreateObject());
case PageStyle.Detail:
return(field.ListDetail.DetailDisplay.CreateObject());
case PageStyle.List:
return(field.ListDetail.ListDisplay.CreateObject());
default:
if (MetaDataUtil.StartsWith(pageData.Style, "DetailList"))
{
return(field.ListDetail.ListDisplay.CreateObject());
}
TkDebug.ThrowToolkitException(
string.Format(ObjectUtil.SysCulture, "当前页面类型是{0}，没有可用的Display，请不要使用这种PageMaker",
PageStyleClass.FromStyle(pageData.Style)), field);
return(null);
}
}
public object this[string paramName]
{
get
{
TkDebug.AssertArgumentNullOrEmpty(paramName, "paramName", this);
if (fOutputParams.ContainsKey(paramName))
{
return(fOutputParams[paramName].Value);
}
else
{
TkDebug.ThrowToolkitException(string.Format(ObjectUtil.SysCulture,
"输出参数中没有名称为{0}的参数", paramName), this);
}
return(null);
}
set
{
TkDebug.AssertArgumentNullOrEmpty(paramName, "paramName", this);
fValueChanged = true;
if (fInputParams.ContainsKey(paramName))
{
fInputParams[paramName].Value = value;
}
else
{
TkDebug.ThrowToolkitException(string.Format(ObjectUtil.SysCulture,
"输入参数中没有名称为{0}的参数", paramName), this);
}
}
}
private void CreateStoredProc()
{
if (Command == null)
{
if (Context != null)
{
fUseContext = true;
fConnection = Context.DbConnection;
Command = Context.CreateCommand();
}
else if (Connection != null)
{
fConnection = Connection;
Command = Connection.CreateCommand();
fUseContext = false;
}
else
{
TkDebug.ThrowToolkitException(
string.Format(ObjectUtil.SysCulture,
"存储过程{0}没有设定DbConnection或者DbContext，请检查", ProcName), this);
}
Command.CommandType = CommandType.StoredProcedure;
Command.CommandText = ProcName;
PrepareParameters();
}
else
{
SetInputValues();
}
}
private static object ExecuteScalar(IDbConnection connection, IDbCommand command)
{
DbConnectionStatus item = new DbConnectionStatus(connection);
object result = null;
item.OpenDbConnection();
try
{
result = command.ExecuteScalar();
}
catch (Exception ex)
{
TkDebug.ThrowToolkitException(string.Format(ObjectUtil.SysCulture,
"执行SQL:{0}出错", command.CommandText), ex, null);
}
finally
{
item.CloseDbConnection();
}
if (result == null)
{
result = DBNull.Value;
}
return(result);
}
internal void ProcessRefField(RegNameList <Tk5FieldInfoEx> fields)
{
if (Decoder == null)
{
return;
}
SimpleFieldDecoder decoder = Decoder as SimpleFieldDecoder;
if (decoder == null || decoder.RefFields == null)
{
return;
}
foreach (var refField in decoder.RefFields)
{
Tk5FieldInfoEx refFieldInfo = fields[refField.RefField];
if (refFieldInfo != null)
{
refField.CtrlType = refFieldInfo.InternalControl.Control;
}
else
{
TkDebug.ThrowToolkitException(string.Format(ObjectUtil.SysCulture,
"没有查找到{0}字段的定义，请确认", refField.RefField), this);
}
}
}
public WeRefundRequest(OrderType orderType, string orderId, string outRefundNo, int totalFee, int refundFee)
: this()
{
TkDebug.AssertArgumentNullOrEmpty(orderId, "orderId", null);
TkDebug.AssertArgumentNullOrEmpty(outRefundNo, "outRefundNo", null);
switch (orderType)
{
case OrderType.TransactionId:
TransactionId = orderId;
break;
case OrderType.OutTradeNo:
OutTradeNo = orderId;
break;
case OrderType.OutRefundNo:
case OrderType.RefundId:
TkDebug.ThrowToolkitException(string.Format(ObjectUtil.SysCulture,
"当前不支持{0}这种枚举，请确认", orderType), null);
break;
}
OutRefundNo = outRefundNo;
TotalFee = totalFee;
RefundFee = refundFee;
OpUserId = MchId;
}
private void WriteConstructorDate(JsonReader reader)
{
if (!reader.Read())
{
TkDebug.ThrowToolkitException("在读日期构造函数时，出现非期望的结束", this);
}
if (reader.TokenType != JsonToken.Integer)
{
TkDebug.ThrowToolkitException("在读日期构造函数时，出现非期望的token。期望整数, 实际是"
+ reader.TokenType, this);
}
long ticks = (long)reader.Value;
DateTime date = JsonConvert.ConvertJavaScriptTicksToDateTime(ticks);
if (!reader.Read())
{
TkDebug.ThrowToolkitException("在读日期构造函数时，出现非期望的结束", this);
}
if (reader.TokenType != JsonToken.EndConstructor)
{
TkDebug.ThrowToolkitException("在读日期构造函数时，出现非期望的token。期望结束构造函数, 实际是"
+ reader.TokenType, this);
}
WriteValue(date);
}
public object GetItem(string key, BaseCacheItemCreator creator, params object[] args)
{
object result = null;
ICacheDataConverter converter = GetDataConverter(creator);
var distributeKey = GetDistributeKey(creator, key);
if (GetCacheInstance(distributeKey, converter, out var cacheObject))
{
return(cacheObject);
}
try
{
result = creator.Create(key, args);
TkDebug.AssertNotNull(result, string.Format(ObjectUtil.SysCulture,
"类型为{0}缓存对象创建者没有创建缓存对象，请确认",
creator.GetType()), creator);
}
catch (Exception ex)
{
TkDebug.ThrowToolkitException(string.Format(ObjectUtil.SysCulture,
"类型为{0}缓存对象创建者在创建对象时发生例外，请检查原因",
creator.GetType()), ex, creator);
}
ICacheDependency dependency = CacheUtil.SearchDependency(result);
IDistributeCacheDependency distributeDependency = dependency as IDistributeCacheDependency;
TkDebug.AssertNotNull(distributeDependency,
$"附着的ICacheDependency（类型为{dependency.GetType()}）不支持IDistributeCacheDependency", dependency);
AddCacheInstance(distributeKey, result, converter, distributeDependency,
creator.Attribute.ForceCache);
return(result);
}
public override OutputData DoAction(IInputData input)
{
PageStyle style = input.Style.Style;
KeyData data = null;
if (style == PageStyle.Delete)
{
try
{
Prepare();
data = DoDeleteAction(input);
}
catch (WebPostException ex)
{
return(OutputData.CreateToolkitObject(ex.CreateErrorResult()));
}
}
else
{
TkDebug.ThrowToolkitException(string.Format(ObjectUtil.SysCulture,
"当前支持页面类型为Delete，当前类型是{0}", input.Style), this);
}
return(OutputData.CreateToolkitObject(data));
}
/// <summary>
/// 更新数据
/// </summary>
/// <param name="postDataSet">提交的数据集</param>
public void Update(DataSet postDataSet, IInputData inputData)
{
TkDebug.AssertArgumentNull(postDataSet, "postDataSet", this);
DataTable postTable = postDataSet.Tables[TableName];
switch (UpdateMode)
{
case UpdateMode.OneRow:
if (postTable == null)
{
return;
}
CopyUpdateTable(postTable, inputData);
break;
case UpdateMode.DelIns:
if (IsFakeDelete)
{
TkDebug.ThrowToolkitException("DelIns模式下，不支持FakeDelete操作", this);
}
CopyDelInsTable(postTable, postDataSet, inputData);
break;
case UpdateMode.Merge:
if (IsFakeDelete)
{
TkDebug.ThrowToolkitException("Merge模式下，不支持FakeDelete操作", this);
}
CopyMergeTable(postTable, postDataSet, inputData);
break;
}
}
public object GetItem(string key, BaseCacheItemCreator creator, params object[] args)
{
object result = null;
object cacheObject;
if (GetCacheInstance(key, out cacheObject))
{
return(cacheObject);
}
try
{
result = creator.Create(key, args);
TkDebug.AssertNotNull(result, string.Format(ObjectUtil.SysCulture,
"类型为{0}缓存对象创建者没有创建缓存对象，请确认",
creator.GetType()), creator);
}
catch (Exception ex)
{
TkDebug.ThrowToolkitException(string.Format(ObjectUtil.SysCulture,
"类型为{0}缓存对象创建者在创建对象时发生例外，请检查原因",
creator.GetType()), ex, creator);
}
AddCacheInstance(key, result, CacheUtil.SearchDependency(result),
creator.Attribute.ForceCache);
return(result);
}
/// <summary>
/// 计算Sequence的下一个值
/// </summary>
/// <param name="name">Sequence的名称</param>
/// <param name="connection">数据库连接</param>
/// <returns>该Sequence的下一个数值</returns>
public static string Execute(string name, IDbConnection connection)
{
TkDebug.AssertArgumentNullOrEmpty(name, "name", null);
TkDebug.AssertArgumentNull(connection, "connection", null);
try
{
return(ExecuteSequence(name, connection));
}
catch (Exception ex)
{
string sql = string.Format(ObjectUtil.SysCulture,
"SELECT COUNT(*) FROM USER_SEQUENCES WHERE SEQUENCE_NAME = 'S_{0}'", name);
int count = int.Parse(DbUtil.ExecuteScalar(sql, connection).ToString(),
ObjectUtil.SysCulture);
if (count == 0)
{
sql = string.Format(ObjectUtil.SysCulture,
"CREATE SEQUENCE S_{0}", name);
DbUtil.ExecuteNonQuery(sql, connection);
return(ExecuteSequence(name, connection));
}
else
{
TkDebug.ThrowToolkitException(
string.Format(ObjectUtil.SysCulture,
"系统中存在S_{0}的Sequence，却无法取值，请检查数据库方面的原因", name), ex, null);
return(null);
}
}
}
private void ParseConstructor()
{
if (MatchValue("new", true))
{
if (EatWhitespace(true))
{
while (char.IsLetter(fCurrentChar))
{
fBuffer.Append(fCurrentChar);
MoveNext();
}
EatWhitespace(false);
if (fCurrentChar != '(')
{
TkDebug.ThrowToolkitException(string.Format(ObjectUtil.SysCulture,
"在分析建构函数时,遇见非法字符: {0}. 在第{1}行, 第{2}列.",
fCurrentChar, fCurrentLineNumber, fCurrentLinePosition), this);
}
string constructorName = fBuffer.ToString();
fBuffer.Position = 0;
SetToken(JsonToken.StartConstructor, constructorName);
}
}
}
private void AssertRead()
{
if (!fReader.Read())
{
TkDebug.ThrowToolkitException(
"需要读取Json数据时，却无法读出，请确认数据是否完整", this);
}
}
private void AutoCompleteClose(JsonToken tokenBeingClosed)
{
// write closing symbol and calculate new state
int levelsToComplete = 0;
for (int i = 0; i < fTop; i++)
{
int currentLevel = fTop - i;
if (fStack[currentLevel] == GetTypeForCloseToken(tokenBeingClosed))
{
levelsToComplete = i + 1;
break;
}
}
TkDebug.Assert(levelsToComplete != 0, "No token to close.", this);
//if (levelsToComplete == 0)
// throw new JsonWriterException("");
for (int i = 0; i < levelsToComplete; i++)
{
JsonToken token = GetCloseTokenForType(Pop());
if (fCurrentState != State.ObjectStart && fCurrentState != State.ArrayStart)
{
WriteIndent();
}
WriteEnd(token);
}
JsonTokenType currentLevelType = Peek();
switch (currentLevelType)
{
case JsonTokenType.Object:
fCurrentState = State.Object;
break;
case JsonTokenType.Array:
fCurrentState = State.Array;
break;
case JsonTokenType.Constructor:
fCurrentState = State.Array;
break;
case JsonTokenType.None:
fCurrentState = State.Start;
break;
default:
TkDebug.ThrowToolkitException("非期望的JSON类型: " + currentLevelType, this);
break;
}
}
string IParamExpression.Execute(string parameter)
{
Match match = fExpr.Match(parameter);
TkDebug.AssertNotNull(match, string.Format(ObjectUtil.SysCulture,
"参数{0}格式不正确，正确格式为TableName.FieldName[.(number | n [ - number])]" +
"[#EasySearchRegName]，请检查", parameter), this);
string tableName = match.Groups["Table"].Value;
string fieldName = match.Groups["Column"].Value;
string regName = match.Groups["RegName"].Value;
int count = 0;
bool isLast = true;
string first = match.Groups["First"].Value;
if (!string.IsNullOrEmpty(first))
{
isLast = false;
count = int.Parse(first, ObjectUtil.SysCulture);
}
else
{
string lastCount = match.Groups["Count"].Value;
if (!string.IsNullOrEmpty(lastCount))
{
try
{
count = int.Parse(lastCount, ObjectUtil.SysCulture);
}
catch
{
TkDebug.ThrowToolkitException(string.Format(ObjectUtil.SysCulture,
"[n - number]格式中number必须是数字，但是现在不是，它的值是{0}", lastCount), this);
}
}
}
DataTable table = fDataSet.Tables[tableName];
TkDebug.AssertNotNull(table, string.Format(ObjectUtil.SysCulture,
"宏{0}中定义的表{1}在DataSet中不存在", parameter, tableName), this);
TkDebug.Assert(table.Columns.Contains(fieldName), string.Format(ObjectUtil.SysCulture,
"宏{0}中定义的字段{1}在表中不存在", parameter, fieldName), this);
int rowCount = table.Rows.Count;
int rowNumber = isLast ? rowCount - 1 - count : count;
TkDebug.Assert(rowNumber >= 0 && rowNumber < rowCount, string.Format(ObjectUtil.SysCulture,
"行号定义错误，当前表中有{0}行记录，而现在行号为{1}", rowCount, rowNumber), this);
string value = table.Rows[rowNumber][fieldName].ToString();
if (!string.IsNullOrEmpty(regName))
{
//EasySearch easySearch = PlugInFactoryManager.CreateInstance<EasySearch>(
// "EasySearch", regName);
//TkDebug.AssertNotNull(fContext,
// "参数宏($)需要Context对象，但是没有从外部对象中找到", this);
//value = easySearch.Decode(fContext, value);
}
return(value);
}
private void AssertReadState(JsonToken token1, JsonToken token2)
{
if (fReader.TokenType != token1 && fReader.TokenType != token2)
{
TkDebug.ThrowToolkitException(string.Format(ObjectUtil.SysCulture,
"Json数据的状态有问题，当前需要的状态是{0}或{1}，实际状态却是{2}，在第{3}行，第{4}列",
token1, token2, fReader.TokenType, fReader.CurrentLineNumber, fReader.CurrentLinePosition), this);
}
}
internal void AutoComplete(JsonToken tokenBeingWritten)
{
int token;
switch (tokenBeingWritten)
{
default:
token = (int)tokenBeingWritten;
break;
case JsonToken.Integer:
case JsonToken.Float:
case JsonToken.String:
case JsonToken.Boolean:
case JsonToken.Null:
case JsonToken.Undefined:
case JsonToken.Date:
case JsonToken.Bytes:
// a value is being written
token = 7;
break;
}
// gets new state based on the current state and what is being written
State newState = stateArray[token][(int)fCurrentState];
if (newState == State.Error)
{
TkDebug.ThrowToolkitException(string.Format(ObjectUtil.SysCulture,
"Token {0} in state {1} would result in an invalid JavaScript object.",
tokenBeingWritten, fCurrentState), this);
}
if ((fCurrentState == State.Object || fCurrentState == State.Array ||
fCurrentState == State.Constructor) && tokenBeingWritten != JsonToken.Comment)
{
WriteValueDelimiter();
}
else if (fCurrentState == State.Property)
{
if (Formatting == JsonFormatting.Indented)
{
WriteIndentSpace();
}
}
JsonWriteState writeState = WriteState;
// don't indent a property when it is the first token to be written (i.e. at the start)
if ((tokenBeingWritten == JsonToken.PropertyName && writeState != JsonWriteState.Start) ||
writeState == JsonWriteState.Array || writeState == JsonWriteState.Constructor)
{
WriteIndent();
}
fCurrentState = newState;
}
public static IParamBuilder CreateInSql(TkDbContext context, IFieldInfo fieldName,
IEnumerable <string> values)
{
TkDebug.AssertArgumentNull(fieldName, "fieldName", null);
TkDebug.AssertArgumentNull(values, "values", null);
string[] valueArray = values.ToArray();
if (valueArray.Length == 0)
{
return(ParamBuilder.NoResult);
}
string seperator = string.Empty;
switch (fieldName.DataType)
{
case TkDataType.String:
seperator = "\'";
break;
case TkDataType.Int:
case TkDataType.Byte:
case TkDataType.Short:
case TkDataType.Double:
case TkDataType.Long:
break;
default:
TkDebug.ThrowToolkitException(string.Format(ObjectUtil.SysCulture,
"生成IN SQL语句的字段只支持字符串、整形、浮点三种类型，现在字段{0}类型是{1}，不在支持范围",
fieldName.FieldName, fieldName.DataType), null);
break;
}
var items = from value in valueArray
select seperator + StringUtil.EscapeAposString(value) + seperator;
string insql = string.Join(",", items);
string field;
if (context != null)
{
field = context.EscapeName(fieldName.FieldName);
}
else
{
field = fieldName.FieldName;
}
string sql = string.Format(ObjectUtil.SysCulture, "{0} IN ({1})",
field, insql);
InternalParamBuilder builder = new InternalParamBuilder {
Sql = sql
};
return(builder);
}
//private void AssertReadState(JsonToken token1, JsonToken token2, JsonToken token3)
//{
// if (fReader.TokenType != token1 && fReader.TokenType != token2 && fReader.TokenType != token3)
// TkDebug.ThrowToolkitException(string.Format(ObjectUtil.SysCulture,
// "Json数据的状态有问题，当前需要的状态是{0}或{1}或{5}，实际状态却是{2}，在第{3}行，第{4}列",
// token1, token2, fReader.TokenType, fReader.CurrentLineNumber, fReader.CurrentLinePosition, token3), this);
//}
private void AssertReadState(params JsonToken[] tokens)
{
var result = tokens.Any(token => fReader.TokenType == token);
if (!result)
{
string hint = string.Join("或", tokens);
string message = $"Json数据的状态有问题，当前需要的状态是{hint}，实际状态却是{fReader.TokenType}，"
+ $"在第{fReader.CurrentLineNumber}行，第{fReader.CurrentLinePosition}列";
TkDebug.ThrowToolkitException(message, this);
}
}
public override bool Read()
{
while (true)
{
if (fCurrentChar == '\0')
{
if (!MoveNext())
{
return(false);
}
}
switch (CurrentState)
{
case State.Start:
case State.Property:
case State.Array:
case State.ArrayStart:
case State.Constructor:
case State.ConstructorStart:
return(ParseValue());
case State.Complete:
break;
case State.Object:
case State.ObjectStart:
return(ParseObject());
case State.PostValue:
// returns true if it hits
// end of object or array
if (ParsePostValue())
{
return(true);
}
break;
case State.Closed:
break;
case State.Error:
break;
default:
TkDebug.ThrowToolkitException(string.Format(ObjectUtil.SysCulture,
"不是期望的状态: {0}. 在第{1}行, 第{2}列.",
CurrentState, fCurrentLineNumber, fCurrentLinePosition), this);
break;
}
}
}
private void ParseUndefined()
{
if (MatchValue(Undefined, true))
{
SetToken(JsonToken.Undefined);
}
else
{
TkDebug.ThrowToolkitException(string.Format(ObjectUtil.SysCulture,
"分析undefined值时出错. 在第{0}行, 第{1}列.",
fCurrentLineNumber, fCurrentLinePosition), this);
}
}
private void ParseFalse()
{
if (MatchValue(False, true))
{
SetToken(JsonToken.Boolean, false);
}
else
{
TkDebug.ThrowToolkitException(string.Format(ObjectUtil.SysCulture,
"分析False值时出错. 在第{0}行, 第{1}列.",
fCurrentLineNumber, fCurrentLinePosition), this);
}
}
private void ParseNumberNaN()
{
if (MatchValue(NaN, true))
{
SetToken(JsonToken.Float, double.NaN);
}
else
{
TkDebug.ThrowToolkitException(string.Format(ObjectUtil.SysCulture,
"分析NaN值时出错. 在第{0}行, 第{1}列.",
fCurrentLineNumber, fCurrentLinePosition), this);
}
}
public override string Execute(object[] customData)
{
try
{
GiveExpressionData(fExpression, customData);
return(fExpression.Execute());
}
catch (Exception ex)
{
TkDebug.ThrowToolkitException(string.Format(ObjectUtil.SysCulture,
"宏(注册关键字{0})在计算表达式时出错，请检查原因", fAttribute.RegName), ex, fExpression);
return(string.Empty);
}
}
protected virtual IContent WritePage(ISource source, IPageData pageData, OutputData outputData)
{
fList.Sort(OrderComparer.Comparer);
foreach (PageMakerInfo item in fList)
{
if (item.Function(source, pageData, outputData))
{
PrepareWritePage(item.PageMaker, source, pageData, outputData);
return(item.PageMaker.WritePage(source, pageData, outputData));
}
}
TkDebug.ThrowToolkitException("当前的状态下，没有一个注册的PageMaker满足其条件，请检查条件", this);
return(null);
}
public override OutputData DoAction(IInputData input)
{
if (MetaDataUtil.StartsWith(input.Style, "DetailList"))
{
InputDataProxy proxy = new InputDataProxy(input, (PageStyleClass)PageStyle.List);
DoListAction(proxy);
input.CallerInfo.AddInfo(DataSet);
return(OutputData.Create(DataSet));
}
TkDebug.ThrowToolkitException(string.Format(ObjectUtil.SysCulture,
"当前支持页面类型为CDetailList，当前类型是{0}", input.Style), this);
return(null);
}
