MTOM Webservice Fehler in C#

Soeben bekam ich beim Versuch, einen mit @MTOM annotierten Apache CXF Java Webservice in C# zu konsumieren, folgende Fehlermeldung:

„The content type multipart/related; type=\“application/xop+xml\“; boundary=\“uuid:3e285018-29a6-49c0-a08d-a855e25fe31d\“; start=\“<root.message@cxf.apache.org>\“; start-info=\“text/xml\“ of the response message does not match the content type of the binding (text/xml; charset=utf-8).

Die Lösung war in diesem Fall, das MessageEncoding innerhalb meines Serviceproxies anzupassen:

BasicHttpBinding binding = client.Endpoint.Binding as BasicHttpBinding;
binding.MessageEncoding = WSMessageEncoding.Mtom;

Passt wieder mal wunderbar in die Kategorie: Gut zu wissen Smile

Table Header Style in Vaadin ändern

Manches sieht man nicht immer gleich auf den ersten Blick, z.B. wie man in Vaadin die Größe einer Table Header Column anpassen kann.

Bei mir sah das immer so aus:

clip_image002

Die Buchstaben verschwanden quasi im Nichts. Nach ein paar Tests habe ich dann die richtige CSS-Klasse gefunden, um den Table Header insgesamt zu vergrößern: v-table-header-wrap.

Beispiel:

.customTableHeader .v-table-header-wrap 
{
   padding-bottom:2px;
}

und

Table table = new Table();
table.setStyleName("customTableHeader");

Et voila:

image

OpenStreetMap in Joomla Beitrag einbinden

Übersicht

OpenStreetMap ist eine freie Geodaten-Software, mit der man, ähnlich wie mit GoogleMaps, Karten erstellen und über diese navigieren kann. Ich stand schon vor einiger Zeit vor dem Problem, eine OpenStreetMap-basierte Karte in eine Joomla-Seite einzubauen. Damals bin ich diversen Tutorials gefolgt. Das Ergebnis war eine eher unschöne Lösung mit viel Javascript Code, Null Konfigurierbarkeit und eine Einbindung über einen Iframe. Da ich damals noch mit Joomla-Version 1.5 unterwegs war, blieb mir auch nicht viel anderes übrig.

Nach der Migration auf Joomla 2.5 stolperte ich allerdings über ein Modul namens OSModul. Wie man diese Modul nutzt, möchte ich im folgenden Blog-Post beschreiben.

Installation und Konfiguration

Die Installation des Moduls erfolgt, wie bei allen anderen Komponenten auch, einfach über den Extension-Manager von Joomla. Interessanter ist die Konfiguration, die man unter „Extensions -> Module-Manager“ vornehmen kann.

01

An dieser Stelle kann man erst einmal Standard-Parameter einfügen. Die meisten werden hier sicherlich den Titel ändern oder sogar ganz verbergen. Bei der Position kann man dem Modul eine entsprechend vorhandene Template-Position verpassen oder eine nicht vorhandene Position, um das Modul später per {loadposition imaginärerpositionsname} in einen Beitrag einzufügen.

02

In diesem Bild wird es schon wichtiger. Die Standardhöhe der Karte ist 200px. Das wird in den meisten Fällen nicht ausreichen. Man kann zwischen verschiedenen Zoom-Stufen und Styles auswählen. Wer die keinen Powered by-Layer auf der Karte haben möchte, kann ihn hier bequem ausschalten. Außerdem ist hier die erste Marker-Position einstellbar, nach der die Karte ausgerichtet wird.

03

Wer sich auf einem Marker einen Popup-Text anzeigen lassen will, kann das im nächsten Reiter tun. Es stehen verschiedene Modi zur Verfügung. Wichtig zu wissen ist, dass nur ein Popup gleichzeitig geöffnet sein kann.

04

Im nächsten Reiter kann man anschließend den Popup-Text festlegen, der (in meinem Fall) beim Klick auf einen Marker angezeigt werden soll. Wie man sieht, stehen einem hier umfangreiche Formatierungsmöglichkeiten zur Verfügung.

05

Wesentlich interessanter ist aber, wie man weitere Marker in die Karte einfügt. Das ist leider nicht mehr ganz so bequem. Ein Blick in die Doku schafft jedoch Abhilfe.

Die Syntax ist immer die gleiche. Man gibt eine beliebigen Namen für den Pin an, anschließend die Koordinaten, die man sich leicht auf der OpenStreetMap-Webseite besorgen kann, dann einen eventuellen Custom Marker-Style (in meinem Fall leer) und schließlich einen Namen für das Popup und die entsprechende Aufruffunktion (in meinem Fall click).

Weiter unten ,im Feld Popups, werden schließlich die Popup-Inhalte eingefügt. Hier kann man beliebigen HTML-Code einfügen. Man muss sich lediglich an die oben festgelegten Popup-Namen halten.

Wichtig: Nicht vergessen, das OSModul auch zu aktivieren!

07

Noch ein Tipp: Wenn man eine mehrsprachige Seite nutzt, sollte die Sprache in den OSModul-Settings auf Alle gestellt werden.

08

Ein bisschen weiter unten kann man schließlich noch einstellen, auf welchen Seiten (Menüpunkten) das Modul angezeigt werden soll.

Modul in einen Beitrag einfügen

Wie fügt man nun ein solches Modul in einen Joomla Beitrag ein?

06

Es gibt dazu zwei Möglichkeiten: loadposition und loadmodule. Die entsprechende Syntax findet man unter „Extensions -> Plugin-Manager ->Content – Load Modules“. Dieses Plugin muss zwingend aktiviert sein.

Ich habe die loadmodule Variante genutzt, da loadposition bei mir zwar lokal, nicht jedoch auf dem Webserver funktionierte. Bisher konnte ich nicht herausfinden, warum. Nutzt man loadmodule, muss man in den Settings des OSModuls auch keine Position angeben.

Die Syntax für loadmodule: {loadmodule modulname, modultitel, style(optional)}

Mögliche Probleme:

Ich hatte bei meinen lokalen Tests auf einem frisch installierten Joomla eigentlich überhaupt keine Probleme mit dem Einfügen der Komponente. In genau den gleichen Schritten funktionierte es anschließend auch auf dem Webserver, allerdings nur, bis ich den Titel der Komponente änderte. Von da an wollte die loadposition Variante bei mir in Beiträgen nicht mehr erscheinen.

Ich stieg also auf loadmodule um, bei dem es essenziell ist, den Modulnamen mit anzugeben. Andernfalls bekam ich zwar eine Karte, allerdings wurden die Modulsettings nicht aus der Joomla-Datenbank gelesen. Warum weiß ich nicht. Außerdem musste ich einen Text vor loadmodule hinzufügen (in diesem Fall „Eine kleine Karte“). Sonst wird auch hier nichts angezeigt. Das Anzeigen des Moduls als Modul in einer Modulposition funktioniert allerdings tadellos. Irgendetwas mag also mit meinem Joomla im Argen liegen.

Fazit:

OSModul ist eine schöne Komponente, die (nach einigen Schwierigkeiten) das tut, was sie soll. Es wäre noch ganz schön, wenn man zusätzliche Marker auch in einem Text-Editor bearbeiten könnte, statt alles selbst schreiben zu müssen. Vielleicht in einer künftigen Version.:)

Wenn der Backend-Login in Joomla 2.5 nicht mehr funktioniert…

…dann hat man vermutlich, so wie ich gerade, ein bestimmtes Plugin deaktiviert. Entweder Authentication – Joomla oder User – Joomla. In diesem Fall kann man per PHPMyAdmin in die extensions-Tabelle der Joomla Datenbank gehen und die entsprechenden Feldwerte(Spaltenname: enabled) von 0 wieder auf 1 setzen. Schon funktioniert auch wieder der Login. Muss man auch erst mal wissen:)

Prinzipien der Objektorientierung: Kapselung

Heute starte ich eine kleine Serie über objektorientierte Prinzipien, die man grundsätzlich immer wieder anwenden sollte. Den Anfang macht: Die Kapselung. Dazu bediene ich mich des Beispiels einer User-Suche (ja ich weiß, das ist nicht sonderlich originell, aber es ist leicht zu verstehen). User sind gekennzeichnet durch Informationen wie User-ID, Name, Vorname, Geburtsdatum, oder Telefonnummer. Ein ganz naiver Ansatz zur Suche nach einem solchen User könnte so aussehen:


class User
{
    private string id;
    private string vorname;
    private string name;
    private DateTime geburtsdatum;
    private string telefonnummer;


    public User(string id, string vorname, string name, DateTime geburtsdatum, string telefonnummer)
    {
        this.id = id;
        this.vorname = vorname;
        this.name = name;
        this.geburtsdatum = geburtsdatum;
        this.telefonnummer = telefonnummer;
    }

    public string ID
    {
        get { return id; }
    }

    public string Vorname
    {
        get { return vorname; }
    }

    public string Name
    {
        get { return name; }
    }

    public DateTime Geburtsdatum
    {
        get { return geburtsdatum; }
    }

    public string Telefonnummer
    {
        get { return telefonnummer; }
    }

}  

class UserDatabase
{
    private List<User> users;

    public UserDatabase()
    {
        users = new List<User>();
    }

    public void AddUser(string id, string vorname, string name, DateTime geburtsdatum, string telefonnummer)
    {
        User user = new User(id, vorname, name, geburtsdatum, telefonnummer);
        users.Add(user);
    }
    public User GetUserByID(string userID)
    {
        foreach (User _user in users)
        {
            User u = _user;
            if (u.ID.Equals(userID))
                return u;
        }
        return null;
    }
    public User Search(User user)
    {
        foreach (User _user in users)
        {
            User u = _user;
            string name = u.Name;
            if ((name != null) && (!name.Equals("")) && (!name.Equals(u.Name)))
                continue;
            string vorname = u.Vorname;
            if ((vorname != null) && (!vorname.Equals("")) && (!vorname.Equals(u.Vorname)))
                continue;
            string telefonnummer = u.Telefonnummer;
            if ((telefonnummer != null) && (!telefonnummer.Equals("")) && (!telefonnummer.Equals(u.Telefonnummer)))
                continue;
            DateTime geburtsdatum = u.Geburtsdatum;
            if ((!geburtsdatum.ToShortDateString().Equals("")) && (!geburtsdatum.Equals(u.Geburtsdatum)))
                continue;
            return u;
        }
        return null;
    }
}

Weiterlesen

Über das Fabrik-Methode Muster Teil 2

So…da hat es doch etwas länger gedauert, den letzten Artikel fortzusetzen. Was war also beim letzten Mal noch das Problem? Der Code wurde zwar an eine Stelle verschoben, an der er sich gut ändern lässt, allerdings sind da immer noch diese komischen, fehlerträchtigen String-Parameter. Des Weiteren ist das noch nicht so ganz flexibel. Was kann man also verändern? Statt nur eine Fabrik-Methode zu definieren, kann man pro Event eine Fabrik-Klasse erstellen, die sich einzig und allein um diese Event-Erstellung kümmert. Das ist zwar ein wenig aufwändiger, aber die Erstellung von Objekten ist gekapselt. Das ist doch schon mal was wert. Hier der (mal wieder nicht ganz perfekte) Code. Natürlich ist dieser Code jetzt wirklich sehr einfach, aber ich wollte allen unnötigen Ballast abwerfen (für eine wirklich realistische Implementierung reicht wohl auch der Platz nicht aus).

using System;
using System.Collections.Generic;

public interface IEvent
{
    void StartEvent();
    void FinishEvent();
    void ChangeEventDetails();
}

class Event:IEvent
{
    public void StartEvent()
    {
        Console.WriteLine("Starte Event");
    }

    public void FinishEvent()
    {
        Console.WriteLine("Beende Event");
    }

    public void ChangeEventDetails()
    {
        Console.WriteLine("Aendere Eventdetails");
    }
}

class ModernEvent : IEvent
{
    public void StartEvent()
    {
        Console.WriteLine("Starte ModernEvent");
    }

    public void FinishEvent()
    {
        Console.WriteLine("Beende ModernEvent");
    }

    public void ChangeEventDetails()
    {
        Console.WriteLine("Aendere ModernEventdetails");
    }
}

class OldFashionedEvent : IEvent
{
    public void StartEvent()
    {
        Console.WriteLine("Starte OldFashionedEvent");
    }

    public void FinishEvent()
    {
        Console.WriteLine("Beende OldFashionedEvent");
    }

    public void ChangeEventDetails()
    {
        Console.WriteLine("Aendere OldFashionedEventdetails");
    }
}

interface IEventFactory
{
    IEvent CreateEvent();
}

public class EventFactory:IEventFactory
{
    public IEvent CreateEvent()
    {
        return new Event();
    }
}

public class ModernEventFactory : IEventFactory
{
    public IEvent CreateEvent()
    {
        return new ModernEvent();
    }
}

public class OldFashionedEventFactory : IEventFactory
{
    public IEvent CreateEvent()
    {
        return new OldFashionedEvent();
    }
}

class EventManager
{
    static void Main(string[] args)
    {
        IEventFactory modernFactory = new ModernEventFactory();
        IEventFactory normalFactory = new EventFactory();
        IEventFactory oldfashionedFactory = new OldFashionedEventFactory();

        var eventList = new List<IEvent>
                            {
                                modernFactory.CreateEvent(),
                                normalFactory.CreateEvent(),
                                oldfashionedFactory.CreateEvent()
                            };

        foreach (var ievent in eventList)
        {
            ievent.StartEvent();
            ievent.FinishEvent();
            ievent.ChangeEventDetails();
        }

        Console.Read();
    }
}

Noch kurz zum Code: Es gibt jetzt ein Event-Interface, das den Kontrakt für die Eventklassen bildet. Dazu gibt es ein EventFactory-Interface, welches nur erzwingt, dass Implementierungen davon die CreateEvent()-Methode definieren müssen. In der Main-Methode sieht man sehr schön, wie man nun gegen Interfaces programmiert. Der Client weiß nur in geringem Maße, welche Factory er nutzt. Hier gibt es also noch eine Abhängigkeit zu beklagen.

Das ist es also, das Fabrikmethode-Muster, so wie ich es momentan verstanden habe. Es gibt sicher andere (womöglich auch bessere) Varianten, für den Einstieg reicht es aber vorerst so aus. Natürlich muss man hierbei Bedenken, dass man zwar mit diesem Muster sehr gut Kapselung betreiben kann, sich allerdings auch zusätzliche Komplexität dabei einfängt. Alles hat eben seine Vor – und Nachteile.