Esempio n. 1
0
        public void AddProperties(StringBuilderWrapper sb, MetadataType type,
                                  bool initCollections, bool includeResponseStatus)
        {
            var wasAdded = false;

            var defaultValue = type.IsInterface != true ? " = null" : "";

            var dataMemberIndex = 1;

            if (type.Properties != null)
            {
                foreach (var prop in type.Properties)
                {
                    if (wasAdded)
                    {
                        sb.AppendLine();
                    }

                    var propType = Type(prop.GetTypeName(Config, allTypes), prop.GenericArgs);

                    var fieldName = prop.Name.SafeToken().PropertyStyle();

                    wasAdded = AppendComments(sb, prop.Description);
                    wasAdded = AppendDataMember(sb, prop.DataMember, dataMemberIndex++) || wasAdded;
                    wasAdded = AppendAttributes(sb, prop.Attributes) || wasAdded;

                    var initProp = initCollections && !prop.GenericArgs.IsEmpty() &&
                                   (ArrayTypes.Contains(prop.Type) || DictionaryTypes.Contains(prop.Type));

                    sb.Emit(prop, Lang.Kotlin);
                    PrePropertyFilter?.Invoke(sb, prop, type);
                    if (!fieldName.IsKeyWord())
                    {
                        sb.AppendLine(!initProp
                            ? $"var {fieldName}:{propType}?{defaultValue}"
                            : $"var {fieldName}:{propType} = {propType}()");
                    }
                    else
                    {
                        var originalName = fieldName;
                        fieldName = char.ToUpper(fieldName[0]) + fieldName.SafeSubstring(1);
                        sb.AppendLine(!initProp
                            ? $"@SerializedName(\"{originalName}\") var {fieldName}:{propType}?{defaultValue}"
                            : $"@SerializedName(\"{originalName}\") var {fieldName}:{propType} = {propType}()");
                    }
                    PostPropertyFilter?.Invoke(sb, prop, type);
                }
            }

            if (includeResponseStatus)
            {
                if (wasAdded)
                {
                    sb.AppendLine();
                }

                AppendDataMember(sb, null, dataMemberIndex++);
                sb.AppendLine($"var {nameof(ResponseStatus).PropertyStyle()}:ResponseStatus?{defaultValue}");
            }
        }
Esempio n. 2
0
        public void AddProperties(StringBuilderWrapper sb, MetadataType type,
                                  bool initCollections, bool includeResponseStatus)
        {
            var wasAdded = false;

            var defaultValue = type.IsInterface != true ? " = null" : "";

            var dataMemberIndex = 1;

            if (type.Properties != null)
            {
                foreach (var prop in type.Properties)
                {
                    if (wasAdded)
                    {
                        sb.AppendLine();
                    }

                    var propType = Type(prop.Type, prop.GenericArgs);

                    var fieldName = prop.Name.SafeToken().PropertyStyle();

                    wasAdded = AppendComments(sb, prop.Description);
                    wasAdded = AppendDataMember(sb, prop.DataMember, dataMemberIndex++) || wasAdded;
                    wasAdded = AppendAttributes(sb, prop.Attributes) || wasAdded;

                    var initProp = initCollections && !prop.GenericArgs.IsEmpty() &&
                                   (ArrayTypes.Contains(prop.Type) || DictionaryTypes.Contains(prop.Type));

                    if (!fieldName.IsKeyWord())
                    {
                        sb.AppendLine(!initProp
                            ? "var {0}:{1}?{2}".Fmt(fieldName, propType, defaultValue)
                            : "var {0}:{1} = {1}()".Fmt(fieldName, propType, defaultValue));
                    }
                    else
                    {
                        var originalName = fieldName;
                        fieldName = char.ToUpper(fieldName[0]) + fieldName.SafeSubstring(1);
                        sb.AppendLine(!initProp
                            ? "@SerializedName(\"{0}\") var {1}:{2}?{3}".Fmt(originalName, fieldName, propType,
                                                                             defaultValue)
                            : "@SerializedName(\"{0}\") var {1}:{2} = {2}()".Fmt(originalName, fieldName, propType));
                    }
                }
            }

            if (includeResponseStatus)
            {
                if (wasAdded)
                {
                    sb.AppendLine();
                }

                AppendDataMember(sb, null, dataMemberIndex++);
                sb.AppendLine("var {0}:ResponseStatus?{1}".Fmt(typeof(ResponseStatus).Name.PropertyStyle(), defaultValue));
            }
        }
Esempio n. 3
0
        private void dg_delete(object source, System.Web.UI.WebControls.DataGridCommandEventArgs e)
        {
            int             ItemID = int.Parse(e.Item.Cells[0].Text);
            DictionaryTypes dic    = (DictionaryTypes)Enum.Parse(typeof(DictionaryTypes), iDictionaryType.ToString());

            Dictionaries.DeleteItem(ItemID, dic);
            dgDic.EditItemIndex = -1;
            BindDG();
        }
Esempio n. 4
0
        /// <summary>
        ///		ItemId, ItemName, Weight, StateId, CanDelete (int)
        /// </summary>
        public static DataTable GetList(DictionaryTypes dict)
        {
            DataTable dt = null;

            switch (dict)
            {
            case DictionaryTypes.Categories:
                dt = DBCommon.GetListCategoriesForDictionaries();
                break;

            case DictionaryTypes.IncidentSeverities:
                dt = DBIncident.GetListIncidentSeverityForDictionaries();
                break;

            case DictionaryTypes.IncidentTypes:
                dt = DBIncident.GetListIncidentTypesForDictionaries();
                break;

            case DictionaryTypes.ProjectTypes:
                dt = DBProject.GetListProjectTypesForDictionaries();
                break;

            case DictionaryTypes.ProjectCategories:
                dt = DBProject.GetListProjectCategoriesForDictionaries();
                break;

            case DictionaryTypes.IncidentCategories:
                dt = DBIncident.GetListIncidentCategoriesForDictionaries();
                break;

            case DictionaryTypes.Currency:
                dt = DBCommon.GetListCurrencyForDictionaries();
                break;

            case DictionaryTypes.DocumentStatus:
                dt = DBDocument.GetListDocumentStatusForDictionaries(Security.CurrentUser.LanguageId);
                break;

            case DictionaryTypes.ProjectPhases:
                dt = DBProject.GetListProjectPhasesForDictionaries();
                break;

            case DictionaryTypes.RiskLevels:
                dt = DBProject.GetListRiskLevelsForDictionaries();
                break;
            }

            if (dict != DictionaryTypes.ProjectPhases && dict != DictionaryTypes.RiskLevels && dt != null)
            {
                dt.Columns.Add("Weight", typeof(int));
            }

            return(dt);
        }
Esempio n. 5
0
        public static void AddItem(string ItemName, int Param, DictionaryTypes dict)
        {
            if (!Company.CheckDiskSpace())
            {
                throw new MaxDiskSpaceException();
            }

            switch (dict)
            {
            case DictionaryTypes.Categories:
                DBCommon.AddCategory(ItemName);
                break;

            case DictionaryTypes.IncidentSeverities:
                DBIncident.AddIncidentSeverity(ItemName);
                break;

            case DictionaryTypes.IncidentTypes:
                DBIncident.AddIncidentType(ItemName);
                break;

            case DictionaryTypes.ProjectTypes:
                AddProjectType(ItemName);
                break;

            case DictionaryTypes.ProjectCategories:
                DBProject.AddProjectCategory(ItemName);
                break;

            case DictionaryTypes.IncidentCategories:
                DBIncident.AddIncidentCategory(ItemName);
                break;

            case DictionaryTypes.Currency:
                DBCommon.AddCurrency(ItemName);
                break;

            case DictionaryTypes.DocumentStatus:
                DBDocument.AddDocumentStatus(ItemName, Param);
                break;

            case DictionaryTypes.ProjectPhases:
                DBProject.AddProjectPhase(ItemName, Param);
                break;

            case DictionaryTypes.RiskLevels:
                DBProject.AddRiskLevel(ItemName, Param);
                break;
            }
        }
Esempio n. 6
0
        public static void UpdateItem(int ItemId, string ItemName, int Param, DictionaryTypes dict)
        {
            switch (dict)
            {
            case DictionaryTypes.Categories:
                DBCommon.UpdateCategory(ItemId, ItemName);
                break;

            case DictionaryTypes.IncidentSeverities:
                DBIncident.UpdateIncidentSeverity(ItemId, ItemName);
                break;

            case DictionaryTypes.IncidentTypes:
                DBIncident.UpdateIncidentType(ItemId, ItemName);
                break;

            case DictionaryTypes.ProjectTypes:
                UpdateProjectType(ItemId, ItemName);
                break;

//				case DictionaryTypes.Clients:
//					DBProject.UpdateClient(ItemId, ItemName);
//					break;
            case DictionaryTypes.ProjectCategories:
                DBProject.UpdateProjectCategory(ItemId, ItemName);
                break;

            case DictionaryTypes.IncidentCategories:
                DBIncident.UpdateIncidentCategory(ItemId, ItemName);
                break;

            case DictionaryTypes.Currency:
                DBCommon.UpdateCurrency(ItemId, ItemName);
                break;

            case DictionaryTypes.DocumentStatus:
                DBDocument.UpdateDocumentStatus(ItemId, ItemName, Param);
                break;

            case DictionaryTypes.ProjectPhases:
                DBProject.UpdateProjectPhase(ItemId, ItemName, Param);
                break;

            case DictionaryTypes.RiskLevels:
                DBProject.UpdateRiskLevel(ItemId, ItemName, Param);
                break;
            }
        }
Esempio n. 7
0
        public static void DeleteItem(int ItemId, DictionaryTypes dict)
        {
            switch (dict)
            {
            case DictionaryTypes.Categories:
                DBCommon.DeleteCategory(ItemId);
                break;

            case DictionaryTypes.IncidentSeverities:
                DBIncident.DeleteIncidentSeverity(ItemId);
                break;

            case DictionaryTypes.IncidentTypes:
                DBIncident.DeleteIncidentType(ItemId);
                break;

            case DictionaryTypes.ProjectTypes:
                DeleteProjectType(ItemId);
                break;

//				case DictionaryTypes.Clients:
//					DBProject.DeleteClient(ItemId);
//					break;
            case DictionaryTypes.ProjectCategories:
                DBProject.DeleteProjectCategory(ItemId);
                break;

            case DictionaryTypes.IncidentCategories:
                DBIncident.DeleteIncidentCategory(ItemId);
                break;

            case DictionaryTypes.Currency:
                DBCommon.DeleteCurrency(ItemId);
                break;

            case DictionaryTypes.DocumentStatus:
                DBDocument.DeleteDocumentStatus(ItemId);
                break;

            case DictionaryTypes.ProjectPhases:
                DBProject.DeleteProjectPhase(ItemId);
                break;

            case DictionaryTypes.RiskLevels:
                DBProject.DeleteRiskLevel(ItemId);
                break;
            }
        }
Esempio n. 8
0
 public static void DeleteItem(int ItemId, DictionaryTypes dict)
 {
     switch(dict)
     {
         case DictionaryTypes.Categories:
             DBCommon.DeleteCategory(ItemId);
             break;
         case DictionaryTypes.IncidentSeverities:
             DBIncident.DeleteIncidentSeverity(ItemId);
             break;
         case DictionaryTypes.IncidentTypes:
             DBIncident.DeleteIncidentType(ItemId);
             break;
         case DictionaryTypes.ProjectTypes:
             DeleteProjectType(ItemId);
             break;
     //				case DictionaryTypes.Clients:
     //					DBProject.DeleteClient(ItemId);
     //					break;
         case DictionaryTypes.ProjectCategories:
             DBProject.DeleteProjectCategory(ItemId);
             break;
         case DictionaryTypes.IncidentCategories:
             DBIncident.DeleteIncidentCategory(ItemId);
             break;
         case DictionaryTypes.Currency:
             DBCommon.DeleteCurrency(ItemId);
             break;
         case DictionaryTypes.DocumentStatus:
             DBDocument.DeleteDocumentStatus(ItemId);
             break;
         case DictionaryTypes.ProjectPhases:
             DBProject.DeleteProjectPhase(ItemId);
             break;
         case DictionaryTypes.RiskLevels:
             DBProject.DeleteRiskLevel(ItemId);
             break;
     }
 }
Esempio n. 9
0
        public static void AddItem(string ItemName, int Param, DictionaryTypes dict)
        {
            if (!Company.CheckDiskSpace())
                throw new MaxDiskSpaceException();

            switch(dict)
            {
                case DictionaryTypes.Categories:
                    DBCommon.AddCategory(ItemName);
                    break;
                case DictionaryTypes.IncidentSeverities:
                    DBIncident.AddIncidentSeverity(ItemName);
                    break;
                case DictionaryTypes.IncidentTypes:
                    DBIncident.AddIncidentType(ItemName);
                    break;
                case DictionaryTypes.ProjectTypes:
                    AddProjectType(ItemName);
                    break;
                case DictionaryTypes.ProjectCategories:
                    DBProject.AddProjectCategory(ItemName);
                    break;
                case DictionaryTypes.IncidentCategories:
                    DBIncident.AddIncidentCategory(ItemName);
                    break;
                case DictionaryTypes.Currency:
                    DBCommon.AddCurrency(ItemName);
                    break;
                case DictionaryTypes.DocumentStatus:
                    DBDocument.AddDocumentStatus(ItemName, Param);
                    break;
                case DictionaryTypes.ProjectPhases:
                    DBProject.AddProjectPhase(ItemName, Param);
                    break;
                case DictionaryTypes.RiskLevels:
                    DBProject.AddRiskLevel(ItemName, Param);
                    break;
            }
        }
Esempio n. 10
0
        private void dg_delete(object source, System.Web.UI.WebControls.DataGridCommandEventArgs e)
        {
            string dictionaryName = ddDictionaries.SelectedItem.Value;

            if (dictionaryName == ListManager.ListTypeEnumName)
            {
                MetaFieldType mft = Mediachase.Ibn.Core.MetaDataWrapper.GetEnumByName(dictionaryName);
                if (mft != null)
                {
                    MetaEnum.RemoveItem(mft, int.Parse(e.CommandArgument.ToString()));
                }
                dgEnum.EditItemIndex = -1;
            }
            else
            {
                int             ItemID = int.Parse(e.Item.Cells[0].Text);
                DictionaryTypes dic    = (DictionaryTypes)Enum.Parse(typeof(DictionaryTypes), dictionaryName);
                Dictionaries.DeleteItem(ItemID, dic);
                dgDic.EditItemIndex = -1;
            }

            BindDG();
        }
Esempio n. 11
0
        private void BindDG()
        {
            dgDic.Columns[1].HeaderText = LocRM.GetString("Name");
            dgDic.Columns[2].HeaderText = LocRM.GetString("tWeight");
            dgDic.Columns[3].HeaderText = LocRM.GetString("Options");

            DictionaryTypes dic = (DictionaryTypes)Enum.Parse(typeof(DictionaryTypes), iDictionaryType.ToString());

            DataView dv = Dictionaries.GetList(dic).DefaultView;

            if ((DictionaryTypes)iDictionaryType != DictionaryTypes.ProjectPhases)
            {
                dv.Sort = "ItemName";
            }
            else
            {
                dv.Sort = "Weight";
            }
            dgDic.DataSource = dv;
            dgDic.DataBind();

            foreach (DataGridItem dgi in dgDic.Items)
            {
                ImageButton ib = (ImageButton)dgi.FindControl("ibDelete");
                if (ib != null)
                {
                    ib.Attributes.Add("onclick", "return confirm('" + LocRM.GetString("Warning") + "')");
                }

                RequiredFieldValidator rf = (RequiredFieldValidator)dgi.FindControl("rfName");
                if (rf != null)
                {
                    rf.ErrorMessage = LocRM.GetString("Required");
                }
            }
        }
Esempio n. 12
0
 public static void AddItem(string ItemName, DictionaryTypes dict)
 {
     AddItem(ItemName, 0, dict);
 }
Esempio n. 13
0
        protected void btnAddNewItem_Click(object sender, System.EventArgs e)
        {
            if (ddDictionaries.SelectedValue == "0")
            {
                DataTable dt = GetTable(BusinessScore.List());

                DataRow dr = dt.NewRow();
                dr["BusinessScoreId"] = -1;
                dr["Key"]             = "";
                dr["Name"]            = "";
                dt.Rows.Add(dr);

                dgScore.EditItemIndex = dt.Rows.Count - 1;
                dgScore.DataSource    = dt.DefaultView;
                dgScore.DataBind();
            }
            else if (ddDictionaries.SelectedValue == "-1")
            {
                DataTable dt = GetTableSlot(BasePlanSlot.List());

                DataRow dr = dt.NewRow();
                dr["BasePlanSlotId"] = -1;
                dr["Name"]           = "";
                dr["IsDefault"]      = false;
                dt.Rows.Add(dr);

                dgPlanSlot.EditItemIndex = dt.Rows.Count - 1;
                dgPlanSlot.DataSource    = dt.DefaultView;
                dgPlanSlot.DataBind();
            }
            else if (ddDictionaries.SelectedValue == ListManager.ListTypeEnumName)              //List Types
            {
                DataTable dt = GetListTable();

                DataRow dr = dt.NewRow();
                dr["Id"]      = -1;
                dr["OrderId"] = dt.Rows.Count + 1;
                dr["Name"]    = "";
                dt.Rows.Add(dr);

                dgEnum.EditItemIndex = dt.Rows.Count - 1;
                dgEnum.DataSource    = dt.DefaultView;
                dgEnum.DataBind();

                DropDownList ddl = (DropDownList)dgEnum.Items[dgEnum.EditItemIndex].FindControl("ddlOrder");
                if (ddl != null)
                {
                    for (int i = 1; i <= dgEnum.Items.Count; i++)
                    {
                        ddl.Items.Add(i.ToString());
                    }
                    ddl.SelectedIndex = dgEnum.EditItemIndex;
                }
            }
            else
            {
                DictionaryTypes dic = (DictionaryTypes)Enum.Parse(typeof(DictionaryTypes), ddDictionaries.SelectedItem.Value);

                DataTable dt = Dictionaries.GetList(dic);

                DataRow dr = dt.NewRow();
                dr["ItemId"]    = -1;
                dr["ItemName"]  = "";
                dr["Weight"]    = 0;
                dr["CanDelete"] = 0;
                dt.Rows.Add(dr);

                dgDic.EditItemIndex = dt.Rows.Count - 1;
                dgDic.DataSource    = dt.DefaultView;
                dgDic.DataBind();
            }
        }
Esempio n. 14
0
        private void BindDG()
        {
            if (ddDictionaries.SelectedValue == "0")            //Business Score
            {
                dgScore.Visible               = true;
                dgPlanSlot.Visible            = false;
                dgDic.Visible                 = false;
                dgEnum.Visible                = false;
                dgScore.Columns[1].HeaderText = LocRM.GetString("tKey");
                dgScore.Columns[2].HeaderText = LocRM.GetString("Name");

                dgScore.DataSource = GetTable(BusinessScore.List()).DefaultView;
                dgScore.DataBind();

                foreach (DataGridItem dgi in dgScore.Items)
                {
                    ImageButton ib = (ImageButton)dgi.FindControl("ibDelete2");
                    if (ib != null)
                    {
                        ib.Attributes.Add("onclick", "return confirm('" + LocRM.GetString("Warning") + "')");
                    }

                    RequiredFieldValidator rf = (RequiredFieldValidator)dgi.FindControl("rfKey");
                    if (rf != null)
                    {
                        rf.ErrorMessage = LocRM.GetString("Required");
                    }

                    RequiredFieldValidator rf2 = (RequiredFieldValidator)dgi.FindControl("rfName2");
                    if (rf2 != null)
                    {
                        rf2.ErrorMessage = LocRM.GetString("Required");
                    }
                }
            }
            else if (ddDictionaries.SelectedValue == "-1")            //Base Plan Slot
            {
                dgScore.Visible    = false;
                dgDic.Visible      = false;
                dgPlanSlot.Visible = true;
                dgEnum.Visible     = false;
                dgPlanSlot.Columns[1].HeaderText = LocRM.GetString("Name");
                dgPlanSlot.Columns[2].HeaderText = LocRM.GetString("tIsDefault");

                dgPlanSlot.DataSource = GetTableSlot(BasePlanSlot.List()).DefaultView;
                dgPlanSlot.DataBind();

                foreach (DataGridItem dgi in dgPlanSlot.Items)
                {
                    ImageButton ib = (ImageButton)dgi.FindControl("ibDelete3");
                    if (ib != null)
                    {
                        ib.Attributes.Add("onclick", "return confirm('" + LocRM.GetString("Warning") + "')");
                    }

                    RequiredFieldValidator rf3 = (RequiredFieldValidator)dgi.FindControl("rfName3");
                    if (rf3 != null)
                    {
                        rf3.ErrorMessage = LocRM.GetString("Required");
                    }
                }
            }
            else if (ddDictionaries.SelectedValue == ListManager.ListTypeEnumName)              //List Types
            {
                dgScore.Visible    = false;
                dgPlanSlot.Visible = false;
                dgDic.Visible      = false;
                dgEnum.Visible     = true;

                dgEnum.DataSource = GetListTable().DefaultView;
                dgEnum.DataBind();

                foreach (DataGridItem row in dgEnum.Items)
                {
                    ImageButton ib = (ImageButton)row.FindControl("ibDelete");
                    if (ib != null)
                    {
                        ib.Attributes.Add("onclick", "return confirm('" + GetGlobalResourceObject("IbnFramework.GlobalMetaInfo", "Delete").ToString() + "?')");
                    }
                    TextBox   tb = (TextBox)row.FindControl("txtName");
                    HtmlImage im = (HtmlImage)row.FindControl("imResourceTemplate");
                    RequiredFieldValidator rfv = (RequiredFieldValidator)row.FindControl("rfName");
                    if (im != null && tb != null && rfv != null)
                    {
                        im.Attributes.Add("onclick", "SetText('" + tb.ClientID + "','{ResourceName:ResourceKey}','" + rfv.ClientID + "')");
                    }
                }

                if (dgEnum.EditItemIndex >= 0)
                {
                    DropDownList ddl = (DropDownList)dgEnum.Items[dgEnum.EditItemIndex].FindControl("ddlOrder");
                    if (ddl != null)
                    {
                        for (int i = 1; i <= dgEnum.Items.Count; i++)
                        {
                            ddl.Items.Add(i.ToString());
                        }
                        ddl.SelectedIndex = dgEnum.EditItemIndex;
                    }
                }
            }
            else
            {
                dgScore.Visible             = false;
                dgPlanSlot.Visible          = false;
                dgDic.Visible               = true;
                dgEnum.Visible              = false;
                dgDic.Columns[1].HeaderText = LocRM.GetString("Name");
                dgDic.Columns[2].HeaderText = LocRM.GetString("tWeight");
                //dgDic.Columns[3].HeaderText = LocRM.GetString("Options");

                DictionaryTypes dic = (DictionaryTypes)Enum.Parse(typeof(DictionaryTypes), ddDictionaries.SelectedItem.Value);
                DataView        dv  = Dictionaries.GetList(dic).DefaultView;
                //			dv.Sort = "ItemName";
                dgDic.DataSource = dv;
                dgDic.DataBind();

                foreach (DataGridItem dgi in dgDic.Items)
                {
                    ImageButton ib = (ImageButton)dgi.FindControl("ibDelete");
                    if (ib != null)
                    {
                        ib.Attributes.Add("onclick", "return confirm('" + LocRM.GetString("Warning") + "')");
                    }

                    RequiredFieldValidator rf = (RequiredFieldValidator)dgi.FindControl("rfName");
                    if (rf != null)
                    {
                        rf.ErrorMessage = LocRM.GetString("Required");
                    }
                }
            }
        }
Esempio n. 15
0
 /// <summary>
 /// Check if the type is a dictionary.
 /// </summary>
 public static bool IsDictionary(Type type)
 {
     return(DictionaryTypes.Contains(type));
 }
Esempio n. 16
0
 public static void UpdateItem(int ItemId, string ItemName, DictionaryTypes dict)
 {
     UpdateItem(ItemId, ItemName, 0, dict);
 }
Esempio n. 17
0
 public static void UpdateItem(int ItemId, string ItemName, DictionaryTypes dict)
 {
     UpdateItem(ItemId, ItemName, 0, dict);
 }
Esempio n. 18
0
        private void AddTypeExtension(ref StringBuilderWrapper sbExt, MetadataType type, bool initCollections)
        {
            var typeName = Type(type.Name, type.GenericArgs);

            var typeNameOnly = typeName.SplitOnFirst('<')[0];

            sbExt.AppendLine();
            sbExt.AppendLine("extension {0} : JsonSerializable".Fmt(typeNameOnly));
            sbExt.AppendLine("{");
            sbExt = sbExt.Indent();

            //func typeConfig()
            sbExt.AppendLine("public class func typeConfig() -> JsConfigType<{0}>".Fmt(typeName));
            sbExt.AppendLine("{");
            sbExt = sbExt.Indent();
            sbExt.AppendLine(
                "return JsConfig.typeConfig() ?? JsConfig.configure(JsConfigType<{0}>(".Fmt(typeName));
            sbExt = sbExt.Indent();

            sbExt.AppendLine("writers: [");
            sbExt = sbExt.Indent();
            foreach (var prop in type.Properties.Safe())
            {
                var isOptional = !(initCollections &&
                                   (prop.IsArray() ||
                                    (!prop.GenericArgs.IsEmpty() &&
                                     (ArrayTypes.Contains(prop.Type) || DictionaryTypes.Contains(prop.Type)))
                                   ));
                var fn = isOptional ? "setOptionalValue" : "setValue";

                sbExt.AppendLine("(\"{1}\", {{ (x:{0}, map:NSDictionary) in {2}(&x.{1}, map, \"{1}\") }}),".Fmt(
                                     typeName, prop.Name.SafeToken().PropertyStyle(), fn));
            }
            sbExt = sbExt.UnIndent();
            sbExt.AppendLine("],");

            sbExt.AppendLine("readers: [");
            sbExt = sbExt.Indent();
            foreach (var prop in type.Properties.Safe())
            {
                sbExt.AppendLine("(\"{1}\", {{ (x:{0}) in x.{1} as Any }}),".Fmt(
                                     typeName,
                                     prop.Name.SafeToken().PropertyStyle()));
            }
            sbExt = sbExt.UnIndent();
            sbExt.AppendLine("]");

            sbExt = sbExt.UnIndent();

            sbExt.AppendLine("))");

            sbExt = sbExt.UnIndent();
            sbExt.AppendLine("}");

            //toJson()
            sbExt.AppendLine();
            sbExt.AppendLine("public func toJson() -> String");
            sbExt.AppendLine("{");
            sbExt = sbExt.Indent();
            sbExt.AppendLine("return serializeToJson(self, {0}.typeConfig())".Fmt(typeName));
            sbExt = sbExt.UnIndent();
            sbExt.AppendLine("}");

            //fromDictionary()
            sbExt.AppendLine();
            sbExt.AppendLine("public class func fromDictionary(map:NSDictionary) -> {0}".Fmt(typeName));
            sbExt.AppendLine("{");
            sbExt = sbExt.Indent();
            sbExt.AppendLine("return populate({0}(), map, {0}.typeConfig())".Fmt(typeName));
            sbExt = sbExt.UnIndent();
            sbExt.AppendLine("}");

            //fromJson()
            sbExt.AppendLine();
            sbExt.AppendLine("public class func fromJson(json:String) -> {0}".Fmt(typeName));
            sbExt.AppendLine("{");
            sbExt = sbExt.Indent();
            sbExt.AppendLine("return populate({0}(), json, {0}.typeConfig())".Fmt(typeName));
            sbExt = sbExt.UnIndent();
            sbExt.AppendLine("}");

            sbExt = sbExt.UnIndent();
            sbExt.AppendLine("}");
        }
Esempio n. 19
0
        private void AddTypeExtension(ref StringBuilderWrapper sbExt, MetadataType type, bool initCollections)
        {
            //Swift doesn't support extensions on same protocol used by Base and Sub types
            if (Config.FlattenAbstractTypes && type.IsAbstract())
            {
                return;
            }

            var typeProperties = type.Properties.Safe().ToList();

            if (Config.FlattenAbstractTypes)
            {
                var baseType = FindType(type.Inherits);
                if (baseType != null && baseType.IsAbstract())
                {
                    typeProperties.InsertRange(0, baseType.Properties.Safe());
                }
            }

            var typeName = Type(type.Name, type.GenericArgs);

            var typeNameOnly = typeName.SplitOnFirst('<')[0];

            sbExt.AppendLine();
            sbExt.AppendLine("extension {0} : JsonSerializable".Fmt(typeNameOnly));
            sbExt.AppendLine("{");
            sbExt = sbExt.Indent();

            //func typeConfig()
            sbExt.AppendLine("public class func typeConfig() -> JsConfigType<{0}>".Fmt(typeName));
            sbExt.AppendLine("{");
            sbExt = sbExt.Indent();
            sbExt.AppendLine(
                "return JsConfig.typeConfig() ?? JsConfig.configure(JsConfigType<{0}>(".Fmt(typeName));
            sbExt = sbExt.Indent();

            sbExt.AppendLine("writers: [");
            sbExt = sbExt.Indent();

            foreach (var prop in typeProperties)
            {
                var isOptional = !(initCollections &&
                                   (prop.IsArray() ||
                                    (!prop.GenericArgs.IsEmpty() &&
                                     (ArrayTypes.Contains(prop.Type) || DictionaryTypes.Contains(prop.Type)))
                                   ));
                var fn = isOptional ? "setOptionalValue" : "setValue";

                sbExt.AppendLine("(\"{1}\", {{ (x:{0}, map:NSDictionary) in {2}(&x.{1}, map, \"{1}\") }}),".Fmt(
                                     typeName, prop.Name.SafeToken().PropertyStyle(), fn));
            }
            sbExt = sbExt.UnIndent();
            sbExt.AppendLine("],");

            sbExt.AppendLine("readers: [");
            sbExt = sbExt.Indent();
            foreach (var prop in typeProperties)
            {
                sbExt.AppendLine("(\"{1}\", Type<{0}>.value {{ $0.{1} }}),".Fmt(
                                     typeName,
                                     prop.Name.SafeToken().PropertyStyle()));
            }
            sbExt = sbExt.UnIndent();
            sbExt.AppendLine("]");

            sbExt = sbExt.UnIndent();

            sbExt.AppendLine("))");

            sbExt = sbExt.UnIndent();
            sbExt.AppendLine("}");

            //toJson()
            sbExt.AppendLine();
            sbExt.AppendLine("public func toJson() -> String");
            sbExt.AppendLine("{");
            sbExt = sbExt.Indent();
            sbExt.AppendLine("return serializeToJson(self, {0}.typeConfig())".Fmt(typeName));
            sbExt = sbExt.UnIndent();
            sbExt.AppendLine("}");

            //fromDictionary()
            sbExt.AppendLine();
            sbExt.AppendLine("public class func fromDictionary(map:NSDictionary) -> {0}".Fmt(typeName));
            sbExt.AppendLine("{");
            sbExt = sbExt.Indent();
            sbExt.AppendLine("return populate({0}(), map, {0}.typeConfig())".Fmt(typeName));
            sbExt = sbExt.UnIndent();
            sbExt.AppendLine("}");

            //fromJson()
            sbExt.AppendLine();
            sbExt.AppendLine("public class func fromJson(json:String) -> {0}".Fmt(typeName));
            sbExt.AppendLine("{");
            sbExt = sbExt.Indent();
            sbExt.AppendLine("return populate({0}(), json, {0}.typeConfig())".Fmt(typeName));
            sbExt = sbExt.UnIndent();
            sbExt.AppendLine("}");

            sbExt = sbExt.UnIndent();
            sbExt.AppendLine("}");
        }
Esempio n. 20
0
        private void dg_update(object source, System.Web.UI.WebControls.DataGridCommandEventArgs e)
        {
            string dictionaryName = ddDictionaries.SelectedItem.Value;

            if (dictionaryName == ListManager.ListTypeEnumName)
            {
                MetaFieldType mft = Mediachase.Ibn.Core.MetaDataWrapper.GetEnumByName(dictionaryName);

                int ItemId = int.Parse(e.CommandArgument.ToString());

                TextBox      tb      = (TextBox)e.Item.FindControl("txtName");
                DropDownList ddl     = (DropDownList)e.Item.FindControl("ddlOrder");
                int          OrderId = int.Parse(ddl.SelectedValue);

                if (tb != null && tb.Text.Trim() != String.Empty)
                {
                    if (ItemId > 0)
                    {
                        MetaEnum.UpdateItem(mft, ItemId, tb.Text.Trim(), OrderId);
                    }
                    else
                    {
                        MetaEnum.AddItem(mft, tb.Text.Trim(), OrderId);
                    }
                }
                dgEnum.EditItemIndex = -1;
            }
            else
            {
                int             ItemID  = int.Parse(e.Item.Cells[0].Text);
                DictionaryTypes dic     = (DictionaryTypes)Enum.Parse(typeof(DictionaryTypes), ddDictionaries.SelectedItem.Value);
                TextBox         tb      = (TextBox)e.Item.FindControl("tbName");
                int             _weight = 0;
                TextBox         tbW     = (TextBox)e.Item.FindControl("tbWeight");
                if (tbW != null && tbW.Text.Length > 0)
                {
                    _weight = int.Parse(tbW.Text);
                }
                if (tb != null)
                {
                    try
                    {
                        if (ItemID > 0)
                        {
                            Dictionaries.UpdateItem(ItemID, tb.Text, _weight, dic);
                        }
                        else
                        {
                            Dictionaries.AddItem(tb.Text, _weight, dic);
                        }
                    }
                    catch (SqlException ex)
                    {
                        if (ex.Number == 2627)                          // Violation of UNIQUE KEY
                        {
                            lblError.Visible = true;
                            lblError.Text    = "<br><br>" + LocRM.GetString("Duplication");
                        }
                    }
                }
                dgDic.EditItemIndex = -1;
            }

            BindDG();
        }
Esempio n. 21
0
        private void AddTypeExtension(ref StringBuilderWrapper sbExt, MetadataType type, bool initCollections)
        {
            //Swift doesn't support extensions on same protocol used by Base and Sub types
            if (type.IsAbstract())
            {
                return;
            }

            var typeName = Type(type.Name, type.GenericArgs);

            var typeNameOnly = typeName.SplitOnFirst('<')[0];

            sbExt.AppendLine();
            sbExt.AppendLine("extension {0} : JsonSerializable".Fmt(typeNameOnly));
            sbExt.AppendLine("{");
            sbExt = sbExt.Indent();

            sbExt.AppendLine("public static var typeName:String {{ return \"{0}\" }}".Fmt(typeName));

            //func typeConfig()

            var isGenericType = !type.GenericArgs.IsEmpty();

            if (!isGenericType)
            {
                sbExt.AppendLine("public static var metadata = Metadata.create([");
                sbExt = sbExt.Indent();
            }
            else
            {
                //Swift 2.0 doesn't allow stored static properties on generic types yet
                sbExt.AppendLine("public static var metadata:Metadata {");
                sbExt = sbExt.Indent();
                sbExt.AppendLine("return Metadata.create([");
            }

            sbExt = sbExt.Indent();

            foreach (var prop in GetPropertes(type))
            {
                var propType = FindType(prop.Type, prop.TypeNamespace, prop.GenericArgs);
                if (propType.IsInterface() ||
                    IgnorePropertyTypeNames.Contains(prop.Type) ||
                    IgnorePropertyNames.Contains(prop.Name))
                {
                    continue;
                }

                var fnName = "property";
                if (prop.IsArray() || ArrayTypes.Contains(prop.Type))
                {
                    fnName = initCollections
                        ? "arrayProperty"
                        : "optionalArrayProperty";
                }
                else if (DictionaryTypes.Contains(prop.Type))
                {
                    fnName = initCollections
                        ? "objectProperty"
                        : "optionalObjectProperty";
                }
                else
                {
                    if (propType != null && !propType.IsEnum.GetValueOrDefault())
                    {
                        fnName = "optionalObjectProperty";
                    }
                    else
                    {
                        fnName = "optionalProperty";
                    }
                }

                sbExt.AppendLine("Type<{0}>.{1}(\"{2}\", get: {{ $0.{2} }}, set: {{ $0.{2} = $1 }}),".Fmt(
                                     typeName, fnName, prop.Name.SafeToken().PropertyStyle()));
            }
            sbExt = sbExt.UnIndent();
            sbExt.AppendLine("])");
            sbExt = sbExt.UnIndent();

            if (isGenericType)
            {
                sbExt.AppendLine("}");
            }

            sbExt = sbExt.UnIndent();
            sbExt.AppendLine("}");
        }
Esempio n. 22
0
 public static void AddItem(string ItemName, DictionaryTypes dict)
 {
     AddItem(ItemName, 0, dict);
 }
Esempio n. 23
0
 public static void UpdateItem(int ItemId, string ItemName, int Param, DictionaryTypes dict)
 {
     switch(dict)
     {
         case DictionaryTypes.Categories:
             DBCommon.UpdateCategory(ItemId, ItemName);
             break;
         case DictionaryTypes.IncidentSeverities:
             DBIncident.UpdateIncidentSeverity(ItemId, ItemName);
             break;
         case DictionaryTypes.IncidentTypes:
             DBIncident.UpdateIncidentType(ItemId, ItemName);
             break;
         case DictionaryTypes.ProjectTypes:
             UpdateProjectType(ItemId, ItemName);
             break;
     //				case DictionaryTypes.Clients:
     //					DBProject.UpdateClient(ItemId, ItemName);
     //					break;
         case DictionaryTypes.ProjectCategories:
             DBProject.UpdateProjectCategory(ItemId, ItemName);
             break;
         case DictionaryTypes.IncidentCategories:
             DBIncident.UpdateIncidentCategory(ItemId, ItemName);
             break;
         case DictionaryTypes.Currency:
             DBCommon.UpdateCurrency(ItemId, ItemName);
             break;
         case DictionaryTypes.DocumentStatus:
             DBDocument.UpdateDocumentStatus(ItemId, ItemName, Param);
             break;
         case DictionaryTypes.ProjectPhases:
             DBProject.UpdateProjectPhase(ItemId, ItemName, Param);
             break;
         case DictionaryTypes.RiskLevels:
             DBProject.UpdateRiskLevel(ItemId, ItemName, Param);
             break;
     }
 }
Esempio n. 24
0
        private void AddTypeExtension(ref StringBuilderWrapper sbExt, MetadataType type, bool initCollections)
        {
            //Swift doesn't support extensions on same protocol used by Base and Sub types
            if (type.IsAbstract())
            {
                return;
            }

            var typeName = Type(type.Name, type.GenericArgs);

            var typeNameOnly = typeName.SplitOnFirst('<')[0];

            sbExt.AppendLine();
            sbExt.AppendLine("extension {0} : JsonSerializable".Fmt(typeNameOnly));
            sbExt.AppendLine("{");
            sbExt = sbExt.Indent();

            sbExt.AppendLine("public class var typeName:String {{ return \"{0}\" }}".Fmt(typeName));

            //func typeConfig()
            sbExt.AppendLine("public class func reflect() -> Type<{0}> {{".Fmt(typeName));
            sbExt = sbExt.Indent();
            sbExt.AppendLine(
                "return TypeConfig.config() ?? TypeConfig.configure(Type<{0}>(".Fmt(typeName));
            sbExt = sbExt.Indent();

            sbExt.AppendLine("properties: [".Fmt(typeName));
            sbExt = sbExt.Indent();

            foreach (var prop in GetPropertes(type))
            {
                var propType = FindType(prop.Type, prop.TypeNamespace, prop.GenericArgs);
                if (propType.IsInterface() ||
                    IgnorePropertyTypeNames.Contains(prop.Type) ||
                    IgnorePropertyNames.Contains(prop.Name))
                {
                    continue;
                }

                var fnName = "property";
                if (prop.IsArray() || ArrayTypes.Contains(prop.Type))
                {
                    fnName = initCollections
                        ? "arrayProperty"
                        : "optionalArrayProperty";
                }
                else if (DictionaryTypes.Contains(prop.Type))
                {
                    fnName = initCollections
                        ? "objectProperty"
                        : "optionalObjectProperty";
                }
                else
                {
                    if (propType != null && !propType.IsEnum.GetValueOrDefault())
                    {
                        fnName = "optionalObjectProperty";
                    }
                    else
                    {
                        fnName = "optionalProperty";
                    }
                }

                sbExt.AppendLine("Type<{0}>.{1}(\"{2}\", get: {{ $0.{2} }}, set: {{ $0.{2} = $1 }}),".Fmt(
                                     typeName, fnName, prop.Name.SafeToken().PropertyStyle()));
            }
            sbExt = sbExt.UnIndent();
            sbExt.AppendLine("]))");

            sbExt = sbExt.UnIndent();
            sbExt = sbExt.UnIndent();
            sbExt.AppendLine("}");


            //toJson()
            sbExt.AppendLine("public func toJson() -> String {");
            sbExt = sbExt.Indent();
            sbExt.AppendLine("return {0}.reflect().toJson(self)".Fmt(typeName));
            sbExt = sbExt.UnIndent();
            sbExt.AppendLine("}");

            //fromJson()
            sbExt.AppendLine("public class func fromJson(json:String) -> {0}? {{".Fmt(typeName));
            sbExt = sbExt.Indent();
            sbExt.AppendLine("return {0}.reflect().fromJson({0}(), json: json)".Fmt(typeName));
            sbExt = sbExt.UnIndent();
            sbExt.AppendLine("}");

            //fromObject()
            sbExt.AppendLine("public class func fromObject(any:AnyObject) -> {0}? {{".Fmt(typeName));
            sbExt = sbExt.Indent();
            sbExt.AppendLine("return {0}.reflect().fromObject({0}(), any:any)".Fmt(typeName));
            sbExt = sbExt.UnIndent();
            sbExt.AppendLine("}");

            //toString()
            sbExt.AppendLine("public func toString() -> String {");
            sbExt = sbExt.Indent();
            sbExt.AppendLine("return {0}.reflect().toString(self)".Fmt(typeName));
            sbExt = sbExt.UnIndent();
            sbExt.AppendLine("}");

            //fromString()
            sbExt.AppendLine("public class func fromString(string:String) -> {0}? {{".Fmt(typeName));
            sbExt = sbExt.Indent();
            sbExt.AppendLine("return {0}.reflect().fromString({0}(), string: string)".Fmt(typeName));
            sbExt = sbExt.UnIndent();
            sbExt.AppendLine("}");

            sbExt = sbExt.UnIndent();
            sbExt.AppendLine("}");
        }
Esempio n. 25
0
        public void AddProperties(StringBuilderWrapper sb, MetadataType type, bool initCollections)
        {
            var wasAdded = false;

            var dataMemberIndex = 1;

            if (type.Properties != null)
            {
                foreach (var prop in type.Properties)
                {
                    if (wasAdded)
                    {
                        sb.AppendLine();
                    }

                    var propType     = Type(prop.Type, prop.GenericArgs);
                    var optional     = "";
                    var defaultValue = "";
                    if (propType.EndsWith("?"))
                    {
                        propType = propType.Substring(0, propType.Length - 1);
                        optional = "?";
                    }
                    if (Config.MakePropertiesOptional)
                    {
                        optional = "?";
                    }

                    if (prop.Attributes.Safe().FirstOrDefault(x => x.Name == "Required") != null)
                    {
                        optional = "?"; //always use optional
                    }

                    if (prop.IsArray())
                    {
                        optional     = "";
                        defaultValue = " = []";
                    }
                    else if (initCollections && !prop.GenericArgs.IsEmpty())
                    {
                        if (ArrayTypes.Contains(prop.Type))
                        {
                            optional     = "";
                            defaultValue = " = []";
                        }
                        if (DictionaryTypes.Contains(prop.Type))
                        {
                            optional     = "";
                            defaultValue = " = [:]";
                        }
                    }

                    wasAdded = AppendDataMember(sb, prop.DataMember, dataMemberIndex++);
                    wasAdded = AppendAttributes(sb, prop.Attributes) || wasAdded;

                    if (type.IsInterface())
                    {
                        sb.AppendLine("var {0}:{1}{2} {{ get set }}".Fmt(
                                          prop.Name.SafeToken().PropertyStyle(), propType, optional));
                    }
                    else
                    {
                        sb.AppendLine("public var {0}:{1}{2}{3}".Fmt(
                                          prop.Name.SafeToken().PropertyStyle(), propType, optional, defaultValue));
                    }
                }
            }

            if (Config.AddResponseStatus &&
                (type.Properties == null ||
                 type.Properties.All(x => x.Name != "ResponseStatus")))
            {
                if (wasAdded)
                {
                    sb.AppendLine();
                }

                AppendDataMember(sb, null, dataMemberIndex++);
                sb.AppendLine("public var {0}:ResponseStatus".Fmt("ResponseStatus".PropertyStyle()));
            }
        }
Esempio n. 26
0
        /// <summary>
        ///		ItemId, ItemName, Weight, StateId, CanDelete (int)
        /// </summary>
        public static DataTable GetList(DictionaryTypes dict)
        {
            DataTable dt = null;
            switch(dict)
            {
                case DictionaryTypes.Categories:
                    dt = DBCommon.GetListCategoriesForDictionaries();
                    break;
                case DictionaryTypes.IncidentSeverities:
                    dt = DBIncident.GetListIncidentSeverityForDictionaries();
                    break;
                case DictionaryTypes.IncidentTypes:
                    dt = DBIncident.GetListIncidentTypesForDictionaries();
                    break;
                case DictionaryTypes.ProjectTypes:
                    dt = DBProject.GetListProjectTypesForDictionaries();
                    break;
                case DictionaryTypes.ProjectCategories:
                    dt = DBProject.GetListProjectCategoriesForDictionaries();
                    break;
                case DictionaryTypes.IncidentCategories:
                    dt = DBIncident.GetListIncidentCategoriesForDictionaries();
                    break;
                case DictionaryTypes.Currency:
                    dt = DBCommon.GetListCurrencyForDictionaries();
                    break;
                case DictionaryTypes.DocumentStatus:
                    dt = DBDocument.GetListDocumentStatusForDictionaries(Security.CurrentUser.LanguageId);
                    break;
                case DictionaryTypes.ProjectPhases:
                    dt = DBProject.GetListProjectPhasesForDictionaries();
                    break;
                case DictionaryTypes.RiskLevels:
                    dt = DBProject.GetListRiskLevelsForDictionaries();
                    break;
            }

            if (dict != DictionaryTypes.ProjectPhases && dict != DictionaryTypes.RiskLevels && dt != null)
                dt.Columns.Add("Weight", typeof(int));

            return dt;
        }
Esempio n. 27
0
        public void AddProperties(StringBuilderWrapper sb, MetadataType type,
                                  bool initCollections, bool includeResponseStatus)
        {
            var wasAdded = false;

            var dataMemberIndex = 1;

            foreach (var prop in type.Properties.Safe())
            {
                if (wasAdded)
                {
                    sb.AppendLine();
                }

                var propTypeName = Type(prop.Type, prop.GenericArgs);
                var propType     = FindType(prop.Type, prop.TypeNamespace, prop.GenericArgs);
                var optional     = "";
                var defaultValue = "";
                if (propTypeName.EndsWith("?"))
                {
                    propTypeName = propTypeName.Substring(0, propTypeName.Length - 1);
                    optional     = "?";
                }
                if (Config.MakePropertiesOptional)
                {
                    optional = "?";
                }

                if (prop.Attributes.Safe().FirstOrDefault(x => x.Name == "Required") != null)
                {
                    optional = "?"; //always use optional
                }

                if (prop.IsArray())
                {
                    optional     = "";
                    defaultValue = " = []";
                }
                else if (initCollections && !prop.GenericArgs.IsEmpty())
                {
                    if (ArrayTypes.Contains(prop.Type))
                    {
                        optional     = "";
                        defaultValue = " = []";
                    }
                    if (DictionaryTypes.Contains(prop.Type))
                    {
                        optional     = "";
                        defaultValue = " = [:]";
                    }
                }

                if (propType.IsInterface() || IgnorePropertyNames.Contains(prop.Name))
                {
                    sb.AppendLine("//{0}:{1} ignored. Swift doesn't support interface properties"
                                  .Fmt(prop.Name.SafeToken().PropertyStyle(), propTypeName));
                    continue;
                }
                else if (IgnorePropertyTypeNames.Contains(propTypeName))
                {
                    sb.AppendLine("//{0}:{1} ignored. Type could not be extended in Swift"
                                  .Fmt(prop.Name.SafeToken().PropertyStyle(), propTypeName));
                    continue;
                }

                wasAdded = AppendDataMember(sb, prop.DataMember, dataMemberIndex++);
                wasAdded = AppendAttributes(sb, prop.Attributes) || wasAdded;

                if (type.IsInterface())
                {
                    sb.AppendLine("var {0}:{1}{2} {{ get set }}".Fmt(
                                      prop.Name.SafeToken().PropertyStyle(), propTypeName, optional));
                }
                else
                {
                    sb.AppendLine("public var {0}:{1}{2}{3}".Fmt(
                                      prop.Name.SafeToken().PropertyStyle(), propTypeName, optional, defaultValue));
                }
            }

            if (includeResponseStatus)
            {
                if (wasAdded)
                {
                    sb.AppendLine();
                }

                AppendDataMember(sb, null, dataMemberIndex++);
                sb.AppendLine("public var {0}:ResponseStatus?".Fmt(typeof(ResponseStatus).Name.PropertyStyle()));
            }
        }
 public DeleteDictionaryItem(DictionaryTypes dictionaryType, long id)
 {
     DictionaryType = dictionaryType;
     Id             = id;
 }