Imagine my surprise when I go looking for an event calendar module and find nothing. How could such a huge CMS not have a simple event calendar? A big part of this misunderstanding was that I didn’t understand Drupal - at all. I still don’t really, but figuring this feature out has helped a lot.

One thing to realize is that Drupal is a content management system. So (eventually) it would make sense to create event content and display that content in a specific way. I surprisingly couldn’t find much documentation on this, so below are the steps I took to get my event calendar up and running. They’re kind of abbreviated, so just ask if you need any clarification. Keep in mind this was a learning experience, so if you have any tips for me, I would like those as well. ;)

1. ## Install Modules
   • View
   • Date
   • CCK
   • Calendar
   • Don’t forget to give yourself permissions to administer these modules and enable them!
2. ## Create Calendar Event Content Type
   1. Name: Event
   2. Type: event
   3. Title Field Label: Event
   4. Body Field Label: Details
   5. Do not promote to front page.
   6. Save
   7. Go to Manage Fields for Event in the content type list
   8. Add a field called Date of type fieldeventdate with a textfield/popup calendar+repeat selector. Configure it to be required and blank by default, have a reasonable format, and to hide the repeat options by default.
   9. Add a field called Location of type field_event_location that is a single-row text field. Configure it to be 100 chars long and required.
3. ## Set up A Calendar View
   1. Go to Administer > Views
   2. Enable the default calendar view and clone it.
      • View Name: a_calendar
      • View Description: Calendar
   3. Change the title to “Whatever you want Calendar”
   4. Change Arguments > Date: Date (Node: Updated date) to Content: Date (field_event_date value) Scroll down a bit to see the checkboxes (under Date fields)
   5. Add a sort criterion for Content: Date (field_event_date value)
   6. Add a filter for Node: Type is one of Event
   7. Click the Calendar page side-tab and change the path to “a_calendar”
   8. Click the Calendar block side-tab and change the block settings admin to “A Calendar”
   9. Save the view.
   10. Navigate to ?q=a_calendar to make sure it is working.
4. ## Set up Roles
   1. Add a new role called Calendar_User and add the following permissions:
      • Edit/view field_event_*
      • (Create | delete own | edit own) event content
   2. Give this role to whoever you want to create event entries. (Let’s call them eventries for fun)
5. ## Add a link somewhere and enjoy!

It's not what I would consider finished, but it works if you need a quick form and don't mind dealing with my markup choices. It behaves sort of like the jQuery tabs plugin, so if you have used that, you should be able to get started fairly quickly.

This is something I've been wanting to figure out for a while. What I'll be demonstrating in this post is how to get driving directions, distances, and trip durations from Google's mapping service... without using Javascript! The demonstration code below is just that - a demonstration. It is your job, dear reader, to make a friendly, accessible interface out of the underlying code.

Note: As far as I can tell, this is undocumented. If you're using this in a production environment, I would advise writing some unit tests in case URLs change, parameters change, etc...

You will need JSON.NET referenced to deserialize the data sent from Google.

using Newtonsoft.Json;

namespace xxxx
{
    public class GDirections
    {
        private string _key = "xxxx";
        private string _output = "js";
        private string _requestFormat = "http://maps.google.com/maps/nav?key={0}&output={1}&q={2}";
        private Hashtable _data = new Hashtable();

Our underlying data. Yes, you could certainly use a generic Dictionary rather than a Hashtable. In the code above, make sure to set _key to your Google Maps API key, which can be generated here.

        /// <param name="path">A path in the format "From {a} to {b}".  Example: "From Lexington, KY to Bowling Green, KY"</param>
public GDirections(string path)
        {
            HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(
                string.Format(_requestFormat, _key, _output, Uri.EscapeUriString(path)));
            request.Method = "GET";
            HttpWebResponse response = (HttpWebResponse)request.GetResponse();
            StreamReader reader = new StreamReader(response.GetResponseStream());
            string json = reader.ReadToEnd();

            _data = readJson(new JsonReader(new StringReader(json)));
        }

In our constructor, we basically just grab the response from a web page. (or in this case, JavaScript object) Using Json.NET, we deserialize the object and somehow stick it in a Hashtable.

        private Hashtable readJson(JsonReader jreader)
        {
            Hashtable data = new Hashtable();
            while (jreader.Read() && jreader.TokenType != JsonToken.EndObject)
            {
                string key = null;
                object value = null;

                if (jreader.TokenType == JsonToken.PropertyName)
                {
                    key = (string)jreader.Value;
                    jreader.Read();
                    switch (jreader.TokenType)
                    {
                        case JsonToken.StartArray:
                            value = readJsonArray(jreader);
                            break;
                        case JsonToken.StartObject:
                            value = readJson(jreader);
                            break;
                        case JsonToken.Null:
                        case JsonToken.Undefined:
                            value = null;
                            break;
                        default:
                            value = jreader.Value;
                            break;
                    }
                }

                if (key != null)
                    data.Add(key, value);
            }
            return data;
        }

        private ArrayList readJsonArray(JsonReader jreader)
        {
            ArrayList value = new ArrayList();
            while (jreader.Read() && jreader.TokenType != JsonToken.EndArray)
            {
                switch (jreader.TokenType)
                {
                    case JsonToken.StartArray:
                        value.Add(readJsonArray(jreader));
                        break;
                    case JsonToken.StartObject:
                        value.Add(readJson(jreader));
                        break;
                    case JsonToken.Null:
                    case JsonToken.Undefined:
                        value.Add(null);
                        break;
                    default:
                        value.Add(jreader.Value);
                        break;
                }
            }
            return value;
        }
    }
}

This is the "somehow stick it in a Hashtable" (or Dictionary) part. The code really is pretty simple, but the resulting data structure is a huge mess. We end up with a nested dictionary-style object with arrays thrown in there just to keep things fun and complicated.

IDEALLY, we would want to create classes for each kind of object we get in our response. For example, Placemark, Status, Point, and Direction classes would need to be created. If even this is too much work, (which it shouldn't be if you are serious about implementing and fully using this functionality!) some more friendly accessor methods/properties shouldn't be a huge chore to do. For example, since we're using this thing just for driving time and duration, I implemented the following accessors

        public decimal DrivingMeters
        {
            get { return Convert.ToDecimal(((Hashtable)Directions["Distance"])["meters"]); }
        }

        public TimeSpan DrivingTime
        {
            get { return new TimeSpan(0, 0, Convert.ToInt32(((Hashtable)Directions["Duration"])["seconds"])); }
        }

        public decimal DrivingMiles
        {
            get { return Math.Round(DrivingMeters * (decimal)0.000621371192, 2); } // according to Google.
        }

        private Hashtable Directions
        {
            get { return (Hashtable)_data["Directions"]; }
        }

So yes, I'm basically saying take this foundation and make it your own. Make it friendly and then give it back to me. :)