Пример #1
0
    public static void CreateNoteColumn(this SPWeb web, string group, string description, string name, string displayName, int numberOfLines, bool richText = true)
    {
        try
        {
            if (!web.Fields.ContainsField(name))
            {
                string fieldName = web.Fields.Add(name, SPFieldType.Note, false);

                SPFieldMultiLineText field = (SPFieldMultiLineText)web.Fields.GetField(name);

                field.Group         = group;
                field.RichText      = richText;
                field.NumberOfLines = numberOfLines;
                field.StaticName    = name;
                field.Title         = displayName;
                field.NoCrawl       = false;
                field.Description   = description;

                field.Update();
            }
        }
        catch (Exception ex)
        {
            SPDiagnosticsService.Local.WriteTrace(0, new SPDiagnosticsCategory("CORE:HELPERS", TraceSeverity.Unexpected, EventSeverity.Error), TraceSeverity.Unexpected, String.Format("Exception happened in Helpers:CreateNoteColumn. MESSAGE: {0}. EXCEPTION TRACE: {1} ", ex.Message, ex.StackTrace), ex.StackTrace);
        }
    }
Пример #2
0
        protected void AddRichTexField(String FieldName, Boolean Required)
        {
            String RichTextFieldName           = List.Fields.Add(FieldName, SPFieldType.Note, Required);
            SPFieldMultiLineText RichTextField = (SPFieldMultiLineText)List.Fields.GetFieldByInternalName(RichTextFieldName);

            RichTextField.RichText     = true;
            RichTextField.RichTextMode = SPRichTextMode.FullHtml;
            RichTextField.Update();
        }
Пример #3
0
        private SPList EnsureGlymaExportsList()
        {
            bool   isNewList = false;
            SPList list      = Site.EnsureList(GlymaLists.GlymaExportsList, ref isNewList);

            SPField titleColumn = list.Fields[SPBuiltInFieldId.Title];

            titleColumn.Indexed             = true;
            titleColumn.Title               = "WorkItem ID";
            titleColumn.EnforceUniqueValues = true;
            titleColumn.Update();

            bool    isNewColumn  = false;
            SPField exportStatus = list.EnsureColumn(GlymaColumns.ExportStatus, false, ref isNewColumn);

            exportStatus.Required = true;
            exportStatus.Update();

            isNewColumn = false;
            SPField exportType = list.EnsureColumn(GlymaColumns.ExportType, false, ref isNewColumn);

            exportType.Required = true;
            exportType.Update();

            isNewColumn = false;
            SPField mapType = list.EnsureColumn(GlymaColumns.MapType, false, ref isNewColumn);

            mapType.Required = true;
            mapType.Update();

            isNewColumn = false;
            SPField       percentageCompletedField = list.EnsureColumn(GlymaColumns.PercentageComplete, false, ref isNewColumn);
            SPFieldNumber percentComplete          = percentageCompletedField as SPFieldNumber;

            percentComplete.Required         = true;
            percentComplete.ShowAsPercentage = true;
            percentComplete.MaximumValue     = 1;
            percentComplete.MinimumValue     = 0;
            percentComplete.Update();

            isNewColumn = false;
            SPField domainUid = list.EnsureColumn(GlymaColumns.DomainUid, false, ref isNewColumn);

            domainUid.Required = true;
            domainUid.Update();

            isNewColumn = false;
            SPField rootMapUid = list.EnsureColumn(GlymaColumns.RootMapUid, false, ref isNewColumn);

            rootMapUid.Required = true;
            rootMapUid.Update();

            isNewColumn = false;
            SPField exportPropertiesField         = list.EnsureColumn(GlymaColumns.ExportProperties, false, ref isNewColumn);
            SPFieldMultiLineText exportProperties = exportPropertiesField as SPFieldMultiLineText;

            exportProperties.Required   = false;
            exportProperties.AppendOnly = false;
            exportProperties.RichText   = false;
            exportProperties.Update();

            isNewColumn = false;
            SPField logMessagesField         = list.EnsureColumn(GlymaColumns.LogMessages, false, ref isNewColumn);
            SPFieldMultiLineText logMessages = logMessagesField as SPFieldMultiLineText;

            logMessages.Required   = false;
            logMessages.AppendOnly = true;
            logMessages.RichText   = false;
            logMessages.Update();

            SPField lastModifiedField = list.Fields[SPBuiltInFieldId.Modified];

            // Configure the default view for the list.
            SPView defaultView = list.DefaultView;

            defaultView.ViewFields.DeleteAll();
            defaultView.ViewFields.Add(titleColumn);
            defaultView.ViewFields.Add(exportStatus);
            defaultView.ViewFields.Add(exportType);
            defaultView.ViewFields.Add(mapType);
            defaultView.ViewFields.Add(percentComplete);
            defaultView.ViewFields.Add(domainUid);
            defaultView.ViewFields.Add(rootMapUid);
            defaultView.ViewFields.Add(exportProperties);
            defaultView.ViewFields.Add(logMessages);
            defaultView.Query = "<OrderBy><FieldRef Name=\"" + lastModifiedField.InternalName + "\" Ascending=\"FALSE\" /></OrderBy>";
            defaultView.Update();

            return(list);
        }
Пример #4
0
        //Create Site Columns
        public void CreateSiteColumns()
        {
            using (SPWeb oSPWeb = oSPSite.RootWeb)
            {
                try
                {
                    //if (!oSPWeb.Fields.ContainsField("Codigo"))
                    //{

                    //Codigo de Documento
                    string      codigoField = oSPWeb.Fields.Add("Codigo", SPFieldType.Text, false);
                    SPFieldText Codigo      = (SPFieldText)oSPWeb.Fields.GetFieldByInternalName(codigoField);
                    Codigo.Group = groupColumn;
                    Codigo.Update();
                    //}

                    //if (!oSPWeb.Fields.ContainsField("Referencia"))
                    //{
                    string      referenciaField = oSPWeb.Fields.Add("Referencia", SPFieldType.Text, false);
                    SPFieldText Referencia      = (SPFieldText)oSPWeb.Fields.GetFieldByInternalName(referenciaField);
                    Referencia.Group = groupColumn;
                    Referencia.Update();
                    //}

                    //if (!oSPWeb.Fields.ContainsField("Comentario")) {
                    string      comentarioField = oSPWeb.Fields.Add("Comentario", SPFieldType.Text, false);
                    SPFieldText Comentario      = (SPFieldText)oSPWeb.Fields.GetFieldByInternalName(comentarioField);
                    Comentario.Group = groupColumn;
                    Comentario.Update();
                    //}


                    //if (!oSPWeb.Fields.ContainsField("Remitente"))
                    //{
                    string      remitenteField = oSPWeb.Fields.Add("Remitente", SPFieldType.Text, false);
                    SPFieldText Remitente      = (SPFieldText)oSPWeb.Fields.GetFieldByInternalName(remitenteField);
                    Remitente.Group = groupColumn;
                    Remitente.Update();

                    //}

                    //if (!oSPWeb.Fields.ContainsField("Factura")) {
                    string        facturaField = oSPWeb.Fields.Add("Factura", SPFieldType.Number, false);
                    SPFieldNumber Factura      = (SPFieldNumber)oSPWeb.Fields.GetFieldByInternalName(facturaField);
                    Factura.Group = groupColumn;
                    Factura.Update();
                    //}


                    //if (!oSPWeb.Fields.ContainsField("Fecha Receopcion")) {
                    string          fechaRecepcionField = oSPWeb.Fields.Add("Fecha Recepcion", SPFieldType.DateTime, true);
                    SPFieldDateTime FechaRecepcion      = (SPFieldDateTime)oSPWeb.Fields.GetFieldByInternalName(fechaRecepcionField);
                    FechaRecepcion.Group = groupColumn;
                    FechaRecepcion.Update();

                    //}

                    //Method 3 using Field schema
                    //if (!oSPWeb.Fields.ContainsField("Nota"))
                    //{
                    string notaField          = oSPWeb.Fields.Add("Nota", SPFieldType.Note, false);
                    SPFieldMultiLineText Nota = (SPFieldMultiLineText)oSPWeb.Fields.GetFieldByInternalName(notaField);
                    Nota.Group = groupColumn;
                    Nota.Update();
                    //}

                    //if (!oSPWeb.Fields.ContainsField("Gerencias"))
                    //{

                    // Lookup Column
                    SPList gerenciasList = oSPWeb.Lists.TryGetList("Gerencias");

                    string        GerenciaField  = oSPWeb.Fields.AddLookup("Gerencia", gerenciasList.ID, true);
                    SPFieldLookup gerenciaLookup = (SPFieldLookup)oSPWeb.Fields.GetFieldByInternalName(GerenciaField);

                    gerenciaLookup.Group       = groupColumn;
                    gerenciaLookup.LookupField = "Title";
                    gerenciaLookup.Update();
                    //}

                    SPList listas = oSPWeb.Lists.TryGetList("Listas");
                    //if (!oSPWeb.Fields.ContainsField("Nivel Prioridad"))
                    //{

                    string        nivelPrioridadField  = oSPWeb.Fields.AddLookup("Nivel Prioridad", listas.ID, true);
                    SPFieldLookup nivelPrioridadLookup = (SPFieldLookup)oSPWeb.Fields.GetFieldByInternalName(nivelPrioridadField);
                    nivelPrioridadLookup.Group       = groupColumn;
                    nivelPrioridadLookup.LookupField = "Title";
                    nivelPrioridadLookup.Update();
                    //}

                    //if (!oSPWeb.Fields.ContainsField("Clasificacion"))
                    //{

                    string        clasificacionField  = oSPWeb.Fields.AddLookup("Clasificacion", listas.ID, true);
                    SPFieldLookup clasificacionLookup = (SPFieldLookup)oSPWeb.Fields.GetFieldByInternalName(clasificacionField);
                    clasificacionLookup.Group       = groupColumn;
                    clasificacionLookup.LookupField = "Title";
                    clasificacionLookup.Update();
                    //}

                    //if (!oSPWeb.Fields.ContainsField("Estado"))
                    //{

                    string        estadoField  = oSPWeb.Fields.AddLookup("Estado", listas.ID, false);
                    SPFieldLookup estadoLookup = (SPFieldLookup)oSPWeb.Fields.GetFieldByInternalName(estadoField);
                    estadoLookup.Group       = groupColumn;
                    estadoLookup.LookupField = "Title";
                    estadoLookup.Update();
                    //}
                }
                catch (Exception)
                {
                    throw;
                }
            }
        }
Пример #5
0
        public override void FeatureActivated(SPFeatureReceiverProperties properties)
        {
            SPWeb  web  = (SPWeb)properties.Feature.Parent;
            SPSite site = web.Site;

            web.AllowUnsafeUpdates = true;
            Lists listRoot = GetListsInfo(properties);

            foreach (List listInfo in listRoot.Items)
            {
                SPList tempList = null;
                if (listInfo.name != null)
                {
                    listName = listInfo.name.Trim();
                }
                else
                {
                    throw new Exception(Constants.LIST_NAME_ERROR);
                }
                descName = listInfo.description;
                if (CheckList(web, listName))
                {
                    tempList = web.Lists[web.Lists.Add(listName, descName, SPListTemplateType.GenericList)];
                }
                else
                {
                    tempList = web.Lists[listName];
                }
                if (tempList != null)
                {
                    foreach (Field fields in listInfo.Fields)
                    {
                        SPFieldType fldType = SPFieldType.Text;
                        ClearFlags();

                        if (fields.name != null)
                        {
                            fieldname = fields.name.Trim();
                        }
                        else
                        {
                            throw new Exception(Constants.FIELD_NAME_ERROR + listName);
                        }

                        if (fields.datatype != null)
                        {
                            fieldtype = fields.datatype.Trim();
                        }

                        if (fields.required != null)
                        {
                            required = fields.required.Trim();
                        }

                        if (fields.defaultvalue != null)
                        {
                            defaultValue = fields.defaultvalue.Trim();
                        }

                        if (fields.textformat != null)
                        {
                            textFormat = fields.textformat.Trim();
                        }

                        if (fields.displaychoicesusing != null)
                        {
                            displayChoicesUsing = fields.displaychoicesusing.Trim();
                        }

                        if (fields.lookuplist != null)
                        {
                            lookupList = fields.lookuplist.Trim();
                        }

                        if (fields.lookupfield != null)
                        {
                            lookupfield = fields.lookupfield.Trim();
                        }

                        switch (fieldtype.ToLower())
                        {
                        case Constants.SINGLE_LINE_TEXT_TYPE:
                            fldType = SPFieldType.Text;
                            break;

                        case Constants.MULTIPLE_LINE_TEXT_TYPE:
                            fldType = SPFieldType.Note;
                            break;

                        case Constants.DATETIME_TYPE:
                            fldType = SPFieldType.DateTime;
                            break;

                        case Constants.NUMBER_TYPE:
                            fldType = SPFieldType.Number;
                            break;

                        case Constants.CURRENCY_TYPE:
                            fldType = SPFieldType.Currency;
                            break;

                        case Constants.YESNO_TYPE:
                            fldType = SPFieldType.Boolean;
                            break;

                        case Constants.PERSON_GROUP_TYPE:
                            fldType = SPFieldType.User;
                            break;

                        case Constants.HYPERLINK_PICTURE_TYPE:
                            fldType = SPFieldType.URL;
                            break;

                        case Constants.CHOICE_TYPE:
                            if (displayChoicesUsing.ToLower().Trim().Equals(Constants.MULTICHECKBOX))
                            {
                                fldType = SPFieldType.MultiChoice;
                            }
                            else
                            {
                                fldType = SPFieldType.Choice;
                            }
                            break;

                        case Constants.LOOKUP_TYPE:
                            fldType = SPFieldType.Lookup;
                            break;
                        }

                        SPField field = tempList.Fields.CreateNewField(fldType.ToString(), fieldname);
                        field.DefaultValue = defaultValue;
                        field.Description  = fielddesc;
                        field.Required     = (required.ToLower().Trim().Equals(Constants.YES) ? true : false);

                        if (!tempList.Fields.ContainsField(fieldname))
                        {
                            tempList.Fields.Add(field);
                        }

                        if ((tempList.Fields[fieldname] as SPFieldText) != null)
                        {
                            int maxLength;
                            int.TryParse(maxCount, out maxLength);
                            var fldText = tempList.Fields[fieldname] as SPFieldText;

                            if (fldText != null && maxLength > 0)
                            {
                                fldText.MaxLength = maxLength;
                                fldText.Update();
                                tempList.Update();
                            }

                            continue;
                        }

                        if ((tempList.Fields[fieldname] as SPFieldMultiLineText) != null)
                        {
                            int noOfLines;
                            int.TryParse(NoOfLines, out noOfLines);
                            SPFieldMultiLineText fldMultiText = tempList.Fields[fieldname] as SPFieldMultiLineText;
                            fldMultiText.NumberOfLines = (noOfLines > 0) ? noOfLines : fldMultiText.NumberOfLines;
                            fldMultiText.RichText      = (textFormat.ToLower().Trim().Equals(Constants.RICHTEXT)) ? true : false;
                            fldMultiText.Update();
                            tempList.Update();

                            continue;
                        }

                        if ((tempList.Fields[fieldname] as SPFieldBoolean) != null)
                        {
                            SPFieldBoolean fldBoolean = (tempList.Fields[fieldname]) as SPFieldBoolean;
                            // useful in future
                            tempList.Update();

                            continue;
                        }

                        if ((tempList.Fields[fieldname] as SPFieldUser) != null)
                        {
                            SPFieldUser fldUser = tempList.Fields[fieldname] as SPFieldUser;
                            // useful in future
                            tempList.Update();

                            continue;
                        }

                        if (tempList.Fields[fieldname] as SPFieldMultiChoice != null)
                        {
                            SPFieldMultiChoice fldMultiChoice = tempList.Fields[fieldname] as SPFieldMultiChoice;

                            foreach (Choice choiceNodes in fields.Choices)
                            {
                                fldMultiChoice.Choices.Add(choiceNodes.Value);
                            }
                            fldMultiChoice.Update();
                            tempList.Update();

                            continue;
                        }

                        if ((tempList.Fields[fieldname] as SPFieldChoice) != null)
                        {
                            SPFieldChoice fldChoice = tempList.Fields[fieldname] as SPFieldChoice;

                            if (displayChoicesUsing.ToLower().Trim().Equals(Constants.DROPDOWNMENU))
                            {
                                fldChoice.EditFormat = SPChoiceFormatType.Dropdown;
                            }

                            if (displayChoicesUsing.ToLower().Trim().Equals(Constants.RADIOBUTTONS))
                            {
                                fldChoice.EditFormat = SPChoiceFormatType.RadioButtons;
                            }

                            // Add the choices
                            foreach (Choice choiceNodes in fields.Choices)
                            {
                                fldChoice.Choices.Add(choiceNodes.Value);
                            }
                            fldChoice.Update();
                            tempList.Update();

                            continue;
                        }

                        if ((tempList.Fields[fieldname] as SPFieldLookup) != null)
                        {
                            SPFieldLookup fldLookup  = tempList.Fields[fieldname] as SPFieldLookup;
                            SPList        parentList = web.Lists[lookupList];
                            fldLookup.LookupList  = parentList.ID.ToString();
                            fldLookup.LookupField = parentList.Fields[lookupfield].InternalName;
                            fldLookup.Update();
                            tempList.Update();

                            continue;
                        }
                    }
                }
            }
            web.Update();
            web.AllowUnsafeUpdates = true;
        }