class City(Location):
zoom_level = models.IntegerField(default=8)
country = models.ForeignKey(Country, on_delete=models.CASCADE)
class Place(MPTTModel, BaseModel, SchemalessFieldMixin, ImageMixin,
ReplacedByMixin):
objects = BaseTreeQuerySet.as_manager()
geo_objects = objects
publisher = models.ForeignKey('django_orghierarchy.Organization',
on_delete=models.CASCADE,
verbose_name=_('Publisher'),
db_index=True,
null=True)
info_url = models.URLField(verbose_name=_('Place home page'),
null=True,
blank=True,
max_length=1000)
description = models.TextField(verbose_name=_('Description'),
null=True,
blank=True)
parent = TreeForeignKey('self',
on_delete=models.CASCADE,
null=True,
blank=True,
related_name='children')
position = models.PointField(srid=settings.PROJECTION_SRID,
null=True,
blank=True)
email = models.EmailField(verbose_name=_('E-mail'), null=True, blank=True)
telephone = models.CharField(verbose_name=_('Telephone'),
max_length=128,
null=True,
blank=True)
contact_type = models.CharField(verbose_name=_('Contact type'),
max_length=255,
null=True,
blank=True)
street_address = models.CharField(verbose_name=_('Street address'),
max_length=255,
null=True,
blank=True)
address_locality = models.CharField(verbose_name=_('Address locality'),
max_length=255,
null=True,
blank=True)
address_region = models.CharField(verbose_name=_('Address region'),
max_length=255,
null=True,
blank=True)
postal_code = models.CharField(verbose_name=_('Postal code'),
max_length=128,
null=True,
blank=True)
post_office_box_num = models.CharField(verbose_name=_('PO BOX'),
max_length=128,
null=True,
blank=True)
address_country = models.CharField(verbose_name=_('Country'),
max_length=2,
null=True,
blank=True)
deleted = models.BooleanField(verbose_name=_('Deleted'), default=False)
replaced_by = models.ForeignKey('Place',
on_delete=models.SET_NULL,
related_name='aliases',
null=True,
blank=True)
divisions = models.ManyToManyField(AdministrativeDivision,
verbose_name=_('Divisions'),
related_name='places',
blank=True)
n_events = models.IntegerField(
verbose_name=_('event count'),
help_text=_('number of events in this location'),
default=0,
editable=False,
db_index=True)
n_events_changed = models.BooleanField(default=False, db_index=True)
class Meta:
verbose_name = _('place')
verbose_name_plural = _('places')
unique_together = (('data_source', 'origin_id'), )
def __unicode__(self):
values = filter(
lambda x: x,
[self.street_address, self.postal_code, self.address_locality])
return u', '.join(values)
@transaction.atomic
def save(self, *args, **kwargs):
if self._has_circular_replacement():
raise Exception(
"Trying to replace this place with a place that is replaced by this place"
"Please refrain from creating circular replacements and"
"remove one of the replacements."
"We don't want homeless events.")
if self.replaced_by and not self.deleted:
self.deleted = True
logger.warning(
"Place replaced without soft deleting. Soft deleting automatically",
extra={'place': self})
# needed to remap events to replaced location
old_replaced_by = None
if self.id:
try:
old_replaced_by = Place.objects.get(id=self.id).replaced_by
except Place.DoesNotExist:
pass
super().save(*args, **kwargs)
# needed to remap events to replaced location
if not old_replaced_by == self.replaced_by:
Event.objects.filter(location=self).update(
location=self.replaced_by)
# Update doesn't call save so we update event numbers manually.
# Not all of the below are necessarily present.
ids_to_update = [
event.id for event in (self, self.replaced_by, old_replaced_by)
if event
]
Place.objects.filter(id__in=ids_to_update).update(
n_events_changed=True)
if self.position:
self.divisions.set(
AdministrativeDivision.objects.filter(
type__type__in=('district', 'sub_district', 'neighborhood',
'muni'),
geometry__boundary__contains=self.position))
else:
self.divisions.clear()
class Individual(AbstractObservation):
HUNTING = 'HU'
FLOWER = 'FL'
OTHER = 'OT'
NEAR_WOOD = 'WO'
NEAR_WATER = 'WA'
FLYING = 'FG'
CAPTURED = 'CA'
DEAD = 'DE'
BEHAVIOUR_CHOICES = ((HUNTING, _('Hunting at beehive')),
(FLOWER, _('Drinking nectar on flower')),
(NEAR_WOOD,
_('Near wood source')), (NEAR_WATER,
_('Near water source')),
(FLYING, _('Flying')), (CAPTURED, _('Captured')),
(DEAD, _('Dead')), (OTHER, _('Other')))
# Fields
individual_count = models.IntegerField(verbose_name=_("Individual count"),
blank=True,
null=True)
behaviour = models.CharField(verbose_name=_("Behaviour"),
max_length=2,
choices=BEHAVIOUR_CHOICES,
blank=True,
null=True)
def get_absolute_url(self):
return reverse('vespawatch:individual-detail', kwargs={'pk': self.pk})
@property
def subject(self):
return 'individual'
def as_dict(self):
return {
'id':
self.pk,
'key':
f'individual-{self.pk}', # Handy when you need a unique key in a batch of Observations (nests and individuals)
'display_scientific_name':
self.display_scientific_name,
'display_vernacular_name':
self.display_vernacular_name,
'subject':
self.subject,
'latitude':
self.latitude,
'longitude':
self.longitude,
'inaturalist_id':
self.inaturalist_id,
'inaturalist_url':
self.inaturalist_obs_url,
'inat_vv_confirmed':
self.inat_vv_confirmed,
'observation_time':
self.observation_time.timestamp() * 1000,
'comments':
self.comments,
'images': [x.image.url for x in self.pictures.all()],
'thumbnails': [x.thumbnail.url for x in self.pictures.all()],
'detailsUrl':
reverse('vespawatch:individual-detail', kwargs={'pk': self.pk})
}
def __str__(self):
return f'Individual of {self.get_taxon_name()}, {self.formatted_observation_date}'
class MapDecisionfinal(models.Model):
fire = models.ForeignKey(Fires)
crowning_square = models.IntegerField()
ground_square = models.IntegerField()
unforest_square = models.IntegerField()
type_polygon = models.IntegerField()
wood_volume_per_ha = models.IntegerField()
pjc = models.IntegerField()
pr = models.IntegerField()
forestry_man_days = models.IntegerField()
emergency_man_days = models.IntegerField()
another_man_days = models.IntegerField()
forestry_fire_eng = models.IntegerField()
forestry_another = models.IntegerField()
emergency_fire_eng = models.IntegerField()
emergency_another = models.IntegerField()
another_fire_eng = models.IntegerField()
another_another = models.IntegerField()
total_fire_eng = models.IntegerField()
total_another = models.IntegerField()
sit_danger = models.IntegerField()
class Meta:
managed = False
db_table = 'map_decisionfinal'
class BillLine(models.Model):
bill = models.ForeignKey('Bill', on_delete=models.CASCADE)
product = models.ForeignKey('Product', on_delete=models.CASCADE)
quantity = models.IntegerField()
class Account(AbstractBaseUser):
# Fields
email = models.EmailField(verbose_name='email address',
max_length=100,
unique=False)
oauth_id = models.CharField(max_length=100, unique=True)
first_name = models.CharField(max_length=40, blank=True)
last_name = models.CharField(max_length=40, blank=True)
gender = models.CharField(max_length=2,
blank=True,
choices=choices.USER_GENDER)
dob = models.DateField(blank=True, null=True)
phone_no = models.CharField(max_length=15, blank=True)
tagline = models.TextField(max_length=200, blank=True)
looking_for = models.CharField(max_length=2,
choices=choices.USER_GENDER,
blank=True)
language = ArrayField(models.CharField(max_length=30, blank=True),
blank=True,
null=True)
relationship_status = models.CharField(max_length=2,
choices=choices.RELATIONSHIP_STATUS,
blank=True)
status = models.CharField(max_length=20,
blank=True,
choices=choices.STATUS)
tags = ArrayField(models.CharField(max_length=50, blank=True),
blank=True,
null=True) # Tags
# Profile Information
height = models.FloatField(blank=True, null=True)
salary = models.FloatField(blank=True, null=True)
country = models.CharField(max_length=30, blank=True)
hair_color = models.CharField(max_length=4,
choices=choices.HAIR_COLORS,
blank=True)
eye_color = models.CharField(max_length=4,
choices=choices.EYE_COLORS,
blank=True)
occupation = models.CharField(max_length=40, blank=True)
drink = models.NullBooleanField()
smoking = models.NullBooleanField()
weed = models.NullBooleanField()
aquarius = models.CharField(max_length=4,
blank=True,
choices=choices.AQUARIUS)
# profile_picture = models.ImageField(upload_to='profile_images', blank=True)
profile_picture = models.CharField(max_length=300, blank=True)
""""
wallpaper = models.ImageField(
upload_to='profile_wallpapers_images',
blank=True
) """
location = models.PointField(geography=True, null=True,
blank=True) # User's Current Location3
created_date = models.DateTimeField(auto_now_add=True)
modified_date = models.DateTimeField(auto_now=True)
likes = models.IntegerField(default=0)
skipped = models.IntegerField(default=0)
superlikes = models.IntegerField(default=0)
is_instagram_activated = models.BooleanField(default=False)
show_me_on_jar = models.BooleanField(default=True)
show_me_on_nearby = models.BooleanField(default=True)
is_active = models.BooleanField(default=True)
is_admin = models.BooleanField(default=False)
USERNAME_FIELD = 'oauth_id'
REQUIRED_FIELDS = []
# Manager
objects = AccountManager()
gis = models.GeoManager()
# Methods
def __str__(self):
return self.first_name + '(' + str(
self.pk) + ')' + ' : ' + self.oauth_id
def get_full_name(self):
return self.first_name + ' ' + self.last_name
def get_short_name(self):
return self.first_name
def has_perm(self, perm, obj=None):
return True
def has_module_perms(self, app_label):
return True
@property
def score(self):
total = self.likes + self.superlikes + self.skipped
if total <= 0:
return 0.5 * 10
else:
return round((float(self.likes + self.superlikes) / total) * 10, 2)
@property
def is_staff(self):
return self.is_admin
class SchemaBaseModel(models.Model):
random_field1 = models.CharField(max_length=32)
random_field2 = models.IntegerField()
class Meta:
abstract = True
class LegFile(TimestampedModelMixin, models.Model):
key = models.IntegerField(primary_key=True)
id = models.CharField(max_length=100, null=True)
contact = models.CharField(max_length=1000, default="No contact")
controlling_body = models.CharField(max_length=1000)
date_scraped = models.DateTimeField(auto_now_add=True,
null=True,
blank=True)
last_scraped = models.DateTimeField(auto_now=True)
final_date = models.DateField(null=True)
intro_date = models.DateField(default=datetime.datetime.now)
sponsors = models.ManyToManyField(CouncilMember,
related_name='legislation')
status = models.CharField(max_length=1000)
title = models.TextField()
type = models.CharField(max_length=1000)
url = models.URLField()
version = models.CharField(max_length=100)
is_routine = models.BooleanField(default=True, blank=True)
class Meta:
ordering = ['-key']
def __unicode__(self):
return "%s %s: %s%s" % (self.type, self.id, self.title[:100],
'...' if len(self.title) > 100 else '')
@models.permalink
def get_absolute_url(self):
return ('legislation_detail', [str(self.pk)])
@property
def last_action_date(self):
"""
Gets the date of the latest action
"""
actions = self.actions.all()
if len(actions) == 0:
return None
return max([action.date_taken for action in actions])
@property
def timeline(self):
"""
Gets a timeline object that represents the legfile actions grouped by
``date_taken``.
"""
from collections import defaultdict
class LegActionTimeline(defaultdict):
def __init__(self):
super(LegActionTimeline, self).__init__(list)
def __iter__(self):
return iter(sorted(self.keys()))
timeline = LegActionTimeline()
for action in self.actions.all().order_by('date_taken'):
print action.date_taken
timeline[action.date_taken].append(action)
return timeline
def all_text(self):
if not hasattr(self, '_all_text'):
att_text = [att.fulltext for att in self.attachments.all()]
self._all_text = ' '.join([self.title] + att_text)
return self._all_text
def unique_words(self):
"""
Gets all the white-space separated words in the file. A word is
anything that starts and ends with word characters and has no internal
white space.
"""
# Get rid of any punctuation on the outside of words.
only_words = re.sub(r'(\s\W+|\W+\s|\W+$)', ' ', self.title)
# Pick out and return the unique values by spliting on whitespace, and
# lowercasing everything.
unique_words = set(word.lower() for word in only_words.split())
return unique_words
def addresses(self):
addresses = ebdata.nlp.addresses.parse_addresses(self.all_text())
return addresses
def topics(self):
return settings.TOPIC_CLASSIFIER(self.title)
def get_status_label(self):
if self.status in [
'Adopted', 'Approved', 'Direct Introduction', 'Passed'
]:
return 'label-success'
elif self.status in ['Failed to Pass', 'Vetoed']:
return 'label-important'
else:
return 'label-inverse'
def mentioned_legfiles(self):
"""
Gets a generator for any files (specifically, bills) mentioned in the
file.
"""
# Find all the strings that match the characteristic regular expression
# for a bill id.
id_matches = re.findall(r'\s(\d{6}(-A+)?)', self.title)
# The id matches may each have two groups (the second of which will
# contain only the A's). We only care about the first.
mentioned_legfile_ids = set(groups[0] for groups in id_matches)
for mentioned_legfile_id in mentioned_legfile_ids:
# It's possible that no legfile in our database may match the id
# we've parsed out. When this is the case, there's nothing we can
# do about it, so just fail "silently" (with a log message).
try:
mentioned_legfile = LegFile.objects.get(
id=mentioned_legfile_id)
yield mentioned_legfile
except LegFile.DoesNotExist:
# TODO: Use a log message.
print 'LegFile %r, referenced from key %s, does not exist!!!' % (
mentioned_legfile_id, self.pk)
def update(self, attribs, commit=True, **save_kwargs):
for attr, val in attribs.items():
setattr(self, attr, val)
if commit:
return self.save(**save_kwargs)
def save(self,
update_words=True,
update_mentions=True,
update_locations=True,
update_topics=True,
*args,
**kwargs):
"""
Calls the default ``Models.save()`` method, and creates or updates
metadata for the legislative file as well.
"""
try:
# We don't want the legfile to be saved without its metadata, so
# wrap this whole thing in a transaction.
sid = transaction.savepoint()
super(LegFile, self).save(*args, **kwargs)
metadata = LegFileMetaData.objects.get_or_create(legfile=self)[0]
if update_words:
# Add the unique words to the metadata
metadata.words.clear()
unique_words = self.unique_words()
for word in unique_words:
md_word = MetaData_Word.objects.get_or_create(
value=word)[0]
metadata.words.add(md_word)
if update_locations:
# Add the unique locations to the metadata
metadata.locations.clear()
locations = self.addresses()
for location in locations:
try:
md_location = MetaData_Location.objects.get_or_create(
matched_text=location[0])[0]
except MetaData_Location.CouldNotBeGeocoded:
continue
metadata.locations.add(md_location)
if update_mentions:
# Add the mentioned files to the metadata
metadata.mentioned_legfiles.clear()
for mentioned_legfile in self.mentioned_legfiles():
metadata.mentioned_legfiles.add(mentioned_legfile)
if update_topics:
# Add topics to the metadata
metadata.topics.clear()
for topic in self.topics():
t = MetaData_Topic.objects.get_or_create(topic=topic)[0]
metadata.topics.add(t)
metadata.save()
transaction.savepoint_commit(sid)
except:
transaction.savepoint_rollback(sid)
raise
def get_data_source(self):
return PhillyLegistarSiteWrapper()
def refresh(self, stale_time=datetime.timedelta(days=1), force=False):
"""
Update the file if it has not been updated in a while. The "while" is
dictated the `stale_time` parameter, a `timedelta`. If `force` is True,
then the refresh will happen immediately, regardless of the time it was
last updated.
"""
pass
class LegKeys(models.Model):
continuation_key = models.IntegerField()
class WorldBorders(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 = models.IntegerField('Region Code')
subregion = models.IntegerField('Sub-Region Code')
lon = models.FloatField('Longitude', help_text="Longitude of centerpoint")
lat = models.FloatField('Latitude', help_text="Latitude of centerpoint")
# 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()
objects = MapnikManager()
# So the model is pluralized correctly in the admin.
class Meta:
verbose_name_plural = "World Borders"
# Returns the string representation of the model.
def __unicode__(self):
return unicode(self.name)
class TrafficLightPlan(UpdatePlanLocationMixin, SourceControlModel,
SoftDeleteModel, UserControlModel):
id = models.UUIDField(primary_key=True,
unique=True,
editable=False,
default=uuid.uuid4)
location = models.PointField(_("Location (3D)"), dim=3, srid=settings.SRID)
direction = models.IntegerField(_("Direction"), default=0)
type = EnumField(TrafficLightType, blank=True, null=True)
device_type = models.ForeignKey(
TrafficControlDeviceType,
verbose_name=_("Device type"),
on_delete=models.PROTECT,
limit_choices_to=Q(
Q(target_model=None)
| Q(target_model=DeviceTypeTargetModel.TRAFFIC_LIGHT)),
)
mount_plan = models.ForeignKey(
MountPlan,
verbose_name=_("Mount Plan"),
on_delete=models.PROTECT,
blank=True,
null=True,
)
mount_type = models.ForeignKey(
MountType,
verbose_name=_("Mount type"),
blank=True,
null=True,
on_delete=models.SET_NULL,
)
validity_period_start = models.DateField(_("Validity period start"),
blank=True,
null=True)
validity_period_end = models.DateField(_("Validity period end"),
blank=True,
null=True)
plan = models.ForeignKey(
Plan,
verbose_name=_("Plan"),
on_delete=models.PROTECT,
related_name="traffic_light_plans",
blank=True,
null=True,
)
location_specifier = EnumIntegerField(
LocationSpecifier,
verbose_name=_("Location specifier"),
default=LocationSpecifier.RIGHT,
blank=True,
null=True,
)
height = models.DecimalField(_("Height"),
max_digits=5,
decimal_places=2,
blank=True,
null=True)
vehicle_recognition = EnumIntegerField(
VehicleRecognition,
verbose_name=_("Vehicle recognition"),
blank=True,
null=True,
)
push_button = EnumIntegerField(
PushButton,
verbose_name=_("Push button"),
blank=True,
null=True,
)
sound_beacon = EnumIntegerField(
TrafficLightSoundBeaconValue,
verbose_name=_("Sound beacon"),
blank=True,
null=True,
)
txt = models.CharField(_("Txt"), max_length=254, blank=True, null=True)
lifecycle = EnumIntegerField(Lifecycle,
verbose_name=_("Lifecycle"),
default=Lifecycle.ACTIVE)
lane_number = EnumField(LaneNumber,
verbose_name=_("Lane number"),
default=LaneNumber.MAIN_1,
blank=True)
lane_type = EnumField(
LaneType,
verbose_name=_("Lane type"),
default=LaneType.MAIN,
blank=True,
)
road_name = models.CharField(_("Road name"),
max_length=254,
blank=True,
null=True)
owner = models.ForeignKey(
"traffic_control.Owner",
verbose_name=_("Owner"),
blank=False,
null=False,
on_delete=models.PROTECT,
)
objects = SoftDeleteQuerySet.as_manager()
class Meta:
db_table = "traffic_light_plan"
verbose_name = _("Traffic Light Plan")
verbose_name_plural = _("Traffic Light Plans")
unique_together = ["source_name", "source_id"]
def __str__(self):
return f"{self.id} {self.type} {self.device_type}"
def save(self, *args, **kwargs):
if not self.device_type.validate_relation(
DeviceTypeTargetModel.TRAFFIC_LIGHT):
raise ValidationError(
f'Device type "{self.device_type}" is not allowed for traffic lights'
)
super().save(*args, **kwargs)
class Species(UDFModel, PendingAuditable):
"""
http://plants.usda.gov/adv_search.html
"""
### Base required info
instance = models.ForeignKey(Instance)
# ``otm_code`` is the key used to link this instance
# species row to a cannonical species. An otm_code
# is usually the USDA code, but this is not guaranteed.
otm_code = models.CharField(max_length=255)
common_name = models.CharField(max_length=255)
genus = models.CharField(max_length=255)
species = models.CharField(max_length=255, blank=True)
cultivar = models.CharField(max_length=255, blank=True)
other_part_of_name = models.CharField(max_length=255, blank=True)
### From original OTM (some renamed) ###
is_native = models.NullBooleanField()
flowering_period = models.CharField(max_length=255, blank=True)
fruit_or_nut_period = models.CharField(max_length=255, blank=True)
fall_conspicuous = models.NullBooleanField()
flower_conspicuous = models.NullBooleanField()
palatable_human = models.NullBooleanField()
has_wildlife_value = models.NullBooleanField()
fact_sheet_url = models.URLField(max_length=255, blank=True)
plant_guide_url = models.URLField(max_length=255, blank=True)
### Used for validation
max_diameter = models.IntegerField(default=200)
max_height = models.IntegerField(default=800)
objects = GeoHStoreUDFManager()
@property
def display_name(self):
return "%s [%s]" % (self.common_name, self.scientific_name)
@classmethod
def get_scientific_name(clazz, genus, species, cultivar):
name = genus
if species:
name += " " + species
if cultivar:
name += " '%s'" % cultivar
return name
@property
def scientific_name(self):
return Species.get_scientific_name(self.genus, self.species,
self.cultivar)
def dict(self):
props = self.as_dict()
props['scientific_name'] = self.scientific_name
return props
def get_itree_code(self, region_code=None):
if not region_code:
region_codes = self.instance.itree_region_codes()
if len(region_codes) == 1:
region_code = region_codes[0]
else:
return None
override = ITreeCodeOverride.objects.filter(
instance_species=self,
region=ITreeRegion.objects.get(code=region_code),
)
if override.exists():
return override[0].itree_code
else:
return get_itree_code(region_code, self.otm_code)
def __unicode__(self):
return self.display_name
class Meta:
verbose_name_plural = "Species"
unique_together = (
'instance',
'common_name',
'genus',
'species',
'cultivar',
'other_part_of_name',
)
class State(models.Model):
state = USStateField()
fips = models.IntegerField(primary_key=True)
poly = models.MultiPolygonField(srid=4269)
objects = models.GeoManager()
class Bike(models.Model):
def _get_next_id():
prev = Bike.objects.aggregate(models.Max('id'))['id__max']
return prev + 1 if prev is not None else 1
id = models.IntegerField(
primary_key=True,
default=_get_next_id,
help_text='ID for the bike. This should match the QR code on the bike')
visible = models.BooleanField(
default=True,
help_text=
'Determines if this bike is rentable. Use this instead of deleting bikes'
)
location = models.PointField(help_text='Location of the bike')
current_rental = models.ForeignKey(
'Rental',
on_delete=models.SET_NULL,
blank=True,
default=None,
null=True,
help_text='The current rental for this bike',
related_name='current_rental')
previous_rental = models.ForeignKey(
'Rental',
on_delete=models.SET_NULL,
blank=True,
default=None,
null=True,
help_text='The previous rental for this bike',
related_name='previous_rental')
lock = models.OneToOneField(BikeLock,
on_delete=models.PROTECT,
blank=True,
default=None,
null=True,
help_text='Lock for the bike',
related_name='bike')
class Meta:
permissions = (
('rent_bike', 'Can rent a bike'),
('rent_hidden_bike', "Can rent a bike that's not visible"),
)
def is_rented(self):
return self.current_rental is not None
#enddef
is_rented.boolean = True
def __str__(self):
return str(self.id)
#enddef
@classmethod
def damaged_bikes(klass, query=None):
if query is None:
query = klass.objects.all()
damaged_bikes = DamageReport.objects.filter(
resolved_by=None, ).values_list('bike', flat=True)
return query.filter(id__in=damaged_bikes)
@classmethod
def rentable_bikes(klass, user, query=None):
if query is None:
query = klass.objects.all()
query = query.filter(current_rental=None)
if not user.has_perm('bikeshare.rent_hidden_bike'):
query = query.filter(visible=True)
damaged_bikes = DamageReport.objects.filter(resolved_by=None, ).filter(
Q(critical=True) | Q(acknowledged=True)).values_list('bike',
flat=True)
query = query.exclude(id__in=damaged_bikes)
return query
class SubclassOfAbstract(AbstractModel):
height = models.IntegerField()
class UserProfile(models.Model):
user = models.ForeignKey(User, unique=True, verbose_name=_('Username'))
# not going to use volunteer, comment at a good moment...
volunteer = models.BooleanField("Volunteer Opportunities",choices=BOOLEAN_CHOICES,default=False)
updates = models.BooleanField('I would like to receive occasional email updates and newsletters',choices=BOOLEAN_CHOICES,default=False)
zip_code = models.CharField(max_length=6,null=True,blank=True)
photo = models.ImageField(upload_to='photos',height_field=None, width_field=None, max_length=200,null=True,blank=True)
site_edits = models.IntegerField(_('Site Edits (to track activity)'),default=0,editable=False)
uid = models.IntegerField(_('Random User ID'),null=True,blank=True,editable=False)
active = models.BooleanField(choices=BOOLEAN_CHOICES,default=True)
def __unicode__(self):
name = self.user.get_full_name()
if name:
return unicode("%s" % self.user.get_full_name())
else:
return unicode("%s" % self.user.username)
class Meta:
verbose_name = _('Profile')
verbose_name_plural = _('Profiles')
def recently_edited_trees(self):
trees = Tree.history.filter(last_updated_by=self.user, present=True).exclude(_audit_change_type="U",_audit_diff="").order_by('-last_updated')[:7]
recent_edits = []
for t in trees:
recent_edits.append((t.species, t.date_planted, t.last_updated, t.id))
return sorted(recent_edits, key=itemgetter(2), reverse=True)[:7]
def recently_added_photos(self):
return TreePhoto.objects.filter(reported_by=self.user, tree__present=True).order_by('-reported_by')[:7]
def recently_changed_reputation(self):
return UserReputationAction.objects.filter(user=self.user).order_by('-date_created')[:7]
def recently_added_pends(self):
return TreePending.objects.filter(submitted_by=self.user).order_by('-submitted')[:7]
def recent_stewardship(self):
tree_s = TreeStewardship.objects.filter(performed_by=self.user)[:7]
plot_s = PlotStewardship.objects.filter(performed_by=self.user)[:7]
recent_activity = []
for t in tree_s:
recent_activity.append((t.tree.species, t.get_activity(), t.performed_date, t.tree.plot.id))
for p in plot_s:
recent_activity.append((p.plot.current_tree().species, p.get_activity(), p.performed_date, p.plot.id))
print recent_activity
return sorted(recent_activity, key=itemgetter(2), reverse=True)[:7]
def badges(self):
return BadgeToUser.objects.filter(user=self)
def badges_in_progress(self):
return_badges = []
for b in Badge.objects.all():
if b.meta_badge.get_progress(self.user) > b.meta_badge.progress_start:
if b.meta_badge.get_progress(self.user) < b.meta_badge.progress_finish:
return_badges.append((b, b.meta_badge.get_progress(self.user)))
return return_badges
def made_edit(self):
self.site_edits += 1
self.save()
def username(self):
return u"%s" % self.user.username
def first_name(self):
return u"%s" % self.user.first_name
def last_name(self):
return u"%s" % self.user.last_name
def full_name(self):
return u"%s %s" % (self.user.first_name, self.user.last_name)
def email(self):
return u"%s" % self.user.email
def remove(self):
return '<input type="button" value="Remove" onclick="location.href=\'%s/delete/\'" />' % (self.pk)
remove.short_description = ''
remove.allow_tags = True
def get_absolute_url(self):
return ('profiles_profile_detail', (), { 'username': self.user.username })
get_absolute_url = models.permalink(get_absolute_url)
def get_random_id(self):
return random.randint(100000,999999)
def account_activated(self):
return self.user.is_active
account_activated.boolean = True
def account_diff(self):
if self.user.is_active:
return (self.user.date_joined - datetime.datetime.now())
def save(self, force_insert=False, force_update=False, using='default'):
if not self.id:
self.uid = self.get_random_id()
super(UserProfile, self).save()
def make_django_model(meta_model, divider):
class Meta:
verbose_name = _(meta_model.get_verbose_name())
verbose_name_plural = _(meta_model.get_verbose_name_plural())
ordering = ('-modification_date', '-creation_date')
unique_together = tuple(
meta_model.get_property(
prop_name='m_unique_together', default_value=[]
)
)
modelisation_version = getattr(meta_model, 'version', None)
if (
modelisation_version is not None
and modelisation_version not in HANDELED_MODELISATION_VERSIONS
):
raise ValueError('Unknown modelisation format')
creation_level = get_minimum_level(
meta_model=meta_model,
prop_name='m_creation_minimum_level',
default_value='authenticated',
)
retrieve_level = get_minimum_level(
meta_model=meta_model,
prop_name='m_retrieve_minimum_level',
default_value='authenticated',
)
update_level = get_minimum_level(
meta_model=meta_model,
prop_name='m_update_minimum_level',
default_value='authenticated',
)
delete_level = get_minimum_level(
meta_model=meta_model,
prop_name='m_delete_minimum_level',
default_value='superuser',
)
attrs = {
'Meta': Meta,
'__module__': 'concrete_datastore.concrete.models',
'__str__': make_unicode_method(meta_model),
'__creation_minimum_level__': creation_level,
'__retrieve_minimum_level__': retrieve_level,
'__update_minimum_level__': update_level,
'__delete_minimum_level__': delete_level,
}
is_default_public = meta_model.get_property(
prop_name='m_is_default_public', default_value=False
)
if is_default_public is None or is_default_public not in (True, False):
is_default_public = False
attrs.update(get_common_fields(public_default_value=is_default_public))
ancestors = (models.Model,)
if meta_model.get_model_name() == 'User':
ancestors = (
AbstractUser,
HasPermissionAbstractUser,
ConfirmableUserAbstract,
)
attrs.update(
{
'username': None,
'objects': UserManager(),
'admin': models.BooleanField(default=False),
'password_modification_date': models.DateField(
default=date.today
),
'subscription_notification_token': models.UUIDField(
default=uuid.uuid4, editable=False
),
'login_counter': models.IntegerField(default=0),
'external_auth': models.BooleanField(default=False),
# True if user created by an external auth
'USERNAME_FIELD': 'email',
'REQUIRED_FIELDS': [],
}
)
else:
attrs.update(get_user_tracked_fields())
for field_name, field in meta_model.get_fields():
if field_name in attrs:
raise ValueError(
f'{field_name} is a protected field and cannot be overwritten'
)
# obsoletes fields
if meta_model.get_model_name() == 'User':
obsoletes_level = ('guest', 'manager', 'blocked')
if field_name in obsoletes_level:
raise ValueError(
f'The fields {obsoletes_level} are no longer supported'
)
args = field.f_args
if field.f_type == 'FileField':
args.update(
{'blank': True, 'null': True, 'validators': [validate_file]}
)
elif field.f_type == 'JSONField':
json_args = args
json_args['blank'] = True
json_args['encoder'] = None
json_args['null'] = False
json_args['default'] = dict
attrs.update({field_name: JSONField(**json_args)})
continue
elif field.f_type in ('CharField', 'TextField'):
args['null'] = False
args.setdefault('blank', True)
args.setdefault('default', "")
elif field.f_type in ('IntegerField', 'BigIntegerField'):
args['null'] = False
args.setdefault('blank', True)
args.setdefault('default', 0)
elif field.f_type == 'DecimalField':
args['null'] = False
args.setdefault('decimal_places', 2)
args.setdefault('max_digits', 20)
args.setdefault('default', 0.00)
elif field.f_type in ('ForeignKey',):
# Copy args to not alter the real field.f_args
args = args.copy()
# Force FK to null=True to avoid default value problems
args.update({'null': True})
# PROTECT foreign key deletion by default
on_delete_rule = args.get('on_delete', 'PROTECT')
if on_delete_rule not in ('CASCADE', 'SET_NULL', 'PROTECT'):
raise ValueError(
f'On delete rule "{on_delete_rule}" is invalid. '
'It must be "CASCADE", "SET_NULL" or "PROTECT"'
)
args.update({'on_delete': getattr(models, on_delete_rule)})
elif field.f_type in ('GenericIPAddressField',):
#: If blank is True, null should be too
#: https://docs.djangoproject.com/fr/3.1/ref/models/fields/#genericipaddressfield
if args.get('blank', False) is True:
args['null'] = True
else:
args.setdefault('blank', False)
args['null'] = False
elif field.f_type in ('DateTimeField',):
if args.get('null', False) is True:
args['null'] = True
args['blank'] = True
else:
args['default'] = timezone.now
args['null'] = False
args.setdefault('blank', False)
elif field.f_type in ('DateField',):
if args.get('null', False) is True:
args['null'] = True
args['blank'] = True
else:
args['default'] = date.today
args['null'] = False
args.setdefault('blank', False)
elif field.f_type == 'ManyToManyField':
# Copy args to not alter the real field.f_args
args = args.copy()
args.pop('null', None)
attrs.update({field_name: getattr(models, field.f_type)(**args)})
if meta_model.get_model_name() != divider:
if meta_model.get_model_name() == "User":
attrs.update(get_divider_fields_manytomany(divider))
attrs.update(get_divider_notification_fields(divider))
attrs.update(
{'email': models.EmailField(_('email address'), unique=True)}
)
elif meta_model.get_model_name() in UNDIVIDED_MODEL:
pass
else:
attrs.update(get_divider_fields_foreignkey(divider))
return type(meta_model.get_model_name(), ancestors, attrs)
class XForm(models.Model):
dynamic_choices = True
xls = models.FileField(upload_to=upload_to, null=True)
json = models.TextField(default=u'')
description = models.TextField(default=u'', null=True, blank=True)
xml = models.TextField()
user = models.ForeignKey(settings.AUTH_USER_MODEL,
related_name='xforms',
null=True,
on_delete=models.CASCADE)
id_string = models.SlugField(editable=False,
verbose_name="ID",
max_length=100)
title = models.CharField(editable=False, max_length=255)
date_created = models.DateTimeField(auto_now_add=True)
date_modified = models.DateTimeField(auto_now=True)
last_submission_time = models.DateTimeField(blank=True, null=True)
has_start_time = models.BooleanField(default=False)
uuid = models.CharField(max_length=36, default=u'')
uuid_regex = re.compile(r'(<instance>.*?id="[^"]+">)(.*</instance>)(.*)',
re.DOTALL)
instance_id_regex = re.compile(r'<instance>.*?id="([^"]+)".*</instance>',
re.DOTALL)
instances_with_geopoints = models.BooleanField(default=False)
num_of_submissions = models.IntegerField(default=0)
version = models.CharField(max_length=255, null=True, blank=True)
created_by = models.ForeignKey(settings.AUTH_USER_MODEL,
null=True,
blank=True,
on_delete=models.CASCADE)
metadata_set = GenericRelation('MetaData',
content_type_field='content_type_id',
object_id_field="object_id")
has_hxl_support = models.BooleanField(default=False)
last_updated_at = models.DateTimeField(auto_now=True)
hash = models.CharField("Hash",
max_length=36,
blank=True,
null=True,
default=None)
class Meta:
unique_together = (
"user",
"id_string",
)
verbose_name = "XForm"
verbose_name_plural = "XForms"
ordering = ("pk", )
def get_osm_survey_xpaths(self):
"""
Returns abbreviated_xpath for OSM question types in the survey.
"""
return [
elem.get_abbreviated_xpath()
for elem in self.get_survey_elements_of_type('osm')
]
def get_media_survey_xpaths(self):
return [
e.get_abbreviated_xpath() for e in sum([
self.get_survey_elements_of_type(m) for m in KNOWN_MEDIA_TYPES
], [])
]
def file_name(self):
return self.id_string + ".xml"
def get_survey_elements_of_type(self, element_type):
return [
e for e in self.get_survey_elements() if e.type == element_type
]
def _set_uuid_in_xml(self, file_name=None):
"""
Add bind to automatically set UUID node in XML.
"""
if not file_name:
file_name = self.file_name()
file_name, file_ext = os.path.splitext(file_name)
doc = clean_and_parse_xml(self.xml)
model_nodes = doc.getElementsByTagName("model")
if len(model_nodes) != 1:
raise Exception(u"xml contains multiple model nodes")
model_node = model_nodes[0]
instance_nodes = [
node for node in model_node.childNodes
if node.nodeType == Node.ELEMENT_NODE and node.tagName.lower() ==
"instance" and not node.hasAttribute("id")
]
if len(instance_nodes) != 1:
raise Exception("Multiple instance nodes without the id "
"attribute, can't tell which is the main one")
instance_node = instance_nodes[0]
# get the first child whose id attribute matches our id_string
survey_nodes = [
node for node in instance_node.childNodes
if node.nodeType == Node.ELEMENT_NODE and (
node.tagName == file_name or node.attributes.get('id'))
]
if len(survey_nodes) != 1:
raise Exception("Multiple survey nodes with the id '%s'" %
self.id_string)
survey_node = survey_nodes[0]
formhub_nodes = [
n for n in survey_node.childNodes
if n.nodeType == Node.ELEMENT_NODE and n.tagName == "formhub"
]
if len(formhub_nodes) > 1:
raise Exception("Multiple formhub nodes within main instance node")
elif len(formhub_nodes) == 1:
formhub_node = formhub_nodes[0]
else:
formhub_node = survey_node.insertBefore(
doc.createElement("formhub"), survey_node.firstChild)
uuid_nodes = [
node for node in formhub_node.childNodes
if node.nodeType == Node.ELEMENT_NODE and node.tagName == "uuid"
]
if len(uuid_nodes) == 0:
formhub_node.appendChild(doc.createElement("uuid"))
if len(formhub_nodes) == 0:
# append the calculate bind node
calculate_node = doc.createElement("bind")
calculate_node.setAttribute(
"nodeset", "/%s/formhub/uuid" % survey_node.tagName)
calculate_node.setAttribute("type", "string")
calculate_node.setAttribute("calculate", "'%s'" % self.uuid)
model_node.appendChild(calculate_node)
self.xml = doc.toprettyxml(indent=" ", encoding='utf-8')
# hack
# http://ronrothman.com/public/leftbraned/xml-dom-minidom-toprettyxml-\
# and-silly-whitespace/
text_re = re.compile('(>)\n\s*(\s[^<>\s].*?)\n\s*(\s</)', re.DOTALL)
output_re = re.compile('\n.*(<output.*>)\n( )*')
pretty_xml = text_re.sub(lambda m: ''.join(m.group(1, 2, 3)),
self.xml.decode('utf-8'))
inline_output = output_re.sub('\g<1>', pretty_xml)
inline_output = re.compile('<label>\s*\n*\s*\n*\s*</label>').sub(
'<label></label>', inline_output)
self.xml = inline_output
def _mark_start_time_boolean(self):
starttime_substring = 'jr:preloadParams="start"'
if self.xml.find(starttime_substring) != -1:
self.has_start_time = True
else:
self.has_start_time = False
def _id_string_already_exists_in_account(self, id_string):
try:
XForm.objects.get(id_string__iexact=id_string)
except XForm.DoesNotExist:
return False
return True
def get_unique_id_string(self, id_string, count=0):
# used to generate a new id_string for new data_dictionary object if
# id_string already existed
if self._id_string_already_exists_in_account(id_string):
if count != 0:
if re.match(r'\w+_\d+$', id_string):
a = id_string.split('_')
id_string = "_".join(a[:-1])
count += 1
id_string = "{}_{}".format(id_string, count)
return self.get_unique_id_string(id_string, count)
return id_string
def _set_title(self):
xml = re.sub(r"\s+", " ", self.xml)
matches = title_pattern.findall(xml)
if len(matches) != 1:
raise XLSFormError(("There should be a single title."), matches)
if matches:
title_xml = matches[0][:XFORM_TITLE_LENGTH]
else:
title_xml = self.title[:XFORM_TITLE_LENGTH] if self.title else ''
if self.title and title_xml != self.title:
title_xml = self.title[:XFORM_TITLE_LENGTH]
if isinstance(self.xml, bytes):
self.xml = self.xml.decode('utf-8')
self.xml = title_pattern.sub(u"<h:title>%s</h:title>" % title_xml,
self.xml)
self._set_hash()
if contains_xml_invalid_char(title_xml):
raise XLSFormError("Title shouldn't have any invalid xml "
"characters ('>' '&' '<')")
self.title = title_xml
def get_hash(self):
return u'md5:%s' % md5(self.xml.encode('utf8')).hexdigest()
def get_random_hash(self):
return u'md5:%s' % md5(("%s-%s" % (self.xml, random.randint(
0, 25101991))).encode('utf8')).hexdigest()
@property
def random_hash(self):
return self.get_random_hash()
def _set_hash(self):
self.hash = self.get_hash()
def _set_id_string(self):
matches = self.instance_id_regex.findall(self.xml)
if len(matches) != 1:
raise XLSFormError("There should be a single id string.")
self.id_string = matches[0]
def save(self, *args, **kwargs):
update_fields = kwargs.get('update_fields')
if update_fields:
kwargs['update_fields'] = list(
set(list(update_fields) + ['date_modified']))
if update_fields is None or 'title' in update_fields:
self._set_title()
if self.pk is None:
self._set_hash()
if update_fields is None or 'id_string' in update_fields:
old_id_string = self.id_string
self._set_id_string()
# check if we have an existing id_string,
# if so, the one must match but only if xform is NOT new
if self.pk and old_id_string and old_id_string != self.id_string \
and self.num_of_submissions > 0:
raise XLSFormError(
"Your updated form's id_string '%(new_id)s' must match "
"the existing forms' id_string '%(old_id)s'." % {
'new_id': self.id_string,
'old_id': old_id_string
})
if getattr(settings, 'STRICT', True) and \
not re.search(r"^[\w-]+$", self.id_string):
raise XLSFormError('In strict mode, the XForm ID must be a '
'valid slug and contain no spaces.')
if 'skip_xls_read' in kwargs:
del kwargs['skip_xls_read']
super(XForm, self).save(*args, **kwargs)
def get_survey(self):
if not hasattr(self, "_survey"):
try:
builder = SurveyElementBuilder()
self._survey = \
builder.create_survey_element_from_json(self.json)
except ValueError:
xml = bytes(bytearray(self.xml, encoding='utf-8'))
self._survey = create_survey_element_from_xml(xml)
return self._survey
survey = property(get_survey)
def get_survey_elements(self):
return self.survey.iter_descendants()
def geopoint_xpaths(self):
survey_elements = self.get_survey_elements()
return [
e.get_abbreviated_xpath() for e in survey_elements
if e.bind.get(u'type') == u'geopoint'
]
def __str__(self):
return self.id_string
class Fossil(projects.models.PaleoCoreGeomBaseClass):
# Foreign keys
context = models.ForeignKey(to='Context',
on_delete=models.CASCADE,
null=True,
blank=True)
# Fossil(Find)
guid = models.URLField(null=True, blank=True)
uuid = models.UUIDField(default=uuid.uuid4)
# catalog_number provides the full catalog number as formatted in the first publication, including suffixes
catalog_number = models.CharField(max_length=40, null=True, blank=True)
# other_catalog_number lists alternative typographic versions of the catalog number
# e.g. OH 7 | O.H. 7 | OH-7 etc,
other_catalog_numbers = models.CharField(max_length=255,
null=True,
blank=True)
date_discovered = models.DateField(null=True, blank=True)
# TODO change year_collected to year_discovered or just migrate to date_discovered
year_collected = models.IntegerField(
'Year',
blank=True,
null=True,
help_text=
'The year, event or field campaign during which the item was found.')
organism_id = models.CharField(max_length=40, null=True, blank=True)
nickname = models.CharField(max_length=40, null=True, blank=True)
is_type_specimen = models.BooleanField('Type Specimen', default=False)
type_status = models.CharField(max_length=255,
null=True,
blank=True,
choices=TYPE_CHOICES)
lifestage = models.CharField(max_length=20, null=True, blank=True)
sex = models.CharField(max_length=10, null=True, blank=True)
short_description = CKRichTextField(null=True, blank=True)
description = CKRichTextField(null=True, blank=True)
# Taxon
taxon = models.ForeignKey('Taxon',
null=True,
blank=True,
on_delete=models.SET_NULL)
ttaxon = models.ForeignKey('TTaxon',
null=True,
blank=True,
on_delete=models.SET_NULL)
# Project
project_name = models.CharField(max_length=100, null=True, blank=True)
project_abbreviation = models.CharField(max_length=10,
null=True,
blank=True)
collection_code = models.CharField(max_length=10, null=True, blank=True)
# NAAN is the name assigning authority number, often the shoulder of the guid
naan = models.CharField(max_length=10, null=True, blank=True)
# discovere_by refers to the person or agent that first located the fossil
discovered_by = models.CharField(max_length=255, null=True, blank=True)
# collected by refers to the person or agent that collected the fossil and is responsible for its sci. documtn.
collected_by = models.CharField(
max_length=255, null=True,
blank=True) # The person or agent that collected the
# Location
place_name = models.CharField(max_length=100, null=True, blank=True)
locality = models.CharField(max_length=40, null=True, blank=True)
site = models.ForeignKey('Site',
on_delete=models.SET_NULL,
null=True,
blank=True)
# country = models.CharField(max_length=10, null=True, blank=True)
country = CountryField('Country', blank=True, null=True)
continent = models.CharField(max_length=20,
null=True,
blank=True,
choices=CONTINENT_CHOICES)
geom = models.PointField(null=True, blank=True)
# Media
image = models.ImageField(max_length=255,
blank=True,
upload_to="uploads/images/origins",
null=True)
# Record
source = models.CharField(max_length=100, null=True, blank=True)
created_by = models.CharField(max_length=100, null=True, blank=True)
created = models.DateTimeField('Modified', auto_now_add=True)
modified = models.DateTimeField(
'Modified',
auto_now=True,
help_text='The date and time this resource was last altered.')
# Search and Filter Fields
origins = models.BooleanField(
default=False) # in scope for origins project
vif = models.BooleanField(default=False) # in scope for origins project
# Original Fields from Human Origins Program DB
verbatim_PlaceName = models.CharField(max_length=100,
null=True,
blank=True)
verbatim_HomininElement = models.CharField(max_length=40,
null=True,
blank=True)
verbatim_HomininElementNotes = models.TextField(null=True, blank=True)
verbatim_SkeletalElement = models.CharField(max_length=40,
null=True,
blank=True)
verbatim_SkeletalElementSubUnit = models.CharField(max_length=40,
null=True,
blank=True)
verbatim_SkeletalElementSubUnitDescriptor = models.CharField(
max_length=100, null=True, blank=True)
verbatim_SkeletalElementSide = models.CharField(max_length=40,
null=True,
blank=True)
verbatim_SkeletalElementPosition = models.CharField(max_length=40,
null=True,
blank=True)
verbatim_SkeletalElementComplete = models.CharField(max_length=40,
null=True,
blank=True)
verbatim_SkeletalElementClass = models.CharField(max_length=40,
null=True,
blank=True)
verbatim_Locality = models.CharField(max_length=40, null=True, blank=True)
verbatim_Country = models.CharField(max_length=20, null=True, blank=True)
verbatim_provenience = models.TextField(null=True, blank=True)
# References
references = models.ManyToManyField(publications.models.Publication,
blank=True)
# Helper field for managing Turkana imports
to_split = models.BooleanField(null=True)
def __str__(self):
return str(self.catalog_number)
def element_count(self):
return FossilElement.objects.filter(fossil=self.id).count()
def elements(self):
"""
function to get a queryset of all skeletal elements associated with a fossil
:return:
"""
return self.fossil_element.all()
def element_description(self):
"""
function to get a text description of all skeletal elements associated with a fossil
:return:
"""
return ', '.join([
"{} {}".format(e.skeletal_element_side, e.skeletal_element)
for e in self.elements()
])
def default_image(self):
"""
Function to fetch a default thumbnail image for a fossil
:return:
"""
images = self.photo_set.filter(default_image=True)
if images.count() >= 1:
return images[0].thumbnail()
else:
return None
def get_subtype(self):
"""
Determine if a Fossil instance has a subtype instance and if so what it is.
:return: Returns a list of the matching subtype class or classes. Should never be more than one.
"""
result = []
try:
TurkFossil.objects.get(pk=self.id)
result.append(TurkFossil)
except TurkFossil.DoesNotExist:
pass
return result
default_image.short_description = 'Fossil Thumbnail'
default_image.allow_tags = True
default_image.mark_safe = True
class DummyIntModel(models.Model):
int_field = models.IntegerField()
small_int_field = models.SmallIntegerField()
big_int_field = models.BigIntegerField()
class Flood(models.Model):
"""Flood model."""
class Meta:
"""Meta class."""
app_label = 'realtime'
event_id = models.CharField(
verbose_name='The id of the event',
help_text='The id of the event, which represents time and interval',
max_length=20,
unique=True,
blank=False)
data_source = models.CharField(
verbose_name='The source of hazard data',
help_text='The source of the hazard data used for analysis',
max_length=255,
blank=True,
null=True,
default=None)
time = models.DateTimeField(verbose_name='Date and Time',
help_text='The time the flood reported.',
blank=False)
interval = models.IntegerField(
verbose_name='Report interval',
help_text='The interval of aggregated report in hours',
default=0)
source = models.CharField(verbose_name='Flood Data Source',
help_text='The source of hazard data',
max_length=255)
region = models.CharField(verbose_name='The Region id for source',
help_text='The region of hazard data',
max_length=255)
hazard_layer = models.FileField(
blank=True,
verbose_name='Hazard Layer',
help_text='Zipped file of Hazard Layer related files',
upload_to='reports/flood/zip')
impact_layer = models.FileField(
blank=True,
verbose_name='Impact Layer',
help_text='Zipped file of Impact Layer related files',
upload_to='reports/flood/zip')
flooded_boundaries = models.ManyToManyField(
Boundary,
through='FloodEventBoundary',
verbose_name='Flooded Boundaries',
help_text='The linked boundaries flooded by this event')
total_affected = models.IntegerField(
verbose_name='Total affected people by flood',
help_text='Total affected people by flood',
default=0)
boundary_flooded = models.IntegerField(
verbose_name='Total boundary flooded',
help_text='Total boundary affected by flood',
default=0)
objects = models.GeoManager()
def delete(self, using=None):
# delete impact layer
self.hazard_layer.delete()
return super(Flood, self).delete(using=using)
def __unicode__(self):
return 'Flood event & interval: %s - %s' % (self.time, self.interval)
class DummyNullFieldsModel(models.Model):
null_foreign_key = models.ForeignKey("DummyBlankFieldsModel",
null=True,
on_delete=models.CASCADE)
null_integer_field = models.IntegerField(null=True)
class QuotationLine(models.Model):
quotation = models.ForeignKey('Quotation', on_delete=models.CASCADE)
product = models.ForeignKey('Product', on_delete=models.CASCADE)
quantity = models.IntegerField()
class DummyMultipleInheritanceModel(DummyDefaultFieldsModel, Person):
my_id = models.AutoField(primary_key=True)
my_dummy_field = models.IntegerField()
class Keyword(BaseModel, ImageMixin, ReplacedByMixin):
publisher = models.ForeignKey('django_orghierarchy.Organization',
on_delete=models.CASCADE,
verbose_name=_('Publisher'),
db_index=True,
null=True,
blank=True,
related_name='Published_keywords')
alt_labels = models.ManyToManyField(KeywordLabel,
blank=True,
related_name='keywords')
aggregate = models.BooleanField(default=False)
deprecated = models.BooleanField(default=False, db_index=True)
n_events = models.IntegerField(
verbose_name=_('event count'),
help_text=_('number of events with this keyword'),
default=0,
editable=False,
db_index=True)
n_events_changed = models.BooleanField(default=False, db_index=True)
replaced_by = models.ForeignKey('Keyword',
on_delete=models.SET_NULL,
related_name='aliases',
null=True,
blank=True)
schema_org_type = "Thing/LinkedEventKeyword"
def __str__(self):
return self.name
def deprecate(self):
self.deprecated = True
self.save(update_fields=['deprecated'])
return True
def replace(self, replaced_by):
self.replaced_by = replaced_by
self.save(update_fields=['replaced_by'])
return True
@transaction.atomic
def save(self, *args, **kwargs):
if self._has_circular_replacement():
raise Exception(
"Trying to replace this keyword with a keyword that is replaced by this keyword"
"Please refrain from creating circular replacements and"
"remove one of the replacements.")
if self.replaced_by and not self.deprecated:
self.deprecated = True
logger.warning(
"Keyword replaced without deprecating. Deprecating automatically",
extra={'keyword': self})
old_replaced_by = None
if self.id:
try:
old_replaced_by = Keyword.objects.get(id=self.id).replaced_by
except Keyword.DoesNotExist:
pass
super().save(*args, **kwargs)
if not old_replaced_by == self.replaced_by:
# Remap keyword sets
qs = KeywordSet.objects.filter(keywords__id__exact=self.id)
for kw_set in qs:
kw_set.keywords.remove(self)
kw_set.keywords.add(self.replaced_by)
kw_set.save()
# Remap events
qs = Event.objects.filter(keywords__id__exact=self.id) \
| Event.objects.filter(audience__id__exact=self.id)
for event in qs:
if self in event.keywords.all():
event.keywords.remove(self)
event.keywords.add(self.replaced_by)
if self in event.audience.all():
event.audience.remove(self)
event.audience.add(self.replaced_by)
class Meta:
verbose_name = _('keyword')
verbose_name_plural = _('keywords')
class NonAbstractPerson(Person):
dummy_count = models.IntegerField()
class RailPassengerStops(models.Model):
vehicle_id = models.IntegerField(blank=True, null=True)
service_date = models.DateField(blank=True, null=True)
service_key = models.TextField(blank=True, null=True)
arrive_time = models.DateTimeField(blank=True, null=True)
leave_time = models.DateTimeField(blank=True, null=True)
stop_time = models.DateTimeField(blank=True, null=True)
route_number = models.IntegerField(blank=True, null=True)
direction = models.IntegerField(blank=True, null=True)
location_id = models.IntegerField(blank=True, null=True)
dwell = models.IntegerField(blank=True, null=True)
door = models.IntegerField(blank=True, null=True)
lift = models.IntegerField(blank=True, null=True)
ons = models.IntegerField(blank=True, null=True)
offs = models.IntegerField(blank=True, null=True)
estimated_load = models.IntegerField(blank=True, null=True)
train_mileage = models.FloatField(blank=True, null=True)
geom_point_4326 = models.PointField(blank=True, null=True)
id = models.BigIntegerField(primary_key=True)
seconds_late = models.IntegerField(blank=True, null=True)
arriving_load = models.IntegerField(blank=True, null=True)
arrive_quarter_hour = models.FloatField(blank=True, null=True)
class Meta:
managed = False
db_table = "rail_passenger_stops"
unique_together = (("service_date", "id"), )
class DummyUniqueIntegerFieldModel(models.Model):
value = models.IntegerField(unique=True)
class Desaparecido(models.Model):
quien_registra = models.ForeignKey(User)
FECHA_ALTA = models.DateTimeField(auto_now_add=True)
FECHA_ACTUALIZACION = models.DateTimeField(auto_now=True)
fecha_desaparicion= models.DateTimeField()
nombre = models.CharField(max_length=50, blank=True)
primer_apellido = models.CharField(max_length=50, blank=True)
segundo_apellido = models.CharField(max_length=50, blank=True)
punto_desaparecido = models.PointField(default='POINT(0 0)', srid=4326)
@property
def longitude(self):
return self.punto_desaparecido[0]
@property
def latitude(self):
return self.punto_desaparecido[1]
num_de_identificacion= models.CharField(max_length=50, blank=True)
TIPO_DE_IDENTIFICACION_OPT= (
('I', 'IFE'),
('P', 'PASAPORTE'),
('L', 'LICENCIA DE MANEJO'),
('O', 'OTRO')
)
TIPO_DE_IDENTIFICACION=models.CharField(max_length=2, choices= TIPO_DE_IDENTIFICACION_OPT,
blank=True)
SEXO_OPT= (
('M', 'Masculino'),
('F', 'Femenino'),
)
sexo = models.CharField(max_length=2, choices= SEXO_OPT,blank=True)
orientacion_sexual = models.CharField(max_length=50, blank=True)
intervencion_quirurgica_modificar_sexo = models.CharField(max_length=50, blank=True)
fecha_nacimiento=models.DateTimeField()
edad_aproximada=models.IntegerField()
nacionalidad=models.CharField(max_length=50, blank=True,default="Mexicano(a)")
pais_origen=models.CharField(max_length=50, blank=True, default="México")
#ESTADO_PROCEDENCIA=
#MUNICIPIO_PROCEDENCIA=
#LOCALIDAD_PROCEDENCIA
descripcion_fisica_desaparecido=models.CharField(max_length=300, blank=True)
estatura=models.IntegerField()
complexion= models.CharField(max_length=50, blank=True)
tez=models.CharField(max_length=50, blank=True)
tipo_de_cabello= models.CharField(max_length=50, blank=True)
color_cabello= models.CharField(max_length=50, blank=True)
color_de_ojos= models.CharField(max_length=50, blank=True)
tiene_muestras_geneticas = models.CharField(max_length=2, blank=True)
numero_referencia_de_muestra = models.CharField(max_length=50, blank=True)
institucon_que_la_tomo = models.CharField(max_length=50, blank=True)
senias_particulares = models.CharField(max_length=300, blank=True)
grupo_etnico = models.CharField(max_length=50, blank=True)
migrante = models.CharField(max_length=50, blank=True)
pais_origen = models.CharField(max_length=50, blank=True)
fue_encontrado = models.CharField(max_length=50, blank=True)
fecha_encontrado = models.CharField(max_length=50, blank=True)
estatus_encontrado = models.CharField(max_length=50, blank=True)
SOLO_OPT= (
('0', 'Sólo'),
('1', 'Acompañado'),
)
desaparicion_en_grupo = models.CharField(max_length=2,blank=True,
verbose_name='Estaba sólo o acompañado', choices = SOLO_OPT)
AVERIGUACION_OPT= (
('0', 'Sí'),
('1', 'No'),
)
tiene_averiguacion_previa = models.CharField(max_length=2,blank=True,
choices=AVERIGUACION_OPT,
help_text="Tiene averiguacion?")
NUM_AVERIGUACION = models.CharField(max_length=100, blank=True)
tipo_lugar_ultimavez_visto=models.CharField(max_length=100, blank=True)
#ESTADO=
#MUNICIPIO=
#LOCALIDAD=
colonia_barrio_ejido_desaparicion=models.CharField(max_length=100, blank=True) #dsp es desaparicion
calle_desaparicion=models.CharField(max_length=100, blank=True)
numero_desaparicion=models.CharField(max_length=100, blank=True)
def __str__(self):
return "%s" % (self.nombre, ' ',self.primer_apellido, ' ', self.segundo_apellido)
class Country(Location):
zoom_level = models.IntegerField(default=5)