public static ValuePathSource GetValuePathSource(IValueSetter setter)
{
var valueKind = setter.ValueKind & ValueKind.Unspecified;
switch (valueKind)
{
case ValueKind.TemplateExpandoPath:
return(ValuePathSource.TemplateExpando);
case ValueKind.SelfExpandoPath:
return(ValuePathSource.Expando);
case ValueKind.SkinPath:
return(ValuePathSource.Skin);
case ValueKind.TemplateSkinPath:
return(ValuePathSource.TemplateSkin);
case ValueKind.ThemeResourcePath:
return(ValuePathSource.ThemeResource);
default:
return(ValuePathSource.ThemeResource);
}
}
protected override object DoUpdate(UpdateContext context, UpdateConfig config, IEnumerable <object> datas, object complexData)
{
var sql = config.Sql;
var cols = GetCols(config);
var key = GetKeyName(config, cols);
IValueSetter valueSetter = ValueSetterCreater.Create(datas.First());
//1.自定义SQl一条条插入
if (!string.IsNullOrEmpty(sql) || !string.IsNullOrEmpty(config.Filter))
{
if (string.IsNullOrEmpty(sql))
{
config.Sql = DBHelper.BuildUpdateSql(cols, config, key, SqlKeyWorld.ComplexDataObjectStart);
}
config.ReturnId = true;
var keys = valueSetter.GetFields(datas.First());
foreach (var data in datas)
{
context.ContentParams.ReplaceOrInsert(SqlKeyWorld.ComplexData, data);
UpdateTrigger.TriggeValuesChecked(context, data, config, cols, ActionType.Update, valueSetter, keys);
SqlExcuter.ExcuteTrann(context);
ExcuteSubUpdate(context, config, data);
}
return(datas.Count());
}
return(UpdateOnOneTime(context, config, cols, datas, valueSetter, key));
}
public static void SetValuePathSource(IValueSetter setter, ValuePathSource value)
{
UnresolveValueProvider(setter);
if (value == ValuePathSource.ThemeResource)
{
setter.ValueKind = ValueKind.ThemeResourcePath;
}
else if (value == ValuePathSource.Expando)
{
setter.ValueKind = ValueKind.SelfExpandoPath;
}
else if (value == ValuePathSource.TemplateExpando)
{
setter.ValueKind = ValueKind.TemplateExpandoPath;
}
else if (value == ValuePathSource.Skin)
{
setter.ValueKind = ValueKind.SkinPath;
}
else if (value == ValuePathSource.TemplateSkin)
{
setter.ValueKind = ValueKind.TemplateSkinPath;
}
else
{
setter.ValueKind = ValueKind.ThemeResourcePath;
}
}
protected override object DoQuery(Context context)
{
var handlerConfig = context.HandlerConfig;
var queryConfigs = context.Configs;
var queryParam = context.Params;
IValueSetter valueSetter = handlerConfig.Create();
object outData = valueSetter.CreateInstance();
context.Data = outData;
IDictionary <string, object> contentData = new ExpandoObject();
IValueSetter contentSetter = ValueSetterCreater.Create(contentData);
foreach (var queryConfig in queryConfigs)
{
IQueryHandler queryHandler = QueryHandlerFactory.GetQueryHandler(queryConfig.QueryType);
IConditionQueryHandler conditionQueryHandler = queryHandler as IConditionQueryHandler;
var subContext = new Context(context)
{
Data = contentData,
Configs = new QueryConfig[] { queryConfig }
};
if (conditionQueryHandler != null)
{
var isContinue = conditionQueryHandler.Continue(subContext);
if (isContinue == false)
{
if (conditionQueryHandler.WhetheStop(subContext))
{
return(outData);
}
continue;
}
}
context.Childs.Add(subContext);
var data = queryHandler.Query(subContext);
contentSetter.SetFieldByConfig(contentData, data, queryConfig);
if (conditionQueryHandler != null)
{
var result = conditionQueryHandler.WhetheResultStop(subContext, data);
if (result == true)
{
return(outData);
}
}
if (queryConfig.IngoreFill == true)
{
continue;
}
valueSetter.SetField(queryConfig.Filed, data);
}
return(outData);
}
public static void SetValue(IValueSetter setter, object value)
{
UnresolveValueProvider(setter);
setter.ValueStore = value;
setter.ValueKind = ValueKind.Explicit;
}
public DecoratedSetter(IValueSetter setter, GetInstanceDelegate <TInnerSubject> getTargetHandler, SetInstanceDelegate <TInnerSubject> newInstanceSetter, Func <TInnerSubject, TInnerSubject> cloner)
{
this.setter = setter;
this.cloner = cloner;
this.getTargetHandler = getTargetHandler;
this.newInstanceSetter = newInstanceSetter;
}
protected override object DoQuery(Context context)
{
var queryConfig = context.Config;
var handlerConfig = context.HandlerConfig;
if (string.IsNullOrEmpty(queryConfig.Connection))
{
queryConfig.Connection = handlerConfig.Connection;
}
IValueSetter valueSetter = queryConfig.Create();
var datas = SqlExcuter.ExcuteQuery(context, valueSetter);
context.Data = datas;
ExcuteSubQueries(context, queryConfig, valueSetter, datas);
if (!queryConfig.OnlyOne)
{
return(datas);
}
if (datas.Any())
{
return(datas.First());
}
return(new object());
}
public void UpdateSelection(OptionValueChangedEventArgs e)
{
if (e == null)
{
return;
}
if (inUpdate)
{
return;
}
// if (!optionItem.IsAlive) {
// return;
// }
// IOptionItem oi = (IOptionItem)optionItem.Target;
object value = e.NewValue;
if (value == OptionItem.VALUE_UNDEFINED)
{
//no change
return;
}
try {
inUpdate = true;
//lock selection for the duration of our update
selection.BeginValueUpdate();
ICollection <IPropertyItemDescriptor <T> > descriptors;
descriptors = selection.Selection;
bool hasChanged = false;
foreach (IPropertyItemDescriptor <T> descriptor in descriptors)
{
//get the propertyItem from the current lookup
IPropertyMap map = descriptor.Properties;
if (map == null)
{
continue;
}
//get value from current selection item
IPropertyItem item = map.GetEntry(virtualPropertyName);
IValueSetter setter = item != null ? item.Setter : null;
if (setter == null || !setter.CanSet())
{
continue;
}
setter.SetValue(value);
hasChanged = true;
}
if (hasChanged)
{
selection.UpdateSelectedItems();
}
} finally {
selection.EndValueUpdate();
inUpdate = false;
}
}
protected override void ApplyRules(UpdateContext updateContext, UpdateConfig config, IDictionary <string, string> cols)
{
var uParams = updateContext.Params;
IValueSetter valueSetter = ValueSetterCreater.Create(uParams);
UpdateTrigger.TriggeValuesChecked(updateContext, uParams, config, cols, ActionType.Update, valueSetter, uParams.Keys);
}
/// <inheritdoc/>
public IPropertyItem AddEntry(string virtualPropertyName, IValueGetter getter,
IValueSetter setter, IEqualityComparer comparer)
{
DefaultPropertyItem item = new DefaultPropertyItem(getter, setter, comparer);
internalMap[virtualPropertyName] = item;
return(item);
}
public static IValueSetter GetPropertySetter(PropertyInfo propertyInfo)
{
if (!m_SetterDict.ContainsKey(propertyInfo)){
IValueSetter setter = CreatePropertySetter(propertyInfo);
m_SetterDict.Add(propertyInfo, setter);
return setter;
}
return m_SetterDict[propertyInfo];
}
public static ISetterValueProvider ResolveValueProvider(IValueSetter setter)
{
var valueProvider = setter.ValueStore as ISetterValueProvider;
if (valueProvider != null)
{
return(valueProvider);
}
var valueKind = setter.ValueKind;
if (IsResolvedValueProvider(valueKind))
{
return(null);
}
try
{
if (valueKind == ValueKind.ThemeResourcePath)
{
var actualValuePath = GetValuePath(setter);
if (string.IsNullOrEmpty(actualValuePath) == false)
{
valueProvider = ThemeManager.GetThemeReference(actualValuePath);
setter.ValueStore = valueProvider;
return(valueProvider);
}
}
if (valueKind == ValueKind.Explicit)
{
var actualValue = GetValue(setter);
var value = actualValue;
if (value is ThemeResourceExtension themeResourceExtension)
{
valueProvider = themeResourceExtension;
}
}
}
finally
{
if (valueProvider != null)
{
setter.ValueStore = valueProvider;
}
setter.ValueKind |= ValueKind.Resolved;
}
return(valueProvider);
}
internal static IEnumerable <object> ExcuteQuery(IContext context, IValueSetter valueSetter, string querySql = "")
{
return(Excute <IEnumerable <object> >(context, (cmd) =>
{
using (var dataReader = cmd.ExecuteReader())
{
var columns = GetColumns(dataReader);
return valueSetter.SetterDatas(context.GetConfig(), dataReader, columns);
}
}, querySql));
}
private static object GetOriginalValue(IValueSetter setter)
{
var valueStore = setter.ValueStore;
if (IsResolvedValueProvider(setter.ValueKind) == false)
{
return(valueStore);
}
return(valueStore is ISetterValueProvider valueProvider ? valueProvider.OriginalValue : valueStore);
}
public static string GetValuePath(IValueSetter setter)
{
var valueKind = setter.ValueKind & ValueKind.Unspecified;
if (valueKind != ValueKind.Explicit)
{
return((string)GetOriginalValue(setter));
}
return(null);
}
/// <summary>
/// Decorates the setters to seemlessly perform the cloning on a set operation.
/// </summary>
internal IValueSetter decorate(IValueSetter setter)
{
if (parent.useClone && this.context.Policy == AssignmentPolicy.CreateNewInstance)
{
return(new CloneValueSetter(this, setter));
}
else
{
return(setter);
}
}
private void AddPanel(string name, float initValue, IValueSetter valueSetter, Transform content)
{
GameObject gameObject = GameObject.Instantiate(panel, content);
var text = gameObject.GetComponentInChildren <TextMeshProUGUI>();
text.text = name + " - " + initValue;
valueSetter.SetInitValue(initValue);
GameObject value = valueSetter.MakeGameObject();
valueSetter.AddAction((float val) => text.text = name + " - " + val);
value.transform.SetParent(gameObject.transform);
}
public virtual object CreateInstance(IDataReader reader)
{
if (this._checkNullOrdinal != null)
{
if (reader.IsDBNull(this._checkNullOrdinal.Value))
{
return(null);
}
}
this._readerOrdinalEnumerator.Reset();
this._objectActivatorEnumerator.Reset();
object obj = null;
try
{
obj = this._instanceCreator(reader, this._readerOrdinalEnumerator, this._objectActivatorEnumerator);
}
catch (Exception ex)
{
if (this._readerOrdinalEnumerator.CurrentOrdinal >= 0)
{
throw new DataException(AppendErrorMsg(reader, this._readerOrdinalEnumerator.CurrentOrdinal), ex);
}
throw;
}
IValueSetter memberSetter = null;
try
{
int count = this._memberSetters.Count;
for (int i = 0; i < count; i++)
{
memberSetter = this._memberSetters[i];
memberSetter.SetValue(obj, reader);
}
}
catch (Exception ex)
{
MappingMemberBinder binder = memberSetter as MappingMemberBinder;
if (binder != null)
{
throw new DataException(AppendErrorMsg(reader, binder.Ordinal), ex);
}
throw;
}
return(obj);
}
} // End of ImplBoundValueAlign (...)
private Boolean _BoundValueSetterAlign()
{
IValueSetter setter = ValueBinder.BoundObjectValue as IValueSetter;
if (setter == null)
{
return(false);
}
setter.SetValue(Value);
return(true);
} // End of ImplBoundValueAlign (...)
public static string BuildColVal(KeyValuePair <string, string> col, IValueSetter valueSetter, object data, IEnumerable <Column> columns)
{
var v = col.Value;
if (v.StartsWith(SqlKeyWorld.ParamStart))
{
return(v);
}
var val = valueSetter.GetValue(data, v);
return(DBHelper.GetDBValue(val, columns));
}
public static void SetValuePath(IValueSetter setter, string value)
{
UnresolveValueProvider(setter);
var valueKind = setter.ValueKind & ValueKind.Unspecified;
if (valueKind != ValueKind.SelfExpandoPath &&
valueKind != ValueKind.TemplateExpandoPath &&
valueKind != ValueKind.ThemeResourcePath &&
valueKind != ValueKind.SkinPath &&
valueKind != ValueKind.TemplateSkinPath)
{
setter.ValueKind = ValueKind.ValuePath;
}
setter.ValueStore = value;
}
public static void UnresolveValueProvider(IValueSetter setter)
{
var valueKind = setter.ValueKind;
if (IsResolvedValueProvider(valueKind) == false)
{
return;
}
setter.ValueKind = valueKind & ValueKind.Unspecified;
var valueStore = setter.ValueStore;
if (valueStore is ISetterValueProvider valueProvider)
{
setter.ValueStore = valueProvider.OriginalValue;
}
}
public static bool TryParse(string value, DependencyProperty property, out IValueSetter setter)
{
bool isLiteral = true; // TODO: binding
bool isBinding = false; // TODO: binding
if (isLiteral && ValueConverter.TryConvert(value, property.PropertyType, out var result))
{
setter = new LiteralSetter(property, result);
return(true);
}
else if (isBinding)
{
// TODO: binding
}
setter = null;
return(false);
}
private void SetSubQueryValue(ReleatedQuery config, IValueSetter valueSetter, IEnumerable <object> parents, IEnumerable <object> datas)
{
var compareFields = config.CompareFields ?? new string[] { };
Dictionary <string, string> mf = compareFields.Select(cf => cf.Split(SqlKeyWorld.Split)).ToDictionary(c => c[0], c => c[1]);
var matchOneTime = config.MatchOneTime;
foreach (var parent in parents)
{
IEnumerable <object> matchDatas = ValueGetter.GetFilterValues(mf, parent, datas);
var handler = ReleatedFillHandlerFactory.Create(config);
var data = handler.Fill(config, parent, matchDatas, valueSetter);
if (matchOneTime == false)
{
continue;
}
datas = datas.Except(matchDatas).ToArray();
}
}
///<inheritdoc/>
public virtual OptionItemValidities CheckValidity(ISelectionProvider <T> selection)
{
if (selection.Selection.Count == 0)
{
return(OptionItemValidities.Invalid);
}
OptionItemValidities retval = OptionItemValidities.ReadWrite;
foreach (IPropertyItemDescriptor <T> descriptor in selection.Selection)
{
IPropertyMap map = descriptor.Properties;
if (map == null)
{
return(OptionItemValidities.Invalid);
}
IPropertyItem item = map.GetEntry(virtualPropertyName);
if (item != null)
{
IValueGetter getter = item.Getter;
IValueSetter setter = item.Setter;
if (getter != null && getter.CanGet())
{
if (setter == null || !setter.CanSet())
{
//readonly item...
retval = OptionItemValidities.ReadOnly;
}
}
else
{
//we can't even get the values :-(
return(OptionItemValidities.Invalid);
}
}
else
{
return(OptionItemValidities.Invalid);
}
}
return(retval);
}
protected override void ApplyRules(UpdateContext updateContext, UpdateConfig config, IDictionary <string, string> cols)
{
var cParams = updateContext.Params;
IValueSetter valueSetter = ValueSetterCreater.Create(cParams);
var keys = cParams.Keys;
UpdateTrigger.TriggeDefaultValues(updateContext, cParams, config, cols, valueSetter, keys);
UpdateTrigger.TriggeValuesChecked(updateContext, cParams, config, cols, ActionType.Insert, valueSetter, keys);
config.ReturnId = true;
var key = GetKeyName(config, cols);
object id;
if (updateContext.Params.TryGetValue(key, out id) == false)
{
return;
}
updateContext.ContentParams.Add(SqlKeyWorld.ReturnKey, id);
}
protected override object DoUpdate(UpdateContext context, UpdateConfig config, IEnumerable <object> datas, object complexData)
{
var sql = config.Sql;
var ingoreKey = config.Config[IngoreKey].ToSingleData <bool>();
var cols = GetCols(config);
var key = GetKeyName(config, cols);
IValueSetter valueSetter = ValueSetterCreater.Create(datas.First());
//1.自定义SQl一条条插入
//2.未包含Key又没有忽略产生Key说明是要数据库自动生成
if (!string.IsNullOrEmpty(sql) || (!cols.ContainsKey(key) && !ingoreKey))
{
if (string.IsNullOrEmpty(sql))
{
config.Sql = DBHelper.BuildInsertSql(cols, config.Table, SqlKeyWorld.ComplexDataObjectStart);
}
config.ReturnId = true;
var keys = valueSetter.GetFields(datas.First());
foreach (var data in datas)
{
context.ContentParams.ReplaceOrInsert(SqlKeyWorld.ComplexData, data);
UpdateTrigger.TriggeDefaultValues(context, data, config, cols, valueSetter, keys);
UpdateTrigger.TriggeValuesChecked(context, data, config, cols, ActionType.Insert, valueSetter, keys);
var result = SqlExcuter.ExcuteTrann(context);
long id = 0;
if (result is long || result is int)
{
id = long.Parse(result.ToString());
valueSetter.SetField(data, id, key);
}
ExcuteSubUpdate(context, config, data);
}
return(datas.Count());
}
return(InsertOnOneTime(context, config, cols, datas, valueSetter));
}
protected override object DoUpdate(UpdateContext context)
{
context.Submit();
var queryConfig = context.Config;
var handlerConfig = context.HandlerConfig;
if (string.IsNullOrEmpty(queryConfig.Connection))
{
queryConfig.Connection = handlerConfig.Connection;
}
IValueSetter valueSetter = queryConfig.Create();
var querySql = queryConfig.Config["query_sql"].ToSingleData <string>(string.Empty);
var datas = SqlExcuter.ExcuteQuery(context, valueSetter, querySql);
foreach (var data in datas)
{
context.ContentParams.ReplaceOrInsert(SqlKeyWorld.ComplexData, data);
SqlExcuter.ExcuteTrann(context);
}
return(true);
}
public IPropertyItem AddEntry(string virtualPropertyName, IValueGetter getter, IValueSetter setter)
{
return(childContext.AddEntry(virtualPropertyName, getter, wrapper.decorate(setter)));
}
public CloneValueSetter(WrappingBuildContext <T1, T2> parent, IValueSetter setter)
{
this.parent = parent;
this.setter = setter;
}
