public void BindData(MetaField field) { if (field.Attributes.ContainsKey(McDataTypeAttribute.BooleanLabel)) { chkValue.Text = CommonHelper.GetResFileString(field.Attributes[McDataTypeAttribute.BooleanLabel].ToString()); } }
/// <summary> /// Adds the new meta field. /// </summary> /// <param name="name">The name.</param> /// <param name="friendlyName">Name of the friendly.</param> /// <param name="typeName">Name of the type.</param> /// <param name="isNullable">if set to <c>true</c> [is nullable].</param> /// <param name="defaultValue">The default value.</param> /// <param name="attributes">The attributes.</param> /// <returns></returns> public MetaField AddNewMetaField(string name, string friendlyName, string typeName, bool isNullable, string defaultValue, AttributeCollection attributes) { if (name == null) { throw new ArgumentNullException("name"); } // Check Meta Field Name. Should be unique CheckMetaFieldName(name); MetaField mf = CreateNewMetaField(name, friendlyName, typeName, isNullable, defaultValue, attributes); this.NewMetaFields.Add(mf); return(mf); }
/// <summary> /// Creates the new list default mapping. /// </summary> protected virtual void CreateNewListDefaultMapping() { MappingElement mapping = new MappingElement(this.SourceTableName, this.DestinationMetaClassName); this.MappingDocument.Add(mapping); if (this.ExternalData == null || this.ExternalData.Tables.Count == 0) { return; } foreach (DataColumn column in this.GetSourceColumns()) { // TODO: Exclude PrimaryKey if (column.ColumnName == "Created" || column.ColumnName == "CreatorId" || column.ColumnName == "Modified" || column.ColumnName == "ModifierId") { continue; } MetaField field = CreateNewMetaField(column); this.NewMetaFields.Add(field); AssignCopyValueRule(column.ColumnName, field.Name); } }
public void Initialize(MetaField field) { if (!field.MemberType.IsAssignableFrom(typeof(Tuple <double, double>))) { throw new ArgumentException("Member type should be assignable from System.Tuple<double, double>."); } }
public DataControlField GetColumn(Page pageInstance, MetaField field, bool isPrimaryKey) { if (pageInstance == null) throw new ArgumentNullException("pageInstance"); if (field == null) throw new ArgumentNullException("field"); if (ControlPathResolver.Current == null) throw new ArgumentNullException("ControlPathResolver"); TemplateField retVal = new TemplateField(); if (!isPrimaryKey) { ResolvedPath resPath = ControlPathResolver.Current.Resolve(CHelper.GetMetaTypeName(field), "Grid", field.Owner.Name, field.Name, viewName); //retVal.ItemTemplate = PageInstance.LoadTemplate(MetaFieldControlPathResolver.Resolve(CHelper.GetMetaTypeName(Field)/*Field.TypeName*/, "Grid", Field.Owner.Name, Field.Name, viewName, string.Empty)); if(resPath!= null) retVal.ItemTemplate = pageInstance.LoadTemplate(resPath.Path); } else retVal.ItemTemplate = pageInstance.LoadTemplate("~/Apps/MetaUI/Primitives/Text.Grid.@[email protected]"); return retVal; }
private void ShowField(MetaField field) { field.Opacity = 1.0f; // If the field is a reflexive, recursively set the opacity of its children var reflexive = field as ReflexiveData; if (reflexive != null) { // Show wrappers _flattener.EnumWrappers(reflexive, ShowField); // Show template fields foreach (MetaField child in reflexive.Template) { ShowField(child); } // Show modified fields foreach (ReflexivePage page in reflexive.Pages) { foreach (MetaField child in page.Fields) { if (child != null) { ShowField(child); } } } } }
private MethodDeclarationSyntax CreateParamsElementArrayMethod(MetaField field, IdentifierNameSyntax methodName, SimpleNameSyntax collectionMutationMethodName, bool passThroughChildSync = false) { var paramsArrayMethod = CreateMethodStarter(methodName.Identifier, field) .WithParameterList(CreateParamsElementArrayParameters(field)); var lambdaParameter = SyntaxFactory.Parameter(SyntaxFactory.Identifier("v")); var argument = passThroughChildSync ? (ExpressionSyntax)Syntax.EnumerableExtension( SyntaxFactory.IdentifierName(nameof(Enumerable.Select)), ValuesParameterName, SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Argument(Syntax.ThisDot(SyncImmediateChildToCurrentVersionMethodName))))) : ValuesParameterName; paramsArrayMethod = this.AddMethodBody( paramsArrayMethod, field, receiver => SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, receiver, collectionMutationMethodName), SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Argument(argument))))); return(paramsArrayMethod); }
public void BindData(MetaField mf) { FillItems(false); object value = mf.Attributes[RoleTypeAttribute.PermittedPrincipalTypes]; if (value != null) { List<int> lst = new List<int>((int[])value); foreach (DataGridItem dgi in MainGrid.Items) { foreach (Control control in dgi.Cells[1].Controls) { if (control is CheckBox) { CheckBox checkBox = (CheckBox)control; int itemId = int.Parse(dgi.Cells[0].Text); if (lst.Contains(itemId)) checkBox.Checked = true; } } } } }
internal static MethodDeclarationSyntax CreateIEnumerableFromParamsArrayMethod(MetaField field, MethodDeclarationSyntax paramsArrayMethod) { return paramsArrayMethod .WithParameterList(SyntaxFactory.ParameterList(SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Parameter(ValuesParameterName.Identifier) .WithType(Syntax.IEnumerableOf(GetFullyQualifiedSymbolName(field.ElementType)))))); }
/// <summary> /// Loads the request variables. /// </summary> private void LoadRequestVariables() { if (Request.QueryString["class"] != null) { ClassName = Request.QueryString["class"]; mc = MetaDataWrapper.GetMetaClassByName(ClassName); } if (mc != null && Request.QueryString["field"] != null) { FieldName = Request.QueryString["field"]; mf = mc.Fields[FieldName]; } if (Request.QueryString["refclass"] != null) { RefClassName = Request.QueryString["refclass"]; mcRef = MetaDataWrapper.GetMetaClassByName(RefClassName); } if (mcRef != null && Request.QueryString["reffield"] != null) { RefFieldName = Request.QueryString["reffield"]; mfRef = mcRef.Fields[RefFieldName]; } if (Request.QueryString["mode"] != null) { Mode = Request.QueryString["mode"].ToUpperInvariant(); } }
public void InitControl(int FieldId) { fieldId = FieldId; MetaField field = MetaField.Load(fieldId); btnEditItems.Visible = false; if (Security.IsManager() && field.DataType == MetaDataType.DictionaryMultivalue) { btnEditItems.Visible = true; btnEditItems.Attributes.Add("onclick", String.Format("EditItems({0})", fieldId)); if (!Page.ClientScript.IsClientScriptBlockRegistered("EditItems")) { String scriptString = "<script language=JavaScript>\r\n"; scriptString += "function EditItems(FieldId)\r\n"; scriptString += "{\r\n"; scriptString += " var w = 640;\r\n"; scriptString += " var h = 350;\r\n"; scriptString += " var l = (screen.width - w) / 2;\r\n"; scriptString += " var t = (screen.height - h) / 2;\r\n"; scriptString += " var winprops = 'resizable=0, height='+h+',width='+w+',top='+t+',left='+l;\r\n"; scriptString += String.Format(" window.open('{0}?Id=' + FieldId, 'EditItems', winprops);\r\n", ResolveUrl("~/Common/MetaDictionary.aspx")); scriptString += "}\r\n"; scriptString += "</script>\r\n"; Page.ClientScript.RegisterClientScriptBlock(this.GetType(), "EditItems", scriptString); } } }
public async Task <ActionResult> CustomFieldUpdate(int?id) { MetaField field; if (id.HasValue) { var fieldQuery = await _customFieldService.Query(x => x.ID == id).Include(x => x.MetaCategories).SelectAsync(); field = fieldQuery.FirstOrDefault(); } else { field = new MetaField() { Required = false, Searchable = false } }; var categories = await _categoryService.Query().SelectAsync(); var model = new MetaFieldModel() { MetaField = field, Categories = categories.ToList() }; return(View(model)); }
/// <summary> /// Resolves the meta control. /// </summary> /// <param name="metaClass">The meta class.</param> /// <param name="metaField">The meta field.</param> /// <returns></returns> private string ResolveMetaControl(MetaClass metaClass, MetaField metaField) { string basePath = "~/Apps/Core/MetaData/Controls/"; string controlName = GetControlNameForMetaType(metaField.DataType); string fullPath = String.Format("{0}{1}.{2}.{3}.ascx", basePath, metaClass.Name, metaField.Name, controlName); if (File.Exists(Server.MapPath(fullPath))) { return(fullPath); } fullPath = String.Format("{0}{1}.{2}.ascx", basePath, metaField.Name, controlName); if (File.Exists(Server.MapPath(fullPath))) { return(fullPath); } fullPath = String.Format("{0}{1}.{2}.ascx", basePath, metaClass.Name, controlName); if (File.Exists(Server.MapPath(fullPath))) { return(fullPath); } return(String.Format("{0}{1}.ascx", basePath, controlName)); }
private MetaField CreateMetaField(MetaDataContext mdContext, string metaDataNamespace, string name, MetaDataType type, int length, bool allowNulls, bool cultureSpecific) { var f = MetaField.Load(mdContext, name) ?? MetaField.Create(mdContext, metaDataNamespace, name, name, string.Empty, type, length, allowNulls, cultureSpecific, false, false); return(f); }
/// <summary> /// Sets MetaFile and Image values /// </summary> /// <param name="context">The context.</param> /// <param name="obj">The obj.</param> /// <param name="fieldName">Name of the field.</param> /// <param name="name">The name.</param> /// <param name="contentType">Type of the content.</param> /// <param name="fileContents">The file contents.</param> /// <returns></returns> public static bool SetMetaFile(MetaDataContext context, MetaObject obj, string fieldName, string name, string contentType, byte[] fileContents) { MetaField mf = MetaField.Load(context, fieldName); if (mf == null || (mf.DataType != MetaDataType.File && mf.DataType != MetaDataType.Image && mf.DataType != MetaDataType.ImageFile)) { return(false); } // assign default meta field value if value is not specified and meta field doesn't allow null values if (fileContents == null || fileContents.Length == 0) { if (!mf.AllowNulls) { obj[mf.Name] = MetaObject.GetDefaultValue(mf.DataType); } else { obj[mf.Name] = null; } return(true); } // assign the file value MetaFile metaFile = new MetaFile(name, contentType, fileContents); obj[mf.Name] = metaFile; return(true); }
/// <summary> /// Gets the meta field value. /// </summary> /// <param name="mf">The mf.</param> /// <param name="value">The value.</param> /// <returns></returns> public static object GetMetaFieldValue(MetaField mf, object value) { if (value == null) { return(value); } if (mf.DataType == MetaDataType.DictionarySingleValue || mf.DataType == MetaDataType.EnumSingleValue) { return(((MetaDictionaryItem)value).Value); } else if (mf.DataType == MetaDataType.DictionaryMultiValue || mf.DataType == MetaDataType.EnumMultiValue) { ArrayList arr = new ArrayList(); foreach (MetaDictionaryItem item in (MetaDictionaryItem[])value) { arr.Add(item.Value); } return((string[])arr.ToArray(typeof(string))); } else { return(value); } }
public void BindData(MetaField mf) { CultureInfo invariantCulture = new CultureInfo(""); if (mf.Attributes.ContainsKey(McDataTypeAttribute.DoubleMinValue)) { txtMinValue.Text = ((double)mf.Attributes[McDataTypeAttribute.DoubleMinValue]).ToString("f"); } else { txtMinValue.Text = ""; } if (mf.Attributes.ContainsKey(McDataTypeAttribute.DoubleMaxValue)) { txtMaxValue.Text = ((double)mf.Attributes[McDataTypeAttribute.DoubleMaxValue]).ToString("f"); } else { txtMaxValue.Text = ""; } if (mf.DefaultValue != String.Empty) { txtDefaultValue.Text = ((double)DefaultValue.Evaluate(mf)).ToString("f"); } else { txtDefaultValue.Text = ""; } }
/// <summary> /// Binds the available fields. /// </summary> private void BindAvailableFields() { DataTable dt = new DataTable(); dt.Columns.Add("MetaFieldId", typeof(int)); dt.Columns.Add("FriendlyName", typeof(string)); // Fields MetaFieldCollection mfc = MetaField.GetList(MDContext); foreach (MetaField field in mfc) { if (field.IsUser) { DataRow row = dt.NewRow(); row["MetaFieldId"] = field.Id; row["FriendlyName"] = field.FriendlyName; dt.Rows.Add(row); } } /* * ItemsGrid.DataSource = new DataView(dt); * ItemsGrid.DataBind(); * */ }
public void BindData(MetaField mf) { ViewState[this.ClientID + "_TypeName"] = mf.TypeName; MetaFieldType mft = DataContext.Current.MetaModel.RegisteredTypes[mf.TypeName]; trName.Visible = false; txtFriendlyName.Text = mft.FriendlyName; if (mf.Attributes.ContainsKey(McDataTypeAttribute.EnumEditable)) { chkEditable.Checked = (bool)mf.Attributes[McDataTypeAttribute.EnumEditable]; } if (mft.Attributes.ContainsKey(McDataTypeAttribute.EnumPrivate) && mft.Attributes[McDataTypeAttribute.EnumPrivate].ToString() == mf.Owner.Name) { chkPublic.Checked = false; } else { chkPublic.Checked = true; } chkPublic.Enabled = false; }
public DataControlField GetColumn(Page pageInstance, MetaField field, bool isPrimaryKey) { if (pageInstance == null) { throw new ArgumentNullException("pageInstance"); } if (field == null) { throw new ArgumentNullException("field"); } if (ControlPathResolver.Current == null) { throw new ArgumentNullException("ControlPathResolver"); } TemplateField retVal = new TemplateField(); if (!isPrimaryKey) { ResolvedPath resPath = ControlPathResolver.Current.Resolve(CHelper.GetMetaTypeName(field), "Grid", field.Owner.Name, field.Name, viewName); //retVal.ItemTemplate = PageInstance.LoadTemplate(MetaFieldControlPathResolver.Resolve(CHelper.GetMetaTypeName(Field)/*Field.TypeName*/, "Grid", Field.Owner.Name, Field.Name, viewName, string.Empty)); if (resPath != null) { retVal.ItemTemplate = pageInstance.LoadTemplate(resPath.Path); } } else { retVal.ItemTemplate = pageInstance.LoadTemplate("~/Apps/MetaUI/Primitives/Text.Grid.@[email protected]"); } return(retVal); }
protected override void FillSystemColumnInfo(System.Collections.ArrayList array) { MetaClass mc = MetaClass.Load(Context, _metaClassId); FillType fillTypes = FillType.CopyValue | FillType.Custom | FillType.Default; array.Add(new ColumnInfo(MetaField.CreateVirtual(this.Context, "eCF.50.Import", "sys_RowAction", "Action (Insert/Update/Delete or I/U/D)", "", MetaDataType.NVarChar, 6, true, false, false, false, false), fillTypes)); //Entry array.Add(new ColumnInfo(MetaField.CreateVirtual(this.Context, "eCF.50.Import", "Code", "Code<sup>1,2</sup>", "", MetaDataType.NVarChar, 100, false, false, false, false, false), fillTypes)); array.Add(new ColumnInfo(MetaField.CreateVirtual(this.Context, "eCF.50.Import", "Name", "Name<sup>1</sup>", "", MetaDataType.NVarChar, 100, true, false, false, false, false), fillTypes)); array.Add(new ColumnInfo(MetaField.CreateVirtual(this.Context, "eCF.50.Import", "ClassTypeId", "Entry Type<sup>1</sup>", "", MetaDataType.NVarChar, 50, true, false, false, false, false), fillTypes, true)); array.Add(new ColumnInfo(MetaField.CreateVirtual(this.Context, "eCF.50.Import", "StartDate", "Available from", "", MetaDataType.DateTime, 8, true, false, false, false, false), fillTypes)); array.Add(new ColumnInfo(MetaField.CreateVirtual(this.Context, "eCF.50.Import", "EndDate", "Expires on", "", MetaDataType.DateTime, 8, true, false, false, false, false), fillTypes)); array.Add(new ColumnInfo(MetaField.CreateVirtual(this.Context, "eCF.50.Import", "TemplateName", "Display Template", "", MetaDataType.NVarChar, 50, true, false, false, false, false), fillTypes, true)); array.Add(new ColumnInfo(MetaField.CreateVirtual(this.Context, "eCF.50.Import", "IsActive", "Available (True/False)", "", MetaDataType.Bit, 1, true, false, false, false, false), fillTypes)); array.Add(new ColumnInfo(MetaField.CreateVirtual(this.Context, "eCF.50.Import", "CategoryCode", "Category Code (by comma)", "", MetaDataType.ShortString, 255, true, false, false, false, false), fillTypes)); array.Add(new ColumnInfo(MetaField.CreateVirtual(this.Context, "eCF.50.Import", "SortOrder", "Sort Order", "", MetaDataType.Int, 4, true, false, false, false, false), fillTypes)); //SEO array.Add(new ColumnInfo(MetaField.CreateVirtual(this.Context, "eCF.50.Import", "SEO Title", "SeoTitle", "", MetaDataType.NVarChar, 150, true, false, true, false, false), fillTypes)); array.Add(new ColumnInfo(MetaField.CreateVirtual(this.Context, "eCF.50.Import", "SEO Url", "SeoUrl", "", MetaDataType.NVarChar, 255, true, false, true, false, false), fillTypes)); array.Add(new ColumnInfo(MetaField.CreateVirtual(this.Context, "eCF.50.Import", "SEO Description", "SeoDescription", "", MetaDataType.NVarChar, 355, true, false, true, false, false), fillTypes)); array.Add(new ColumnInfo(MetaField.CreateVirtual(this.Context, "eCF.50.Import", "SEO Keywords", "SeoKeywords", "", MetaDataType.NVarChar, 355, true, false, true, false, false), fillTypes)); }
/// <summary> /// Gets the column. /// </summary> /// <param name="pageInstance">The page instance.</param> /// <param name="field">The field.</param> /// <param name="placeName">Name of the place.</param> /// <returns></returns> public DataControlField GetColumn(Page pageInstance, MetaField field, string placeName) { if (pageInstance == null) { throw new ArgumentNullException("pageInstance"); } if (field == null) { throw new ArgumentNullException("field"); } if (ControlPathResolver.Current == null) { throw new ArgumentNullException("ControlPathResolver"); } if (pageInstance == null) { throw new ArgumentNullException("pageInstance"); } TemplateField retVal = new TemplateField(); ResolvedPath resPath = ControlPathResolver.Current.Resolve(CHelper.GetMetaTypeName(field), "Grid", field.Owner.Name, field.Name, placeName); if (resPath != null) { retVal.ItemTemplate = pageInstance.LoadTemplate(resPath.Path); } return(retVal); }
protected override void Build() { var type = this.__CLRType; m_BuildInformation = new BuildInformation(type.Assembly, throwError: false); m_IsValueType = type.IsValueType; m_IsVisible = type.IsVisible; m_IsArray = type.IsArray; m_IsAbstract = type.IsAbstract; if (m_IsArray) { m_ArrayRank = type.GetArrayRank(); m_ArrayElementTypeIndex = MetaType.GetExistingOrNewMetaTypeIndex(m_Document, type.GetElementType()); } m_Fields = new List <MetaField>(); var fields = SerializationUtils.GetSerializableFields(type); foreach (var fld in fields) { var mf = new MetaField(this, fld); m_Fields.Add(mf); mf.m_Index = m_Fields.Count - 1; } m_MethodsOnSerializing = SerializationUtils.FindSerializationAttributedMethods(type, typeof(OnSerializingAttribute)); m_MethodsOnSerialized = SerializationUtils.FindSerializationAttributedMethods(type, typeof(OnSerializedAttribute)); }
private void MakeDataViewFromListForXML(DataTable dt, EntityObject[] list, string prefix) { DataRow dr; foreach (EntityObject entityObject in list) { dr = dt.NewRow(); foreach (EntityObjectProperty entityProp in entityObject.Properties) { EntityObject agregatedEntity = entityProp.Value as EntityObject; if (agregatedEntity != null) //Aggregation { MakeDataViewFromListForXML(dt, new EntityObject[] { agregatedEntity }, entityProp.Name); } else { string metaFieldName = string.IsNullOrEmpty(prefix) ? entityProp.Name : String.Format("{0}.{1}", prefix, entityProp.Name); if (dt.Columns.Contains(metaFieldName)) { MetaField field = Mediachase.Ibn.Web.UI.Controls.Util.FormController.GetMetaField(ClassName, metaFieldName); object value = Mediachase.Ibn.Lists.Mapping.Type2McDataType.ConvertMcData2ManagedData(field, entityProp.Value); if (value != null) { dr[metaFieldName] = value; } } } } dt.Rows.Add(dr); } }
private void AddMetaFieldLineItem(object sender, EventArgs eventArgs) { var lineItemMetaClass = OrderContext.Current.LineItemMetaClass; var context = OrderContext.MetaDataContext; var name = "VariantOptionCodes"; var displayName = "Variant Option Codes"; var length = 256; var metaFieldType = MetaDataType.LongString; var metaNamespace = string.Empty; var description = string.Empty; var isNullable = false; var isMultiLanguage = true; var isSearchable = true; var isEncrypted = true; var metaField = MetaField.Load(context, name) ?? MetaField.Create(context, lineItemMetaClass.Namespace, name, displayName, description, metaFieldType, length, isNullable, isMultiLanguage, isSearchable, isEncrypted); if (lineItemMetaClass.MetaFields.All(x => x.Id != metaField.Id)) { lineItemMetaClass.AddField(metaField); } }
private void ShowField(MetaField field) { field.Opacity = 1.0f; // If the field is a block, recursively set the opacity of its children var block = field as TagBlockData; if (block != null) { // Show wrappers _flattener.EnumWrappers(block, ShowField); // Show template fields foreach (MetaField child in block.Template) { ShowField(child); } // Show modified fields foreach (TagBlockPage page in block.Pages) { foreach (MetaField child in page.Fields) { if (child != null) { ShowField(child); } } } } }
private MethodDeclarationSyntax CreateSingleElementMethod(MetaField field, IdentifierNameSyntax methodName, SimpleNameSyntax collectionMutationMethodName, bool passThroughChildSync = false) { var paramsArrayMethod = CreateMethodStarter(methodName.Identifier, field) .WithParameterList(SyntaxFactory.ParameterList(SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Parameter(ValueParameterName.Identifier).WithType(GetFullyQualifiedSymbolName(field.ElementType))))); var argument = passThroughChildSync ? (ExpressionSyntax)SyntaxFactory.InvocationExpression( Syntax.ThisDot(SyncImmediateChildToCurrentVersionMethodName), SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument(ValueParameterName)))) : ValueParameterName; paramsArrayMethod = this.AddMethodBody( paramsArrayMethod, field, receiver => SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, receiver, collectionMutationMethodName), SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Argument(argument))))); return(paramsArrayMethod); }
/// <summary> /// Binds the data. /// </summary> /// <param name="field">The field.</param> public void BindData(MetaField field) { ddlValue.Items.Clear(); ddlValue.Items.Add(new ListItem(CHelper.GetResFileString(field.Attributes[McDataTypeAttribute.BooleanTrueText].ToString()), "true")); ddlValue.Items.Add(new ListItem(CHelper.GetResFileString(field.Attributes[McDataTypeAttribute.BooleanFalseText].ToString()), "false")); CHelper.SafeSelect(ddlValue, _value.ToString().ToLower()); }
private static List <MetaField> GetMetaFields(Type type) { var fields = type.GetFields(); var result = new List <MetaField>(); foreach (var field in fields) { string desc = "TODO document me"; var attr = field.GetCustomAttribute <APIDescriptionAttribute>(); if (attr != null) { desc = attr.Description; } var meta = new MetaField() { Name = field.Name, FieldType = field.FieldType, Description = desc }; result.Add(meta); } return(result); }
public void Initialize(MetaField field) { if (field.MemberType != typeof(double)) { throw new ArgumentException("Only double member type is allowed."); } }
public void Initialize(MetaField field) { Guard.CheckNotNull("field", field); if (field.AllowMultipleValues) { if (field.MemberType != typeof(TermInfo[]) && !field.MemberType.IsAssignableFrom(typeof(List <TermInfo>))) { throw new ArgumentException("Only TermInfo[] or any class assigname from List<TermInfo> can be used as a member type."); } _isMulti = true; _isArray = field.MemberType.IsArray; } else { if (field.MemberType != typeof(TermInfo)) { throw new ArgumentException( "Only TermInfo can be used as a member type."); } } _termSetId = field.TermSetId; }
public void BindData(MetaField field) { string sReferencedClass = field.Attributes[McDataTypeAttribute.ReferenceMetaClassName].ToString(); ViewState["ReferencedClass"] = sReferencedClass; if (sReferencedClass == TimeTrackingEntry.GetAssignedMetaClass().Name || sReferencedClass == TimeTrackingBlock.GetAssignedMetaClass().Name || sReferencedClass == TimeTrackingBlockType.GetAssignedMetaClass().Name || sReferencedClass == TimeTrackingBlockTypeInstance.GetAssignedMetaClass().Name || sReferencedClass == Principal.GetAssignedMetaClass().Name || Mediachase.IBN.Business.Security.CurrentUser == null) { tblEntity.Visible = false; string url = ResolveClientUrl(String.Format("~/Apps/MetaUI/Pages/Public/SelectItem.aspx?class={0}&btn={1}", sReferencedClass, Page.ClientScript.GetPostBackEventReference(btnRefresh, "xxx"))); ibSelect.OnClientClick = String.Format("OpenPopUpWindow(\"{0}\", 640, 480, 1); return false;", url); } else { ReferenceUpdatePanel.Visible = false; refObjects.ObjectTypes = sReferencedClass; if (Request["ContainerFieldName"] != null && field.Name == Request["ContainerFieldName"] && Request["ContainerId"] != null) { this.Value = PrimaryKeyId.Parse(Request["ContainerId"]); } } }
private static void FastLoadField(MetaField fieldInfo, Pointer <byte> addr, Pointer <byte> fieldAddr) { int fieldSize = fieldInfo.Size; byte[] memCpy = addr.CopyBytes(fieldSize); fieldAddr.WriteAll(memCpy); }
public void BindData(MetaField mf) { if (mf.Attributes.ContainsKey(McDataTypeAttribute.DateTimeMinValue)) txtMinValue.Text = ((DateTime)mf.Attributes[McDataTypeAttribute.DateTimeMinValue]).ToString("yyyy-MM-dd"); if (mf.Attributes.ContainsKey(McDataTypeAttribute.DateTimeMaxValue)) txtMaxValue.Text = ((DateTime)mf.Attributes[McDataTypeAttribute.DateTimeMaxValue]).ToString("yyyy-MM-dd"); chkCurrentDateAsDefault.Checked = (DefaultValue.Evaluate(mf) != null); }
internal static ParameterListSyntax CreateParamsElementArrayParameters(MetaField field) { return SyntaxFactory.ParameterList(SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Parameter(ValuesParameterName.Identifier) .WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.ParamsKeyword))) .WithType(SyntaxFactory.ArrayType(GetFullyQualifiedSymbolName(field.ElementType)) .AddRankSpecifiers(SyntaxFactory.ArrayRankSpecifier(SyntaxFactory.SingletonSeparatedList<ExpressionSyntax>(SyntaxFactory.OmittedArraySizeExpression())))))); }
public static bool CheckCardField(MetaClass _class, MetaField cardField) { string CardPKeyName = string.Format(CultureInfo.InvariantCulture, "{0}Id", cardField.Owner.Name); string CardRefKeyName = string.Format(CultureInfo.InvariantCulture, "{0}Id", _class.Name); return (cardField.Name != CardRefKeyName && cardField.Name != CardPKeyName && !(cardField.GetOriginalMetaType().McDataType == McDataType.ReferencedField && cardField.Attributes.GetValue<string>(McDataTypeAttribute.ReferencedFieldMetaClassName) == _class.Name) ); }
public void BindData(MetaField mf) { if (mf.Attributes.ContainsKey(McDataTypeAttribute.StringMaxLength)) txtMaxLen.Text = mf.Attributes[McDataTypeAttribute.StringMaxLength].ToString(); txtMaxLen.Enabled = false; if (mf.Attributes.ContainsKey(McDataTypeAttribute.StringIsUnique)) chkUnique.Checked = (bool)mf.Attributes[McDataTypeAttribute.StringIsUnique]; chkUnique.Enabled = false; }
public void BindData(MetaField mf) { if (mf.DefaultValue != String.Empty) txtDefaultValue.Text = ((decimal)DefaultValue.Evaluate(mf)).ToString("f"); else txtDefaultValue.Text = ""; if (mf.Attributes.ContainsKey(McDataTypeAttribute.CurrencyAllowNegative)) chkAllowNegative.Checked = (bool)mf.Attributes[McDataTypeAttribute.CurrencyAllowNegative]; }
public void BindData(MetaField mf) { string RefClassName = mf.Attributes[McDataTypeAttribute.BackReferenceMetaClassName].ToString(); string RefFieldName = mf.Attributes[McDataTypeAttribute.BackReferenceMetaFieldName].ToString(); ddlClass.Items.Add( new ListItem( String.Format("{0} ({1})", RefClassName, RefFieldName), String.Format("{0},{1}", RefClassName, RefFieldName)) ); ddlClass.Enabled = false; }
public void BindData(MetaField mf) { string primaryClassName = mf.Attributes[McDataTypeAttribute.ReferenceMetaClassName].ToString(); ClassList.Items.Add(new ListItem(CHelper.GetResFileString(Mediachase.Ibn.Core.MetaDataWrapper.GetMetaClassByName(primaryClassName).FriendlyName))); ClassList.Enabled = false; chkUseObjectRoles.Enabled = false; chkUseObjectRoles.Checked = Mediachase.Ibn.Data.Services.Security.AreObjectRolesAddedFromRefernce(mf); if (!BusinessObjectServiceManager.IsServiceInstalled(mf.Owner, SecurityService.ServiceName)) chkUseObjectRoles.Visible = false; }
public void BindData(MetaField mf) { if (mf.Attributes.ContainsKey(McDataTypeAttribute.BooleanLabel)) txtCheckBoxLabel.Text = mf.Attributes[McDataTypeAttribute.BooleanLabel].ToString(); try { chkCheckedByDefault.Checked = (bool)DefaultValue.Evaluate(mf); } catch { } }
public void BindData(MetaField mf) { if (mf.Attributes.ContainsKey(McDataTypeAttribute.StringMaxLength)) txtMaxLen.Text = mf.Attributes[McDataTypeAttribute.StringMaxLength].ToString(); txtMaxLen.Enabled = false; if (mf.Attributes.ContainsKey(McDataTypeAttribute.StringIsUnique)) chkUnique.Checked = (bool)mf.Attributes[McDataTypeAttribute.StringIsUnique]; chkUnique.Enabled = false; LoadData(); if (mf.Attributes.ContainsKey(McDataTypeAttribute.StringUrlTarget)) CHelper.SafeSelect(ddlTarget, mf.Attributes[McDataTypeAttribute.StringUrlTarget].ToString()); }
private void AddItem(MetaField mf) { if (mf.IsAggregation) { string aggrClassName = mf.Attributes[McDataTypeAttribute.AggregationMetaClassName].ToString(); MetaClass mc = MetaDataWrapper.GetMetaClassByName(aggrClassName); foreach (MetaField mfa in mc.Fields) ddField.Items.Add( new ListItem( String.Format("{0} - {1}", CHelper.GetMetaFieldName(mf), CHelper.GetMetaFieldName(mfa)), String.Format("{0}.{1}", mf.Name, mfa.Name) ) ); } else ddField.Items.Add(new ListItem(CHelper.GetMetaFieldName(mf), mf.Name)); }
public void BindData(MetaField mf) { string RefClassName = mf.Attributes[McDataTypeAttribute.ReferenceMetaClassName].ToString(); string ReferenceName = mf.Attributes[McDataTypeAttribute.ReferencedFieldReferenceName].ToString(); string RefFieldName = mf.Attributes[McDataTypeAttribute.ReferencedFieldMetaFieldName].ToString(); MetaClass mc = MetaDataWrapper.GetMetaClassByName(RefClassName); ddlClass.Items.Add( new ListItem( String.Format(CultureInfo.InvariantCulture, "{0} ({1})", CHelper.GetResFileString(mf.Owner.Fields[ReferenceName].FriendlyName), CHelper.GetResFileString(mc.FriendlyName)), String.Format(CultureInfo.InvariantCulture, "{0},{1}", RefClassName, ReferenceName)) ); ddlClass.Enabled = false; ddlField.Items.Add(new ListItem(CHelper.GetResFileString(mc.Fields[RefFieldName].FriendlyName))); ddlField.Enabled = false; }
public void BindData(MetaField mf) { if (mf.Attributes.ContainsKey(McDataTypeAttribute.FileNameRegexPattern)) txtRegexPattern.Text = mf.Attributes[McDataTypeAttribute.FileNameRegexPattern].ToString(); if (mf.Attributes.ContainsKey(McDataTypeAttribute.ImageWidth)) txtWidth.Text = mf.Attributes[McDataTypeAttribute.ImageWidth].ToString(); else txtWidth.Text = ""; if (mf.Attributes.ContainsKey(McDataTypeAttribute.ImageHeight)) txtHeight.Text = mf.Attributes[McDataTypeAttribute.ImageHeight].ToString(); else txtHeight.Text = ""; if (mf.Attributes.ContainsKey(McDataTypeAttribute.ImageShowBorder)) chkShowBorder.Checked = (bool)mf.Attributes[McDataTypeAttribute.ImageShowBorder]; }
public void BindData(MetaField mf) { CultureInfo invariantCulture = new CultureInfo(""); if (mf.Attributes.ContainsKey(McDataTypeAttribute.DoubleMinValue)) txtMinValue.Text = ((double)mf.Attributes[McDataTypeAttribute.DoubleMinValue]).ToString("f"); else txtMinValue.Text = ""; if (mf.Attributes.ContainsKey(McDataTypeAttribute.DoubleMaxValue)) txtMaxValue.Text = ((double)mf.Attributes[McDataTypeAttribute.DoubleMaxValue]).ToString("f"); else txtMaxValue.Text = ""; if (mf.DefaultValue != String.Empty) txtDefaultValue.Text = ((double)DefaultValue.Evaluate(mf)).ToString("f"); else txtDefaultValue.Text = ""; }
public void BindData(MetaField mf) { ViewState[this.ClientID + "_TypeName"] = mf.TypeName; MetaFieldType mft = DataContext.Current.MetaModel.RegisteredTypes[mf.TypeName]; trName.Visible = false; txtFriendlyName.Text = mft.FriendlyName; if (mf.Attributes.ContainsKey(McDataTypeAttribute.EnumEditable)) chkEditable.Checked = (bool)mf.Attributes[McDataTypeAttribute.EnumEditable]; if (mft.Attributes.ContainsKey(McDataTypeAttribute.EnumPrivate) && mft.Attributes[McDataTypeAttribute.EnumPrivate].ToString() == mf.Owner.Name) chkPublic.Checked = false; else chkPublic.Checked = true; chkPublic.Enabled = false; }
public void BindData(MetaField mf) { if (mf.Attributes.ContainsKey(McDataTypeAttribute.BooleanTrueText)) txtYesText.Text = mf.Attributes[McDataTypeAttribute.BooleanTrueText].ToString(); if (mf.Attributes.ContainsKey(McDataTypeAttribute.BooleanFalseText)) txtNoText.Text = mf.Attributes[McDataTypeAttribute.BooleanFalseText].ToString(); if (ddlDefaultValue.Items.Count == 0) { ddlDefaultValue.Items.Add(new ListItem(GetGlobalResourceObject("IbnFramework.GlobalFieldManageControls", "Yes").ToString(), "1")); ddlDefaultValue.Items.Add(new ListItem(GetGlobalResourceObject("IbnFramework.GlobalFieldManageControls", "No").ToString(), "0")); } try { if ((bool)DefaultValue.Evaluate(mf)) CHelper.SafeSelect(ddlDefaultValue, "1"); else CHelper.SafeSelect(ddlDefaultValue, "0"); } catch { } }
public DataControlField GetColumn(Page PageInstance, MetaField Field, bool IsPrimaryKey) { if (PageInstance == null) throw new ArgumentNullException("pageInstance"); if (Field == null) throw new ArgumentNullException("field"); TemplateField retVal = new TemplateField(); if (!IsPrimaryKey) { string className = Field.Owner.Name; if (ListManager.MetaClassIsList(className)) className = "List_@"; ResolvedPath resPath = ControlPathResolver.Current.Resolve(CHelper.GetMetaTypeName(Field), "GridEntity", className, Field.Name, viewName); if (resPath != null) retVal.ItemTemplate = PageInstance.LoadTemplate(resPath.Path); } else retVal.ItemTemplate = PageInstance.LoadTemplate("~/Apps/MetaUIEntity/Primitives/Text.GridEntity.@[email protected]"); return retVal; }
public void BindData(MetaField field) { if (field.Attributes.ContainsKey(McDataTypeAttribute.StringMaxLength)) txtValue.MaxLength = (int)field.Attributes[McDataTypeAttribute.StringMaxLength]; if (field.Attributes.GetValue<bool>(McDataTypeAttribute.StringIsUnique, false)) ViewState[FieldName + "FieldClassName"] = field.Owner.Name; }
public void BindData(MetaField mf) { }
public void BindData(MetaField mf) { txtMinValue.Text = mf.Attributes.GetValue<int>(McDataTypeAttribute.IntegerMinValue, int.MinValue).ToString(); txtMaxValue.Text = mf.Attributes.GetValue<int>(McDataTypeAttribute.IntegerMaxValue, int.MaxValue).ToString(); txtDefaultValue.Text = mf.DefaultValue; }
/// <summary> /// Loads the request variables. /// </summary> private void LoadRequestVariables() { // Class if (Request.QueryString["class"] != null) { ClassName = Request.QueryString["class"]; mc = MetaDataWrapper.GetMetaClassByName(ClassName); } // Bridge if (Request.QueryString["bridge"] != null) { BridgeName = Request.QueryString["bridge"]; mcBridge = MetaDataWrapper.GetMetaClassByName(BridgeName); } // Current Field if (mcBridge != null && Request.QueryString["field"] != null) { FieldName = Request.QueryString["field"]; mf = mcBridge.Fields[FieldName]; } // Another field if (mf != null) { if (mf.Name == mcBridge.Attributes.GetValue<string>(MetaClassAttribute.BridgeRef1Name, string.Empty)) mfRef = mcBridge.Fields[mcBridge.Attributes[MetaClassAttribute.BridgeRef2Name].ToString()]; else mfRef = mcBridge.Fields[mcBridge.Attributes[MetaClassAttribute.BridgeRef1Name].ToString()]; } // Another Class if (mfRef != null) { RefClassName = mfRef.Attributes.GetValue<string>(McDataTypeAttribute.ReferenceMetaClassName, string.Empty); if (!String.IsNullOrEmpty(RefClassName)) mcRef = MetaDataWrapper.GetMetaClassByName(RefClassName); } }
private MethodDeclarationSyntax CreateParamsElementArrayMethod(MetaField field, IdentifierNameSyntax methodName, SimpleNameSyntax collectionMutationMethodName, bool passThroughChildSync = false) { var paramsArrayMethod = CreateMethodStarter(methodName.Identifier, field) .WithParameterList(CreateParamsElementArrayParameters(field)); var lambdaParameter = SyntaxFactory.Parameter(SyntaxFactory.Identifier("v")); var argument = passThroughChildSync ? (ExpressionSyntax)Syntax.EnumerableExtension( SyntaxFactory.IdentifierName(nameof(Enumerable.Select)), ValuesParameterName, SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Argument(Syntax.ThisDot(SyncImmediateChildToCurrentVersionMethodName))))) : ValuesParameterName; paramsArrayMethod = this.AddMethodBody( paramsArrayMethod, field, receiver => SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, receiver, collectionMutationMethodName), SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Argument(argument))))); return paramsArrayMethod; }
private MethodDeclarationSyntax CreateSingleElementMethod(MetaField field, IdentifierNameSyntax methodName, SimpleNameSyntax collectionMutationMethodName, bool passThroughChildSync = false, IdentifierNameSyntax elementParameterName = null, ITypeSymbol elementType = null) { elementParameterName = elementParameterName ?? ValueParameterName; var paramsArrayMethod = CreateMethodStarter(methodName.Identifier, field) .WithParameterList(SyntaxFactory.ParameterList(SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Parameter(elementParameterName.Identifier) .WithType(GetFullyQualifiedSymbolName(elementType ?? field.ElementType))))); var argument = passThroughChildSync ? (ExpressionSyntax)SyntaxFactory.InvocationExpression( Syntax.ThisDot(SyncImmediateChildToCurrentVersionMethodName), SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument(elementParameterName)))) : elementParameterName; paramsArrayMethod = this.AddMethodBody( paramsArrayMethod, field, receiver => SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, receiver, collectionMutationMethodName), SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Argument(argument))))); return paramsArrayMethod; }
private MethodDeclarationSyntax CreateMethodStarter(SyntaxToken name, MetaField field) { var method = SyntaxFactory.MethodDeclaration( GetFullyQualifiedSymbolName(this.generator.applyToSymbol), name) .AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword)); if (!field.IsLocallyDefined) { method = Syntax.AddNewKeyword(method); } return method; }
private MethodDeclarationSyntax CreateKeyValueMethod(MetaField field, IdentifierNameSyntax methodName, SimpleNameSyntax collectionMutationMethodName) { var paramsArrayMethod = CreateMethodStarter(methodName.Identifier, field) .WithParameterList(SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList( new ParameterSyntax[] { SyntaxFactory.Parameter(KeyParameterName.Identifier).WithType(GetFullyQualifiedSymbolName(field.ElementKeyType)), SyntaxFactory.Parameter(ValueParameterName.Identifier).WithType(GetFullyQualifiedSymbolName(field.ElementValueType)), }))); paramsArrayMethod = this.AddMethodBody( paramsArrayMethod, field, receiver => SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, receiver, collectionMutationMethodName), SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(new ArgumentSyntax[] { SyntaxFactory.Argument(KeyParameterName), SyntaxFactory.Argument(ValueParameterName), })))); return paramsArrayMethod; }
private MemberDeclarationSyntax CreateClearMethod(MetaField field, IdentifierNameSyntax methodName) { var method = CreateMethodStarter(methodName.Identifier, field) .WithParameterList(SyntaxFactory.ParameterList()); method = this.AddMethodBody( method, field, receiver => SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, receiver, SyntaxFactory.IdentifierName(nameof(ICollection<int>.Clear))), SyntaxFactory.ArgumentList())); return method; }
private MethodDeclarationSyntax AddMethodBody(MethodDeclarationSyntax containingMethod, MetaField field, Func<ExpressionSyntax, InvocationExpressionSyntax> mutatingInvocationFactory) { var returnExpression = field.IsLocallyDefined ? (ExpressionSyntax)SyntaxFactory.InvocationExpression( // this.With(field: this.field.SomeOperation(someArgs)) Syntax.ThisDot(WithMethodName), SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Argument( SyntaxFactory.NameColon(field.Name), NoneToken, mutatingInvocationFactory(Syntax.ThisDot(field.NameAsField)))))) : SyntaxFactory.CastExpression( // (TemplateType)base.SameMethod(sameArgs) GetFullyQualifiedSymbolName(this.generator.applyToSymbol), SyntaxFactory.InvocationExpression( Syntax.BaseDot(SyntaxFactory.IdentifierName(containingMethod.Identifier)), SyntaxFactory.ArgumentList( Syntax.JoinSyntaxNodes( SyntaxKind.CommaToken, containingMethod.ParameterList.Parameters.Select(p => SyntaxFactory.Argument(SyntaxFactory.IdentifierName(p.Identifier))))))); return containingMethod.WithBody(SyntaxFactory.Block( SyntaxFactory.ReturnStatement(returnExpression))); }
public void BindData(MetaField field) { string cards = String.Empty; int[] permittedTypes = (int[])field.Attributes[RoleTypeAttribute.PermittedPrincipalTypes]; foreach (int i in permittedTypes) { if (!String.IsNullOrEmpty(cards)) cards += ","; //TODO DELEGATE //PrincipalTypes type = (PrincipalTypes)i; //cards += type.ToString(); } MainPopupControl.CardFilter = cards; }