Menu użytkownika w pliku xml cz.1 - Podstawa

Pisząc aplikację w ASP.NET MVC na pewno będziemy borykać się z problemem sposobu przechowywania głównego menu jakie powinno zostać wyświetlone użytkownikowi. Jeżeli opieramy działanie na uniwersalnym menu to oczywiście najlepiej wpisać je w master page i zapomnieć o całej sprawie. Najczęściej jednak użytkownicy mają różne prawa/role, co często ciągnie za sobą brak autoryzacji do pewnych funkcjonalności. Wylądowaliśmy zatem w sytuacji gdzie w zależności praw dostępu użytkownika powinniśmy wygenerować mu inne menu.

Możliwe rozwiązania

Do dyspozycji mamy zatem następujące możliwości zapisania menu:

• na stałe w kodzie
• w pliku
• w bazie danych

Zapis na stałe w kodzie jest oczywiście z definicji zły dla tego typu dynamicznych elementów. Kolejne dwa rozwiązania są już znacznie lepsze (choćby dlatego, że odpada potrzeba ponownej kompilacji i możemy dowolnie edytować informacje). Warto jednak zwrócić uwagę, że do obsługi menu niekoniecznie trzeba używać aż bazy danych (dużą rolę odgrywa tutaj wielkość aplikacji). Jeżeli dysponujemy stałym zestawem ról dla użytkowników można swobodnie do tego celu wykorzystać plik XML.

Docelowa struktura

Odpowiednik menu użytkownika w xml powinien zawierać elementy:

• typ/prawa/rolę użytkownika
• adres docelowy
• opis wyświetlanego linku

W związku z tym wybrałem następującą strukturę zapewniającą powyższe założenia:

<!--menu.xml-->
<?xml version="1.0" encoding="utf-8" ?>
<menus>
  <menu for="Doctor">
    <item value="Dzisiejsze wizyty" url="/Doctor/Index" />
    <item value="Ostatnia wizyta" url="/Visit/Last" />
    <item value="Wyloguj" url="/User/Logout" />
  </menu>
  <menu for="Recepcionist">
    <item value="Nowy pacjent" url="/Patient/Create" />
    <item value="Wyloguj" url="/User/Logout" />
  </menu>
</menus>

Jak widać w przykładzie mamy dwa osobne menu. Jedno dla lekarza z trzema wpisami i drugie dla recepcjonisty z dwoma. Struktura jest przy okazji na tyle prosta, że bardzo łatwo da się ją odzwierciedlić w kodzie. A jak już o tym mowa, najpierw nieco abstrakcji:

[Flags]
public enum UserRole
{
    Doctor = 1 << 0,
    Recepcionist = 1 << 1,
}

public interface IMenu
{
    IEnumerable<IMenuItem> For(UserRole role);
}

public interface IMenuItem
{
    string Value { get; }
    string Url { get; }
}

Interfejs IMenu reprezentuje już wczytane menu dając dając dostęp do listy elementów IMenuItem czyli informacji opisujących link jaki później zostanie wygenerowany. Dodajmy zatem do tego wszystkiego obsługę xml i jesteśmy w domu.

[XmlRoot("menus")]
public class XmlMenu : IMenu
{
    [XmlElement("menu")]
    public List<XmlRoleMenu> RoleMenus { get; set; }

    public XmlMenu()
    {
        RoleMenus = new List<XmlRoleMenu>();
    }

    public IEnumerable<IMenuItem> For(UserRole role)
    {
        XmlRoleMenu roleMenu = RoleMenus
            .Where(m => m.Role == role)
            .Single();
        return roleMenu.Items;
    }

    public static IMenu LoadFrom(string filePath)
    {
        XmlSerializer serializer = new XmlSerializer(typeof(XmlMenu));
        XmlMenu menu = null;
        using (StreamReader reader = new StreamReader(filePath)) {
            menu = (XmlMenu)serializer.Deserialize(reader);
            reader.Close();
        }
        return menu;
    }
}

public class XmlRoleMenu
{
    [XmlElement("item")]
    public List<XmlMenuItem> MenuItems { get; set; }

    [XmlAttribute("for")]
    public UserRole Role { get; set; }

    public XmlRoleMenu()
    {
        MenuItems = new List<XmlMenuItem>();
    }

    public IEnumerable<IMenuItem> Items
    {
        get { return MenuItems.ConvertAll(item => (IMenuItem)item); }
    }
}

public class XmlMenuItem : IMenuItem
{
    [XmlAttribute("value")]
    public string Value { get; set; }
    [XmlAttribute("url")]
    public string Url { get; set; }
}

Na zakończenie jeszcze przykład użycia wyciągający menu dla doktora

static void Main(string[] args)
{
    IMenu menu = XmlMenu.LoadFrom("menu.xml");
    foreach (IMenuItem item in menu.For(UserRole.Doctor)) {
        Console.WriteLine("{0}\t{1}", item.Url, item.Value);
    }
    Console.ReadLine();
}

Prawda, że proste? Wczytywanie pliku to jednak nie wszystko czego potrzebujemy. Takie menu należy jeszcze osadzić w widoku asp.net mvc, ale o tym już niedługo.

ConfirmSubmit - HtmlHelper Extensions cz.1

Jedną z tzw dobrych praktyk projektowania aplikacji w ASP.NET MVC jest stosowanie HtmlHelper w przypadkach bardziej skomplikowanego kody widoku. Co można w skrócie nazwać "Keep your views simple". Obiekt Html oczywiście nie realizuje każdego z możliwych scenariuszy stąd powinien być w trakcie kodowania uzupełniany o dodatkowe funkcjonalności pisząc stosowne metody rozszerzające. Stąd też pomysł na niniejszy cykl postów w którym postaram zaprezentować parę przydatnych rozwiązań.

ConfirmSubmit czyli najpierw zapytaj

Tworząc różne formy do edycji/tworzenia/usuwania obiektów wypada czasem upewnić się czy użytkownik na pewno wie co robi ;] Istnieją różne metody, ale chyba najprostsza to wyświetlenie okienka z poziomu javascript:

<input  type="submit" value="Usuń" onclick="return confirm('Czy na pewno?')" />

Zakładając, że w przeglądarce nie mamy wyłączonej obsługi js (co w dobie aplikacji internetowych i Ajaxa jest rzadkością) otrzymamy coś na kształt:

Wszystko pięknie działa, ale jest hmm, niewygodne i do tego nie zgodne z zasadą tworzenia widoków o której wcześniej wspominałem. Stąd też proste rozszerzenie ConfirmSubmit:

public static  MvcHtmlString ConfirmSubmit(
    this HtmlHelper html,
    string value,
    string question)
{
    string submit = String.Format(
        "<input type=\"submit\" value=\"{0}\" onclick=\"return confirm('{1}');\"",
        value,
        question);
    return MvcHtmlString.Create(submit);           
}

Do kompletu jeszcze wywołanie i wszyscy są szczęśliwi:

<%=Html.ConfirmSubmit("Usuń", "Czy na pewno?") %>