def submit(request):
PhotoFormSet = formset_factory(PhotoForm, extra=1)
if request.method == 'POST':
storyform = StoryForm(request.POST, request.FILES)
photoformset = PhotoFormSet(request.POST, request.FILES)
if storyform.is_valid() and photoformset.is_valid():
s = Story(
title = storyform.cleaned_data['title'],
moderator = request.user
)
s.save();
for form in photoformset.cleaned_data:
image = form['image']
p = Photo(
name=s.title,
story=s,
image=image
)
p.save()
else:
storyform = StoryForm()
photoformset = PhotoFormSet()
return render(request, 'stories/submit.html', {'storyfrom': storyform, 'photoformset': photoformset})
def ghetto_fixtures(self):
from os.path import abspath, dirname, join
from django.contrib.auth.models import User
from django.core.files import File
from photos.models import Photo, PhotoSet
fixtures_dir = join(abspath(dirname(__file__)), "fixtures")
self.admin = User.objects.create_user('admin', '*****@*****.**', 's3cure!1')
self.set = PhotoSet.objects.create(name="default")
self.__photos = []
for i in range(1, 5):
name = "photo_{0}.jpg".format(i)
with open(join(fixtures_dir, name)) as f:
p = Photo(
title="Photo {0}".format(i),
photo_set=self.set)
p.image.save(name, File(f))
self.__photos.append(p)
p.save()
setattr(self, "photo_%d" % i, p)
def test_validation_fields(self):
photo = Photo(name="")
with self.assertRaises(IOError):
photo.save()
#@TODO:Criar teste para o upload usando o GoogleStorage
def post(self, request, *args, **kwargs):
# Ajax POST for file uploads
if request.is_ajax():
custom_post = QueryDict('temp_hash=%s' % request.POST.get('temp_hash'))
file_form = PhotoUploadForm(request.POST, request.FILES)
print(request.POST)
print(request.FILES)
if file_form.is_valid():
# file_form.save()
response = {'file': []}
for photo in request.FILES.getlist('file'):
# Create a new entry in our database
new_image = Photo(image=photo,
temp_hash=request.POST.get('temp_hash'))
# Save the image using the model's ImageField settings
new_image.save()
response['file'].append({
'name': '%s' % new_image.id,
'size': '%d' % request.FILES.__sizeof__(),
'url': '%s' % new_image.image.url,
'thumbnailUrl': '%s' % new_image.image.url,
'deleteUrl': '\/image\/delete\/%s' % new_image.id,
"deleteType": 'DELETE'
})
# return HttpResponse('{"status":"success"}', content_type='application/json')
return JsonResponse(response)
# return HttpResponse('{"status":"error: %s"}' % file_form.errors, content_type='application/json')
return JsonResponse({'response': file_form.errors, })
return super(MultiAttachmentMixin, self).post(request, *args, **kwargs)
def get_default_photo(self):
try:
return Photo.objects.filter(user_default=True)[0]
except IndexError:
user_fallback = "%s/photos/%s" % (settings.MEDIA_ROOT, "img_user_fallback.png")
try:
fp = open(user_fallback, "r")
image = Image.open(fp)
image.verify()
photo = Photo(user_default=True)
photo.save()
Photo.objects.filter(pk=photo.pk).update(image="photos/img_user_fallback.png")
photo = Photo.objects.get(pk=photo.pk)
fp.close()
return photo
except:
user_fallback = "%s/images/%s" % (settings.GLOBALS_STATIC_ROOT, "img_user_fallback.png")
fp = open(user_fallback, "r")
image = Image.open(fp)
image.verify()
fp2 = open(user_fallback, "r")
target_file = File(fp2)
name = "img_user_fallback.png"
photo = Photo(user_default=True)
photo.image.save(name, target_file, save=True)
fp.close()
fp2.close()
return photo
def send_photos(request):
if request.method == 'POST':
package = json.loads(request.body.decode('utf-8'))
feedbacks = package['feedbacks']
category_id = package['categoryId']
product_id = package['productId']
for feedback in feedbacks:
for image in feedback['images']:
photo = Photo(
url=image['url'],
width=image['width'],
height=image['height'],
item_id=product_id,
category_id=category_id,
feedback_id=feedback['feedbackId'],
)
try:
photo.save()
except Exception:
pass
response = HttpResponse("OK")
add_access_control_headers(response)
return response
def _create_photos(self):
# print(os.getcwd())
with open('photos/management/commands/test-photo.csv', 'r') as fh:
next(fh)
for line in fh:
image_url, dt = line.split(';')[1:3]
image_url = image_url[1:-1]
dt = dt.strip()[1:-1]
photo_dt = datetime.strptime(dt, '%Y-%m-%d %H:%M:%S')
r = requests.get(image_url, stream=True)
if r.status_code != requests.codes.ok:
continue
img_temp = NamedTemporaryFile(delete=True)
img_temp.write(r.content)
img_temp.flush()
file_name = image_url.rsplit('/', 1)[1]
tags_count = random.randint(4, 7)
new_photo = Photo()
new_photo.creation_date = photo_dt
new_photo.image.save(file_name, File(img_temp), save=True)
new_photo.tags = Tag.objects.order_by('?')[:tags_count]
new_photo.save()
print('\t', file_name)
print('photos loaded, count: ', Photo.objects.count())
def upload_photos(request):
if request.method == "POST":
# get fields from page and build object
files = request.FILES.getlist('images')
description = request.POST['description']
title = request.POST['title']
pric = request.POST['price']
pub = request.POST.get('public', False)
if (pub == 'on'):
pub = False
s_instance = Photoseries(title = title , description = description, owner=request.user ,price = pric, public = pub)
# save series before adding images
s_instance.save(False)
# iterate over files
for count,a_file in enumerate(files):
# create & save Image for every file
p_instance = Photo(title='Photoseries Photo', image=a_file, owner=request.user, public = pub)
p_instance.save(True)
# add image to series
s_instance.images.add(p_instance)
# save modified series
s_instance.save()
return redirect('/photoseries/list/')
return render(request, 'photoseries/upload.html')
def test_get(self):
Membership.objects.create(
type=Membership.MEMBER,
user=self.member,
since=date(year=2015, month=1, day=1),
until=None,
)
for i in range(10):
with open(
os.path.join(settings.BASE_DIR, "photos/fixtures/thom_assessor.png"),
"rb",
) as f:
fi = SimpleUploadedFile(
name="photo{}.png".format(i),
content=f.read(),
content_type="image/png",
)
photo = Photo(album=self.album, file=fi)
photo.save()
response = self.client.get(reverse("photos:album", args=(self.album.slug,)))
self.assertEqual(response.status_code, 200)
self.assertEqual(response.context["album"], self.album)
self.assertEqual(len(response.context["photos"]), 10)
def handle(self, *args, **options):
if not os.path.isdir(options["folder"]):
raise Exception("You must specify a directory to import")
foldername = os.path.relpath(options["folder"])
album, date, title = foldername.split("_", maxsplit=2)
date = parse_date("{}-{}-{}".format(date[:4], date[4:6], date[6:]))
slug = slugify("-".join([str(date), title]))
if Album.objects.filter(title=title, date=date).exists():
self.stdout.write(
"An album with title ({}) and"
" date ({}) already exists.".format(title, date)
)
return
self.stdout.write("Importing album '{}' ({})".format(title, str(date)))
album = Album(title=title, date=date, slug=slug)
album.save()
n = 0
for filename in os.listdir(options["folder"]):
try:
photo = Photo(album=album)
file = open(os.path.join(options["folder"], filename), "rb")
photo.file.save(filename, File(file))
photo.save()
n += 1
except Exception:
self.stdout.write("Could not import {}".format(filename))
self.stdout.write("Imported {} photos from {}".format(n, options["folder"]))
def upload(request):
if request.method == 'POST':
response = {'files': []}
# Create a new entry in our database
new_image = Photo(image_field=request.FILES['image_field'])
# Save the image using the model's ImageField settings
new_image.save()
# Save output for return as JSON
response['files'].append({
'name': '%s' % new_image.id,
'size': '%d' % request.FILES.__sizeof__(),
'url': '%s' % new_image.image_field.url,
'thumbnailUrl': '%s' % new_image.image_field.url,
'deleteUrl': '\/image\/delete\/%s' % new_image.id,
"deleteType": 'DELETE'
})
print(response)
return JsonResponse(response)
form = PhotoUploadForm()
context = {
'form': form,
"class_name": form.__class__.__name__
}
return render(request, "photos/upload.html", context)
def index(request):
'''
the index view is responsible for managing user image uploads and
outputing a list of all uploaded images ordered by ratings to the
index.html template
'''
if request.method == 'POST':
form = ImageForm(request.POST, request.FILES)
if form.is_valid():
photo_name = form.cleaned_data['image_path']
new_img = Photo(
image = photo_name,
image_thumb = photo_name,
name = photo_name,
description = form.cleaned_data['image_desc']
)
new_img.save()
return HttpResponseRedirect(reverse('photos:index'))
else:
form = ImageForm()
photos_list = Photo.objects.all().order_by('-avg_rating', '-id')
return render(request, 'photos:index',
{'photos_list': photos_list, 'form': form})
def populate(request):
for i in (1,2,3):
p = Photo(name="test image #%s" % i, original_image="apps/photos/tests/test%s.jpg" % i)
p.save()
return HttpResponseRedirect("/photos")
def save_latest_flick_image():
flickr_image = get_latest_flickr_image()
if not Photo.objects.filter(link=flickr_image['link']).exists():
photo = Photo(title=flickr_image['title'],
link=flickr_image['link'],
image_url=flickr_image['media']['m'],
description=flickr_image['description'])
photo.save()
def multi_upload(request, album_id):
if request.method == 'POST':
owner = request.user
print album_id
gallery = get_object_or_404(Gallery, id=album_id)
file = request.FILES[u'files[]']
error = False
#文件是否合法
if file.size > MAX_FILE_SIZE:
error = "maxFileSize"
if file.size < MIN_FILE_SIZE:
error = "minFileSize"
if file.content_type not in ACCEPTED_FORMATS:
error = "acceptFileTypes"
if request.session["is_allow_upload"] == 0:
error = "maxNumberOfFiles"
else:
request.session["is_allow_upload"] -= 1
response_data = {
"name": file.name,
"size": file.size,
"type": file.content_type,
}
if error:
response_data["error"] = error
response_data = simplejson.dumps([response_data])
return HttpResponse(response_data, mimetype=response_mimetype(request))
#保存文件
image = Photo(
title=file.name, description='description',
image=file, owner=owner, gallery=gallery,
)
image.save()
response_data["url"] = image.image.url
response_data['thumbnail_url'] = image.image['thumbnail'].url
print 'url:',image.image['thumbnail'].url
#删除链接
response_data["delete_url"] = "/photos/del/" + str(image.id)
response_data["delete_type"] = "GET"
response_data = simplejson.dumps({"files":[response_data]})
return HttpResponse(response_data, mimetype=response_mimetype(request))
else:
request.session["is_allow_upload"] = MAXNUMBEROFFILES
print request.session["is_allow_upload"]
return render_to_response('photos/multi_upload.html',{
"open_tv":u'{%',"close_tv": u'%}',"maxfilesize": MAX_FILE_SIZE,
"minfilesize": MIN_FILE_SIZE,"maxnumberoffiles":MAXNUMBEROFFILES,
}, context_instance=RequestContext(request)
)
def form_valid(self, form):
photo_name = form.cleaned_data['image_path']
new_img = Photo(
image = photo_name,
image_thumb = photo_name,
name = photo_name,
description = form.cleaned_data['image_desc']
)
new_img.save()
return HttpResponseRedirect(reverse('photos:index'))
def create_photo_model(self, name='testname', border_color="#FFFFFF",
created_at=None):
photo = Photo(
owner=self.user,
photo=self.create_image_file(),
name=name,
border_color=border_color,
)
photo.save()
if created_at is not None:
Photo.objects.filter(pk=photo.pk).update(created_at=created_at)
return photo
def form_valid(self, form):
# I load these uploaded files into django-filer objects.
files = Photo.objects.filter(temp_hash=self.request.POST.get('temp_hash'))
# folder = Folder.objects.get(name='Customer Service')
for f in files:
new_file = Photo(image=f)
# Save the image using the model's ImageField settings
new_file.save()
# Attach the new Filer files to the original form object.
self.object.attachments.add(new_file)
files.delete()
return super(MultiAttachmentMixin, self).form_valid(form)
def save_latest_flickr_image():
"""
We get the lastest image and save it to our Photo Model in the Database
"""
flickr_image = get_latest_flickr_image()
# lets make sure we don't save the same image more than once
# we are assuming each Flickr image has a unique Link
if not Photo.objects.filter(link=flickr_image['link']).exists():
photo = Photo(title=flickr_image['title'],
link=flickr_image['link'],
image_url=flickr_image['media']['m'],
description=flickr_image['description'])
photo.save()
def save_latest_flickr_image():
"""
We get the lastest image and save it to our Photo Model in the Database
"""
flickr_image = get_latest_flickr_image()
# lets make sure we don't save the same image more than once
# we are assuming each Flickr image has a unique Link
if not Photo.objects.filter(link=flickr_image['link']).exists():
photo = Photo(
title=flickr_image['title'],
link=flickr_image['link'],
image_url=flickr_image['media']['m'],
description=flickr_image['description']
)
photo.save()
def upload(request):
file = upload_receive(request)
instance = Photo(file=file)
instance.save()
basename = os.path.basename(instance.file.file.name)
file_dict = {
'name': basename,
'size': instance.file.file.size,
'url': settings.MEDIA_URL + basename,
'thumbnail_url': settings.MEDIA_URL + basename,
'delete_url': reverse('jfu_delete', kwargs={'pk': instance.pk}),
'delete_type': 'POST',
}
return UploadResponse(request, file_dict)
def post(self, request, pk, **kwargs):
review = get_object_or_404(ParkReview, pk=pk, user=request.user)
if review.photos.count == 10:
return HttpResponseBadRequest('Max photos have been reached')
im = Image.open(request.FILES.get('file'))
width, height = im.size
if width < 720 or height < 540:
return HttpResponseBadRequest('Image is too small')
else:
photo = Photo()
photo.park_review = review
photo.image = request.FILES.get('file')
photo.user = request.user
photo.draft = True
photo.save()
return HttpResponse(photo.id)
def import_photo(self, row, photographer):
'''
Add or update a Photograph record from the given CSV row.
'''
ret = None
image = self.get_or_create_image(row)
if not image:
print('WARNING: image file not found {}'.format(row['filename']))
return ret
created = False
if not self.append_only:
ret = Photo.objects.filter(image=image).first()
if not ret:
ret = Photo()
created = True
date_parts = _parse_date(row['date'])
photo = {
'taken_year': date_parts.year,
'taken_month': date_parts.month,
'taken_day': date_parts.day,
'photographer': photographer,
'description': (row['description'] or ''),
'comments': row['comments'],
'image': image,
}
coords = row['dd_co_ordinates']
if coords:
coords = coords.split()
photo['location'] = Point(float(coords[1]), float(coords[0]))
for field in photo:
if photo[field]:
setattr(ret, field, photo[field])
ret.save()
_print_operation(ret, created, 'title')
# Update or Create image file as Wagtail Image
# .image_title = ~slugify(FILENAME)
# .file = hash(FILE).jpg
return ret
def handle(self, *args, **options):
if not args:
raise CommandError("The <photo_target_dir> argument is required")
img_dir = os.path.join(settings.DJANGO_PROJECT_ROOT, args[0])
for fn in os.listdir(img_dir):
if re.match(r'.+\.(png|jpg|gif)', fn) is not None:
fp = os.path.join(img_dir, fn)
self.stdout.write('Loading the photo "%s" ...' % fn)
photo = Photo()
photo.photo = photo.get_photo_path(fn)
photo.photo.storage.save(photo.photo.name, File(open(fp)))
photo.save()
self.stdout.write('All photos loaded succesfully.')
def save(self, commit=True, **kwargs):
instance = super(GrowingPlaceForm, self).save(commit=False, **kwargs)
instance.centroid = Point(self.cleaned_data['longitude'],
self.cleaned_data['latitude'])
# Intentionally ignoring commit keyword to save Photo
instance.save()
if self.cleaned_data['photo']:
photo = Photo(
content_type=ContentType.objects.get_for_model(instance),
object_id=instance.pk,
original_image=self.cleaned_data['photo']
)
photo.save()
return instance
def create(self, request, raw=False, **kwargs):
""" Uploads a new photo. """
title = request.CLEANED.get('title', '')
description = request.CLEANED.get('description', '')
if request.CLEANED['url']:
photo = get_picture_from_url(request.CLEANED['url'])
elif request.CLEANED['file64']:
photo = request.CLEANED['photo']
else:
if request.CLEANED['file']:
uploaded_file = request.CLEANED['file']
format = request.CLEANED['format']
photo = Photo(user=request.user, title=title, description=description)
photo.image.save("%s.%s" % (uuid.uuid4(), format), uploaded_file)
photo.save()
uploaded_file.close()
return photo.to_json(request=request, detail=request.CLEANED['detail']) if not raw else photo
def upload( request ):
# The assumption here is that jQuery File Upload
# has been configured to send files one at a time.
# If multiple files can be uploaded simulatenously,
# 'file' may be a list of files.
file = upload_receive( request )
instance = Photo( file = file )
instance.save()
basename = os.path.basename( instance.file.path )
file_dict = {
'name' : basename,
'size' : file.size,
'url': settings.MEDIA_URL + basename,
'thumbnailUrl': settings.MEDIA_URL + basename,
'deleteUrl': reverse('jfu_delete', kwargs = { 'pk': instance.pk }),
'deleteType': 'POST',
}
return UploadResponse( request, file_dict )
def upload( request ):
file = upload_receive( request )
instance = Photo( file = file )
instance.save()
basename = os.path.basename( instance.file.file.name )
file_dict = {
'name' : basename,
'size' : instance.file.file.size,
'url': settings.MEDIA_URL + basename,
'thumbnail_url': settings.MEDIA_URL + basename,
'delete_url': reverse('jfu_delete', kwargs = { 'pk': instance.pk }),
'delete_type': 'POST',
}
return UploadResponse( request, file_dict )
def create_photo(self, album):
photo = Photo()
photo.album = album
name = _generate_title()
igen = IconGenerator(5, 5) # 5x5 blocks
icon = igen.generate(
name,
480,
480,
padding=(10, 10, 10, 10),
output_format="jpeg",
) # 620x620 pixels, with 10 pixels padding on each side
photo.file.save(f"{name}.jpeg", ContentFile(icon))
photo.save()
def _save_photo(request, username):
create_time = request.POST['create_time']
latitude = request.POST['latitude']
longitude = request.POST['longitude']
location = request.POST['location']
image_name = request.POST['image_name']
image_type = request.POST['type']
description = request.POST['description']
_handle_uploaded_file(request.FILES['image_file'], os.path.join(UPLOAD_TO, image_name))
photo = Photo(username=username,
create_time=create_time,
latitude=latitude,
longitude=longitude,
location=location,
image_name=image_name,
type=image_type,
description=description
)
photo.save()
def handle(self, *args, **options):
path = options['path']
for category in os.listdir(path):
if category.startswith('.'):
continue
print 'Processing photos in category %s...' % category
subfolder = os.path.join(path, category)
for photo_name in os.listdir(subfolder):
fh = open(os.path.join(subfolder, photo_name))
p = Photo(photo=File(fh))
p.save()
p.metadata.category = category.lower()
p.save()
fh.close()
def new(request):
if request.method == 'POST':
form = PhotoForm(request.POST, request.FILES)
if form.is_valid():
photo = Photo(
title = form.cleaned_data['title'],
image = request.FILES['image'],
user = request.user,
)
photo.save()
return HttpResponseRedirect(reverse('photos:index'))
else:
form = PhotoForm()
return render_to_response(
'photos/new.html',
{'form': form},
context_instance=RequestContext(request)
)
def upload(request):
file = upload_receive(request)
pet = PetProfile.objects.get(id=int(request.GET.get('pet_id')))
instance = Photo(image=file, pet=pet)
instance.save()
basename = os.path.basename( instance.image.path )
file_dict = {
'name' : basename,
'size' : file.size,
'photo_id': instance.id,
'url': settings.MEDIA_URL + 'photo/' + basename,
'thumbnailUrl': instance.thumbnail.url,
'deleteUrl': reverse('jfu_delete', kwargs = { 'pk': instance.pk }),
'deleteType': 'POST',
}
return UploadResponse( request, file_dict )
def import_photos(request):
path = settings.RAPIDSMS_APPS['receiver']['attachments_path'] # -> data/attachments
def is_img(filename):
return (filename.endswith('.jpg') or filename.endswith('.jpeg') or filename.endswith('.png'))
def not_in_db_already(filename):
# Note that there's a query for each file here - another way would be to load all existing files to a list in one operation and work with that
# but, that might generate huge list when there are a lot of photos in the DB, and might cause data freshness issues in some edge cases
# so, we just do n queries each time (where n is probably not too big) instead
return (Photo.objects.filter(original_image="%s/%s" % (path, filename)).count() == 0)
files = os.listdir(path)
img_files = filter(is_img, files)
new_img_files = filter(not_in_db_already, img_files)
for f in new_img_files:
p = Photo(name=f, original_image="%s/%s" % (path, f))
p.save()
return HttpResponseRedirect("/photos")
def base64_to_photo_obj(creator, base64_str):
from photos.models import Photo
base64_str = re.sub('\s', '', base64_str)
base64_pattern = re.compile('data:image/(%s);base64,(.*)$' % '|'.join(settings.PHOTOS_FORMATS))
match_groups = base64_pattern.match(base64_str)
format = match_groups.group(1)
photo_64 = match_groups.group(2)
tmp_file_name = "/tmp/%s.%s" % (uuid.uuid4(), 'png')
fh = open(tmp_file_name, "wb")
fh.write(photo_64.decode('base64'))
fh.close()
fh = open(tmp_file_name, "rb")
photo = Photo(user=creator, title='', description='')
photo.image.save("%s.%s" % (uuid.uuid4(), 'png'), File(fh))
fh.close()
photo.save()
os.remove(tmp_file_name)
return photo, format
def post(self, request, **kwargs):
im = Image.open(request.FILES.get('file'))
width, height = im.size
if width < 720 or height < 540:
return HttpResponseBadRequest('Image is too small')
else:
itinerary = False
if 'itinerary_slug' in kwargs:
itinerary_slug = self.kwargs.get('itinerary_slug')
itineraries = Itinerary.objects.filter(slug=itinerary_slug)
itineraries = itineraries.filter(tour_operator=self.request.user.profile.tour_operator)
itinerary = itineraries.first()
photo = Photo(draft=True)
to = self.request.GET.get('to', -1)
if not to:
to = 0
to = int(to)
if to == 1:
photo.tour_operator = self.request.user.profile.tour_operator
else:
photo.user = request.user
if itinerary:
photo.itinerary = itinerary
photo.image = request.FILES.get('file')
if photo.image.size > settings.MAX_PHOTO_SIZE:
resize_factor = math.sqrt(photo.image.size / settings.MAX_PHOTO_SIZE)
new_width = int(photo.image.width / resize_factor)
new_height = int(photo.image.height / resize_factor)
output_size = (new_width, new_height)
img = Image.open(photo.image.path)
new_size = img.resize(output_size)
new_size.save(photo.image.path)
photo.uuid = uuid4().hex
photo.save()
return Response(photo.id)
def handle(self, *args, **options):
client = login()
directory_name = options['directory']
set_name = options.get('set_name', directory_name)
files = client.metadata(directory_name)
ps, _ = PhotoSet.objects.get_or_create(name=set_name)
for image_dict in files['contents']:
name = image_dict['path'].rsplit("/", 1)[-1]
print name
f, metadata = client.get_file_and_metadata(image_dict['path'])
sf = StringIO()
sf.write(f.read())
img = File(sf)
p = Photo(title=name, photo_set=ps)
p.image.save(name, img)
p.save()
generate_all_aliases(p.image, include_global=True)
def test_get(self):
for i in range(10):
with open(
os.path.join(settings.BASE_DIR, "photos/fixtures/thom_assessor.png"),
"rb",
) as f:
fi = SimpleUploadedFile(
name="photo{}.png".format(i),
content=f.read(),
content_type="image/png",
)
photo = Photo(album=self.album, file=fi)
photo.save()
response = self.client.get(
reverse(
"photos:shared-album", args=(self.album.slug, self.album.access_token,)
)
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.context["album"], self.album)
self.assertEqual(len(response.context["photos"]), 10)
def __getattribute__(self, key):
if key == "username":
if not object.__getattribute__(self, "username") and self.id:
self.username = self.user.username
self.save()
return self.username
if key == "main_profile_pic":
if not object.__getattribute__(self, "main_profile_pic"):
try:
default_photo = Photo.objects.filter(user_default=True)[0]
return default_photo
except IndexError:
user_fallback = "%s/photos/%s" % (settings.MEDIA_ROOT, "img_user_fallback.png")
try:
fp = open(user_fallback, "r")
image = Image.open(fp)
image.verify()
photo = Photo(user_default=True)
photo.save()
Photo.objects.filter(pk=photo.pk).update(image="photos/img_user_fallback.png")
photo = Photo.objects.get(pk=photo.pk)
fp.close()
return photo
except Exception, e:
user_fallback = "%s/images/%s" % (settings.GLOBALS_STATIC_ROOT, "img_user_fallback.png")
fp = open(user_fallback, "r")
image = Image.open(fp)
image.verify()
fp2 = open(user_fallback, "r")
target_file = File(fp2)
name = "img_user_fallback.png"
photo = Photo(user_default=True)
photo.image.save(name, target_file, save=True)
fp.close()
fp2.close()
return photo
def upload_photo(request):
if request.method == 'POST':
user = request.user
album_id = request.GET.get('album_id')
form = PhotoForm(request.POST, request.FILES)
if form.is_valid():
cd = form.cleaned_data
title = cd['title']
description = cd['description']
image = cd['image']
owner = user
gallery = get_object_or_404(Gallery, id=album_id)
photo = Photo(title=title, description=description,
image=image, owner=owner, gallery=gallery,
)
photo.save()
return HttpResponseRedirect("/photos/")
else:
form = PhotoForm()
return render_to_response("photos/photo_upload.html", {
"form": form,
}, context_instance=RequestContext(request)
)
temp_class = ImageClass(class_name = 'temp')
temp_class.save()
for root, dirs, files in os.walk(images_directory):
for direcory in dirs:
image_class = ImageClass()
image_class.class_name=direcory.lower()
images_dir= images_directory+'/'+direcory
if os.listdir(images_dir):
image_class.save()
print 'class ' + direcory + ' is added to database'
for filee in os.listdir(images_dir):
if filee.endswith('.jpg'):
ph = Photo()
ph.name = filee
ph.class_name=image_class
ph.photo.save(filee, File(open(images_dir+'/' + filee, 'r')))
feature_file_dir= features_directory+'/'+direcory+'/'+filee+'.txt'
ph.features.save(filee[:-3]+'csv', File(open(feature_file_dir, 'r')))
ph.save()
old_name = read_m_r[filee]
photo_labels = images_and_labels[old_name]
for label in photo_labels:
l = LabelsClass.objects.get(label_name = label)
ph.label_name.add(l)
def post(self, *args, **kwargs):
print(self.request.POST)
if self.steps.current == '0':
if self.request.is_ajax() and self.request.FILES:
try:
temp_hash = self.request.POST.get('0-temp_hash')
uploaded_photos = Photo.objects.filter(temp_hash=temp_hash).count()
product = Product.objects.get(slug=self.kwargs.get('slug', None))
if uploaded_photos < product.image_total:
photo = self.request.FILES.get('file')
new_image = Photo(image=photo, temp_hash=self.request.POST.get('0-temp_hash'))
new_image.save()
response = {'file': []}
response['file'].append({
'id': '%s' % new_image.id,
'name': '%s' % new_image.image.name,
'size': '%d' % self.request.FILES.__sizeof__(),
'url': '%s' % new_image.smart.url,
'thumbnailUrl': '%s' % new_image.thumbnail.url,
'deleteUrl': '\/image\/delete\/%s' % new_image.id,
"deleteType": 'DELETE'
})
# Get the minimum image dimension for square crop
if new_image.smart.width >= new_image.smart.height:
image_dimension = new_image.smart.height
else:
image_dimension = new_image.smart.width
# Simulate initial crop with dummy coordinates.
filter_data = [{
'name': 'crop',
'params':
{'x': 0,
'y': 0,
'width': image_dimension,
'height': image_dimension,
'rotate': 0,
}
}]
# Crop and create the new Cropped object
result_image = apply_filters_to_image(new_image.smart.name, filter_data)
new_cropped_file, created = Cropped.objects.get_or_create(original=new_image)
new_cropped_file.image_cropped.save(new_image.get_name("crop_"), result_image)
return JsonResponse(response)
else:
return HttpResponseForbidden(self.request)
except Exception as e:
print("Exception Uploading the image", e.message)
pass
else:
if self.request.POST.get('0-uploaded_photo_count') == '0':
raise ValidationError("Ocurrio un error, recibimos un total de 0 fotos cargadas!")
elif self.steps.current == '1':
# TODO: Cambiar el json.loads porque no todos los exploradores pueden enviar el JSON con los resultados del sort, ej: iPhone.
try:
sorted_photo_list = json.loads(self.request.POST.get('1-photo_sort_list', None))
for index, sorted_photo in enumerate(sorted_photo_list):
photo = get_object_or_404(Photo, id=sorted_photo['id'])
Photo.objects.filter(id=sorted_photo['id']).update(sequence=index)
# photo.sequence = index
# photo.save()
except Exception as e:
print("AQUI2", e)
pass
# elif self.steps.current == '2':
# if not self.request.POST.get('wizard_goto_step'):
# product = Product.objects.get(slug=self.kwargs.get('slug', None))
# qty = self.request.POST['2-quantity']
# cart_id = self.request.POST.get('2-cart')
#
# prev_data = self.storage.get_step_data('0')
# if prev_data:
# temp_hash = prev_data.get('0-temp_hash', None)
#
# cart = Cart.objects.get(id=cart_id)
#
# photos = Photo.objects.filter(temp_hash=temp_hash)
#
# cart_item = CartItem.objects.create(cart=cart, product=product)
# cart_item.photo_set = photos
# cart_item.quantity = qty
# cart_item.line_total = product.price
# cart_item.save()
# return HttpResponseRedirect(reverse("cart"))
return super(UploadPhotosWizard, self).post(self.request, *args, **kwargs)
def make(request, slug=None):
product = get_object_or_404(Product, slug=slug)
if request.method == "POST":
print(request.POST)
print(request.FILES)
images_count = Photo.objects.filter(temp_hash=request.POST.get('temp_hash')).count()
if images_count == product.image_total:
return JsonResponse({'status': 'Total de imagenes cargadas!'})
else:
form = PhotoUploadForm(request.POST, request.FILES or None)
if form.is_valid():
response = {'file': []}
photo = request.FILES.get('file')
# [...] Process the file. Resize it, create thumbnails, etc.
# Get an instance of picture model (defined below)
new_image = Photo(image=photo, temp_hash=request.POST.get('temp_hash'))
# Save the image using the model's ImageField settings
new_image.save()
response['file'].append({
'name': '%s' % new_image.id,
'size': '%d' % request.FILES.__sizeof__(),
'url': '%s' % new_image.image.url,
'thumbnailUrl': '%s' % new_image.image.url,
'deleteUrl': '\/image\/delete\/%s' % new_image.id,
"deleteType": 'DELETE'
})
# return HttpResponse('{"status":"success"}', content_type='application/json')
return JsonResponse(response)
# return HttpResponse('{"status":"error: %s"}' % file_form.errors, content_type='application/json')
return JsonResponse({'response': form.errors, })
# uploaded_images = [] # product variation
# if request.method == "POST":
# try:
# response = {'files': []}
# for photo in request.FILES.getlist('photos'):
# # Create a new entry in our database
# new_image = Photo(image_field=photo)
# # new_image.cart_item = cart_item
# # Save the image using the model's ImageField settings
# new_image.save()
# # Save output for return as JSON
# response['files'].append({
# 'name': '%s' % new_image.id,
# 'size': '%d' % request.FILES.__sizeof__(),
# 'url': '%s' % new_image.image_field.url,
# 'thumbnailUrl': '%s' % new_image.image_field.url,
# 'deleteUrl': '\/image\/delete\/%s' % new_image.id,
# "deleteType": 'DELETE'
# })
# uploaded_images.append(new_image)
# except:
# pass
# print(len(uploaded_images))
# if len(uploaded_images) > 0:
# cart_item.photo_set.add(*uploaded_images)
#
# # cart_item.save()
# # success message
# context = {
# 'product': product,
# 'photos': uploaded_images,
# }
#
# return render(request, "photos/upload.html", context)
# # return JsonResponse(response)
# # return HttpResponseRedirect(reverse('cart'))
# error message
instagram_images = get_instagram_images(user=request.user)
form = PhotoUploadForm()
context = {
'upload_form': form,
'product': product,
'class_name': form.__class__.__name__,
'images': instagram_images,
}
return render(request, "photos/upload2.html", context)
# WARNING! Enter your API key in the query parameter for the below two URLs
url_by_group = """https://api.flickr.com/services/rest/?method=flickr.groups.pools.getPhotos&api_key=<your_api_key_here>&group_id={0}&format=json&nojsoncallback=1"""
url_by_photo = """https://api.flickr.com/services/rest/?method=flickr.photos.getInfo&api_key=<your_api_key_here>&photo_id={0}&format=json&nojsoncallback=1"""
for group_id in group_list:
group = Group(name=group_id)
group.save()
count = 0
response_by_group = requests.get(url_by_group.format(group_id), timeout=5)
print(response_by_group.content)
pic_list = response_by_group.json()['photos']['photo']
for pic in pic_list:
response_by_photo = requests.get(url_by_photo.format(pic['id']),
timeout=5)
owner = response_by_photo.json()['photo']['owner']['username']
title = response_by_photo.json()['photo']['title']['_content']
url = response_by_photo.json()['photo']['urls']['url'][0]['_content']
photo = Photo(pid=int(pic['id']),
title=title,
photo_url=url,
owner=owner,
group=group)
photo.save()
count += 1
group.no_of_photos = count
group.save()
def record_photo(path):
file_modified_at = datetime.fromtimestamp(os.stat(path).st_mtime, tz=utc)
try:
photo_file = PhotoFile.objects.get(path=path)
except PhotoFile.DoesNotExist:
photo_file = PhotoFile()
if photo_file and photo_file.file_modified_at == file_modified_at:
return False
metadata = PhotoMetadata(path)
date_taken = parse_datetime(metadata.get('Date/Time Original'))
camera = None
camera_make = metadata.get('Make')
camera_model = metadata.get('Camera Model Name')
if camera_model:
camera_model = camera_model.replace(camera_make, '').strip()
if camera_make and camera_model:
try:
camera = Camera.objects.get(make=camera_make, model=camera_model)
if date_taken < camera.earliest_photo:
camera.earliest_photo = date_taken
camera.save()
if date_taken > camera.latest_photo:
camera.latest_photo = date_taken
camera.save()
except Camera.DoesNotExist:
camera = Camera(make=camera_make,
model=camera_model,
earliest_photo=date_taken,
latest_photo=date_taken)
camera.save()
lens = None
lens_name = metadata.get('Lens ID')
if lens_name:
try:
lens = Lens.objects.get(name=lens_name)
if date_taken < lens.earliest_photo:
lens.earliest_photo = date_taken
lens.save()
if date_taken > lens.latest_photo:
lens.latest_photo = date_taken
lens.save()
except Lens.DoesNotExist:
lens = Lens(name=lens_name,
earliest_photo=date_taken,
latest_photo=date_taken)
lens.save()
photo = None
if date_taken:
try:
# TODO: Match on file number/file name as well
photo = Photo.objects.get(taken_at=date_taken)
except Photo.DoesNotExist:
pass
latitude = None
longitude = None
if metadata.get('GPS Position'):
latitude, longitude = parse_gps_location(metadata.get('GPS Position'))
if not photo:
# Save Photo
photo = Photo(
taken_at=date_taken,
taken_by=metadata.get('Artist') or None,
aperture=metadata.get('Aperture')
and Decimal(metadata.get('Aperture')) or None,
exposure=metadata.get('Exposure Time') or None,
iso_speed=metadata.get('ISO') and int(metadata.get('ISO')) or None,
focal_length=metadata.get('Focal Length')
and metadata.get('Focal Length').split(' ', 1)[0] or None,
flash=metadata.get('Flash')
and 'on' in metadata.get('Flash').lower() or False,
metering_mode=metadata.get('Metering Mode') or None,
drive_mode=metadata.get('Drive Mode') or None,
shooting_mode=metadata.get('Shooting Mode') or None,
camera=camera,
lens=lens,
latitude=latitude,
longitude=longitude,
altitude=metadata.get('GPS Altitude')
and metadata.get('GPS Altitude').split(' ')[0])
photo.save()
# Save PhotoFile
photo_file.photo = photo
photo_file.path = path
photo_file.width = metadata.get('Image Width')
photo_file.height = metadata.get('Image Height')
photo_file.mimetype = mimetypes.guess_type(path)[0]
photo_file.file_modified_at = file_modified_at
photo_file.bytes = os.stat(path).st_size
photo_file.preferred = False # TODO
photo_file.save()
return photo
def test_to_string(self):
photo = Photo(name="Park St.Amado")
photo.save()
self.assertEqual(str(photo), photo.name)
def record_photo(path):
global_state.increment('photo_import_tasks_running')
file_modified_at = datetime.fromtimestamp(os.stat(path).st_mtime, tz=UTC())
try:
photo_file = PhotoFile.objects.get(path=path)
except PhotoFile.DoesNotExist:
photo_file = PhotoFile()
if photo_file and photo_file.file_modified_at == file_modified_at:
return False
metadata = PhotoMetadata(path)
date_taken = parse_datetime(metadata.get('Date/Time Original'))
camera = None
camera_make = metadata.get('Make')
camera_model = metadata.get('Camera Model Name')
if camera_model:
camera_model = camera_model.replace(camera_make, '').strip()
if camera_make and camera_model:
try:
camera = Camera.objects.get(make=camera_make, model=camera_model)
if date_taken < camera.earliest_photo:
camera.earliest_photo = date_taken
camera.save()
if date_taken > camera.latest_photo:
camera.latest_photo = date_taken
camera.save()
except Camera.DoesNotExist:
camera = Camera(make=camera_make,
model=camera_model,
earliest_photo=date_taken,
latest_photo=date_taken)
camera.save()
lens = None
lens_name = metadata.get('Lens ID')
if lens_name:
try:
lens = Lens.objects.get(name=lens_name)
if date_taken < lens.earliest_photo:
lens.earliest_photo = date_taken
lens.save()
if date_taken > lens.latest_photo:
lens.latest_photo = date_taken
lens.save()
except Lens.DoesNotExist:
lens = Lens(name=lens_name,
earliest_photo=date_taken,
latest_photo=date_taken)
lens.save()
try:
# TODO: Match on file number/file name as well
photo = Photo.objects.get(taken_at=get_datetime(path))
except Photo.DoesNotExist:
photo = Photo(
taken_at=get_datetime(path),
taken_by=metadata.get('Artist'),
aperture=metadata.get('Aperture')
and Decimal(metadata.get('Aperture')) or None,
exposure=metadata.get('Exposure Time'),
iso_speed=metadata.get('ISO') and int(metadata.get('ISO')) or None,
focal_length=metadata.get('Focal Length')
and metadata.get('Focal Length').split(' ', 1)[0] or None,
flash=metadata.get('Flash')
and 'on' in metadata.get('Flash').lower() or False,
metering_mode=metadata.get('Metering Mode'),
drive_mode=metadata.get('Drive Mode'),
shooting_mode=metadata.get('Shooting Mode'),
camera=camera,
lens=lens,
location=metadata.get('GPS Position')
and parse_gps_location(metadata.get('GPS Position')) or None,
altitude=metadata.get('GPS Altitude')
and metadata.get('GPS Altitude').split(' ')[0])
photo.save()
Channel('generate-thumbnails-for-photo').send(
{'text': json.dumps({'id': str(photo.id)})})
photo_file.photo = photo
photo_file.path = path
photo_file.width = metadata.get('Image Width')
photo_file.height = metadata.get('Image Height')
photo_file.mimetype = mimetypes.guess_type(path)[0]
photo_file.file_modified_at = file_modified_at
photo_file.bytes = os.stat(path).st_size
photo_file.preferred = False # TODO
photo_file.save()
global_state.decrement('photo_import_tasks_running')
return photo
def photo_write(self, photo_id):
data = self.photo_data[photo_id]
photo = Photo(nsid = data['owner_id'],
photo_id = data['photo_id'],
title = data['title'])
photo.save()
def populate_photos(sol_limit=None):
"""Fill database with photos from NASA API."""
api_key = NASA_API_KEY
last_earth_date = DEFAULT_LAST_EARTH_DATE
null_id_counter = count(1000000000)
good_prev = {}
null_prev = {}
for sol, rover in iter_sol_rover(sol_limit):
url = make_rover_url(rover.name)
# Dict keeping track of just the photos from each cam at this sol.
photos_this_sol = {}
for camera in rover.cameras.all():
good_prev.setdefault(rover.name, {}).setdefault(camera.name, None)
null_prev.setdefault(rover.name, {}).setdefault(camera.name, set())
photos = get_photos(url, sol, camera.name, api_key)
photos = filter(is_good_photo, photos)
photos = sorted(photos, key=itemgetter('img_src'))
for photo in photos:
print('Creating photo:\n{}\n'.format(photo))
# Prepare params for init --overwrite dict with model
prev_photo = good_prev[rover.name][camera.name]
photo['rover'] = rover
photo['camera'] = camera
photo['prev_photo'] = prev_photo
new_photo = Photo(**photo)
new_photo.save()
# Crucial association of prev_photo/next_photo relationship
if prev_photo:
prev_photo.next_photo = new_photo
prev_photo.save()
good_prev[rover.name][camera.name] = new_photo
# Collect photos this sol for association as concurrent
photos_this_sol.setdefault(camera.name, []).append(new_photo)
# Set a connection from null photos to next good one
for null_photo in null_prev[rover.name][camera.name]:
null_photo.next_photo = new_photo
null_photo.save()
null_prev[rover.name][camera.name] = set()
# Update last_earth_date to set on null photos.
last_earth_date = max((last_earth_date, photo['earth_date']))
if not photos:
null_photo = Photo(
is_null=True,
img_src=NULL_IMG_SRC,
id=next(null_id_counter),
sol=sol,
earth_date=last_earth_date,
camera=camera,
rover=rover,
prev_photo=good_prev[rover.name][camera.name],
)
null_photo.save()
null_prev[rover.name][camera.name].add(null_photo)
photos_this_sol[camera.name] = [null_photo]
set_concurrent(photos_this_sol)
def fileupload(request):
if request.method == 'POST':
upload = Import.objects.create()
eventstr = request.POST.get('event')
if eventstr != '':
event, ev_created = Event.objects.get_or_create(name=eventstr)
else:
event, ev_created = Event.objects.get_or_create(name=upload.name)
event.visible_for.add(request.user)
tagstr = request.POST.get('tags')
if tagstr != '':
tags = tagstr.split(';')
else:
tags = []
count = 0
files = request.FILES
for f in files:
# save file to media directory
imgfile = files[f]
fs = FileSystemStorage()
mediadir = getattr(settings, "MEDIA_ROOT", None)
filename = os.path.join(mediadir, 'photos', upload.slug,
imgfile.name)
imgfilename = fs.save(filename, imgfile)
exif_data = exifread.process_file(imgfile, details=False)
exif_json = parse_exif_data.get_exif_data_as_json(exif_data)
exif_tsp = parse_exif_data.get_exif_timestamp(exif_data)
if not is_aware(exif_tsp):
exif_tsp = make_aware(exif_tsp)
lat, lon = parse_exif_data.get_exif_location(exif_data)
if lat is not None and lon is not None:
lat = '{:3.10}'.format(lat)
lon = '{:3.10}'.format(lon)
basename = os.path.basename(imgfilename)
photo = Photo(
name=basename.split('.')[0],
filename=basename,
timestamp=exif_tsp,
uploaded_by=request.user,
owner=request.user,
exif=exif_json,
latitude=lat,
longitude=lon,
upload=upload,
)
if event:
photo.event = event
photo.imagefile = os.path.join('photos', upload.slug, basename)
photo.geocode()
photo.save()
count += 1
for tagstr in tags:
tag, created = Tag.objects.get_or_create(name=tagstr)
photo.tags.add(tag)
messages.success(
request,
_('successfully added {count} photos.').format(count=count))
return HttpResponse('ok')
from photos.models import Photo
import csv
with open('clean_data.csv') as csvfile:
reader = csv.DictReader(csvfile)
for row in reader:
p = Photo(url=row['image_url'])
p.save()
def handle(self, *args, **options):
journalist_group, created = Group.objects.get_or_create(name="Journalists")
if created:
journalist_group.permissions.add(
# jaam.act
Permission.objects.get(codename="add_act"),
Permission.objects.get(codename="change_act"),
Permission.objects.get(codename="delete_act"),
# jaam.blog
Permission.objects.get(codename="add_blog"),
Permission.objects.get(codename="change_blog"),
Permission.objects.get(codename="delete_blog"),
Permission.objects.get(codename="add_blogpost"),
Permission.objects.get(codename="change_blogpost"),
Permission.objects.get(codename="delete_blogpost"),
# jaam.journalism
Permission.objects.get(codename="add_tag"),
Permission.objects.get(codename="change_tag"),
Permission.objects.get(codename="delete_tag"),
Permission.objects.get(codename="add_userprofile"),
Permission.objects.get(codename="change_userprofile"),
Permission.objects.get(codename="delete_userprofile"),
# jaam.photos
Permission.objects.get(codename="add_photo"),
Permission.objects.get(codename="change_photo"),
Permission.objects.get(codename="delete_photo"),
Permission.objects.get(codename="add_photogallery"),
Permission.objects.get(codename="change_photogallery"),
Permission.objects.get(codename="delete_photogallery"),
Permission.objects.get(codename="add_photogalleryitem"),
Permission.objects.get(codename="change_photogalleryitem"),
Permission.objects.get(codename="delete_photogalleryitem"),
# jaam.projects
Permission.objects.get(codename="add_project"),
Permission.objects.get(codename="change_project"),
Permission.objects.get(codename="delete_project"),
Permission.objects.get(codename="add_projectlocation"),
Permission.objects.get(codename="change_projectlocation"),
Permission.objects.get(codename="delete_projectlocation"),
# jaam.stories
Permission.objects.get(codename="add_story"),
Permission.objects.get(codename="change_story"),
Permission.objects.get(codename="delete_story"),
# jaa.videos
Permission.objects.get(codename="add_video"),
Permission.objects.get(codename="change_video"),
Permission.objects.get(codename="delete_video"),
Permission.objects.get(codename="add_videogallery"),
Permission.objects.get(codename="change_videogallery"),
Permission.objects.get(codename="delete_videogallery"),
Permission.objects.get(codename="add_videogalleryitem"),
Permission.objects.get(codename="change_videogalleryitem"),
Permission.objects.get(codename="delete_videogalleryitem"),
# comments
Permission.objects.get(codename="add_comment"),
Permission.objects.get(codename="change_comment"),
Permission.objects.get(codename="delete_comment"),
Permission.objects.get(codename="add_commentflag"),
Permission.objects.get(codename="change_commentflag"),
Permission.objects.get(codename="delete_commentflag"),
Permission.objects.get(codename="can_moderate"),
# doccloud
Permission.objects.get(codename="add_document"),
Permission.objects.get(codename="change_document"),
Permission.objects.get(codename="delete_document"),
Permission.objects.get(codename="add_documentcloudproperties"),
Permission.objects.get(codename="change_documentcloudproperties"),
Permission.objects.get(codename="delete_documentcloudproperties"),
)
try:
User.objects.get(username="******")
except User.DoesNotExist:
default_journalist = User()
default_journalist.username = "******"
default_journalist.save()
default_journalist.groups.add(Group.objects.get(name="Journalists"))
default_journalist.save()
try:
Project.all_objects.get(slug="default")
except Project.DoesNotExist:
default_project = Project()
default_project.title = "Default"
default_project.slug = "default"
default_project.tagline = "The default project"
default_project.image = 0
default_project.save()
try:
Photo.all_objects.get(slug="default")
except Photo.DoesNotExist:
default_photo = Photo()
default_photo.project = Project.all_objects.get(slug="default")
default_photo.title = "Default"
default_photo.slug = "default"
default_photo.caption = "The default photo"
default_photo.journalist = User.objects.get(username="******")
default_photo.image = "http://i.imgur.com/uxRkD.jpg"
default_photo.save()
def AddAlbum(request):
if request.method == "POST":
albumform = AlbumUpload(request.POST)
if albumform.is_valid():
a = albumform.save(commit=False)
member = User.objects.all().filter(
username=request.user.username).first()
if member:
contributor = member.first_name + " " + member.last_name
a.updated_by = contributor
photoform = PhotoUpload(request.POST, request.FILES)
photos = request.FILES.getlist('files[]')
photolist = list()
today = datetime.now()
tWidth, tHeight = 300, 200
pWidth, pHeight = 1200, 800
if photoform.is_valid():
fig = 1
albumPath = os.path.join(settings.MEDIA_ROOT, "photos")
for f in photos:
p = Photo(file=f, album=a, figNo=fig)
try:
fname, ext = os.path.splitext(p.file.name)
nfname = today.strftime("%m%dT%H%M%S") + "_" + str(fig)
nfthumb = "photos/" + today.strftime(
"%Y") + "/" + nfname + "_thumb" + ext
p.thumb = nfthumb
if (fig == 1):
a.thumb = nfthumb
a.save()
p.save()
#Rename
opath = os.path.join(settings.MEDIA_ROOT, p.file.name)
nfname = today.strftime("%Y") + "/" + nfname + ext
npath = os.path.join(albumPath, nfname)
os.rename(opath, npath)
img = Image.open(npath)
width, height = img.size
if (width > pWidth):
nWidth = pWidth
nHeight = pHeight
img = apply_orientation(img)
img.thumbnail((nWidth, nHeight), Image.HAMMING)
img.save(npath)
p.file.name = "photos/" + nfname
p.save(update_fields=["file"])
img.thumbnail((tWidth, tHeight), Image.LANCZOS)
tpath = os.path.join(settings.MEDIA_ROOT, nfthumb)
img.save(tpath)
print("Saved Thumb file" + tpath + " size " +
str(tWidth) + "x" + str(tHeight))
photolist.append(p)
fig += 1
except IOError as err:
print(
"Exception file processing album {0}".format(err))
pass
mail_approval(a.id, 'Album', request)
return render(request, 'photos/success.html', {'album': a})
else:
return render(request, 'photos/failed.html')
else:
photoform = PhotoUpload()
albumform = AlbumUpload()
return render(request, 'photos/add_photo.html', {
'photo': photoform,
'album': albumform
})
