def get_context_data(self, **kwargs):
documentversion_list = [{
'name':
d.uploaded_file.name,
'generate_filename':
default_storage.generate_filename(d.uploaded_file.name),
'url':
default_storage.url(
default_storage.generate_filename(d.uploaded_file.name)),
'exists':
default_storage.exists(
default_storage.generate_filename(d.uploaded_file.name)),
'id':
d.id
} for d in DocumentVersion.objects.all()]
kwargs.update({
'objectstore_container_list': [
'uploads/%s' % default_storage.get_valid_name(o)
for o in default_storage.listdir('uploads')[1]
],
'documentversion_list':
documentversion_list,
})
return super().get_context_data(**kwargs)
def validate(self):
self.load_file_remote_service()
# validate file is not None or file not exists
path_storage = default_storage.generate_filename(self.file_path)
if not default_storage.exists(path_storage):
raise InvalidFormatException(
message="File not exist in system for uploader")
def create_thumbnail(self, w, h):
if not self.images_file:
return
from PIL import Image
from io import BytesIO
THUMBNAIL_SIZE = (w, h)
if 'jpg' in self.images_file.name or 'jpeg' in self.images_file.name:
PIL_TYPE = 'jpeg'
FILE_EXTENSION = 'jpg'
elif 'png' in self.images_file.name:
PIL_TYPE = 'png'
FILE_EXTENSION = 'png'
self.images_file.open()
image = Image.open(BytesIO(self.images_file.read()))
image.thumbnail(THUMBNAIL_SIZE, Image.ANTIALIAS)
temp_handle = BytesIO()
image.save(temp_handle, PIL_TYPE)
temp_handle.seek(0)
# Было os.path.basename(self.images_file.name),
# Для доступа к S3 AWS используем библиотеку django.core.files.storage
# Метод basename нет в пакете, использовуем аналог метода - open generate_filename
self.images_file.save(storage.generate_filename(self.images_file.name),
File(temp_handle),
save=False)
def _write_to_file(self, file_path, content):
try:
gen_name = default_storage.generate_filename(file_path)
default_storage.save(gen_name, ContentFile(content.encode()))
except ValueError as ex:
raise ex
def download_documentversion(request, id):
documentversion = get_object_or_404(DocumentVersion, id=id)
if not default_storage.exists(
default_storage.generate_filename(
documentversion.uploaded_file.name)):
raise Http404()
return HttpResponseRedirect(documentversion.uploaded_file.url)
def create_from_as2message(
self,
as2message,
payload,
direction,
status,
filename=None,
detailed_status=None,
):
"""Create the Message from the pyas2lib's Message object"""
if direction == "IN":
organization = as2message.receiver.as2_name if as2message.receiver else None
partner = as2message.sender.as2_name if as2message.sender else None
else:
partner = as2message.receiver.as2_name if as2message.receiver else None
organization = as2message.sender.as2_name if as2message.sender else None
message, _ = self.update_or_create(
message_id=as2message.message_id,
partner_id=partner,
organization_id=organization,
defaults=dict(
direction=direction,
status=status,
compressed=as2message.compressed,
encrypted=as2message.encrypted,
signed=as2message.signed,
detailed_status=detailed_status,
),
)
# Save the headers and payload to store
if not filename:
filename = f"{uuid4()}.msg"
message.headers.save(
name=f"{filename}.header", content=ContentFile(as2message.headers_str)
)
message.payload.save(name=filename, content=ContentFile(payload))
# Save the payload to the inbox folder
full_filename = None
if direction == "IN" and status == "S":
if settings.DATA_DIR:
dirname = os.path.join(
settings.DATA_DIR, "messages", organization, "inbox", partner
)
else:
dirname = os.path.join("messages", organization, "inbox", partner)
if not message.partner.keep_filename or not filename:
filename = f"{message.message_id}.msg"
full_filename = default_storage.generate_filename(
posixpath.join(dirname, filename)
)
default_storage.save(name=full_filename, content=ContentFile(payload))
return message, full_filename
def handle(self, *args, **options):
remote_filenames = options['filename']
self.stdout.write(str(remote_filenames))
if not remote_filenames:
self.stdout.write("No filenames specified")
return
for remote_filename in remote_filenames:
if not remote_filename:
self.stdout.write("No filename specified")
continue
if not settings.APPLICATION_PMO_FTP_URL or type(
settings.APPLICATION_PMO_FTP_URL
) != ParseResult or not settings.IMPORT_ROOT:
self.stdout.write(
"Can't read PMO settings. Check you configuration")
continue
file_dir_path = os.path.normpath(
settings.IMPORT_ROOT + '/apps.processing.pmo/' +
str(timezone.now().strftime("%Y%m%d")))
file_path = os.path.normpath(file_dir_path + "/" + remote_filename)
with closing(
FTP(
host=settings.APPLICATION_PMO_FTP_URL.hostname,
user=settings.APPLICATION_PMO_FTP_URL.username,
passwd=settings.APPLICATION_PMO_FTP_URL.password,
)) as ftp:
try:
gen_name = default_storage.generate_filename(file_path)
with TemporaryFile() as f:
res = ftp.retrbinary('RETR %s' % remote_filename,
f.write)
f.seek(0)
default_storage.save(gen_name, f)
if not res.startswith('226 Transfer complete'):
self.stderr.write(
'Download of file {0} is not complete.'.format(
remote_filename))
# default_storage.delete(gen_name)
continue
self.stdout.write(
"File {} was successfully downloaded to {}".format(
remote_filename, gen_name))
continue
except Exception as e:
self.stderr.write(
'Error during download from FTP! {}'.format(e))
def uuid_filename_generator(instance, filename, path_format):
filetype = os.path.splitext(filename)[1]
if len(filetype) == 0:
filetype = '.'
basename = ''.join((force_text(uuid.uuid4()), filetype))
dirname = force_text(datetime.datetime.now().strftime(force_str(path_format)))
filename = posixpath.join(dirname, basename)
return default_storage.generate_filename(filename)
def download_file_google(file_path: str, module: str, category: str):
path_file = create_path_file(file_path, module, category)
path_storage = os.path.join(MEDIA_ROOT, path_file)
path_storage = default_storage.generate_filename(path_storage)
default_storage.save(path_storage, ContentFile(''))
# download file
r = requests.get(file_path)
with open(path_storage, 'wb') as f:
f.write(r.content)
path_storage = path_storage.replace('\\', '/')
return path_storage
def get_template_path(self, filename):
"""
Check if a template named ``template_name`` can be found in a list of directories. Returns
the path if the file exists or raises ``TemplateDoesNotExist`` otherwise.
"""
if default_storage.exists(filename):
return filename
for directory in self.template_dirs:
abstract_path = default_storage.generate_filename(
os.path.join(directory, filename))
if default_storage.exists(abstract_path):
return abstract_path
raise TemplateDoesNotExist(f'Unknown: {filename}')
def get_file_location(instance,
filename,
prepend=None,
specific_folder=None,
by_date=False,
getter=None,
prepare=False):
args = tuple()
if getter is None:
def _getter(instance):
return str(instance)
getter = _getter
if prepend is not None:
args += (prepend, )
args += (getter(instance), )
if specific_folder is not None:
args += (specific_folder, )
if by_date:
args += (timezone.now().strftime("%Y/%m/%d"), )
args += (filename, )
file_location = os.path.join(*args)
if prepare:
from django.core.files.storage import default_storage
default_storage.generate_filename(file_location)
return file_location
def get_file_path(instance, filename) -> str:
ret = getattr(settings, "SPIDER_FILE_DIR", "spider_files")
# try 100 times to find free filename
# but should not take more than 1 try
# IMPORTANT: strip . to prevent creation of htaccess files or similar
for _i in range(0, 100):
ret_path = default_storage.generate_filename(
posixpath.join(ret, str(instance.content.usercomponent.user_id),
create_b64_token(FILE_TOKEN_SIZE),
filename.lstrip(".")))
if not default_storage.exists(ret_path):
break
else:
raise FileExistsError("Unlikely event: no free filename")
return ret_path
def download_document(request, case_pk, document_pk):
qs = Case._default_manager.by_user(user=request.user)
case = qs.filter(pk=case_pk).first()
if not case:
raise PermissionDenied
document = get_object_or_404(Document, id=document_pk)
if request.user.user_type in [WONEN, WONINGCORPORATIE_MEDEWERKER]:
form_status_list = [
f[0] for f in case.casestatus_set.all().order_by(
'form').distinct().values_list('form')
]
shared_in_forms = [f for f in document.forms if f in form_status_list]
if not shared_in_forms:
raise PermissionDenied
if document.case != case:
raise PermissionDenied
if not default_storage.exists(
default_storage.generate_filename(document.uploaded_file.name)):
raise Http404()
return HttpResponseRedirect(document.uploaded_file.url)
def update_attachment(self):
if not self.media_original:
self.media = None
return
original_url = str(self.media_original)
filename = original_url.split('/')[-1]
if not (filename.lower().endswith('.png')
or filename.lower().endswith('.jpg')
or filename.lower().endswith('.jpeg')):
self.media = filename
return
file_content = requests.get(original_url).content
try:
img = Image.open(BytesIO(file_content))
except:
self.media = filename
logging.exception('Loading attachment for processing failed')
return
image_changed = False
orig_mode = img.mode
max_size = (1920, 1080)
# Resize image
if any(actual > max_ for actual, max_ in zip(img.size, max_size)):
scale = min(max_ / actual
for max_, actual in zip(max_size, img.size))
new_size = tuple(int(dim * scale) for dim in img.size)
img = img.resize(new_size, resample=Image.LANCZOS)
image_changed = True
# Draw credit onto image
if self.media_note:
# Create initial image objects for text drawing
img = img.convert('RGBA')
alpha = Image.new('RGBA', img.size, (0, 0, 0, 0))
draw = ImageDraw.Draw(alpha)
# Configuration for text drawing
the_text = 'FOTO: ' + self.media_note.upper()
fontsize = max((img.size[0] + img.size[1]) / 2 / 50, 10)
shadow_radius = fontsize / 3
shadow_mult = 0.75
text_alpha = 0.7
padding = tuple((int(shadow_radius * 2.5), int(shadow_radius * 3)))
position = tuple(int(shadow_radius + p) for p in padding)
fnt = ImageFont.truetype(
str(ASSETS_DIR / 'Open_Sans' / 'OpenSans-SemiBold.ttf'),
int(fontsize))
# Calculate size of text
text_size = draw.textsize(the_text, font=fnt)
# Create new, smaller image to draw the text on
txt = Image.new(
'RGBA',
tuple(ts + pad + pos
for ts, pad, pos in zip(text_size, padding, position)),
(0, 0, 0, 0))
# Do the drawing
draw = ImageDraw.Draw(txt)
draw.text(position, the_text, font=fnt, fill=(0, 0, 0, 255))
shadow = txt.filter(ImageFilter.GaussianBlur(radius=shadow_radius))
txt = shadow.point(lambda px: min(int(px * shadow_mult), 255))
draw = ImageDraw.Draw(txt)
draw.text(position,
the_text,
font=fnt,
fill=(255, 255, 255, int(255 * text_alpha)))
# Rotate and paste onto original image
txt = txt.rotate(90, expand=1, resample=Image.LANCZOS)
alpha.paste(txt,
box=tuple(a - b for a, b in zip(alpha.size, txt.size)))
img = Image.alpha_composite(img, alpha)
image_changed = True
if not image_changed:
self.media = filename
return
# Save result
bio = BytesIO()
bio.name = filename
out = img.convert(orig_mode)
out.save(bio)
bio.seek(0)
new_filename = default_storage.generate_filename(filename)
print('New filename:', new_filename)
path = default_storage.save(new_filename,
ContentFile(bio.read(), name=new_filename))
self.media = path
def testGenerateFilename(self):
self.assertEqual(
default_storage.generate_filename(
os.path.join("foo", ".", "bar.txt")), "foo/bar.txt")
