Beispiel #1
0
        private static void AddFieldDateTime(SiteColumn column, SPList listEdit)
        {
            listEdit.Fields.Add(column.Name, column.Type, column.Required);
            var date = (SPFieldDateTime)listEdit.Fields.GetField(column.Name);

            date.DisplayFormat = column.Date == TypeDate.Date
                ? SPDateTimeFieldFormatType.DateOnly
                : SPDateTimeFieldFormatType.DateTime;
            date.Update();
        }
Beispiel #2
0
        /// <summary>
        /// Delete Field
        /// </summary>
        /// <param name="column"></param>
        /// <returns></returns>
        public bool DeleteField(SiteColumn column)
        {
            var listEdit = Web.Lists.TryGetList(Name);

            if (listEdit != null)
            {
                listEdit.Fields.GetField(column.Name).Delete();
            }
            return(true);
        }
Beispiel #3
0
        private static void AddFieldCalculated(SiteColumn column, SPList listEdit)
        {
            listEdit.Fields.Add(column.Name, column.Type, column.Required);
            var calculate = (SPFieldCalculated)listEdit.Fields.GetField(column.Name);

            calculate.Formula = column.Formula;

            calculate.Required = column.Required;

            calculate.Update();
        }
Beispiel #4
0
        private void AddFieldCurrency(SiteColumn column)
        {
            if (string.IsNullOrEmpty(column.GroupName))
            {
                return;
            }
            var field = (SPFieldCurrency)Web.Fields.GetFieldByInternalName(Name);

            field.Group            = column.GroupName;
            field.Required         = column.Required;
            field.CurrencyLocaleId = column.Currency;
            field.Update();
        }
Beispiel #5
0
 /// <summary>
 /// Existe esta Columna de Lista
 /// </summary>
 /// <param name="column"></param>
 /// <returns></returns>
 public bool ExistField(SiteColumn column)
 {
     try
     {
         var listEdit = Web.Lists.TryGetList(Name);
         var spfield  = listEdit.Fields.GetField(column.Name);
         return(spfield != null);
     }
     catch (Exception exception)
     {
         Logger.Error(string.Concat("Error:", exception.Message));
         return(false);
     }
 }
Beispiel #6
0
        /// <summary>
        /// Añadir Campos
        /// </summary>
        /// <param name="column"></param>
        /// <returns></returns>
        public bool AddField(SiteColumn column)
        {
            try
            {
                var listEdit = Web.GetList(SPUrlUtility.CombineUrl(Web.Url, string.Concat("/lists/", Name)));
                switch (column.Type)
                {
                case SPFieldType.Boolean:
                    AddFieldBoolean(column, listEdit);
                    break;

                case SPFieldType.Choice:
                    AddFieldChoice(column, listEdit);
                    break;

                case SPFieldType.DateTime:
                    AddFieldDateTime(column, listEdit);
                    break;

                case SPFieldType.Lookup:
                    AddFieldLookup(column, listEdit);

                    break;

                case SPFieldType.Calculated:
                    AddFieldCalculated(column, listEdit);
                    break;

                case SPFieldType.Currency:
                    Web.Fields.Add(Name, column.Type, column.Required);
                    AddFieldCurrency(column);
                    break;

                default:
                    var item         = listEdit.Fields.Add(column.Name, column.Type, column.Required);
                    var fieldDefault = listEdit.Fields.GetField(item);
                    fieldDefault.Title = column.DisplayName;
                    fieldDefault.Update(true);
                    break;
                }
            }
            catch (Exception exception)
            {
                Logger.Error(string.Concat("Add Field", exception.Message));
                return(false);
            }
            return(true);
        }
Beispiel #7
0
        private static void AddFieldBoolean(SiteColumn column, SPList listEdit)
        {
            listEdit.Fields.Add(column.Name, column.Type, column.Required);
            if (string.IsNullOrEmpty(column.DefaultValue))
            {
                return;
            }
            if (column.DefaultValue != "0" && column.DefaultValue != "1")
            {
                return;
            }
            var boolean = (SPFieldBoolean)listEdit.Fields.GetField(column.Name);

            boolean.DefaultValue = column.DefaultValue;
            boolean.Update();
        }
Beispiel #8
0
        private static void AddFieldChoice(SiteColumn column, SPList listEdit)
        {
            if (column.Choice.Count <= 0)
            {
                return;
            }
            listEdit.Fields.Add(column.Name, column.Type, column.Required, false,
                                column.Choice);
            if (string.IsNullOrEmpty(column.DefaultValue))
            {
                return;
            }
            var choice = (SPFieldChoice)listEdit.Fields.GetField(column.Name);

            choice.DefaultValue = column.DefaultValue;
            choice.Update();
        }
Beispiel #9
0
        private void AddFieldLookup(SiteColumn column, SPList listEdit)
        {
            var targetList =
                Web.GetList(SPUrlUtility.CombineUrl(Web.Url, string.Concat("/lists/", column.TargetListInternalName)));

            listEdit.Fields.AddLookup(column.Name, targetList.ID, column.Required);
            var lookup = (SPFieldLookup)listEdit.Fields.GetField(column.Name);

            lookup.LookupField =
                targetList.Fields[
                    targetList.Fields.GetFieldByInternalName(column.TargetListFieldInternalName).Id]
                .InternalName;
            lookup.Update();
            foreach (var fieldAdditional in column.FieldAdditional)
            {
                var depLookUp      = listEdit.Fields.AddDependentLookup(fieldAdditional, lookup.Id);
                var fieldDepLookup = (SPFieldLookup)listEdit.Fields.GetFieldByInternalName(depLookUp);
                fieldDepLookup.LookupWebId = Web.ParentWeb.ID;
                fieldDepLookup.LookupField =
                    targetList.Fields[targetList.Fields.GetFieldByInternalName(fieldAdditional).Id]
                    .InternalName;
                fieldDepLookup.Update();
            }
        }
 /// <summary>
 /// Create one column site of Taxonomy
 /// </summary>
 /// <param name="args"></param>
 private static bool CreateColumnSiteTaxonomy(ParamsCreateSite args,  SPFieldType type)
 {
     var result = false;
     var columnSite =
         new SiteColumn(new ParamsSiteColumnDefaultValue
         {
             Web = args.Web,
             Name = args.Name,
             FieldType = type,
             Requiered = args.Requiered,
             Group = args.Group,
             AddPrefix = args.AddPrefix,
             DefaultValue = args.DefaultValue
         });
     if (!columnSite.Exist())
     {
         result = columnSite.CreateTaxonomy(args.GroupTerm, args.Term, args.MultiValue, args.Requiered);
     }
     args.Name = (args.AddPrefix) ? string.Concat(Constants.Prefix, args.Name) : args.Name;
     columnSite.RenameField(args.Name,
         string.IsNullOrEmpty(args.DisplayName) 
         ? args.Name 
         : args.DisplayName);
     if (args.Hidden)
     {
         columnSite.Hidden();
     }
     return result;
 }
 private static bool CreateColumnSetParameters(ParamsCreateSite args, SiteColumn columnSite)
 {
     var result = false;
     if (!columnSite.Exist())
     {
         result = columnSite.Create();               
         if (args.Hidden) columnSite.Hidden();
     }
     return result;
 }
        /// <summary>
        /// Create one column site
        /// </summary>
        /// <param name="args"></param>
        private static void CreateColumnSite(ParamsCreateSite args)
        {
            try
            {                
                var type = GetFieldType(args.FieldType);
                if (args.FieldType.Equals("Taxonomy"))
                {
                    CreateColumnSiteTaxonomy(args, type);
                }
                else
                {
                    SiteColumn columnSite;
                    switch (type)
                    {
                        case SPFieldType.MultiChoice:
                        case SPFieldType.Choice:
                            columnSite = new SiteColumn(
                                new ParamsSiteColumnChoices
                                {
                                    Web = args.Web,
                                    Name = args.Name,
                                    FieldType = type,
                                    Choices = args.Choice,
                                    Group = args.Group,
                                    AddPrefix = args.AddPrefix,
                                    DisplayName = args.DisplayName
                                }, args.DefaultValue, args.Requiered);
                            break;
                        case SPFieldType.Calculated:
                            columnSite = new SiteColumn(
                                new ParamsSiteColumnBaseExtended
                                {
                                    Web = args.Web,
                                    Name = args.Name,
                                    FieldType = type,
                                    Requiered = args.Requiered,
                                    Group = args.Group,
                                    AddPrefix = args.AddPrefix,
                                    DisplayName = args.DisplayName
                                }, args.Formula);
                            break;
                        case SPFieldType.Currency:
                            columnSite = new SiteColumn(
                                new ParamsSiteColumnBaseExtended
                            {
                                Web = args.Web,
                                Name = args.Name,
                                FieldType = type,
                                Requiered = args.Requiered,
                                Group = args.Group,
                                AddPrefix = args.AddPrefix,
                                DisplayName = args.DisplayName
                            }, args.FormatCurrency);
                            break;
                        case SPFieldType.DateTime:
                            columnSite = new SiteColumn(
                                new ParamsSiteColumnBaseExtended
                            {
                                Web = args.Web,
                                Name = args.Name,
                                FieldType = type,
                                Requiered = args.Requiered,
                                Group = args.Group,
                                AddPrefix = args.AddPrefix,
                                DisplayName = args.DisplayName
                            }, args.Date);
                            break;
                        default:
                            columnSite = new SiteColumn(
                                new ParamsSiteColumnDefaultValue
                                {
                                Web = args.Web,
                                Name = args.Name,
                                FieldType = type,
                                Requiered = args.Requiered,
                                Group = args.Group,
                                AddPrefix = args.AddPrefix,
                                DefaultValue = args.DefaultValue,
                                MultiValue = args.MultiValue,
                                DisplayName = args.DisplayName
                            });

                            break;
                    }
                    CreateColumnSetParameters(args, columnSite);
                }
                args.Web.Update();                
            }
            catch (Exception exception)
            {
                Logger.Error(string.Concat("Error CreateColumnSite", exception.Message));                
            }
        }
Beispiel #13
0
        private static void CreateColumnInList(ParamsColumnSite args)
        {
            var type = GetFieldType(args.FieldType);
            if (args.FieldType.Equals("Taxonomy"))
            {
                var columnSite = new SiteColumn
                    (new ParamsSiteColumnDefaultValue
                    {
                        Name = args.Name,
                        FieldType = type,
                        Requiered = args.Requiered,
                        Group = args.Group,
                        DefaultValue = args.DefaultValue,
                        AddPrefix = args.AddPrefix
                    });
                args.List.AddField(columnSite);

            }
            else
            {
                SiteColumn columnSite;
                switch (type)
                {
                    case SPFieldType.MultiChoice:
                    case SPFieldType.Choice:
                        columnSite = new SiteColumn(new ParamsSiteColumnChoices
                        {
                            Web = args.List.Web,
                            Name = args.Name,
                            FieldType = type,
                            Choices = args.Choice,
                            Group = args.Group,
                            AddPrefix = args.AddPrefix
                        },
                           args.DefaultValue, args.Requiered);
                        break;
                    default:
                        columnSite = new SiteColumn(new ParamsSiteColumnDefaultValue
                        {
                            Web = args.List.Web,
                            Name = args.Name,
                            FieldType = type,
                            Requiered = args.Requiered,
                            Group = args.Group,
                            DefaultValue = args.DefaultValue,
                            MultiValue = args.MultiValue,
                            AddPrefix = args.AddPrefix
                        });
                        break;
                }

                if (!args.List.ExistField(columnSite))
                {
                    args.List.AddField(columnSite);
                }


            }
        }
 /// <summary>
 /// Delete Field
 /// </summary>
 /// <param name="column"></param>
 /// <returns></returns>
 public bool DeleteField(SiteColumn column)
 {
     var listEdit = Web.Lists.TryGetList(Name);
     if (listEdit != null)
     {
         listEdit.Fields.GetField(column.Name).Delete();
     }         
     return true;
 }
 /// <summary>
 /// Existe esta Columna de Lista
 /// </summary>
 /// <param name="column"></param>
 /// <returns></returns>
 public bool ExistField(SiteColumn column)
 {
     try
     {
         var listEdit = Web.Lists.TryGetList(Name);
         var spfield = listEdit.Fields.GetField(column.Name);
         return spfield != null;
     }
     catch (Exception exception)
     {
         Logger.Error(string.Concat("Error:", exception.Message));
         return false;
     }
 }
        /// <summary>
        /// Añadir Campos
        /// </summary>
        /// <param name="column"></param>
        /// <returns></returns>
        public bool AddField(SiteColumn column)
        {
            try
            {
                var listEdit = Web.GetList(SPUrlUtility.CombineUrl(Web.Url, string.Concat("/lists/", Name)));
                switch (column.Type)
                {
                    case SPFieldType.Boolean:
                        AddFieldBoolean(column, listEdit);
                        break;
                    case SPFieldType.Choice:
                        AddFieldChoice(column, listEdit);
                        break;
                    case SPFieldType.DateTime:
                        AddFieldDateTime(column, listEdit);
                        break;
                    case SPFieldType.Lookup:
                        AddFieldLookup(column, listEdit);

                        break;
                    case SPFieldType.Calculated:
                        AddFieldCalculated(column, listEdit);
                        break;

                    case SPFieldType.Currency:
                        Web.Fields.Add(Name, column.Type, column.Required);
                        AddFieldCurrency(column);
                        break;
                    default:
                        var item= listEdit.Fields.Add(column.Name, column.Type, column.Required);
                        var fieldDefault = listEdit.Fields.GetField(item);
                        fieldDefault.Title = column.DisplayName;
                        fieldDefault.Update(true);
                        break;
                }
            }
            catch (Exception exception)
            {
                Logger.Error(string.Concat("Add Field", exception.Message));
                return false;
            }
            return true;
        }
        private static void AddFieldCalculated(SiteColumn column, SPList listEdit)
        {
            listEdit.Fields.Add(column.Name, column.Type, column.Required);
            var calculate = (SPFieldCalculated)listEdit.Fields.GetField(column.Name);
            calculate.Formula = column.Formula;
            calculate.Title = column.DisplayName;
            calculate.Required = column.Required;

            calculate.Update();
        }
        private void AddFieldLookup(SiteColumn column, SPList listEdit)
        {
            var targetList =
                Web.GetList(SPUrlUtility.CombineUrl(Web.Url, string.Concat("/lists/", column.TargetListInternalName)));

            listEdit.Fields.AddLookup(column.Name, targetList.ID, column.Required);
            var lookup = (SPFieldLookup)listEdit.Fields.GetField(column.Name);
            lookup.LookupField =
                targetList.Fields[
                    targetList.Fields.GetFieldByInternalName(column.TargetListFieldInternalName).Id]
                    .InternalName;
            lookup.Update();
            foreach (var fieldAdditional in column.FieldAdditional)
            {
                var depLookUp = listEdit.Fields.AddDependentLookup(fieldAdditional, lookup.Id);
                var fieldDepLookup = (SPFieldLookup)listEdit.Fields.GetFieldByInternalName(depLookUp);
                fieldDepLookup.LookupWebId = Web.ParentWeb.ID;
                fieldDepLookup.LookupField =
                    targetList.Fields[targetList.Fields.GetFieldByInternalName(fieldAdditional).Id]
                        .InternalName;
                fieldDepLookup.Update();
            }
        }
 private void AddFieldCurrency(SiteColumn column)
 {
     if (string.IsNullOrEmpty(column.GroupName))
     {
         return;
     }
     var field = (SPFieldCurrency)Web.Fields.GetFieldByInternalName(Name);
     field.Title = column.DisplayName;
     field.Group = column.GroupName;
     field.Required = column.Required;
     field.CurrencyLocaleId = column.Currency;
     field.Update();
 }
 private static void AddFieldBoolean(SiteColumn column, SPList listEdit)
 {
     listEdit.Fields.Add(column.Name, column.Type, column.Required);
     if (string.IsNullOrEmpty(column.DefaultValue))
     {
         return;
     }
     if (column.DefaultValue != "0" && column.DefaultValue != "1")
     {
         return;
     }
     var boolean = (SPFieldBoolean)listEdit.Fields.GetField(column.Name);
     boolean.DefaultValue = column.DefaultValue;
     boolean.Title = column.DisplayName;
     boolean.Update();
 }
 private static void AddFieldChoice(SiteColumn column, SPList listEdit)
 {
     if (column.Choice.Count <= 0)
     {
         return;
     }
     listEdit.Fields.Add(column.Name, column.Type, column.Required, false,
         column.Choice);
     if (string.IsNullOrEmpty(column.DefaultValue))
     {
         return;
     }
     var choice = (SPFieldChoice)listEdit.Fields.GetField(column.Name);
     choice.Title = column.DisplayName;
     choice.DefaultValue = column.DefaultValue;
     choice.Update();
 }
 private static void AddFieldDateTime(SiteColumn column, SPList listEdit)
 {
     listEdit.Fields.Add(column.Name, column.Type, column.Required);
     var date = (SPFieldDateTime)listEdit.Fields.GetField(column.Name);
     date.DisplayFormat = column.Date == TypeDate.Date
         ? SPDateTimeFieldFormatType.DateOnly
         : SPDateTimeFieldFormatType.DateTime;
     date.Title = column.DisplayName;
     date.Update();
 }