public static ISearch CreateSearch(string regName, bool throwIfNoRegName)
{
if (!throwIfNoRegName && string.IsNullOrEmpty(regName))
{
return(null);
}
TkDebug.AssertArgumentNullOrEmpty(regName, "regName", null);
try
{
TkDebug.ThrowIfNoGlobalVariable();
return(PlugInFactoryManager.CreateInstance <ISearch>(REG_NAME, regName));
}
catch (Exception ex)
{
if (throwIfNoRegName)
{
throw ex;
}
else
{
return(null);
}
}
}
public RazorModuleTemplatePageMaker(string moduleTemplate, IPageData pageData)
: base(pageData)
{
TkDebug.AssertArgumentNullOrEmpty(moduleTemplate, "moduleTemplate", null);
fModuleTemplate = PlugInFactoryManager.CreateInstance <IModuleTemplate>(
ModuleTemplatePlugInFactory.REG_NAME, moduleTemplate);
if (fModuleTemplate.PageTemplates != null)
{
foreach (var item in fModuleTemplate.PageTemplates)
{
RazorPageTemplatePageMaker pageMaker = new RazorPageTemplatePageMaker(item.PageTemplate, pageData)
{
ModelCreator = item.ModelCreator
};
Add(item.Function, pageMaker);
pageMaker.SetPageData += pageMaker_SetPageData;
}
}
var pageMakers = fModuleTemplate.CreatePageMakers(pageData);
if (pageMakers != null)
{
foreach (var item in pageMakers)
{
if (item.PageMaker != null)
{
Add(item.Function, item.PageMaker);
}
}
}
SetCallInfo(pageData);
}
public object CreateObjectSource()
{
object source = PlugInFactoryManager.CreateInstance <object>(
ObjectSourcePlugInFactory.REG_NAME, RegNameObjectSource);
return(source);
}
private static ICacheCreator CreateCache(string name)
{
ICacheCreator creator = PlugInFactoryManager.CreateInstance <ICacheCreator>(
CacheCreatorPlugInFactory.REG_NAME, name);
return(creator);
}
public OutputData DoAction(IInputData input)
{
if (input.IsPost)
{
EasySearchInput esIn = input.PostObject.Convert <EasySearchInput>();
EasySearch easySearch = PlugInFactoryManager.CreateInstance <EasySearch>(
EasySearchPlugInFactory.REG_NAME, esIn.RegName);
using (easySearch as IDisposable)
{
IEnumerable <IDecoderItem> result = easySearch.Search(esIn.Text, esIn.RefFields);
//EasySearchOutput output = new EasySearchOutput(result);
IDecoderItem[] resultArr;
if (result != null)
{
resultArr = result.ToArray();
}
else
{
resultArr = new CodeItem[0];
}
return(OutputData.CreateToolkitObject(resultArr));
}
}
TkDebug.ThrowImpossibleCode(this);
return(null);
}
protected override FieldErrorInfo CheckError(IInputData inputData,
string value, int position, params object[] args)
{
DataRow row = GetPostRow(inputData, position);
string hdFieldValue = row[HdFieldName].ToString();
if (string.IsNullOrEmpty(value) && string.IsNullOrEmpty(hdFieldValue))
{
return(null);
}
EasySearch easySearch = PlugInFactoryManager.CreateInstance <EasySearch>(
EasySearchPlugInFactory.REG_NAME, fRegName);
string newValue = value;
EasySearchErrorType error = easySearch.CheckName(hdFieldValue, ref newValue, args);
if (error == EasySearchErrorType.None)
{
if (newValue != value)
{
if (string.IsNullOrEmpty(newValue))
{
row[Field.NickName] = DBNull.Value;
}
else
{
row[Field.NickName] = newValue;
}
}
return(null);
}
return(CreateErrorObject(error));
}
protected override OutputData DoGet(IInputData input)
{
using (TableResolver resolver = PlugInFactoryManager.CreateInstance <TableResolver>(
ResolverPlugInFactory.REG_NAME, "TaxDocument", this))
{
MetaDataTableResolver metaResolver = resolver as MetaDataTableResolver;
string conditionStr = string.Empty;
if (metaResolver != null)
{
Dictionary <string, string> query = new Dictionary <string, string>
{
{ "Title", input.QueryString["Title"] }
};
IParamBuilder builder = metaResolver.GetQueryCondition(new QueryConditionObject(false, query));
if (builder != null)
{
QueryCondition condition = new QueryCondition(query, builder);
conditionStr = "&Condition=" + HttpUtility.UrlEncode(condition.ToEncodeString());
}
}
string url = WebUtil.ResolveUrl("~/Library/WebListXmlPage.tkx?Source=Cxcs/FaGui");
return(OutputData.Create(url + conditionStr));
}
}
public object GetCacheItem(string cacheName, string key,
params object[] args)
{
TkDebug.AssertArgumentNullOrEmpty(cacheName, "cacheName", this);
TkDebug.AssertArgumentNullOrEmpty(key, "key", this);
ICache cache = GetCache(cacheName);
BaseCacheItemCreator creator = PlugInFactoryManager.CreateInstance <BaseCacheItemCreator>(
CacheItemCreatorPlugInFactory.REG_NAME, cacheName);
TkDebug.AssertNotNull(creator, $"{cacheName}不存在", this);
if (cache == null)
{
ICacheCreator cacheCreator = creator.CacheCreator;
if (cacheCreator == null)
{
cacheCreator = creator.SupportDistributed ? DefaultDistributedCreator : DefaultCreator;
}
cache = cacheCreator.CreateCache(cacheName);
CacheLock.WriteLockAction(() =>
{
if (!fCaches.ContainsKey(cacheName))
{
fCaches.Add(cacheName, cache);
return(true);
}
return(false);
});
}
return(cache.GetItem(creator.TransformCacheKey(key), creator, args));
}
private Expression(string expressionString)
{
TkDebug.AssertArgumentNullOrEmpty(expressionString, "expressionString", null);
fParser = ExpressionParser.ParseExpression(expressionString);
TkDebug.ThrowIfNoGlobalVariable();
PlugInFactoryManager factories = BaseGlobalVariable.Current.FactoryManager;
BasePlugInFactory paramFactory = factories.GetCodeFactory(
ParamExpressionPlugInFactory.REG_NAME);
BasePlugInFactory exprFactory = factories.GetCodeFactory(
ExpressionPlugInFactory.REG_NAME);
fExpressions = new List <BaseExpressionItem>();
foreach (string item in fParser.ParamArray)
{
string firstChar = item[0].ToString();
BaseExpressionItem expressionItem;
if (paramFactory.Contains(firstChar))
{
IParamExpression expression = paramFactory.CreateInstance <IParamExpression>(firstChar);
string parameter = item.Substring(1);
expressionItem = new ParamExpressionItem(expression, parameter);
}
else
{
IExpression expression = exprFactory.CreateInstance <IExpression>(item);
expressionItem = new ExpressionItem(expression, item);
}
fExpressions.Add(expressionItem);
}
}
public bool Reply(ReceiveMessage message, out BaseSendMessage replyMessage)
{
IMessageReplyEngine subEngine = fEngineList[(int)message.MsgType];
RuleAttribute attr = subEngine.Match(message);
if (attr != null)
{
if (attr == RuleAttribute.Empty)
{
replyMessage = null;
}
else
{
IRule reply = PlugInFactoryManager.CreateInstance <IRule>(
RulePlugInFactory.REG_NAME, attr.RegName).Convert <IRule>();
replyMessage = reply.Reply(message);
}
return(true);
}
else
{
replyMessage = null;
return(false);
}
}
public TableResolver CreateObject(params object[] args)
{
IDbDataSource source = ObjectUtil.ConfirmQueryObject <IDbDataSource>(this, args);
return(PlugInFactoryManager.CreateInstance <TableResolver>(
ResolverPlugInFactory.REG_NAME, Content, source));
}
public override OutputData DoAction(IInputData input)
{
CodeTable table = PlugInFactoryManager.CreateInstance <CodeTable>(
CodeTablePlugInFactory.REG_NAME, RegName);
table.Fill(DataSet, Context);
return(OutputData.Create(DataSet));
}
internal PlugInManagerData()
{
TkDebug.ThrowIfNoGlobalVariable();
PlugInFactoryManager manager = BaseGlobalVariable.Current.FactoryManager;
CodeFactories = CreateList(manager.CodeFactories);
XmlConfigs = CreateList(manager.XmlConfigs);
}
public IModule Create(string source)
{
TkDebug.AssertArgumentNullOrEmpty(source, "source", this);
ISource dataSource = PlugInFactoryManager.CreateInstance <ISource>(
SourcePlugInFactory.REG_NAME, source);
return(new SourceModuleXml(dataSource));
}
public static BaseCacheItemCreator Create(string creatorName)
{
TkDebug.AssertArgumentNullOrEmpty(creatorName, "creatorName", null);
BaseCacheItemCreator result = PlugInFactoryManager.CreateInstance <BaseCacheItemCreator>(
CacheItemCreatorPlugInFactory.REG_NAME, creatorName);
return(result);
}
public IModule Create(string source)
{
TkDebug.AssertArgumentNullOrEmpty(source, "source", this);
IModule module = PlugInFactoryManager.CreateInstance <IModule>(
ModulePlugInFactory.REG_NAME, source);
return(module);
}
public bool ContainsKey(string key, string cacheName)
{
BaseCacheItemCreator creator = PlugInFactoryManager.CreateInstance <BaseCacheItemCreator>(
CacheItemCreatorPlugInFactory.REG_NAME, cacheName);
TkDebug.AssertNotNull(creator, $"{cacheName}不存在", this);
ICacheDataConverter converter = GetDataConverter(creator);
return(GetCacheInstance(key, converter, out _));
}
public object Read(IInputData input, Stream stream)
{
object postObject = PlugInFactoryManager.CreateInstance <object>(
RegClassPlugInFactory.REG_NAME, fRegClass);
postObject.ReadFromStream("Json", ModelName, stream,
fReadSettings, QName.ToolkitNoNS);
return(postObject);
}
private IModelCreator InternalCreateModelCreator(string pageTemplate)
{
string regName;
if (fDefault.TryGetValue(pageTemplate, out regName))
{
return(PlugInFactoryManager.CreateInstance <IModelCreator>(
ModelCreatorPlugInFactory.REG_NAME, regName));
}
return(null);
}
// checkbox下拉菜单选项值
public static IEnumerable <IDecoderItem> GetDecoderItem(Tk5FieldInfoEx fieldInfo)
{
CodeTableContainer ctContainer = new CodeTableContainer();
string regName = fieldInfo.Decoder.RegName;
CodeTable codeTable = PlugInFactoryManager.CreateInstance <CodeTable>(
CodeTablePlugInFactory.REG_NAME, regName);
codeTable.Fill(ctContainer);
IEnumerable <IDecoderItem> data = ctContainer[regName];
return(data);
}
public object ReadObject(string name)
{
DateTime current = DateTime.Now;
DataRow row = TrySelectRowWithKeys(name);
IRetriever retriever = PlugInFactoryManager.CreateInstance <IRetriever>(
WeDataObjectPlugInFactory.REG_NAME, name);
WeixinResult result;
if (row == null)
{
result = retriever.RetrieveData();
if (!result.IsError)
{
row = NewRow();
row.BeginEdit();
row["DataKey"] = row["DataPlug"] = name;
row["Data"] = result.WriteJson();
row["CreateDate"] = current;
row["ValidDate"] = current.AddDays(3);
row.EndEdit();
SetCommands(AdapterCommand.Insert);
UpdateDatabase();
}
}
else
{
if (row["ValidDate"].Value <DateTime>() >= current)
{
result = retriever.ReadData(row["Data"].ToString());
}
else
{
result = retriever.RetrieveData();
if (!result.IsError)
{
row.BeginEdit();
row["Data"] = result.WriteJson();
row["ValidDate"] = current.AddDays(3);
row.EndEdit();
SetCommands(AdapterCommand.Update);
UpdateDatabase();
}
}
}
return(result);
}
public CodeTableColumnReader(Tk5FieldInfoEx fieldInfo, TkDbContext context, int cellIndex)
: base(fieldInfo, cellIndex)
{
CodeTableContainer ctContainer = new CodeTableContainer();
string regName = fieldInfo.Decoder.RegName;
CodeTable codeTable = PlugInFactoryManager.CreateInstance <CodeTable>(
CodeTablePlugInFactory.REG_NAME, regName);
codeTable.Fill(ctContainer, context);
IEnumerable <IDecoderItem> data = ctContainer[regName];
fCodeTable = new Dictionary <string, IDecoderItem>();
foreach (var item in data)
{
fCodeTable[item.Name] = item;
}
}
public RegNameList <ListTabSheet> CreateTabSheet(IDbDataSource dataSource,
IFieldInfoIndexer indexer)
{
if (TabSheets != null)
{
RegNameList <ListTabSheet> result = new RegNameList <ListTabSheet>();
foreach (var item in TabSheets)
{
string sql = item.Condition == null ? null :
Expression.Execute(item.Condition, dataSource);
IParamBuilder builder = string.IsNullOrEmpty(sql) ? null :
SqlParamBuilder.CreateSql(sql);
result.Add(new ListTabSheet(item.Id,
item.Caption.ToString(ObjectUtil.SysCulture), builder));
}
return(result);
}
if (CodeTabSheet != null)
{
RegNameList <ListTabSheet> result = new RegNameList <ListTabSheet>();
if (CodeTabSheet.NeedAllTab)
{
result.Add(new ListTabSheet("_All", "全部", null));
}
CodeTable table = PlugInFactoryManager.CreateInstance <CodeTable>(
CodeTablePlugInFactory.REG_NAME, CodeTabSheet.CodeRegName);
YJC.Toolkit.Decoder.CodeTableContainer data = new YJC.Toolkit.Decoder.CodeTableContainer();
table.Fill(data, dataSource.Context);
var tableData = data[CodeTabSheet.CodeRegName];
IFieldInfo info = indexer[CodeTabSheet.NickName];
TkDebug.AssertNotNull(info, "", this);
foreach (var item in tableData)
{
IParamBuilder builder = SqlParamBuilder.CreateEqualSql(dataSource.Context, info, item.Value);
var tabSheet = new ListTabSheet(item.Value, item.Name, builder);
result.Add(tabSheet);
}
return(result);
}
return(null);
}
protected override OutputData DoPost(IInputData input)
{
QueryConditionPostObject postObject = input.PostObject.Convert <QueryConditionPostObject>();
TableResolver resolver = PlugInFactoryManager.CreateInstance <TableResolver>(
ResolverPlugInFactory.REG_NAME, postObject.Resolver, this);
using (resolver)
{
MetaDataTableResolver metaResolver = resolver as MetaDataTableResolver;
if (metaResolver != null)
{
IParamBuilder builder = metaResolver.GetQueryCondition(postObject.Query);
if (builder != null)
{
QueryCondition condition = new QueryCondition(postObject.Query.Condition, builder);
return(OutputData.Create(condition.ToEncodeString()));
}
}
return(OutputData.Create(string.Empty));
}
}
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));
}
public OutputData DoAction(IInputData input)
{
string regName = input.QueryString["RegName"];
EasySearch easySearch = PlugInFactoryManager.CreateInstance <EasySearch>(
EasySearchPlugInFactory.REG_NAME, regName);
IConfigCreator <ITree> creator = easySearch as IConfigCreator <ITree>;
string url;
if (creator != null)
{
url = string.Format(ObjectUtil.SysCulture,
"~/c/source/C/EasySearchTreeDialog?RegName={0}&InitValue={1}",
regName, input.QueryString["InitValue"]);
}
else
{
url = string.Format(ObjectUtil.SysCulture,
"~/c/source/C/EasySearchDialog?RegName={0}&RefValue={1}&Addition={2}",
regName, input.QueryString["RefValue"], input.QueryString["Addition"]);
}
return(OutputData.Create(url));
}
public EasySearchColumnReader(Tk5FieldInfoEx fieldInfo, int cellIndex)
: base(fieldInfo, cellIndex)
{
fEasySearch = PlugInFactoryManager.CreateInstance <EasySearch>(
EasySearchPlugInFactory.REG_NAME, fieldInfo.Decoder.RegName);
}
public override ISource CreateSource(IPageData pageData)
{
return(PlugInFactoryManager.CreateInstance <ISource>(
SourcePlugInFactory.REG_NAME, "ShowException"));
}
private static IPageTemplate CreatePageTemplate(string regName)
{
TkDebug.AssertArgumentNullOrEmpty(regName, "regName", null);
return(PlugInFactoryManager.CreateInstance <IPageTemplate>(PageTemplatePlugInFactory.REG_NAME, regName));
}
public T CreateObject(params object[] args)
{
return(PlugInFactoryManager.CreateInstance <T>(fFactoryName, Content));
}
