public ViewBufferValue[] GetPage(int pageSize)
{
TkDebug.AssertArgument(pageSize > 0, nameof(pageSize),
$"{nameof(pageSize)}必须大于0，当前值是{pageSize}", this);
if (fDisposed)
{
throw new ObjectDisposedException(typeof(MemoryPoolViewBufferScope).FullName);
}
if (fLeased == null)
{
fLeased = new List <ViewBufferValue[]>(1);
}
ViewBufferValue[] segment = null;
// Reuse pages that have been returned before going back to the memory pool.
if (fAvailable != null && fAvailable.Count > 0)
{
segment = fAvailable[fAvailable.Count - 1];
fAvailable.RemoveAt(fAvailable.Count - 1);
return(segment);
}
try
{
segment = fViewBufferPool.Rent(Math.Max(pageSize, MinimumSize));
fLeased.Add(segment);
}
catch when(segment != null)
{
fViewBufferPool.Return(segment);
throw;
}
return(segment);
}
public string DisplayValue(object value, Tk5FieldInfoEx field, IFieldValueProvider rowValue)
{
TkDebug.AssertArgumentNull(field, "field", this);
if (DisplayUtil.IsNull(value))
{
return(string.Empty);
}
if (field.Upload != null)
{
Tk5UploadConfig upload = field.AssertUpload();
IUploadProcessor2 processor = upload.CreateUploadProcessor2();
//IFieldValueProvider provider = new DataRowFieldValueProvider(row, row.Table.DataSet);
string url = processor.Display(upload, rowValue);
return(string.Format(ObjectUtil.SysCulture, "<a href=\"{2}\" target=\"_blank\">{0}{1}</a>",
StringUtil.EscapeHtml(rowValue.GetValue(upload.FileNameField)),
BaseUploadProcessor.FormatSize(rowValue.GetValue <int>(upload.SizeField)),
StringUtil.EscapeHtmlAttribute(url)));
}
return(string.Empty);
}
public string GetSearchControl(string regName, object sender)
{
TkDebug.AssertArgumentNullOrEmpty(regName, "regName", sender);
var item = ObjectUtil.TryGetValue(fDictionary, regName);
TkDebug.AssertNotNull(item, string.Format(ObjectUtil.SysCulture, "{0}尚未注册", regName),
sender);
String searchCtrl = item.Item1;
if (searchCtrl == "~")
{
TkDebug.ThrowToolkitException(
string.Format(ObjectUtil.SysCulture, "控件类型{0}不支持查询", regName), sender);
}
if (string.IsNullOrEmpty(searchCtrl))
{
searchCtrl = regName;
}
return(searchCtrl);
}
public byte[] Export(ObjectListModel listModel)
{
TkDebug.AssertArgumentNull(listModel, "listModel", null);
MemoryStream ms = new MemoryStream();
using (ms)
{
IWorkbook workbook = new HSSFWorkbook();
ISheet sheet = workbook.CreateSheet(fMetaData.Table.TableDesc);
HeaderSetting(workbook, sheet);
Dictionary <string, ICellStyle> ContentStyles = GetContentStyles(workbook);
if (listModel.List != null)
{
ObjectExport(ContentStyles, sheet, listModel);
}
workbook.Write(ms);
ms.Flush();
return(ms.ToArray());
}
}
string ISqlProvider.GetFunction(string funcName, params object[] funcParams)
{
TkDebug.AssertArgumentNullOrEmpty(funcName, "funcName", this);
switch (funcName.ToUpper(ObjectUtil.SysCulture))
{
case "SUBSTRING":
TkDebug.AssertEnumerableArgumentNull(funcParams, "funcParams", this);
TkDebug.AssertArgument(funcParams.Length == 3, "funcParams", string.Format(ObjectUtil.SysCulture,
"SUBSTRING的参数个数要求是3个，现在是{0}个", funcParams.Length), this);
return(string.Format(ObjectUtil.SysCulture,
"SUBSTR({0}, {1}, {2})", funcParams));
case "SYSDATE":
return("SYSDATE");
case "LENGTH":
return(string.Format(ObjectUtil.SysCulture, "LENGTH({0})", funcParams));
default:
return(string.Empty);
}
}
/// <summary>
/// 查找数据行
/// </summary>
/// <param name="table">表</param>
/// <param name="sourceRow">源数据行</param>
/// <returns>数据行</returns>
public DataRow FindRow(DataTable table, DataRow sourceRow)
{
TkDebug.AssertArgumentNull(table, "table", this);
TkDebug.AssertArgumentNull(sourceRow, "srouceRow", this);
TkDebug.Assert(table.PrimaryKey != null && table.PrimaryKey.Length > 0,
string.Format(ObjectUtil.SysCulture, "表{0}没有设置主键，无法执行FindRow操作",
table.TableName), this);
object[] keyValue = Array.ConvertAll(fKeyFieldArray, field =>
{
try
{
return(sourceRow[field.NickName]);
}
catch (System.ArgumentException ex)
{
TkDebug.ThrowToolkitException(string.Format(ObjectUtil.SysCulture,
"sourceRow中没有字段{0}，请检查", field.NickName), ex, this);
return(null);
}
});
return(table.Rows.Find(keyValue));
}
public override OutputData DoAction(IInputData input)
{
string regName = input.QueryString["RegName"];
EasySearch easySearch = PlugInFactoryManager.CreateInstance <EasySearch>(
EasySearchPlugInFactory.REG_NAME, regName);
BaseDbEasySearch dbSearch = easySearch as BaseDbEasySearch;
if (dbSearch != null)
{
if (!string.IsNullOrEmpty(dbSearch.ContextName))
{
Context = DbContextUtil.CreateDbContext(dbSearch.ContextName);
}
}
IConfigCreator <ITree> creator = easySearch as IConfigCreator <ITree>;
TkDebug.AssertNotNull(creator, string.Format(ObjectUtil.SysCulture,
"类型为{0}，注册名为{1}的EasySearch需要实现创建ITree的接口",
easySearch.GetType(), regName), easySearch);
Tree = creator.CreateObject(this);
return(base.DoAction(input));
}
private static XslCompiledTransform GetTransformFromFile(string xslFile, TransformSetting setting)
{
TkDebug.ThrowIfNoAppSetting();
XslCompiledTransform result = null;
bool cache = setting.UseCache && BaseAppSetting.Current.UseCache;
if (cache)
{
XsltTransformCacheData data = CacheManager.GetItem("XsltTransformFile",
xslFile, setting).Convert <XsltTransformCacheData>();
result = data.Transform;
}
else
{
result = new XslCompiledTransform();
XsltSettings xsltSetting = setting.NeedEvidence ? XsltSettings.TrustedXslt
: XsltSettings.Default;
result.Load(new Uri(xslFile).ToString(), xsltSetting, fResolver);
}
return(result);
}
public static PropertyActivator <TContext>[] GetPropertiesToActivate(Type type, Type activateAttributeType,
Func <PropertyInfo, PropertyActivator <TContext> > createActivateInfo, bool includeNonPublic)
{
TkDebug.AssertArgumentNull(type, nameof(type), null);
TkDebug.AssertArgumentNull(activateAttributeType, nameof(activateAttributeType), null);
TkDebug.AssertArgumentNull(createActivateInfo, nameof(createActivateInfo), null);
var properties = type.GetRuntimeProperties().Where((property) =>
{
return
(property.IsDefined(activateAttributeType) &&
property.GetIndexParameters().Length == 0 &&
property.SetMethod != null &&
!property.SetMethod.IsStatic);
});
if (!includeNonPublic)
{
properties = properties.Where(property => property.SetMethod.IsPublic);
}
return(properties.Select(createActivateInfo).ToArray());
}
public void DoAction(DataSet dataSet, TableResolver resolver)
{
TkDebug.AssertArgumentNull(dataSet, "dataSet", null);
DataSet = dataSet;
Resolver = resolver;
if (resolver != null)
{
Table = dataSet.Tables[resolver.TableName];
if (Table != null && Table.Rows.Count > 0)
{
Row = Table.Rows[0];
}
}
try
{
Execute();
}
catch (Exception e)
{
throw new WebPostException("保存成功,后续操作失败,原因:" + e.Message);
}
}
public static void UpdateTableResolvers(Action <Transaction> applyData,
bool sort, IEnumerable <TableResolver> resolvers)
{
TkDebug.AssertArgumentNull(resolvers, "resolvers", null);
IEnumerable <TkDbContext> contexts = (from resolver in resolvers
select resolver.Context).Distinct();
List <TkDbContext> contextArray = contexts.ToList();
int count = contextArray.Count;
if (count == 0)
{
return;
}
if (count == 1)
{
UpdateTableResolvers(contextArray[0], applyData, sort, resolvers);
}
else
{
UpdateTableResolvers(contextArray, applyData, sort, resolvers);
}
}
public IParamBuilder CreateParamBuilder(string filterSql, string[] fields, params object[] values)
{
TkDebug.AssertEnumerableArgumentNullOrEmpty(fields, "fields", this);
TkDebug.AssertEnumerableArgumentNull(values, "values", this);
TkDebug.Assert(fields.Length == values.Length, string.Format(ObjectUtil.SysCulture,
"参数fields和values的个数不匹配，fields的个数为{0}，而values的个数为{1}",
fields.Length, values.Length), this);
List <IParamBuilder> list = new List <IParamBuilder>(fields.Length + 1);
for (int i = 0; i < fields.Length; i++)
{
IParamBuilder builder = SqlParamBuilder.CreateEqualSql(Context,
GetFieldInfo(fields[i]), values[i]);
list.Add(builder);
}
if (!string.IsNullOrEmpty(filterSql))
{
list.Add(ParamBuilder.CreateSql(filterSql));
}
return(ParamBuilder.CreateParamBuilder(list));
}
public UploadInfo CreateValue(IFieldUpload upload, DataRow row)
{
TkDebug.AssertArgumentNull(upload, "upload", this);
TkDebug.AssertArgumentNull(row, "row", this);
string fileName = row.GetString(upload.FileNameField);
if (string.IsNullOrEmpty(fileName))
{
return(null);
}
UploadInfo info = new UploadInfo
{
FileName = fileName,
ContentType = row.GetString(upload.MimeTypeField),
ServerPath = row.GetString(upload.ServerPathField),
FileSize = row.GetValue <int>(upload.SizeField),
WebPath = row.GetString(upload.ContentField)
};
return(info);
}
public override UploadInfo CreateValue(IFieldUpload upload, IFieldValueProvider provider)
{
TkDebug.AssertArgumentNull(upload, "upload", this);
TkDebug.AssertArgumentNull(provider, "provider", this);
string fileName = provider.GetValue(upload.FileNameField);
if (string.IsNullOrEmpty(fileName))
{
return(null);
}
UploadInfo info = new UploadInfo
{
FileName = fileName,
ContentType = provider.GetValue(upload.MimeTypeField),
ServerPath = provider.GetValue(upload.ServerPathField),
FileSize = provider.GetValue <int>(upload.SizeField),
WebPath = provider.GetValue(upload.ContentField)
};
return(info);
}
private static Func <object, object> MakeFastPropertyGetter(PropertyInfo propertyInfo,
MethodInfo propertyGetterWrapperMethod, MethodInfo propertyGetterByRefWrapperMethod)
{
TkDebug.AssertArgumentNull(propertyInfo, nameof(propertyInfo), null);
TkDebug.AssertArgumentNull(propertyGetterWrapperMethod, nameof(propertyGetterWrapperMethod), null);
TkDebug.AssertArgumentNull(propertyGetterByRefWrapperMethod, nameof(propertyGetterByRefWrapperMethod), null);
// Must be a generic method with a Func<,> parameter
TkDebug.Assert(propertyGetterWrapperMethod.IsGenericMethodDefinition, "", null);
TkDebug.Assert(propertyGetterWrapperMethod.GetParameters().Length == 2, "", null);
// Must be a generic method with a ByRefFunc<,> parameter
TkDebug.Assert(propertyGetterByRefWrapperMethod.IsGenericMethodDefinition, "", null);
TkDebug.Assert(propertyGetterByRefWrapperMethod.GetParameters().Length == 2, "", null);
var getMethod = propertyInfo.GetMethod;
TkDebug.AssertNotNull(getMethod, "", null);
TkDebug.Assert(!getMethod.IsStatic, "", null);
TkDebug.Assert(getMethod.GetParameters().Length == 0, "", null);
// Instance methods in the CLR can be turned into static methods where the first parameter
// is open over "target". This parameter is always passed by reference, so we have a code
// path for value types and a code path for reference types.
if (getMethod.DeclaringType.GetTypeInfo().IsValueType)
{
// Create a delegate (ref TDeclaringType) -> TValue
return(MakeFastPropertyGetter(typeof(ByRefFunc <,>), getMethod,
propertyGetterByRefWrapperMethod));
}
else
{
// Create a delegate TDeclaringType -> TValue
return(MakeFastPropertyGetter(typeof(Func <,>), getMethod,
propertyGetterWrapperMethod));
}
}
internal static void DeleteTree(TableResolver resolver, DbTreeDefinition tree, string id, IInputData inputData)
{
TkDebug.AssertArgumentNull(resolver, "resolver", null);
TkDebug.AssertArgumentNull(tree, "tree", null);
TkDebug.AssertArgumentNullOrEmpty(id, "id", null);
DataRow row = null;
if (resolver.HostTable != null)
{
row = resolver.HostTable.Select(string.Format(ObjectUtil.SysCulture, "{0} = '{1}'",
tree.IdField, id))[0];
}
else
{
row = resolver.SelectRowWithParam(tree.IdField, id);
}
resolver.SetCommands(AdapterCommand.Update | AdapterCommand.Delete);
DataTable table = resolver.HostTable;
int currentCount = table.Rows.Count;
IFieldInfo layerField = resolver.GetFieldInfo(tree.LayerField);
IParamBuilder builder = CreateLayerParamBuilder(resolver.Context, layerField,
row[tree.LayerField].ToString());
resolver.Select(builder);
for (int i = currentCount; i < table.Rows.Count; ++i)
{
DataRow delRow = table.Rows[i];
resolver.DeleteRow(delRow, UpdateKind.Delete, null, inputData);
}
SetParentLeaf(resolver, tree, row[tree.ParentIdField].ToString());
resolver.DeleteRow(row, UpdateKind.Delete, null, inputData);
}
public NormalDataRowTreeNode(ITree tree, DataRow row, DbTreeDefinition treeDef)
: base(tree, row)
{
TkDebug.AssertArgumentNull(treeDef, "treeDef", null);
fHasParent = true;
Id = row[treeDef.IdField].ToString();
Name = row[treeDef.NameField].ToString();
ParentId = row[treeDef.ParentIdField].ToString();
Layer = row[treeDef.LayerField].ToString();
if (row[treeDef.LeafField].Value <int>() == 0)
{
HasChild = true;
NodeType = TreeNodeType.Branch;
}
else
{
HasChild = null;
NodeType = TreeNodeType.Leaf;
}
if (ParentId == tree.RootParentId)
{
SetRoot();
}
//switch (treeDef.SearchType)
//{
// case RootSearchType.Id:
// if (Id == treeDef.RootId)
// SetRoot();
// break;
// case RootSearchType.ParentId:
// if (ParentId == treeDef.RootId)
// SetRoot();
// break;
//}
}
protected virtual string GetDefaultUrl(ISource source, IPageData pageData, OutputData outputData)
{
string url = string.Empty;
KeyData keyData = outputData.Data.Convert <KeyData>();
switch (DestUrl)
{
case PageStyle.Custom:
TkDebug.AssertNotNull(CustomUrl,
"配置了DestUrl为Custom，却没有配置CustomUrl", this);
url = Expression.Execute(CustomUrl, source);
url = AppUtil.ResolveUrl(url);
if (CustomUrl.UseKeyData)
{
url = UriUtil.AppendQueryString(url, keyData.ToString());
}
break;
case PageStyle.Insert:
case PageStyle.List:
url = WebUtil.GetTemplateUrl(DestUrl, pageData).AppVirutalPath();
break;
case PageStyle.Update:
case PageStyle.Delete:
case PageStyle.Detail:
url = WebUtil.GetTemplateUrl(DestUrl, pageData);
url = UriUtil.AppendQueryString(url, keyData.ToString()).AppVirutalPath();
break;
default:
TkDebug.ThrowImpossibleCode(this);
break;
}
return(url);
}
public static ITableScheme CreateSqlTableScheme(string sql, string tableName,
string keyFields, TkDbContext context)
{
TkDebug.AssertArgumentNullOrEmpty(sql, "sql", null);
TkDebug.AssertArgumentNullOrEmpty(tableName, "tableName", null);
TkDebug.AssertArgumentNullOrEmpty(keyFields, "keyFields", null);
TkDebug.AssertArgumentNull(context, "context", null);
IDbDataAdapter adapter = context.CreateDataAdapter();
DataSet dataSet = new DataSet {
Locale = ObjectUtil.SysCulture
};
using (dataSet)
{
IDbCommand command = context.CreateCommand();
adapter.SelectCommand = command;
using (adapter as IDisposable)
using (command)
{
string newSql = string.Format(ObjectUtil.SysCulture,
"SELECT * FROM ({0}) {1} WHERE 1 = 0", sql, tableName);
command.CommandText = newSql;
try
{
FillDataSet(null, adapter, dataSet, tableName);
}
catch (Exception ex)
{
TkDebug.ThrowToolkitException(string.Format(ObjectUtil.SysCulture,
"无法选取数据库表{0}，请确认该表是否存在于数据库中", tableName), ex, null);
}
}
return(new InternalTableScheme(tableName, keyFields, dataSet.Tables[tableName]));
}
}
public byte[] Export(DataSet dataSet)
{
TkDebug.AssertArgumentNull(dataSet, "dataSet", this);
MemoryStream ms = new MemoryStream();
using (ms)
{
IWorkbook workbook = new HSSFWorkbook();
ISheet sheet = workbook.CreateSheet(fMetaData.Table.TableDesc);
HeaderSetting(workbook, sheet);
Dictionary <string, ICellStyle> ContentStyles = GetContentStyles(workbook);
DataTable dt = dataSet.Tables[fMetaData.Table.TableName];
if (dt != null)
{
DataTableExport(ContentStyles, sheet, dt);
}
workbook.Write(ms);
ms.Flush();
return(ms.ToArray());
}
}
public WeRefundQueryRequest(OrderType orderType, string orderId)
: this()
{
TkDebug.AssertArgumentNullOrEmpty(orderId, "orderId", null);
switch (orderType)
{
case OrderType.TransactionId:
TransactionId = orderId;
break;
case OrderType.OutTradeNo:
OutTradeNo = orderId;
break;
case OrderType.OutRefundNo:
OutRefundNo = orderId;
break;
case OrderType.RefundId:
RefundId = orderId;
break;
}
}
public void SelectTopRows(int topCount, IParamBuilder builder, string orderBy)
{
TkDebug.AssertArgumentNull(builder, "builder", this);
TkDebug.AssertArgument(topCount > 0, "topCount", "参数必须大于0", this);
string whereSql = builder.Sql;
if (!string.IsNullOrEmpty(whereSql))
{
whereSql = "WHERE " + whereSql;
}
var listContext = Context.ContextConfig.GetListSql(ListFields, Context.EscapeName(TableName),
GetKeyFieldArray(), whereSql, orderBy, 0, topCount);
SqlSelector selector = new SqlSelector(Context, HostDataSet);
using (selector)
{
ISimpleAdapter adapter = selector;
adapter.SetSql(listContext.ListSql, builder);
Context.ContextConfig.SetListData(listContext, adapter, HostDataSet, 0,
topCount, TableName);
}
}
public static TableResolver CreateSingleTableResolver(object config, IDbDataSource source)
{
TkDebug.AssertArgumentNull(config, "config", null);
TkDebug.AssertArgumentNull(source, "source", null);
ISingleResolverConfig intf = config as ISingleResolverConfig;
if (intf != null)
{
return(intf.Resolver.CreateObject(source));
}
IMultipleResolverConfig multiple = config as IMultipleResolverConfig;
if (multiple != null)
{
return(multiple.MainResolver.CreateObject(source));
}
TkDebug.ThrowToolkitException(string.Format(ObjectUtil.SysCulture,
"{0}即没有支持ISingleResolverConfig接口，也没有支持IMultipleResolverConfig接口，无法创建TableResolver",
config.GetType()), config);
return(null);
}
public WeCardBaseInfo(string logo, CodeType codeType, string brandName, string title,
string color, string notice, string description, WeDateInfo dateInfo, int quantity)
{
TkDebug.AssertArgumentNullOrEmpty(logo, "logo", null);
TkDebug.AssertArgumentNullOrEmpty(brandName, "brandName", null);
TkDebug.AssertArgumentNullOrEmpty(title, "title", null);
TkDebug.AssertArgumentNullOrEmpty(color, "color", null);
TkDebug.AssertArgumentNullOrEmpty(notice, "notice", null);
TkDebug.AssertArgumentNullOrEmpty(description, "description", null);
TkDebug.AssertArgumentNull(dateInfo, "dateInfo", null);
LogoUrl = logo;
CodeType = codeType;
BrandName = brandName;
Title = title;
Color = color;
Notice = notice;
Description = description;
DateInfo = dateInfo;
Quantity = quantity;
// 最大领取次数，不填写默认为quantity
GetLimit = quantity;
}
private OutputData DoPost(IInputData input)
{
PreparePostObject(input);
switch (input.Style.Style)
{
case PageStyle.Insert:
DefaultInsertAction(input);
break;
case PageStyle.Update:
DefaultUpdateAction(input);
break;
default:
TkDebug.ThrowImpossibleCode(this);
break;
}
PostData(input);
Commit(input);
return(OutputData.CreateToolkitObject(MainResolver.CreateKeyData()));
}
public TableResolver CreateObject(params object[] args)
{
IDbDataSource source = ObjectUtil.ConfirmQueryObject <IDbDataSource>(this, args);
TkDebug.AssertNotNullOrEmpty(TableName, "没有配置TableName属性", this);
TableResolver resolver;
if (string.IsNullOrEmpty(KeyFields))
{
resolver = new TableResolver(TableName, source);
}
else if (string.IsNullOrEmpty(Fields))
{
resolver = new TableResolver(TableName, KeyFields, source);
}
else
{
resolver = new TableResolver(TableName, KeyFields, Fields, source);
}
resolver.AutoTrackField = AutoTrackField;
resolver.AutoUpdateKey = AutoUpdateKey;
return(resolver);
}
public string GetHtml(Tk5FieldInfoEx field, IFieldValueProvider provider, bool needId)
{
TkDebug.AssertArgumentNull(field, "field", this);
return(field.Detail(provider, true, needId));
}
public bool Remove(HtmlAttribute attribute)
{
TkDebug.AssertArgumentNull(attribute, "attribute", null);
return(fAttrs.Remove(attribute));
}
public bool Remove(string name)
{
TkDebug.AssertArgumentNullOrEmpty(name, "name", this);
return(fAttrs.Remove((HtmlAttribute)name));
}
public void Add(string name, object value)
{
TkDebug.AssertArgumentNullOrEmpty(name, "name", this);
AddAttribute(new HtmlAttribute(name, value));
}
