class Region(geomodel.Model):
name = geomodel.CharField(max_length=50, blank=True, null=True)
reg_code = geomodel.PositiveIntegerField(primary_key=True)
geom = geomodel.MultiPolygonField(srid=my_srid)
def __str__(self):
return str(self.reg_code)
class RasterLayerParseStatus(models.Model):
"""
Tracks the parsing status of the raster layer.
"""
UNPARSED = 0
DOWNLOADING_FILE = 1
REPROJECTING_RASTER = 2
CREATING_TILES = 3
DROPPING_EMPTY_TILES = 4
FINISHED = 5
FAILED = 6
STATUS_CHOICES = (
(UNPARSED, 'Layer not yet parsed'),
(DOWNLOADING_FILE, 'Downloading file'),
(REPROJECTING_RASTER, 'Reprojecting'),
(CREATING_TILES, 'Creating tiles'),
(DROPPING_EMPTY_TILES, 'Dropping empty tiles'),
(FINISHED, 'Finished parsing'),
(FAILED, 'Failed parsing'),
)
rasterlayer = models.OneToOneField(RasterLayer, related_name='parsestatus')
status = models.IntegerField(choices=STATUS_CHOICES, default=UNPARSED)
log = models.TextField(default='', editable=False)
tile_levels = ArrayField(models.PositiveIntegerField(), default=[])
def __str__(self):
return '{0} - {1}'.format(self.rasterlayer.name,
self.get_status_display())
def reset(self):
self.tile_levels = []
self.log = ''
self.status = self.UNPARSED
self.save()
class Position(models.Model):
date = models.DateTimeField(_('Date'), auto_now_add=True)
tracker = models.ForeignKey(Tracker,
verbose_name=_('Tracker'),
related_name='positions',
blank=True,
null=True)
point = models.PointField(_('Point'))
speed = models.FloatField(_('Speed'),
help_text=_('Speed in km/h'),
blank=True,
null=True)
# Tracking object
tracking_content_type = models.ForeignKey(ContentType,
blank=True,
null=True)
tracking_object_id = models.PositiveIntegerField(db_index=True,
blank=True,
null=True)
tracking_object = generic.GenericForeignKey('tracking_content_type',
'tracking_object_id')
objects = models.GeoManager()
def __unicode__(self):
return u'%s %s' % (self.date, self.tracker)
class Meta:
verbose_name = _('Position')
verbose_name_plural = _('Positions')
class Airport(models.Model):
airport_id = models.PositiveIntegerField(primary_key=True, editable=False)
name = models.CharField(_("name"), max_length=100)
iata = models.CharField(_("IATA/FAA code"),
blank=True,
max_length=3,
validators=[MinLengthValidator(3)],
)
icao = models.CharField(_("ICAO code"),
blank=True,
max_length=4,
validators=[MinLengthValidator(4)]
)
altitude = models.FloatField(_("altitude"), default=0)
location = models.PointField(_("location"))
country = models.ForeignKey('cities.Country', on_delete=models.DO_NOTHING, null=True)
city = models.ForeignKey('cities.City', on_delete=models.DO_NOTHING, null=True)
objects = GeoManager()
class Meta: # pylint: disable=C1001
ordering = ['airport_id']
def __str__(self):
return force_text(self.name)
class Product(models.Model):
name = models.CharField(max_length=200)
description = models.TextField()
order = models.PositiveIntegerField(default=0)
def __unicode__(self):
return u"%s" % (self.name)
class Referral(models.Model):
"""This model represents a referral of an application to a referee
(external or internal) for comment/conditions.
"""
REFERRAL_STATUS_CHOICES = Choices(
(1, 'referred', ('Referred')), (2, 'responded', ('Responded')),
(3, 'recalled', ('Recalled')), (4, 'expired', ('Expired')),
(5, 'with_admin', ('Not Sent')))
application = models.ForeignKey(Application, on_delete=models.CASCADE)
referee = models.ForeignKey(settings.AUTH_USER_MODEL,
on_delete=models.PROTECT)
details = models.TextField(blank=True, null=True)
sent_date = models.DateField(blank=True, null=True)
period = models.PositiveIntegerField(verbose_name='period (days)')
expire_date = models.DateField(blank=True, null=True, editable=False)
response_date = models.DateField(blank=True, null=True)
feedback = models.TextField(blank=True, null=True)
proposed_conditions = models.TextField(blank=True, null=True)
records = models.ManyToManyField(Record, blank=True)
status = models.IntegerField(choices=REFERRAL_STATUS_CHOICES,
default=REFERRAL_STATUS_CHOICES.with_admin)
class Meta:
unique_together = ('application', 'referee')
def __str__(self):
return 'Referral {} to {} ({})'.format(self.pk, self.referee,
self.application)
def save(self, *args, **kwargs):
"""Override save to set the expire_date field.
"""
#self.expire_date = self.sent_date + timedelta(days=self.period)
super(Referral, self).save(*args, **kwargs)
class Event(models.Model):
EVENT_TYPE = (
("FO", "Food"),
("NT", "Networking"),
("PT", "Party"),
("SP", "Sports"),
("AC", "Academics"),
("MU", "Music"),
("MS", "Miscellaneous"),
)
host = models.ForeignKey('auth.User', related_name='events_hosting', on_delete=models.CASCADE, default=1)
registered_users = models.ManyToManyField('auth.User', related_name='events_registered')
attending_users = models.ManyToManyField('auth.User', related_name='events_attended')
favourited_users = models.ManyToManyField('auth.User', related_name='events_favourited')
creation_date = models.DateTimeField(auto_now_add=True)
event_name = models.CharField(max_length=100, default='event')
event_description = models.CharField(max_length=100, blank=True, default='New event')
event_address = models.CharField(max_length=50, null=True, blank=True)
event_point_location = models.PointField(null=True)
event_max_capacity = models.PositiveIntegerField(default=100) #NOTE: the redundant validator was just added for compatibility with SQLite
event_type = ArrayField(
models.CharField(choices=EVENT_TYPE, max_length=2, blank=True, default="MS"),
default=list,
null=True
)
event_start_time = models.DateTimeField('start date and time', null=True)
event_end_time = models.DateTimeField('start date and time', null=True)
event_price = models.DecimalField(max_digits=7, decimal_places=2, default='0.00', validators=[MinValueValidator(0.0)])
room_id = models.CharField(max_length=150, null=True)
class Meta:
ordering = ('-creation_date',)
class Archelogy(models.Model):
fiche = models.TextField(_("fiche"),null=True)
commune = models.TextField(_("commune"),null=True)
descriptio = models.TextField(_("descriptio"),null=True)
note_carto = models.TextField(_("note_carto"),null=True)
annee_revi = models.TextField(_("annee_revi"),null=True)
id_per = models.TextField(_("id_per"),null=True)
lien_img = models.TextField(_("lien_img"),null=True)
note_detai = models.TextField(_("note_detai"),null=True)
shape_len = models.TextField(_("shape_len"),null=True)
date_maj = models.TextField(_("date_maj"),null=True)
guid = models.TextField(_("guid"),null=True)
mention = models.TextField(_("mention"),null=True)
fme_feat = models.TextField(_("fme_feat"),null=True)
autre_ment = models.TextField(_("autre_ment"),null=True)
multi_read = models.TextField(_("multi_read"),null=True)
autre_mesu = models.TextField(_("autre_mesu"),null=True)
shape_area = models.TextField(_("shape_area"),null=True)
objectid = models.TextField(_("objectid"),null=True)
date_mesur = models.TextField(_("date_mesur"),null=True)
eca = models.TextField(_("eca"),null=True)
url_recens = models.TextField(_("url_recens"),null=True)
mesure = models.TextField(_("mesure"),null=True)
import_date = models.PositiveIntegerField(_("import_date"),null=True)
geom = models.MultiPolygonField(_("geom"),srid=2056)
class Meta:
verbose_name = _('archelogy')
def __str__(self):
return 'Archelogy' + str(self.id)
class Profile(models.Model):
# The authentication model of the user
user = models.OneToOneField(User, on_delete=models.CASCADE)
# The current path the user is waiting beside
path = models.ForeignKey('GeoPath', on_delete=models.SET_NULL, null=True)
# Car the user is currently within (null if user is not in a car)
current_car = models.ForeignKey('Car', on_delete=models.SET_NULL, null=True, blank=True)
# Estimated time of arrival of current car in seconds
wait_time = models.PositiveIntegerField(default=0)
USER_STATES = (
('r', 'Ride Request (Not active)'),
('w', 'Waiting for ride'),
('a', 'Car has arrived'),
('p', 'User is passenger'),
)
# User state
user_state = models.CharField(max_length=1, choices=USER_STATES, blank=True, default='r')
def __str__(self):
return self.user.username
class Contact(models.Model):
from_name = models.CharField(max_length=255)
from_email = models.EmailField()
message = models.TextField()
spam_score = models.PositiveIntegerField()
ip_address = models.GenericIPAddressField()
referrer = models.URLField(blank=True)
class RelationMember(models.Model):
parent = models.ForeignKey('Relation', on_delete=models.CASCADE)
member_node = models.ForeignKey('Node',
on_delete=models.CASCADE,
blank=True,
null=True)
member_way = models.ForeignKey('Way',
on_delete=models.CASCADE,
blank=True,
null=True)
member_relation = models.ForeignKey(
'Relation',
on_delete=models.CASCADE,
blank=True,
null=True,
related_name="%(class)s_member_relations")
NODE = 'n'
WAY = 'w'
RELATION = 'r'
TYPES = ((NODE, 'node'), (WAY, 'way'), (RELATION, 'relation'))
type = models.CharField(max_length=1, choices=TYPES)
role = models.TextField()
sequence = models.PositiveIntegerField()
class WebhookTransaction(TimeStampedModel):
UNPROCESSED = 1
PROCESSED = 2
ERROR = 3
SKIPPED = 4
STATUSES = (
(UNPROCESSED, "Unprocessed"),
(PROCESSED, "Processed"),
(ERROR, "Error"),
(SKIPPED, "Skipped"),
)
# time of generation on Strava side
class Meta:
ordering = ["-date_generated"]
date_generated = models.DateTimeField()
body = JSONField()
request_meta = JSONField()
status = models.PositiveIntegerField(choices=STATUSES, default=UNPROCESSED)
def __str__(self):
return "{0} - {1}".format(self.get_status_display(),
self.date_generated)
class Layer(models.Model):
"""
A layer object that can be added to any map.
"""
name = models.CharField(max_length=200)
type = models.CharField(choices=SERVICE_TYPES, max_length=75)
"""TODO: Make this url field a CharField"""
url = models.URLField(help_text='URL of service. If WMS or ESRI, can be any valid URL. Otherwise, the URL will require a local proxy')
layer = models.CharField(max_length=800, null=True, blank=True, help_text='Layer names can sometimes be comma-separated, and are not needed for data layers (KML, GeoRSS, GeoJSON...)')
image_format = models.CharField(null=True, blank=True, choices=IMAGE_FORMATS, max_length=75, help_text='The MIME type of the image format to use for tiles on WMS layers (image/png, image/jpeg image/gif...). Double check that the server exposes this exactly - some servers push png instead of image/png.')
styles = models.CharField(null=True, blank=True, max_length=200, help_text='The name of a style to use for this layer (only useful for WMS layers if the server exposes it.)')
transparent = models.BooleanField(default=True, help_text='If WMS or overlay, should the tiles be transparent where possible?')
refreshrate = models.PositiveIntegerField(blank=True, null=True, verbose_name="Layer Refresh Rate", help_text='Layer refresh rate in seconds for vector/data layers (will not refresh WMS layers)')
description = models.TextField(max_length=800, null=True, blank=True, help_text='Text to show in layer chooser, please be descriptive - this will soon be searchable')
attribution = models.CharField(max_length=200, null=True, blank=True, help_text="Attribution from layers to the map display (will show in bottom of map when layer is visible).")
token = models.CharField(max_length=400, null=True, blank=True, help_text='Authentication token, if required (usually only for secure layer servers)')
## Advanced layer options
objects = models.GeoManager()
extent = models.PolygonField(null=True, blank=True, help_text='Extent of the layer.')
layer_parsing_function = models.CharField(max_length=100, blank=True, null=True, choices=PARSER_CATEGORIES, help_text='Advanced - The javascript function used to parse a data service (GeoJSON, GeoRSS, KML), needs to be an internally known parser. Contact an admin if you need data parsed in a new way.')
enable_identify = models.BooleanField(default=False, help_text='Advanced - Allow user to click map to query layer for details. The map server must support queries for this layer.')
info_format = models.CharField(max_length=75, null=True, blank=True, choices=INFO_FORMATS, help_text='Advanced - what format the server returns for an WMS-I query')
root_field = models.CharField(max_length=100, null=True, blank=True, help_text='Advanced - For WMS-I (queryable) layers, the root field returned by server. Leave blank for default (will usually be "FIELDS" in returned XML).')
fields_to_show = models.CharField(max_length=200, null=True, blank=True, help_text='Fields to show when someone uses the identify tool to click on the layer. Leave blank for all.')
downloadableLink = models.URLField(max_length=300, null=True, blank=True, help_text='URL of link to supporting tool (such as a KML document that will be shown as a download button)')
layer_params = JSONField(null=True, blank=True, help_text='JSON key/value pairs to be sent to the web service. ex: {"crs":"urn:ogc:def:crs:EPSG::4326"}')
spatial_reference = models.CharField(max_length=32, blank=True, null=True, default="EPSG:4326", help_text='The spatial reference of the service. Should be in ESPG:XXXX format.')
constraints = models.TextField(null=True, blank=True)
## Primarily for http://trac.osgeo.org/openlayers/wiki/OpenLayersOptimization
additional_domains = models.TextField(null=True, blank=True, help_text='Semicolon seperated list of additional domains for the layer.')
def __unicode__(self):
return '{0}'.format(self.name)
def get_layer_urls(self):
"""
Returns a list of urls for the layer.
"""
urls = []
if getattr(self, 'additional_domains'):
map(urls.append, (domain for domain in self.additional_domains.split(";") if domain))
return urls
def get_absolute_url(self):
return reverse('layer-update', args=[self.id])
def get_layer_params(self):
"""
Converts a layer's parameters to json.
"""
return self.layer_params
class Meta:
ordering = ["name"]
class AlternateName(models.Model):
""" other names for localities for example in different languages etc. """
### model options - "anything that's not a field"
class Meta:
unique_together = (("locality", "name"), )
ordering = ['locality__pk', 'name']
### Python class methods
def __unicode__(self):
if settings.DEBUG:
return u'PK{0}: {1} ({2})'.format(self.alternatenameid, self.name,
self.locality.name)
return u'{0} ({1})'.format(self.name, self.locality.name)
### model DB fields
status = models.IntegerField(
blank=False,
default=BaseManager.STATUS_ENABLED,
# specify blank=False default=<value> to avoid form select '-------' rendering
choices=BaseManager.STATUS_CHOICES)
alternatenameid = models.PositiveIntegerField(primary_key=True)
locality = models.ForeignKey(Locality,
related_name="alternatename_set",
on_delete=models.CASCADE)
name = models.CharField(max_length=200, db_index=True)
# TODO include localization code
### custom managers
objects = BaseManager()
class EmailLog(TimeStampedSafeDeleteModel):
"""
In Finnish: Sähköpostiloki
"""
type = EnumField(EmailLogType, verbose_name=_("Email log type"), max_length=30)
user = models.ForeignKey(
User, related_name="emaillogs", verbose_name=_("User"), on_delete=models.PROTECT
)
text = models.TextField(verbose_name=_("Text"), null=True, blank=True)
sent_at = models.DateTimeField(
verbose_name=_("Time created"), null=True, blank=True
)
recipients = models.ManyToManyField(User)
content_type = models.ForeignKey(
ContentType, related_name="+", on_delete=models.CASCADE
)
object_id = models.PositiveIntegerField()
content_object = GenericForeignKey("content_type", "object_id")
recursive_get_related_skip_relations = ["user"]
class Meta:
verbose_name = pgettext_lazy("Model name", "Email log")
verbose_name_plural = pgettext_lazy("Model name", "Email logs")
class Geotag(models.Model):
"""
A simple wrapper around the GeoDjango field types
"""
# Content-object field
content_type = models.ForeignKey(ContentType,
related_name="content_type_set_for_%(class)s")
object_id = models.PositiveIntegerField(_('object ID'), max_length=50)
tagged_obj = generic.GenericForeignKey(ct_field="content_type",
fk_field="object_id")
point = models.PointField(**field_kwargs('point'))
multilinestring = models.MultiLineStringField(**field_kwargs('multi-line'))
line = models.LineStringField(**field_kwargs('line'))
polygon = models.PolygonField(**field_kwargs('polygon'))
geometry_collection = models.GeometryCollectionField(
**field_kwargs('geometry collection'))
objects = GeotagManager()
def get_geom(self):
"""Returns the geometry in use or None"""
for geom_type in ('point', 'line', 'multilinestring',
'polygon', 'geometry_collection'):
geom = getattr(self, geom_type)
if geom:
return geom
return None
class ProvinceStateCode(AuditModel):
"""
Lookup of Provinces/States.
Used to specify valid provinces or states for the address of the owner of a well.
It provides for a standard commonly understood code and description for provinces and states.
Some examples include: BC, AB, WA
"""
province_state_code = models.CharField(primary_key=True, max_length=10)
description = models.CharField(max_length=100)
display_order = models.PositiveIntegerField(
db_index=True,
db_comment='The order in which the codes may display on screen.')
"""
Tue 13 Feb 22:24:26 2018 GW Disabled for now until Code With Us sprint is complete
effective_date = models.DateTimeField(blank=True, null=True)
expiry_date = models.DateTimeField(blank=True, null=True)
"""
class Meta:
db_table = 'province_state_code'
ordering = ['display_order']
db_table_comment = 'Province or state used for the mailing address for the company'
def __str__(self):
return self.description
class Geoname(models.Model):
geonameid = models.PositiveIntegerField(primary_key=True, unique=True)
name = models.CharField(max_length=200, db_index=True)
alternates = models.TextField(blank=True)
fclass = models.CharField(max_length=1, db_index=True)
fcode = models.CharField(max_length=10, db_index=True)
country = models.CharField(max_length=2, blank=True, db_index=True)
cc2 = models.CharField('Alternate Country Code', max_length=60, blank=True)
admin1 = models.CharField(max_length=20, blank=True, db_index=True)
admin2 = models.CharField(max_length=80, blank=True, db_index=True)
admin3 = models.CharField(max_length=20, blank=True, db_index=True)
admin4 = models.CharField(max_length=20, blank=True, db_index=True)
population = BigIntegerField(db_index=True)
elevation = models.IntegerField(db_index=True)
topo = models.IntegerField(db_index=True)
timezone = models.CharField(max_length=30, blank=True)
moddate = models.DateField('Date of Last Modification')
point = models.PointField(null=True)
objects = models.GeoManager()
def __unicode__(self):
return self.name
def is_country(self):
return self.fcode == 'PCLI'
def get_country(self):
if not self.is_country():
return self.__class__.objects.get(fcode='PCLI', country=self.country)
else:
return self
class BasePoint(models.Model):
point = models.PointField(null=True, editable=False)
heading = models.PositiveIntegerField(default=0,
help_text="Heading in degrees",
editable=False)
velocity = models.PositiveIntegerField(default=0,
help_text="Speed in metres/hr",
editable=False)
altitude = models.IntegerField(
default=0,
help_text="Altitude above sea level in metres",
editable=False)
seen = models.DateTimeField(null=True, editable=False)
message = models.PositiveIntegerField(default=3, choices=RAW_EQ_CHOICES)
source_device_type = models.CharField(max_length=32,
choices=SOURCE_DEVICE_TYPE_CHOICES,
default="other")
class Meta:
abstract = True
ordering = ['-seen']
def clean_fields(self, exclude=None):
"""
Override clean_fields to provide model-level validation.
"""
if exclude is None:
exclude = []
errors = {}
for f in self._meta.fields:
if f.name in exclude:
continue
if hasattr(self, "clean_%s" % f.attname):
try:
getattr(self, "clean_%s" % f.attname)()
except ValidationError as e:
errors[f.name] = e.error_list
try:
super(BasePoint, self).clean_fields(exclude)
except ValidationError as e:
errors = e.update_error_dict(errors)
if errors:
raise ValidationError(errors)
class LandUseAgreementIdentifier(TimeStampedSafeDeleteModel):
"""
In Finnish: Maankäyttösopimustunnus
"""
# In Finnish: Tunnus
identifier = models.CharField(
verbose_name=_("Identifier"), max_length=255, blank=True, null=True
)
# In Finnish: Tyyppi
type = models.ForeignKey(
LandUseAgreementType,
verbose_name=_("Land use agreement type"),
related_name="+",
on_delete=models.PROTECT,
)
# In Finnish: Kaupunki
municipality = models.ForeignKey(
Municipality,
verbose_name=_("Municipality"),
related_name="+",
on_delete=models.PROTECT,
)
# In Finnish: Kaupunginosa
district = models.ForeignKey(
District, verbose_name=_("District"), related_name="+", on_delete=models.PROTECT
)
# In Finnish: Juokseva numero
sequence = models.PositiveIntegerField(verbose_name=_("Sequence number"))
class Meta:
verbose_name = pgettext_lazy("Model name", "Land use agreement identifier")
verbose_name_plural = pgettext_lazy(
"Model name", "Land use agreement identifiers"
)
unique_together = ("type", "municipality", "district", "sequence")
def save(self, *args, **kwargs):
self.identifier = str(self)
super(LandUseAgreementIdentifier, self).save(*args, **kwargs)
def __str__(self):
"""Returns the land use agreement identifier as a string
The Land use agreement identifier is constructed out of the type identifier, municipality,
district, and sequence, in that order. For example, the identifier
for a land use agreement (MA) in Helsinki (1), Vallila (22), and sequence
number 1 would be MA122-1.
"""
return "{}{}{:02}-{}".format(
self.type.identifier,
self.municipality.identifier,
int(self.district.identifier),
self.sequence,
)
class Pheno(models.Model):
name = models.CharField(max_length=200)
description = models.TextField(blank=True, null=True)
order = models.PositiveIntegerField(default=0)
image = models.FileField("Image", upload_to="pheno", null=True, blank=True, help_text="Upload phase image")
def __unicode__(self):
return u"%s" % (self.name)
class Hit(models.Model):
session = models.ForeignKey(Session)
location = models.ForeignKey('accounts.Location', null=True)
path = models.CharField(max_length=255)
referrer = models.TextField(blank=True)
verb = models.CharField(max_length=6)
response_code = models.PositiveIntegerField()
timestamp = models.DateTimeField(default=datetime.now)
ip_address = models.IPAddressField()
coords = models.PointField(null=True)
hit_number = models.PositiveIntegerField()
objects = HitManager()
def save(self, *args, **kwargs):
g = GeoIP()
self.coords = g.geos(self.ip_address)
super(Hit, self).save(*args, **kwargs)
class Room(BaseModel):
"""部屋を表す"""
building = models.ForeignKey(Building, on_delete=models.CASCADE)
floor = models.PositiveIntegerField()
class Meta:
verbose_name = "教室"
verbose_name_plural = "教室"
class Attachment (OrderedModelMixin, CloneableModelMixin, TimeStampedModel):
url = models.URLField(max_length=2048)
thumbnail_url = models.URLField(max_length=2048, blank=True, null=True)
label = models.TextField(blank=True)
description = models.TextField(blank=True)
type = models.CharField(max_length=256, blank=True)
index = models.PositiveIntegerField(blank=True)
attached_to_type = models.ForeignKey('contenttypes.ContentType')
attached_to_id = models.PositiveIntegerField()
attached_to = GenericForeignKey('attached_to_type', 'attached_to_id')
class Meta:
ordering = ('attached_to_type', 'attached_to_id', 'index',)
def get_siblings(self):
return self.attached_to.attachments.all()
class Transit_shape(models.Model):
shape_id = models.CharField(max_length=10, db_index=True)
lat = models.FloatField()
lon = models.FloatField()
sequence = models.PositiveIntegerField()
def __unicode__(self):
return self.shape_id + '' + self.sequence
class Reservation(models.Model):
camper = models.ForeignKey('Camper',
related_name='camper_id',
on_delete=models.DO_NOTHING)
place = models.ForeignKey('Place',
related_name='place_id',
on_delete=models.DO_NOTHING)
status = models.PositiveIntegerField()
class ProjectPhaseFieldSetAttributeIndex(models.Model):
index = models.PositiveIntegerField(verbose_name=_("index"), default=0)
phase = models.ForeignKey(ProjectPhase, on_delete=models.CASCADE)
attribute = models.ForeignKey(FieldSetAttribute, on_delete=models.CASCADE)
unique_together = ("attribute", "phase")
def __str__(self):
return f"{self.attribute} {self.phase} {self.index}"
class ContactReq(models.Model):
user = models.ForeignKey(User, related_name='contactreq_users')
otheruser = models.ForeignKey(User, related_name='contactreq_otherusers')
req_type = models.PositiveIntegerField(default=0)
date = models.DateTimeField(auto_now_add=True)
def __unicode__(self):
return "{} - {}".format(self.user, self.otheruser)
class Meeting(models.Model):
policymaker = models.ForeignKey(
Policymaker, help_text='Policymaker or other organization')
date = models.DateField(db_index=True, help_text='Date of the meeting')
number = models.PositiveIntegerField(
help_text='Meeting number for the policymaker')
year = models.PositiveIntegerField(help_text='Year the meeting is held')
issues = models.ManyToManyField('Issue', through='AgendaItem')
minutes = models.BooleanField(
default=False, help_text='Meeting minutes document available')
def __unicode__(self):
return u"%s %d/%d (%s)" % (self.policymaker, self.number, self.year,
self.date)
class Meta:
unique_together = (('policymaker', 'year', 'number'), )
class Course(models.Model):
"""
The course model describes a course at Oregon state.
This includes the course number (ie. 312 for CS312)
the name (ie. Linux System Administration)
the crn (ie. 98765)
the term (ie. Winter)
the year (ie. 2016)
the department (ie. CS)
"""
course_num = models.PositiveIntegerField()
name = models.TextField()
crn = models.PositiveIntegerField()
term = models.TextField()
year = models.DateField()
dept = models.ForeignKey('Department', null=False, blank=False)
