class MVC(models.Model):
region = models.ForeignKey(Region, help_text="MVC region", null=True, blank=True, default=None, on_delete=models.SET_NULL, db_index=True)
alias = models.CharField(max_length=1000, help_text="MVC alias", null=True, blank=True, default=None, db_index=True)
datetime = models.DateTimeField(default=None, help_text="MVC date", null=True, blank=True, db_index=True)
address = models.CharField(max_length=1000, help_text="MVC address", null=True, blank=True, default=None, db_index=True)
street = models.ForeignKey(Street, help_text="MVC Street", null=True, blank=True, default=None, on_delete=models.SET_NULL, db_index=True)
type = models.ForeignKey(MVCType, help_text="MVC Type", null=True, blank=True, default=None, on_delete=models.SET_NULL, db_index=True)
participant_type = models.ForeignKey(MVCParticipantType, help_text="MVC Participant Type", null=True, blank=True, default=None, on_delete=models.SET_NULL, db_index=True)
longitude = models.FloatField(help_text="MVC longitude", null=True, blank=True, default=None)
latitude = models.FloatField(help_text="MVC longitude", null=True, blank=True, default=None)
conditions = JSONField(help_text="MVC conditions", null=True, blank=True, default=None)
dead = models.IntegerField(help_text="MVC dead count", null=True, blank=True, default=None, db_index=True)
injured = models.IntegerField(help_text="MVC injured count", null=True, blank=True, default=None, db_index=True)
participants = models.IntegerField(help_text="MVC participants count", null=True, blank=True, default=None, db_index=True)
scheme = models.CharField(max_length=100, help_text="MVC scheme number", null=True, blank=True, default=None, db_index=True)
nearby = models.ManyToManyField(Nearby, help_text="Nearby objects", db_index=True)
geo_updated = models.BooleanField(help_text="Geo updated", default=None, null=True)
created_at = models.DateTimeField(auto_now=True)
point = PointField(help_text="MVC point", default=None, null=True)
point_source = PointField(help_text="MVC source point", default=None, null=True)
def __str__(self):
return self.type.name + " " + self.region.name + " " + str(self.datetime)
def get_absolute_url(self):
return '/dtp/' + self.alias + '/'
class Store(models.Model):
name = models.CharField(max_length=20)
location = PointField(srid=4326, geography=True, blank=True, null=True)
opening_time = models.TimeField()
closing_time = models.TimeField()
user = models.OneToOneField(AuthUser,
primary_key=True,
on_delete=models.CASCADE,
related_name='stores')
is_open = models.BooleanField(null=True, blank=True)
opening_days = MultiSelectField(choices=DAY_CHOICES)
# image = models.ImageField(upload_to=)
@property
def average_wait_time(self):
print(self.turns.all())
turns = self.turns.filter(~Q(completion_time=None))
total_time = [
datetime.combine(date.min, turn.completion_time) -
datetime.combine(date.min, turn.creation_time) for turn in turns
]
sum = timedelta()
for i in total_time:
sum += i
if turns.count() > 0:
# print(turns)
average_time = sum / turns.count()
return str((average_time.seconds // 60) % 60)
return
def __str__(self):
return self.name
class UniversityGate(models.Model):
title = models.CharField(max_length=200)
location = PointField()
university = models.ForeignKey(University)
def __str__(self):
return self.title
class Meet(models.BasicObjectModel, models.UGCModel, models.TextModel,
models.Likable):
title = fields.CharField(verbose_name='Название', max_length=255)
participants = fields.ManyToManyField(verbose_name='Участники',
to=get_user_model(),
related_name='participated_meets',
blank=True)
meet_time = fields.DateTimeField(verbose_name='Время проведения')
max_participants = fields.PositiveIntegerField(
verbose_name='Максимальное кол-во участников', default=0)
coordinates = PointField(verbose_name='Координаты')
categories = fields.ManyToManyField(to=Category,
verbose_name='Категории',
related_name='meets')
class Meta:
verbose_name = 'Мероприятие'
verbose_name_plural = 'Мероприятия'
# @fields.permalink
# def get_absolute_url(self):
# return "api/v1/meet/" + str(self.pk)
def __str__(self):
return self.title
class Data(models.Model):
"""A table of all air quality measurements (all sessions). Individual sessions can be extracted
by filtering on "session"""
session = models.ForeignKey(Session, on_delete=models.CASCADE)
value = models.FloatField()
time = models.DateTimeField()
latlon = PointField()
class HalfmileWaypoint(models.Model):
point = PointField()
name = models.SlugField(unique=True, max_length=200)
description = models.TextField(blank=True)
elevation = models.FloatField(blank=True, null=True)
symbol = models.TextField(blank=True)
MILE_TYPE = "mile"
POI_TYPE = "poi"
TYPE_CHOICES = ((MILE_TYPE, "mile"), (POI_TYPE, "point of interest"))
type = models.CharField(max_length=50, choices=TYPE_CHOICES)
objects = HalfmileWaypointManager()
def __str__(self):
if self.type == HalfmileWaypoint.MILE_TYPE:
return "Mile " + self.name.replace("-", ".")
else:
return self.name
@property
def latitude(self):
return self.point.y
@property
def longitude(self):
return self.point.x
class CustomUser(PhoneNumberAbstactUser):
REQUIRED_FIELDS = ['phone_number', 'email']
dob = models.DateField(default=None, null=True)
bio = models.TextField(default='', blank=True)
address = models.CharField(max_length=120, default='')
location = PointField(default=Point(0, 0))
is_location = models.BooleanField(default=False)
photo = models.FileField(null=True)
is_blocked = models.BooleanField(default=False)
black_list = models.ManyToManyField('self', symmetrical=False, blank=True)
def __str__(self):
return self.username
def __unicode__(self):
return self.username
@property
def last_seen(self):
return cache.get('seen_%s' % self.username)
@property
def online(self):
if self.last_seen:
now = datetime.datetime.now()
if now > self.last_seen + datetime.timedelta(
seconds=settings.USER_ONLINE_TIMEOUT):
return False
else:
return True
else:
return False
class District(Place, SlugModel):
slug_contains_id = True
name_std = models.CharField(max_length=200,
db_index=True,
verbose_name="standard name")
code = models.CharField(blank=True,
db_index=True,
max_length=200,
null=True)
location = PointField()
population = models.IntegerField()
city = models.ForeignKey(swapper.get_model_name('cities', 'City'),
related_name='districts',
on_delete=SET_NULL_OR_CASCADE)
class Meta:
unique_together = (('city', 'name'), )
@property
def parent(self):
return self.city
def slugify(self):
if self.id:
return '{}-{}'.format(self.id, unicode_func(self.name))
return None
class Circonscription(models.Model):
departement = models.CharField(verbose_name="Code du département",
max_length=3)
numero = models.PositiveSmallIntegerField(
verbose_name="Numéro de la circonscription")
contour = GeometryField(verbose_name="Contour", geography=True, null=True)
centroid = PointField(verbose_name="Centre approximatif",
geography=True,
null=True)
@property
def nom(self):
if self.numero == 1:
ordinal_suffix = "ère"
else:
ordinal_suffix = "ème"
return format_html(
"{numero}<sup>{ordinal}</sup> circonscription {departement}",
numero=self.numero,
ordinal=ordinal_suffix,
departement=departements[self.departement].avec_charniere,
)
def __str__(self):
return f"{self.departement}-{self.numero}"
class Meta:
constraints = [
models.UniqueConstraint(fields=["departement", "numero"],
name="code_circonscription")
]
verbose_name = "Circonscription"
class Checkin(models.Model):
seller_name = models.CharField(max_length=255, verbose_name='Your name')
point = PointField(blank=True)
time = models.DateTimeField(auto_now=True)
expiry = models.DateTimeField()
expiry_offset = models.IntegerField(verbose_name='For how long?',
default=3600,
choices=(
(3600, u'1 Hour'),
(7200, u'2 Hours'),
(10800, u'3 Hours'),
(14400, u'4 Hours'),
))
items = models.ManyToManyField(Item)
notes = models.TextField(
help_text='Any additional information you would like to share.')
objects = GeoManager()
class Meta:
ordering = ('-time', )
def __unicode__(self):
return self.seller_name
def save(self, *args, **kwargs):
self.expiry = datetime.now() + timedelta(0, self.expiry_offset)
super(Checkin, self).save(*args, **kwargs)
class Location(models.Model):
city = models.CharField(max_length=50,
default='Chicago',
verbose_name=_('city'))
address = models.CharField(max_length=100,
blank=True,
verbose_name=_('address'))
point = PointField(geography=True,
verbose_name=_('map'),
null=True,
blank=True)
# zipcode =
@property
def lat_lng(self):
"""for ubuntu 20.04(GDAL v. 3) dont need use revers
getattr(self.point, 'coords', [])[::-1]
"""
return list(getattr(self.point, 'coords', []))
class Meta:
ordering = ['city']
abstract = True
def __unicode__(self):
return self.city
def __str__(self):
return self.city
class AbstractAddress(models.Model):
"""A abstract address model for addresses.
The text of street is free. If the city does not exist can be entered manually.
"""
street = models.CharField(max_length=120, label=_('Street and number'))
poiny = PointField(blank=True, null=True)
district = models.ForeignKey(District, blank=True, null=True, on_delete=models.SET_NULL, label=_('District'))
city = models.ForeignKey(City, blank=True, null=True, on_delete=models.SET_NULL, label=_('City'))
custom_city = models.CharField(max_length=40, blank=True)
custom_postal_code = models.CharField(max_length=15, blank=True, label=_('Postal code'))
subregion = models.ForeignKey(Subregion, blank=True, null=True, label=_('Subregion'), on_delete=models.SET_NULL)
region = models.ForeignKey(Region, label=_('Region'), on_delete=models.PROTECT)
updated_at = models.DateTimeField(auto_now=True)
created_at = models.DateTimeField(auto_now_add=True)
def clean(self):
if not self.city and not self.custom_city:
raise ValidationError(_('You must provide a city or a custom city'))
elif self.city and self.custom_city:
raise ValidationError(_('You can not provide custom city if you provided a city'))
elif not self.custom_postal_code and self.custom_city:
raise ValidationError(_('You must provide a postal code if you use a custom city'))
class Meta:
abstract = True
class Address(models.Model):
location = PointField(srid=4326, geography=True, blank=True, null=True)
#long = models.FloatField()
#lat = models.FloatField()
street = models.TextField()
city = models.TextField()
state = models.CharField(max_length=2, choices=STATES)
zip_code = models.CharField(max_length=5, validators=[zip_validator])
# Relationship Fields
service_provider = models.OneToOneField(
ServiceProvider,
on_delete=models.CASCADE,
primary_key=True,
related_name='address',
)
def save(self, *args, **kwargs):
if not self.location:
addr = self.street + ' ' + self.city + ' ' + self.state + ' ' + self.zip_code
provider_point = geolocator.geocode(addr)
self.location = Point(provider_point.longitude,
provider_point.latitude)
super().save(*args, **kwargs)
class Meta:
verbose_name_plural = "addresses"
def __str__(self):
return self.street
class Place(models.Model):
title = models.CharField(max_length=250, null=False)
location = PointField(null=True, blank=True)
description = models.CharField(max_length=250)
address = models.CharField(max_length=250)
phone = models.CharField(max_length=10, null=True, blank=True)
city = models.ForeignKey(City, on_delete=models.CASCADE)
type = models.ManyToManyField(Type)
tags = TaggableManager()
slug = models.SlugField(unique=True)
date_added = models.DateField(null=True, blank=True)
user = models.ForeignKey(User, on_delete=models.CASCADE)
class Meta:
verbose_name_plural = 'Place'
def __str__(self):
return str(self.title)
@property
def get_all_tags(self):
return ','.join(
str(tag) for tag in Place.objects.get(pk=self.id).tags.names())
def save(self, *args, **kwargs):
if not self.id:
self.slug = get_unique_slug(self, Place)
self.date_added = datetime.datetime.now()
super(Place, self).save(*args, **kwargs)
class Encampment(BaseModel):
name = models.CharField(
max_length=100,
help_text="A descriptive name for the encampment, which may be based on the address.",
)
location = models.CharField(
max_length=250,
help_text="An intersection or address. Adding a city/state can help accuracy.",
)
location_geom = PointField(srid=4326, blank=True)
region = models.ForeignKey("Region", null=True, on_delete=models.PROTECT)
def open_tasks(self):
return self.tasks.filter(completed=None)
def completed_tasks(self):
return self.tasks.exclude(completed=None)
def reports(self):
return self.reports.order_by("-date")
def last_report(self):
return self.reports.order_by("-date").first()
def next_visit(self):
return (
ScheduledVisit.objects.filter(encampment=self, report=None)
.order_by("-date")
.first()
)
@classmethod
def not_visited_in(cls, n_days: int):
return Encampment.objects.delayed(days=n_days)
def get_absolute_url(self):
return reverse("encampment-detail", kwargs={"pk": self.id})
def save(self, *args, **kwargs):
if not self.location_geom:
# geocode
geocoder = mapbox.Geocoder()
result = geocoder.forward(
self.location,
lon=settings.LOCAL_LONGITUDE,
lat=settings.LOCAL_LATITUDE,
types=["address"],
).geojson()
self.location_geom = GEOSGeometry(str(result["features"][0]["geometry"]))
if not self.region:
self.region = Region.get_for_point(self.location_geom)
super().save(*args, **kwargs)
def __str__(self):
return "{} ({})".format(self.name, self.location)
objects = EncampmentManager()
class Meta:
ordering = ("name",)
class Property(models.Model):
title = models.CharField(max_length=255)
description = models.TextField(blank=True)
slug = models.SlugField(unique=True)
address = models.CharField(max_length=255)
point = PointField(null=True, blank=True, srid=4326)
image = models.ImageField(upload_to='properties')
is_available = models.BooleanField(default=True)
price = models.DecimalField(max_digits=8, decimal_places=2)
property_type = models.CharField(max_length=24,
choices=PROPERTY_TYPE,
default='house')
created_by = models.ForeignKey(User, on_delete=models.CASCADE)
created_date = models.DateTimeField(auto_now_add=True)
updated_date = models.DateTimeField(auto_now=True)
class Meta:
ordering = ['-created_date', '-updated_date', 'title']
verbose_name_plural = 'properties'
def __str__(self):
return self.title
@models.permalink
def get_absolute_url(self):
return ('property-update', (), {'slug': self.slug})
class CurrentLocation(models.Model):
node = models.OneToOneField('nodes.Node',
on_delete=C,
related_name='current_location')
effective_as_of = models.DateTimeField(null=False)
location = PointField(null=False)
altitude = models.FloatField(null=True, default=None, blank=True)
elevation = models.FloatField(null=True, default=None, blank=True)
orientation = JSONField(null=True, default=None, blank=True)
class Meta:
managed = False
db_table = 'node_current_locations'
@staticmethod
def create_materialized_view():
return """
CREATE MATERIALIZED VIEW node_current_locations AS
SELECT id, node_id, location, altitude, elevation, orientation, effective_as_of
FROM node_locations
WHERE id NOT IN (
SELECT DISTINCT old_location_id
FROM node_location_changes
)
"""
@staticmethod
def refresh_materialized_view(*args, **kwargs):
with connection.cursor() as cursor:
cursor.execute('REFRESH MATERIALIZED VIEW node_current_locations')
def __str__(self) -> str:
return f'{self.node} [{self.effective_as_of}]'
class Order(models.Model):
owner = models.ForeignKey(settings.AUTH_USER_MODEL,
on_delete=models.CASCADE,
related_name='orders')
request = models.TextField(help_text=_('Say what you want.'))
location = PointField(null=True)
created = models.DateTimeField(auto_now_add=True)
@property
def doer(self):
doer = None
request = self.requests.filter(status=Status.ACCEPTED).first()
if (request):
doer = request.doer
return doer
class Meta:
verbose_name = _('Order')
verbose_name_plural = _('Orders')
def __str__(self):
return self.request
class EmergencyProcess(Process):
point = PointField(null=True)
nature_of_emergency = models.CharField(choices=nature_of_emergency_choices,
max_length=255)
question_answer = JSONField(
null=True) # Stores each question-answer pair, service provider
accept = models.BooleanField(default=False)
class Scene(models.Model):
artwork = models.ForeignKey(Artwork, default=None)
description = models.TextField(default='')
notes = models.TextField(default='')
latitude = models.FloatField()
longitude = models.FloatField()
submitted_by = User()
name = models.TextField(default='')
coordinates = PointField(geography=True, null=True, blank=True)
objects = SceneDistanceManager()
def to_dict(self):
data = {}
data['id'] = self.id
data['artist'] = self.artwork.artist.full_name
data['artwork'] = self.artwork.title
data['name'] = self.name
data['description'] = self.description
data['notes'] = self.notes
data['loc'] = {
'coordinates': [self.latitude, self.longitude],
'type': 'Point'
}
return data
def save(self, *args, **kwargs):
if isinstance(self.latitude, float) and isinstance(
self.longitude, float):
self.coordinates = GEOSGeometry(
Point(self.latitude, self.longitude))
super().save(*args, **kwargs)
class Breadcrumb(models.Model):
"""
A raw track from the SPOT tracker
Store this separate from the Location to prevent clutter, and to maybe use to display a live-ish track.
"""
spot_id = models.BigIntegerField(unique=True)
timestamp = models.DateTimeField()
point = PointField()
raw = JSONField()
# For "OK" checkins, also save as a post so it shows up on the map.
post = models.ForeignKey(
Post,
blank=True,
null=True,
related_name="breadcrumbs",
on_delete=models.SET_NULL,
)
@property
def latitude(self):
return self.point.y if self.point else None
@property
def longitude(self):
return self.point.x if self.point else None
def __str__(self):
return f"({self.latitude}, {self.longitude}) at {self.timestamp}"
class UserProfile(models.Model):
GENDER_CHOICES = (
('male', 'male'),
('female', 'female'),
('other', 'other')
)
user = models.OneToOneField(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name='profile')
location = PointField(geography=True, srid=4326, blank=True, null=True)
image = models.ImageField(upload_to='profile_pics/')
address = models.CharField(max_length=255)
contact = models.CharField(max_length=255)
zip_code = models.CharField(max_length=255, null=True, blank=True)
gender = models.CharField(max_length=255, choices=GENDER_CHOICES, null=True, blank=True)
@property
def longitude(self):
if self.location:
return self.location.x
else:
return 0
@property
def latitude(self):
if self.location:
return self.location.y
else:
return 0
def __str__(self):
return self.user.username + ' - ' + 'Profile'
class Company(models.Model):
name = models.CharField(max_length=500)
category = models.CharField(max_length=100)
funding_total = models.DecimalField(max_digits=20, decimal_places=9)
status = models.CharField(max_length=20)
country = CountryField()
us_state = USStateField()
us_city = models.CharField(max_length=200)
funding_rounds = models.IntegerField()
number_of_investors = models.IntegerField()
acquirer = models.CharField(max_length=200, null=True, blank=True)
acquirer_category = models.CharField(max_length=100, null=True, blank=True)
acquirer_country = CountryField(null=True, blank=True)
acquirer_us_state = USStateField(null=True, blank=True)
acquirer_us_city = models.CharField(max_length=200, null=True, blank=True)
acquired_price = models.DecimalField(max_digits=25,
decimal_places=5,
null=True,
blank=True)
acquired_currency = models.CharField(max_length=3, null=True, blank=True)
county = models.CharField(max_length=100)
founded_at = models.IntegerField()
coordinates = PointField(null=True, blank=True)
@property
def latitude(self):
return self.coordinates.coords[1]
@property
def longitude(self):
return self.coordinates.coords[0]
def __str__(self):
return self.name
class Area(models.Model):
name = models.CharField(max_length=100)
city = models.ForeignKey(City)
point = PointField(null=True, blank=True)
def __unicode__(self):
return self.name
class Winery(models.Model):
"""Model for winery"""
name = models.CharField(max_length=30)
description = models.TextField()
website = models.CharField(max_length=40, blank=True)
available_since = models.DateTimeField(null=True, blank=True)
location = PointField(u"longitude/latitude",
geography=True,
blank=True,
null=True)
class Meta:
verbose_name = 'Winery'
verbose_name_plural = 'Wineries'
def __str__(self):
return self.name
@staticmethod
def get_nearly_wineries(location, ratio):
current_point = geos.fromstr(location)
distance_from_point = {'km': ratio}
distance = Distance(**distance_from_point)
wineries = Winery.objects.filter(
location__distance_lt=(current_point, distance),
location__isnull=False,
available_since__isnull=False,
)
return wineries
class Peak(models.Model):
"""
Peak model defintion, longitude and latitude are contained within the location field
"""
location = PointField()
altitude = models.IntegerField()
name = models.CharField(max_length=512)
class User(AbstractUser):
# First Name and Last Name do not cover name patterns
# around the globe.
name = models.CharField(_('Name of User'), blank=True, max_length=255)
location = PointField(
null=True,
blank=True,
help_text='User Location, only read in production user admin panel'
)
def user_photo_upload(instance, filename):
extension = os.path.splitext(filename)[1]
return "media/users/%s%s" % (str(instance.id), extension)
picture = models.ImageField(
null=True,
blank=True,
help_text='Profile Picture',
upload_to=user_photo_upload,
)
def __str__(self):
return self.username
def get_absolute_url(self):
return reverse('users:detail', kwargs={'username': self.username})
class Location(models.Model):
name = models.CharField(max_length=255)
point = PointField()
@property
def lat_lng(self):
return list(getattr(self.point, 'coords', [])[::-1])
class Attendance(models.Model):
attendance_date = models.DateField()
staffs = models.ManyToManyField(Staff)
team = models.ForeignKey(Team, blank=True, null=True, related_name="attandence_team")
submitted_by = models.ForeignKey(User, related_name="attendance_submitted_by")
created_date = models.DateTimeField(auto_now_add=True)
updated_date = models.DateTimeField(auto_now=True)
is_deleted = models.BooleanField(default=False)
location = PointField(geography=True, srid=4326, blank=True, null=True)
logs = GenericRelation('eventlog.FieldSightLog')
id_pass_proof = JSONField(default=[])
class Meta:
unique_together = [('attendance_date', 'team', 'is_deleted'),]
@property
def latitude(self):
if self.location:
return self.location.y
@property
def longitude(self):
if self.location:
return self.location.x
def save(self, *args, **kwargs):
attendance_date = datetime.datetime.strptime(str(self.attendance_date), '%Y-%m-%d')
if attendance_date > datetime.datetime.today():
raise PermissionDenied()
else:
super(Attendance, self).save(*args, **kwargs) # Call the "real" save() method.
def __unicode__(self):
return str(self.attendance_date)
class IP(models.Model):
"""
Inventory for caching the geographic info from IP
"""
ip = models.GenericIPAddressField(protocol='both', unpack_ipv4=True)
# Area related information
state_prov = models.CharField(max_length=50)
district = models.CharField(max_length=50)
city = models.CharField(max_length=50)
zip = models.CharField(max_length=10)
location = PointField(srid=4326)
time_zone = TimeZoneField(display_GMT_offset=True)
isp = models.CharField(max_length=30)
connection_type = models.CharField(max_length=30)
country = models.ForeignKey(Country,
on_delete=models.SET_NULL,
null=True,
related_name='assigned_ips')
created_at = models.DateTimeField()
updated_at = models.DateTimeField()
def __str__(self):
return f'{self.ip}'
def save(self, *args, **kwargs):
if not self.id:
self.created_at = timezone.localtime()
self.updated_at = timezone.localtime()
return super().save(*args, **kwargs)