/// <summary> /// 转换辅助类。 mapping暂未使用 /// </summary> /// <param name="type"></param> /// <param name="dataAdapter"></param> /// <param name="mapping"></param> /// <returns></returns> private static object ConvertDataToObject(Type type, BeeDataAdapter dataAdapter, Dictionary <string, string> mapping) { ThrowExceptionUtil.ArgumentNotNull(type, "type"); ThrowExceptionUtil.ArgumentNotNull(dataAdapter, "dataAdapter"); object result = ReflectionUtil.CreateInstance(type); if (result != null) { IEntityProxy entityProxy = EntityProxyManager.Instance.GetEntityProxyFromType(type); foreach (string key in dataAdapter.Keys) { string value = dataAdapter[key] as string; if (value != null && value.Length == 0) { /// 空字符串并且目标类型不是字符型则不转换 PropertySchema schema = entityProxy[key]; if (schema != null && schema.PropertyType != typeof(string)) { continue; } } entityProxy.SetPropertyValue(result, key, dataAdapter[key]); } } return(result); }
/// <summary> /// An internal scalar field. /// </summary> public SchemaScalarField(PropertySchema propertySchema) { // internal FluidTrade.Sandbox.WorkingOrder.AskPrice askPrice; this.Attributes = MemberAttributes.Assembly; this.Type = new CodeTypeReference(propertySchema.Type); this.Name = CommonConversion.ToCamelCase(propertySchema.Name); }
public IndexSpecification <T> Add(string propertyName, IndexType indexType) { EntityProxy <T> proxy = EntityProxyManager.Instance.GetEntityProxy <T>(); PropertySchema schema = proxy.GetProperty(propertyName); if (schema == null) { return(this); } bool containFlag = false; foreach (IndexMeta item in IndexedProperties) { if (string.Compare(item.PropertyName, schema.Name, false) == 0) { containFlag = true; break; } } if (!containFlag) { IndexedProperties.Add(new IndexMeta() { PropertyName = schema.Name, IndexType = indexType, PropertyType = schema.PropertyType }); } return(this); }
private object DetermineActualValue(ServerObject obj, PropertySchema propertySchema) { object val = obj.Data.GetValue(propertySchema.Property.Name); if (val == null) { if (propertySchema.CanBeNull) { val = DBNull.Value; } else { throw new ObjectServerException(String.Format(CultureInfo.CurrentCulture, "{0}.{1} has no value", obj.ServerObjectType.FullName, propertySchema.Property.Name)); } } else { if (propertySchema.CanBeNull && val.Equals(propertySchema.NullValue)) { val = DBNull.Value; } } return(val); }
private static LoanFieldFormat?GetFormat(PropertySchema propertySchema) { if (propertySchema.Format.EnumValue.HasValue) { return(propertySchema.Format); } switch (propertySchema.Type.EnumValue) { case PropertySchemaType.Bool: return(LoanFieldFormat.YN); case PropertySchemaType.DateTime: return(LoanFieldFormat.DATETIME); case PropertySchemaType.Date: return(LoanFieldFormat.DATE); case PropertySchemaType.Int: return(LoanFieldFormat.INTEGER); case PropertySchemaType.String: case PropertySchemaType.Uuid: return(LoanFieldFormat.STRING); default: return(null); } }
/// <summary> /// An internal vector field. /// </summary> public SchemaVectorField(PropertySchema propertySchema) { // internal System.Collections.Generic.IEnumerable<Sandbox.WorkingOrder.WorkingOrder> workingOrderList; this.Attributes = MemberAttributes.Assembly; this.Type = new CodeTypeReference(string.Format("{0}[]", propertySchema.Type)); this.Name = CommonConversion.ToCamelCase(propertySchema.Name); }
/// <summary> /// Creates a property for from the XML Schema definition. /// </summary> public SchemaProperty(PropertySchema propertySchema) { // /// <summary> // /// Price // /// <summary> // public decimal Price // { // get // { // return this.price; // } // set // { // // } this.Comments.Add(new CodeCommentStatement("<summary>", true)); this.Comments.Add(new CodeCommentStatement(propertySchema.Name, true)); this.Comments.Add(new CodeCommentStatement("</summary>", true)); this.Attributes = MemberAttributes.Public | MemberAttributes.Final; this.Type = propertySchema.MaxOccurs == 1 ? new CodeTypeReference(propertySchema.Type) : new CodeTypeReference(string.Format("System.Collections.Generic.IEnumerable<{0}>", propertySchema.Type)); this.Name = propertySchema.Name; this.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), CommonConversion.ToCamelCase(propertySchema.Name)))); this.SetStatements.Add(new CodeSnippetStatement()); // } }
public void InitializeContext() { this.store.TransactionManager.DoWithinTransaction(() => { this.patternModel = this.store.ElementFactory.CreateElement <PatternModelSchema>(); this.property = patternModel.Create <PatternSchema>().Create <PropertySchema>(); }); }
public void InitializeContext() { this.store.TransactionManager.DoWithinTransaction(() => { this.patternModel = this.store.ElementFactory.CreateElement<PatternModelSchema>(); this.property = patternModel.Create<PatternSchema>().Create<PropertySchema>(); }); }
public virtual void Initialize() { this.store.TransactionManager.DoWithinTransaction(() => { this.elementOwner = this.store.ElementFactory.CreateElement<ElementSchema>(); this.element = this.store.ElementFactory.CreateElement<PropertySchema>(); this.elementOwner.Properties.Add(this.element); }); validationContext = new ValidationContext(ValidationCategories.Save, this.element); }
public PropertyRepo(PropertySchema propertySchema, TypeRepo typeRepo = null) { PropertySchema = propertySchema; TypeRepo = typeRepo; if (typeRepo?.Serializer.PublicOnly == true && PropertySchema.IsPrivate) { PropertySchema.IsLoadable = false; } }
public void Initialize() { this.store.TransactionManager.DoWithinTransaction(() => { var patternModel = this.store.ElementFactory.CreateElement <PatternModelSchema>(); var pattern = patternModel.Create <PatternSchema>(); this.property = pattern.Create <PropertySchema>(); }); validationContext = new ValidationContext(ValidationCategories.Save, this.property); }
/// <summary> /// 获取子表结构 /// </summary> /// <param name="Schema"></param> /// <param name="Field"></param> /// <returns></returns> private BizObjectSchema GetChildSchema(BizObjectSchema schema, FieldSchema field) { PropertySchema property = schema.GetProperty(field.Name); if (property != null && property.ChildSchema != null) { return(property.ChildSchema); } return(this.Engine.BizObjectManager.GetPublishedSchema(field.ChildSchemaCode)); }
public virtual void Initialize() { this.store.TransactionManager.DoWithinTransaction(() => { this.elementOwner = this.store.ElementFactory.CreateElement <ElementSchema>(); this.element = this.store.ElementFactory.CreateElement <PropertySchema>(); this.elementOwner.Properties.Add(this.element); }); validationContext = new ValidationContext(ValidationCategories.Save, this.element); }
public void InitializeContext() { this.store.TransactionManager.DoWithinTransaction(() => { var patternModel = this.store.ElementFactory.CreateElement<PatternModelSchema>(); var pattern = patternModel.Create<PatternSchema>(); this.property = pattern.Create<PropertySchema>(); }); this.descriptor = new DefaultValuePropertyDescriptor("DefaultValue", property, typeof(string), new Attribute[0]); }
public void InitializeContext() { this.store.TransactionManager.DoWithinTransaction(() => { var patternModel = this.store.ElementFactory.CreateElement<PatternModelSchema>(); this.propertySchema = (PropertySchema)patternModel.CreatePatternSchema().CreatePropertySchema(); this.propertySchema.Type = typeof(string).FullName; this.propertySchema.DefaultValue.Value = "Foo"; this.propertySchema.DefaultValue.ValueProvider = new ValueProviderBindingSettings { TypeId = "Bar" }; }); }
public void WhenPropertyAddedToElement_ThenPropertyUsageIsGeneral() { PropertySchema newProperty = null; this.store.TransactionManager.DoWithinTransaction(() => { newProperty = this.patternModel.Pattern.Create <PropertySchema>(); }); Assert.True(newProperty.PropertyUsage == Runtime.PropertyUsages.General); }
public void InitializeContext() { this.store.TransactionManager.DoWithinTransaction(() => { var patternModel = this.store.ElementFactory.CreateElement <PatternModelSchema>(); var pattern = patternModel.Create <PatternSchema>(); this.property = pattern.Create <PropertySchema>(); }); this.descriptor = new DefaultValuePropertyDescriptor("DefaultValue", property, typeof(string), new Attribute[0]); }
public void WhenSameNamedElementAddedToDifferentOwner_ThenValidateNameIsUniqueSucceeds() { this.store.TransactionManager.DoWithinTransaction(() => { ElementSchema elementOwner2 = this.store.ElementFactory.CreateElement <ElementSchema>(); PropertySchema element2 = this.store.ElementFactory.CreateElement <PropertySchema>(); element2.Name = this.element.Name; elementOwner2.Properties.Add(element2); }); this.element.ValidateNameIsUnique(validationContext); Assert.True(validationContext.CurrentViolations.Count == 0); }
public void InitializeContext() { this.store.TransactionManager.DoWithinTransaction(() => { var patternModel = this.store.ElementFactory.CreateElement <PatternModelSchema>(); this.propertySchema = (PropertySchema)patternModel.CreatePatternSchema().CreatePropertySchema(); this.propertySchema.Type = typeof(string).FullName; this.propertySchema.DefaultValue.Value = "Foo"; this.propertySchema.DefaultValue.ValueProvider = new ValueProviderBindingSettings { TypeId = "Bar" }; }); }
internal static string DetermineColumnName(IQueryBuilder query, string propertyName) { string[] properties = propertyName.Split('.'); string table = String.Empty; string column = String.Empty; TypeSchema schema = SchemaCache.Current.GetSchema(query.QueriedType); for (int i = 0; i < properties.Length; i++) { if (i == properties.Length - 1) { PropertySchema propertySchema = schema.FindPropertySchema(properties[i]); if (propertySchema != null) { column = String.Format(CultureInfo.CurrentCulture, query.Context.ColumnFormat, propertySchema.ColumnName); } else { ParentSchema parentSchema = schema.FindParentSchema(properties[i]); if (parentSchema != null) { column = String.Format(CultureInfo.CurrentCulture, query.Context.ColumnFormat, parentSchema.ColumnName); } else { throw new ObjectServerException(String.Format(CultureInfo.CurrentCulture, "Could not locate schema for {0}.{1}", schema.Type.FullName, properties[i])); } } table = String.Format(CultureInfo.CurrentCulture, query.Context.TableFormat, schema.TableName); } else { ParentSchema parentSchema = schema.FindParentSchema(properties[i]); if (parentSchema == null) { throw new ObjectServerException(String.Format(CultureInfo.CurrentCulture, "Could not locate schema for {0}.{1}", schema.Type.FullName, properties[i])); } schema = SchemaCache.Current.GetSchema(parentSchema.Property.PropertyType); query.AddParentJoin(parentSchema); } } return(String.Format(CultureInfo.CurrentCulture, query.Context.TableColumnFormat, table, column)); }
public void WhenSameNamedElementAddedToSameOwner_ThenValidateNameIsUniqueFails() { this.store.TransactionManager.DoWithinTransaction(() => { PropertySchema element2 = this.store.ElementFactory.CreateElement <PropertySchema>(); element2.Name = this.element.Name; this.elementOwner.Properties.Add(element2); }); this.element.ValidateNameIsUnique(validationContext); Assert.True(validationContext.CurrentViolations.Count == 1); Assert.True(validationContext.ValidationSubjects.IndexOf(this.element) == 0); Assert.True(validationContext.CurrentViolations[0].Code == Properties.Resources.Validate_PropertyNameIsNotUniqueCode); }
public void WhenAddingNewProperty_ThenNamePropertyIsBrowsableAndNotReadOnly() { PropertySchema property = null; this.PatternModel.Store.TransactionManager.DoWithinTransaction(() => { property = this.PatternModel.Create <PropertySchema>(); }); var descriptor = TypedDescriptor.GetProperty(property, prop => prop.Name); Assert.False(property.IsInheritedFromBase); Assert.True(descriptor.IsBrowsable); Assert.False(descriptor.IsReadOnly); }
private PropertySchema FillPropertySchema(DataRow Fields) { PropertySchema propsch = new PropertySchema(); propsch.Id = (int)Fields[PropertySchemaNames.Id]; propsch.Name = Fields[PropertySchemaNames.Name].ToString(); propsch.IsSummaryProperty = (bool)Fields[PropertySchemaNames.IsSummaryProp]; IEnumerable <AttributeSchema> attrschs = _attrschlist.Values.Where(attr => attr.PropertySchema.Id == propsch.Id); foreach (AttributeSchema a in attrschs) { propsch.AttributeSchemas.Add(a.Id, a); } return(propsch); }
private static BeeDataAdapter GetHeaderItem(PropertySchema propertySchema) { ModelPropertyAttribute modelPropertyAttribute = propertySchema.GetCustomerAttribute <ModelPropertyAttribute>(); BeeDataAdapter dataAdapter = new BeeDataAdapter(); string descriptionInfo; if (modelPropertyAttribute != null) { if (!modelPropertyAttribute.Visible) { return(null); } descriptionInfo = modelPropertyAttribute.Description; if (string.IsNullOrEmpty(descriptionInfo)) { descriptionInfo = propertySchema.Name; } dataAdapter.Add("description", descriptionInfo); dataAdapter.Add("name", propertySchema.Name); if (modelPropertyAttribute.ColumnWidth != 0) { dataAdapter.Add("width", modelPropertyAttribute.ColumnWidth.ToString()); } if (!string.IsNullOrEmpty(modelPropertyAttribute.Align)) { dataAdapter.Add("align", modelPropertyAttribute.Align); } if (modelPropertyAttribute.OrderableFlag) { dataAdapter.Add("orderField", propertySchema.Name); } } else { dataAdapter.Add("description", propertySchema.Name); dataAdapter.Add("Name", propertySchema.Name); } return(dataAdapter); }
private BeeDataAdapter GetSearchItem(PropertySchema propertySchema) { BeeDataAdapter dataAdapter = null; ModelPropertyAttribute modelPropertyAttribute = propertySchema.GetCustomerAttribute <ModelPropertyAttribute>(); if (modelPropertyAttribute != null) { if (!modelPropertyAttribute.Visible) { return(null); } if (!modelPropertyAttribute.Queryable) { return(null); } dataAdapter = new BeeDataAdapter(); string descriptionInfo = modelPropertyAttribute.Description; if (string.IsNullOrEmpty(descriptionInfo)) { descriptionInfo = propertySchema.Name; } dataAdapter.Add("name", propertySchema.Name); dataAdapter.Add("Type", propertySchema.PropertyType); dataAdapter.Add("QueryType", modelPropertyAttribute.QueryType); dataAdapter.Add("Description", descriptionInfo); if (!string.IsNullOrEmpty(modelPropertyAttribute.MappingName)) { dataAdapter.Add("MappingName", modelPropertyAttribute.MappingName); } if (propertySchema.PropertyType.IsEnum && !dataAdapter.ContainsKey("MappingName")) { dataAdapter.Add("MappingName", propertySchema.PropertyType.ToString()); } } return(dataAdapter); }
public IPropertySchema AddSchema([Required] string name, [Required] string nspace) { IPropertySchema result = null; if (GetSchema(name, nspace) == null) { if (_schemas == null) { _schemas = new List <IPropertySchema>(); } result = new PropertySchema(this, name, nspace); _schemas.Add(result); SetDirty(); RegisterEvents(result); ChildCreated?.Invoke(result); } return(result); }
public virtual void InitializeContext() { var store = new DslTestStore <PatternModelDomainModel>(); var serviceProvider = Mock.Get(store.ServiceProvider); serviceProvider.Setup(s => s.GetService(typeof(IPatternManager))).Returns( Mock.Of <IPatternManager>(p => p.InstalledToolkits == new List <IInstalledToolkitInfo>())); store.TransactionManager.DoWithinTransaction(() => { this.PatternModel = store.ElementFactory.CreateElement <PatternModelSchema>(); var pattern = this.PatternModel.Create <PatternSchema>(); pattern.PatternLink = "patternmanager://foo"; var uriService = Mock.Of <IUriReferenceService>( u => u.ResolveUri <IInstanceBase>(It.IsAny <Uri>()) == Mock.Of <IProduct>(p => p.ToolkitInfo.Identifier == "ToolkitId")); pattern.UriService = uriService; this.Property = pattern.Create <PropertySchema>(); }); }
private static IHtmlContent EditorDataProperty(IHtmlHelper helper, object record, PropertySchema propertySchema) { IProperty property = propertySchema.Property as IProperty; if (property.GetContainingForeignKeys().Any()) { // editing and creating this property should be handled by the INavigation entity property, rather than the raw key return(new StringHtmlContent(string.Empty)); } object propertyValue = record == null ? null : property.GetGetter().GetClrValue(record); if (property.IsPrimaryKey()) { // primary key shouldn't be edited return(helper.Hidden(property.Name, propertyValue)); } return(GeneratorUtils.LoadView(helper, "Edit", propertyValue, propertySchema) ?? helper.TextBox(property.Name, propertyValue)); }
///------------------------------------------------------------------------------------------------- /// <summary> /// Deserializes an element from the specified context. /// </summary> /// <param name="ctx"> /// Serialization context. /// </param> /// <returns> /// An object. /// </returns> ///------------------------------------------------------------------------------------------------- protected override object Deserialize(SerializationContext ctx) { ctx.Schema = this.PropertySchema; return(PropertySchema.Deserialize(ctx)); }
///------------------------------------------------------------------------------------------------- /// <summary> /// Serializes the specified data. /// </summary> /// <param name="data"> /// The data. /// </param> /// <returns> /// A string. /// </returns> ///------------------------------------------------------------------------------------------------- protected override object Serialize(object data) { return(PropertySchema.Serialize(data)); }
private static List <FieldOption> GetOptions(PropertySchema propertySchema) { return(propertySchema.AllowedValues?.Where(o => !string.IsNullOrEmpty(o.Text) || !string.IsNullOrEmpty(o.Value)).Select(o => o.Value == "true" || o.Value == "false" ? new FieldOption(o.Value == "true" ? "Y" : "N", o.Text) : o).Distinct().ToList()); }
public void Initialize() { this.store.TransactionManager.DoWithinTransaction(() => { var patternModel = this.store.ElementFactory.CreateElement<PatternModelSchema>(); var pattern = patternModel.Create<PatternSchema>(); this.property = pattern.Create<PropertySchema>(); }); validationContext = new ValidationContext(ValidationCategories.Save, this.property); }
public static IHtmlContent EditorProperty(IHtmlHelper helper, object record, PropertySchema property) { return((property.Property is INavigation) ? EditorNavigationProperty(helper, record, property) : EditorDataProperty(helper, record, property)); }
private static IHtmlContent EditorNavigationProperty(IHtmlHelper helper, object record, PropertySchema propertySchema) { INavigation property = propertySchema.Property as INavigation; object propertyValue = record == null ? null : property.GetGetter().GetClrValue(record); var lookupType = property.IsDependentToPrincipal() ? property.ForeignKey.PrincipalEntityType : property.ForeignKey.DeclaringEntityType; IQueryable <object> lookupData = Reflection.GetDbSetForType(new FormicDbContext(), lookupType); var primaryKeyGetter = EFUtils.GetPrimaryKeyProperty(lookupType).GetGetter(); var items = (from result in lookupData let value = primaryKeyGetter.GetClrValue(result).ToString() select new SelectListItem { Text = result.ToString(), Value = value, Selected = value.Equals(propertyValue) }) .ToList(); return(GeneratorUtils.LoadView(helper, "Edit", items, propertySchema) ?? GeneratorUtils.LoadView(helper, "EditTemplates/Navigation", propertyValue: items, propertyLabel: propertySchema.Description, propertyName: property.ForeignKey.Properties[0].Name)); }
public DefaultValuePropertyDescriptor(string propertyName, PropertySchema schema, Type propertyType, Attribute[] attrs) : base(propertyName, attrs.Add(new DefaultValueAttribute(propertyType.GetDefaultValueString())).ToArray()) { this.schema = schema; this.propertyType = TypeDescriptor.GetProvider(propertyType).GetRuntimeType(propertyType); }