class Event(ModelBase, interfaces.Locatable, interfaces.Authorable,
interfaces.Taggable, interfaces.Titled):
class Meta:
verbose_name = _('event')
def __unicode__(self):
return u'%s (%s)' % (self.title, self.start_date)
@models.permalink
def get_api_uri(self):
return ('event_api_single', [str(self.id)])
objects = GeoManager()
def api_serialize(self, request):
d = {}
d['start_date'] = datetostr(self.start_date)
d['end_date'] = datetostr(self.end_date)
return d
def geojson_properties(self, request):
d = {}
d['id'] = self.id
d['title'] = self.title
d['start_date'] = datetostr(self.start_date)
d['end_date'] = datetostr(self.end_date)
return d
start_date = models.DateTimeField('start_date')
end_date = models.DateTimeField('end_date')
class MapPlace(ModelBase, Locatable, Titled):
class Meta:
abstract = True
verbose_name = _('map place')
verbose_name_plural = _('map places')
def __unicode__(self):
return u'%s' % self.title
def _api_serialize(self, request=None):
d = Locatable._api_serialize(self, request)
d.update(Titled._api_serialize(self, request))
if self.zoom_level:
d['zoom_level'] = self.zoom_level
return d
objects = GeoManager()
default = models.BooleanField(default=False)
zoom_level = models.PositiveIntegerField(null=True, blank=True)
def _pre_save(self):
if self.default:
cur_defs = get_model('mapplace').objects.filter(default=True)
for c in cur_defs:
c.default = False
c.save()
else:
cur_defs = get_model('mapplace').objects.filter(default=True)
if len(cur_defs) == 0:
self.default = True
class Media(modelbases.LocastContent, interfaces.Authorable,
interfaces.Locatable):
@models.permalink
def get_api_uri(self):
return ('cast_media_api_single', [str(self.cast.id), str(self.id)])
def api_serialize(self, request):
d = {}
d['language'] = self.language
if self.caption:
d['caption'] = self.caption
if self.capture_time:
d['capture_time'] = datetostr(self.capture_time)
if self.cast:
d['cast'] = self.cast.get_api_uri()
return d
objects = GeoManager()
# Caption length borrowed from pinterest.
caption = models.CharField(max_length=500, null=True, blank=True)
language = models.CharField(max_length=90,
choices=settings.LANGUAGES,
default='en')
cast = models.ForeignKey(Cast, null=True, blank=True)
capture_time = models.DateTimeField('date and time captured',
null=True,
blank=True)
class ApiarySiteOnApproval(models.Model):
apiary_site = models.ForeignKey('ApiarySite', )
approval = models.ForeignKey('Approval', )
available = models.BooleanField(default=False)
site_status = models.CharField(default=SITE_STATUS_CURRENT,
max_length=20,
db_index=True)
# site_available = models.BooleanField(default=False)
created_at = models.DateTimeField(auto_now_add=True)
modified_at = models.DateTimeField(auto_now=True)
wkb_geometry = PointField(srid=4326, blank=True,
null=True) # store approved coordinates
site_category = models.ForeignKey(
'SiteCategory',
null=True,
blank=True,
)
objects = GeoManager()
def __str__(self):
return 'id:{}: (apiary_site: {}, approval: {})'.format(
self.id, self.apiary_site.id, self.approval.id)
class Meta:
app_label = 'disturbance'
unique_together = [
'apiary_site',
'approval',
]
class Itinerary(ModelBase, interfaces.Authorable, interfaces.Titled,
interfaces.Taggable, interfaces.Favoritable):
@models.permalink
def get_api_uri(self):
return ('itinerary_api_single', [str(self.id)])
class Meta:
verbose_name = _('itinerary')
verbose_name_plural = _('itineraries')
def __unicode__(self):
return u'(id: %s) %s' % (str(self.id), self.title)
def api_serialize(self, request):
d = {}
if self.path:
d['path'] = self.path.coords
d['casts'] = reverse('itinerary_cast_api', kwargs={'itin_id': self.id})
d['casts_ids'] = []
for c in self.related_casts.all():
d['casts_ids'].append(c.id)
d['casts_count'] = self.related_casts.count()
if self.preview_image:
d['preview_image'] = self.preview_image.url
d['thumbnail'] = self.thumbnail.url
return d
def geojson_properties(self, request):
d = {}
d['id'] = self.id
d['title'] = self.title
d['casts_count'] = self.related_casts.count()
d['favorites'] = self.favorited_by.count()
if self.preview_image:
d['preview_image'] = self.preview_image.url
d['thumbnail'] = self.thumbnail.url
return d
objects = GeoManager()
related_casts = models.ManyToManyField('Cast', null=True, blank=True)
path = gismodels.LineStringField(null=True, blank=True, srid=4326)
preview_image = models.ImageField(upload_to='content_images',
null=True,
blank=True)
@property
def thumbnail(self):
try:
return get_thumbnail(self.preview_image, '600', quality=75)
except:
return get_thumbnail(settings.PLACEHOLDER_PATH, '600', quality=75)
class AreaModel(TimeStampedModel):
polygon = PolygonField()
objects = GeoManager()
class Meta(TimeStampedModel.Meta):
abstract = True
def get_center(self):
return self.polygon.centroid
def center(): #@NoSelf
doc = """The center latitude and longitude of the area. This is only accurate for very small geographic areas.""" #@UnusedVariable
def fget(self):
return self.get_center()
return locals()
center = property(**center())
class Media(modelbases.LocastContent, interfaces.Authorable, interfaces.Titled,
interfaces.Locatable):
@models.permalink
def get_api_uri(self):
return ('cast_media_api_single', [str(self.cast.id), str(self.id)])
def api_serialize(self, request):
d = {}
d['language'] = self.language
if self.cast:
d['cast'] = self.cast.get_api_uri()
return d
objects = GeoManager()
language = models.CharField(max_length=90,
choices=settings.LANGUAGES,
default='en')
cast = models.ForeignKey(Cast, null=True, blank=True)
class LocativeModel(TimeStampedModel):
point = PointField()
altitude = models.FloatField(blank=True, null=True)
accuracy = models.FloatField(blank=True, null=True)
altitude_accuracy = models.FloatField(blank=True, null=True)
objects = GeoManager()
class Meta(TimeStampedModel.Meta):
abstract = True
def latlon(): #@NoSelf
doc = """Returns the latitude/longitude pair as a dict for the API, etc.""" #@UnusedVariable
def fget(self):
#return self.point.geojson
return {'lat': self.point.y, 'lon': self.point.x}
return locals()
latlon = property(**latlon())
class Cast(ModelBase, interfaces.PrivatelyAuthorable, interfaces.Titled,
interfaces.Commentable, interfaces.Favoritable,
interfaces.Flaggable, interfaces.Locatable, interfaces.Taggable):
@models.permalink
def get_api_uri(self):
return ('cast_api_single', [str(self.id)])
def get_absolute_url(self):
return reverse('frontpage') + '#!cast/' + str(self.id) + '/'
class Meta:
verbose_name = _('cast')
def __unicode__(self):
return u'%s (id: %s)' % (self.title, str(self.id))
objects = GeoManager()
def api_serialize(self, request):
d = {}
d['itineraries_ids'] = []
for i in self.itinerary_set.all():
d['itineraries_ids'].append(i.id)
d['media'] = reverse('cast_media_api', kwargs={'cast_id': self.id})
d['comments'] = reverse('cast_comments_api',
kwargs={'cast_id': self.id})
d['featured'] = self.is_featured
d['promotional'] = self.is_promotional
d['official'] = self.author.is_staff
if self.preview_image:
d['preview_image'] = self.preview_image
return d
def geojson_properties(self, request):
d = {}
d['id'] = self.id
d['title'] = self.title
d['author'] = {
'id': self.author.id,
'display_name': self.author.display_name
}
d['featured'] = self.is_featured
d['promotional'] = self.is_promotional
d['official'] = self.author.is_staff
if self.preview_image:
d['preview_image'] = self.preview_image
d['favorites'] = self.favorited_by.count()
return d
@property
def is_featured(self):
return (not self.get_tag_by_name('_featured') == None)
@property
def is_promotional(self):
return (not self.get_tag_by_name('_promotional') == None)
@property
def preview_image(self):
if len(self.imagemedia):
image = self.imagemedia[0].content
if image and image.file:
return image.thumbnail.url
elif len(self.videomedia):
vid = self.videomedia[0].content
if vid and vid.screenshot:
return vid.screenshot.url
elif len(self.linkedmedia):
vid = self.linkedmedia[0].content
if vid and vid.screenshot:
return vid.screenshot
return None
@property
def videomedia(self):
return self.media_set.filter(content_type_model='videomedia')
@property
def imagemedia(self):
return self.media_set.filter(content_type_model='imagemedia')
@property
def linkedmedia(self):
return self.media_set.filter(content_type_model='linkedmedia')
class Cast(ModelBase, interfaces.PrivatelyAuthorable, interfaces.Titled,
interfaces.Commentable, interfaces.Favoritable,
interfaces.Flaggable, interfaces.Locatable, interfaces.Taggable):
attempts = models.IntegerField(null=True, default=0)
cell_image = models.TextField(blank=True)
cell_timestamp = models.CharField(max_length=32, blank=True)
guid = models.CharField(max_length=64, blank=True)
cell_revision = models.CharField(max_length=64, blank=True)
post_to_twitter = models.BooleanField(default=False)
post_to_facebook = models.BooleanField(default=False)
@models.permalink
def get_api_uri(self):
return ('cast_api_single', [str(self.id)])
def get_absolute_url(self):
return reverse('frontpage') + '#!cast/' + str(self.id) + '/'
def absolute_url_with_host(self):
return settings.FULL_BASE_URL + self.get_absolute_url()
class Meta:
verbose_name = _('cast')
def __unicode__(self):
return u'%s (id: %s)' % (self.title, str(self.id))
objects = GeoManager()
def api_serialize(self, request):
d = {}
d['itineraries_ids'] = []
for i in self.itinerary_set.all():
d['itineraries_ids'].append(i.id)
d['media'] = reverse('cast_media_api', kwargs={'cast_id': self.id})
d['comments'] = reverse('cast_comments_api',
kwargs={'cast_id': self.id})
d['featured'] = self.is_featured
d['promotional'] = self.is_promotional
d['official'] = self.author.is_staff
if self.preview_image:
d['preview_image'] = self.preview_image
d['primary_image'] = self.prefetched_primary_image()
return d
def geojson_properties(self, request):
d = {}
d['id'] = self.id
d['title'] = self.title
d['author'] = {
'id': self.author.id,
'display_name': self.author.display_name
}
d['official'] = self.author.is_staff
d['urgency_level'] = self.urgency_level()
if self.prefetch_optimized_preview_image:
d['preview_image'] = self.prefetch_optimized_preview_image()
return d
def urgency_rank_serialize(self, request, rank=0):
d = {}
d['id'] = self.id
d['title'] = self.title
d['urgency_level'] = self.urgency_level()
d['thumbnail'] = self.prefetch_optimized_preview_image()
d['rank'] = rank
d['created'] = self.created.strftime("%b %d, %Y")
categories = self.itinerary_set.all()
if len(categories) > 0:
d['category'] = categories[0].title
else:
d['category'] = 'None'
d['tags'] = [tag.name for tag in self.tags.all()]
return d
def urgency_level(self):
urgency_score = sum([tag.urgency_score for tag in self.tags.all()])
return urgency_score / 50
@property
def is_featured(self):
return (not self.get_tag_by_name('_featured') == None)
@property
def is_promotional(self):
return (not self.get_tag_by_name('_promotional') == None)
# Use this methods instead of 'preview_image' when you know the related media has been
# prefetched
def prefetch_optimized_preview_image(self):
images = [
i for i in self.media_set.all()
if i.content_type_model == 'imagemedia'
]
videos = [
v for v in self.media_set.all()
if v.content_type_model == 'videomedia'
]
links = [
l for l in self.media_set.all()
if l.content_type_model == 'linkedmedia'
]
return self.preview_image_from_given_media(images, videos, links)
def prefetched_primary_image(self):
images = [
i for i in self.media_set.all()
if i.content_type_model == 'imagemedia'
]
for image_base in images:
image = image_base.content
if image and image.file and image.medium_file:
return image.medium_file.url
return None
def preview_image_from_given_media(self, images, videos, links):
for image_base in images:
image = image_base.content
if image and image.file:
return image.thumbnail.url
for video_base in videos:
vid = video_base.content
if vid and vid.screenshot:
return vid.screenshot.url
for link_base in links:
vid = link_base.content
if vid and vid.screenshot:
return vid.screenshot
return None
@property
def preview_image(self):
return self.preview_image_from_given_media(self.imagemedia,
self.videomedia,
self.linkedmedia)
@property
def videomedia(self):
return self.media_set.filter(content_type_model='videomedia')
@property
def imagemedia(self):
return self.media_set.filter(content_type_model='imagemedia')
@property
def linkedmedia(self):
return self.media_set.filter(content_type_model='linkedmedia')
@staticmethod
def urgency_rank():
return Cast.objects.prefetch_related('itinerary_set').select_related(
'author').prefetch_related('media_set').prefetch_related(
'tags').annotate(
urgency_score=Sum('tags__urgency_score')).filter(
urgency_score__gt=0).order_by('-urgency_score')[:10]
class AbstractOnspd(models.Model):
pcd = models.CharField(blank=True, max_length=7)
pcd2 = models.CharField(blank=True, max_length=8)
pcds = models.CharField(blank=True, max_length=8, primary_key=True)
dointr = models.CharField(blank=True, max_length=6)
doterm = models.CharField(blank=True, max_length=6)
oscty = models.CharField(blank=True, max_length=9)
ced = models.CharField(blank=True, max_length=9)
oslaua = models.CharField(blank=True, max_length=9)
osward = models.CharField(blank=True, max_length=9)
parish = models.CharField(blank=True, max_length=9)
usertype = models.CharField(blank=True, max_length=1)
oseast1m = models.CharField(blank=True, max_length=6)
osnrth1m = models.CharField(blank=True, max_length=7)
osgrdind = models.CharField(blank=True, max_length=1)
oshlthau = models.CharField(blank=True, max_length=9)
nhser = models.CharField(blank=True, max_length=9)
ctry = models.CharField(blank=True, max_length=9)
rgn = models.CharField(blank=True, max_length=9)
streg = models.CharField(blank=True, max_length=1)
pcon = models.CharField(blank=True, max_length=9)
eer = models.CharField(blank=True, max_length=9)
teclec = models.CharField(blank=True, max_length=9)
ttwa = models.CharField(blank=True, max_length=9)
pct = models.CharField(blank=True, max_length=9)
nuts = models.CharField(blank=True, max_length=10)
statsward = models.CharField(blank=True, max_length=6)
oa01 = models.CharField(blank=True, max_length=10)
casward = models.CharField(blank=True, max_length=6)
park = models.CharField(blank=True, max_length=9)
lsoa01 = models.CharField(blank=True, max_length=9)
msoa01 = models.CharField(blank=True, max_length=9)
ur01ind = models.CharField(blank=True, max_length=1)
oac01 = models.CharField(blank=True, max_length=3)
oa11 = models.CharField(blank=True, max_length=9)
lsoa11 = models.CharField(blank=True, max_length=9)
msoa11 = models.CharField(blank=True, max_length=9)
wz11 = models.CharField(blank=True, max_length=9)
ccg = models.CharField(blank=True, max_length=9)
bua11 = models.CharField(blank=True, max_length=9)
buasd11 = models.CharField(blank=True, max_length=9)
ru11ind = models.CharField(blank=True, max_length=2)
oac11 = models.CharField(blank=True, max_length=3)
lat = models.CharField(blank=True, max_length=10)
long = models.CharField(blank=True, max_length=10)
lep1 = models.CharField(blank=True, max_length=9)
lep2 = models.CharField(blank=True, max_length=9)
pfa = models.CharField(blank=True, max_length=9)
imd = models.CharField(blank=True, max_length=5)
calncv = models.CharField(blank=True, max_length=9)
stp = models.CharField(blank=True, max_length=9)
location = models.PointField(null=True, blank=True)
objects = GeoManager()
def _get_cty(self):
"""
Note: these are not _exactly_ the same because
'CTY' in ONSUD is:
E10000002 - E10000034 = England (county);
E11000001 - E11000007 = England (metropolitan county);
E13000001 - E13000002 = England (Inner/Outer London);
E99999999 (pseudo) = England (UA/MD/LB);
W99999999 (pseudo) = Wales;
S99999999 (pseudo) = Scotland
whereas 'OSCTY' in ONSPD is
E10000002 – E10000034 = England;
E99999999 (pseudo) = England (UA/MD/LB);
W99999999 (pseudo) = Wales;
S99999999 (pseudo) = Scotland;
"""
return self.oscty
def _get_lad(self):
return self.oslaua
def _get_ward(self):
return self.osward
def _get_hlthau(self):
return self.oshlthau
def _get_ruc11(self):
return self.ru11ind
cty = property(_get_cty)
lad = property(_get_lad)
ward = property(_get_ward)
hlthau = property(_get_hlthau)
ruc11 = property(_get_ruc11)
class Meta:
abstract = True
class Cast(ModelBase, interfaces.PrivatelyAuthorable, interfaces.Titled,
interfaces.Commentable, interfaces.Favoritable,
interfaces.Flaggable, interfaces.Locatable, interfaces.Taggable):
@models.permalink
def get_api_uri(self):
return ('cast_api_single', [str(self.id)])
def get_absolute_url(self):
return reverse('frontpage') + '#!cast/' + str(self.id) + '/'
class Meta:
verbose_name = _('cast')
def __unicode__(self):
return u'%s (id: %s)' % (self.title, str(self.id))
datetime = models.DateTimeField('Date and Time',
default=timezone.now,
null=True,
blank=True)
objects = GeoManager()
def api_serialize(self, request):
d = {}
d['collections'] = []
for i in self.collection_set.all():
d['collections'].append(i.get_api_uri())
if self.datetime:
d['datetime'] = datetostr(self.datetime)
d['media'] = reverse('cast_media_api', kwargs={'cast_id': self.id})
d['comments'] = reverse('cast_comments_api',
kwargs={'cast_id': self.id})
if self.preview_image:
d['preview_image'] = self.preview_image
return d
def geojson_properties(self, request):
d = {}
d['id'] = self.id
d['title'] = self.title
d['author'] = {
'id': self.author.id,
'display_name': self.author.display_name
}
if self.datetime:
d['datetime'] = datetostr(self.datetime)
if self.preview_image:
d['preview_image'] = self.preview_image
if self.thumbnail:
d['thumbnail'] = self.thumbnail.url
d['favorites'] = self.favorited_by.count()
return d
# Returns the url of the preview image
@property
def preview_image(self):
if len(self.imagemedia):
image = self.imagemedia[0].content
if image and image.file and image.medium_file:
return image.medium_file.url
elif len(self.videomedia):
vid = self.videomedia[0].content
if vid and vid.screenshot:
return vid.screenshot.url
elif len(self.linkedmedia):
vid = self.linkedmedia[0].content
if vid and vid.screenshot:
return vid.screenshot
return None
@property
def thumbnail(self):
if self.preview_image:
return l_get_thumbnail(self.preview_image, '150', quality=75)
return None
@property
def videomedia(self):
return self.media_set.filter(content_type_model='videomedia')
@property
def imagemedia(self):
return self.media_set.filter(content_type_model='imagemedia')
@property
def linkedmedia(self):
return self.media_set.filter(content_type_model='linkedmedia')
class Spotting(LocativeModel):
image = StdImageField(upload_to='img/spotter/spottings/', null=True, blank=True, size=(480, 640), thumbnail_size=(48,64))
inquiry = models.ForeignKey(Inquiry, null=True, blank=True, related_name="spottings")
author = models.ForeignKey(User, related_name="spotter_spottings")
taken_on = models.DateTimeField(null=True, blank=True)
is_snapshot = models.BooleanField(default=False,
verbose_name="Timeline snapshot?",
help_text="Should this observation image be associated with the its activity timeline?")
in_widget = models.BooleanField(default=True,
verbose_name="Include in widgets?",
help_text="Should this observation image be included in remote app widgets?")
caption = models.CharField(max_length=300,null=True,blank=True)
objects = GeoManager()
snapshots = SnapshotManager()
class Meta:
verbose_name = "Observation"
verbose_name_plural = "Observations"
ordering = ("-modified","-taken_on")
def image_url(): #@NoSelf
doc = """The url of the spotting's image""" #@UnusedVariable
def fget(self):
try:
return self.image.url
except ValueError:
return checkerboard.settings.MEDIA_URL + "img/spotter/missing_spotting.png"
return locals()
image_url = property(**image_url())
def date(): #@NoSelf
doc = """The date of the spotting""" #@UnusedVariable
def fget(self):
if self.taken_on is None:
return self.created
else:
return self.taken_on
return locals()
date = property(**date())
def answer_text(): #@NoSelf
doc = """Retrives a textual version of the answers for this spotting""" #@UnusedVariable
def fget(self):
answers = []
for answer in self.answers.all():
text = "Q: %s\n" % answer.question.body
try:
text += "A: %s\n" % getattr(answer,"textualanswer",None).body
except:
pass
try:
text += "A: %d\n" % getattr(answer,"numericanswer",None).value
except:
pass
try:
test = getattr(answer,"booleananswer",None).value
if test:
text += "A: true\n"
else:
text += "A: false\n"
except answer.DoesNotExist:
pass
if isinstance(answer,TextualAnswer.__class__):
text += "A: %s\n" % answer.body
elif isinstance(answer,NumericAnswer.__class__):
text += "A: %d\n" % answer.value
else:
try:
text += "A: %s\n" % answer.body
except:
pass
try:
text += "A: %d\n" % answer.value
except:
pass
answers.append(text)
return "\n".join(answers)
return locals()
answer_text = property(**answer_text())
def __unicode__(self):
return "%s by %s on %s" % (self.inquiry,self.author,self.created)
def save(self, *args, **kwargs):
super(Spotting,self).save(*args, **kwargs)
exists = Accomplishment.objects.filter(content_type__name="spotting",object_id=self.pk)
if len(exists) == 0:
Accomplishment.objects.create(content_object=self,user=self.author)
else:
exists[0].modified = datetime.datetime.now()
