class Image(BaseCollectionItem):
file = models.FileField(
upload_to=upload_img_to,
null=False,
blank=False,
storage=DoubleExtensionStorage(),
verbose_name='File with the unthresholded map (.img, .nii, .nii.gz)')
figure = models.CharField(
help_text=
"Which figure in the corresponding paper was this map displayed in?",
verbose_name="Corresponding figure",
max_length=200,
null=True,
blank=True)
thumbnail = models.FileField(
help_text="The orthogonal view thumbnail path of the nifti image",
null=True,
blank=True,
upload_to=upload_img_to,
verbose_name='Image orthogonal view thumbnail 2D bitmap',
storage=DoubleExtensionStorage())
reduced_representation = models.FileField(
help_text=
("Binary file with the vector of in brain values resampled to lower resolution"
),
verbose_name="Reduced representation of the image",
null=True,
blank=True,
upload_to=upload_img_to,
storage=OverwriteStorage())
data = hstore.DictionaryField(blank=True, null=True)
hstore_objects = hstore.HStoreManager()
def get_absolute_url(self):
return_args = [str(self.id)]
url_name = 'image_details'
if self.collection.private:
return_args.insert(0, str(self.collection.private_token))
url_name = 'private_image_details'
return reverse(url_name, args=return_args)
def get_thumbnail_url(self):
try:
url = self.thumbnail.url
except ValueError:
url = os.path.abspath(
os.path.join("/static", "images", "glass_brain_empty.jpg"))
return url
@classmethod
def create(cls, my_file, my_file_name, my_name, my_desc, my_collection_pk,
my_map_type):
my_collection = Collection.objects.get(pk=my_collection_pk)
# Copy the nifti file into the proper location
image = cls(description=my_desc,
name=my_name,
collection=my_collection)
f = open(my_file)
niftiFile = File(f)
image.file.save(my_file_name, niftiFile)
# If a .img file was loaded then load the correspoding .hdr file as well
_, ext = os.path.splitext(my_file_name)
print ext
if ext in ['.img']:
f = open(my_file[:-3] + "hdr")
hdrFile = File(f)
image.hdr_file.save(my_file_name[:-3] + "hdr", hdrFile)
image.map_type = my_map_type
# create JSON file for neurosynth viewer
if os.path.exists(image.file.path):
nifti_gz_file = ".".join(
image.file.path.split(".")[:-1]) + '.nii.gz'
nii = nb.load(image.file.path)
nb.save(nii, nifti_gz_file)
f = open(nifti_gz_file)
image.nifti_gz_file.save(nifti_gz_file.split(os.path.sep)[-1],
File(f),
save=False)
image.save()
return image
# Celery task to generate glass brain image on new/update
def save(self):
file_changed = False
collection_changed = False
if self.pk is not None:
old_pk = Image.objects.get(pk=self.pk)
if old_pk.file != self.file:
file_changed = True
if old_pk.collection != self.collection:
collection_changed = True
do_update = True if file_changed else False
new_image = True if self.pk is None else False
super(Image, self).save()
if (do_update or new_image
) and self.collection and self.collection.private == False:
# Generate glass brain image
generate_glassbrain_image.apply_async([self.pk])
if collection_changed:
for field_name in self._meta.get_all_field_names():
field_instance = getattr(self, field_name)
if field_instance and isinstance(field_instance, FieldFile):
old_path = field_instance.path
new_name = upload_img_to(
self,
field_instance.name.split("/")[-1])
new_name = field_instance.storage.get_available_name(
new_name)
new_path = field_instance.storage.path(new_name)
if not os.path.exists(os.path.dirname(new_path)):
os.mkdir(os.path.dirname(new_path))
shutil.copy(old_path, new_path)
field_instance.name = new_name
assert (old_path != new_path)
os.remove(old_path)
super(Image, self).save()
class Job(CommonFieldsMixin):
"""Job post associated with project."""
related_name = 'jobs'
related_query_name = 'job'
created_by = models.ForeignKey(User,
db_index=True,
related_name='created_jobs',
related_query_name='created_job',
on_delete=models.CASCADE)
group = models.ForeignKey(Group,
null=True,
blank=True,
related_name=related_name,
related_query_name=related_query_name)
applicants = models.ManyToManyField(User,
through='application.Application',
related_name=related_name,
related_query_name=related_query_name)
role_position = models.CharField(
null=True,
blank=True,
max_length=255,
help_text=
'For eg. lead character, supporting character, background dancer etc.')
ages = IntegerRangeField(null=True,
blank=True,
help_text='Age range required for this role.')
required_gender = models.CharField(max_length=2,
choices=choices.GENDER_CHOICES,
default=choices.NOT_SPECIFIED)
required_tokens = models.IntegerField(
default=5,
help_text='How much tokens user needs to have to apply to this job.')
location = models.ForeignKey(
City,
null=True,
blank=True,
help_text="Location of user's project experience.")
required_information_to_apply = hstore.DictionaryField(null=True,
blank=True)
reason_for_rejection = models.CharField(
max_length=255,
null=True,
blank=True,
help_text='Reason why the job was rejected/unapproved by stageroute.')
submission_deadline = models.DateField(
null=True, blank=True, help_text='Date for the job deadline.')
status = models.CharField(max_length=2,
choices=choices.JOB_STATE_CHOICES,
default=choices.PENDING_APPROVAL)
number_of_vacancies = models.IntegerField(
default=1, help_text='How many positions are open for this job.')
budgets = IntegerRangeField(
null=True,
blank=True,
help_text='budget range amount to be spent on the job.')
featured = models.BooleanField(default=False, help_text='Is job featured.')
skin_type = models.CharField(max_length=50,
null=True,
blank=True,
default=choices.DOES_NOT_MATTER,
choices=choices.SKIN_TYPE_CHOICES,
help_text='Preferred skin type.')
hair_type = models.CharField(max_length=50,
null=True,
blank=True,
default=choices.DOES_NOT_MATTER,
choices=choices.HAIR_TYPE_CHOICES,
help_text='Preferred hair type.')
eye_color = models.CharField(max_length=50,
default=choices.DOES_NOT_MATTER,
null=True,
blank=True,
choices=choices.EYE_COLOR_CHOICES,
help_text='Peferred eye color.')
hair_color = models.CharField(max_length=50,
default=choices.DOES_NOT_MATTER,
null=True,
blank=True,
choices=choices.HAIR_COLOR_CHOICES,
help_text='Peferred eye color.')
hair_style = models.CharField(max_length=50,
default=choices.DOES_NOT_MATTER,
null=True,
blank=True,
choices=choices.HAIR_STYLE_CHOICES,
help_text='Peferred eye color.')
heights = FloatRangeField(null=True,
blank=True,
help_text='Range of height required.')
body_type = models.CharField(max_length=50,
null=True,
blank=True,
default=choices.DOES_NOT_MATTER,
choices=choices.BODY_TYPES)
language = models.CharField(max_length=50,
null=True,
blank=True,
default=choices.DOES_NOT_MATTER,
choices=choices.LANGUAGE_CHOICES,
help_text='Preferred languages.')
job_type = models.CharField(max_length=50,
null=True,
blank=True,
choices=choices.JOB_TYPE_CHOICES,
help_text='Type of job.')
auditions_per_day = models.IntegerField(
null=True,
blank=True,
help_text='Number of auditions to do per day for this job.')
audition_range = DateRangeField(null=True,
blank=True,
help_text='Audition range')
job_owner_email = models.EmailField(
null=True,
blank=True,
help_text='Should be valid email, e.g. [email protected]',
)
job_owner_phone = models.CharField(max_length=10,
null=True,
blank=True,
db_index=True,
help_text="User's phone number.")
notes = models.CharField(
max_length=255,
null=True,
blank=True,
help_text="Useful for job posters. A quick note they can refere later."
)
field_history = FieldHistoryTracker(['status'])
related_query_name = 'jobs'
images = GenericRelation(Image, related_query_name=related_query_name)
videos = GenericRelation(Video, related_query_name=related_query_name)
audios = GenericRelation(Audio, related_query_name=related_query_name)
objects = hstore.HStoreManager()
def __unicode__(self):
"""unicode."""
return self.title
class HStoreModel(models.Model):
objects = hstore.HStoreManager()
class Meta:
abstract = True
class Account(models.Model):
""" NAV's basic account model"""
DEFAULT_ACCOUNT = 0
ADMIN_ACCOUNT = 1
# An overview of current preferences.
# They should start with PREFERENCE_KEY
PREFERENCE_KEY_LANGUAGE = 'language' # AlertProfiles
PREFERENCE_KEY_STATUS = 'status-preferences'
PREFERENCE_KEY_WIDGET_COLUMNS = 'widget_columns'
PREFERENCE_KEY_REPORT_PAGE_SIZE = 'report_page_size'
PREFERENCE_KEY_WIDGET_DISPLAY_DENSITY = 'widget_display_density'
# FIXME get this from setting.
MIN_PASSWD_LENGTH = 8
login = VarcharField(unique=True)
name = VarcharField()
password = VarcharField()
ext_sync = VarcharField()
preferences = hstore.DictionaryField()
objects = hstore.HStoreManager()
organizations = models.ManyToManyField(Organization, db_table='accountorg')
class Meta(object):
db_table = u'account'
ordering = ('login', )
def __unicode__(self):
return self.login
def get_active_profile(self):
"""Returns the account's active alert profile"""
try:
return self.alertpreference.active_profile
except (AlertPreference.DoesNotExist, AlertProfile.DoesNotExist):
pass
def get_groups(self):
"""Fetches and returns this users groups.
Also stores groups in this object for later use.
"""
try:
return self._cached_groups
except AttributeError:
self._cached_groups = self.accountgroup_set.values_list('id',
flat=True)
return self._cached_groups
def get_privileges(self):
"""Fetches privileges for this users groups.
Also stores privileges in this object for later use.
"""
try:
return self._cached_privileges
except AttributeError:
self._cached_privileges = Privilege.objects.filter(
group__in=self.get_groups())
return self._cached_privileges
def get_tools(self):
"""Get the tool list for this account"""
return [
tool for tool in self.accounttool_set.all().order_by('priority')
if self.has_perm('web_access', tool.tool.uri)
]
def has_perm(self, action, target):
"""Checks if user has permission to do action on target."""
groups = self.get_groups()
privileges = self.get_privileges()
if AccountGroup.ADMIN_GROUP in groups:
return True
elif privileges.count() == 0:
return False
elif action == 'web_access':
for privilege in privileges:
regexp = re.compile(privilege.target)
if regexp.search(target):
return True
return False
else:
return privileges.filter(target=target).count() > 0
def is_system_account(self):
"""Is this system (undeleteable) account?"""
return self.id < 1000
def is_default_account(self):
"""Is this the anonymous user account?"""
return self.id == self.DEFAULT_ACCOUNT
def is_admin_account(self):
"""Is this the admin account?"""
return self.id == self.ADMIN_ACCOUNT
def is_admin(self):
"""Has this user administrator rights?"""
return self.has_perm(None, None)
@sensitive_variables('password')
def set_password(self, password):
"""Sets user password. Copied from nav.db.navprofiles"""
if len(password.strip()):
pw_hash = nav.pwhash.Hash(password=password)
self.password = str(pw_hash)
else:
self.password = ''
@sensitive_variables('password')
def check_password(self, password):
"""
Return True if the submitted authentication tokens are valid
for this Account. In simpler terms; when password
authentication is used, this method compares the given
password with the one stored for this account and returns true
if they are equal. If the stored password is blank, we
interpret this as: 'The user is not allowed to log in'
In the future, this could be extended to accept other types of
authentication tokens, such as personal certificates or
whatever.
Copied from nav.db.navprofiles
"""
# FIXME If password is old style NAV MD5, shouldn't we update the
# password in the database to be new style password?
if not self.locked:
stored_hash = nav.pwhash.Hash()
try:
stored_hash.set_hash(self.password)
except nav.pwhash.InvalidHashStringError:
# Probably an old style NAV password hash, get out
# of here and check it the old way
pass
else:
return stored_hash.verify(password)
# If the stored password looks like an old-style NAV MD5
# hash we compute the MD5 hash of the supplied password
# for comparison.
if self.password[:3] == 'md5':
pw_hash = md5(password)
return pw_hash.hexdigest() == self.password[3:]
else:
return password == self.password
else:
return False
@property
def locked(self):
return not self.password or self.password.startswith('!')
@locked.setter
def locked(self, value):
if not value and self.password.startswith('!'):
self.password = self.password[1:]
elif value and not self.password.startswith('!'):
self.password = '******' + self.password
class Order(BaseOrder):
FEEDBACK_CHOICES = (('UP', 'Happy'), ('DOWN', 'Unhappy'))
coffee = models.ForeignKey(CoffeeType)
different = models.BooleanField(verbose_name='Different?', default=False)
amount = models.DecimalField(verbose_name='Amount',
max_digits=6,
decimal_places=2,
default=18)
interval = models.PositiveIntegerField(verbose_name='Shipping Interval',
default=14)
recurrent = models.BooleanField(verbose_name='Recurrent?', default=False)
# TODO: move existing feedback to review and remove it
feedback = models.CharField(max_length=16,
choices=FEEDBACK_CHOICES,
null=True,
blank=True)
brew = models.ForeignKey(BrewMethod)
package = models.CharField(verbose_name='Packaging method',
max_length=16,
choices=Preferences.PACKAGE_CHOICES,
default=Preferences.GRINDED)
details = hstore.DictionaryField(default={}, blank=True)
objects = hstore.HStoreManager()
resent = models.BooleanField(verbose_name='Resent Order?', default=False)
custom_price = models.BooleanField(verbose_name='Custom Price?',
default=False)
def __unicode__(self):
return '[{}] {} | {} | {} | {} | {}'.format(
self.id,
self.get_status_display(),
timezone.localtime(self.date).strftime('%b, %d (%H:%M)'),
timezone.localtime(self.shipping_date).strftime('%b, %d (%H:%M)'),
self.customer,
self.coffee,
)
def save(self, *args, **kwargs):
if (self.coffee.is_discovery_pack
and 'discovery_coffees' not in self.details):
self.update_discovery_coffees(commit=False)
super(Order, self).save(*args, **kwargs)
@property
def is_editable(self):
now = CTZ.normalize(timezone.now())
is_friday = now.isoweekday() == 5
shipping_date_is_monday = self.shipping_date.isoweekday() == 1
next_48h = now + timedelta(hours=48)
next_96h = now + timedelta(hours=96)
if (self.recurrent and not (is_friday and shipping_date_is_monday
and next_96h > self.shipping_date)
and (next_48h < self.shipping_date)):
return True
return False
@property
def is_paused(self):
return self.status == self.PAUSED
@property
def is_first_order(self):
"""Check if this order is the first customer order."""
is_first = False
try:
is_first = self.id == self.customer.orders.earliest('id').id
except Order.DoesNotExist:
pass
return is_first
def hours_to_change(self):
"""Return hours left to make changes to this order."""
uneditable_at = self.shipping_date - timedelta(hours=48)
delta = CTZ.normalize(uneditable_at) - CTZ.normalize(timezone.now())
delta_hrs = int(delta.total_seconds() / 3600)
return 1 if delta_hrs == 0 else delta_hrs
def get_next_shipping_date(self, after=None):
now = after or CTZ.normalize(timezone.now())
possible_day = now + timedelta(days=self.interval)
day = possible_day.isoweekday()
today = possible_day.replace(hour=12,
minute=0,
second=0,
microsecond=0)
# noon = now.replace(hour=12, minute=0, second=0, microsecond=0)
# morning = True if now < noon else False
# Mon, Tue, Wed, Thu, Fri
if day in range(1, 6):
# return today if morning else tomorrow
return today
# Saturday
elif day == 6:
return today + timedelta(days=2)
# Sunday
elif day == 7:
return today + timedelta(days=1)
def get_after_next_shipping_date(self):
return self.get_next_shipping_date(after=self.shipping_date)
def get_discovery_coffee_ids(self):
return json.loads(self.details['discovery_coffees'])
def update_discovery_coffees(self, commit=True):
self.details['discovery_coffees'] = [
c.id for c in (CoffeeType.objects.discovery_pack(self.customer))
]
if commit:
self.save(update_fields=['details'])
@cached_property
def discovery_coffees(self):
coffee_ids = self.get_discovery_coffee_ids()
coffees = CoffeeType.objects.filter(id__in=coffee_ids)
reviews = {
review.coffee.id: review
for review in self.reviews.filter(coffee_id__in=coffee_ids)
}
for coffee in coffees:
coffee.review = reviews.get(coffee.id, {})
return coffees
class Bio(models.Model):
"""Bio stores physical attributes and contact details for user."""
person = models.OneToOneField(Person,
related_name='bio',
related_query_name='bio',
on_delete=models.CASCADE)
# hstore field for storing person's physical attributes.
# http://djangonauts.github.io/django-hstore/#_python_api
data = hstore.DictionaryField(schema=[
{
'name': 'street_address',
'class': 'CharField',
'kwargs': {
'blank': True,
'max_length': 255,
'null': True,
}
},
{
'name': 'hair_color',
'class': 'CharField',
'kwargs': {
'default':
'Black',
'blank':
True,
'max_length':
20,
'null':
True,
'choices': (
("black", "black"),
("dark_brown", "dark_brown"),
("light_brown", "light_brown"),
("blonde", "blonde"),
("red", "red"),
("grey", "grey"),
("white", "white"),
('does_not_matter', ''),
)
}
},
{
'name': 'eye_color',
'class': 'CharField',
'kwargs': {
'blank':
True,
'max_length':
20,
'null':
True,
'choices': (
("black", "black"),
("blue", "blue"),
("dark_brown", "dark_brown"),
("light_brown", "light_brown"),
("green", "green"),
("grey", "grey"),
("violet", "violet"),
("hazel", "hazel"),
('does_not_matter', ''),
)
},
},
{
'name': 'height',
'class': 'FloatField',
'kwargs': {
'blank': True,
'null': True,
}
},
{
'name': 'waist',
'class': 'IntegerField',
'kwargs': {
'blank': True,
'null': True,
}
},
{
'name': 'shoulders',
'class': 'IntegerField',
'kwargs': {
'blank': True,
'null': True,
}
},
{
'name': 'chest',
'class': 'IntegerField',
'kwargs': {
'blank': True,
'null': True,
}
},
{
'name': 'hips',
'class': 'IntegerField',
'kwargs': {
'blank': True,
'null': True,
}
},
{
'name': 'shoe_size',
'class': 'FloatField',
'kwargs': {
'blank': True,
'null': True,
}
},
{
'name': 'hair_style',
'class': 'CharField',
'kwargs': {
'blank':
True,
'max_length':
50,
'null':
True,
'choices':
(("army_cut", "army_cut"), ("normal", "normal"),
("slightly_long", "slightly_long"), ("shoulder_length",
"shoulder_length"),
("partially_bald", "partially_bald"), ("completely_bald",
"completely_bald"),
("boy_cut", "boy_cut"), ("bust_length", "bust_length"),
("waist_length", "waist_length"),
("knee_length", "knee_length"), ('does_not_matter', ''))
}
},
{
'name': 'hair_type',
'class': 'CharField',
'kwargs': {
'blank':
True,
'max_length':
50,
'null':
True,
'choices': (('straight',
'straight'), ('wavy', 'wavy'), ('curly', 'curly'),
('bald', 'bald'), ('half_bald', 'half_bald'),
('scanty', 'scanty'), ('does_not_matter', ''))
}
},
{
'name': 'skin_type',
'class': 'CharField',
'kwargs': {
'blank':
True,
'max_length':
50,
'null':
True,
'choices':
(("very_fair", "very_fair"), ("fair", "fair"),
("wheatish", "wheatish"), ("dusky", "dusky"),
("dark", "dark"), ("very_dark",
"very_dark"), ('does_not_matter', ''))
}
},
{
'name': 'body_type',
'class': 'CharField',
'kwargs': {
'blank':
True,
'max_length':
50,
'null':
True,
'choices':
(('skinny', 'skinny'), ('bulky', 'bulky'), ('slim', 'slim'),
('athletic', 'athletic'), ('muscular', 'muscular'),
('curvy', 'curvy'), ('heavy', 'heavy'), ('very_heavy',
'very_heavy'),
('very_fat', 'very_fat'), ('does_not_matter', ''))
}
},
],
db_index=True)
zipcode = models.ForeignKey(PostalCode, null=True, blank=True)
objects = hstore.HStoreManager()
class BasicHStoreData(models.Model):
hsdata = hstore.DictionaryField()
objects = hstore.HStoreManager()
class Card(models.Model):
_data = hstore.DictionaryField()
last_data_update = models.DateTimeField()
_prices = hstore.DictionaryField()
last_prices_update = models.DateTimeField()
objects = hstore.HStoreManager()
def __unicode__(self):
card = "Card %s (updated %s)" % (str(
self._data), self.last_data_update)
prices = "Prices %s (updated %s)" % (str(
self._prices), self.last_prices_update)
return "%s\n%s" % (card, prices)
def set_data(self, value):
self._data = self.prepare_hstore(value)
self.last_data_update = datetime.now()
def get_data(self):
if datetime.now() - self.last_data_update > UPDATE_TIMES['data']:
self._update_data()
if not self._data.get('link') and 'id' in self._data:
self._data['link'] = get_link(self._data['id'])
self.save()
return self.load_hstore(self._data)
data = property(get_data, set_data)
def set_prices(self, value):
self._prices = self.prepare_hstore(value)
self.last_prices_update = datetime.now()
def get_prices(self):
if datetime.now() - self.last_prices_update > UPDATE_TIMES['prices']:
self._update_prices()
return self.load_hstore(self._prices)
prices = property(get_prices, set_prices)
def _update_data(self):
self.last_data_update = datetime.now()
print 'Update data'
def _update_prices(self):
self.last_prices_update = datetime.now()
print 'Update prices'
@classmethod
def freesearch(cls, text):
splitted = text.split(' ')
return cls.objects.raw(card_query, (splitted, len(splitted)))
def load_hstore(self, value):
for key in value:
if '&' in value[key] and key != 'link':
value[key] = value[key].split('&')
while value[key][-1] == '':
value[key] = value[key][:-1]
return value
def prepare_hstore(self, value):
for key in value:
if isinstance(value[key], list):
value[key] = '&'.join([smart_str(v) for v in value[key]])
if '&' not in value[key]:
value[key] = value[key] + '&'
value[key] = smart_str(value[key])
return value
class Experiment(models.Model):
must_have_attributes = [
'accession', 'secondaryaccession', 'name', 'releasedate',
'lastupdatedate', 'samples'
]
must_have_attributes_map = {
'accession': 'accession',
'secondaryaccession': 'secondary accession',
'name': 'name',
'experimenttype': 'experiment type',
'releasedate': 'release date',
'lastupdatedate': 'last update date',
'samples': 'samples'
}
extra_attributes = ['microarrays', 'status']
data = hstore.DictionaryField(db_index=True)
objects = hstore.HStoreManager()
history = HistoricalRecords()
samples = models.ManyToManyField('Sample')
microarrays = models.ManyToManyField('Microarray')
def find(exp):
return Experiment.objects.filter(data__contains={
'accession': exp
}).first()
def samples(self):
return Sample.objects.filter(experiment=self)
def sample_attributes(self):
"""get all attributes for all samples in experiment"""
return SampleAttribute.objects.filter(sample__experiment=self)
def __unicode__(self):
to_print = 'accession'
if to_print in self.data:
return self.data[to_print]
else:
return 'some experiment'
def __str__(self):
to_print = 'accession'
if to_print in self.data:
# print("self data",type(self.data))
return self.data[to_print]
else:
return 'some experiment'
def to_dict(self, pretty_attributes=True):
"""
Create dict of all meaningful characteristics of the Experiment
"""
attributes = {}
for attribute in self.must_have_attributes:
if attribute in self.data:
if pretty_attributes:
attributes[self.must_have_attributes_map[attribute]] = \
self.data[attribute]
else:
attributes[attribute] = self.data[attribute]
attributes['microarrays'] = self.get_microarrays_lst()
attributes['status'] = self.cached_status()
return attributes
def to_list_of_dicts(pretty_attributes=True):
exps = Experiment.objects.all()
list_of_dicts = []
for exp in exps:
list_of_dicts.append(exp.to_dict(pretty_attributes))
return list_of_dicts
def add_or_replace(data):
obj, some_bool = Experiment.objects.get_or_create(
data__contains={'accession': data['accession']})
obj.data = data
obj.save()
return obj
def get_microarrays_lst(self):
lst = [m.data['name'] for m in self.microarrays.all()]
return ', '.join(lst)
def is_excluded(self):
return 'excluded' in self.data
def is_mail_received():
return 'mail received' in self.data
def is_unified(self):
exp_samples = self.samples()
has_empty_name = SampleAttribute.objects.filter(
sample__in=exp_samples, unificated_name=None).exists()
has_empty_value = SampleAttribute.objects.filter(
sample__in=exp_samples, unificated_value=None).exists()
if has_empty_name or has_empty_value:
return False
else:
return True
def set_has_minimal(self):
if self.has_minimal():
self.data['has minimal'] = 'true'
else:
self.data['has minimal'] = 'false'
self.save()
def get_has_minimal(self):
if 'has minimal' in self.data:
if self.data['has minimal'] == 'true':
return True
else:
return False
return False
def has_minimal(self):
"""
check whether experiment has minimal sample data,
needed for sample comparison
"""
# import time
# timestart = time.time()
# print(self, "start")
bspecimen = StandardName.objects.get(name="Biological Specimen").id
diagnosis = StandardName.objects.get(name="Diagnosis").id
age = StandardName.objects.get(name="Gestational Age").id
age_exp = StandardName.objects.get(
name="Gestational Age at Time of Sampling").id
age_avg = StandardName.objects.get(name="Average Gestational Age").id
age_cat = StandardName.objects.get(name="Gestational Age Category").id
attributes = SampleAttribute.objects.filter(
Q(unificated_name=bspecimen) | Q(unificated_name=diagnosis)
| Q(unificated_name=age) | Q(unificated_name=age_avg)
| Q(unificated_name=age_exp) | Q(unificated_name=age_cat))
# timeq1 = time.time()
# print(timeq1-timestart)
samples = self.samples()
# timeq2 = time.time()
# print(timeq2-timestart)
for sample in samples:
sample_attributes = attributes.filter(sample=sample).values_list(
"unificated_name", flat=True)
if not (bspecimen in sample_attributes and \
diagnosis in sample_attributes and \
(age in sample_attributes or
age_exp in sample_attributes or
age_avg in sample_attributes or
age_cat in sample_attributes)):
for attr in sample_attributes:
print(StandardName.objects.get(id=attr))
# timeq3 = time.time()
# print(timeq3-timestart)
# print("end-")
return False
# timeq3 = time.time()
# print(timeq3-timestart)
# print("end+")
return True
def is_cell_line(self):
if SampleAttribute.objects.filter(
sample__in=self.samples(),
unificated_name__name="Cells, Cultured").exists():
return True
return False
def status(self):
status = []
# if 'status' in self.data:
# status.append(self.data['status'])
if self.is_unified():
status.append('Unified')
if 'mail sent' in self.data:
status.append('Mail Sent')
if 'mail received' in self.data:
status.append('Mail Received')
if self.is_cell_line():
status.append('Cell Сulture')
if self.has_minimal():
status.append('Has minimal sample data')
if 'excluded' in self.data:
status.append('Excluded')
return ", ".join(status)
def update_status(self):
self.data['status'] = self.status()
self.save()
def cached_status(self):
if 'status' not in self.data:
self.update_status()
return self.data['status']
class Survey(models.Model):
class Meta:
db_table = 'survey'
STATUS_CHOICES = (
('approved', 'Approved'),
('in_planning', 'In planning'),
('not_available', 'Not available'),
)
TRANSPORT_PARTS = (
('infrastructure', 'Transport infrastructure'),
('services', 'Transport services'),
)
TRANSPORT_MODES = (
('road', 'Road'),
('rail', 'Rail'),
('aviation', 'Aviation'),
('inland_water', 'Inland water shipping'),
('maritime', 'Maritime shipping'),
('urban_transport', 'Urban transport'),
)
IMPACTS = (
('temperatures', '(Extreme) Temperatures'),
('flooding', 'Flooding'),
('sea_level_rise', 'Sea level rise'),
('storms', 'Storms'),
('ice_snow', 'Ice and snow'),
('water_scarcity_droughts', 'Water scarcity and droughts'),
)
RELEVANT_CHOICES = (
('none', 'None'),
('low', 'low'),
('medium', 'medium'),
('high', 'high'),
('don\'t know', 'don\'t know'),
)
category = models.ForeignKey(Category)
country = models.ForeignKey('countries.Country')
user = models.ForeignKey('tach.User')
date = models.DateTimeField(auto_now=True)
status = models.CharField(max_length=50,
choices=STATUS_CHOICES,
null=True,
blank=True)
title = models.CharField(max_length=256, null=True, blank=True)
english_title = models.CharField(max_length=256, null=True, blank=True)
year = models.IntegerField(null=True, blank=True)
parts_considered = hstore.DictionaryField(null=True, blank=True)
transport_modes = hstore.DictionaryField(null=True, blank=True)
climate_change_impacts = hstore.DictionaryField(null=True, blank=True)
responsible_organisation = models.CharField(max_length=256,
null=True,
blank=True)
link = models.CharField(max_length=256, null=True, blank=True)
language = models.ForeignKey(Language, null=True, blank=True)
contact = models.CharField(max_length=256, null=True, blank=True)
focus = models.CharField(max_length=256, null=True, blank=True)
section_a_info = models.TextField(null=True, blank=True)
section_a_comment = models.TextField(null=True, blank=True)
section_b_info = models.TextField(null=True, blank=True)
section_b_comment = models.TextField(null=True, blank=True)
section_c2 = models.TextField(null=True, blank=True)
section_d_comment = models.TextField(null=True, blank=True)
section_c_comment = models.TextField(null=True, blank=True)
section_e_comment = models.TextField(null=True, blank=True)
area_of_expertise = models.CharField(max_length=256, null=True, blank=True)
# section D
adaptation_strategy = models.CharField(max_length=50,
choices=STATUS_CHOICES,
null=True,
blank=True)
transport_information = models.CharField(max_length=50,
choices=STATUS_CHOICES,
null=True,
blank=True)
trans_national_cooperation = models.CharField(max_length=50,
choices=STATUS_CHOICES,
null=True,
blank=True)
stakeholders_cooperaton = models.CharField(max_length=50,
choices=STATUS_CHOICES,
null=True,
blank=True)
integration_of_climate_change = models.CharField(max_length=50,
choices=STATUS_CHOICES,
null=True,
blank=True)
funding = models.CharField(max_length=50,
choices=STATUS_CHOICES,
null=True,
blank=True)
revision_of_design = models.CharField(max_length=50,
choices=STATUS_CHOICES,
null=True,
blank=True)
climate_proof = models.CharField(max_length=50,
choices=STATUS_CHOICES,
null=True,
blank=True)
development_methodologies = models.CharField(max_length=50,
choices=STATUS_CHOICES,
null=True,
blank=True)
data_collection = models.CharField(max_length=50,
choices=STATUS_CHOICES,
null=True,
blank=True)
transport_research = models.CharField(max_length=50,
choices=STATUS_CHOICES,
null=True,
blank=True)
lack_of_awareness = models.CharField(max_length=50,
choices=STATUS_CHOICES,
null=True,
blank=True)
knowledge_gaps = models.CharField(max_length=50,
choices=STATUS_CHOICES,
null=True,
blank=True)
data_gaps = models.CharField(max_length=50,
choices=STATUS_CHOICES,
null=True,
blank=True)
lack_of_training = models.CharField(max_length=50,
choices=STATUS_CHOICES,
null=True,
blank=True)
lack_of_capacities = models.CharField(max_length=50,
choices=STATUS_CHOICES,
null=True,
blank=True)
lack_of_resources = models.CharField(max_length=50,
choices=STATUS_CHOICES,
null=True,
blank=True)
access_to_funding = models.CharField(max_length=50,
choices=STATUS_CHOICES,
null=True,
blank=True)
lack_of_coordination = models.CharField(max_length=50,
choices=STATUS_CHOICES,
null=True,
blank=True)
awareness_lack_eu_level = models.CharField(max_length=50,
choices=STATUS_CHOICES,
null=True,
blank=True)
relevance = models.CharField(max_length=50,
choices=RELEVANT_CHOICES,
null=True,
blank=True)
d1_comments = models.TextField(null=True, blank=True)
d2_comments = models.TextField(null=True, blank=True)
objects = hstore.HStoreManager()
