Martin

SEO - Homepage in Google Place eintragen!

Einleitung

Google Place

Firma bzw. Verein bei Google Place anmelden

1. Einleitung

Seit geraumer Zeit investiert Google in Produkte die Geodaten beinhalten. Es handelt sich dabei um digitale Informationen denen Lokalitäten zugewiesen werden können.

So werden in Google Maps schon lange Ärzte, Hotels usw. angezeigt. Diese Unternehmen werden dabei automatisch in Google Maps in der Karte angezeigt. In der Hilfe kann man dazu folgendes nachlesen:

„Welche Unternehmen angezeigt werden, wird anhand unseres proprietären Algorithmus festgelegt. Diese Unternehmen ändern sich normalerweise von Zeit zu Zeit. Unser Ziel ist es, auf der Karte Orte darzustellen, die für die Nutzer interessant sein könnten oder ihnen bei der Orientierung auf der Karte helfen. Wir nehmen keine Bezahlung dafür an, dass bestimmte Einträge auf der Karte angezeigt werden. „(Graue Symbole in Google : Suchergebnisse - Google Places-Hilfe, 14.12.2010, http://www.google.com/support/places/bin/answer.py?hl=de&answer=174115).

Man hat also derzeit noch keinen Einfluss, was beim Kartendienst angezeigt wird und was nicht.

2. Google Place

Einer der neueren Plattformen ist Google Place bei der man hingegen die Möglichkeit hat Unternehmen und Vereine in den Kartendienst ein zu tragen (sofern man sich als diese Firma authentifizieren kann).

Dies schafft die Möglichkeit noch effizienter zu werben, denn Suchergebnisse mit übereinstimmenden Standorten werden stärker gewertet.

Such man also z.B. nach „Webdesigner in Wien“ sieht das Ergebnis wie folgt aus.

Aber auch in der „normalen“ Google Suche werden, vorausgesetzt der Name eines Standorts ist vorhanden, die Suchergebnisse entsprechend ausgegeben.

Suchen mit Standorten können wie folgt aussehen. „pension feldkirch“,“ anwaltskanzlei feldkirch“, „masseur feldkirch“ usw.

Wie bereits erwähnt, werden Suchergebnisse mit übereinstimmendem Standort stärker bewertet (siehe Abbildung 2 rot umrahmt) und sind somit ganz oben bei den Ergebnissen aufgelistet (siehe Abbildung 2). Erst danach kommen die normalen Suchergebnisse (siehe Abbildung 2 grüner umrahmt)

3. Bei Google Place eigenen Verein / Firma Anmelden

1. Wechseln Sie zur Seite http://Google.de/places
2. Um sich bei Google Place an zu melden benötigt man einen Google-Account
3. Klicken Sie auf anmelden / Jetzt anmelden
4. Formular ausfüllen
5. Beim Bestätigungsemail Link anklicken
6. Anschließend wechseln Sie nochmals zur Seite http:// Google.de/places und loggen sich ein, sofern sie noch nicht eingeloggt sind
7. Wählen Sie danach „Ein Unternehmen hinzufügen“
8. Wählen Sie das Land aus und geben Sie eine Telefonnummer (diese kann muss aber nicht stimmen) ein
9. Anschließend können Sie das Formular ausfüllen
10. Falls die angegebene Telefonnummer nicht stimmt, müssen Sie am Schluss die Authentifizierung per Post wählen
11. Wichtig bei diesem Formular sind die Kategorien, diese sind ausschlaggebend, bei welchen Suchanfragen das Unternehmen / der Verein angezeigt wird. Sie sollten sich daher genau überlegen wie ein Außenstehender nach ihrem Unternehmen sucht. Halten Sie daher die Kategorien eher allgemein
12. Zum Schluss können noch Details wie Fotos und Youtube Videos , Öffnungszeiten hinzugefügt werden.
13. Anschließend muss man auswählen wie man authentifiziert werden will. Das geht entweder über die Post oder per SMS.
14. Nach der Authentifizierung hat man es geschafft das Unternehmen in Google Place anzumelden.

Bei Fragen, Anregungen einfach die Kommentarfunktion nutzen oder mich per Mail kontaktieren.

lg

Martin

Links zum Thema: http://enno.verbrennung.org/2010-12-17-smo-und-seo-trends-2011/

Martin

IIS 7 mit PHP Virtuelles Verzeichnis RewriteRules

Heute habe ich probiert unser CMS mit dem IIS 7 Webserver von MS mit der Webtechnologie PHP zu verwenden.

Also als erstes muss man unter Windows 7 in Systemsteuerung\Programme\Programme und Funktionen\ "Windows Funktionen aktivieren oder deaktivieren" den Internetinformationsdienst installieren.

Das tolle ab der IIS Version 7 ist, dass man ganz Einfach die verschiedensten Module bequem installieren kann.

Mit dem Aufrufen der Seite http://php.iis.net/ und dem klick auf "Install PHP" wird der "Webplatform Installer" aufgerufen sofern er installiert wurde. Ansonsten kann man ihn einfach über den Internet Explorer nach installieren. Danach wählt man im Programm auf PHP installieren. Siehe Abbildung.

Als nächstes erstellt man ein Virtuelles Verzeichnis damit wir dort unsere PHP Anwendung speichern können.

Das macht man im IIS-Manager unter Sites Default Web Site --> Rechter Mausklick --> virtuelles Verzeichnis hinzufügen. Beim physikalischen Verzeichnis müsst ihr jetzt noch die Berechtigungen setzen. Wichtig ist dass der IIS_IUSRS ausreichend Rechte (also zumindest die Dateien im angegeben Verzeichnis lesen kann) hat. Hier gibts das ausführlicher.

Zur Erinnerung, bei den älteren IIS Versionen musste man noch selber die PHP Binaries herunterladen und konfigurieren (Berechtigungen, Pfade usw. setzen), was sehr nerven zerreißend sein konnte.

Eine weitere Erneuerung beim IIS 7 sind die unterstützten RewriteRules. Früher musste man für diesen Komfort auf Drittanbieter-Tools zurückgreifen.

Bei unserem CMS werden auch RewriteRules verwendet und so kam ich in den Genuss dieses Feature mit seinen Eigenheiten kennenlernen zu dürfen. Die .htaccess kann vom PHP Projekt aber nicht so ohne weiteres übernommen werden. Die Rules werden nämlich beim IIS in der web.conf gespeichert und müssen daher aus der .htacess importiert werden. (Zu finden im IIS-Manager unter RewriteRules)

Außerdem müssen vor dem Importvorgang der .htaccess die Pfade angepasst werden. Die relativen Pfade der .htaccess erkennt der IIS-Manager nämlich nicht. So musste ich zum Pfad den Namen des Virtuellen Verzeichnisses hinzufügen.

Nach dem also eigentlich alles richtig eingestellt sein sollte erhielt ich jedoch die Meldung:

"Das Anforderungsfilterungsmodul ist so konfiguriert, dass Pfade in der URL abgelehnt wird, die einen Abschnitt "hiddenSegment" enthalten."

Nach kurzem Googeln fand ich heraus, dass im IIS-Manager unter Anforderungsfilter in der Tab "Ausgeblendete Segmente", Segmente aufgelistet sind, die nicht in der URL oder/RewriteRule (bin mir nicht sicher welches von beiden oder ob es beide betrifft) vorkommen dürfen.

Nach dem Entfernen des entsprechenden Segments funktionierte es dann.

Martin

C# Plugins mit AppDomains realisieren

1. Einführung 

• AppDomains können nicht auf Objekte von anderen AppDomains direkt zugreifen
• AppDomains können entladen werden, mit Ausnahme der Default AppDomain
• AppDomains können unterschiedliche Sicherheitsprivilegien vergeben werden
• AppDomains können unterschiedlich konfiguriert werden (AppDomainSetup)

2. Sonstige Bemerkungen
 

	 public static void Main(string[] Args)
	{
	    //Gib die AppDomain zurück in der wir uns befinden
	    System.Console.WriteLine(AppDomain.CurrentDomain);
	 
	    //AppDomain erstellen
	    AppDomain appDomain = AppDomain.CreateDomain("AppDomain #2");
	 
	    //Schauen wir ob es sich um die Default Domain handelt
	    System.Console.WriteLine(AppDomain.CurrentDomain + " " + AppDomain.CurrentDomain.IsDefaultAppDomain());
	 
	    System.Console.WriteLine(appDomain + " " + appDomain.IsDefaultAppDomain());
	 
	    Print(AppDomain.CurrentDomain.GetAssemblies());
	 
	    //In unsere AppDomain lib laden
	    appDomain.DoCallBack(new CrossAppDomainDelegate(delegate()
	        {
	            System.Console.WriteLine(AppDomain.CurrentDomain);
	 
	            Assembly.LoadFrom(@"C:\Users\martin\Plugin.dll");
	 
	        }));
	 
	    Print(appDomain.GetAssemblies());
	}
	static void Print(System.Reflection.Assembly[] Assemblies)
	{
	    int i = 0;
	    foreach (System.Reflection.Assembly assem in Assemblies)
	        System.Console.WriteLine("[{0}] {1}", ++i, assem.GetName().Name);
	}
	 

	Die Ausgabe dazu sieht wie folgt aus:
	Name:ConsoleApplication1.vshost.exe
	Keine Kontextrichtlinien vorhanden.
	 
	Name:ConsoleApplication1.vshost.exe
	Keine Kontextrichtlinien vorhanden.
	 True
	Name:AppDomain #2
	Keine Kontextrichtlinien vorhanden.
	 False
	[1] mscorlib
	[2] Microsoft.VisualStudio.HostingProcess.Utilities
	[3] System.Windows.Forms
	[4] Microsoft.VisualStudio.HostingProcess.Utilities.Sync
	[5] System
	[6] Microsoft.VisualStudio.Debugger.Runtime
	[7] mscorlib.resources
	[8] vshost
	[9] System.Core
	[10] System.Xml.Linq
	[11] System.Data.DataSetExtensions
	[12] System.Data
	[13] System.Xml
	[14] WindowsBase
	[15] ConsoleApplication1
	[16] System.Drawing
	[17] Accessibility
	[18] DomainManager
	[19] IPlugin
	 
	Name:AppDomain #2
	Keine Kontextrichtlinien vorhanden.
	 
	[1] mscorlib
	[2] Microsoft.VisualStudio.HostingProcess.Utilities
	[3] ConsoleApplication1
	[4] Plugin
	 

public interface IPlugin
	{
	    public void Execute();
	    public void Connect(object info);
	}    
	public class PluginProxy : System.MarshalByRefObject, IPlugin
	{
	    private IPlugin m_IPlugin;
	 
	 
	    //Other Code for Events etc. 
	 
	    void Init(string assemblyName, string typeName)
	    {
	        m_IPlugin = (IPlugin)Activator.CreateInstance(assemblyName, typeof(IPlugin));
	    }
	    public void Execute()
	    {
	        try
	        {
	            m_IPlugin.Execute();
	        }
	        catch (Exception ex)
	        {
	            //Event feuern
	            this.OnException(ex);
	        }
	    }
	    public void Connect(object info)
	    {
	        try
	        {
	            m_IPlugin.Connect(info);
	        }
	        catch (Exception ex)
	        {
	            //Event feuern
	            this.OnException(ex);
	        }
	    }
	}
	 

<?xml version="1.0" encoding="utf-8" ?>
	<configuration>
	  <runtime>
	    <legacyUnhandledExceptionPolicy enabled="true" />
	  </runtime>
	</configuration>

3. AppDomain und Plugin erstellen

Bevor man aber überhaupt die Plugin-Isolation machen kann, muss man sich Gedanken machen wie man die Plugins in Kombination mit den AppDomains handhabt.

Meine Idee ist für jedes Plugin eine separate AppDomain zu erstellen. Das Erstellen der AppDomain für das Plugin soll eine Klasse für uns erledigen die PluginDomain heißt. Es handelt sich dabei um eine generische Klasse, damit man den Plugin-Typ angeben kann. Den Generischen Typ brauchen wir später beim Erstellen der Plugin-Instanz und um die Instanz speichern. Das macht das Arbeiten mit dem Plugin einfacher, da der „Cast“ Vorgang weg fällt.

Die Klasse wird mit dem Konstruktor PluginDomain(string assemblyPath) initialisiert, wobei der Parameter assemblyPath den Pfad des Plugins enthält. Im Konstruktor wird die AppDomain mit Hilfe der Klasse AppDomainSetup konfiguriert und erstellt.

 

//Beim erstellen der AppDomain wird die Funktion GetInterfaceTypes aufgerufen
	appDomainSetup.AppDomainInitializer = new AppDomainInitializer(GetInterfaceTypes);
	//Parameter der Funktion übergeben, Pfad des Plugins und nach welchem Interface gesucht werden soll
	appDomainSetup.AppDomainInitializerArguments = new string[] { assemblyPath, typeof(T).ToString() };
	 

/// <summary>
	/// Diese Methode sucht in der übgergebenen Datei die erste Klassen die das übergebene
	/// Interface implementieren.
	/// </summary>
	/// <param name="args">Der erste Parameter ist der Datepfad der Datei die nach dem gesuchten 
	/// Interface durchsucht werden soll.
	/// Im zweiten Parameter wird das Interface übergeben.</param>
	private static void GetInterfaceTypes(string[] args)
	{
	    AppDomain appDomain = System.AppDomain.CurrentDomain;
	 
	    //Laden wir die Plugin Assembly in unsere AppDomain
	    System.Reflection.Assembly assembly = System.Reflection.Assembly.LoadFrom(args[0]);
	 
	    String pluginType = String.Empty;
	 
	    foreach (Type type in assembly.GetTypes())
	    {
	        //Check only Public Types
	        if (type.IsPublic)
	        {
	            //Check only not abstract Types
	            if (!type.IsAbstract)
	            {
	                //look up the interface
	                Type typeInterface = type.GetInterface(args[1], true);
	                if (typeInterface != null)
	                {
	                    //return the type which implements our interface
	                    pluginType = type.FullName;
	                }
	            }
	        }
	    }
	 
	    //Daten über die Methode SetData setzen, weil der AppDomainInitializer-Delegate
	    //kein Rückgabewert hat. Mit GetData können die Daten wieder abgeholt werden
	    //http://msdn.microsoft.com/en-us/library/37z40s1c.aspx
	    appDomain.SetData(_GetDataPluginTypes, pluginType);
	}
	 

	_Instance = this._appDom.CreateInstanceFromAndUnwrap(_AssemblyPath, pPluginType) as T;

	_appDom.UnhandledException += new UnhandledExceptionEventHandler(AppDom_UnhandledException);

System.AppDomain appDomain = sender as System.AppDomain;
	Exception exception = e.ExceptionObject as Exception;
	 
	exception.Data.Add("PluginDomain", this);

if (appDomain.Equals(plugindomain.AppDomain) && plugindomain.AppDomain.IsDefaultAppDomain().Equals(false))
	{
	    new Thread(delegate()
	    {
	        try
	        {
	            Console.WriteLine("Unloading the offending application domain...");
	 
	            AppDomain.Unload(appDomain);
	            appDomain = null;
	 
	            plugindomain = null;
	        }
	        catch (System.Threading.ThreadAbortException abortexception)
	        {
	            //(AppDomain..::.Unload beendet Threads mit Thread..::.Abort
	            //http://msdn.microsoft.com/de-de/library/cyayh29d.aspx
	 
	            appDomain = null;
	 
	            plugindomain = null;
	 
	            System.Console.WriteLine(abortexception);
	        }
	        catch (CannotUnloadAppDomainException unloadexception)
	        {
	            System.Console.WriteLine(unloadexception);
	        }
	        catch (Exception ex)
	        {
	            Console.WriteLine(ex.ToString());
	        }
	        finally
	        {
	            OnPluginChangedEvent(new PluginManager.PluginChangedArgs(plugindomain,
	             ChangedAction.Remove));
	        }
	 
	        Console.WriteLine("Unloaded the offending application domain...");
	 
	}).Start();

Martin

C# Anwendung Plugin fähig machen

    /// <summary>
	    /// Definiert das "Aussehen" unseres Plugins
	    /// </summary>
	    public interface IPlugin
	    {
	        /// <summary>
	        /// Name des Plugins
	        /// </summary>
	        String Name { get; set; }
	 
	        /// <summary>
	        /// Beschreibung des Plugins
	        /// </summary>
	        String Description { get; set; }
	 
	        /// <summary>
	        /// Berechnet die Eingabe
	        /// </summary>
	        /// <param name="pInput">Eingabe die ausgewertet werden soll.</param>
	        /// <returns>Gibt das berechnete Ergebnis zurück</returns>
	        String Calc(String pInput);
	    }

public void LoadPlugins(String pPluginPath)
	{
	            String[] files = Directory.GetFiles(pPluginPath);
	 
	            foreach (String file in files)
	            {
	                FileInfo fileInfo = new FileInfo(file);
	 
	                if (fileInfo.Extension.Equals(".dll"))
	                {
	                    Dictionary<string, object> dictionary = GetModul(file, typeof(IPlugin.IPlugin));
	                    foreach (var a in dictionary)
	                    {
	                        Plugins.Add(a.Key,a.Value);
	                    }
	 
	                }
	 
	            }
	}

private static Dictionary<string, object> GetModul(string pFileName, Type pTypeInterface)
	{
	            //Hier speichern wir unsere Plugins
	            Dictionary<string, object> interfaceinstances = new Dictionary<string, object>();
	 
	            //Loads an assembly given its file name or path.
	            Assembly assembly = Assembly.LoadFrom(pFileName);
	 
	            // http://msdn.microsoft.com/de-de/library/t0cs7xez.aspx
	            // Assembly Eigenschaften checken
	            foreach (Type type in assembly.GetTypes())
	            {
	                if (type.IsPublic) // Ruft einen Wert ab, der angibt, ob der Type als öffentlich deklariert ist. 
	                {
	                    if (!type.IsAbstract)  //nur Assemblys verwenden die nicht Abstrakt sind
	                    {
	                        // Sucht die Schnittstelle mit dem angegebenen Namen. 
	                        Type typeInterface = type.GetInterface(pTypeInterface.ToString(), true);
	 
	                        //Make sure the interface we want to use actually exists
	                        if (typeInterface != null)
	                        {
	                            try
	                            {
	 
	                                object activedInstance = Activator.CreateInstance(type);
	                                if (activedInstance != null)
	                                {
	                                    interfaceinstances.Add(type.Name, activedInstance);
	                                }
	                            }
	                            catch (Exception exception)
	                            {
	                                System.Diagnostics.Debug.WriteLine(exception);
	                            }
	                        }
	 
	                        typeInterface = null;
	                    }
	                }
	            }
	 
	            assembly = null;
	 
	            return interfaceinstances;
	}

Simon

CKeditor: Events abfangen

Ich bin gerade dabei, die Modifikationen für den FCKeditor auf den CKeditor umzuschreiben. Dazu zählen: interne Verlinkungen, Links zum Galeriemodul, Links zu Blogeinträgen (vom Blogmodul).
 

Das Ziel ist es, alles umzusetzen, ohne den Originalquelltext zu ändern. Dabei ergibt sich in manchen Situationen ein Problem:
 

Wie soll man z.B.: das onOk Ereignis modifizieren? Es gibt keinerlei Möglichkeit den Quelltext über Javascript zu ändern.
Man kann aber vor der eigentlichen Funktion eine eigene Funktion einfügen die die Ausnahmesituation behandelt:

Pseudocode:
Ereignis onOk: Wenn Ausnahmesituation -> führe eigene Funktion aus, andernfalls: führe native Funktion aus!
 

(c) 2011 | Impressum |