Antoine.MOSS2007

How To Delete an “Orphan” Content Type?

2009-11-06T14:50:00.001+01:00

Problem

I created a set of content types from a feature and after the installation, activation of this feature, I used (in list or document libraries) all content types contained in this feature but one, called CT1 for instance

After a while, I wanted to remove the never used content type, so I modified the feature, removed the content type CT1 from it, reinstalled the feature.

The content type CT1 was still in the content types list! Ok, no problem, from the UI I click on delete this content type, and…

The content type "CT1" is part of an application feature.

What a message! I removed it from the feature, but still, I have this error. I googled a lot and with the help of Vincent Rothwell I finally found a solution, not Microsoft allowed, but efficient!

Solution

First, I checked if the content type was not used somewhere in a site (see Vincent Rothwell article)

Then I went to the DB and in the ContentTypes table, you can filter the CT you want with:

     SELECT [SiteId]

          ,[Class]

          ,[Scope]

          ,sys.fn_varbintohexstr([ContentTypeId]) as CT

          ,[Version]

          ,[NextChildByte]

          ,[Size]

          ,[Definition]

          ,[ResourceDir]

          ,[IsFromFeature]

      FROM [SharePoint - 27235].[dbo].[ContentTypes]

    where (sys.fn_varbintohexstr(ContentTypeId) LIKE '0x0101EF0201%')

Because I defined the CT, I knew the ContentTypeId. And I used sys.fn_varbintohexstr() because the ContentTypeId is of type tContentTypeId which is a varbinary(512)

In the result, you can see the column IsFromFeature set to 1. This means your CT belongs to a feature
So one solution was to change the value of IsFromFeature to 0, in order to “fake” SharePoint.

    Update [SharePoint - 27235].[dbo].[ContentTypes] set [IsFromFeature] = 0 where (sys.fn_varbintohexstr(ContentTypeId) LIKE '0x0101EF0201%')

Then I could delete the content type CT1 directly from the UI!

How do I manage a Farm level counter in SharePoint?

2009-01-05T15:48:00.000+01:00

Recently, I had to add a counter into a metadata for each document added in all documents libraries in a SharePoint farm. This counter is composed of several text identifiers plus a number (a chrono). This number is incremented automatically each time a new document is added.
For instance, a generated code is 2-45-IT-TXT-0110000 and the next one will be 2-45-IT-TXT-0110001 or 2-C-IT-TXT-0110001. So the number is incremented, which wouldn’t be a big deal with the help of an Event Receiver in every document library.

But, where to store this number?

It must be accessible by every document library
It must be accessible by every site and site collection
It must be accessible by every web application in the farm.

So, one solution could be to store it directly in the database, but I’m not fond of creating a database and a table for one field!

Not a good idea! Can’t we store this information directly in SharePoint, at a farm level? I googled a bit (a lot :-)) and found this interesting article from Maurice Prather. And I read a little bit more with Robin Meure. Obviously I went also to msdn for the SPPersistedObject definition. So you can read all of this for understanding the mechanism. I prefer to focus this blog on how did I put everything in place? :-)

After the theory… the code!

I have created a form in the SCAW where I can set the first value of the chrono and the datacenter it belongs to. In my architecture, a datacenter is a farm.

The chrono value and the datacenter value are stored in a Chrono object

   1: using System;

   2: using System.Collections.Generic;

   3: using System.Linq;

   4: using System.Text;

   5: using Microsoft.SharePoint.Administration;

6:

7:

   8: namespace apichot.SharePoint.Administration

   9: {

  10:     [System.Runtime.InteropServices.GuidAttribute("BECCB1FC-3B63-45b5-937C-EB5324E6D9BB")]

  11:     public class Chrono : SPPersistedObject

  12:     {

  13:         [Persisted]

  14:         private int _currentChrono = 0;

15:

  16:         [Persisted]

  17:         private int _dataCenter = 0;

18:

  19:         //Two constructors for the serialization

  20:         public Chrono()

  21:         { ;}

22:

  23:         public Chrono(string name, SPPersistedObject parent, Guid guid)

  24:             : base(name, parent, guid)

  25:         { ;}

26:

  27:         public override string DisplayName

  28:         {

  29:             get

  30:             {

  31:                 return string.Format("ReferenceCode Chrono (DC{0})",_dataCenter);

  32:             }

  33:         }

34:

  35:         public int CurrentChrono

  36:         {

  37:             get

  38:             {

  39:                 return _currentChrono;

  40:             }

  41:             set

  42:             {

  43:                 _currentChrono = value;

  44:             }

  45:         }

  46:         public int DataCenter

  47:         {

  48:             get

  49:             {

  50:                 return _dataCenter;

  51:             }

  52:             set

  53:             {

  54:                 _dataCenter = value;

  55:                 this.Name = string.Format("ReferenceCodeChronoDC{0}",_dataCenter);

  56:             }

  57:         }

  58:     }

  59: }

This class inherit from SPPersistedObject and properties are set as “Persisted” in order to be stored in the SPFarm.Properties property bag.

I also created a static class for managing the chrono:

   1: using System;

   2: using System.Collections.Generic;

   3: using System.Linq;

   4: using System.Text;

   5: using Microsoft.SharePoint.Administration;

   6: using Microsoft.SharePoint;

   7: using System.Security.Principal;

   8: using System.Configuration;

   9: using System.Threading;

10:

  11: namespace apichot.SharePoint.Administration

  12: {

  13:     public class ManageChrono

  14:     {

  15:         private const string CHRONO_GUID = "BECCB1FC-3B63-45b5-937C-EB5324E6D9BB";

16:

  17:         public static Chrono InitChrono(SPSite currentSite)

  18:         {

  19:             Chrono _chrono = null;

  20:             try

  21:             {

  22:                 if (currentSite == null)

  23:                 {

  24:                     throw new Exception("Please initialize the site before");

  25:                 }

  26:                 if (_chrono == null)

  27:                 {

  28:                     SPFarm farm = currentSite.WebApplication.Farm;

29:

  30:                     _chrono = farm.GetChild<Chrono>("ReferenceCodeChronoDC1");

  31:                     if (_chrono == null)

  32:                     {

  33:                         _chrono = new Chrono("ReferenceCodeChronoDC1", farm, new Guid(CHRONO_GUID));

  34:                         _chrono.Update();

  35:                     }

  36:                 }

  37:             }

  38:             catch (Exception ex)

  39:             {

  40:                 throw new SPException(ex.Message);

  41:             }

  42:             return _chrono;

43:

  44:         }

  45:         public static string GetChronoCode(SPSite currentSite)

  46:         {

  47:             Chrono _chrono = InitChrono(currentSite);

  48:             return formatCode(_chrono.DataCenter, _chrono.CurrentChrono);

  49:         }

  50:         public static string GetChronoIncremented(SPSite currentSite)

  51:         {

  52:             Impersonator user = null;

  53:             Chrono _chrono = null;

  54:             try

  55:             {

  56:                 user = new Impersonator(ConfigurationSettings.AppSettings["Impersonator User"], ConfigurationSettings.AppSettings["Impersonator Domain"], ConfigurationSettings.AppSettings["Impersonator Pwd"]);

  57:                 for (int i = 0; i < 5; i++)

  58:                 {

  59:                     try

  60:                     {

  61:                         user.Impersonate();

  62:                     }

  63:                     catch (Exception ex)

  64:                     {

  65:                         Thread.Sleep(100);

  66:                     }

  67:                 }

  68:                 // Thread is now impersonating

  69:                 _chrono = InitChrono(currentSite);

70:

  71:                 if (_chrono != null)

  72:                 {

  73:                     _chrono.CurrentChrono++;

  74:                     _chrono.Update(true);

  75:                 }

  76:             }

  77:             catch

  78:             {

  79:                 // Prevent exceptions propagating.

  80:             }

  81:             finally

  82:             {

  83:                 // Ensure impersonation is reverted

  84:                 if (user != null)

  85:                     user.Undo();

  86:             }

  87:             return formatCode(_chrono.DataCenter, _chrono.CurrentChrono);

  88:         }

  89:         public static Chrono GetChronoObject(SPSite currentSite)

  90:         {

  91:             return InitChrono(currentSite);

  92:         }

  93:         private static string formatCode(int dc, int counter)

  94:         {

  95:             return string.Format(@"{0:00}{1:00000}", dc, counter);

  96:         }

  97:     }

  98: }

Line 17: InitChrono makes all the work. It gets the SPSite as a parameter, and from it, retrieves the SPFarm it belongs to. Then I get the chrono (if it exists) under the “ReferenceCodeChronoDC1” tag. In my case, this method is called only from the administration page. So I don’t need to take care of access rights here.

Line 50: GetChronoIncremented. This part is accessible by every user able to add a new document in a document library. And because I don’t want to give access to the SCAW to all users !-(, I impersonate the connection. I use the “Impersonator” from Jay Nathan because it works fine :-) Certainly better than SPSecurity.RunWithElevatedPrivileges ! Don’t forget that we have to read and write the Chrono object inside the SPFarm properties
Because sometimes (rarely) in my architecture the impersonation can’t be done the first time, I made this little loop (line 57)

Line 69: I get the Chrono object retrieved from the SPFarm properties

Line 73: I increment the Chrono and save it

Line 87: returns the chrono string in a good format (Datacenter + number)

From the ItemAdded event receiver in a document library I use this Chrono like this:

try
{
    this._RefCode += "-" + ManageChrono.GetChronoIncremented(properties.ListItem.ParentList.ParentWeb.Site);
}
catch (Exception ex)
{
    SPEventLog.Write("CHRONO: " + ex.ToString());
}

Conclusion

By using the SPPersistedObject, it is easy (:-)) to store properties accessible by all components of a SPFarm without using external tricks.

Sharepoint Item Update is a NIGHTMARE!

2008-05-08T13:44:00.001+02:00

What a strange statement!

Why?

Actually, using item updates is easy and you get what you want, your item updated. Right.
Let's try an example:
You have to create several items, in several content types, in several folders. Let's assume you want to have a kind of hierarchy like:

Folder 1 with a specific content type
- Items with a specific content type inside this folder
- A new folder structure with a specific content type
  - Items inside this folder

Logically, you use a code like the following for the folder:

SPFolder ArchiveFolder = MonthFolder.SubFolders.Add("Folder 1");
ArchiveFolder.UniqueContentTypeOrder = contentTypes;
ArchiveFolder.Update();

//Process all about the folder item
ArchiveFolder.Item["Title"] = this._PONumber;
ArchiveFolder.Item["PONumber"] = this._PONumber;
ArchiveFolder.Item["ContentTypeId"] = ePOFolder.Id.ToString(); // Fix the content type for the folder
ArchiveFolder.Item.Update();

And the following code for a document:

SPFile fileH = HistoryFolder.Files.Add(this.getUniqueFileName(), this._docSize);
fileH.Update();
//Getthe item and fill it with history data, plus the content type id
SPListItem itemH = fileH.Item;
itemH["Title"] = "TITRE";
itemH["ContentTypeId"] = historyCT.Id.ToString();
itemH.UpdateOverwriteVersion();

But all of this works fine if you have only a small number of items, ie less than let's say 50000 records in your list (not only in your container)

If you are above this number of records, things start to be less fancy. One update takes 1 second, then 2 seconds, then 4 seconds, etc... I had the case with more than 120 000 records, and one update could take 1 or 2 minutes! Unbelievable.

After googling and looking at my own experience (see here) I've solved one aspect, uploading documents with meta-data :

First, store your item data into a Hashtable:

Hashtable result = new Hashtable();
result.Add("Title",_PONumber); 
result.Add("HistoryDescription",_historyDescription);
result.Add("HistoryOutcome",_historyOutcome);
result.Add("ContentTypeId", CT_Id);

then use the corresponding overload of SPFiles.Add():

SPFile fileH = HistoryFolder.Files.Add(this.getUniqueFileName(), this._docSize, result);

And that's all! You don't need any update! It's automatically done! Great. It was not so obvious but there is an overload for this method.

Now, what about folders. If you try SPFolders.Add()... you don't see any overload like with SPFiles. So you may think there is no way to use the same technic in order to avoid at least one Update (on item)?

Well, have a look on the bad (un)documented property "Properties" of SPFolder: it is a Hashtable! So you can use the add method to add your items properties, then you only need one update, instead of two. Here is the previous code modifed:

ArchiveFolder = MonthFolder.SubFolders.Add("Folder 1");
ArchiveFolder.UniqueContentTypeOrder = contentTypes;
//Process all about the folder item
ArchiveFolder.Properties.Add("Title", this._PONumber);
ArchiveFolder.Properties.Add("PONumber", this._PONumber);
ArchiveFolder.Properties.Add("ContentTypeId", ePOFolder.Id.ToString()); // Fix the content type for the folder
ArchiveFolder.Update();

Be aware of one thing: in Properties you can only add basic data type, like DateTime, String, Int... but no Double for instance. So be careful if you numeric data.

Summary:

We have now only one update for each folder and no more updates for documents. With my set of 120 000 rows, actually more than 500 000, it takes less than one second to add 2 folders and 12 documents. In one minute now I can process 70 times more documents and folders than before!

SharePoint Folder, Sub-Folder and Content Type (part 2)

2008-04-16T15:24:00.000+02:00

In the previous post we saw how to make a folder hierarchy with there own content type, their own view and their own "New" menu from the user interface. The interesting part of this method is it is easy to implement with only a few clics. But the bad side of this method is we have to do this Folder/New Button implementation everytime we create a folder.

One answer would be to make this implementation automatically each time we create a folder. It is possible with SPItemEventReceiver. But let's focus more on how to make this association from the SharePoint object model ?

Let's say I want to have this kind of structure:

Year-Month folder
- Archive Folder (with meta-data)
  - Document (with meta-data)
  - History folder
    - List of history rows (with meta-data)

For example:

2008-04
- PO12345684
  - 12345678.pdf
  - History as of 2008-04-01
    - history row 1
    - history row 2
    - history row 3
2008-03
- PO10000684
  - 10000684.pdf
  - History as of 2008-03-01
    - history row 1
    - history row 2
    - history row 3

I have an Archive List where I'll store all these data. Each folder or document will have its own set of meta-data. We will use a Content Type for each of them. These CT are supposed to be implemented and attached to the Archive list.. The archive folder name will be the Purchase Order Number (PONumber). The PO will be copied from another list, Purchase Orders.

Here is the code:

using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;
using Microsoft.SharePoint;
using Microsoft.SharePoint.Workflow;

namespace APichot.Services
{

    public class ArchiveData
    {
        //List and Content type names
        //These names will be used to retrieve the content type in the Archive List
        protected string _ArchiveList = "Archive"; //Name of the archive list
        protected string _FolderYM = "Year-Month Folder";
        protected string _FolderCT = "Archive Folder";
        protected string _FolderHCT = "History Folder";
        protected string _HistoryCT = "History Data";
        protected string _purchOrderCT = "Purchase Order Archive";
        protected string _docCT = "Document";
        //Helper for various processes
        protected HelperClass hc;

        protected SPListItem _item;
        protected string _PONumber = string.Empty;
        protected SPList _LstArchive;
        protected string _RecordingDate = string.Empty;

        //Size of the fake document for history
        protected byte[] _docSize = new byte[1];
        //Name of the fake document
        protected Guid _guid = Guid.NewGuid();
        protected int _increment = 0;

        /// <summary>
        /// Get the current item to be moved to the archive list
        /// </summary>
        /// <param name="item">PO Item</param>
        public ArchiveData(SPListItem item) {
            try {
                if (item == null) {
                    throw new ArgumentNullException("item", "This value cannot be null");
                }
                this._item = item;
                this._LstArchive = this._item.Web.Lists[this._ArchiveList]; //this._item.Web.Lists[this._ArchiveList];
                this._PONumber = this._item["PONumber"].ToString();
                if (string.IsNullOrEmpty(this._PONumber)) {
                    throw new Exception("PONumber cannot be null or empty");
                }
            }
            catch (Exception x) {
                Utilities.logMessage("Event Source", "Archive Data", "Constructor", x.ToString(), EventLogEntryType.Error, this._PONumber);
            }
        }
        /// <summary>
        /// Main method to save data to archive
        /// Run the savePO() and saveHistory() methods
        /// </summary>
        /// <param name="wp">Current Workflow properties</param>
        /// <param name="hd">All history data</param>
        /// <returns></returns>
        public bool saveToArchive(HelperClass hc) {
            if (hc == null) {
                throw new ArgumentNullException("hc", "This value cannot be null");
            }
            try {
                this.hc = hc;
                SPFolder ArchiveFolder = this.savePO();
                if (ArchiveFolder != null && ArchiveFolder is SPFolder) {
                    this.saveHistory(ArchiveFolder);
                }
                else {
                    throw new Exception("ArchiveFolder is null or is not an SPFolder");
                }
                return true;
            }
            catch (Exception x) {
                this.hc.logMessage("saveToArchive", x.ToString(), EventLogEntryType.Error);
                return false;
            }
        }
        /// <summary>
        /// Save the PO to the Archive list
        /// </summary>
        /// <returns>Return the archive folder generated to be used by the history folder as a parent folder</returns>
        protected SPFolder savePO() {
            string whereIAm = string.Empty;
            try {
                //Specify the content type to be attached to a folder
                SPContentType FolderYM = this._LstArchive.ContentTypes[this._FolderYM];
                SPContentType Folder = this._LstArchive.ContentTypes[this._FolderCT];
                SPContentType FolderH = this._LstArchive.ContentTypes[this._FolderHCT];
                SPContentType eMailFolder = this._LstArchive.ContentTypes[this._eMailFolderCT];
                SPContentType purchOrder = this._LstArchive.ContentTypes[this._purchOrderCT];
                SPContentType doc = this._LstArchive.ContentTypes[this._docCT];

                List<SPContentType> contentTypes = new List<SPContentType>();

                //Get the item creation date, wich will become the Year/Month folder
                string currentMonthFolder = this.buildMonthFolderName();
                SPFolder MonthFolder;
                //If the folder already exists, get it, else create it
                whereIAm = "Month Folder";
                try {
                    MonthFolder = this._LstArchive.RootFolder.SubFolders[currentMonthFolder];
                }
                catch {
                    this.hc.logMessage("savMonthFolder", "Month folder creation (" + currentMonthFolder + ")", EventLogEntryType.Information);
                    //Create the folder
                    MonthFolder = this._LstArchive.RootFolder.SubFolders.Add(currentMonthFolder);
                    //What goes into the New menu
                    contentTypes.Add(Folder);
                    //Associate the content type to the folder
                    MonthFolder.UniqueContentTypeOrder = contentTypes;
                    //Use the Properties Hashtable to store folder's meta-data 
                    MonthFolder.Properties.Add("Title", currentMonthFolder);
                    MonthFolder.Properties.Add("ContentTypeId", FolderYM.Id.ToString()); // Fix the content type for the folder
                    whereIAm = "Month Folder Update";
                    MonthFolder.Item.Update();
                }

                SPFolder ArchiveFolder;
                whereIAm = "Archive Folder";
                try {
                    //If the folder doesn't exists, then go to Catch
                    ArchiveFolder = MonthFolder.SubFolders[this._PONumber];
                    //Because of international settings (french), the comma is interpreted as a thousand separator by the hastable.
                    //We have to convert it to a period.
                    string poAmount = this._item["POAmount"].ToString().Replace(",", ".");
                    ArchiveFolder.Properties["POAmount"] =  (this._item["POAmount"] == null) ? "0" : poAmount;
                    ArchiveFolder.Properties["VendorName"] =  (this._item["VendorName"] == null) ? string.Empty : this._item["VendorName"].ToString();
                    ArchiveFolder.Properties["POStatus"] =  this._item["POStatus"].ToString();
                    this.hc.logMessage("savArchive Folder", "Archive folder updated", EventLogEntryType.Information);
                }
                catch {
                    //Folder 
                    //Process all about the folder
                    contentTypes = new List<SPContentType>();
                    //What goes into the new menu
                    contentTypes.Add(purchOrder);
                    contentTypes.Add(doc);
                    contentTypes.Add(FolderH);
                    contentTypes.Add(eMailFolder);

                    ArchiveFolder = MonthFolder.SubFolders.Add(this._PONumber);

                    ArchiveFolder.UniqueContentTypeOrder = contentTypes;
                    //Process all about the folder item
                    ArchiveFolder.Properties.Add("Title", this._PONumber);
                    ArchiveFolder.Properties.Add("PONumber", this._PONumber);
                    //Because Properties accepts only int, string and date, and not Double, we must change PO Amount to a string
                    //And transform the comma (decimal) into a period
                    string poAmount = this._item["POAmount"].ToString().Replace(",", ".");
                    ArchiveFolder.Properties.Add("POAmount", (this._item["POAmount"] == null) ? "0" : poAmount);
                    ArchiveFolder.Properties.Add("VendorName", (this._item["VendorName"] == null) ? string.Empty : this._item["VendorName"].ToString());
                    ArchiveFolder.Properties.Add("POStatus", this._item["POStatus"].ToString());
                    ArchiveFolder.Properties.Add("ContentTypeId", Folder.Id.ToString()); // Fix the content type for the folder
                }
                whereIAm = "Archive Folder Update";
                ArchiveFolder.Update();
                //Store a recording date for the History folder name
                this._RecordingDate = DateTime.Now.ToShortDateString().Replace("/", "-") + " " + DateTime.Now.ToShortTimeString().Replace(":", "h");
                //Copy the PO into the new folder
                whereIAm = "Copy file";
                string destUrl = this._item.Web.Site.Url + this._LstArchive.ParentWebUrl + ArchiveFolder.Url + "/" + this.buildName("PO") + ".pdf";
                //Copy the document from Purchase Order list to the Archive list, with meta-data
                this._item.File.CopyTo(destUrl);
                return ArchiveFolder;
            }
            catch (Exception x) {
                this.hc.logMessage("savePO" + whereIAm, x.ToString(), EventLogEntryType.Error);
                return null;
            }
        }
        protected void saveHistory(SPFolder ArchiveFolder) {
            try {
                //Create History Folder
                string hFolderName = this.buildName("History"); 
                SPFolder HistoryFolder = ArchiveFolder.SubFolders.Add(hFolderName);
                List<SPContentType> contentTypes = new List<SPContentType>();
                //CT for the folder
                SPContentType historyFolderCT = this._LstArchive.ContentTypes[this._FolderHCT];
                //CT for the files inside the folder
                SPContentType historyCT = this._LstArchive.ContentTypes[this._HistoryCT];
                //In this folder, we will be able to create only History Data
                contentTypes.Add(historyCT);

                HistoryFolder.UniqueContentTypeOrder = contentTypes;
                HistoryFolder.Properties.Add("Title", hFolderName);
                HistoryFolder.Properties.Add("ContentTypeId", historyFolderCT.Id.ToString());
                HistoryFolder.Update();

                historyFolderCT = null;
                //Store history rows
                this.storeHistoryRows(HistoryFolder, historyCT);
            }
            catch (Exception x) {
                this.hc.logMessage("saveHistory", x.ToString(), EventLogEntryType.Error);
            }
        }
        protected virtual void storeHistoryRows(SPFolder HistoryFolder, SPContentType historyCT) {
            try {
                //Reset the increment number for the UniqueFileName
                this._increment = 0;
                foreach (historyData hdata in this.hc.HistoryDataCollection.ListOfHistoryData) {
                    //Prepare a fake file for storing each history line as in a custom list. Manadatory for a docLib
                    //hData.FillItem methos is:
                    // public Hashtable FillItem(string CT_Id) {
                    //    Hashtable result = new Hashtable();
                    //    result.Add("Title",_PONumber); 
                    //    result.Add("PONumber",_PONumber);
                    //    result.Add("HistoryDescription",_historyDescription);
                    //    result.Add("HistoryOutcome",_historyOutcome);
                    //    result.Add("WFStart",_eventDate);
                    //    result.Add("ApproversName",_approver);
                    //    result.Add("ContentTypeId", CT_Id);
                    //    return result;
                    //}
                    SPFile fileH = HistoryFolder.Files.Add(this.getUniqueFileName(), this._docSize, hdata.FillItem(historyCT.Id.ToString()));
                    fileH = null;
                }
            }
            catch (Exception x) {
                this.hc.logMessage("storeHistoryRows", x.ToString(), EventLogEntryType.Error);
            }
        }

        protected string buildName(string s) {
            return this._PONumber + " " + s.Trim() + " " + this._RecordingDate;
        }
        protected string getUniqueFileName() {
            if (this._increment == 0) {
                this._guid = Guid.NewGuid();
            }
            this._increment++;
            return string.Format(@"{0}-{1:00}.txt", this._guid.ToString(), this._increment);
        }
        protected string buildMonthFolderName() {
            //Get the item creation date, wich will become the Year/Month folder
            DateTime itemCreate = (DateTime) this._item["Created"];
            return string.Format("{0} - {1:00}", itemCreate.Year, itemCreate.Month);
        }
    }
}

As you can see there are some tricky things:

For the New button, you have to prepare a List<> with SPContentType and add this list to the folder's UniqueContentTypeOrder property.
For setting meta-data to a folder it is actually worth to use the Folder's Properties property (see this post)
For inserting a file, it is actually worth to use a Hastable for meta-data associated with SPFile object (see this post again)

Try to avoid as possible the number of updates you make in order to insert data faster. I've explained it in this post

I've spent some time with this, I hope this helps.

Accélerez SharePoint: Purgez les logs !

2008-03-21T16:40:00.000+01:00

Lorsqu'on utilise une configuration standard de SQL Server, les fichiers logs ne sont pas paramétrés au mieux. Ceci à des incidences non négligeables sur les performances à venir de SharePoint. En effet, on peut noter que le fichier log de configuration (Config) de SharePoint à tendance à prendre de l'embonpoint au fur et à mesure de son utlisation. Et bien entendu, les logs associés à votre ou vos ContentDB.

Alors si cette gestion des logs n'est pas optimisée, voici une astuce qui permettra de faire un peu de place et de gagner en rapidité. Cette astuce peut de toute façon être utilisée, même si la gestion des logs est bien faite, cela n'empêche pas! Une bonne cure de printemps, c'est le moment.

Comment faire ?

Tout d'abord, il vaut mieux arrêter quelques services, comme le timer et le search :

NET STOP SPTIMERV3

NET STOP OSEARCH

IISRESET

Puis, personnellement, je préfère faire comme si je voulais déplacer la base. Pour éviter que SharePoint se mélange les pinceaux, et inonde l'Event Viewer de messages pas très catholiques, je fais un preparetomove :

stsadm -o preparetomove -contentdb SQLSERVERNAME:CONTENTDBNAME -site http://SITENAME

Ensuite, je vais dans SQL Server Management Studio pour détacher la base CONTENTDBNAME. Assurez-vous que personne n'est connecté.
Puis je retourne dans le file system pour renommer le fichier CONTENTDBNAME.LDF en... ce que vous voulez, mais il ne faut pas l'effacer (pas encore)
Retour à nouveau dans SQL Server Management Studio pour attacher (Attach) la base CONTENTDBNAME, et, dans la fenêtre de confirmation qui apparaît, il faut mettre en surbrillance le nom du fichier log "Not Found" et cliquer sur le bouton Remove.
Ceci fait, cliquez sur Ok et la base est de retour.
Dans les propriétés de la base, vous pouvez maintenant voir que le fichier log est d'environ 1Mo (cela varie selon la configuration de la DB) et vous pouvez ajuster sont incrément ainsi que sa limite maxi.

NET START SPTIMERV3

NET START OSEARCH

Ensuite, retourner sur votre site et... tout doit fonctionner correctement ! Si ce n'est pas le cas, alors vous avez encore la possibilité de renommer à nouveau l'ancien log. Mais si tout fonctionne, alors vous pouvez supprimer les logs renommés.
Pour ma part, j'ai fait cette opération chez un client qui avait deux logs de plus de 50Go pour des DB de 10Go. Et bien, ça a fait de la place, et il y a surtout eu un gain en rapidité en lecture et écriture.

Sharepoint: Accessing a List with it's Internal Name

2008-03-20T13:04:00.002+01:00

Le problème pour accéder aux listes SharePoint est qu'on doit utiliser le nom "public" de la liste, le Title, et non le nom interne:

Si je crée une liste en lui donnant le nom "MaListe" puis je renomme cette liste en "Ma Liste", alors la liste a deux noms:

Le nom interne, MaListe (le premier créé)
Le nom public, Ma Liste, suite au renommage.

Si je veux accéder à la liste par programme, je vais utiliser:

SPList list = web.Lists["Ma Liste"];

car la string demandée par la Lists correspond au champs Title de la liste

Mais si on considère que toute liste est un folder, alors on peut contourner le problème en passant par le SPFolder:

public enum ListType { CustomList, Document };

static public SPList GetListName(SPWeb web, ListType type, string InternalName) {
            try {
                SPFolder folder = null;
                switch (type) {
                    case ListType.CustomList:
                        folder = web.Folders["Lists"].SubFolders[InternalName];
                        break;
                    case ListType.Document:
                        folder = web.Folders[InternalName];
                        break;
                    default:
                        break;
                }
                SPList realList = web.Lists[folder.ParentListId];
                return realList;
            }
            catch (Exception x) {
                return null;
            }
        }

Lorsque vous créez une liste, le premier nom que vous donnez devient le nom du folder et donc le nom interne qui ne changera plus. Ensuite, vous pouvez modifier le nom de la liste, mais c'est le champ Title qui est affecté.

J'ai ici mis en avant l'accès aux listes de type "Custom List", qui sont des sous-folder de "Lists", et des listes de type "Document", dont le folder est directement en web root.
Une fois qu'on a le folder, il suffit de récupérer son ParentListId pour obtenir la liste associée.

SharePoint Folder, Sub-Folder and Content Type (part 1)

2008-03-13T17:13:00.002+01:00

Aujourd'hui, je vais décrypter la façon dont on peut travailler avec les Folder et sous-folders dans SharePoint, tout en leur associant des Content Type. J'ai partagé ce blog en deux :

Partie 1 : comment faire via l'interface utilisateur
Partie 2 : comment utiliser ceci par programme

Voici l'énoncé du problème :

Dans une Document Library, je veux avoir des folders qui ont leurs propres meta données (appelons ces folder "Folder Niveau 1")
Au niveau root, je ne veux qu'avoir la possiblité de créer des "Folder Niveau 1"
Au niveau Root je veux avoir une seule vue qui me montre ces meta données
En entrant dans un "Folder Niveau 1", je veux avoir la possibilité de créer des Documents de type contrat et des "Folder Niveau 2" de type Folder
Dans un "Folder Niveau 1", je veux avoir une seule vue qui montre les meta données de Document
Dans "Folder Niveau 2" je veux avoir une seule vue qui montre les meta données de Document
Comment gérer ces folders par programmation (partie 2)

Résolution par l'interface utilisateur

Tout d'abord, il faut créer les content type (CT). Un content type que l'on crée via l'IU va hériter de propriétés d'un parent. Habituellement ce parent est un document, mais rien n'empêche de prendre un Folder comme parent (après tout, c'est aussi un content type)

Dans le site settings on trouve la gallerie des CT

Et on crée le premier CT, Folder Niveau 1. Il faut bien noter que le parent de ce CT est bien le Folder. Je mets le tout dans un group "Folder Group" (pas très inspiré aujourd'hui...)

Ensuite, on rajoute quelques colonnes. Pour l'exemple, je les ai prises dans les colonnes existantes. Il faut faire de même pour le CT "Folder Niveau 2", mais cette fois je n'ai pas pris de colonnes supplémentaires. Ensuite, il y a le CT pour le document de type contrat

Et les colonnes, prises aussi dans les colonnes existantes. Maintenant, il faut retourner dans la Document Library Settings (advanced), autoriser les Content Type, Et empêcher la création de Folder standard (si on le souhaite bien sûr) Ensuite, il faut choisir les CT qui nous intéressent Puis, pour n'avoir que "Folder Niveau 1" dans le menu "New", il faut enlever les CT qui ne nous intéressent pas. Attention, cela ne veut pas dire qu'ils ne seront plus accessibles. En fait, il sont toujours attachés à la liste, mais il ne seront simplement pas visible. Vous allez voir qu'on va jouer là-dessus pour filtrer le contenu du menu "New" dans les sous-folder. Ceci fait, on note dans le menu new qu'il n'y a plus grand chose, hormis la possibilité de créer un "Folder Niveau 1" Avant de créer un "Folder Niveau 1", il faut faire un tour du coté de la vue "All Documents". Cette vue affiche des données standard, et nous sommes plutôt intéressés pour voir les données du CT "Folder Niveau 1". La première étape consiste à modifier cette vue en sélectionnant les bonnes colonnes puis, petite astuce, il faut aller tout en bas à la rubrique Folders pour dire que cette vue ne sera valable que lorsqu'on est dans le root folder. Cette possibilité est très intéressante car elle va justement nous permettre de sélectionner les vue que l'on souhaite en fonction du niveau de folder dans le quel on est. Ceci fait, on va créer un "Folder Niveau 1". Faites New / Folder Niveau 1 et vous constatez qu'il y a bien un formulaire d'édition qui nous demande d'entrer les meta données que l'on a associé au folder Et après avoir cliqué sur OK, on a bien dans la liste un folder avec ses meta données Maintenant, nous allons modifier les paramètres ce folder pour personnaliser son menu New. Il ne devra permettre que la création des "Folder Niveau 2" et des Contrats. C'est le même principe que sur la liste: dans le menu associé au nom du folder, on trouve l'option "Change New Button Order" qui va permettre de sélectionner les éléments que l'on souhaite voir s'afficher dans le menu New de ce folder (Folder Niveau 2 et Contrats) Le menu est bien, mais la vue n'est pas bonne En effet, on ne voit pas les meta data spécifiques aux documents contenus dans ce folder. Nous allons créer une vue qui va permettre cela. Cette vue aura un nom, sera une vue par défaut, avec des colonnes appropriées, et surtout, elle sera associée au CT "Folder Niveau 1". Cela devient donc la vue par défaut pour ce folder Et maintenant, en entrant dans ce Folder Niveau 1 la vue précédente apparaîtra. Ce qui fait qu'on maintenant deux vue par défaut, une pour le niveau Root, et une pour le niveau Folder Niveau 1.

Bien sûr, pour le Folder Niveau 2 il faut faire de même, ce qui permet d'avoir une hiérarchie de folder et de vue très intéressante. Mais l'inconvénient majeur de ce système, c'est qu'il faut faire la démarche de sélectionner le "New Button Order" pour chaque nouveau folder créé. Heureusement il existe une méthode par programmation. C'est ce que nous verrons dans la partie 2 de ce post.

SharePoint 2007 : How To Run STSADM Command From Your Code

2007-11-30T16:10:00.000+01:00

Today, I've discovered something very interesting I want to share with you: How to run stsadm command inside my code. It's really easy, if you look at the following code, I specify to search from a membership provider only:

string prgFilePath = System.Environment.GetFolderPath(Environment.SpecialFolder.CommonProgramFiles); string stsadmPath = prgFilePath + @"\Microsoft Shared\web server extensions\12\BIN\stsadm.exe"; System.Diagnostics.Process proc = new System.Diagnostics.Process();

//Wait for the end of the process

proc.EnableRaisingEvents = false; proc.StartInfo.FileName = stsadmPath; proc.StartInfo.Arguments = "-o setproperty -url http://dcmoss:50020/ -pn "peoplepicker-nowindowsaccountsfornonwindowsauthenticationmode" -pv yes"; proc.Start();

//Wait

proc.WaitForExit();

With this method you can dynamically activate or deactivate feature, make some maintenance operation, change properties...

Sharepoint 2007: SPBuiltInFieldId a Class You Must Know

2007-11-22T09:40:00.000+01:00

A short comment today about a class I've just discovered: SPBuiltInFieldId With this class you have access to all built-in fields, even the hidden one's Example:

SPBuiltInFieldId.WorkflowListId SPBuiltInFieldId.WorkflowItemId SPBuiltInFieldId.WorkflowVersion SPBuiltInFieldId._CopySource SPBuiltInFieldId._RightsManagement

Link: http://msdn2.microsoft.com/En-US/library/microsoft.sharepoint.spbuiltinfieldid_members.aspx

SharePoint 2007 - Create field lookup and associated list as a feature

2007-11-21T17:25:00.000+01:00

Je suis désolé pour les francophones, mais je dois maintenant m'exprimer en anglais car j'ai mis le code sur Codeplex This feature is an extension of the one from Chris O'Brien (SharePoint 2007 - create lookup fields as a feature), but offer you the ability to define one or more fields and the associated lists within one xml file.Moreover you'll can use these fields in one or more content type. When you'll activate the feature, everything will be build ! Let me explain a bit: First, if you want to have a full explanation of managing lookup column dynamically, you can start with a look on the blog of Chris O'Brien : http://sharepointnutsandbolts.blogspot.com/2007/04/creating-list-based-site-columns-as.html For summarizing, a lookup field is like a choice field but the content comes from a list in the site collection. The main difficulty is that the link between the field and the list is a GUID coming from the instance of the list. This means the GUID is only known when the list has been created. So you can't fix the link in your site column definition. ie:

is not possible because you don't know the list GUID. Well, of course you can cheat a bit if you define a list in your site and you retrieve the actual GUID of the instance. But what about moving a site from a test environment to a production environement ? Or from a site collection to another...? The GUID change each time ! The solution proposed by Chris is great. But you must still define a list before activating the feature. And because I'm a little bit lazy, I've tried to improve his solution to one more generic. Let's suppose you want to have a lookup field which contain a list of keywords. These keywords come from a SharePoint list, so you can extend it as you want. Create a new XML file and insert the following code inside. Of course you can have more than one field into this XML file, but I'll use only one for the demo.

<?xml version="1.0" encoding="utf-8" ?><Elements xmlns="http://schemas.microsoft.com/sharepoint/"> <Field Type="Lookup" DisplayName="Mots-clés" Mult="TRUE" Required="FALSE" List="Keywords;Mots-Clés" ShowField="Title" UnlimitedLengthInDocumentLibrary="FALSE" Group="TEST" ID="{E918A3F4-9E34-4bd2-A621-5F353B4529E2}" SourceID="http://schemas.microsoft.com/sharepoint/v3" StaticName="KeywordLookup" Name="KeywordLookup" /> </Elements>

As you can, this is a classic field definition. Except for one attribute: List. This attribute has two words, Keyword and Mots-Clés. The first one is the internal name of the list template, the second one is the name of the list we'll see in the site. In our case, we gonna create a list named Mots-Clés based on the template internal name Keyword. For a standard Customlist, the internal name is custlist (have a look on 12\TEMPLATE\FEATURES\CustomList\ListTemplates) Why all of this? Because when the feature will be activated, a program will search for a list named Mots-Clés in the site collection. If this list doesn't exist, then the program creates it, based on the list template and the list name you define in the List attribute. Here is the Feature.xml file:

<?xml version="1.0" encoding="utf-8" ?> <Feature Title="Site Column Lookup Initialization" Id="498CB08B-1786-4e34-AD09-F61009A0C6AB" Description="This feature create site columns lookup related to lists" Version="1.0.0.0" Scope="Site" Hidden="FALSE" DefaultResourceFile="TEST" xmlns="http://schemas.microsoft.com/sharepoint/" ReceiverAssembly="Tls.Moss, Version=1.0.0.0, Culture=neutral, PublicKeyToken=9f4da00116c38ec5" ReceiverClass="MossSolution.Receivers.LookupFeatureReceiver"> <ActivationDependencies> <ActivationDependency FeatureId="bfda08d3-c7a8-4ade-99d5-86de4ce0ac26"/> </ActivationDependencies> <ElementManifests> <ElementFile Location="LookupFields.xml"/> </ElementManifests> <Properties> <Property Key="ColumnDefinitionPath" Value="C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\TEMPLATE\FEATURES\SiteLookupFields\LookupFields.xml" /> </Properties> </Feature>

In this feature, adapt the event receiver with the name of your assembly. The LookupFields.xml is the file where I put all lookup columns definitions. You can notice one particular property: ColumnDefinitionPath. This is the path where the lookup columns definitions is located. This path will used in the code to retrieve the XML data. I've also added a dependency, because the list template feature must be activated before activating this lookup feature. The tips here is because you defined properly a field, with all the usual behaviors (DisplayName, Show where you want, Readonly...) and a GUID, you can use these fields inside a ContentType! Good news, you have now the opportunity to have a content type with usual field types, PLUS one or more lookup type! The code is available on Codeplex: SharePoint 2007 - Create field lookup and associated list as a feature. There is a folder named Solution which contains the wsp Now, you have to add the solution with stsadm -o addsolution -filename lookupsolution.wsp Then, go to Central Admin / Operation /Solution Management and deploy the solution to the site(s) you want. Then, go to your site settings for activating the collection features, first TEST Keywords then Site Column Lookup Initialization The source code is in _App_code/Receivers. Hope this helps you.

SharePoint 2007 : Workflow et Association Form avec InfoPath 2007

2007-07-30T16:04:00.001+02:00

Aujourd'hui je vais m'intéresser à la création d'un formulaire d'association pour un Workflow.

Un formulaire d'association est une page qui apparaît lorsqu'on crée une instance de Workflow : on choisit tout d'abord le modèle de Workflow, puis la Task list qui sera associée, puis l'History List, et enfin le mode d'activation du Workflow (Automatique, manuel...)

En cliquant sur le bouton Next, j'obtiens mon propre formulaire qui me permet de récupérer des informations complémentaires dés l'instanciation du Workflow. En l'occurrence, un flag qui m'indique si un mail doit être envoyé au "Supplier", puis un commentaire à insérer dans la description de tâche. Ainsi ce texte se retrouvera dans chaque tâche. Pour créer un tel formulaire, et l'associer au workflow, il est préférable d'utiliser InfoPath 2007 qui offre beaucoup d'avantages par rapport aux pages ASPX. Voici en quelques étapes comment faire pour construire l'écran précédent et l'intégrer dans le workflow. Principe : Un formulaire InfoPath est est un fichier XML associé à un Schéma XSD. Il y a une partie mise en forme et une partie données. L'astuce principale est de transformer le shéma en une classe C# (.cs) pour disposer facilement des propriétés (Data Source) au sein du Workflow. Les propriétés seront, entre autre, des champs de saisie dans l'écran InfoPath. Préliminaires Il faut avoir créer un projet de type Workflow sous Visual Studio, puis avoir créé une arborescence prête à accueillir les fichier d'installation

Etape 1 : créer l'écran

Ouvrir InfoPath et créer un nouveau Template.
Il faut ensuite créer une "Data Source" (Design Tasks / Data Source), ensemble de variables qui mémoriserons les données entrées. C'est grâce à ces Data Source que l'on va pouvoir dialoguer avec le formulaire. Une bonne pratique pour créer la Data Source est de lui donner un nom explicite. Par ailleurs, ce nom sera plus tard le nom de la classe qui sera générée pour être utilisée dans le Workflow. Dans mon exemple, j'ai pris comme nom de "Data Source" AssocData et j'ai créé deux champs, l'un booleen, l'autre de type texte mutillignes
Mise en forme du formulaire : une fois les champs créés, il faut, dans le menu Design Tasks / Layout faire la mise en forme. Sélectionnez un tableau à deux colonnes, puis retournez dans Design Tasks / Data Source pour faire un Drag & Drop des champs aux bons emplacements. Ajoutez ensuite un bouton (Design Tasks / Controls)
Il faut ensuite paramétrer le bouton pour que le formulaire soit envoyé à SharePoint (à l'instance de workflow en cours), puis que le formulaire soit fermé. Pour cela, il faut faire un click doit sur le bouton et aller dans "Button Properties"... ... et mettre le label (ici "Done"), puis cliquer sur Rules...
A partir de là, il va falloir créer une Data Connexion pour se connecter au Host (SharePoint) et renvoyer les données. Cliquez sur Add Actions puis Add... pour ajouter une Data Connexion Utilisez les mêmes paramètres (on veut faire une soumission de formulaire) et cliquez sur Next... et selectionnez le "Hosting Environment". Puis donnez un nom explicite à cette Connexion.
Il faut ensuite ajouter une action (Add Action) pour fermer le formulaire (choisissez cette option dans la liste)

Etape 2 : Publication

Voilà, le formulaire est prêt. Maintenant il faut (1) le publier, (2) récupérer le schéma. (1) Publication : le mécanisme de publication, dans notre cas, consiste à publier le formulaire dans notre répertoire d'installation de la feature Workflow. Tout d'abord, il faut enregistrer le formulaire quelque part où vous le retrouverez (My Document/Forms par exemple). Puis cliquez sur "Publish Form Template..." et choisir une "Network Location" puis Next Enregistrer le formulaire dans votre répertoire de projet Visual Studio dans le sous-répertoire concerné par la feature Workflow (dans mon cas, GYPOWorkflow) et donnez lui un nom explicite (celui de votre sauvegarde pourra faire l'affaire) Ne mettez rien dans cette form et ignorez l'avertissement. Publiez, c'est fait.
Un fois que c'est publié, il faut encore se faciliter le travail en créant une classe C# à partir du schéma du formulaire. Cette classe aura comme propriété les champs du formulaire. Pour se faire, il faut enregistrer le code source du formulaire dans un répertoire InfoPath va générer un lot de fichier dont seul myschema.xsd nous intéresse Nous allons utiliser le programme XSD.EXE fournit avec VSStudio pour générer une classe C#. Le nom du fichier cs généré portera le nom du fichier xsd (myschema actuellement) mais la classe elle-même portera le nom de notre Data Source (AssocData pour l'exemple). Par conséquent je vous conseille de renommer myschema.xsd en AssocData.xsd pour être cohérent. Ensuite, ouvrez une fenêtre DOS, allez dans le répertoire où est situé votre shéma (My Document\XSD_Sources dans mon cas) puis tapez l'instruction suivante : xsd myschema.xsd /c Vous aurez ensuite un fichier portant le nom myschema.cs (ou AssocData.cs si vous avez renommé le fichier) qui contient une structure particulière et les accesseurs nécessaires pour retrouver les données du formulaire.
Ceci étant fait, retournez sous VS et ajoutez cette classe à votre projet.
Dans l'événement OnWorkflowActivated1_Invoked, ajoutez les lignes de code suivantes: //Get the info about sending email to supplier from the association form //Part 1 XmlSerializer serializer = new XmlSerializer(typeof(AssocData)); XmlTextReader reader = new XmlTextReader(new System.IO.StringReader(workflowProperties.AssociationData)); //Part 2 AssocData AssocForm = (AssocData)serializer.Deserialize(reader); //Internal variables eMailToSupplier = (bool)AssocForm.eMailToSupplier; reviewComments = AssocForm.reviewComment; La première partie du code récupère le fichier xml InfoPath sérialisé qui est stocké dans une propriété (AssociationData) du Workflow. La deuxième partie désérialise le XML en faisant un Cast sur l'objet AssocData. Ceci permet ensuite d'utiliser les propriétés de l'objet pour récupérer les données et les stocker dans des variables locales au Workflow pour un usage ultérieur.

Etape 3 : Paramétrage de la feature

une fois que le code est écrit et compilé, jeté dans le GAC, il faut créer une feature qui va se charger d'assembler tout ceci en quelque chose de cohérent. Dans un répertoire, il vous faudra avoir un fichier feature.xml, un fichier workflow.xml et votre formulaire, GYWFPOAssocForm.xsn dans mon cas. (ne vous occupez pas pour l'instant du quatrième fichier, qui fera l'objet d'un autre article) Le fichier feature.xml se présente de la façon suivante : <?xml version="1.0" encoding="utf-8"?> <Feature Id="B72AA389-51B8-4d7b-8730-F5A2885F9E93" Title="Purchase Order Workflow" Description="Purchase Order workflow, automated review process" Version="12.0.0.0" Scope="Site" ReceiverAssembly="Microsoft.Office.Workflow.Feature, Version=12.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" ReceiverClass="Microsoft.Office.Workflow.Feature.WorkflowFeatureReceiver" xmlns="http://schemas.microsoft.com/sharepoint/"> <ElementManifests> <ElementManifest Location="workflow.xml" /> </ElementManifests> <Properties> <Property Key="GloballyAvailable" Value="true" /> <Property Key="RegisterForms" Value="*.xsn" /> </Properties> </Feature> Puis le fichier workflow.xml : <?xml version="1.0" encoding="utf-8" ?> <Elements xmlns="http://schemas.microsoft.com/sharepoint/"> <Workflow Name="Purchase Order Workflow" Description="Puchase Order Workflow, automated review process" Id="869774CD-6710-4583-938B-5B691903CCBF" CodeBesideClass="MyWorkflow.WFPO" CodeBesideAssembly="MyWorkflow, Version=1.0.0.0, Culture=neutral, PublicKeyToken=53941405af02689c" TaskListContentTypeId="0x01080100C9C9515DE4E24001905074F980F93160" AssociationUrl="_layouts/CstWrkflIP.aspx" ModificationUrl="_layouts/ModWrkflIP.aspx" StatusUrl="_layouts/WrkStat.aspx"> <Categories/>  <MetaData> <Association_FormURN>urn:schemas-microsoft-com:office:infopath:GYWFPOAssocForm:-myXSD-2007-05-14T07-58-42</Association_FormURN> <AssociateOnActivation>false</AssociateOnActivation> </MetaData> </Workflow> </Elements> Pour obtenir l'URN du formulaire InfoPath, il faut charger le formulaire dans InfoPath (design Template), puis aller dans File / Properties et copier/coller l'urn entre les tags CodeBesideClass et CodeBesideAssembly correspondent à la DLL et la classe de votre workflow.
Ceci fait, il faut copier le répertoire d'installation (GYPOWorkflow) dans le répertoire "12\Template\Feature" et il vous faut installer (stsadm -o install feature GYPOWorkflow\feature.xml) et activer (stsadm -o activatefeature -filename "GYPOWorkflow\feature.xml" -url http://dcmoss:50010/) la feature.

Voilà, c'est tout, normalement cela doit marcher. C'est un peu laborieux, mais une fois que le formulaire est enregistré, il est très simple de le modifier. Et c'est très joli !

Champs type Lookup et type People (update) et type Link

2007-07-18T18:45:00.000+02:00

Je reviens rapidemment sur les deux champs à saisie simple et multiple, les champs Lookup et People Comme je le précise dans mon article précédent, ils renvoient une chaîne de caractères bizarres composés d'un couple ID/Libellé ( "#1;#data1#;#2#data2#;") Pour pouvoir accéder facilement aux données, il faut réussir à utiliser au final un type SPFieldLookupValue qui a deux propriétés utiles: - LookupId : pour récupérer l'Id de l'item de la liste liée dans le lookup - LookupValue : pour récupérer le libellé (ce qu'on voit dans la liste) Dans le cas d'une sélection multiple, on doit utiliser le constructeur de SPFieldLookupValueCollection avec en paramètre la chaîne de caractère à traiter : SPFieldLookupValueCollection spcol = new SPFieldLookupValueCollection(string_from_field) Ce qui retournera une collection de SPFieldLookupValue Par contre, si c'est une sélection unique, deux cas se présentent : Cas 1 : c'est un champ de type Lookup, alors on peut utiliser le contructeur de SPFieldLookupValue : SPFieldLookupValue spfield = new SPFieldLookupValue(string_from_field) Cas 2 : c'est un champ de type People, alors ce champs renvoit un Integer qui est l'Id du SPUser : SPUser user = web.AllUsers.GetByID(userId); Le champs de type Link Le champ de type Link a besoin de deux informations : - l'URL - La description Pour adresser un tel champs, il faut utiliser l'objet SPFieldUrlValue et renseigner les deux propriétés Description et Url : SPFieldUrlValue linkURL = new SPFieldUrlValue(); linkURL.Description = description; linkURL.Url = link; La description représente le libellé qui apparaîtra dans la colonne. Ce libellé sera un lien vers Url Voilà trois champs que l'on rencontre très souvent et qui sont un petit peu pénible à utiliser.

SharePoint 2007 : Champs Lookup et People

2007-06-05T11:32:00.000+02:00

Je me suis arraché les cheveux pour répondre à ce qui me semble être une incohérence : Cas 1: si on utilise un champ lookup ou People dans une liste, les données sont renvoyées sous forme d'une chaîne de caractères "#1#;data1#;". Cas 2: Si on utilise un champ lookup ou people dans une liste avec sélection multiple, les données sont renvoyées sous forme d'une chaîne de caractères "#1#;data1#;#2#data2#;". Il existe un objet SPFieldLookupValueCollection qui contient des SPFieldLookupValue qui a deux propriétés intéressantes : - LookupId : pour récupérer l'Id de l'item de la liste liée dans le lookup - LookupValue : pour récupérer le libellé (ce qu'on voit dans la liste) Dans le Cas 2, on peut "caster" cette chaîne à l'aide de : SPListitem relation; SPFieldLookupValueCollection temp = (SPFieldLookupValueCollection)relation["columnName"]; columnName est une colonne de type lookup ou people à sélection multiple et relation est un élément de la liste Mais cela ne marche pas dans le Cas 1 : SharePoint génère une erreur. Une première approche serait de caster avec SPFieldLookupValue : SPFieldLookupValue tempValue = (SPFieldLookupValue)relation["columnName"]; Mais non, ça ne marche toujours pas ! Ce qu'il faut faire, avant de chercher un super algorithme de parsing de la chaîne de caractères, c'est d'utiliser un paramètre du constructeur : SPFieldLookupValue tempValue = new SPFieldLookupValue(relation["columnName"].ToString()); Dans ce cas on obtient bien un objet SPFieldLookupValue avec les propriétés LookupId et LookupValue qui sont vraiment bien pratiques. Pourquoi ne pas avoir une seule façon de "caster" ??

Sharepoint 2007: upload d'un document avec ses meta-data

2007-05-29T09:48:00.000+02:00

J'ai dû récemment faire l'application suivante: Des documents étaient générés automatiquement par une application externe. Le but du programme était de récupérer ces documents pour les mettre dans une document list, avec leurs meta-data. Puis de lancer un workflow pour approbation avec différents paramètres. Dans cet article, je vais m'attacher à l'importation des fichiers dans la liste. Je ferai un autre article pour le workflow. Le premier réflexe est bien entendu de télécharger le document dans la liste puis de faire une correspondance entre les colonnes de la liste et des meta-data. Mais étant donné que je gère les versions dans cette liste, cette façon de faire risque d'incrémenter un numéro de version pour rien, suite à deux updates (un pour le document, un pour les meta-données) Mais en cherchant un peu, j'ai trouvé un overload bien pratique... La première chose est de considérer la liste comme un folder, et de récupérer dans ce folder la collection des fichiers existants. Le folder se récupère en utilisant le nom interne de la liste. Je spécifie bien le nom interne, c'est à dire le nom qui a été utilisé la première fois lors de la création de la liste (si elle a été créée via l'UI). On trouve ce nom en regardant dans l'url de la liste. Par exemple : http://dcmoss:50010/testgy/PurchaseOrder PurchaseOder est bien le nom du folder, même si la liste s'appelle "Purchase Order". SPFolder folder = _web.GetFolder("nom interne de la liste"); SPFileCollection files = folder.Files; Puis je récupère le fichier lui-même, en le stockant dans un stream mémoire FileStream fStream = File.OpenRead("fileName"); Pour terminer je crée l'URL du fichier, avec son nom: string url = "url Site web" + "nom interne de la liste" + "/" + Path.GetFileName("fileName"); Maintenant, les meta-data doivent être stockée dans une HashTable: HashTable MetaDataTable = new HashTable(); MetaDataTable.Add("nom de colonne", "valeur"); En réalité j'ai une classe qui parse le fichier texte et qui me renvoit une hashtable. Enfin, je l'ajoute le tout à la collection de fichier de la liste: SPFile currentFile = files.Add(url, fStream, MetaDataTable, true); Le flag True permet d'écraser un fichier s'il est déjà présent. En une ligne, on ajoute un fichier avec ses meta-données. Pas mal, non ? Voici un exemple de code pour uploader un document avec les meta-données: //Using required, especially System.IO; using System.Collections.Generic; using System.Collections; using System.Text; using Microsoft.SharePoint; using System.IO; namespace DocImport { public class DocManagement { //Some variables private string _DestUrlPath = string.Empty; private string _DestFolder = string.Empty; private SPSite _site = null; private SPWeb _web = null; public DocManagment(string DestUrl, string DestFolder) { _DestUrlPath = DestUrl; _DestFolder = DestFolder; _site = new SPSite(_DestUrlPath); _web = _site.OpenWeb(); } private bool _uploadDocument(string pdfFile, string txtFile) { try { //This is mandatory for avoiding an error _web.AllowUnsafeUpdates = true; //Use the list as a folder SPFolder folder = _web.GetFolder(_DestFolder); SPFileCollection files = folder.Files; //Get the file FileStream fStream = File.OpenRead(pdfFile); HashTable MetaDataTable = new HashTable(); MetaDataTable.Add("nom de colonne", "valeur"); //Set the destination url for SharePoint string url = _DestUrlPath + _DestFolder + "/" + Path.GetFileName(pdfFile); //Add document to the list with metadata, and overwrite an existing document with the same name SPFile currentFile = files.Add(url, fStream, MetaDataTable, true); fStream.Close(); return true; } catch (Exception x) { throw new Exception(x.Message); } } }

Sharepoint 2007 Workflow Update Item

2007-05-23T11:48:00.001+02:00

Dans un workflow déclenché par une modification de l'item d'une liste, il est souvent nécessaire de mettre à jour une meta-donnée de cet item. Le principe est simple en utilisant par exemple : workflowProperties.Item["Status"] = "Archived"; Mais que ce passe-t-il lorsqu'on met à jour ? Le fait de faire workflowProperties.Item.update(); déclenche l'événement de mise à jour, et donc redéclenche le workflow, donc une erreur car une instance du même workflow est déjà active sur cet item. La réponse est dans l'instruction suivante : workflowProperties.Item.SystemUpdate(); Cette méthode permet d'écrire directement dans la base, sans déclencher les événements sur l'item. D'autre part, il est possible de spécifier un flag (true/false) pour incrémenter ou non la version.