Un Control Adapter permet de modifier l’apparence de contrôles en récupérant le flux HTML généré par celui-ci.
Dans le cadre de SharePoint on peut du coup l’utiliser pour venir modifier l’apparence de certains contrôles natifs.
Pour cela, il faut créer une classe qui héritera de la classe ControlAdapter (dans l’espace de noms System.Web.UI.Adapters) et venir redéfinir la méthode Render :
public class InputFormDropDownListAdapter : ControlAdapter
{
protected override void Render(System.Web.UI.HtmlTextWriter writer)
{
StringBuilder sb = new StringBuilder();
HtmlTextWriter htw = new HtmlTextWriter(new StringWriter(sb));
base.Render(htw);
string stringToWrite = sb.ToString();
//Modifier la chaine "stringToWrite" à écrire dans le rendu du contrôle...
writer.Write(stringToWrite);
}
}
Il faut maintenant mettre en place la prise en compte de ce ControlAdapter par le navigateur.
Pour cela, il faut se placer dans le constructeur de la masterPage
qui sera utilisée par SharePoint :
public SiteMaster()
{
var adapters = HttpContext.Current.Request.Browser.Adapters;
var key = typeof(Microsoft.SharePoint.Portal.WebControls.InputFormDropDownList).AssemblyQualifiedName;
if (!adapters.Contains(key))
{
var adapter = typeof(InputFormDropDownListAdapter).AssemblyQualifiedName;
adapters.Add(key, adapter);
}
}
La clé de l’entrée du dictionnaire correspond au nom de l’assembly du type du contrôle dont
on viendra modifier l’apparence.
La valeur de l’entrée du dictionnaire correspond au nom de l’assembly du controlAdapter
que l’on a développé plus haut.
Il est ainsi possible de modifier l’apparence des contrôles natifs de SharePoint…
A première vue, une page contenant des webpart peut ne plus pouvoir être éditée si l’une des webparts contenue dedans plante.
Dans ces cas-là, un raccourci très simple permet d’éditer le contenu de la page via le menu d’administration de celle-ci. Pour cela, il suffit d’ajouter à l’URL le querystring suivant : ?contents=1
Exemple : http://mysharepointsite.com/mywebpartpageaspx?contents=1
Voici l’affichage que vous obtiendrez :
A vous ensuite de faire les modifications qui s’imposent pour que la page soit à nouveau fonctionnelle…
Dans SharePoint 2010 et plus précisément dans la partie “Réseau Social” du produit, il est possible d’ajouter un autre utilisateur en tant que collègue.
L’ajout d'un collègue est unidirectionnel : c’est-à-dire que lorsqu'une personne ajoutera une autre dans sa liste des collègues, le collègue ne verra cependant pas dans sa liste celui qui vient de l’ajouter.
Dans le cas de la mise en place d’une mise en relation comme Facebook par exemple, lorsqu’un utilisateur accepte la requête d’un autre, l’un est ajouté dans la liste de contacts de l’autre et inversement.
Pour réaliser cela avec SharePoint, on peut se dire que c’est très simple mais j’ai fait face à un petit soucis : lorsque l’utilisateur connecté accepte la requête, l’ajout du collègue dans sa propre liste fonctionne mais l’inverse ne fonctionne pas et on obtient une erreur de sécurité. En effet, il est impossible d’ajouter un collègue dans la liste d’un autre utilisateur que celui dans lequel le contexte tourne. Et ce, même en élévation de privilèges…
Il y a un hack possible pour “shooter” le contexte utilisateur pour faire en sorte que la requête passe :
public void AddToColleagues(UserProfile user, UserProfile colleagueToAdd, SPSite currentSite)
{
SPSecurity.RunWithElevatedPrivileges(delegate()
{
using (SPSite site = new SPSite(currentSite.Url))
{
using (SPWeb web = ssite.OpenWeb())
{
SPServiceContext context = SPServiceContext.GetContext(site);
//On sauvegarde le contexte
HttpContext currentContext = HttpContext.Current;
//On “shoote” le contexte
HttpContext.Current = null;
UserProfileManager profManager = new UserProfileManager(context);
user.Colleagues.CreateWithoutEmailNotification(colleagueToAdd, ColleagueGroupType.General, impersUser.Colleagues.GetGroupList()[0], false, Privacy.Public);
colleagueToAdd.Colleagues.CreateWithoutEmailNotification(user, ColleagueGroupType.General, impersUser.Colleagues.GetGroupList()[0], false, Privacy.Public);
//On recharge le contexte
HttpContext.Current = currentContext;
}
}
});
}
Pour modifier programmatiquement le titre et la description d'une webpart présente dans un site SharePoint, il faut pouvoir l'atteindre depuis la galerie de webpart.
Cette galerie de webpart est accessible depuis les paramètres du site :
L’idée est donc toute simple : aller récupérer l’item de cette liste contenant les fichier “.dwp” ou “.webpart” correspondant aux webparts. Une fois l’item souhaité récupéré, il suffit d’en modifier les métadata comme bon nous semble.
Dans l’exemple qui suit, j’ai souhaité modifier les métadata de la webpart "Colleagues" présente nativement dans SharePoint 2010. Celle-ci permet de visualiser la liste de ses collègues (partie Réseau Social de SharePoint).
using (SPSite site = new SPSite(mysiteUrl))
{
using (SPWeb web = site.OpenWeb())
{
SPList wpList = site.GetCatalog(SPListTemplateType.WebPartCatalog);
SPListItem colleagueItem = null;
foreach (SPListItem item in wpList.Items)
{
if (item["LinkWebPart"].ToString().Equals("Colleagues.dwp"))
{
colleagueItem = item;
break;
}
}
if (colleagueItem != null)
{
colleagueItem.Properties["vti_title"] = "Contacts";
colleagueItem.Properties["vti_cachedtitle"] = "Contacts";
colleagueItem.Properties["WebPartDescription"] = colleagueItem["WebPartDescription"].ToString().Replace("colleague", "contact").Replace("colleagues", "contacts");
colleagueItem.SystemUpdate(false);
}
}
}
Voilà le résultat lorsque l’utilisateur souhaite ajouter la webpart dans une page :
[EDIT]
Remplacement de SPList wpList = web.Lists["Web Part Gallery"]; par SPList wpList = site.GetCatalog(SPListTemplateType.WebPartCatalog);
[/EDIT]
Peut-être avez-vous déjà obtenu cette exception finalement peu explicite face à son moyen de résolution.
En utilisant un objet SPSite ou SPWeb venant du contexte courant sans l'utiliser au sein d'une instruction using, il se peut que vous rencontriez cette erreur.
Attention aux bonnes pratiques, utiliser ces objets comme ceci :
using (SPSite site = new SPSite(SPContext.Current.Site.Url))
{
//Votre code ici
}
Avec SharePoint 2007, le déploiement de solutions WSP se faisait à l'aide de l'outil en ligne de commande stsadm.
Avec SharePoint 2010, l'outil à privilégier pour déployer ces solutions est PowerShell.
Voici les cmdlet à exécuter pour la gestion du déploiement d'une solution WSP :
Add-SPSolution C:\path\mySolution.wsp
Install-SPSolution -Identity mySolution.wsp -WebApplication http://myWebApp -GACDeployment
Uninstall-SPSolution -Identity mySolution.wsp -WebApplication http://myWebApp
Remove-SPSolution -Identity mySolution.wsp
Update-SPSolution -Identity mySolution.wsp -LiteralPath C:\path\mySolution.wsp -GACDeployment
In my previous article I presented how to create a basic window as new feature in the SCCM management console.
Then, I’ll show how to interact with SCCM objects thanks to the SCCM SDK. In this article I’ll show the software distribution part.
Software distribution consists of deploying applications on a set of client computers or servers.
With SCCM, this operation is accomplished thanks to 3 objects :
- A package : this object contains programs that will be executed at deployment. For example, a package called Silverlight could contain 2 programs (an installation program and an uninstallation one). A program of a package is an executable file.
- A collection : this object is a computer container. It is used to group clients thanks to queries such as “Which OS do they run under ?” or “Clients with Silverlight installed”, etc…
- An advertisement : this is the object used to deploy a program of a package on a collection. It is the link between a program’s package and a collection.
As I mentioned in my previous article, the SDK is a WMI .NET wrapper. Every SCCM object in that wrapper is typed as a IResultObject object.
Firstly, to manipulate SCCM objects through the wrapper, you should open/get a connection to the SCCM server in order to process operations on it. In our case, we’ll directly operate inside the SCCM management console (as I explained in my previous post).
You can access the connection manager through a property of our window :
| WqlConnectionManager connection = (WqlConnectionManager)PageData.PropertyManager.ConnectionManager; |
To access properties of an IResultObject object, you should get or set them thanks to an indexer. It means that you access properties with a string. You’ll have to know each of the properties of your object that you are manipulating.
Let’s see an example while creating an advertisement :
| IResultObject myAdvertisement = connection.CreateInstance("SMS_Advertisement"); |
The
CreateInstance method will create an instance of the class that you specified as a parameter. To find the type of the object that you want to create, the msdn will be so helpful ! In fact, you’ll always need the msdn in order to know each property of the objects you want to manipulate. For example, navigate to the
SMS_Advertisement class msdn page.
In this way, you can now set the name of the advertisement by doing this :
| myAdvertisement["AdvertisementName"].StringValue = “My new advertisement”; |
As you can see, properties are not typed, it’s your job to know their type and to chose the value type of the property (StringValue, BooleanValue, etc…).
Another operation that you can do with the SDK is to execute WQL (WMI Query Language) queries. This query language is similar to classic SQL query language.
You just have to call the ExecuteQuery method from the QueryProcessor object of your connection manager object.
| WqlConnectionManager connection = (WqlConnectionManager)PageData.PropertyManager.ConnectionManager;
IResultObject result = connection.QueryProcessor.ExecuteQuery(“SELECT * FROM SMS_Advertisement”); |
To dive into something more practical, we can try to get a program from a specific package and assign it to a computer collection through an advertisement :
- First, we’ll create a reusable method in order to execute a WQL query and return its result :
| private IResultObject ExecuteQuery(string query)
{
try
{
WqlConnectionManager connection = (WqlConnectionManager)PageData.PropertyManager.ConnectionManager;
return connection.QueryProcessor.ExecuteQuery(query);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
return null;
}
} |
- Then, let’s get a package called “MyPackage” :
| private IResultObject GetMyPackage()
{
try
{
IResultObject packages =
ExecuteQuery("SELECT * FROM SMS_Package WHERE Name='MyPackage’");
foreach (IResultObject p in packages)
{
return p;
}
return null;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
return null;
}
} |
- We can now retrieve (for example) an “INSTALL” program from this package :
private IResultObject GetInstallPackageProgram(IResultObject package)
{
try
{
IResultObject programs = ExecuteQuery(string.Concat(“SELECT * FROM SMS_Program WHERE PackageID=’”, package[“PackageID”].StringValue, “’”));
foreach(IResultObject p in programs)
return p;
}
catch(Exception ex)
{
MessageBox.Show(ex.Message);
return null;
}
} |
- After that, let’s retrieve a specific collection (precisely its ID) called “MyCollection” where to deploy the advertisement we will create below :
| private string GetMyCollectionID(string collectionName)
{
try
{
IResultObject collectionIDs = ExecuteQuery(“SELECT CollectionID FROM SMS_Collection WHERE Name=’MyCollection’”);
foreach(IResultObject c in collectionIDs)
return c;
}
catch(Exception ex)
{
MessageBox.Show(ex.Message);
return null;
}
} |
- At least, we will create the advertisement in order to associate the package program and the collection. With this operation, the program will be deployed on the collection :
| private IResultObject CreateMyAdvertisement()
{
try
{
WqlConnectionManager connection = (WqlConnectionManager)PageData.PropertyManager.ConnectionManager;
IResultObject myPackage = GetMyPackage();
IResultObject newAdvertisement = connection.CreateInstance("SMS_Advertisement"); newAdvertisement["CollectionID"].StringValue = GetMyCollectionID();
newAdvertisement["AdvertisementName"].StringValue = “MyAdvertisement”;
newAdvertisement["PackageID"].StringValue = myPackage[“PackageID”].StringValue;
newAdvertisement["ProgramName"].StringValue = GetInstallPackageProgram(myPackage);
newAdvertisement.Put();
newAdvertisement.Get(); return newAdvertisement;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
return null;
}
} |
The Put() method effectively creates the advertisement object in SCCM. You can see it appear in the advertisement list though.
The Get() method refreshes the properties of the current object.
A short briefing about the product itself : “System Center Configuration Manager 2007 R2 comprehensively assesses, deploys, and updates servers, client computers, and devices-across physical, virtual, distributed, and mobile environments”
IT administrators use the administration console in order to process operations on the infrastructure (OS & application deployment, software metering, reporting, etc…). The management console is shown below :
This console is extensible thanks to the SCCM SDK (you can download it here). This SDK consists of a .NET WMI wrapper. This wrapper allow us, for example, to extend the console by adding new menus and/or windows in it. It is also possible to develop tierce applications which interact with SCCM thanks to the provided SDK.
For this first article about SCCM development, I’ll show how to create a new window available in the management console by clicking on a new context menu item.
First, Open Visual Studio => create a Windows Forms Control Library project.
Then, add the following references to the project :
- admin.wqlqueryengine.dll
- microsoft.configurationmanagement.dll
- microsoft.configurationmanagement.managementprovider.dll
- Microsoft.ManagementConsole.dll
Note : These dll are present in the SCCM installation folder : “\Microsoft Configuration Manager\AdminUI\bin\”
After that, modify the base class of the windows forms. In SCCM our window will not inherit from “UserControl” but from SmsCustomDialog.
Now, change the namespace of the application to include the following base namespace : Microsoft.ConfigurationManagement.AdminConsole.
In my example, the namespace of the application would be “Microsoft.ConfigurationManagement.AdminConsole.MyFirstSccmApplication”.
Override the Initialize method. This method will get the data context of the management console from which it has been called.
Now, you can create the design of your window as if you were developing a classical windows form.
As the screenshot above shows, we’ll do it easy first ! When clicking on the button a MessageBox will appear. A classical and mythical “Hello World” will appear.
Here is the code-behind :
|
public partial class SayHelloWindow: SmsCustomDialog
{
public SayHelloWindow()
{
InitializeComponent();
}
public override bool Initialize(System.Reflection.Assembly assembly, SmsFormData propertySheet, SmsPageData pageData)
{
base.Initialize(assembly, propertySheet, pageData);
return true;
}
private void btnSayHello_Click(object sender, EventArgs e)
{
MessageBox.Show("Hello world !!");
}
}
|
The big question is now : How can we access to that beautiful and so functional window ?!
First, copy all assemblies resulting from the compilation of the VS project and paste them to the bin folder of the management console : “\Microsoft Configuration Manager\AdminUI\bin”
Custom extensions that you develop will be available in the management console by editing two XML files though:
- One file to reference the assembly of the custom window (SayHelloDialog.xml) :
<?xml version="1.0" encoding="utf-8"?>
<SmsFormData FormatVersion="1.0" xmlns=”http://schemas.microsoft.com/SystemsManagementServer/2005/03/ConsoleFramework”>
<Form Id="{ED8B671C-64E4-4ffd-BC99-8CC185195D3C}" CustomData="User Properties" FormType="CustomDialog" >
<Assembly Name="MyFirstSccmApplication" Namespace="Microsoft.ConfigurationManagement.AdminConsole.MyFirstSccmApplication" ClassType="SayHelloWindow"/>
</Form>
</SmsFormData> |
- One file to create the context menu item on which the window can be instanciated (SayHelloAction.xml) :
|
<ActionDescription Class="ShowDialog" DisplayName="Say Hello" MnemonicDisplayName="Mnemonic" Description="Say Hello to the world">
<DialogId>SayHelloDialog</DialogId>
</ActionDescription>
|
Note: The value of the “DialogId” tag in the second XML file should match the name of the first XML file.
Note (bis): The value of the “Id” attribute of the “Form” tag is manually generated thanks to the guidgen.exe tool.
The two files are located in the following folders:
- SayHelloActions.xml => “\Microsoft Configuration Manager\AdminUI\XmlStorage\Extensions\Actions\{GUID}\”
- SayHelloDialog.xml => “\Microsoft Configuration Manager\AdminUI\XmlStorage\Extensions\Forms\”
{GUID} => This is the GUID corresponding to the object which the window will appear.
For example, to enable a new context menu item while right clicking on a package in the management console, you’ll have to put the XML file in “\Microsoft Configuration Manager\AdminUI\XmlStorage\Extensions\Actions\3ad39fd0-efd6-11d0-bdcf-00a0c909fdd7\”.
The list of the useful GUID can be found here.
Then you should have the following results 
Access to the part 2 of my posts about SCCM development here.
Vous souhaitez découvrir les nouvelles technologies Microsoft, les ExaTech Days sont là pour vous !
Venez nous rejoindre à Toulouse le 8 Juin 2010 :
Et à Nantes le 15 Juin 2010 :
J’animerai une session sur Windows Phone 7 à Toulouse et à Nantes en collaboration avec Julien Dollon.
Tout a commencé il y a un peu plus d’un an lorsque Julien, Olivier et moi-même avons décidé de participer au concours Imagine Cup. Passionnés par les technologies Microsoft et en particulier par les technologies .NET, il va de soi que participer au plus grand concours sur les nouvelles technologies organisé par Microsoft est un beau challenge !
De plus, étant donné que nous sommes dans la même classe et que nous travaillions alors sur un projet commun à savoir la communauté Dotnet-France, nous ne pouvions pas ne pas y participer ! Mais pour avoir une équipe complète, il nous manquait un membre + un mentor. Nous nous sommes alors tournés vers deux personnes que nous connaissions de SUPINFO : Yann Lautredou (à l’époque directeur du laboratoire .NET de SUPINFO) en tant que mentor et Mauricio Diaz Orlich (à l’époque directeur du laboratoire Web&Dev de SUPINFO).
Atout supplémentaire pour l’équipe, Mauricio étant MSP, il faisait grimper le quota à 3 MSP au total dans l’équipe en plus de Julien et Olivier.
![clip_image002[4]](http://blogs.dotnet-france.com/bertrandv/image.axd?picture=clip_image002%5B4%5D_thumb.jpg "clip_image002[4]")
De gauche à droite, Olivier Courtois, Julien Dollon, Vincent Bouatou (Microsoftee), Mauricio Diaz Orlich et Bertrand Vergnault
Pour rappel voici le thème de l’année : « Imaginez un monde où la technologie nous aide à répondre aux enjeux les plus cruciaux de notre société ».
Ce thème étant très vaste, nous avons mis du temps pour nous focaliser sur une problématique et en ressortir un réel projet à présenter pour ce concours : une solution de protection des enfants sur Internet.
Comment en sommes-nous arrivés à la définition de ce projet ? Olivier ayant travaillé pendant plusieurs années avec l’association Docteur Souris dont le but est d’apporter les nouvelles technologies dont Internet aux enfants hospitalisés de longue durée, une problématique est très vite ressortie : Comment assurer la sécurité des enfants sur Internet de façon fiable et sûre ?
C’est donc à cette problématique que nous avons souhaité apporter un élément de réponse et de le présenter au concours Imagine Cup dans la catégorie Software Design, catégorie reine de la compétition.
Concernant, la définition du projet et des partenaires, je vous renvoie vers l’article d’Olivier où sont exposés tous les documents que l’on a rendu pour la compétition.
En ce qui concerne la répartition des rôles, il a été défini deux chefs de projet à savoir Olivier et Julien. Olivier s’occupant des relations avec le partenaire principal (Docteur Souris) ainsi que de la partie communication externe. Julien pris la responsabilité technique du projet ainsi que le rôle de designer de l’équipe.
Concernant le développement des applications composant la solution de protection des enfants sur Internet, elle a été divisé comme suit : un développeur pour le site web de la communauté réalisé à l’aide de SharePoint 2007, un développeur sur la partie moteur communautaire permettant de centraliser et d’analyser tous les résultats des évaluations des sites web testés, un développeur sur la partie contrôle parental PC qui consiste en le client installé sur l’ordinateur familial et qui permet d’analyser et de rediriger en cas de besoin le trafic http et enfin un développeur dont le rôle était de développer les différents « bookmarklets » permettant à un utilisateur de pouvoir soumettre et de pouvoir noter un site très facilement.
Grâce à ce projet, nous avons eu la chance de pouvoir être sélectionné pour la finale française de la compétition. Pour cela, il a fallu rédiger un document d’une quinzaine de page (disponible sur le blog d’Olivier) permettant de présenter l’équipe, la problématique choisie, la solution à cette problématique ainsi que les technologies employées pour arriver à nos fins.
Nous faisions donc partie des 6 équipes finalistes et afin de nous préparer au mieux pour le grand moment de la soutenance devant le jury de la finale française, Microsoft avait organisé un week-end de coaching pour toutes les équipes retenues.
Ce bootcamp a été organisé dans un grand hôtel en banlieue parisienne…une sorte de mise au vert avant le grand rendez-vous !
Au programme du week-end : échanges avec des membres de la DPE de Microsoft à propos de la problématique et des technologies employées pour la résoudre, mise en place d’un « elevator pitch » permettant de vendre notre projet en quelques mots ainsi qu’un travail de réflexion sur la mise en place d’un business plan pour notre solution.
Salles d’ateliers durant le bootcamp
Nous avons donc pu nous rendre compte que l’on avait absolument pas assez bossé…et les membres de la DPE qui étaient présents ne se sont pas gênés pour nous le faire remarquer :D Tout ceci bien sûr dans l’optique de nous donner un coup de fouet pour que l’on se mette à 300% sur le projet !
Ce week-end a été conclu par un passage devant un jury blanc afin de nous entrainer à la mise en place de notre discours durant la finale française.
Nos deux chefs de projet ;)
Pour notre équipe, ce week-end de coaching a constitué une étape importante puisqu’il s’agissait en fait de la première vraie rencontre entre tous les membres de l’équipe : Mauricio et Yann étant basés à Paris, nous n’avions pas pu jusqu’alors nous rassembler ! L’effet de cohésion dans l’équipe ne s’en ai vu qu’augmentée après ce week-end ;)
Après ce bootcamp intense, nous nous sommes donc remis au travail de plus belle afin d’être prêt pour la finale française qui avait lieu dans les locaux de la DPE, rue de l’Université à Paris.
Mais dans l’optique de réaliser une prestation de grande qualité, Olivier, Julien et moi avons rejoint Mauricio et Yann à Paris 3 jours avant le jour de la finale. SUPINFO nous a accueilli dans ses locaux rue de Bassano où l’on a pu préparer notre présentation : les slides, les démos, le story-telling, etc…devant plusieurs membres de l’administration comme Marc Pybourdin, Thierry Boidart ainsi que certains des directeurs de labo de SUPINFO. Durant ces 3 jours de préparation, nous avons modifié, déplacé, supprimé, réajusté les démos, les diapos de présentation, etc…afin d’obtenir le résultat présent sur le blog d’Olivier (en ce qui concerne la présentation en elle-même).
Puis le jour de la finale tant attendue arriva : attente insoutenable dans les locaux de la DPE puis premier passage devant un premier jury composé entre autres de Vincent Bellet et Pascal Belaud. La présentation se passe à merveille : Mauricio enchaîne le speech en anglais, les démos passent nickel ainsi que l’engouement du jury lors des réponses à leurs questions.
Mais ce n’est pas fini, il reste un second jury à convaincre !!...Il reste encore 20 minutes de présentation + 10 minutes de réponse aux questions avant d’aller pouvoir se détendre et profiter de la réception organisée par MS :D
Le second jury est composé de responsables d’associations ainsi que Guillaume Belmas, MVP. Ce second jury nous a valu quelques frayeurs et nous l’avons senti moins convaincu face à notre propos mais cependant, nous étions plutôt contents de nos deux prestations.
Une fois ce moment passé, direction le premier étage de la Tour Eiffel : Microsoft aime faire les choses en grand et c’est dans ce symbole parisien que nous avons pu fêter et faire partager notre projet aux invités. Chaque équipe avait en effet à disposition un stand lui permettant d’exposer son projet aux différents journalistes, Microsoftees, personnages politiques, etc…présents lors de cette réception.
Vint ensuite le moment tant redouté de l’annonce des résultats…ce moment qui nous a valu une terrible déception (nous souhaitions évidemment la première place !) : nous sommes annoncé comme 3ème !...médaille de bronze…le billet vers la finale mondiale au Caire en Egypte nous passe sous le nez !
Notre “médaille” pour la 3ème place à la finale française
Nous repartons alors un peu déçu mais avec notre lot de consolation sous le bras (une Xbox 360)…
Ce n’est seulement que le lendemain où nous discutons avec les autres membres de l’équipe et poussé par Vincent Bouatou pour participer à un des awards organisé durant le concours. L’award en question se prénommant : H.E. Mrs. Suzanne Mubarak Special Award. En effet, la femme du Président Egyptien étant fondatrice d’une fondation pour la protection des enfants, l’égalité des femmes, etc…et dont le sujet de cet award devait rassembler les 5 meilleures équipes parmi celles du monde entier de la catégorie Software Design qui répondaient aux buts de cette fondation, nous avons donc pu nous inscrire à cette catégorie.
Il a fallu rédiger de nouveau un document, de 5 pages maximum, expliquant notre projet.
Une semaine plus tard nous avons eu la très très bonne surprise d’apprendre que nous avions été sélectionné directement pour la finale mondiale au Caire en Egypte parmi les 94 équipes qui s’étaient présentées pour cette catégorie.
Nous prenons notre revanche sur la déception de la finale française !...A nous le Caire !!!
Nous avons pu aussi voir nos adversaires : 4 autres équipes de nationalité américaine, égyptienne, polonaise et une équipe indonésienne.
La finale mondiale a été une semaine exceptionnelle : entre l’hôtel 5 étoiles luxueux, les visites des pyramides et du sphinx, les échanges avec les étudiants du monde entier et pour finir en apothéose avec le World Festival devant les pyramides et la remise des prix !!
L’équipe en compagnie de Vincent Bouatou devant notre stand à la finale mondiale
Cette expérience a été pour nous l’une des plus riches de notre vie. Non seulement en termes de découverte du monde (différentes cultures) mais aussi sur la conduite de projet, technique et surtout le fait de porter une idée et de se battre pour que l’on le croit en nous.
Auteur : Bertrand Vergnault
Co-Auteur : Julien Dollon
Remise du prix pour la 3ème place à la finale mondiale (on peut noter que Mauricio se prépare à twitter l’info :D )
World Festival devant les Pyramides