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 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 post(self, request):
#Crea una instancia vacía de foto
photo_with_owner = Photo()
#Asigna los datos
photo_with_owner.owner = request.user
form = PhotoForm(request.POST, instance=photo_with_owner)
if form.is_valid():
new_photo = form.save(
) #Guarda el objeto que viene en el formulario y lo devuelve
#Poner todos los campos vacíos
form = PhotoForm()
success_message = 'Guardado con exito!'
#reverse sirve para generar la url
success_message += '<a href="{0}">'.format(
reverse('photo_detail', args=[new_photo.pk]))
success_message += 'Ver Foto'
success_message += '</a>'
context = {'form': form, 'success_message': success_message}
return self.render(request, context)
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 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 post(self, request):
"""
Crea una foto en base a la informacion POST
:param request: HttpRequest
:return: HttpResponse
"""
success_message = ''
# Instancio el objeto
photo_with_owner = Photo()
# Asigno como propietario de la foto, al usuario que esta autenticado
photo_with_owner.owner = request.user
form = PhotoForm(request.POST, instance=photo_with_owner)
if form.is_valid():
# Guarda el objeto photo y me lo devuelve
new_photo = form.save()
form = PhotoForm()
success_message = 'Guardado con éxito!'
"""No se debe usar new_photo.id, se debe usar pk. pk es la clave primaria que django identifica como id.
El {0} nos indica el orden en el que van los argumentos
"""
success_message += '<a href="{0}">'.format(reverse('photo_detail', args=[new_photo.pk]))
success_message += 'Ver foto'
success_message += '</a>'
context = {
'form': form,
'success_message': success_message
}
return render(request, 'photos/new_photo.html', context)
def extract_photo(request, archive_file, photo, album):
# zipfile and tarfile are inconsistent
if isinstance(photo, ZipInfo):
photo_filename = photo.filename
extract_file = archive_file.open
elif isinstance(photo, tarfile.TarInfo):
photo_filename = photo.name
extract_file = archive_file.extractfile
else:
raise TypeError("'photo' must be a ZipInfo or TarInfo object.")
# Ignore directories
if not os.path.basename(photo_filename):
return
# Generate unique filename
num = album.photo_set.count()
filename, extension = os.path.splitext(photo_filename)
new_filename = str(num).zfill(4) + extension
photo_obj = Photo()
photo_obj.album = album
try:
with extract_file(photo) as f:
photo_obj.file.save(new_filename, File(f))
if not save_photo(photo_obj):
messages.add_message(request, messages.WARNING,
_("{} is duplicate.").format(photo_filename))
except (OSError, AttributeError, UnidentifiedImageError):
messages.add_message(request, messages.WARNING,
_("Ignoring {}").format(photo_filename))
if photo_obj.file.path:
os.remove(photo_obj.file.path)
photo_obj.delete()
def create(request):
'''
Formulario para creacion de de foto (petición POST)
param request: HttpRequest
return: HttpResponse
'''
success_message = ''
if request.method == 'GET':
form = PhotoForm()
else:
photo_with_owner = Photo()
photo_with_owner.owner = request.user # Asignar como propietario de la foto al user autenticado
form = PhotoForm(request.POST, instance=photo_with_owner)
if form.is_valid():
new_photo = form.save() # Guarda el objeto y lo devuelve
form = PhotoForm() # Al no pasar valores aparece el formulario vacio
success_message = 'Guardado con éxito'
success_message += '<a href="{0}">'.format(reverse('photo_detail',args=[new_photo.pk]))
success_message += 'ver foto'
success_message += '</a>'
context = {
'form': form ,
'success_message': success_message
}
return render(request, 'photos/new_photo.html', context)
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 post(self, request):
"""
crea una foto en base a la información POST
:param request: HttpRequest
:return: HttpResponse
"""
success_message = ''
photo_with_owner = Photo()
photo_with_owner.owner = request.user #asigno como propietario de la foto al usuario atuenticado
form = PhotoForm(
request.POST, instance=photo_with_owner
) #especificar instancia de foto a utilizar por el formulario
if form.is_valid():
new_photo = form.save() #guarda el objeto Photo y me lo devuelves
form = PhotoForm()
success_message = '¡Guardado con éxito!'
success_message += '<a href="{0}">'.format(
reverse('photo_detail', args=[new_photo.pk]))
success_message += 'Ver foto'
success_message += '</a>'
context = {'form': form, 'success_message': success_message}
return render(request, 'photos/new_photo.html', context)
def create(request):
"""
Show a form for create a new photo post.
:param request: HttpRequest Object
:return: HttpResponse Object
"""
success_message = ''
if request.method == 'GET': #GET REQUEST
form = PhotoForm()
else: #POST REQUEST
photo_with_owner = Photo()
photo_with_owner.owner = request.user #Automatic asign user autenticated as owner
form = PhotoForm(request.POST,instance=photo_with_owner)
if form.is_valid():
new_photo = form.save() #Save the object photo and return it
form = PhotoForm() #Empty form after submitting
success_message = 'Photo created succesfully'
success_message += '<a href="{0}">'.format(reverse('photo_detail',args=[new_photo.pk]))
success_message += 'Take a look'
success_message += '</a>'
context = dict(form=form,success_message=success_message)
return render(request,'photos/new_photo.html',context)
def post(self, request):
success_message = ''
number_of_photos_uploaded = self.get_number_of_photos_from_user(
request)
if not check_if_uploads_remaining(number_of_photos_uploaded):
form = PhotoForm()
success_message = 'Ya has subido 25 fotos. Has alcansado el limite.'
else:
photo_with_owner = Photo()
photo_with_owner.owner = request.user
form = PhotoForm(request.POST, instance=photo_with_owner)
if form.is_valid():
new_photo = form.save()
form = PhotoForm()
success_message = 'Guardado con éxito'
success_message += '<br>'
success_message += '<br>'
success_message += '<a href="{0}">'.format(
reverse('photos_detail', args=[new_photo.pk]))
success_message += 'Ver foto'
success_message += '</a>'
context = {
'form': form,
'success_message': success_message,
'nof': number_of_photos_uploaded,
'nof2': 25 - number_of_photos_uploaded
}
return render(request, 'photos/new_photo.html', context)
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):
"""
Crea una foto en base a la documentacioón POST
:param request: HttpRequest
:param pk: id de la foto
:return: HttpResponse
"""
success_message = ''
photo_with_owner = Photo()
photo_with_owner.owner = request.user # asigno como usuario de la foto, el usuario auteticado
form = PhotoForm(request.POST, instance=photo_with_owner) # Instanciamos el formulario con los datos del POST
if form.is_valid(): # Preguntar si es válido
new_photo = form.save() # Guarda el objeto Photo y me lo devuelve
form = PhotoForm()
success_message = 'Guardado con éxito!'
success_message += '<a href="{0}">'.format(
reverse('photo_detail', args=[new_photo.pk])
)
success_message += 'Ver foto'
success_message += '</a>'
context = {
'form': form,
'success_message': success_message
}
return render(request, 'photos/new_photo.html', context)
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 post(self, request):
photo = Photo()
photo.owner = request.user
form = PhotoForm(request.POST, instance=photo)
if form.is_valid():
new_photo = form.save()
messages.success(
request,
'Foto creada correctamente con ID {0}'.format(new_photo.pk))
form = PhotoForm()
context = {'form': form}
return render(request, 'photos/new.html', context)
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 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 create_photos(num_photos: int = 100):
"""Create num_photos Photos in the DB for testing"""
photos_to_create = []
start_date = datetime.date(year=2000, month=1, day=1)
base_num_prints = 10
for i in range(num_photos):
shot_date = start_date + datetime.timedelta(days=i)
p = Photo(image_id=i,
image_location='photos',
title=f'photo{i}',
shot_date=shot_date,
max_prints=i % base_num_prints + base_num_prints)
photos_to_create.append(p)
Photo.objects.bulk_create(photos_to_create)
def create(self, validated_data):
post = Post.objects.get(id=self.context['request'].data['post_id'])
images_data = self.context['request'].FILES
photo_bulk_list = []
for image in images_data.getlist('photos'):
photo = Photo(post=post,
photo_images=image,
image_name=image.name,
user=self.context['request'].user)
photo_bulk_list.append(photo)
Photo.objects.bulk_create(photo_bulk_list)
return post
def upload(request):
user = request.twitter_user
if user is None:
raise HTTPUnauthorized()
if user.get('id') != request.registry.uploader_twitter_id:
raise HTTPForbidden()
media = request.POST.get('media')
photo = Photo(media.type, request.POST.get('message', ''))
photo.set_content(request.registry.photo_storage, media.file.read())
DBSession.add(photo)
return dict(photo=photo,
user_id=user['id'],
user_screen_name=user.get('screen_name', ''))
def post(self, request):
success_message = ''
photo_with_owner = Photo()
photo_with_owner.owner = request.user
form = PhotoForm(request.POST, instance=photo_with_owner)
if form.is_valid():
new_photo = form.save()
form = PhotoForm()
success_message = 'Imagen guardada con éxito! Ver '
success_message += '<a href="{0}">'.format(
reverse('photo_detail', args=[new_photo.pk]))
success_message += 'foto'
success_message += '</a>'
context = {'new_photo_form': form, 'success_message': success_message}
return render(request, 'photos/new_photo.html', context)
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 post(self,request):
success_message = ''
photo_with_owner = Photo()
photo_with_owner.owner = request.user #Automatic asign user autenticated as owner
form = PhotoForm(request.POST,instance=photo_with_owner)
if form.is_valid():
new_photo = form.save() #Save the object photo and return it
form = PhotoForm() #Empty form after submitting
success_message = 'Photo created succesfully'
success_message += '<a href="{0}">'.format(reverse('photo_detail',args=[new_photo.pk]))
success_message += 'Take a look'
success_message += '</a>'
context = dict(form=form,success_message=success_message)
return render(request,'photos/new_photo.html',context)
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 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 post(self, request):
"""
Presenta el formulario para crear una foto y en caso de que la peticion sea POST la
valida y la creat en caso de ser valida
:param request: objeto HttpRequest con los datos de la peticion
:return: un objeto HttpResponse con los datos de respuesta
"""
message = None
photo_with_user = Photo(owner=request.user)
photo_form = PhotoForm(request.POST, instance=photo_with_user)
if photo_form.is_valid():
new_photo = photo_form.save()
photo_form = PhotoForm()
message = 'Foto creada satisfactoriamente <a href="{0}">Ver foto</a>'.format(
reverse('photos_detail', args=[new_photo.pk]))
context = {'form': photo_form, 'message': message}
return render(request, 'photos/photo_creation.html', context)
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 post(self, request):
"""
Presenta el formulario para crear una foto
:param request: objeto HttpRequest con los datos de la petición
:return: HttpResponse con la plantilla
"""
message = None
photo_with_user = Photo(owner=request.user)
photo_form = PhotoForm(request.POST, instance=photo_with_user)
if photo_form.is_valid():
new_photo = photo_form.save()
photo_form = PhotoForm()
message = "Foto creada satisfactoriamente. <a href='{0}'>Ver foto</a>".format(
# obtiene la url nombrada 'photos_detail'
reverse('photos_detail', args={new_photo.pk}))
context = {'form': photo_form, 'message': message}
return render(request, 'photos/photo_creation.html', context)
