I’ve been doing some tinkering recently with SmugMug again.

Through testing SnugUp for the past 4 years, I’ve made quite the mess of my SmugMug account. Literally hundreds of poorly organized and often completely junk albums. I’ve been wanting to clean it up, but SmugMug’s UI for that is so obnoxiously slow and tedious that I decided I wanted to write a tool to make it easier to manage.

Admittedly, given the amount of time I’ve spent on writing the tool (which I’m not yet finished with), I could have cleaned up my SmugMug account dozens of times. However, with my developer hat on, I thought, how fun would that be?

So, I’ve started to create the SnugUp.Browser. It’s a bit of an interesting beast in that it is a Windows application that hosts a web browser to display its UI. I’d tried using WPF/XAML and just couldn’t get the look I was wanting in a reasonable amount of time and effort.

<RANT>WPF desperately needs a VirtualizingWrapPanel. Microsoft needs to ship it. </RANT>

So, I created a WinForms project to host the IE Web Browser. (Arrgh, the WPF WebBrowser sucks still. It’s not nearly as feature complete as the one from WinForms!). Internally, the web pages are served via an HttpListener.

try
{
    int portSuggest = GetAvailablePort();
    portSuggest = 40000;
    _listener.Prefixes.Add(string.Format("http://localhost:{0}/", portSuggest));
    _listener.Start();
    while (maxConnections-- > 0)
    {
        _listener.BeginGetContext(HandleRequest, _listener);                    
    }
}
catch (Exception ex)
{
    Debug.WriteLine(ex);
}

The HandleRequest method responds in two ways:

1. Respond with JSON data (as if it were a web service). 99% of the code needed to access SmugMug’s APIs was already written in a C# library I wrote for SnugUp.
2. Respond with binary data, providing a “proxy” to a service. This was needed to handle downloading images from the application. When the request was directly made from the WebBrowser to SmugMug, it was refused as the http-referer header was not a valid source apparently (SmugMug didn’t like “http://localhost:####” as the referrer.

resourceRequested = context.Request.Url.LocalPath.Replace('/', '.');
if (resourceRequested.StartsWith(".")) { resourceRequested = resourceRequested.Substring(1); }
Debug.WriteLine(string.Format("Requested: {0}", resourceRequested));
using (Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(string.Format("SnugUp.Resources.{0}", resourceRequested)))
{
    if (stream == null)
    {
        //context.Response.StatusCode = 404;

        if (url.LocalPath.StartsWith("/proxy"))
        {
            var proxyUrl = url.Query.Substring("?url=".Length);
            extension = Path.GetFileName(proxyUrl);
            try
            {
                WebClient client = new WebClient();
                byte[] buffer = client.DownloadData(proxyUrl);
                context.Response.Headers.Add("Expires", DateTime.UtcNow.AddDays(30).ToString("R"));                                        
                context.Response.ContentType = GetContentType(context, extension);
                context.Response.OutputStream.Write(buffer, 0, buffer.Length);                                         
            }
            catch
            {

                context.Response.StatusCode = 404;
            }
        }

    }
    else
    {
        string contentType = GetContentType(context, extension);

        context.Response.ContentType = contentType;                                
        stream.CopyTo(context.Response.OutputStream);
    }
    // Close the Response to send it to the client.
    //                        }
}

If the resource can’t be found as an Embedded Resource, it tries a proxy.

I built a tiny router for the web services so that I could easily plug-n-play new functionality:

public virtual object Route(string path, dynamic data)
{
    if (path.StartsWith("/")) { path = path.Substring(1); }
    var paths = path.Split('/');

    if (paths.Length > 0)
    {
        var controllerName = paths[0];
        var controllerType = Type.GetType(string.Format("SnugUp.Controller.{0}Controller", controllerName), false, true);
        if (controllerType != null)
        {
            var instance = InitializeControllerInstance(controllerType);
            // default?
            if (paths.Length > 1)
            {
                MethodInfo method = controllerType.GetMethod(paths[1]);
                if (method != null)
                {
                    try
                    {
                        object results = method.Invoke(instance, new object[] {data});
                        return results;
                    }
                    catch (Exception ex)
                    {
                        Debug.WriteLine(ex);
                    }
                }
            }
        }
    }
    return null;
}

It just looks up a request dynamically, maps to a method, and calls it (the response is eventually serialized as JSON).

For UI, I’m currently using Bootstrap (although that may be removed), Knockout.JS, and jQuery. I’m doing a bit of trickery to make sure that only what’s visible on the screen is loaded (even when the user scrolls up and down … it’s pretty smart).  I’ll likely post more about that in a future update.

The app is becoming larger… and bloated a bit when compared to my original needs.

It now can show the images from the gallery as well.