def upload(request, customer_id):
customer = get_object_or_404(Customer, pk=customer_id)
if request.method == 'POST' and request.POST['content']:
myfile = request.FILES['myfile']
post = Post()
post.content = request.POST['content']
post.createtime = timezone.now()
post.updatetime = timezone.now()
post.customer = Customer.objects.get(id=customer_id)
fs = FileSystemStorage()
filename = fs.save(myfile.name, myfile)
uploaded_file_url = fs.url(filename)
# image = Image()
post.save()
for file in request.FILES.getlist('myfile'):
image = Image()
post.save()
image.imageurl = file
image.post = Post.objects.get(id=post.id)
image.save()
# image.imageurl = filename
# image.post = Post.objects.get(id=post.id)
# post.save()
# image.save()
return redirect('/customers/' + 'detail/' + str(customer_id))
return render(request, 'customers/detail.html', {'customer': customer})
def create(request):
if request.method == "POST":
if request.user.is_authenticated:
content = json.loads(request.POST['content'])
establishment_uuid = uuid.uuid4()
image_url = 'https://outtolunchstatic.s3.amazonaws.com/media/images/download.png'
if request.user.elo >= 1000:
if 'image' in request.FILES:
request.FILES['image'].name = uuid.uuid4().__str__()
image = Image(file=request.FILES['image'],
type='E',
uuid=establishment_uuid)
image.save()
image_url = image.file.url
establishment = Establishment(
establishment_id=establishment_uuid,
name=content['name'],
location=content['location'],
description=content['description'],
rating=0,
owner=request.user,
rating_count=0,
image=image_url)
establishment.save()
return JsonResponse({"success": "success"})
else:
return JsonResponse({"error": "You do not have enough elo!"})
else:
return JsonResponse(
{"error": "You are not logged in you silly goose!"})
else:
return redirect('/')
def images_add(request):
if not request.user.is_authenticated():
return HttpResponseRedirect('/staff/login/')
elif request.user.has_perm('images.add_image'):
if request.method == 'POST':
form = ImageForm(request.POST, request.FILES)
if form.is_valid():
# save new image
new_image = Image(name=form.cleaned_data['name'])
if form.cleaned_data.get('caption'):
new_image.caption = form.cleaned_data['caption']
if form.cleaned_data.get('credit'):
new_image.credit = form.cleaned_data['credit']
new_image.image = form.cleaned_data['image']
new_image.save()
return HttpResponseRedirect(
reverse('images.views.images_add_to_markup',
args=[new_image.id]))
else:
return render_to_response(
'images/widget_add.html', {'form': form},
context_instance=RequestContext(request))
else:
form = ImageForm()
return render_to_response('images/widget_add.html', {'form': form},
context_instance=RequestContext(request))
else:
return render_to_response('staff/access_denied.html', {
'missing': 'add photos to',
'staffapp': 'this entry'
},
context_instance=RequestContext(request))
def update(request):
if request.method == 'POST':
if request.user.is_authenticated:
if 'image' in request.FILES:
request.FILES['image'].name = uuid.uuid4().__str__()
try:
image = Image.objects.get(uuid=request.user.id, type='U')
image.file = request.FILES['image']
image.save()
request.user.image = image.file.url
request.user.save()
except Image.DoesNotExist:
request.FILES['image'].name = uuid.uuid4().__str__()
image = Image(file=request.FILES['image'],
type='U',
uuid=request.user.id)
image.save()
request.user.image = image.file.url
request.user.save()
return successful_message({})
else:
return error_message("No image provided!")
else:
return error_message("You must be signed in!")
else:
return redirect('/')
def create(request):
if request.method == "POST":
if request.user.is_authenticated:
content = json.loads(request.POST['content'])
post_id = uuid.uuid4().__str__()
image_url = 'https://outtolunchstatic.s3.amazonaws.com/media/images/download.png'
if 'image' in request.FILES:
request.FILES['image'].name = uuid.uuid4().__str__()
image = Image(file=request.FILES['image'], type='P', uuid=post_id)
image.save()
image_url = image.file.url
post_event = Event(event_id=uuid.uuid4().__str__(),
type='PostCreatedEvent',
timestamp=datetime.now(),
data=Post(post_id=post_id,
post_user=content['userId'],
post_rating=content['rating'],
post_subject=content['subject'],
establishment_id=content['establishmentId'],
post_content=content['content'],
post_photo_location=image_url
)
)
post_event.save()
establishment = Establishment.objects.get(establishment_id=content['establishmentId'])
establishment.rating_count += 1
establishment.rating = ((establishment.rating * (establishment.rating_count - 1)) + content[
'rating']) / establishment.rating_count
establishment.save()
return JsonResponse({'success': 'success'})
else:
return JsonResponse({'error': 'You have to login first in order to post!'})
else:
return redirect('/')
def create(self, request, *args, **kwargs):
serializer = ImageNewSerializer(data=request.data)
if serializer.is_valid():
form_url = serializer.validated_data.get('form_url', None)
form_file = serializer.validated_data.get('form_file', None)
image_instance = Image()
if form_url:
file_name = os.path.basename(
urllib.parse.urlparse(form_url).path)
req = urllib.request.Request(form_url)
try:
response = urllib.request.urlopen(req)
except urllib.error.HTTPError:
return Response(status=status.HTTP_400_BAD_REQUEST,
data={"form_url": "error"})
django_file = ContentFile(BytesIO(response.read()).getvalue())
image_instance.file.save(file_name, django_file)
elif form_file:
image_instance.file = form_file
image_instance.save()
return Response(data=ImageSerializer(image_instance).data,
status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def update_picture_for_candidate(candidate_data, cache_directory, **options):
picture_intro = 'Picture from the IEBC API for candidate'
candidate_code = candidate_data['code']
filename = os.path.join(cache_directory,
"candidate-%s.jpg" % (candidate_code, ))
if not os.path.exists(filename):
image_url = candidate_data['picture']
r = requests.get(image_url)
if r.status_code == 200:
with open(filename, 'w') as fp:
fp.write(r.content)
# If that image now exists, use it:
if os.path.exists(filename):
# Find the position from the candidate code, so we can get the right person:
positions = Position.objects.filter(
external_id=candidate_code).currently_active()
if not positions:
print "#### Missing position for:", candidate_code
elif len(positions) > 1:
print "#### Multiple positions for:", candidate_code
else:
person = positions[0].person
if options['commit']:
# Remove old IEBC images for that person:
person.images.filter(source__startswith=picture_intro).delete()
# And now create the new one:
new_image = Image(content_object=person,
source="%s %s" %
(picture_intro, candidate_code))
with open(filename) as fp:
new_image.image.save(
name="%s-%s.jpg" %
(candidate_code, file_mtime_iso8601(filename)),
content=ContentFile(fp.read()))
def upload_image(id):
url = IMAGE_ORIGINAL_URL.format(id)
image = download_file(url)
image = '{}/{}'.format(Image.src.field.upload_to, image)
image = Image(src=image, order=99)
image.save()
return image
def test_can_created_encrypted_key(self):
"""
Tests that the DES key encrypts properly
"""
i = Image(pk=1)
self.assertEquals('fQj1bFDkn3g', i.generate_encrypted_key())
i.pk = 2
self.assertEquals('i76tPgXaavF', i.generate_encrypted_key())
def import_glance_image(request):
"""
Imports Openstack Glance image into Wistar.
:param request: JSON payload that contains a single object with the following properties:
image_name, image_type, image_descr
:return: a JSON object with at least the following properties: status (boolean) and message
"""
logger.debug("<---- API call import_glance_images ---->")
if openstackUtils.connect_to_openstack():
json_string = request.body
try:
json_body = json.loads(json_string)
except ValueError as ve:
logger.error(
'Could not parse json payload with error <{0}>'.format(
ve.message))
return apiUtils.return_json(False, "Could not parse json payload!")
logger.debug(json_body)
required_fields = {'image_name', 'image_type', 'image_descr'}
if not required_fields.issubset(json_body):
logger.error("Invalid parameters in json body")
return apiUtils.return_json(False,
"Invalid parameters in json payload")
image_name = json_body["image_name"]
image_type = json_body["image_type"]
image_decr = json_body["image_descr"]
logger.debug(
"<---- API call import_glance_image: <{0}> START ---->".format(
image_name))
if Image.objects.filter(name=image_name).exists():
logger.info('image with name %s already exists' % image_name)
return apiUtils.return_json(True, "Glance images already imported")
image = Image()
image.description = image_decr + ' image imported from Glance'
image.name = image_name
image.type = image_type
image.save()
logger.debug(
"<---- API call import_glance_image: <{0}> DONE ---->".format(
image_name))
return apiUtils.return_json(True,
"Glance images successfully imported")
else:
return apiUtils.return_json(False, "Failed to authenticate")
def test_upload(self):
i1 = Image()
i1.title = "aaa"
i1.thumb = File(open("static/images/comments4.png"))
i1.save()
p = Image.objects.get(id=1).thumb.path
self.failUnless(open(p), 'file not found')
def importZip(zipfile, galleryName, galleryDescription):
# Stuff bgins here ...
imagesObj = imagesFromZip(zipfile)
imagesList = imagesObj.listImages()
# Is there images in this zip ?
if len(imagesList) > 0:
# regexp for extractiong name ...
nameRe = re.compile('/([^/]+)$')
# Create corresponding gallery
gallery = Gallery()
gallery.title = galleryName
gallery.desc = galleryDescription
gallery.save() # Must save gallery
# Now, for each images in it, create an image object and bind it to gallery
for imgPath in imagesList:
src = PILImage.open(imgPath)
m = nameRe.search(imgPath)
imgObj = Image()
imgObj.gallery = gallery
# First, put the original sized picture
# use StringIO hack to save image to a string ...
output = StringIO.StringIO()
src.save(output, 'JPEG')
imgObj.original.save(m.groups()[0], ContentFile(output.getvalue()))
output.close()
# Then, resize it to something like 1600*1200
(orig_w, orig_h) = src.size
orig_s = orig_w * orig_h
new_s = 1600 * 1200
ratio = orig_s / new_s
# Resize only if requested size is lower than original
if ratio > 1:
(new_w, new_h) = (orig_w / (sqrt(ratio)),
orig_h / (sqrt(ratio)))
resized = src.resize((int(new_w), int(new_h)))
else: # Else, just keep original one ...
(new_w, new_h) = (orig_w, orig_h)
resized = src
output = StringIO.StringIO()
resized.save(output, 'JPEG')
imgObj.screen.save(m.groups()[0], ContentFile(output.getvalue()))
output.close()
# Finally, get a thumb of 150px*150px, work on resized picture to be faster
if new_w < new_h:
maxi = new_w
else:
maxi = new_h
thumb = resized.transform((150, 150), PILImage.EXTENT,
(0, 0, maxi, maxi))
output = StringIO.StringIO()
thumb.save(output, 'JPEG')
imgObj.thumb.save(m.groups()[0], ContentFile(output.getvalue()))
output.close()
imgObj.save()
gallery.save()
print "done !"
def create_from_instance(request, uuid):
logger.debug("Creating new image from instance")
domain = libvirtUtils.get_domain_by_uuid(uuid)
logger.debug("got domain " + domain.name())
domain_image = libvirtUtils.get_image_for_domain(uuid)
logger.debug("got domain_image: " + domain_image)
if osUtils.is_image_thin_provisioned(domain_image):
logger.error(
"Cannot clone disk that is thinly provisioned! Please perform a block pull before continuing"
)
context = {
'error':
"Cannot Clone thinly provisioned disk! Please perform a block pull!"
}
return render(request, 'error.html', context)
domain_name = domain.name()
# FIXME - make these variable names a bit more clear about their meaning
# we need to get the path of the image relative to the MEDIA_ROOT
media_root = settings.MEDIA_ROOT
media_root_array = media_root.split("/")
len_media_root = len(media_root_array)
full_path_array = domain_image.split("/")
full_path = "/".join(full_path_array[:full_path_array.index('instances')])
# grab the file path of the domain image without the MEDIA_ROOT prepended
file_path_array = domain_image.split('/')[len_media_root:]
images_dir = "/".join(file_path_array[:file_path_array.index('instances')])
new_relative_image_path = images_dir + "/image_" + str(
domain.UUIDString()) + ".img"
new_full_image_path = full_path + "/image_" + str(
domain.UUIDString()) + ".img"
if osUtils.check_path(new_full_image_path):
logger.info("Image has already been cloned")
context = {'error': "Instance has already been cloned!"}
return render(request, 'error.html', context)
logger.debug("Copying image from " + domain_image)
logger.debug("To " + new_full_image_path)
osUtils.copy_image_to_clone(domain_image, new_full_image_path)
image = Image()
image.name = "image_" + str(domain.UUIDString())
image.description = "Clone of " + domain_name
image.filePath = new_relative_image_path
image.save()
return HttpResponseRedirect('/images/')
def test_if_no_title_uses_image_name(self):
"""
If there's no title then the image's name should be the default.
"""
with open(
os.path.join(settings.BASE_DIR, 'images', 'tests', 'data',
'image.png'), "rb") as image_file:
image = Image(
image=SimpleUploadedFile("test.png", image_file.read()))
image.set_title()
self.assertEquals('test.png', image.title)
def create(self, request, *args, **kwargs):
image = Image()
image.title = request.data['title']
image.format = request.data['format']
image.file = request.data['file']
image.date_created = timezone.now()
image.date_updated = timezone.now()
#return super().create(request, *args, **kwargs)
image.save()
return Response({"message": "Image entry successful"},
status=status.HTTP_201_CREATED)
def create(self, validated_data):
user = None
request = self.context.get("request")
if request and hasattr(request, "user"):
user = request.user
image = Image(
comments=validated_data["comments"],
data=validated_data["data"],
uploaded_by=user,
)
image.save()
return image
def populate_data_base_with_images(apps, schema_editor):
context = {}
with open('data/context.json') as file:
context = json.load(file)
products = []
products = context["products"]
for data in products:
image = Image(name=data["image"], value=data["image"])
image.save()
def _update_v1(request, name, os, payload):
"""Update API v1."""
start_time = timezone.now()
try:
im = Image.objects.get(name=name)
im.os = os
im.save() # Always update at least the modification time
images_packages = {
image_pkg.package.name: image_pkg
for image_pkg in ImagePackage.objects.filter(image=im)
}
except Image.DoesNotExist:
im = Image(name=name, os=os)
im.save()
images_packages = {}
logger.info("Created image '%s'", name)
existing_not_updated = []
existing_upgradable_not_updated = []
installed = payload.get('installed', [])
for item in installed:
_process_installed(im, os, images_packages, existing_not_updated, item)
logger.info("Tracked %d installed packages for image '%s'", len(installed),
name)
uninstalled = payload.get('uninstalled', [])
for item in uninstalled:
existing = images_packages.get(item['name'], None)
if existing is not None:
existing.delete()
logger.info("Untracked %d uninstalled packages for image '%s'",
len(uninstalled), name)
upgradable = payload.get('upgradable', [])
for item in upgradable:
_process_upgradable(im, os, images_packages,
existing_upgradable_not_updated, item)
logger.info("Tracked %d upgradable packages for image '%s'",
len(upgradable), name)
if payload['update_type'] == 'full':
_garbage_collection(im, name, start_time, existing_not_updated,
existing_upgradable_not_updated)
def create_account(request):
if request.method == 'POST':
content = json.loads(request.POST['content'])
user_id = uuid.uuid4()
image_url = 'https://outtolunchstatic.s3.amazonaws.com/media/images/download.png'
if 'image' in request.FILES:
request.FILES['image'].name = uuid.uuid4().__str__()
image = Image(file=request.FILES['image'], type='U', uuid=user_id)
image.save()
image_url = image.file.url
return register_user(user_id, content['username'], content['password'],
content['email'], content['FName'],
content['LName'], image_url)
else:
return redirect('/')
def handle(self, *args, **options):
img_formats = ('.jpg', '.jpeg', '.png')
imgs_dir = options['directory']
# path = os.path.join(settings.MEDIA_ROOT, imgs_dir)
path = os.path.join(settings.BASE_DIR, imgs_dir)
file_list = os.listdir(path)
if options['del']:
Image.objects.all().delete()
for f in file_list:
if f.endswith(img_formats):
image = Image(name=f, img=f)
image.save()
def test_run(self):
image = Image(**image_kwargs)
# Make operation
operation = self.operation_class(*filter_spec.split('-'))
# Make operation recorder
operation_recorder = WillowOperationRecorder(
(image.width, image.height))
# Run
operation.run(operation_recorder, image, {})
# Check
self.assertEqual(operation_recorder.ran_operations,
expected_output)
def setUp(self):
self.category = Category(name="Test cat")
self.category.save_category()
self.location = Location(name="Test Loc")
self.location.save_location()
self.image = Image(
name="Test Img",
location_id=self.location,
category_id=self.category,
image=SimpleUploadedFile(
name='image_test.jpg',
content=open(
'photo_gallery/static/images/default_location.jpg',
'rb').read(),
content_type='image/jpeg'))
def transform(self, data):
path = self.find_biggest_image(data['props']['srcset'])
name = os.path.basename(path)
image = Image(caption=data['props'].get('caption', ''),
title=data['props']['alt'] or self.page.title)
# save temp file
img_temp = NamedTemporaryFile()
img_temp.write(self.get_image_data_from_file(path))
img_temp.flush()
# save file and image
image.file.save(name, File(img_temp), save=True)
image.save()
return {'type': 'image', 'value': image.id}
def upload_file(request):
if request.method == 'POST':
form = UploadFileForm(request.POST, request.FILES)
if form.is_valid():
im = Image()
im.model_pic = form.cleaned_data['file']
filename = '{0}{1}'.format(
str(
base64.b64encode(
bytes(str(datetime.datetime.now().timestamp()),
'utf-8')))[2:-2],
pathlib.Path(form.cleaned_data['file'].name).suffix)
im.model_pic.name = filename
x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
if x_forwarded_for:
ipaddress = x_forwarded_for.split(',')[-1].strip()
else:
ipaddress = request.META.get('REMOTE_ADDR')
im.owner = None
im.upload_ip_address = ipaddress
im.lease = datetime.datetime.now().replace(
microsecond=0) + datetime.timedelta(
seconds=int(form.cleaned_data['expiration'].split(".")[0]))
im.name = filename
if form.cleaned_data['your_name'] == "":
im.custom_name = None
else:
im.custom_name = form.cleaned_data['your_name']
im.save()
for tag in request.POST.getlist('tagList'):
tag = Tag(name=tag.split(":")[0], image=im)
tag.save()
return HttpResponseRedirect("/image/view/%s" % filename)
else:
form = UploadFileForm()
return render(request, 'index.html', {'form': form})
def upload_images(request):
"""
View to store upload images specific to an event.
Models used: Folder, Image
"""
try:
is_loggedin, username = get_session_variables(request)
# User is not logged in
if not is_loggedin:
return HttpResponseRedirect('/register/login')
# User is logged in
else:
if request.method == 'POST':
form = FolderForm(request.POST, request.FILES)
# form is not valid
if not form.is_valid():
error = "Invalid inputs"
return render(request, 'images/upload_images.html', \
{'form':form, 'error':error, }, \
RequestContext(request))
# form is valid
else:
cleaned_form_data = form.cleaned_data
folder_name = cleaned_form_data['folder_name']
# create a new folder
folder = form.save(commit=False)
folder.save()
# save images
image = request.FILES['image']
new_image_object = Image(img=image, \
folder_name = folder)
img_name = new_image_object.img.name
new_image_object.save()
return render(request, "images/success.html")
else:
return render(request, 'images/upload_images.html', \
{'form':FolderForm(), 'is_loggedin': is_loggedin },\
RequestContext(request))
except KeyError:
return error_key(request)
def upload_base64(self, request, *args, **kwargs):
if request.user.is_verified:
data = request.data
extension = 'jpg'
if 'image' in data:
if len(data['image']) > 0:
if re.compile('^data:image/jpeg;').match(
data['image']) is not None:
image_type = 'image/jpeg'
extension = 'jpg'
if re.compile('^data:image/png;').match(
data['image']) is not None:
image_type = 'image/png'
extension = 'png'
image_data = binascii.a2b_base64(data['image'].replace(
'data:' + image_type + ';base64,', ''))
f = BytesIO(image_data)
pil_image = PilImage.open(f)
f.seek(0)
# TODO: make them all jpegs
average_color = average_image_color(pil_image)
color = "rgb(%s,%s,%s)" % (average_color['R'],
average_color['G'],
average_color['B'])
image = Image(width=pil_image.width,
height=pil_image.height,
created_by=request.user,
modified_by=request.user,
color=color)
image.image = UploadedFile(file=f,
name='%s.%s' %
(image.id, extension),
content_type=image_type,
size=len(image_data))
image.save()
f.close()
return Response(ImageSerializer(image).data)
raise NotFound()
def save_latest_images(image_file=None, image_path=None):
"""
Processes the file with images URLs and saves them into db
:param image_file: The file containing image urls, if empty it defaults to the one in settings
:param image_path: The place to store images, if empty it defaults to the one in settings
"""
from images.tasks import logger
images_file = image_file if image_file else image_settings.IMAGES_FILE
saved_images_path = image_path if image_path else image_settings.IMAGES_PATH
# Check if file is present, skip otherwise
if os.path.isfile(images_file):
# Open images file and process each line
file = open(images_file, 'r')
for image in file:
image = image.rstrip('\n')
response = requests.get(image, stream=True)
# Get file name
image_name = os.path.basename(image)
try:
with open(saved_images_path + image_name, 'xb') as out_file:
shutil.copyfileobj(response.raw, out_file)
# Save object in bd if does not exist
if not Image.objects.filter(image_url=image).exists():
image = Image(
title=image_name,
image_url=image,
location=saved_images_path + image_name,
created_on=datetime.datetime.utcnow(),
)
image.save()
logger.info(
'Saved image {0} correctly to db and to disk'.format(
image_name))
del response
except IOError:
logger.error(
'An error occured trying to save image to disk for image {0}'
.format(image_name))
continue
else:
logger.error(
'Could not find file {0} with images urls'.format(images_file))
def handle(self, *args, **options):
try:
project = Project.objects.get(pk=options['project_id'])
except Project.DoesNotExist:
raise CommandError('Project "%s" does not exist' %
options['project_id'])
for path, dirs, files in os.walk(options['folder']):
match = []
match.extend(fnmatch.filter(files, '*.[Jj][Pp][Gg]'))
match.extend(fnmatch.filter(files, '*.[Jj][Pp][Ee][Gg]'))
match.extend(fnmatch.filter(files, '*.[Pp][Nn][Gg]'))
match.extend(fnmatch.filter(files, '*.[Tt][Ii][Ff]'))
match.extend(fnmatch.filter(files, '*.[Tt][Ii][Ff][Ff]'))
for m in match:
# FIXME: filename should be relative to settings.MEDIA_ROOT
im = Image(project=project)
im.image.save(m, File(open(os.path.join(path, m))))
im.save()
print '.',
def upload_tar(request, projectid):
import tarfile
if request.method == "POST":
targzfile = request.FILES.get('tarfile', None)
project = Project.objects.get(id=projectid)
if tarfile:
tar = tarfile.open(targzfile.temporary_file_path())
tar.extractall()
files = tar.getnames()
tar.close()
for image in files:
i = Image(project=project)
i.image.save(image, File(open(image, 'r')))
i.save()
return render(request, "images/upload_result.html", {
"project": project,
"files": files
})
def import_from_glance(request, glance_id):
"""
Creates a local db entry for the glance image
Everything in Wistar depends on a db entry in the Images table
If you have an existing openstack cluster, you may want to import those
images here without having to physically copy the images to local disk
:param request: HTTPRequest object
:param glance_id: id of the glance image to import
:return: redirect to /images/image_id
"""
if openstackUtils.connect_to_openstack():
image_details = openstackUtils.get_glance_image_detail(glance_id)
image = Image()
image.description = "Imported from Glance"
image.name = image_details["name"]
image.type = 'blank'
image.save()
logger.debug("All done")
return HttpResponseRedirect('/images/%s' % image.id)
context = {'error': "Could not connect to OpenStack"}
return render(request, 'error.html', context)
