Discussion :

[xanass]

Bonjour à tous,

J'ai généralement pas besoin de poster parceque je trouve toujours ce que j'ai besoin sur les forum mais là j'ai besoin de votre aide.

Mon entreprise souhaite migrer son intranet de Oracle portal (CMS d'oracle) vers sharepoint 2010. Jusque là pourquoi pas.

Mon soucis est que je dois le faire migrer de façon automatique en évitant aux maximums les opérations manuelles.

Il est trés facile d'extraire la structure du site, des pages et leurs contenus d'oracle Portal, ce qui veut dire qu'en gros on peut sortir l'intégralité de l'intranet sous forme de fichier à plat.

Mon idée est donc de savoir s'il possible par la suite de faire via un ETL une migration des données directement dans sharepoint.

Si oui, quelles tables je doit "attaquer"? ou qu'elle est la structure de la BD sharepoint?

Si non, quelqu'un aurait-il déjà fait ce genre de chose ou s'en rapprochant? ou aurait manipuler la base sharepoint? ou encore aurait carrément une procédure pour le faire.

Merci beaucoup pour votre aide

BR

[xanass]

Je me rends compte que ce que je demande est de l'ordre du trés difficile à faire

Alors je vais posé la question d'une autre manière.

Je vais essayé d'être plus clair et surtout essayé de faire la correspondance avec des items sharepoints.

J'ai un intranet que l'on pourrait considérer comme une web application sous SP2010, sous cette intranet j'ai différents services, soit des collections de sites/sites/sous-sites, et dans chaque service j'ai des pages HTML contenant des liens, du texte, des images, ou des fichiers.

J'aimerais d'abord savoir s'il y a un moyen simple de porter les infos vers sharepoint ou faut tout se retaper à la main?

[SONY30]

Bonjour,

Ton sujet m'intéresse mais je suis débutant SharePoint donc peu de solutions à t'apporter.
Simplement je sais qu'il n'est pas conseillé (voire interdit) d'attaquer directement la base de données SharePoint à la main.

Il te faudra développer un composant .net qui attaquera ta base Oracle et chargera les bibliothèques, listes SharePoint à l'aide des objets SharePoint.

[xanass]

Merci,

Je suis aussi un débutant en sharepoint, et j'ai un peu de mal à voir comment je peux réaliser des automatismes.

Je me doutais bien qu'il fallait que je développe un composant .NET mais en fait je vois pas trop comment faire cela.

Et quelque part je me dis qu'il y a bien quelqu'un qui a eu la même problèmatique.

Pour faire encore plus simple, j'ai des pages HTML (enregistré sous ORACLE) que j'aimerais porter dans sharepoint en automatique. Doit bien y'avoir moyen de me guider .

[Lapinpanda]

Il existe des solutions payantes qui le propose, donc oui c'est faisable, gratuitement, difficilement.

[xanass]

Si c'était aussi simple je poserais pas la question et j'aurais prit une presta.

Malheureusement je dois me débrouiller comme un grand.

je demande pas une solution toute faite, juste un peu d'aide pour me guider pour savoir par ou commencer, ou une piste de réflexion.

[Lapinpanda]

Je dis cela parce qu'en faisant une rapide recherche sur google je n'ai trouvé aucun blog parlant de ça.

Si un blog parle de ça, alors tu as ta chance, sinon...

[SONY30]

Apparemment tu es en mesure de descendre tes pages HTML de portal.

Les étapes à suivre dans ton composant .net pourraient être les suivantes, pas encore assez de recul pour te dire comment faire mais cela me semble faisable ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
=> Parcourt et lecture d'un dossier
=> Pour chaque HTML rencontré
     => Création d'une page aspx dans une bibliothèque SharePoint
     => Ajout d'un composant WebPart Editeur de contenu
     => Fournir à l'éditeur de contenu le contenu de ton fichier HTML

Se pose quand même la question des images linkées dans tes fichiers html.

[xanass]

Merci sony,

c'est exactement ce que je pense faire, maintenant que j'y vois plus clair.

Il me faut une application (parser) qui décompose mon HTML et le reconstruit dans sharepoint.

Maintenant c'est dans le choix du type d'application que j'ai une grosse question : est-ce que je fais une application externe C# genre win32 pour faire ça ou il faut une application dans sharepoint?

J'ai vu qu'il y avait une librairie microsoft.sharepoint, ce qui veut dire que je dois pouvoir construire tout les objets avec cette librairie ou y'en a une autre?

[SONY30]

J'ai vu qu'il y avait une librairie microsoft.sharepoint, ce qui veut dire que je dois pouvoir construire tout les objets avec cette librairie ou y'en a une autre?

Oui tu dois pouvoir travailler sur tous les objets SharePoint avec cette librairie.
Pour les WebParts il te faudra aussi "System.Web.UI" mais celle-ci n'est pas spécifique Sharepoint.

[xanass]

J'ai pas specifiquement besoin de faire un webpart?

Comme je peux construire mon intranet via la référence, vu que tous les items sharepoint sont accessible.

A la base, je suis développeur C# orienté client lourd, donc j'ai plutot l'habitude de construire des applications Win32, ma société s'oriente de plus en plus vers du client léger ASP.NET, et la plateforme sharepoint. Donc pour moi il est naturel de contruire une application avec des ref ou directement connecté à la base de données, d'ou mes premières questions.

Je commence à mieux voir le fonctionnement de sharepoint, on a beau faire des formations, rien ne vaut un bon cas pratique pour se torturer les meninges.

Pour l'instant je vais partir sur une appli win32 (parser) qui transformera mes données Oracle en items sharepoint.

Longue vie à developpez.com
Je laisse le topic ouvert, j'essaierais de tenir à jour mon avancé, ça pourra peut être aider d'autres personnes.

merci pour les éclaircissements.

[SONY30]

Je laisse le topic ouvert, j'essaierais de tenir à jour mon avancé, ça pourra peut être aider d'autres personnes.

Tout à fait, moi le premier.

[xanass]

Salut,

J'ai fais beaucoup de recherche sur le sujet, j'ai utilisé beaucoup de source pour arriver à mes fins, ou du moins en être trés proche.

Donc l'idée globale est d'utiliser une appli Win32 ou console pour intégrer de façon automatique des pages HTML ou des données dans sharepoint2010.

Il ya des tutos sur Developpez.com qui donne des brides d'information mais pas la méthode globale d'ou mon post en espérant que ça aide d'autres personnes. Pour certain ça va paraitre évident (Je sents venir les links sur developpez.com), pour d'autres (comme moi) ce fut plus dure (Et google c'est pas ton ami quand tu connais pas les mots clés).

Il faut d'abord bien comprendre la hiérarchie des items sharepoint avant de commencer :

SiteCollections

|_ Sites

|_ webs

|_ Lists----------|_ Libraries

|_ Data----------|_ Files

Les lists correspondent à des données pures, exemple la liste du personnel.
Les libraries sont des bibliothèques de fichiers, elles correspondent à des types bien précis dans sharepoint (SPListTemplateType), choisissez bien le bon template pour vos fichiers sinon vous etes bon pour faire du move à la main.

Pour bien démarrer, il faut savoir que l'appli win32 doit obligatoirement être en X64 et Framework 3.5, sinon ça marche pas.

Ensuite il faut integrer la ref microsoft.sharepoint ( le path de la DLL est trouvable sur le net).

Maintenant le code, (j'ai pas fait de class spécifique je mets juste le code en vrac) :

Créer un site :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
using (SPSite siteCollection = new SPSite(URL_siteroot_sharepoint))
{
     using (SPWeb mySite = siteCollection.OpenWeb())
     {
          SPWebCollection subSites = mySite.Webs;
          subSites.Add(URL_new_site, site_Title, site_Description, 1033, "STS#1", true, false);
          mySite.AllowUnsafeUpdates = false;
     }
}
 
// 1033 = code langage en français
// "STS#1" = correspond au template "blank_site" il y en plein d'autre, si on met "GLOBAL" ça reprend le template du site root

... A suivre

[Lapinpanda]

Good tu as une bonne comprehension de sharepoint

[xanass]

Bon ben voici ma classe globale pour construire l'intégralité d'un site sharepoint par programmation.

La classe est loin d'etre parfaite et optimisée, mais elle a le mérite d'apporter la réponse à mon problème. C'est un peu barbare quelques fois à vous d'adapter si besoin.

La classe est en anglais car je code toujours tout en anglais vu que je bosse dans une boite américaine.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security;
using System.Security.AccessControl;
using System.Security.Permissions;
 
using Microsoft.SharePoint ;
using Microsoft.SharePoint.WebPartPages;
using Microsoft.SharePoint.WebControls ;
 
using System.IO;
 
namespace W32SP.Class
{
    /// <summary>
    /// Description : Class for parse information to sharepoint
    /// Use for : Create, modify, delete some items on sharepoint
    /// </summary>
    class CParserSP
    {
        protected String m_sRootURL = "";
        protected SPSite m_oSite;
        protected SPWeb m_oWeb;
        protected Exception m_xError;
 
 
        /// <summary>
        /// Description : Constructor of CParserSP
        /// </summary>
        /// <param name="p_sRootURL">Url of the SHAREPOINT root site, exemple : "HTTP://MySharepointsite"</param>
        public CParserSP(String p_sRootURL)
        {
            m_sRootURL = p_sRootURL;
            m_oSite = new SPSite(m_sRootURL);
            m_oWeb = m_oSite.OpenWeb();
 
            // Set read and write permission
            m_oSite.AllowUnsafeUpdates = true;
            m_oWeb.AllowUnsafeUpdates = true;
        }
 
 
 
        #region GET&SET
 
        #region m_oSite
        public SPSite get_oSite()
        {
            return m_oSite;
        }
 
        public void set_oSite(SPSite p_oValue)
        {
            m_oSite = p_oValue;
        }
        #endregion
 
        #region m_oWeb
        public SPWeb get_oWeb()
        {
            return m_oWeb;
        }
 
        public void set_oWeb(SPWeb p_oValue)
        {
            m_oWeb = p_oValue;
        }
        #endregion
 
#endregion
 
        #region CREATE
 
        /// <summary>
        /// Method for create a new site
        /// </summary>
        /// <param name="p_sNameURL">Name for URL (No space)= "my_new_site"</param>
        /// <param name="p_sSiteName">Title of the new site = "My New Site"</param>
        /// <param name="p_sDescription">Description for site = "my description of the site ..."</param>
        /// <param name="p_sTemplate">Template for site
        ///        "Team site": SiteTemplateCode = "STS#0"
        ///        "Blank Site": SiteTemplateCode = "STS#1"
        ///        "Document workspace": SiteTemplateCode = "STS#2"
        ///        "Basic meeting workspace": SiteTemplateCode = "MPS#0"
        ///        "Blank meeting workspace": SiteTemplateCode = "MPS#1"
        ///        "Decision meeting workspace": SiteTemplateCode = "MPS#2"
        ///        "Social meeting workspace": SiteTemplateCode = "MPS#3"
        ///        "Multipage meeting workspace": SiteTemplateCode = "MPS#4"
        ///        "Wiki": SiteTemplateCode = "WIKI#0"
        ///        "Blog": SiteTemplateCode = "BLOG#0"
        ///        "Document center": SiteTemplateCode = "BDR#0"
        ///        "Records center": SiteTemplateCode = "OFFILE#0"
        ///        "Define routes for incoming files": SiteTemplateCode = "OFFILE#1"
        ///        "Publishing site": SiteTemplateCode = "CMSPUBLISHING#0"
        ///        "Publishing site With Workflows": SiteTemplateCode = "BLANKINTERNET#0"
        ///        "Press releases site": SiteTemplateCode = "BLANKINTERNET#1"
        ///        "Publishing site with workflow": SiteTemplateCode = "BLANKINTERNET#2"
        ///        "News and Articles": SiteTemplateCode = "SPSNHOME#0"
        ///        "Report center": SiteTemplateCode = "SPSREPORTCENTER#0"
        ///        "Intranet Divisional Portal": SiteTemplateCode = "SPSPORTAL#0"
        ///        "Profile Site": SiteTemplateCode = "PROFILES#0"
        ///        "Publishing porta": SiteTemplateCode = "BLANKINTERNETCONTAINER#0" </param>
        /// <returns>   Normal : SPWeb >> New site </returns>
        /// 
        public SPWeb CreateSite(String p_sNameURL, String p_sSiteName, String p_sDescription,String p_sTemplate)
        {   
            SPWebCollection oWebCol = m_oWeb.Webs;
            SPWeb oNewSite = oWebCol.Add(p_sNameURL, p_sSiteName, p_sDescription, 1033, p_sTemplate, true, false);
            m_oWeb.AllowUnsafeUpdates = false;
 
            return oNewSite;
        }
 
 
 
 
        /// <summary>
        /// Method for create a new list
        /// </summary>
        /// <param name="p_sRootWeb">Root web for list</param>
        /// <param name="p_oTemplateType">Template Type for list</param>
        /// <param name="p_sLibName">Name of the list</param>
        /// <returns>   Normal : SpList >> New list</returns>
        /// 
        public SPList CreateList(SPWeb p_sRootWeb, String p_sLibName, SPListTemplateType p_oTemplateType)
        {   
            Guid oListId = p_sRootWeb.Lists.Add(p_sLibName, null, p_oTemplateType);
            return p_sRootWeb.Lists[oListId];
        }
 
 
 
 
        /// <summary>
        /// Method for create a new Item in list
        /// </summary>
        /// <param name="p_oRootList">Root List</param>
        /// <param name="p_oItemType">Type if the item</param>
        /// <param name="p_sItemName">Name of the item</param>
        /// <returns>   Normal : SPListItem </returns>
        /// 
        public SPListItem CreateListItem(SPList p_oRootList,String p_sItemName,SPFileSystemObjectType p_oItemType)
        {
            SPListItem oListItem = p_oRootList.Items.Add("" , p_oItemType, p_sItemName);
            oListItem.Update();
 
            return oListItem;
        }
 
 
 
 
        /// <summary>
        /// Method for create a Subfolder
        /// </summary>
        /// <param name="p_oFolderCol">the root collection to attache this folder</param>
        /// <param name="p_sFolderName">Name of the folder</param>
        /// <returns>   Normal : SPFolder </returns>
        /// 
        public SPFolder  CreateSubFolder(SPFolderCollection p_oFolderCol, String p_sFolderName)
        {
            SPFolder oNewFolder = p_oFolderCol.Add(p_sFolderName);
            oNewFolder.Update();
 
            return oNewFolder;
        }
 
 
 
 
        /// <summary>
        /// Method for create a wikipage
        /// </summary>
        /// <param name="p_oRootList">the root list</param>
        /// <param name="p_sPageName">Name of the page with .aspx</param>
        /// <param name="p_sPageURLName">Relative-URL to put the page with the name and .aspx file</param>
        /// <returns>   Normal : SPListItem </returns>
        /// 
        public SPListItem CreateWikiPage(SPList p_oRootList, String p_sPageURLName ,String p_sPageName,String p_sContent)
        {
            SPFolder oFolder = p_oRootList.RootFolder;
            SPFileCollection oFileCol = oFolder.Files;
            SPFile oWikiFile = oFileCol.Add(p_sPageURLName, SPTemplateFileType.WikiPage);
            SPListItem oWikiPage = oWikiFile.Item;
            oWikiPage["Name"] = p_sPageName;
            oWikiPage["Wiki Content"] = p_sContent;
            oWikiPage.Update();
 
            return oWikiPage;          
        }
 
 
 
        /// <summary>
        /// Method for create a Webpart in wikipage
        /// </summary>
        /// <param name="p_oPage">The Wiki page where you want to put the webpart</param>
        /// <param name="p_oList">WebPart List</param>
        /// <param name="p_sNameWebPart">Name of the WebPart</param>
        /// <returns>   none </returns>
        ///
        public void InsertListWebPart(SPFile p_oPage, SPList p_oList, String p_sNameWebPart)
        {
            SPLimitedWebPartManager  oWPmng = p_oPage.GetLimitedWebPartManager(System.Web.UI.WebControls.WebParts.PersonalizationScope.Shared);
            XsltListViewWebPart oWP = new XsltListViewWebPart()
            {
                ListId = p_oList.ID,
                Title = p_sNameWebPart
            };
            oWPmng.AddWebPart(oWP,"WPLibrary",100);
        }
 
 
 
        #endregion
 
        #region FILES
        /// <summary>
        /// Method for upload a file
        /// </summary>
        /// <param name="p_oRootFolder">the destination root folder</param>
        /// <param name="p_sFilePath">full path of file with namefile and extension</param>
        /// <param name="p_sFileName">Name of the file with extension</param>"
        /// <returns>   Normal : SPFile </returns>
        /// 
        public SPFile UploadFile(SPFolder p_oRootFolder, String p_sFilePath, String p_sFileName)
        {
            SPFileCollection oFileCol = p_oRootFolder.Files;
            String sFileURL = p_oRootFolder.ServerRelativeUrl + "\\" + p_sFileName;
            Stream oStream = File.Open(p_sFilePath, FileMode.OpenOrCreate);
            Byte[] bContents = new Byte[oStream.Length];
            oStream.Position = 0;
            oStream.Read(bContents, 0, (int)oStream.Length);
            oStream.Close();
            SPFile oFile = p_oRootFolder.Files.Add(sFileURL, bContents);
            return oFile ;
        }
 
        /// <summary>
        /// Method for upload a Binary file
        /// </summary>
        /// <param name="p_oRootFolder">the destination root folder</param>
        /// <param name="p_bContents">Binary content</param>
        /// <param name="p_sFileName">Name of the file with extension</param>"
        /// <returns>   Normal : SPFile </returns>
        ///
 
        public SPFile UploadBinaryFile(SPFolder p_oRootFolder, Byte[] p_bContents, String p_sFileName)
        {
 
            SPFileCollection oFileCol = p_oRootFolder.Files;
            String sFileURL = p_oRootFolder.ServerRelativeUrl + "\\" + p_sFileName;
            SPFile oFile = p_oRootFolder.Files.Add(sFileURL, p_bContents);
            return oFile;
        }
 
        #endregion
 
    }
}

[xanass]

Et voilà comment on s'en sert.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
            m_oParserSharepoint = new CParserSP("http://monsitesharepoint");
 
            // Create Page group as a site
            SPWeb oWebSite = m_oParserSharepoint.CreateSite("PortalSite", "PortalSite", "", "STS#1");
 
            #region Lists/Library Process
            // Create Document Library
            SPList oDocLibrary = m_oParserSharepoint.CreateList(oWebSite, "DocumentsLibrary", SPListTemplateType.DocumentLibrary);
 
            // Create Web page Library
            SPList oWebLibrary = m_oParserSharepoint.CreateList(oWebSite, "WebPagesLibrary", SPListTemplateType.WebPageLibrary);
 
            // Create Picture Library
            SPList oPicLibrary = m_oParserSharepoint.CreateList(oWebSite, "PicturesLibrary", SPListTemplateType.PictureLibrary);
            #endregion
 
            #region Folder Process
 
            // Create Folder in documents Library
            SPListItem oFolder = m_oParserSharepoint.CreateListItem(oDocLibrary, "Folder_lvl1", SPFileSystemObjectType.Folder);
 
            // Create SubFolder in Documents library
            SPFolderCollection oFolderColl = oWebSite.GetFolder(oFolder.Url).SubFolders;
            SPFolder oSubFolder = m_oParserSharepoint.CreateSubFolder(oFolderColl, "Folder_lvl2");
 
            #endregion
 
            #region Document Process
            // Insert document
            SPFile oFile = m_oParserSharepoint.UploadFile(oFolder.Folder, AppDomain.CurrentDomain.BaseDirectory + "XML\\109-174564.xml", "109-174564.xml");
 
            #endregion
 
            #region WebPage process
            // Create Wiki HTML content
            String sWikiHtmlContent = "<h2>Ceci est du HTML</h2>";
 
           // Create WikiPage
            SPListItem oWikipage = m_oParserSharepoint.CreateWikiPage(oWebLibrary, oWebLibrary.RootFolder.ServerRelativeUrl + "/myWikiPage3.aspx", "myWikiPage3.aspx", sWikiHtmlContent);
            #endregion

En espérant que ça aide d'autre personne, ma fallu plusieurs jours de recherche intense pour réussir mon objectif.

Pour moi mon problème est résolu, mais je suis loin d'avoir fini.

[Lapinpanda]

je n'ai pas vu d'Update()

Cela n'est plus nécessaire en 2010?

[xanass]

En fait je ne fais que générer les objets, je ne modifie pas le contenu sauf lors de la création de la page wiki ou j'insere du code html et il y a bien un Update() de la page.

L'Update() est toujours d'actualité si tu modifie les données des columns d'une list, un item, un field ... mais pas à la création