have at it

19 files changed, 1423 insertions, 0 deletions

diff --git a/apps/blog/__init__.py b/apps/blog/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/apps/blog/__init__.py
diff --git a/apps/blog/admin.py b/apps/blog/admin.py
new file mode 100644
index 0000000..37aab8d
--- /dev/null
+++ b/apps/blog/admin.py
@@ -0,0 +1,73 @@
+from django.contrib import admin
+from django import forms
+from blog.models import Entry, PostImage
+from blog.widgets import AdminImageWidget
+from django.contrib.gis.admin import OSMGeoAdmin
+from django.contrib.gis.maps.google import GoogleMap
+from django.conf import settings
+
+
+
+GMAP = GoogleMap(key=settings.GOOGLE_MAPS_API_KEY)
+
+class EntryAdmin(OSMGeoAdmin):
+    def formfield_for_dbfield(self, db_field, **kwargs):
+        if db_field.name == 'thumbnail':
+            field = forms.FileField(widget=AdminImageWidget)
+        else:
+            field = super(EntryAdmin,self).formfield_for_dbfield(db_field,**kwargs)
+        return field
+    list_display = ('title', 'pub_date','enable_comments', 'status','region','location')           
+    search_fields = ['title', 'body_markdown']
+    prepopulated_fields = {"slug" : ('title',)}
+    list_filter = ('pub_date', 'enable_comments', 'status','region','location')
+    fieldsets = (
+      ('Entry', {'fields': ('title','body_markdown', ('location','region'), 'pub_date', ('status','enable_comments'), 'tags', 'slug'), 'classes': ('show','extrapretty','wide')}),
+      ('Pub Location', {'fields': ('point',('thumbnail',),'dek'), 'classes': ('collapse', 'wide')}),
+    )
+    extra_js = [GMAP.api_url + GMAP.key]
+    map_template = 'gis/admin/google.html'
+    # Default GeoDjango OpenLayers map options
+    # Uncomment and modify as desired
+    # To learn more about this jargon visit:
+    # www.openlayers.org
+    
+    default_lon = -9314310
+    default_lat = 3991847
+    default_zoom = 6
+    #display_wkt = False
+    #display_srid = False
+    #extra_js = []
+    #num_zoom = 18
+    #max_zoom = False
+    #min_zoom = False
+    #units = False
+    #max_resolution = False
+    #max_extent = False
+    #modifiable = True
+    #mouse_position = True
+    #scale_text = True
+    #layerswitcher = True
+    scrollable = False
+    #admin_media_prefix = settings.ADMIN_MEDIA_PREFIX
+    map_width = 700
+    map_height = 325
+    #map_srid = 4326
+    #map_template = 'gis/admin/openlayers.html'
+    #openlayers_url = 'http://openlayers.org/api/2.6/OpenLayers.js'
+    #wms_url = 'http://labs.metacarta.com/wms/vmap0'
+    #wms_layer = 'basic'
+    #wms_name = 'OpenLayers WMS'
+    #debug = False
+    #widget = OpenLayersWidget
+
+     
+
+
+
+class PostImageAdmin(admin.ModelAdmin):
+	list_display = ('title', 'output_tags')
+	
+
+admin.site.register(PostImage, PostImageAdmin)	
+admin.site.register(Entry, EntryAdmin)
diff --git a/apps/blog/fields.py b/apps/blog/fields.py
new file mode 100644
index 0000000..bab8ad3
--- /dev/null
+++ b/apps/blog/fields.py
@@ -0,0 +1,7 @@
+from django import forms
+from blog.widgets import AdminImageWidget
+
+
+class FileUploadForm(forms.ModelForm):
+    upload = forms.FileField(widget=AdminImageWidget)
+
diff --git a/apps/blog/models.py b/apps/blog/models.py
new file mode 100644
index 0000000..d9cea69
--- /dev/null
+++ b/apps/blog/models.py
@@ -0,0 +1,101 @@
+import datetime
+from django.contrib.gis.db import models
+from django.conf import settings
+from django.contrib.syndication.feeds import Feed
+from django.contrib.sitemaps import Sitemap
+from django.template.defaultfilters import truncatewords_html
+
+
+import markdown2 as markdown
+from tagging.fields import TagField
+from tagging.models import Tag
+
+from photos.models import PhotoGallery
+from locations.models import Location,Region
+#from locations.signals import create_location_item
+
+def get_upload_path(self, filename):
+    return "%s/post-thumbs/%s/%s" %(settings.IMAGES_ROOT, datetime.datetime.today().strftime("%Y"), filename)
+
+def markdown_processor(md):    
+    processed = markdown.markdown(md, safe_mode = False).split('<break>')
+    html = processed[0]+processed[1]
+    lede = processed[0]
+    return html, lede
+
+class PostImage(models.Model):
+    title = models.CharField(max_length=100)
+    image = models.ImageField(upload_to="%s%s" %(settings.IMAGES_ROOT, datetime.datetime.today().strftime("%Y")))
+
+    def __unicode__(self):
+        return self.title
+    
+    def output_tags(self):
+	    return force_unicode('<img src="%s%s" alt="%s" class="postpic"/>' % \
+                (settings.IMAGES_URL, self.image.url.split('images')[1].split('/',1)[1], self.title))
+
+class Entry(models.Model):
+    title = models.CharField(max_length=200)
+    slug = models.SlugField(unique_for_date='pub_date')
+    lede = models.TextField(blank=True)
+    body_html = models.TextField(blank=True)
+    body_markdown = models.TextField()
+    dek = models.TextField(null=True,blank=True)
+    pub_date = models.DateTimeField('Date published')
+    tags = TagField()
+    enable_comments = models.BooleanField(default=True)
+    point = models.PointField(null=True)
+    location = models.ForeignKey(Location, null=True)
+    region = models.ForeignKey(Region, null=True)
+    PUB_STATUS = (
+        (0, 'Draft'),
+        (1, 'Published'),
+    )
+    status = models.IntegerField(choices=PUB_STATUS, default=0)
+    photo_gallery = models.ForeignKey(PhotoGallery, blank=True, null=True, verbose_name='photo set')
+    thumbnail = models.FileField(upload_to=get_upload_path, null=True,blank=True)
+    
+    class Meta:
+        ordering = ('-pub_date',)
+        get_latest_by = 'pub_date'
+        verbose_name_plural = 'entries'
+
+    def __unicode__(self):
+        return self.title
+
+    def get_absolute_url(self):
+        return "/%s/%s/" % (self.pub_date.strftime("%Y/%b/%d").lower(), self.slug)
+    
+    def get_previous_published(self):
+        return self.get_previous_by_pub_date(status__exact=1)
+        
+    def get_next_published(self):
+        return self.get_next_by_pub_date(status__exact=1)
+
+    def get_tags(self):
+        return Tag.objects.get_for_object(self)
+        
+    def comment_period_open(self):
+        return self.enable_comments and datetime.datetime.today() - datetime.timedelta(30) <= self.pub_date
+    
+    def get_thumbnail_url(self):
+        return '%s%s' %(settings.IMAGES_URL, self.thumbnail.url[33:])
+    
+    def save(self): 
+         html,lede = markdown_processor(self.body_markdown)
+         self.body_html = html
+         self.lede = lede
+         self.dek == markdown.markdown(self.dek, safe_mode = False)
+         super(Entry, self).save()
+
+class BlogSitemap(Sitemap):
+    changefreq = "never"
+    priority = 1.0
+
+    def items(self):
+        return Entry.objects.filter(status=1)
+
+    def lastmod(self, obj):
+        return obj.pub_date
+
+#signals.post_save.connect(create_location_item, sender=Entry)
\ No newline at end of file
diff --git a/apps/blog/urls.py b/apps/blog/urls.py
new file mode 100644
index 0000000..57a3e7a
--- /dev/null
+++ b/apps/blog/urls.py
@@ -0,0 +1,15 @@
+from django.conf.urls.defaults import *
+from django.views.generic.list_detail import object_list
+from django.views.generic.simple import redirect_to
+
+from blog.models import Entry
+
+
+
+urlpatterns = patterns('',
+    
+    (r'(?P<slug>[-\w]+)/(?P<page>\d+)/$', 'blog.views.entry_list_by_area'),
+    (r'(?P<page>\d+)/$', 'blog.views.entry_list'),
+    (r'(?P<slug>[-\w]+)/$', redirect_to, {'url': '/writing/%(slug)s/1/'}),
+    (r'', redirect_to, {'url': '/writing/1/'}),
+)
diff --git a/apps/blog/views.py b/apps/blog/views.py
new file mode 100644
index 0000000..9641813
--- /dev/null
+++ b/apps/blog/views.py
@@ -0,0 +1,65 @@
+from django.shortcuts import render_to_response,get_object_or_404
+from django.template import RequestContext
+from django.views.generic.date_based import object_detail
+from django.views.generic.list_detail import object_list
+from django.http import Http404
+
+
+from blog.models import Entry
+from locations.models import Region, Country
+
+def home(request):
+    featured = Entry.objects.filter(status__exact=1).order_by('-pub_date')[:1].get()
+    context = {
+        'featured': featured,
+        'object_list': Entry.objects.all().exclude(id=featured.id).order_by('-pub_date')[:5],
+    }    
+    return render_to_response('archives/homepage.html', context, context_instance = RequestContext(request))
+
+
+def entry_detail(request, year, month, day, slug):
+    obj = get_object_or_404(Entry, slug__exact=slug)
+    photos = {}
+    if obj.photo_gallery:
+        photos = Photo.objects.filter(set__exact=obj.get().photo_gallery.id)[:9]
+    extra = {'photos':photos,}
+    return render_to_response('details/entry.html', {'object': obj,'photos':photos}, context_instance=RequestContext(request))
+
+
+"""
+List of all writing
+"""
+def entry_list(request,page):
+    request.page_url = '/writing/%d/'
+    request.page = int(page)
+    qs = Entry.objects.filter(status__exact=1).order_by('-pub_date')
+    context = {
+        'country_list': Country.objects.filter(visited=True),
+        'region_list': Region.objects.all()
+    }
+    return object_list(request, queryset=qs, template_name='archives/writing.html',
+                       extra_context=context)
+
+
+"""
+Grabs entries by region or country
+"""
+def entry_list_by_area(request,slug,page):
+    request.page_url = '/writing/'+slug+'/%d/'
+    request.page = int(page)
+    try:
+        region = Region.objects.get(slug__exact=slug)
+        qs = Entry.objects.filter(status__exact=1,region = region).order_by('-pub_date')
+    except:
+        region = Country.objects.get(slug__exact=slug)
+        qs = Entry.objects.filter(status__exact=1,location__state__country = region).order_by('-pub_date')
+        if not region:
+            raise Http404
+    context = {
+        'region': region,
+        'country_list': Country.objects.filter(visited=True),
+        'region_list': Region.objects.all()
+    }
+    return object_list(request, queryset=qs, template_name='archives/writing.html',
+                       extra_context=context)
+
diff --git a/apps/blog/widgets.py b/apps/blog/widgets.py
new file mode 100644
index 0000000..a9451e7
--- /dev/null
+++ b/apps/blog/widgets.py
@@ -0,0 +1,32 @@
+from django.contrib.admin.widgets import AdminFileWidget
+from django.utils.translation import ugettext as _
+from django.utils.safestring import mark_safe
+from django.conf import settings
+from PIL import Image
+import os
+
+try:
+    from sorl.thumbnail.main import DjangoThumbnail
+    def thumbnail(image_path):
+        t = DjangoThumbnail(relative_source=image_path, requested_size=(200,200))
+        return u'<img src="%s" alt="%s" />' % (t.absolute_url, image_path)
+except ImportError:
+    def thumbnail(image_path):
+        absolute_url = os.path.join(settings.IMAGES_URL, image_path)
+        return u'<img src="%s" alt="%s" />' % (absolute_url, image_path)
+
+class AdminImageWidget(AdminFileWidget):
+    """
+    A FileField Widget that displays an image instead of a file path
+    if the current file is an image.
+    """
+    def render(self, name, value, attrs=None):
+        output = []
+        file_name = str(value)
+        if file_name:
+            file_path = '%s' % (file_name)
+            output.append('<a target="_blank" href="%s">%s</a><br />%s <a target="_blank" href="%s">%s</a><br />%s ' % \
+                    (file_path, thumbnail(file_name), _('Currently:'), file_path, file_name, _('Change:')))
+             
+        output.append(super(AdminFileWidget, self).render(name, value, attrs))
+        return mark_safe(u''.join(output))
diff --git a/apps/locations/__init__.py b/apps/locations/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/apps/locations/__init__.py
diff --git a/apps/locations/admin.py b/apps/locations/admin.py
new file mode 100644
index 0000000..7fcfee5
--- /dev/null
+++ b/apps/locations/admin.py
@@ -0,0 +1,241 @@
+from django.contrib import admin
+from django.contrib.gis.admin import OSMGeoAdmin
+from locations.models import Region,Country,Location,State
+from django.contrib import databrowse
+from django.contrib.gis.maps.google import GoogleMap
+from django.conf import settings
+
+GMAP = GoogleMap(key=settings.GOOGLE_MAPS_API_KEY)
+databrowse.site.register(Region)
+
+class RegionAdmin(OSMGeoAdmin):
+    # Standard Django Admin Options
+    list_display = ('name','slug')
+    prepopulated_fields = {'slug': ('name',)}
+    search_fields = ('name',)
+    ordering = ('name',)
+    save_as = True
+    search_fields = ['name',]
+    list_select_related = True
+    fieldsets = (
+      ('Region', {'fields': ('name','slug','pub_date'), 'classes': ('show','extrapretty')}),
+      ('Editable Map View', {'fields': ('geometry',), 'classes': ('show', 'wide')}),
+    )
+    extra_js = [GMAP.api_url + GMAP.key]
+    map_template = 'gis/admin/google.html'
+    # Default GeoDjango OpenLayers map options
+    # Uncomment and modify as desired
+    # To learn more about this jargon visit:
+    # www.openlayers.org
+    
+    #default_lon = 0
+    #default_lat = 0
+    #default_zoom = 4
+    #display_wkt = False
+    #display_srid = False
+    #extra_js = []
+    #num_zoom = 18
+    #max_zoom = False
+    #min_zoom = False
+    #units = False
+    #max_resolution = False
+    #max_extent = False
+    #modifiable = True
+    #mouse_position = True
+    #scale_text = True
+    #layerswitcher = True
+    scrollable = False
+    #admin_media_prefix = settings.ADMIN_MEDIA_PREFIX
+    map_width = 700
+    map_height = 325
+    #map_srid = 4326
+    #map_template = 'gis/admin/openlayers.html'
+    #openlayers_url = 'http://openlayers.org/api/2.6/OpenLayers.js'
+    #wms_url = 'http://labs.metacarta.com/wms/vmap0'
+    #wms_layer = 'basic'
+    #wms_name = 'OpenLayers WMS'
+    #debug = False
+    #widget = OpenLayersWidget
+
+# Finally, with these options set now register the model
+# associating the Options with the actual model
+admin.site.register(Region,RegionAdmin)
+
+class CountryAdmin(OSMGeoAdmin):
+    """
+    # Standard Django Admin Options
+    list_display = ('name','slug','region')
+    prepopulated_fields = {'slug': ('name',)}
+    search_fields = ('name',)
+    ordering = ('name',)
+    save_as = True
+    search_fields = ['name',]
+    list_select_related = True
+    fieldsets = (
+      ('Country', {'fields': ('name','slug','abbr','region','pub_date'), 'classes': ('show','extrapretty')}),
+      ('Editable Map View', {'fields': ('geometry',), 'classes': ('show', 'wide')}),
+    )
+    """
+    
+     # Standard Django Admin Options
+    list_display = ('name','pop2005','region','subregion',)
+    search_fields = ('name',)
+    ordering = ('name',)
+    list_filter = ('visited','region','subregion',)
+    save_as = True
+    search_fields = ['name','iso2','iso3','subregion','region']
+    list_select_related = True
+    fieldsets = (
+      ('Country Attributes', {'fields': (('name','pop2005','slug','zoom_level','visited')), 'classes': ('show','extrapretty')}),
+      ('Country Codes', {'fields': ('region','subregion','iso2','iso3','un',), 'classes': ('collapse',)}),
+      ('Area and Coordinates', {'fields': ('area','lat','lon',), 'classes': ('collapse', 'wide')}),
+      ('Editable Map View', {'fields': ('geometry',), 'classes': ('show', 'wide')}),
+    )
+
+    extra_js = [GMAP.api_url + GMAP.key]
+    map_template = 'gis/admin/google.html'
+    # Default GeoDjango OpenLayers map options
+    # Uncomment and modify as desired
+    # To learn more about this jargon visit:
+    # www.openlayers.org
+    
+    #default_lon = 0
+    #default_lat = 0
+    #default_zoom = 4
+    #display_wkt = False
+    #display_srid = False
+    #extra_js = []
+    #num_zoom = 18
+    #max_zoom = False
+    #min_zoom = False
+    #units = False
+    #max_resolution = False
+    #max_extent = False
+    #modifiable = True
+    #mouse_position = True
+    #scale_text = True
+    #layerswitcher = True
+    scrollable = False
+    #admin_media_prefix = settings.ADMIN_MEDIA_PREFIX
+    map_width = 700
+    map_height = 325
+    #map_srid = 4326
+    #map_template = 'gis/admin/openlayers.html'
+    #openlayers_url = 'http://openlayers.org/api/2.6/OpenLayers.js'
+    #wms_url = 'http://labs.metacarta.com/wms/vmap0'
+    #wms_layer = 'basic'
+    #wms_name = 'OpenLayers WMS'
+    #debug = False
+    #widget = OpenLayersWidget
+
+# Finally, with these options set now register the model
+# associating the Options with the actual model
+admin.site.register(Country,CountryAdmin)
+
+
+
+class StateAdmin(OSMGeoAdmin):
+    # Standard Django Admin Options
+    list_display = ('name','slug','country')
+    prepopulated_fields = {'slug': ('name',)}
+    search_fields = ('name','country')
+    ordering = ('name',)
+    save_as = True
+    search_fields = ['name',]
+    list_select_related = True
+    fieldsets = (
+      ('Location', {'fields': ('name','slug','pub_date','country'), 'classes': ('show','extrapretty')}),
+      ('Editable Map View', {'fields': ('geometry',), 'classes': ('show', 'wide')}),
+    )
+    extra_js = [GMAP.api_url + GMAP.key]
+    map_template = 'gis/admin/google.html'
+    # Default GeoDjango OpenLayers map options
+    # Uncomment and modify as desired
+    # To learn more about this jargon visit:
+    # www.openlayers.org
+    
+    #default_lon = 0
+    #default_lat = 0
+    #default_zoom = 4
+    #display_wkt = False
+    #display_srid = False
+    #extra_js = []
+    #num_zoom = 18
+    #max_zoom = False
+    #min_zoom = False
+    #units = False
+    #max_resolution = False
+    #max_extent = False
+    #modifiable = True
+    #mouse_position = True
+    #scale_text = True
+    #layerswitcher = True
+    scrollable = False
+    #admin_media_prefix = settings.ADMIN_MEDIA_PREFIX
+    map_width = 700
+    map_height = 325
+    #map_srid = 4326
+    #map_template = 'gis/admin/openlayers.html'
+    #openlayers_url = 'http://openlayers.org/api/2.6/OpenLayers.js'
+    #wms_url = 'http://labs.metacarta.com/wms/vmap0'
+    #wms_layer = 'basic'
+    #wms_name = 'OpenLayers WMS'
+    #debug = False
+    #widget = OpenLayersWidget
+
+# Finally, with these options set now register the model
+# associating the Options with the actual model
+admin.site.register(State,StateAdmin)
+
+class LocationAdmin(OSMGeoAdmin):
+    # Standard Django Admin Options
+    list_display = ('name','slug','state')
+    prepopulated_fields = {'slug': ('name',)}
+    search_fields = ('name','state')
+    ordering = ('name',)
+    save_as = True
+    search_fields = ['name',]
+    list_select_related = True
+    fieldsets = (
+      ('Location', {'fields': ('name','slug','pub_date','state'), 'classes': ('show','extrapretty')}),
+      ('Editable Map View', {'fields': ('geometry',), 'classes': ('show', 'wide')}),
+    )
+    extra_js = [GMAP.api_url + GMAP.key]
+    map_template = 'gis/admin/google.html'
+    # Default GeoDjango OpenLayers map options
+    # Uncomment and modify as desired
+    # To learn more about this jargon visit:
+    # www.openlayers.org
+    
+    #default_lon = 0
+    #default_lat = 0
+    #default_zoom = 4
+    #display_wkt = False
+    #display_srid = False
+    #extra_js = []
+    #num_zoom = 18
+    #max_zoom = False
+    #min_zoom = False
+    #units = False
+    #max_resolution = False
+    #max_extent = False
+    #modifiable = True
+    #mouse_position = True
+    #scale_text = True
+    #layerswitcher = True
+    scrollable = False
+    #admin_media_prefix = settings.ADMIN_MEDIA_PREFIX
+    map_width = 700
+    map_height = 325
+    #map_srid = 4326
+    #map_template = 'gis/admin/openlayers.html'
+    #openlayers_url = 'http://openlayers.org/api/2.6/OpenLayers.js'
+    #wms_url = 'http://labs.metacarta.com/wms/vmap0'
+    #wms_layer = 'basic'
+    #wms_name = 'OpenLayers WMS'
+    #debug = False
+    #widget = OpenLayersWidget
+
+# Finally, with these options set now register the model
+# associating the Options with the actual model
+admin.site.register(Location,LocationAdmin)
\ No newline at end of file
diff --git a/apps/locations/models.py b/apps/locations/models.py
new file mode 100644
index 0000000..57806a2
--- /dev/null
+++ b/apps/locations/models.py
@@ -0,0 +1,170 @@
+# -*- coding: utf-8 -*-
+# models.py
+
+# All standard Django fields as well as GeoDjango geometry fields and the GeoManager() can be
+# imported from django.contrib.gis.db after adding django.contrib.gis to INSTALLED_APPS
+from django.contrib.gis.db import models
+from django.contrib.sitemaps import Sitemap
+# Used to display html 'help text' links within Admin App
+from django.utils.safestring import mark_safe
+
+class Region(models.Model):
+    name = models.CharField(max_length=50, )
+    slug = models.SlugField()
+    pub_date = models.DateTimeField('Date published',null=True)
+    # GeoDjango specific Polygon Field and GeoManager
+    geometry = models.MultiPolygonField(srid=4326, null=True)
+    lon = models.FloatField('Longitude',help_text="Longitude of centerpoint",null=True)
+    lat = models.FloatField('Latitude',help_text="Latitude of centerpoint",null=True)
+    zoom_level = models.CharField(max_length=2,null=True)
+    # GeoManager, a subclass that adds a rich set of geospatial queryset methods
+    objects = models.GeoManager()
+        
+    def get_absolute_url(self):
+        return "/locations/region/%s/" % (self.slug)
+        
+    def __unicode__(self): return self.name
+
+
+# imported from django.contrib.gis.db
+from django.contrib.gis.db import models
+
+# Used to display html 'help text' links within Admin App
+from django.utils.safestring import mark_safe
+
+class Country(models.Model):
+    """
+    
+    A geographic model based on the v3 of the simplified world borders multipolygon shapefile
+    from http://thematicmapping.org/downloads/world_borders.php.
+    
+    Field names, Django types, and max_lengths were autogenerated using the ogrinspect utility with hand
+    edits to add alternative field names and help_text.
+    
+    Imported using LayerMapping (requires GDAL) called within the load_data.py script provided
+    within this sample project.
+    
+    All fields match the source dataset, an ESRI format shapefile made up of several related files:
+    .shp - holds the vector data that is to be stored in the MultiPolygonField field named'geometry'.
+    .shx - spatial index file for geometries stored in the .shp.
+    .dbf - database file for holding attribute data (can be opened in excel and open office).
+    .prj - contains the spatial reference information for the geometries stored in the .shp
+      
+
+    """
+    
+    # Regular Django fields corresponding to the attributes in the
+    # world borders shapefile
+    name = models.CharField(max_length=50)
+    area = models.IntegerField(help_text="Area of Country in SQ meters")
+    pop2005 = models.IntegerField('Population 2005')
+    fips = models.CharField('FIPS Code', max_length=2, help_text=mark_safe('<a href="http://www.census.gov/geo/www/fips/fips.html">Federal Information Processing Standard Code</a>'))
+    iso2 = models.CharField('2 Digit ISO', max_length=2, help_text=mark_safe('<a href="http://www.iso.org/">International Organization for Standardization</a>' ))
+    iso3 = models.CharField('3 Digit ISO', max_length=3,help_text=mark_safe('<a href="http://www.iso.org/">International Organization for Standardization</a>' ))
+    un = models.IntegerField('United Nations Code')
+    REGION_CODES = (
+        (0, 'MISC'),
+        (2, 'Africa'),
+        (9, 'Oceania'),
+        (19, 'Americas'),
+        (142, 'Asia'),
+        (150, 'Europe'),
+    )
+    SUBREGION_CODES = (
+        (0, 'MISC'),
+        (5, 'South America'),
+        (11, 'Western Africa'),
+        (13, 'Central America'),
+        (14, 'Eastern Africa'),
+        (15, 'Northern Africa'),
+        (17, 'Middle Africa'),
+        (18, 'Southern Africa'),
+        (21, 'North America'),
+        (29, 'Caribbean'),
+        (30, 'Eastern Asia'),
+        (34, 'Southern Asia'),
+        (35, 'Southeast Asia'),
+        (39, 'Southern Europe'),
+        (53, 'Australia and New Zealand'),
+        (54, 'Melanesia'),
+        (57, 'Micronesia'),
+        (61, 'Polynesia'),
+        (143, 'Central Asia'),
+        (145, 'Western Asia'),
+        (151, 'Eastern Europe'),
+        (154, 'Northern Europe'),
+        (155, 'Western Europe'),
+    )
+    region = models.IntegerField('Region Code',choices=REGION_CODES)
+    subregion = models.IntegerField('Sub-Region Code',choices=SUBREGION_CODES)
+    lon = models.FloatField('Longitude',help_text="Longitude of centerpoint")
+    lat = models.FloatField('Latitude',help_text="Latitude of centerpoint")
+    zoom_level = models.CharField(max_length=2,null=True)
+    slug = models.SlugField(null=True)
+    visited = models.BooleanField(default=False)
+    lux_region = models.ForeignKey(Region, null=True)
+    pub_date = models.DateTimeField('Date published',null=True)
+    # GeoDjango-specific: a geometry field (MultiPolygonField), and
+    # overriding the default manager with a GeoManager instance.
+    geometry = models.MultiPolygonField('Country Border',srid=4326)
+    objects = models.GeoManager()
+
+  
+    # Returns the string representation of the model.        
+    def __unicode__(self):
+        return self.name
+  
+    class Meta:
+        ordering = ['name']
+        verbose_name_plural = 'Countries'
+        
+    def get_absolute_url(self):
+        return "/locations/%s/" % (self.slug)
+
+    
+class State(models.Model):
+    name = models.CharField(max_length=250, blank=True, null=True,)
+    country = models.ForeignKey(Country)
+    slug = models.SlugField()
+    pub_date = models.DateTimeField('Date published',null=True)
+    geometry = models.MultiPolygonField(srid=4326,null=True)
+    objects = models.GeoManager()
+    
+    class Meta:
+        ordering = ['name']
+    
+    class Admin:
+        pass
+        
+    def __unicode__(self):
+        return "%s" %(self.name)
+
+    def get_absolute_url(self):
+        return "/locations/%s/%s/" % (self.country.slug, self.slug)
+
+class Location(models.Model):
+    state = models.ForeignKey(State)
+    name = models.CharField(max_length=50, )
+    slug = models.SlugField()
+    pub_date = models.DateTimeField('Date published',null=True)
+    # GeoDjango specific Polygon Field and GeoManager
+    geometry = models.MultiPolygonField(srid=4326)
+    # GeoManager, a subclass that adds a rich set of geospatial queryset methods
+    objects = models.GeoManager()
+        
+    def get_absolute_url(self):
+        return "/locations/%s/%s/%s/" % (self.state.country.slug, self.state.slug, self.slug)
+
+        
+    def __unicode__(self): return self.name
+
+class WritingbyLocationSitemap(Sitemap):
+    changefreq = "weekly"
+    priority = 0.6
+    
+    def location():
+        return '/writing/%s/1/' %(self.slug)
+    
+    def items(self):
+        return Location.objects.all()
+
diff --git a/apps/locations/urls.py b/apps/locations/urls.py
new file mode 100644
index 0000000..669b828
--- /dev/null
+++ b/apps/locations/urls.py
@@ -0,0 +1,6 @@
+from django.conf.urls.defaults import *
+
+urlpatterns = patterns('',
+	#(r'(?P<slug>[0-9a-zA-Z_.-]+)/$', 'locations.views.list_view_region'),
+	(r'^$', 'locations.views.list_view'),	
+)
diff --git a/apps/locations/views.py b/apps/locations/views.py
new file mode 100644
index 0000000..a59a2e5
--- /dev/null
+++ b/apps/locations/views.py
@@ -0,0 +1,11 @@
+from django.shortcuts import render_to_response,get_object_or_404
+from django.template import RequestContext
+
+from blog.models import Entry
+from locations.models import Location, Country, Region
+
+def list_view(request):
+    qs = Entry.objects.filter(status__exact=1)
+    cl = Country.objects.filter(visited=True).exclude(name='default')
+    rl = Region.objects.all()
+    return render_to_response('archives/map.html', {'object_list': qs,'country_list':cl,'region_list':rl}, context_instance=RequestContext(request))
\ No newline at end of file
diff --git a/apps/photos/__init__.py b/apps/photos/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/apps/photos/__init__.py
diff --git a/apps/photos/admin.py b/apps/photos/admin.py
new file mode 100644
index 0000000..3cc1ae8
--- /dev/null
+++ b/apps/photos/admin.py
@@ -0,0 +1,66 @@
+from django.contrib import admin
+from django.contrib.gis.admin import OSMGeoAdmin
+from django.contrib.gis.maps.google import GoogleMap
+from django.conf import settings
+
+from photos.models import Photo,PhotoGallery
+
+GMAP = GoogleMap(key=settings.GOOGLE_MAPS_API_KEY)
+
+class PhotoAdmin(OSMGeoAdmin):
+    list_display = ('title','admin_thumbnail', 'flickr_id', 'pub_date',)
+    list_filter = ('pub_date',)
+    fieldsets = (
+        (None, {'fields': (('title', 'description'),'pub_date', 'tags',('lat','lon'))}),
+        ('Exif Data', {'fields': ('exif_aperture','exif_shutter','exif_iso','exif_lens','exif_date','exif_make','exif_model'), 'classes': ('collapse')}),
+        ('Flickr Data', {'fields': ('flickr_id','flickr_owner','flickr_farm','flickr_server','flickr_secret','flickr_originalsecret'), 'classes': ('collapse')}),
+    )
+    extra_js = [GMAP.api_url + GMAP.key]
+    map_template = 'gis/admin/google.html'
+    # Default GeoDjango OpenLayers map options
+    # Uncomment and modify as desired
+    # To learn more about this jargon visit:
+    # www.openlayers.org
+    
+    #default_lon = 0
+    #default_lat = 0
+    #default_zoom = 4
+    #display_wkt = False
+    #display_srid = False
+    #extra_js = []
+    #num_zoom = 18
+    #max_zoom = False
+    #min_zoom = False
+    #units = False
+    #max_resolution = False
+    #max_extent = False
+    #modifiable = True
+    #mouse_position = True
+    #scale_text = True
+    #layerswitcher = True
+    scrollable = False
+    #admin_media_prefix = settings.ADMIN_MEDIA_PREFIX
+    map_width = 700
+    map_height = 325
+    #map_srid = 4326
+    #map_template = 'gis/admin/openlayers.html'
+    #openlayers_url = 'http://openlayers.org/api/2.6/OpenLayers.js'
+    #wms_url = 'http://labs.metacarta.com/wms/vmap0'
+    #wms_layer = 'basic'
+    #wms_name = 'OpenLayers WMS'
+    #debug = False
+    #widget = OpenLayersWidget
+
+admin.site.register(Photo, PhotoAdmin)
+
+
+class PhotoGalleryAdmin(OSMGeoAdmin):
+    list_display = ('set_title','region','location')
+    list_filter = ('region','location')
+    fieldsets = (
+        (None, {'fields': (('set_id','set_title', 'set_desc'),'set_slug','primary','location','region')}),
+    )
+    
+    
+    
+admin.site.register(PhotoGallery, PhotoGalleryAdmin)
\ No newline at end of file
diff --git a/apps/photos/detail_urls.py b/apps/photos/detail_urls.py
new file mode 100644
index 0000000..9ff9b84
--- /dev/null
+++ b/apps/photos/detail_urls.py
@@ -0,0 +1,10 @@
+from django.conf.urls.defaults import *
+from photos.models import Photo
+
+detail_dict = {
+	'queryset': Photo.objects.all(),
+}
+
+urlpatterns = patterns('django.views.generic.list_detail',
+	(r'^(?P<object_id>\d+)/$', 'object_detail', dict(detail_dict, template_name='details/photo.html')),
+)
diff --git a/apps/photos/models.py b/apps/photos/models.py
new file mode 100644
index 0000000..9b6d331
--- /dev/null
+++ b/apps/photos/models.py
@@ -0,0 +1,154 @@
+import datetime
+from django.contrib.gis.db import models
+from django.contrib.syndication.feeds import Feed
+from django.contrib.sitemaps import Sitemap
+from django.utils.encoding import force_unicode
+from django.conf import settings
+
+from tagging.fields import TagField
+from tagging.models import Tag
+
+from locations.models import Location,Region
+
+class Photo(models.Model):
+    description = models.TextField(blank=True, null=True)
+    title = models.CharField(blank=True, max_length=300)
+    pub_date = models.DateTimeField()
+    tags = TagField()
+    exif_aperture = models.CharField(max_length=50, blank=True, null=True)
+    exif_make = models.CharField(max_length=50, blank=True, null=True)
+    exif_model = models.CharField(max_length=50, blank=True, null=True)
+    exif_shutter = models.CharField(max_length=50, blank=True, null=True)
+    exif_iso = models.CharField(max_length=50, blank=True, null=True)
+    exif_lens = models.CharField(max_length=50, blank=True, null=True)
+    exif_date = models.DateTimeField()
+    """Flickr Specific Stuff"""
+    flickr_id = models.CharField(max_length=300) #varchar since Flickr ids are larger than than integerfield can handle and BigIntegerField gets weird in Postgres.
+    flickr_owner = models.CharField(max_length=20)
+    flickr_server = models.IntegerField()
+    flickr_farm = models.IntegerField()
+    flickr_secret = models.CharField(max_length=50)
+    flickr_originalsecret = models.CharField(max_length=50)
+    lon = models.FloatField('Longitude',help_text="Longitude of centerpoint",null=True)
+    lat = models.FloatField('Latitude',help_text="Latitude of centerpoint",null=True)
+    location = models.ForeignKey(Location, null=True)
+    region = models.ForeignKey(Region, null=True)
+    
+    
+
+        
+    class Meta:
+        ordering = ('-pub_date',)
+
+
+    def admin_thumbnail(self):
+        return force_unicode('<a href="%s"><img src="%s"></a>' % \
+                (self.get_absolute_url(), self.get_small_square_url()))
+    admin_thumbnail.allow_tags = True
+    admin_thumbnail.short_description = 'Thumbnail'
+    
+            
+    def __unicode__(self):
+        return self.title
+        
+    def get_absolute_url(self):
+        return "/photo/%s/" % (self.id)
+        
+    def get_model_name(self):
+        return 'photo'
+        
+    def get_small_square_url(self):
+        return self.get_pic_url(size="small_square")
+        
+    def get_large_url(self):
+        return self.get_pic_url(size="large")
+    
+    def get_small_url(self):
+        return self.get_pic_url(size="small")
+    
+    def get_medium_url(self):
+        return self.get_pic_url(size="medium")
+    
+    def get_original_url(self):
+        #return self.get_pic_url(size="original")
+        return "http://farm%s.static.flickr.com/%s/%s_%s_o.jpg" % (self.flickr_farm, self.flickr_server, self.flickr_id, self.flickr_originalsecret)
+    
+    def get_pic_url(self, size='small'):
+        # small_square=75x75
+        # thumb=100 on longest side
+        # small=240 on longest side
+        # medium=500 on longest side
+        # large=1024 on longest side
+        # original=duh
+    
+        base_url = "http://static.flickr.com"
+        size_char='s'  # default to small_square
+        
+        if size == 'small_square':
+            size_char='_s'
+        elif size == 'thumb':
+            size_char='_t'
+        elif size == 'small':
+            size_char='_m'
+        elif size == 'medium':
+            size_char=''
+        elif size == 'large':
+            size_char='_b'
+        elif size == 'original':
+            size_char='_o'
+    
+        return "http://farm%s.static.flickr.com/%s/%s_%s%s.jpg" % (self.flickr_farm, self.flickr_server, self.flickr_id, self.flickr_secret, size_char)
+        
+    def get_tumble_image(self):
+        return "%s/crops/%s/%s.jpg" %(settings.IMAGES_URL, self.pub_date.strftime("%Y/%b").lower(), self.id)
+        
+    def get_tags(self):
+        return Tag.objects.get_for_object(self)
+                
+    def get_previous_published(self):
+        return self.get_previous_by_pub_date()
+        
+    def get_next_published(self):
+        return self.get_next_by_pub_date()
+    
+    def comment_period_open(self):
+        return self.enable_comments and datetime.datetime.today() - datetime.timedelta(30) <= self.pub_date
+    """    
+    def save(self):
+        self.lat = self.gps.split(',')[0]
+        self.lon = self.gps.split(',')[1]
+        super(Photo, self).save()
+    """
+class PhotoGallery(models.Model):
+    set_id = models.CharField(blank=True, max_length=300)
+    set_title = models.CharField(blank=True, max_length=300)
+    set_desc = models.TextField(blank=True, null=True)
+    set_slug = models.CharField(blank=True, max_length=300)
+    primary = models.CharField(blank=True, max_length=300)
+    photos = models.ManyToManyField(Photo)
+    location = models.ForeignKey(Location, null=True)
+    region = models.ForeignKey(Region, null=True)
+    
+    class Meta:
+        ordering = ('id',)
+        
+    def __unicode__(self):
+        return self.set_title
+        
+    def get_main_image(self):
+        return "%sgallery_thumbs/%s.jpg" % (settings.IMAGES_URL, self.id)
+    
+    def get_absolute_url(self):
+        return "/photos/album/%s/" % (self.id)
+          
+   
+class PhotoSitemap(Sitemap):
+    changefreq = "never"
+    priority = 0.7
+
+    def items(self):
+        return Photo.objects.all()
+
+    def lastmod(self, obj):
+        return obj.pub_date
+
diff --git a/apps/photos/urls.py b/apps/photos/urls.py
new file mode 100644
index 0000000..44b4869
--- /dev/null
+++ b/apps/photos/urls.py
@@ -0,0 +1,12 @@
+from django.conf.urls.defaults import *
+from django.views.generic import list_detail
+from django.views.generic.simple import redirect_to
+
+
+
+urlpatterns = patterns('',
+    (r'(?P<slug>[-\w]+)/(?P<page>\d+)/$', 'photos.views.gallery_list_by_area'),
+    (r'(?P<page>\d+)/$', 'photos.views.gallery_list'),
+    (r'(?P<slug>[-\w]+)/$', redirect_to, {'url': '/photos/%(slug)s/1/'}),
+    (r'', redirect_to, {'url': '/photos/1/'}),
+)
\ No newline at end of file
diff --git a/apps/photos/utils.py b/apps/photos/utils.py
new file mode 100644
index 0000000..de0884d
--- /dev/null
+++ b/apps/photos/utils.py
@@ -0,0 +1,411 @@
+from __future__ import division
+import datetime
+import os
+import cStringIO # *much* faster than StringIO
+import urllib
+
+
+from django.contrib.contenttypes.models import ContentType
+from django.template.defaultfilters import slugify
+from django.core.exceptions import ObjectDoesNotExist
+from django.utils.encoding import force_unicode,smart_unicode
+from django.conf import settings
+
+# Required PIL classes may or may not be available from the root namespace
+# depending on the installation
+try:
+    import Image
+    import ImageFile
+    import ImageFilter
+    import ImageEnhance
+except ImportError:
+    try:
+        from PIL import Image
+        from PIL import ImageFile
+        from PIL import ImageFilter
+        from PIL import ImageEnhance
+    except ImportError:
+        raise ImportError("Could not import the Python Imaging Library.")
+  
+
+from strutils import safestr
+from photos.models import Photo,PhotoGallery
+
+
+# Flickr Sync stuffs
+API_KEY = settings.FLICKR_API_KEY
+from APIClients import FlickrClient
+
+EXIF_PARAMS = {"Aperture":'f/2.8',"Make":'Apple',"Model":'iPhone',"Exposure":'',"ISO Speed":'',"Focal Length":'',"Shutter Speed":'','Date and Time (Original)':'2008:07:03 22:44:25'}
+
+def sync_flickr_photos(*args, **kwargs):
+    cur_page = 1           # Start on the first page of the stream
+    paginate_by = 100       # Get 100 photos at a time
+    dupe = False           # Set our dupe flag for the following loop
+    BASE_PATH = 'http://flickr.com/services/rest/'
+    client = FlickrClient(BASE_PATH, API_KEY)
+    data = client.flickr_people_getPublicPhotos(user_id=settings.FLICKR_USER_ID, page=cur_page, per_page=paginate_by,extras="date_upload,date_taken,geo")
+    #photos.photos.photo.reverse()
+    for post in data.findall('photos/photo'):
+        info = dict((k, smart_unicode(post.get(k))) for k in post.keys())
+        try:
+            row = Photo.objects.get(flickr_id=info['id'], flickr_secret=info['secret'])
+            # If the row exists already, set the dupe flag
+            dupe = True
+            print 'already have '+info['id']+' moving on'
+        except ObjectDoesNotExist:
+            taglist = []
+            place = place_handler(force_unicode(info['latitude'])+","+force_unicode(info['longitude']))
+            details = client.flickr_photos_getInfo(user_id=settings.FLICKR_USER_ID, photo_id=force_unicode(info['id']))
+            for t in details.findall('photo/tags/tag'):
+                tag = dict((k, smart_unicode(t.get(k))) for k in t.keys())
+                taglist.append(tag['raw'])
+            exif = exif_handler(client.flickr_photos_getExif(user_id=API_KEY, photo_id=safestr(info['id'])))
+            photo = Photo.objects.create(
+                title = info['title'],
+                flickr_id = info['id'],
+                flickr_owner = info['owner'],
+                flickr_server = info['server'],
+                flickr_secret = info['secret'],
+                flickr_originalsecret = force_unicode(details[0].attrib['originalsecret']),
+                flickr_farm = info['farm'],
+                pub_date = flickr_datetime_to_datetime(info['datetaken']),
+                description = force_unicode(details[0].findtext('description')),
+                exif_aperture = exif['Aperture'],
+                exif_make = exif['Make'],
+                exif_model = exif['Model'],
+                exif_shutter = exif['Exposure'],
+                exif_iso = exif['ISO Speed'],
+                exif_lens = exif['Focal Length'],
+                exif_date = flickr_datetime_to_datetime(exif["Date and Time (Original)"].replace(':', '-', 2)),
+                gps = force_unicode(info['latitude'])+","+force_unicode(info['longitude']),
+                place = place,
+                tags = ", ".join(t for t in taglist)
+            )
+            photo.save()
+            make_local_size(photo)
+
+def exif_handler(data):
+    converted = {}
+    try:
+        for t in data.findall('photo/exif'):
+            e = dict((k, smart_unicode(t.get(k))) for k in t.keys())
+            if safestr(e['label']) == "Aperture":
+                if not converted.has_key("Aperture"):
+                    converted["Aperture"] = safestr(t.findtext('clean'))
+            else: 
+                converted[safestr(e['label'])] = safestr(t.findtext('raw'))
+    except:
+        pass
+    for k,v in EXIF_PARAMS.items():   
+        if not converted.has_key(k):
+            converted[k] = v
+    return converted
+
+    
+def flickr_datetime_to_datetime(fdt):
+    from datetime import datetime
+    from time import strptime
+    date_parts = strptime(fdt, '%Y-%m-%d %H:%M:%S')
+    return datetime(*date_parts[0:6])
+
+def place_handler(gps):
+    place = Place.objects.all()
+    count = Place.objects.count()
+    num = 1
+    for p in place:
+        if p.within_bounds(gps) is True:
+            return p
+        elif p.within_bounds(gps) is False and count == num:
+            return Place.objects.filter(name='Default').get()
+        num += 1
+
+ImageFile.MAXBLOCK = 1000000
+
+def make_local_size(photo,set):
+    crop_dir = settings.IMAGES_ROOT + '/gallery_thumbs/'
+    if not os.path.isdir(crop_dir):
+        os.makedirs(crop_dir)
+    remote = photo.get_original_url()
+    print remote
+    fname = urllib.urlopen(remote)
+    im = cStringIO.StringIO(fname.read()) # constructs a StringIO holding the image
+    img = Image.open(im)
+
+    #calculate crop:
+    cur_width, cur_height = img.size
+    new_width, new_height = 210, 210
+    ratio = max(float(new_width)/cur_width,float(new_height)/cur_height)
+    x = (cur_width * ratio)
+    y = (cur_height * ratio)
+    xd = abs(new_width - x)
+    yd = abs(new_height - y)
+    x_diff = int(xd / 2)
+    y_diff = int(yd / 2)
+    box = (int(x_diff), int(y_diff), int(x_diff+new_width), int(y_diff+new_height))
+   
+    #create resized file
+    resized = img.resize((int(x), int(y)), Image.ANTIALIAS).crop(box)
+    # save resized file
+    resized_filename = '%s/%s.jpg' %(crop_dir, set.id)
+    try:
+        if img.format == 'JPEG':
+            resized.save(resized_filename, 'JPEG', quality=95, optimize=True)
+        else:
+            resized.save(resized_filename)
+    except IOError, e:
+        if os.path.isfile(resized_filename):
+            os.unlink(resized_filename)
+        raise e
+    #os.unlink(img)
+                
+    
+               
+def sync_sets(*args, **kwargs): 
+    dupe = False            # Set our dupe flag for the following loop
+    BASE_PATH = 'http://flickr.com/services/rest/'
+    client = FlickrClient(BASE_PATH, API_KEY)
+    data = client.flickr_photosets_getList(user_id=settings.FLICKR_USER_ID)
+    nodes = data.findall('photosets/photoset')
+    for post in nodes:
+        info = dict((k, smart_unicode(post.get(k))) for k in post.keys())
+        try:
+            row = PhotoGallery.objects.get(set_id__exact=info['id'])
+            # okay it already exists, but is it up-to-date?
+            #get_photos_in_set(row,set.id)
+                
+        except ObjectDoesNotExist:            
+            s = PhotoGallery.objects.create (
+                set_id = force_unicode(info['id']),
+                set_title = force_unicode(post.findtext('title')),
+                set_desc = force_unicode(post.findtext('description')),
+                set_slug = slugify(force_unicode(post.findtext('title'))),
+                primary = force_unicode(info['primary']),
+            )
+            
+            get_photos_in_set(s)
+        
+def get_photos_in_set(set):
+    BASE_PATH = 'http://flickr.com/services/rest/'
+    client = FlickrClient(BASE_PATH, API_KEY)
+    data = client.flickr_photosets_getPhotos(user_id=settings.FLICKR_USER_ID, photoset_id=str(set.set_id))
+    for post in data.findall('photoset/photo'):
+        info = dict((k, smart_unicode(post.get(k))) for k in post.keys())
+        photo = Photo.objects.get(flickr_id__exact=str(info['id']))
+        set.photos.add(photo)
+    
+    
+"""            
+def sync_flickr_comments(*args, **kwargs):
+    cur_page = 1           # Start on the first page of the stream
+    paginate_by = 100      # Get 100 photos at a time
+    inc = 1                # Set our dupe flag for the following loop
+    # Get our flickr client running
+    client = FlickrClient(settings.FLICKR_API_KEY) 
+    # get total number of photos in stream
+    total = client.flickr_people_getInfo(user_id=settings.FLICKR_USER_ID)
+    total_num = safestr(total.person.photos.count)
+    while (inc < int(total_num)):
+        photos = client.flickr_people_getPublicPhotos(user_id=settings.FLICKR_USER_ID, page=cur_page, per_page=paginate_by,extras="date_upload,date_taken,geo")
+        incr = 1
+        for photo in photos.photos:
+            do_photo_comments(photo("id"),photo("secret"))
+            inc = inc+1
+            incr = incr+1
+            print cur_page
+            if incr == 100:
+                cur_page = cur_page+1 
+            
+
+
+def do_photo_comments(id, secret):
+    # Get our flickr client running
+    client = FlickrClient(settings.FLICKR_API_KEY)  
+    photo = Photo.objects.get(flickr_id=id, flickr_secret=secret)
+    comments = client.flickr_photos_comments_getList(user_id=settings.FLICKR_USER_ID, photo_id=id)
+    for item in comments.comments:
+        try:
+            item
+            print item('authorname')
+            dt = datetime.datetime.fromtimestamp(float(item('datecreate')))
+            ctype = ContentType.objects.get_for_model(Photo)
+            try:
+                f = FreeComment.objects.get(content_type=ctype, object_id=photo.id, submit_date=dt)
+                #print f.id
+            except ObjectDoesNotExist:
+                if safestr(item('authorname')) == 'luxagraf':
+                    mail = 'hyper@luxagraf.net'
+                else:
+                    mail = slugify(item('authorname'))+'@flickr.com'
+                c = FreeComment.objects.create (
+                    content_type = ctype,
+                    object_id = photo.id,
+                    comment = safestr(item),
+                    person_name = safestr(item('authorname')),
+                    person_email = mail,
+                    person_url = item('permalink'),
+                    is_public = True,
+                    site_id = 1,
+                    approved = 0,
+                    submit_date = dt
+                )
+
+        except AttributeError:
+            pass        
+            
+    def get_country_name(lat,long):
+        name = GeoClient.findCountrySubdivision(lat,long, http_proxy=None)
+        if name.countrySubdivision.countryCode.PCDATA == "US":
+            r_name = "US-%s" %(force_unicode(STATE_LIST[name.countrySubdivision.adminCode1.PCDATA]))
+        else:
+            r_name = force_unicode(name.countrySubdivision.countryName.PCDATA)
+        return r_name
+                
+        
+def create_size(self, photosize):
+    if self.size_exists(photosize):
+        return
+    if not os.path.isdir(self.cache_path()):
+        os.makedirs(self.cache_path())
+    try:
+        im = Image.open(self.get_image_filename())
+    except IOError:
+        return
+    if im.size == photosize.size():
+        shutil.copy(self.get_image_filename(),
+                    self._get_SIZE_path(photosize))
+        return
+    cur_width, cur_height = im.size
+    new_width, new_height = photosize.size()
+    if photosize.crop:
+        ratio = max(float(new_width)/cur_width,float(new_height)/cur_height)
+        x = (cur_width * ratio)
+        y = (cur_height * ratio)
+        xd = abs(new_width - x)
+        yd = abs(new_height - y)
+        x_diff = int(xd / 2)
+        y_diff = int(yd / 2)
+        if self.crop_from == 'top':
+                box = (int(x_diff), 0, int(x_diff+new_width), new_height)
+        elif self.crop_from == 'left':
+                box = (0, int(y_diff), new_width, int(y_diff+new_height))
+        elif self.crop_from == 'bottom':
+                box = (int(x_diff), int(yd), int(x_diff+new_width), int(y)) # y - yd = new_height
+        elif self.crop_from == 'right':
+                box = (int(xd), int(y_diff), int(x), int(y_diff+new_height)) # x - xd = new_width
+        else:
+                box = (int(x_diff), int(y_diff), int(x_diff+new_width), int(y_diff+new_height))
+        resized = im.resize((int(x), int(y)), Image.ANTIALIAS).crop(box)
+    else:
+        if not new_width == 0 and not new_height == 0:
+            if cur_width > cur_height:
+                ratio = float(new_width)/cur_width
+            else:
+                ratio = float(new_height)/cur_height
+        else:
+            if new_width == 0:
+                ratio = float(new_height)/cur_height
+            else:
+                ratio = float(new_width)/cur_width
+        resized = im.resize((int(cur_width*ratio), int(cur_height*ratio)), Image.ANTIALIAS)
+        
+    # Apply effect if found
+    if self.effect is not None:
+        resized = self.effect.process(resized)
+    elif photosize.effect is not None:
+        resized = photosize.effect.process(resized) 
+        
+    # save resized file
+    resized_filename = getattr(self, "get_%s_path" % photosize.name)()
+    try:
+        if im.format == 'JPEG':
+            resized.save(resized_filename, 'JPEG', quality=int(photosize.quality),
+                         optimize=True)
+        else:
+            resized.save(resized_filename)
+    except IOError, e:
+        if os.path.isfile(resized_filename):
+            os.unlink(resized_filename)
+        raise e
+
+""" 
+
+
+
+"""
+for p in photos.photos.photo:
+    try:
+        row = Photo.objects.get(flickr_id=p.id, flickr_secret=p.secret)
+        # If the row exists already, set the dupe flag
+        dupe = True
+        #print 'already have '+p.id+' moving on'
+    except ObjectDoesNotExist:
+        #assign the photo to a place, uses "default" if the photo isn't near anything
+        place = place_handler(force_unicode(p.latitude)+","+force_unicode(p.longitude))
+        #Grab tags 
+        tags = client.flickr_photos_getInfo(user_id=settings.FLICKR_USER_ID, photo_id=force_unicode(p.id))
+        # grab exif data
+        exif = exif_handler(client.flickr_photos_getExif(user_id=API_KEY, photo_id=safestr(p.id)))
+        # sort the exif data if it's available
+        if exif.has_key("Aperture"): 
+            aperture = exif["Aperture"]
+        else: aperture = ''
+        if exif.has_key("Make"): 
+            make = exif["Make"]
+        else: make = ''
+        if exif.has_key("Model"): 
+            model = exif["Model"]
+        else: model = ''
+        if exif.has_key("Exposure"): 
+            exposure = exif["Exposure"]
+        else: exposure = ''
+        if exif.has_key("ISO Speed"): 
+            iso = exif["ISO Speed"]
+        else: iso = ''
+        if exif.has_key("Focal Length"): 
+            length = exif["Focal Length"]
+        else: length = ''
+        if exif.has_key("Date and Time (Original)"): 
+            dto = flickr_datetime_to_datetime(exif["Date and Time (Original)"].replace(':', '-', 2))
+        else: dto = flickr_datetime_to_datetime(p.datetaken)
+        photo = Photo.objects.create(
+            title = p.title,
+            flickr_id = p.id,
+            flickr_owner = p.owner,
+            flickr_server = p.server,
+            flickr_secret = p.secret,
+            flickr_originalsecret = tags.photo.originalsecret,
+            flickr_farm = p.farm,
+            pub_date = flickr_datetime_to_datetime(p.datetaken),
+            description = force_unicode(tags.photo.description.PCDATA),
+            exif_aperture = aperture,
+            exif_make = make,
+            exif_model = model,
+            exif_shutter = exposure,
+            exif_iso = iso,
+            exif_lens = length,
+            exif_date = dto,
+            gps = force_unicode(p.latitude)+","+force_unicode(p.longitude),
+            place = place,
+            tags = str(", ".join(t.raw for t in tags.photo.tags.tag)).lower()
+        )
+        make_local_size(photo)
+    #if (dupe):
+        #break
+            
+"""
+
+from locations.models import Location
+from photos.models import Photo
+from django.contrib.gis.geos import Point
+
+def find_loc(photos):
+    for photo in photos:
+        p = Point(photo.lon, photo.lat, srid=4326)
+        try:
+            loc = Location.objects.filter(geometry__contains=p).get()
+            photo.location = loc
+            print photo.id
+            photo.save()
+        except Location.DoesNotExist:
+            print "photo %s does not fall within any exisiting location" %(photo.id)
\ No newline at end of file
diff --git a/apps/photos/views.py b/apps/photos/views.py
new file mode 100644
index 0000000..23efbde
--- /dev/null
+++ b/apps/photos/views.py
@@ -0,0 +1,49 @@
+from django.shortcuts import render_to_response,get_object_or_404
+from django.template import RequestContext
+from django.views.generic.list_detail import object_list
+from django.http import Http404
+
+from tagging.models import Tag,TaggedItem
+from photos.models import Photo,PhotoGallery
+from locations.models import Country, Region
+
+def potd_list(request):
+    potd_obj = Tag.objects.filter(name__exact='potd')
+    qs = TaggedItem.objects.get_by_model(Photo, potd_obj)
+    return render_to_response('photos/photo-of-the-day.html', {'object_list': qs,})
+    
+    
+    
+def gallery_list(request,page):
+    request.page_url = '/photos/%d/'
+    request.page = int(page)
+    qs = PhotoGallery.objects.all().order_by('-id')
+    context = {
+        'country_list': Country.objects.filter(visited=True),
+        'region_list': Region.objects.all()
+    }
+    return object_list(request, queryset=qs, template_name='archives/photos.html',
+                       extra_context=context)
+
+    
+"""
+Grabs entries by region or country
+"""
+def gallery_list_by_area(request,slug,page):
+    request.page_url = '/photos/'+slug+'/%d/'
+    request.page = int(page)
+    try:
+        region = Region.objects.get(slug__exact=slug)
+        qs = PhotoGallery.objects.filter(region = region).order_by('-id')
+    except:
+        region = Country.objects.get(slug__exact=slug)
+        qs = PhotoGallery.objects.filter(location__state__country = region).order_by('-id')
+        if not region:
+            raise Http404
+    context = {
+        'region': region,
+        'country_list': Country.objects.filter(visited=True),
+        'region_list': Region.objects.all()
+    }
+    return object_list(request, queryset=qs, template_name='archives/photos.html',
+                       extra_context=context)