Création de clé primaire composé en MVC3

Vous avez une table jointe, voiçi comment déclarer les clé primaires composé en MVC3.

Il suffit de les définir dans le Context comme ceçi :

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    modelBuilder.Entity<RencontreClass>().HasKey(t => new { t.UserId, t.ClientId });
}

Source

Calendrier en jQuery – DatePicker

Tous d’abord récupérer (si ce n’est pas déjà fait) le jquery-ui et le css qui vous fait envie sur le site officiel.

Vous n’avez plus qu’à les importer.

<script src="../Scripts/jquery-ui-1.8.11.min.js" type="text/javascript"></script>
<link href="../Content/themes/base/jquery.ui.all.css" rel="stylesheet" type="text/css" />

Pendant qu’on y est, on récupère également la traduction française du calendrier ici. Et on l’importe

<script src="../Scripts/jquery.ui.datepicker-fr.js" type="text/javascript"></script>

Ensuite on aura besoin d’une textbox pour saisir la date et l’afficher.

<input type="text" class="date"/>

Et enfin de script pour relier la textbox avec le calendrier.

<script>
$(function () {
    $('.date').datepicker({ dateFormat: "dd/mm/yy" });
});
</script>

Voilà c’est aussi simple, et comme bonus, voici la même chose en intégrale et en plus classe. Lire la suite

Utilisation d’Ajax en MVC Razor

En MVC3 Razor, pour avoir un petit peu d’événementiel dans les pages, vous allez être obligé de passé par les fonctions JavaScript et notamment Ajax pour interagir avec vos controllers.

D’abord un cas simple (1 variable en entrée, 1 variable en sortie):
Controller

[HttpPost]
public string MyFonction(int myVar = 0)
{
    // ...
    String sView = "Halo";
    return sView;
}

View

function toto(){
    $.ajax({
        type: "POST",
        url: '@Url.Action("MyFonction")',
        data: '{myVar : @Model.Foo}',
        success: function (result){
            // ...
        },
        error: function (req, status, error) {
            // ...
        }
    });
}

La partie « error » n’est pas obligatoire, mais pour tester une première fois, ça peut-être utile.

Et maintenant corsons un peu les choses avec plusieurs variables en entrée :
Controller
Côté controller c’est du classique avec :

[HttpGet]
public ActionResult MyFonction2(int myVar1, string myVar2, DateTime myVar3)
{
    // ...
    return Json(result, JsonRequestBehavior.AllowGet);
}

View
Côté Vue, on va passé par du JSON pour transmettre toutes les informations.

function tata() {
    var strJson = {
        myVar1: $(foo).val(),
        myVar2: $(bar).val(),
        myVar3: $(baz).val()
    };

    $.ajax({
        type: "GET",
        url: '@Url.Action("MyFonction2")',
        dataType: "json",
        contentType: "application/json; charset=utf-8",
        data: strJson,
        success: function (result) {
            // ...
        }
    });
}

Si vous souhaitez retourner à la vue plusieurs valeur, je vous conseillerai de passé par un tableau et de l’utiliser de manière standard (result[0]…).

UPDATE 25/10/2012

IE (dans ses versions 7 et 8) est un navigateur ultra agressif avec le cache en Ajax. Si vous posez une question avec les mêmes paramètres d’entrée, il considèrera qu’il possède déjà la réponse. Vous avez donc 2 possibilités, rajouter un paramètres aléatoire à la fin (c’est pas très propre) ou alors rajouter parmi les options de la commande AJAX:

cache : false,

Récupérer le numéro de la semaine en cours – C#

Comment récupérer de manière simple, le numéro de la semaine en cours en C#.

Après avoir fait une petite recherche sur Wikipédia, j’ai découvert que la 1ère semaine de l’année est la première qui possède un jeudi dans la nouvelle année. Wikipédia

Donc mon esprit de codeur à tout de suite imaginé une manière fantaisiste. Puis j’ai découvert une solution beaucoup plus simple :

int Semaine = CultureInfo.InvariantCulture.Calendar.GetWeekOfYear(DateTime.Now, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday)

C’est beaucoup plus simple. Et vous pouvez vérifier le résultat sur ce site :
Numéro de Semaine

Source

ForEach Enum

Comment réaliser un foreach sur une énumérations :

L’énum :

enum MitEnum
{
    Toto = 0,
    Titi,
    Tata
}

Et le code :

static void Main(string[] args)
{
    foreach(MitEnum item in Enum.GetValues(typeof (MitEnum)))
    {
        // ...
    }
}

Source

Peuplement du DropDownList

Pour le peuplement d’une DropDownList avec Razor pour du MVC directement dans la page cshtml.

Je vous propose deux solutions qui rempliront une DDL avec des nombres de 0 à 100 et un pas de 5 :

La première, la plus simple, on pose simplement à l’endroit souhaité :

@Html.DropDownListFor(model => model.Pourcentage, new SelectList(Enumerable.Range(0, 100).Where(i => i % 5 == 0))) %

C’est simple, utilise les expressions lambda.

Et pour ceux qui ne sont pas fan, voici la version plus longues, mais tout aussi efficaces :

@{
    List<SelectListItem> list = new List<SelectListItem>(); 
        for (int i = 0; i <= 100; i+=5) 
        {     
            list.Add(new SelectListItem { 
                Text = i.ToString(),
                Value = i.ToString()
            });
        }
}

@Html.DropDownListFor(x => x.Pourcentage, list) %

Comparaison d’un Enum

Petit tuto pour comparer deux Enumérations (en LinQ sur un modèle MVC).

D’abord la définition de l’énumération :

public enum MitEnum : int
{
    Toto = 0,
    Tata = 1,
    Titi = 2,
    Tutu = 3,
}

Ensuite la déclaration dans l’objet :

public int EnumID { get; set; }
public virtual MitEnum TxTx
{
    get { return (MitEnum)EnumID; }
    set { EnumID = (int)value; }
}

Et enfin le comparaison :

var listToto = listFoo.Where(s => s.EnumID == (int) MitEnum.Toto);

Dans ce cas, je récupère tous les éléments de listFoo dont mon énumération MitEnum est « Toto » et je les mets dans listToto… Simplement

DropDownList en Cascade – MVC Razor

Voici une petit tutorial pour créer un effet de cascade sur les DropDownList en MVC Razor.

Nous partirons sur un modele de Marque et de Voiture. Simple. Marque 1.n –> 1.1 Voiture. Avec ID et Libelle.
Déjà nous avons besoin dans la vue de 2 DropDownList.

Vue :

@Html.DropDownListFor(model => model.MarqueID, Model.Marques, new { onChange = "MarqueDDL()"})
@Html.ValidationMessageFor(model => model.MarqueID)

@Html.DropDownListFor(model => model.VoitureID, Model.Voitures)
@Html.ValidationMessageFor(model => model.VoitureID)

Vous pouvez passez par le ViewBag, personnellement j’ai opter pour une ViewModel plus simple.

Ensuite chargons les valeurs dans le contrôleur lors de l’appelle de la page. :
Controller :

model.MarqueID = 0;
model.Marques = new SelectList(db.Marque, "MarqueID", "Libelle", model.MarqueID);
model.Voitures = new SelectList(db.Voiture.Where(x => x.MarqueID == model.MarqueID), "VoitureID", "Libelle");

On retourne dans la Vue pour implementer la fonctions de cascade :
Vue

function ProjetDDL() {
    var DDLparent = '#MarqueID'
    var DDLchild = '#VoitureID'
    cascade('@Url.Action("getVoitures")', 'marqID', $(DDLchild), false, DDLparent );
}

function cascade(url, paramName, childSelect, childCascade, parent) {
    var selectedValue = $(parent).val();
    var params = {};
    params[paramName] = selectedValue;

    childSelect.empty();
    $.getJSON(url, params, function (items) {
        $.each(items, function (index, item) {
            childSelect.append($('').attr('value', item.Id).text(item.Name));
            if (item.Selected) {
                $(childSelect).children().last().attr("selected", true);
            }
        });
        if (childCascade) { childSelect.change(); }
    });
}

La fonction cascade est une adaptation du script que l’on peut trouver ici.
Cette fonction demande les paramètres suivant : l’URL de la fonction qui retournera la nouvelle liste à afficher (voir çi-dessous), le nom paramètre d’entrée (et non sa valeur), la DropDownList à peupler, si la DropDownList peupler va entraîner une nouvelle cascade, et la DropDownList qui vient d’être modifier.

Et nous retournons dans le contrôleur pour renvoyé à la vue les valeurs de la DropDownList enfant.

Controller

[HttpGet]
public ActionResult getVoitures(int marqID)
{
    //Récupération via un paramètre
    //Id et Name sont obligatoire, même pour des Enumerable
    var voitures = db.Voiture.Where(x => x.MarqueID == marqID).Select(
        x => new
        {
            Id = x.LotID,
            Name = x.Libelle
        });
    return Json(voitures, JsonRequestBehavior.AllowGet);
}

Vous remarquerez que le nom de la variable d’entrée est celle qui a été indiqué dans la fonction en JS cascade().

Petit bonus, si vous souhaitez préselectionner une valeur dans la DropDownList enfant, il suffit lors de la création de la SelectList d’indiqué le paramètre Selected à true comme ceçi :

var voitures = db.Voiture.Where(x => x.MarqueID == marqID).Select(
    x => new
    {
        Id = x.VoitureID,
        Name = x.Libelle,
        Selected = x.MiseEnAvant == true ? true : false
    });

Dans cet exemple, j’ai une variable MiseEnAvant de type bool, mais ça pourrait être un int, un string une valeur par défaut.

Update : Problème de Cache sous IE 7 – 8

Voir en bas de ce billet précédent

jQuery Visual Studio Doc

Visual Studio est vraiment un logiciel terrible !! Son énorme point fort est l’IntelliSense (l’autocomplétion de VS).

Cet outils a des limites, les limites du languages que l’on code (C#, J#, ASP.net, html). Et lorsque vint le jQuery et l’absence de documentation, voir d’IDE assez performant pour coder, on fut obliger de passer par notepad++.
Mais voila que Microsoft à sortit les doc de jQuery.

Disponible ici. Il suffit d’ajouter le jquery-1.X.X-vsdoc.js dans le même répertoire que le JQuery scripts et l’on utilise et l’IntelliSense vous donnera la documentation de toutes les fonctions jQuery!!

Et ce n’est pas tout. En cas d’utilisation d’un script JS externe, on lui rajoute simplement une référence (un simple glissé déposé du vsdoc dans le fichier vous écrira :

/// <reference path="../jquery-1.7.2-vsdoc.js" />

Pour un rendu identique.

Visual Studio Guides

Vous aurez d’ici peu un tuto sur les différentes conventions à suivre lors du développement d’application.

Mais tout de suite, comment faire une belle ligne d’aide sur Visual Studio pour ne pas dépassé les 80 caractères conventionnels.

 2003: HKEY_CURRENT_USER\Software\MicrosoftVisualStudio\7.1\Text Editor
 2005: HKEY_CURRENT_USER\Software\MicrosoftVisualStudio\8.0\Text Editor
 2008: HKEY_CURRENT_USER\Software\MicrosoftVisualStudio\9.0\Text Editor
 2008 Express: HKEY_CURRENT_USER\Software\MicrosoftVCExpress\9.0\Text Editor

En fonction de votre Visual Studio, vous devriez trouver cette clé.

Maintenant rajouter une valeur chaine à l’intérieur nommé Guides.
Double cliquer dessus pour lui insérer la valeur : RGB(186,0,0) 80, 120

RGB(186,0,0) indique la couleur. Suivit par tous les emplacements ou vous souhaite insérer une colonne d’indication (pour moi 80 et 120).

Source