Création d’un outil d’installation et de mise à jour d’applications Windows Modern Ui

Dans le cadre du déploiement d’une application métier développée sous Windows 8.1, vers une cinquantaine d’utilisateurs au cours du mois de mai dernier, nous nous sommes ainsi confrontés à la problématique du déploiement de l’application à nos utilisateurs, notamment de part l’absence de store d’entreprise.

A l’heure où je publie ce billet, Windows a annoncé un store pour les entreprises sur Windows 10, d’ici fin 2015.

En attendant, cette solution peut très bien s’appliquer à des applications sous Windows 10.

[MEETUP] Soft’it héberge le tout premier meetup dédié à AureliaJS autour d’un apéro

Auteur original, de notre ancien blog : Philippe Beroucry

Vous n’avez jamais entendu parler d’AureliaJS et vous n’êtes toujours pas parti en vacances ? Alors, Soft’it vous propose d’assister à un apéro autour de ce framework JavaScript très prometteur.

Ce premier meetup, organisé par Etienne Folio et Quentin Raynaud, permettra d’aborder le futur de ce meetup mais également :

  1. D’échanger autour d’Aurelia
  2. De discuter sur les différents frameworks ES6 actuellement disponibles
  3. De débattre d’une comparaison entre Angular2 vs Aurelia
… et bien d’autres choses.
Cet événement se déroulera ce mercredi 5 août à partir de 19h dans les locaux de Soft’it. Si vous souhaitez y participer (il reste encore des places), inscrivez-vous sur le meetup suivant :
A bientôt,
L’équipe Soft’it 

[Agile France] Retour sur « Comment les jeux vidéo ont fait de moi un meilleur développeur ? »

Suite à l’annonce de la présence de Soft’It et Coactiv à Agile France, la conférence « Comment les jeux vidéo ont fait de moi un meilleur développeur ? » est disponible sur YouTube.

Un grand merci à l’organisation de l’événement et aux personnes présentes pour leur attention, leur soutien et leurs retours.

 

[ALT.NET] Coding Mojito #3…les images !

Le dernier coding dojo ALT.NET version Mojito s’est déroulé comme prévu hier soir chez CLT Services, organisé par Soft’it et plus particulièrement par l’un de nos craftsmen et membre nCrafts, Jean-François Saguin.

Le sujet : implémenter, en respectant un certain nombre de règles, un jeu de cartes façon Hearthstone – Heroes of Warcraft® (TradingCardGame_Kata.pdf (182,4KB)).
Pas forcément aisé de premier abord, mais tout le monde s’est prêté au jeu, que ce soit en C#, en F# ou en Haskell, avec une approche TDD évidemment.

Mojitos maison (préparés par la fine équipe CLT) + Bagels de chez Ari, un super mélange pour des katas…plus ou moins productifs.

Clément Bougereau (sur la photo ci-dessus) a gentiment partagé sa solution en F# : https://gist.github.com/cboudereau/adf4a956386659ad7d0e
N’hésitez pas à faire de même.

Images de la soirée :

[Meetup] Alt.NET - Coding Mojito Juillet 2015

Et si vous souhaitez revoir les précédents codings : http://blog.softit.fr/?tag=/Altnet

Comme vous l’a annoncé Jean-François hier, nous allons nous efforcer de revenir à un rythme plus régulier à la rentrée. Stay tuned pour des nouveaux dojos, sur de nouveaux thèmes.

[ALT.NET] Coding Mojito #3

Des katas, des mojitos et des algos. Comme chaque année depuis 2 ans, nous organisons durant la période des vacances un coding dojo spécial été ! L’événement aura lieu le jeudi 23 juillet dans nos locaux, 34 boulevard de Sébastopol.

Comme à l’habitude, nous vos proposons un petit exercice de programmation, agrémenté d’un atelier dégustation de mojitos (virgin mojito et boissons fraîches sont également de la partie).

mojito3

L’objectif du coding dojo est s’entraîner […] sur un kata de programmation; un problème simple d’une durée n’excédant pas 45min à 1H. Durant l’exercice chaque développeur travaille en pair programming et en TDD. A la fin on compare les différentes solutions et on discute.

Pour les développeurs qui souhaiteraient en apprendre plus sur le pair progamming et le TDD, c’est une bonne occasion de pratiquer sur un sujet qui sort de l’ordinaire. Pour les habitués du meetup c’est aussi un moment propice au partage en ce mois de juillet où il y a peu d’événements et pourquoi pas de tester une nouvelle approche, voire un nouveau langage.

Pour vous donner une idée, vous pouvez consulter les événements précédents: http://blog.softit.fr/?tag=/Altnet

Pour réserver votre place, ça se passe sur le meetup ALT.NET

[Interview] Logiciel sur-mesure : l’agile vu par les clients comme facteur clé de succès


Qu’apporte l’agilité au client dans un projet de logiciel sur-mesure ?

Cette vidéo croise le point de vue de plusieurs clients sur les bénéfices de l’agilité dans le cadre de projets de développement d’application mobile, site web ou autre système informatique sur-mesure.

Soft’it est spécialisé dans le développement de logiciels en agilité : nous avons à cœur de construire des relations de partenariat avec nos clients, de positionner des valeurs humaines fortes dans toutes nos collaborations, et d’apporter une valeur ajoutée différenciante dans chacune de nos interventions.

Les méthodes agiles facilitent la mise en pratique de ces valeurs et le témoignage de nos clients le démontre.

Pourquoi le sur-mesure, associé à l’agilité ?

Vous avez le sentiment de perdre du temps, voire de l’argent dans votre cœur métier, vous faites des tâches répétitives sans valeur ajoutée, vous avez l’impression que vos processus pourraient être plus efficacesLire la suite

Meetup ALT.NET REST & Hateoas

altnetPour cette dernière rencontre du meetup ALT.NET avant les vacances, Soft’It a le plaisir d’accueillir un OpenSpace sur les API REST.

L’idée est d’échanger avec des experts de la communauté .NET sur les bonnes pratiques de conception de ces API et de découvrir de nouveaux concepts.

Nous présenterons par exemple la contrainte d’une API REST avec HATEOAS, qui prône la simplicité de découverte des ressources par un client n’ayant aucune connaissance au préalable de celle-ci. 

L’événement aura lieu ce soir dans les locaux de Soft’It, 34 Boulevard de Sébastopol à Paris, 75004.

Pour les inscriptions, c’est par ici :

Alt.Net Talks #2015.6 – REST, Hateoas Open Space

En espérant vous voir présent parmi nous ce soir.

TFS 2015 : automatiser la création d’une définition de build XAML.

Auteur original, de notre ancien blog : Laurent Jacques

xaml1

xaml2

Aujourd’hui nous étudierons un cas pratique d’utilisation avancée de TFS  (2012,2013 et 2015) et de ses mécanismes de build.

Nous chercherons à automatiser la création et la suppression des définitions de builds avec l’utilisation de l’API de Team Foundation Server avec Visual Studio 2013.

Pour le cas d’étude de ce billet, l’organisation du code source se présente ainsi :

  • une branche dev : le travail courant des développeurs, tous check-in leurs modificationdedans au jour le jour.
  • plusieurs branches uat : en fin de cycle de développement, une nouvelle branche uat_X.Y.Z est créée à partir du dev pour partir en validation (test d’intégration)
  • une branche master : une fois validée la branche uat_X.Y.Z devient la nouvelle branche master : version référence pour les développements.

Ce qui donne par exemple l’arborescence suivante :

/Projet/
       /dev
	       /Appli1
		/Appli2
       /master
		/Appli1
		/Appli2
	/uat_1.2.3
		/Appli1
		/Appli2
	/uat_1.3.0
		/Appli1
		/Appli2

 

L’équipe de développement a mis au point deux définitions de build basées sur la branche DEV :

  • une intégration continue, tournant les tests unitaires automatiques, générant la doc, fournissant les livrables dans un répertoire dépôt;
  • une nightly : déployant les applications sur l’environnement de test tous les jours à 23h.

Problématique 

Une fois validée en interne, le DEV est branché en UAT_X.Y.Z : les définitions de builds ne fonctionnent donc pas sur cette branche.

Actuellement : pour chaque nouvelle branche UAT le lead technique vient créer une nouvelle définition de build UAT et ajouter les différents paramètres.

Besoin 

Automatiser le processus.

Mise en oeuvre

Pour cette première version nous visons la mise en place d’une app console en c# qui ira, à intervalles réguliers, vérifier l’état des branches et gérer les définitions de builds.[…]

Avant toute chose: ajouter les références (v12) dans le projet :

xaml3

1ière étape:  récupérer la listes des branches UAT existantes.:

List<Branch> branchList = new List<Branch>();
using (var tfs = new TfsTeamProjectCollection(_TFSserver))
{
    VersionControlServer vcs = (VersionControlServer)tfs.GetService(typeof(VersionControlServer));
    var items = vcs.GetItems(sourceCodeArea, VersionSpec.Latest, RecursionType.OneLevel,
        DeletedState.NonDeleted, ItemType.Folder).Items;
    foreach (Item item in items)
    {
        // skip self
        if (!item.ServerItem.Equals(sourceCodeArea))
        {
            if (item.ServerItem.ToLower().Contains(filter.ToLower()))
                branchList.Add(new Branch(item.ServerItem, item.CheckinDate, project));
        }
    }
}

Dans le code présent la logique est la suivante:

  1. on fournit comme paramètres :
  • l’url d’accès au serveur TFS ,
  • la zone de départ dans le source (sourceCodeArea) , 
  • un fitre est indiqué qui va permettre de ne ressortir que les branches qui nous intéressent (filter) 
     2. on récupère la liste des folders (branche) ;
var items = vcs.GetItems(sourceCodeArea, VersionSpec.Latest, RecursionType.OneLevel,                                          DeletedState.NonDeleted, ItemType.Folder).Items;

3. pour chacun de ses folders, on vérifie la cohérence du nom par rapport au filtre précisé :

if (item.ServerItem.ToLower().Contains(filter.ToLower()))

4. une fois récupérées, les branches seront ajoutées dans une liste d’objets maisons pour être gérées plus tard.

 

2ième étape:  récupérer les définitions de build existantes:

    var tfs = new TfsTeamProjectCollection(_TFSserver);
    tfs.Authenticate();
    var buildServer = (IBuildServer)tfs.GetService(typeof(IBuildServer));
    var buildDefinitionList = new List<IBuildDefinition>(buildServer.QueryBuildDefinitions(TEAM_PROJECT));

Afin de déterminer si les builds n’existent pas déjà, il faut en premier lieu récupérer la liste des builds existantes.

Les instructions ci-dessus permettent d’interroger le serveur TFS pour cela.

Ici, le TEAM_PROJECT  est simplement une constante représentant le nom du projet d’équipe.

L’appel à  buildServer.QueryBuildDefinitions va fournir l’ensemble des builds existantes pour le projet.

 

3ème étape:  parcourir la liste des branches et créer les builds inexistantes:

if (!buildDefinitionList.Exists(x => x.Name == TfsBuildServices.BuildName(projectName, branch)))
                {
                    IBuildDefinition CIBuild = buildDefinitionList.Where(x => x.Name == projectName + "_CI").First();
                    if (CIBuild != null)
                    {
                        var newbuild = buildServer.CreateBuildDefinition(TEAM_PROJECT);
                        newbuild.CopyFrom(CIBuild);
                        newbuild.Name = TfsBuildServices.BuildName(projectName, branch);
                        BuildSettings settings = new BuildSettings();
                        var process = WorkflowHelpers.DeserializeProcessParameters(newbuild.ProcessParameters);
                        settings.ProjectsToBuild = new StringList(((BuildSettings)process["BuildSettings"]).ProjectsToBuild.ToString().Replace("DEV",branch));
                        process.Remove("BuildSettings");
                        process.Remove("ProjectsToBuild");
                        process.Add("BuildSettings", settings);
                        process.Add("ProjectsToBuild", new string[] { settings.ProjectsToBuild.ToString() });
                        newbuild.ProcessParameters = WorkflowHelpers.SerializeProcessParameters(process);
                        newbuild.DefaultDropLocation += @"" + projectName;
                        newbuild.Workspace.Mappings[0].ServerItem = newbuild.Workspace.Mappings[0].ServerItem.Replace("DEV", branch);
                        newbuild.Save();
                    }
                }

1. une simple requête linq sur le nom de la build permet de passer la création si la build existe déjà

if (!buildDefinitionList.Exists(x => x.Name == TfsBuildServices.BuildName(projectName, branch)))

L’appel  à TfsBuildServices.BuildName  permet de centraliser et de formaliser  la création du nom de la build 

2. on récupère la build d’intégration continue qui va nous servir de modèle pour la nouvelle définition 

IBuildDefinition CIBuild = buildDefinitionList.Where(x => x.Name == projectName + "_CI").First();

3. on initialise la nouvelle build avec le modèle

var newbuild = buildServer.CreateBuildDefinition(TEAM_PROJECT);
  newbuild.CopyFrom(CIBuild);

4. la modification des paramètres

La build definition utilise des BuildSettings pour enregistrer ses paramètres :

BuildSettings settings = new BuildSettings();
                        var process = WorkflowHelpers.DeserializeProcessParameters(newbuild.ProcessParameters);
                        settings.ProjectsToBuild = new StringList(((BuildSettings)process["BuildSettings"]).ProjectsToBuild.ToString().Replace("DEV",branch));
                        process.Remove("BuildSettings");
                        process.Remove("ProjectsToBuild");
                        process.Add("BuildSettings", settings);
                        process.Add("ProjectsToBuild", new string[] { settings.ProjectsToBuild.ToString() });
                        newbuild.ProcessParameters = WorkflowHelpers.SerializeProcessParameters(process);
                        newbuild.DefaultDropLocation += @"" + projectName;
                        newbuild.Workspace.Mappings[0].ServerItem = newbuild.Workspace.Mappings[0].ServerItem.Replace("DEV", branch);

Ces settings sont sérialisés sous forme de dictionnaires et doivent donc être réédités pour cadrer avec le besoin spécifique UAT:

  • la copie de la build CI pointe par exemple vers la solution à compiler $/Project/dev/Appli1/Appli1.sln . il faut donc modifier ce répertoire pour celui UAT : 
settings.ProjectsToBuild = new StringList(((BuildSettings)process["BuildSettings"]).ProjectsToBuild.ToString().Replace("DEV",branch));
  • de la même manière le default drop location contient celle de la build CI et doit être modifié : 
newbuild.DefaultDropLocation += @"" + projectName;
  • et enfin le modèle objet de la définition de build contient aussi le mapping vers le répertoire source controle mappé qui doit lui aussi être remplacé : 
newbuild.Workspace.Mappings[0].ServerItem = newbuild.Workspace.Mappings[0].ServerItem.Replace("DEV", branch);

5. on sauvegarde, laisse 15 min au four : et hop. la build est créée !

newbuild.Save();

 

4ième étape:  supprimer les builds des anciennes branches :

Récupération de la liste des branches supprimées :

var items = vcs.GetItems(area, VersionSpec.Latest, RecursionType.OneLevel, 
DeletedState.Deleted,
ItemType.Folder).Items;

Pour chacune des anciennes branches on récupère la définition de la build associée (si elle existe)

IBuildDefinition UAT_CIBuild = buildDefinitionList.Where(x => x.Name == TfsBuildServices.BuildName(projectName, branch)).FirstOrDefault();
if (UAT_CIBuild != null)
{
   buildServer.DeleteBuilds(UAT_CIBuild.QueryBuilds());
}

A noter: pour pouvoir supprimer une définition de builds il faut que les historiques de run soient eux-aussi supprimés, c’est pourquoi l’appel buildServer.DeleteBuilds(UAT_CIBuild.QueryBuilds());  est fait ainsi  : cela supprime l’ensemble.

 

5ième étape:  emballer dans une petite application :

Je ne rentrerai pas dans les détails sur ce point, mais avec les éléments fournis rien de plus simple que de réunir tout cela dans une application qui tourne à intervalle régulier et exécute ces appels afin de synchroniser les définitions de builds et les branches.

 

Pour aller plus loin 

http://nakedalm.com/

https://msdn.microsoft.com/fr-fr/vstudio/ff637362.aspx

ALM ranger’s site

Prochaine étape 

Dans le prochain billet j’expliquerai comment se passer de l’application console en intégrant ce code au sein d’activités de build maisons et comment créer notre propre template de build avec tout ceci.

 

Laurent.

 

Soft’it et CoActiv présents à Agile France

En plus d’assister aux conférences Agile France, deux collaborateurs CoActiv (Christophe Keromen et Sébastien Delest) et un collaborateur Soft’it (Rémi Lesieur-Bridel) proposent des conférences.

Christophe présentera « Leurs petites pattes agiles », Sébastien « L’estimation : Un formidable outil de discussion, même pour des projets #NoEstimates » et Rémi « Comment les jeux vidéo ont fait de moi un meilleur développeur ».

Un teaser est d’ores et déjà disponible pour cette dernière conférence : 

Agile France aura lieu les 18 et 19 juin 2015 au Chalet de la Porte Jaune, Porte de Versailles à Paris.

Nous espérons vous voir là-bas pour échanger sur les sujets que nous vous proposons !