def stash(self, item, user, ordering=1):
'''
Creates an association between the object and whatever the item
specified "ordering" arg is optional.
'''
from localground.apps.site.models import GenericAssociation
from localground.apps.site.models.abstract.base import \
BaseUploadedMedia
from localground.apps.lib.helpers import get_timestamp_no_milliseconds
if not issubclass(item.__class__, BaseUploadedMedia):
raise Exception(
'Only items of type Photo, Audio, Record, or Map Image \
can be appended.')
assoc = GenericAssociation(
source_type=self.get_content_type(),
source_id=self.id,
entity_type=item.get_content_type(),
entity_id=item.id,
ordering=ordering,
owner=user,
last_updated_by=user,
date_created=get_timestamp_no_milliseconds(),
time_stamp=get_timestamp_no_milliseconds()
)
assoc.save()
def save(self, *args, **kwargs):
is_new = self.pk is None
# 1. ensure that user doesn't inadvertently change the data type of the
# column
if is_new:
self.date_created = get_timestamp_no_milliseconds()
self.col_name_db = 'col_placeholder'
else:
o = Field.objects.get(id=self.id)
if o.data_type != self.data_type:
raise Exception(
'You are not allowed to change the column type of an existing column')
self.time_stamp = get_timestamp_no_milliseconds()
super(Field, self).save(*args, **kwargs)
# 2. ensure that the column name is unique, and add column to table:
if is_new:
self.col_name_db = 'col_%s' % self.id
super(Field, self).save(update_fields=['col_name_db'])
self.add_column_to_table()
# 3. reset the application cache with the new table structure:
self.form.remove_table_from_cache()
def append(self, item, user, ordering=1, turned_on=False):
'''
Creates an association between the object and whatever the item specified
"ordering" and "turned_on" args are optional.
'''
from localground.apps.site.models import GenericAssociation
from localground.apps.site.models.abstract.media import BaseUploadedMedia
from localground.apps.lib.helpers import get_timestamp_no_milliseconds
if not issubclass(item.__class__, BaseUploadedMedia):
raise Exception(
'Only items of type Photo, Audio, Record, or Map Image can be appended.')
assoc = GenericAssociation(
source_type=self.get_content_type(),
source_id=self.id,
entity_type=item.get_content_type(),
entity_id=item.id,
ordering=ordering,
turned_on=turned_on,
owner=user,
last_updated_by=user,
date_created=get_timestamp_no_milliseconds(),
time_stamp=get_timestamp_no_milliseconds()
)
assoc.save()
def save(self, user, *args, **kwargs):
is_new = self.pk is None
# 1. ensure that user doesn't inadvertently change the data type of
# the column
if is_new:
self.owner = user
self.date_created = get_timestamp_no_milliseconds()
self.last_updated_by = user
self.time_stamp = get_timestamp_no_milliseconds()
# self.project = self.form.project
super(self.__class__, self).save(*args, **kwargs)
def save(self, user, *args, **kwargs):
from localground.apps.lib.helpers import generic
is_new = self.pk is None
# 1. ensure that user doesn't inadvertently change the data type of the
# column
if is_new:
if not hasattr(self, 'owner'):
self.owner = user
self.date_created = get_timestamp_no_milliseconds()
self.last_updated_by = user
self.time_stamp = get_timestamp_no_milliseconds()
super(ImageOpts, self).save(*args, **kwargs)
def save(self, user=None, *args, **kwargs):
from localground.apps.lib.helpers import generic
is_new = self.pk is None
# 1. ensure that user doesn't inadvertently change the data type of the
# column
if is_new:
if not hasattr(self, 'owner') and user is not None:
self.owner = user
self.date_created = get_timestamp_no_milliseconds()
if user is not None:
self.last_updated_by = user
self.time_stamp = get_timestamp_no_milliseconds()
super(ImageOpts, self).save(*args, **kwargs)
def insert_form_data_record(self, form, project=None, photo=None, audio=None, name=None):
from django.contrib.gis.geos import Point
# create a marker:
lat = 37.87
lng = -122.28
record = form.TableModel()
record.point = Point(lng, lat, srid=4326)
if project:
record.project = project
# generate different dummy types depending on the data_type
for field in form.fields:
if field.data_type.id in [
models.DataType.INTEGER,
models.DataType.RATING]:
setattr(record, field.col_name, 5)
elif field.data_type.id == models.DataType.BOOL:
setattr(record, field.col_name, True)
elif field.data_type.id == models.DataType.DATE_TIME:
setattr(
record,
field.col_name,
get_timestamp_no_milliseconds())
elif field.data_type.id == models.DataType.DECIMAL:
setattr(record, field.col_name, 3.14159)
elif field.data_type.id == models.DataType.PHOTO:
setattr(record, field.col_name, photo)
elif field.data_type.id == models.DataType.AUDIO:
setattr(record, field.col_name, audio)
else:
setattr(record, field.col_name, name or 'some text')
record.save(user=self.user)
return record
def setUp(self):
BaseAbstractModelClassTest.setUp(self)
self.user_granted_permission = User.objects.create_user(
'tester2',
first_name='test',
email='',
password=self.user_password
)
self.user_not_granted_permission = User.objects.create_user(
'tester3',
first_name='otherPerson',
email='',
password='******'
)
self.model = UserAuthorityObject(
user=self.user_granted_permission,
authority=UserAuthority.objects.get(id=1),
granted_by=self.user,
time_stamp=get_timestamp_no_milliseconds(),
content_type=self.project.get_content_type(),
object_id=self.project.id
)
self.model.save()
self.object_type = self.model_name = self.pretty_name = 'user authority object'
self.model_name_plural = self.pretty_name_plural = 'user authority objects'
def save(self, user=None, *args, **kwargs):
from localground.apps.lib.helpers import generic
is_new = self.pk is None
# 1. ensure that user doesn't inadvertently change the data type of the
# column
if is_new:
if user and not hasattr(self, 'owner'):
self.owner = user
self.date_created = get_timestamp_no_milliseconds()
self.table_name = 'table_%s_%s' % (
self.owner.username.lower(), generic.generateID(num_digits=10))
if user:
self.last_updated_by = user
self.time_stamp = get_timestamp_no_milliseconds()
super(Dataset, self).save(*args, **kwargs)
def save(self, user=None, *args, **kwargs):
from localground.apps.lib.helpers import generic
is_new = self.pk is None
# 1. ensure that user doesn't inadvertently change the data type of the
# column
if is_new:
if user and not hasattr(self, 'owner'):
self.owner = user
self.date_created = get_timestamp_no_milliseconds()
self.table_name = 'table_%s_%s' % (
self.owner.username.lower(), generic.generateID(num_digits=10))
if user:
self.last_updated_by = user
self.time_stamp = get_timestamp_no_milliseconds()
super(Dataset, self).save(*args, **kwargs)
def _add_group_user(self, group, user, authority_id):
from localground.apps.site import models
uao = models.UserAuthorityObject(
object_id=group.id,
content_type=group.get_content_type(),
user=user,
authority=models.UserAuthority.objects.get(id=authority_id),
time_stamp=get_timestamp_no_milliseconds(),
granted_by=group.owner)
uao.save()
def grant_project_permissions_to_user(self, project, granted_to, authority_id=1):
uao = models.UserAuthorityObject()
uao.user = granted_to
uao.authority = models.UserAuthority.objects.get(id=authority_id)
uao.granted_by = project.owner
uao.time_stamp = get_timestamp_no_milliseconds()
uao.content_type = project.get_content_type()
uao.object_id = project.id
uao.save()
return uao
def _add_group_user(self, group, user, authority_id):
uao = models.UserAuthorityObject(
object_id=group.id,
content_type=group.get_content_type(),
user=user,
authority=models.UserAuthority.objects.get(id=authority_id),
time_stamp=get_timestamp_no_milliseconds(),
granted_by=group.owner
)
uao.save()
def test_add_fields_to_existing_form(self, **kwargs):
from localground.apps.site import models
d = {
'text_field': { 'type': Field.DataTypes.TEXT, 'test_val': 'Column Value 1' },
'integer_field': { 'type': Field.DataTypes.INTEGER, 'test_val': 8 },
'datetime_field': { 'type': Field.DataTypes.DATETIME, 'test_val': datetime.datetime.now() },
'boolean_field': { 'type': Field.DataTypes.BOOLEAN, 'test_val': True },
'decimal_field': { 'type': Field.DataTypes.DECIMAL, 'test_val': 1.5 },
'rating_field': { 'type': Field.DataTypes.RATING, 'test_val': 1 },
'photo_field': { 'type': Field.DataTypes.PHOTO, 'test_val': models.Photo.objects.get(id=1) },
'audio_field': { 'type': Field.DataTypes.AUDIO, 'test_val': models.Audio.objects.get(id=1) }
}
for key in d:
f = models.Field(col_alias=key,
data_type=models.DataType.objects.get(id=d[key]['type']),
ordering=1,
form=self.form,
owner=self.user,
last_updated_by=self.user
)
f.save()
d[key]['field'] = f
# clear cache
self.form.remove_table_from_cache()
self.assertEqual(len(d.keys()), len(self.form.fields))
# query the new form:
self.assertEqual(
len(self.form.TableModel.objects.get_objects(self.user)), 0)
# insert a record
timestamp = get_timestamp_no_milliseconds()
record = self.form.TableModel()
record.owner = self.user
# set record data before insert:
for key in d:
setattr(record, d[key]['field'].col_name, d[key]['test_val'])
record.project = self.project
record.save(user=self.user)
rec = self.form.TableModel.objects.get_objects(self.user)[0]
# check that the record data is the same after being re-queried from DB:
for key in d:
self.assertEqual(d[key]['test_val'], getattr(rec, d[key]['field'].col_name))
self.assertIsNotNone(rec.time_stamp)
self.assertIsNotNone(rec.date_created)
self.assertEqual(self.user, rec.owner)
self.assertEqual(self.user, rec.last_updated_by)
self.assertEqual(record.project, self.project)
def grant_project_permissions_to_user(self,
project,
granted_to,
authority_id=1):
from localground.apps.site import models
uao = models.UserAuthorityObject()
uao.user = granted_to
uao.authority = models.UserAuthority.objects.get(id=authority_id)
uao.granted_by = project.owner
uao.time_stamp = get_timestamp_no_milliseconds()
uao.content_type = project.get_content_type()
uao.object_id = project.id
uao.save()
return uao
def rotate_right(request, pk, format='html'):
context = {'request': request}
try:
photo = models.Photo.objects.get(id=pk)
photo.media_file_orig.storage.location = photo.get_storage_location()
photo.rotate_right()
photo.last_updated_by = request.user
photo.time_stamp = get_timestamp_no_milliseconds()
photo.save()
return Response(serializers.PhotoSerializer(photo, context=context).data,
status=status.HTTP_200_OK)
except models.Photo.DoesNotExist:
return Response(
{"error": "Photo #%s not found on the server" % pk}, status=status.HTTP_404_NOT_FOUND)
def _rotate(self, user, degrees):
from PIL import Image, ImageOps
import time
timestamp = int(time.time())
media_path = self.get_absolute_path()
# 1) do the rotation:
im = Image.open(media_path + self.file_name_new)
file_name, ext = os.path.splitext(self.file_name_new)
im = im.rotate(degrees)
im.save(media_path + self.file_name_new)
# 2) create thumbnails:
sizes = [1000, 500, 250, 128, 50, 20]
photo_paths = []
for s in sizes:
if s in [50, 25]:
# ensure that perfect squares:
im.thumbnail((s * 2, s * 2), Image.ANTIALIAS)
im = im.crop([0, 0, s - 2, s - 2])
im = ImageOps.expand(im, border=2, fill=(255, 255, 255, 255))
else:
im.thumbnail((s, s), Image.ANTIALIAS)
new_file_path = '%s_%s_%s%s' % (file_name, s, timestamp, ext)
im.save('%s%s' % (media_path, new_file_path))
photo_paths.append(new_file_path)
# 3) delete old, pre-rotated files on file systems:
file_paths = [
'%s%s' % (media_path, self.file_name_large),
'%s%s' % (media_path, self.file_name_medium),
'%s%s' % (media_path, self.file_name_medium_sm),
'%s%s' % (media_path, self.file_name_small),
'%s%s' % (media_path, self.file_name_marker_lg),
'%s%s' % (media_path, self.file_name_marker_sm)
]
for f in file_paths:
if os.path.exists(f) and f.find(settings.USER_MEDIA_DIR) > 0:
os.remove(f)
# 4) save pointers to new files in database:
self.file_name_large = photo_paths[0]
self.file_name_medium = photo_paths[1]
self.file_name_medium_sm = photo_paths[2]
self.file_name_small = photo_paths[3]
self.file_name_marker_lg = photo_paths[4]
self.file_name_marker_sm = photo_paths[5]
self.last_updated_by = user
self.time_stamp = get_timestamp_no_milliseconds()
self.save()
def rotate_right(request, pk, format='html'):
context = {'request': request}
try:
photo = models.Photo.objects.get(id=pk)
photo.media_file_orig.storage.location = photo.get_storage_location()
photo.rotate_right()
photo.last_updated_by = request.user
photo.time_stamp = get_timestamp_no_milliseconds()
photo.save()
return Response(serializers.PhotoSerializer(photo,
context=context).data,
status=status.HTTP_200_OK)
except models.Photo.DoesNotExist:
return Response({"error": "Photo #%s not found on the server" % pk},
status=status.HTTP_404_NOT_FOUND)
def save(self, *args, **kwargs):
is_new = self.pk is None
# 1. ensure that user doesn't inadvertently change the data type of the
# column
if is_new:
import random
random_string = ''.join(
random.sample('0123456789abcdefghijklmnopqrstuvwxyz', 8))
self.date_created = get_timestamp_no_milliseconds()
self.col_name_db = 'col_placeholder_' + random_string
else:
o = Field.objects.get(id=self.id)
if o.data_type != self.data_type:
raise Exception(
'You are not allowed to change the field type of an ' +
'existing field')
self.time_stamp = get_timestamp_no_milliseconds()
super(Field, self).save(*args, **kwargs)
# 2. ensure that the column name is unique, and add column to table:
self.col_name_db = self.unique_key
super(Field, self).save(update_fields=['col_name_db'])
def create_form_post_data(self):
lat, lng, description, color = 54.16, 60.4, \
'Test description1', 'FF0000'
vals = [
'a different test string', # TEXT
897, # INTEGER
get_timestamp_no_milliseconds(), # DATE_TIME
True, # BOOL
4.5, # DECIMAL
10 # RATING
]
d = {
'geometry': self.POINT,
'project_id': self.project.id
}
# add dynamic form values:
fields = self.form.fields
for i, field in enumerate(fields):
d[field.col_name] = vals[i]
return d
def add_record(self, dictionary, user, fields=None):
d = dictionary
e = self.TableModel()
if fields is None:
print('querying for fields...')
fields = self.fields
# populate content that exists for all dynamic tables:
e.project = d.get('project')
e.time_stamp = get_timestamp_no_milliseconds()
e.owner = user
e.point = d.get('point')
e.scan = d.get('scan')
e.last_updated_by = d.get('last_updated_by')
# populate ad hoc columns (variable across tables):
for n in fields:
e.__setattr__(n.col_name, d.get(n.col_name))
e.save(user=user)
self.save(user=user)
return e
def generate_photo(self, **kwargs):
user = self.user
project = self.project
image = Image.new('RGB', (200, 100))
tmp_file = 'test.jpg'
image.save(tmp_file)
author_string = 'Author of the media file'
tags = "j,k,l"
with open(tmp_file, 'rb') as data:
photo_data = {
'attribution': user.username,
'host': settings.SERVER_HOST,
'owner': user,
'last_updated_by': user,
'time_stamp': get_timestamp_no_milliseconds(),
'project': self.project
}
photo = models.Photo.objects.create(**photo_data)
media_path = photo.get_absolute_path()
photo.process_file(File(data))
return photo
def generate_photo(self, **kwargs):
user = self.user
project = self.project
image = Image.new('RGB', (200, 100))
tmp_file = 'test.jpg'
image.save(tmp_file)
author_string = 'Author of the media file'
tags = "j,k,l"
with open(tmp_file, 'rb') as data:
photo_data = {
'attribution': user.username,
'host': settings.SERVER_HOST,
'owner': user,
'last_updated_by': user,
'time_stamp': get_timestamp_no_milliseconds(),
'project': self.project
}
photo = models.Photo.objects.create(**photo_data)
media_path = photo.get_absolute_path()
photo.process_file(File(data))
return photo
def save_generic_relations(self, obj, entities):
'''
Saves all children:
'''
from localground.apps.lib.helpers import get_timestamp_no_milliseconds
import json
from django.db import connection, IntegrityError, DatabaseError
if entities:
entities = json.loads(entities)
source_type = self.model.get_content_type()
source_id = obj.id
# 1) clear out existing child media:
obj.entities.all().delete()
# 2) attach new child media:
for child in entities:
overlay_type = child.get('overlay_type')
entity_type = models.Base.get_model(
model_name=overlay_type
).get_content_type()
for id in child.get('ids'):
a = models.GenericAssociation(
source_id=source_id,
source_type=source_type,
entity_id=id, # entity['id'],
entity_type=entity_type,
owner=self.request.user,
last_updated_by=self.request.user,
time_stamp=get_timestamp_no_milliseconds(),
turned_on=True,
)
try:
a.save()
except IntegrityError as e:
self.warnings.append('duplicates removed')
connection._rollback()
def get_presave_update_dictionary(self):
return {
'last_updated_by': self.context.get('request').user,
'time_stamp': get_timestamp_no_milliseconds()
}
def create_update_group_with_sharing(
request,
action,
object_type_plural,
object_id=None,
embed=False,
template="profile/create_update_group.html",
base_template="base/profile.html",
):
"""
This view creates and updates permissions for views and projects. Parameters:
object_type: valid values are 'projects' or 'views'
object_id: Integer -- primary key to a Project or View object
embed: Whether or not it's an iframe:
In addition, this view also processes a UserAuthorityObject formset, which applies
user-level permissions to a particular project.
This form uses the contenttypes framework (so object-user permissions can
be arbitrarily assigned to more than one object). Helpful links here:
* http://hdknr.github.com/docs/django/modules/django/contrib/contenttypes/generic.html
* http://weispeaks.wordpress.com/2009/11/04/overcoming-limitations-in-django-using-generic-foreign-keys/
"""
from django.forms import models, formsets
from django.contrib.contenttypes import generic
from localground.apps.site.models import Base, UserAuthorityObject, UserAuthority
from localground.apps.site.forms import UserAuthorityObjectForm
from django.http import HttpResponseRedirect
r = request.POST or request.GET
ModelClass = Base.get_model(model_name_plural=object_type_plural)
GroupForm = ModelClass.get_form()
if action == "share":
GroupForm = ModelClass.sharing_form()
if embed:
base_template = "base/iframe.html"
prefix = "groupuser"
source_object = None
no_shared_users = True
extra = 0
# query for model object to update (if object_id is specified):
try:
if object_id is not None:
source_object = ModelClass.objects.get(id=object_id)
no_shared_users = len(source_object.users.all()) == 0
except ModelClass.DoesNotExist:
pass
if no_shared_users:
extra = 1
UserAuthorityObjectFormset = generic.generic_inlineformset_factory(
UserAuthorityObject,
form=UserAuthorityObjectForm,
formset=generic.BaseGenericInlineFormSet,
ct_field="content_type",
fk_field="object_id",
extra=extra,
can_delete=True,
)
extras = {}
if request.method == "POST":
form = GroupForm(request.POST, instance=source_object)
formset = UserAuthorityObjectFormset(request.POST, instance=source_object, prefix=prefix)
if formset.is_valid() and form.is_valid():
from django.contrib.contenttypes.models import ContentType
# ----------------------------
# PROJECT FORM POST-PROCESSING
# ----------------------------
instance = form.instance
instance.time_stamp = get_timestamp_no_milliseconds()
# determine ContentType:
app_label = instance._meta.app_label
model_name = ModelClass.__name__.lower()
content_type = ContentType.objects.get(app_label=app_label, model=model_name)
if instance.access_authority.id != 2:
instance.access_key = None
if instance.pk is None:
instance.owner = request.user
is_new = True
else:
orig = ModelClass.objects.get(id=object_id)
if orig.owner != instance.owner:
# ensure there's a UserAuthorityObject entry for the old owner for
# this object:
is_object_user = (
len(
UserAuthorityObject.objects.filter(user=orig.owner)
.filter(content_type=content_type)
.filter(object_id=object_id)
)
== 1
)
if not is_object_user:
previous_owner = UserAuthorityObject()
previous_owner.user = orig.owner
previous_owner.content_type = content_type
previous_owner.object_id = orig.id
previous_owner.authority = UserAuthority.objects.get(id=3)
previous_owner.granted_by = request.user
previous_owner.time_stamp = get_timestamp_no_milliseconds()
previous_owner.save()
instance.last_updated_by = request.user
instance.save()
source_object = instance
# -----------------------------------
# PROJECTUSER FORM(S) POST-PROCESSING
# -----------------------------------
marked_for_delete = formset.deleted_forms
for form in formset.forms:
if form.has_changed():
instance = form.instance
if not instance in formset.deleted_forms:
instance.granted_by = request.user
instance.time_stamp = get_timestamp_no_milliseconds()
instance.content_type = content_type
instance.object_id = source_object.id
instance.save()
if len(marked_for_delete) > 0:
formset.save()
# If success, determine which URL to redirect to (either update project or
# update permissions) so that form doesn't post twice:
# url = '{0}{1}/?success=true'.format(request.path, source_object.id)
# url = url.replace('create', 'update') #create URL should redirect
# to update URL
url = source_object.update_url()
if action == "share":
url = source_object.share_url()
if embed:
url += "embed/"
url += "?success=true"
return HttpResponseRedirect(url)
else:
extras.update(
{
"success": False,
"error_message": "There were errors when updating the %s information. \
Please review message(s) below."
% ModelClass.model_name,
}
)
else:
form = GroupForm(instance=source_object)
formset = UserAuthorityObjectFormset(instance=source_object, prefix=prefix)
extras.update(
{
"form": form,
"no_users": str(no_shared_users).lower(),
"formset": formset,
"prefix": prefix,
"source_object": source_object,
"object_name": ModelClass.model_name,
"parent_id": object_id,
"show_hidden_fields": True,
"base_template": base_template,
"embed": embed,
}
)
if source_object:
extras.update({"owner": source_object.owner.username})
if r.get("success", "false") in ["1", "true", "True"]:
extras.update(
{"success": True, "message": "The %s information was successfully updated." % ModelClass.model_name}
)
return render_to_response(template, extras, context_instance=RequestContext(request))
