/// <summary>
/// Fetches the next row and casts it to a model.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
/// <exception cref="System.Exception">
/// The provided type must be a model
/// or
/// The provided model has no attribute
/// or
/// The provided model does not match the table
/// or
/// The model field ' + field.Name + ' has no attribute
/// </exception>
public T Fetch <T>()
{
// test
if (!typeof(Model).IsAssignableFrom(typeof(T)))
{
throw new Exception("The provided type must be a model");
}
// get type data
Type t = typeof(T);
// get model attributes
ModelAttribute modelAtt = t.GetCustomAttribute <ModelAttribute>();
// check table
if (modelAtt.Name.ToLower() != Fields[0].Table.ToLower())
{
throw new Exception("The provided model does not match the table");
}
// create
object obj = null;
// fetch
MySqlRow row = Fetch();
if (row == null)
{
return(default(T));
}
// get fields
foreach (FieldInfo field in t.GetFields())
{
// get field attributes
ModelFieldAttribute fieldAtt = field.GetCustomAttribute <ModelFieldAttribute>();
// find mysql field
for (int i = 0; i < Fields.Length; i++)
{
if (Fields[i].Name == fieldAtt.Name)
{
if (fieldAtt.Primary)
{
obj = Activator.CreateInstance(typeof(T), row.Values[i]);
}
else if (obj == null)
{
throw new Exception("The model does not define a valid primary key");
}
field.SetValue(obj, row.Values[i]);
}
}
}
return((T)obj);
}
/// <summary>
/// 属性修改时忽略
/// </summary>
/// <param name="prop"></param>
/// <returns></returns>
private static bool PropModifyIgnore(Cache_ModelInfor_Property propinfor, Func <ModelFieldAttribute, bool> func)
{
if (func == null)
{
func = (a) => { return(false); };
}
ModelFieldAttribute attr = propinfor.PropertyModelAttr;
if (attr != null)
{
if (attr.IdentityKey || attr.UseDatabaseDefaultValue || func(attr))
{
return(true);
}
}
return(false);
}
public virtual void InitByType(Type type, object data, bool modelOnly = false, string htmlFieldName = "", object additionalViewData = null)
{
type = Store.GetEnumerableGenericType(type);
if (data is IEnumerable)
{
data = null;
}
ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(delegate { return(data); }, type);
if (metadata != null)
{
ResourcesRegistrator registrator = metadata.AdditionalValues.ContainsKey(ClientResourceAttribute.KEY) ? (ResourcesRegistrator)metadata.AdditionalValues[ClientResourceAttribute.KEY] : null;
if (registrator != null)
{
this.Controls.Add(registrator);
}
HtmlHelper html = Ext.Net.X.Builder.HtmlHelper;
ViewDataDictionary viewData = new ViewDataDictionary(html.ViewDataContainer.ViewData)
{
Model = data,
ModelMetadata = metadata,
TemplateInfo = new TemplateInfo
{
HtmlFieldPrefix = html.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(htmlFieldName)
}
};
if (additionalViewData != null)
{
foreach (KeyValuePair <string, object> kvp in new RouteValueDictionary(additionalViewData))
{
viewData[kvp.Key] = kvp.Value;
}
}
HtmlHelper helper = new HtmlHelper(
new ViewContext(html.ViewContext, html.ViewContext.View, viewData, html.ViewContext.TempData, html.ViewContext.Writer),
new ViewDataContainer(viewData)
);
foreach (ModelMetadata propertyMetadata in metadata.Properties)
{
ModelFieldAttribute modelAttr = propertyMetadata.AdditionalValues.ContainsKey(ModelFieldAttribute.KEY) ? (ModelFieldAttribute)propertyMetadata.AdditionalValues[ModelFieldAttribute.KEY] : null;
if (!propertyMetadata.ShowForEdit)
{
continue;
}
if (modelAttr == null && this.InitForModelOnly)
{
continue;
}
FieldAttribute fieldAttr = propertyMetadata.AdditionalValues.ContainsKey(FieldAttribute.KEY) ? (FieldAttribute)propertyMetadata.AdditionalValues[FieldAttribute.KEY] : null;
if ((modelAttr != null && modelAttr.Ignore) || (fieldAttr != null && fieldAttr.Ignore))
{
continue;
}
if (propertyMetadata.TemplateHint.IsNotEmpty())
{
this.Items.Add(new MvcItem(delegate { return(EditorExtensions.Editor(helper, propertyMetadata.PropertyName, propertyMetadata.TemplateHint)); }));
}
else
{
Type fieldType = null;
if (fieldAttr != null && fieldAttr.FieldType != null)
{
fieldType = fieldAttr.FieldType;
if (!fieldType.IsSubclassOf(typeof(Ext.Net.Field)))
{
throw new Exception("FieldType must be subclass of Ext.Net.Field");
}
}
else
{
if (propertyMetadata.IsComplexType)
{
continue;
}
if (Store.IsDate(propertyMetadata.ModelType))
{
fieldType = typeof(Ext.Net.DateField);
}
else if (Store.IsNumeric(propertyMetadata.ModelType))
{
fieldType = typeof(Ext.Net.NumberField);
}
else if (Store.IsBoolean(propertyMetadata.ModelType))
{
fieldType = typeof(Ext.Net.Checkbox);
}
else
{
fieldType = typeof(Ext.Net.TextField);
}
}
Field cmp = (Ext.Net.Field)System.Activator.CreateInstance(fieldType);
cmp.ViewContext = helper.ViewContext;
cmp.ControlFor = propertyMetadata.PropertyName;
cmp.SetControlFor(propertyMetadata);
this.Items.Add(cmp);
}
}
}
}
public static ModelField CreateModelFieldFromMeta(ModelMetadata propertyMetadata, Ext.Net.Model storeModel = null, ModelFieldAttribute modelAttr = null, ControllerContext controllerContext = null)
{
var modelField = new ModelField();
if (modelAttr == null)
{
modelAttr = propertyMetadata.AdditionalValues.ContainsKey(ModelFieldAttribute.KEY) ? (ModelFieldAttribute)propertyMetadata.AdditionalValues[ModelFieldAttribute.KEY] : null;
}
modelField.Name = propertyMetadata.PropertyName;
if (Store.IsDate(propertyMetadata.ModelType))
{
modelField.Type = ModelFieldType.Date;
}
else if (Store.IsInteger(propertyMetadata.ModelType))
{
modelField.Type = ModelFieldType.Int;
}
else if (Store.IsFloat(propertyMetadata.ModelType))
{
modelField.Type = ModelFieldType.Float;
}
else if (Store.IsBoolean(propertyMetadata.ModelType))
{
modelField.Type = ModelFieldType.Boolean;
}
else if (propertyMetadata.ModelType == typeof(string))
{
modelField.Type = ModelFieldType.String;
}
if (propertyMetadata.IsComplexType && modelAttr != null)
{
modelField.IsComplex = true;
}
if (modelAttr != null && storeModel != null)
{
modelAttr.CopyTo(modelField, storeModel);
}
if (storeModel != null)
{
storeModel.Fields.Add(modelField);
}
ValidationCollection validations = new ValidationCollection();
if (propertyMetadata.AdditionalValues.ContainsKey(AbstractValidationAttribute.KEY))
{
validations = (ValidationCollection)propertyMetadata.AdditionalValues[AbstractValidationAttribute.KEY];
}
foreach (ModelValidator v in propertyMetadata.GetValidators(controllerContext))
{
var rule = v.GetClientValidationRules().FirstOrDefault();
if (rule != null)
{
switch (rule.ValidationType)
{
case "required":
validations.Add(new PresenceValidation {
Message = rule.ErrorMessage
});
break;
case "regex":
if (rule.ValidationParameters.ContainsKey("pattern"))
{
validations.Add(new FormatValidation {
Matcher = rule.ValidationParameters["pattern"].ToString(), Message = rule.ErrorMessage
});
}
break;
case "length":
int num;
LengthValidation length = new LengthValidation();
length.Message = rule.ErrorMessage;
if (rule.ValidationParameters.ContainsKey("max"))
{
if (int.TryParse(rule.ValidationParameters["max"].ToString(), out num))
{
length.Max = num;
}
else
{
continue;
}
}
if (rule.ValidationParameters.ContainsKey("min"))
{
if (int.TryParse(rule.ValidationParameters["min"].ToString(), out num))
{
length.Min = num;
}
else
{
continue;
}
}
validations.Add(length);
break;
}
}
}
if (controllerContext != null)
{
foreach (ModelValidator v in propertyMetadata.GetValidators(controllerContext))
{
var rule = v.GetClientValidationRules().FirstOrDefault();
if (rule != null)
{
switch (rule.ValidationType)
{
case "required":
validations.Add(new PresenceValidation {
Field = modelField.Name, Message = rule.ErrorMessage
});
break;
case "regex":
if (rule.ValidationParameters.ContainsKey("pattern"))
{
validations.Add(new FormatValidation {
Field = modelField.Name, Matcher = rule.ValidationParameters["pattern"].ToString(), Message = rule.ErrorMessage
});
}
break;
case "length":
var lengthVal = new LengthValidation();
if (rule.ValidationParameters.ContainsKey("max"))
{
lengthVal.Max = (int)Convert.ChangeType(rule.ValidationParameters["max"], typeof(int));
}
if (rule.ValidationParameters.ContainsKey("min"))
{
lengthVal.Min = (int)Convert.ChangeType(rule.ValidationParameters["min"], typeof(int));
}
lengthVal.Message = rule.ErrorMessage;
validations.Add(lengthVal);
break;
}
}
}
}
if (validations.Count > 0)
{
if (storeModel != null)
{
storeModel.Validations.AddRange(validations);
}
else
{
modelField.Validations = validations;
}
}
return(modelField);
}
