summaryrefslogtreecommitdiff
path: root/apps
diff options
context:
space:
mode:
authorluxagraf@c63593aa-01b0-44d9-8516-4b9c7e931d7f <luxagraf@c63593aa-01b0-44d9-8516-4b9c7e931d7f>2009-01-05 04:07:10 +0000
committerluxagraf@c63593aa-01b0-44d9-8516-4b9c7e931d7f <luxagraf@c63593aa-01b0-44d9-8516-4b9c7e931d7f>2009-01-05 04:07:10 +0000
commit637d71d2c3a7c1c65a931e1eb094052a095cdf05 (patch)
treeca34a2fead939b133143ec7647a9437d52c89075 /apps
have at it
Diffstat (limited to 'apps')
-rw-r--r--apps/blog/__init__.py0
-rw-r--r--apps/blog/admin.py73
-rw-r--r--apps/blog/fields.py7
-rw-r--r--apps/blog/models.py101
-rw-r--r--apps/blog/urls.py15
-rw-r--r--apps/blog/views.py65
-rw-r--r--apps/blog/widgets.py32
-rw-r--r--apps/locations/__init__.py0
-rw-r--r--apps/locations/admin.py241
-rw-r--r--apps/locations/models.py170
-rw-r--r--apps/locations/urls.py6
-rw-r--r--apps/locations/views.py11
-rw-r--r--apps/photos/__init__.py0
-rw-r--r--apps/photos/admin.py66
-rw-r--r--apps/photos/detail_urls.py10
-rw-r--r--apps/photos/models.py154
-rw-r--r--apps/photos/urls.py12
-rw-r--r--apps/photos/utils.py411
-rw-r--r--apps/photos/views.py49
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)