def filecolumn_supports_fieldfile(column, storage):
field = models.FileField(storage=storage)
name = "child/foo.html"
fieldfile = FieldFile(instance=None, field=field, name=name)
root = parse(column.render(value=fieldfile))
assert root.tag == "a"
assert root.attrib == {
"class": "a exists",
"title": name,
"href": "/baseurl/child/foo.html"
}
assert root.text == "foo.html"
# Now try a file that doesn't exist
name = "child/does_not_exist.html"
fieldfile = FieldFile(instance=None, field=field, name=name)
html = column.render(value=fieldfile)
root = parse(html)
assert root.tag == "a"
assert root.attrib == {
"class": "a missing",
"title": name,
"href": "/baseurl/child/does_not_exist.html"
}
assert root.text == "does_not_exist.html"
def test_filecolumn_supports_fieldfile(self):
field = models.FileField(storage=storage())
name = "child/foo.html"
class Table(tables.Table):
filecolumn = column()
table = Table([{
"filecolumn":
FieldFile(instance=None, field=field, name=name)
}])
html = table.rows[0].get_cell("filecolumn")
root = parse(html)
self.assertEqual(root.tag, "a")
self.assertEqual(root.attrib, {
"class": "a",
"href": "/baseurl/child/foo.html"
})
span = root.find("span")
self.assertEqual(span.tag, "span")
self.assertEqual(span.text, "foo.html")
# Now try a file that doesn't exist
name = "child/does_not_exist.html"
fieldfile = FieldFile(instance=None, field=field, name=name)
root = parse(column().render(value=fieldfile, record=None))
self.assertEqual(root.tag, "span")
self.assertEqual(root.attrib, {"class": "span missing", "title": name})
self.assertEqual(root.text, "does_not_exist.html")
def test_filecolumn_supports_fieldfile(column, storage):
field = models.FileField(storage=storage)
name = 'child/foo.html'
fieldfile = FieldFile(instance=None, field=field, name=name)
root = parse(column.render(value=fieldfile))
assert root.tag == 'a'
assert root.attrib == {
'class': 'a exists',
'title': name,
'href': '/baseurl/child/foo.html'
}
assert root.text == 'foo.html'
# Now try a file that doesn't exist
name = 'child/does_not_exist.html'
fieldfile = FieldFile(instance=None, field=field, name=name)
html = column.render(value=fieldfile)
root = parse(html)
assert root.tag == 'a'
assert root.attrib == {
'class': 'a missing',
'title': name,
'href': '/baseurl/child/does_not_exist.html'
}
assert root.text == 'does_not_exist.html'
def __getattribute__(self, name):
fallback = object.__getattribute__(self, 'fallback')
attr = object.__getattribute__(self, name)
opts = object.__getattribute__(self, '_meta')
default_lang = object.__getattribute__(self, 'default_language_code')
active_lang = get_language()
if name not in opts.translatable_fields or default_lang == active_lang:
return attr
translated = object.__getattribute__(self, '_translated')
if translated:
if hasattr(translated, name):
_field = self._meta.get_field(name)
if isinstance(_field, ImageField):
return ImageFieldFile(
self, _field,
getattr(translated, name, attr if fallback else ''))
elif isinstance(_field, FileField):
return FieldFile(
self, _field,
getattr(translated, name, attr if fallback else ''))
else:
return getattr(translated, name, attr if fallback else '')
elif hasattr(translated, '__iter__') and (active_lang in translated
or name in translated):
try:
return translated.get(active_lang).get(name, '')
except Exception as e:
print('exception happened in model getattribute', e)
return attr
def _get_value(self):
primitive_models_dict = MetaModel.get_primitive_models_dict()
mtype = primitive_models_dict.get(self.model_id, None)
if mtype:
mtype = mtype.name
if mtype == 'BooleanField':
return bool(self.decimal_value)
if mtype == 'CharField':
return self.unicode_value
if mtype == 'DateField':
return date.fromordinal(self.decimal_value)
if mtype == 'DateTimeField':
epoch = datetime.utcfromtimestamp(0)
delta = timedelta(seconds=int(self.decimal_value))
return epoch + delta
if mtype == 'DecimalField':
return self.decimal_value
if mtype == 'FileField':
return FieldFile(default_storage.open(self.unicode_value),
FileField(), self.unicode_value)
if mtype == 'IntegerField':
return int(self.decimal_value)
return self.__getattr__('value')
def __init__(self, *args, **kwargs):
super(OptionsForm, self).__init__(*args, **kwargs)
self.not_options = kwargs.pop('not_options', self.not_options) or ()
self.readonly_fields = kwargs.pop('readonly_fields',
self.readonly_fields) or ()
for key in self.get_option_fields():
value = get_option(self._get_key(key))
if key in self.initial and value == self.initial[key]:
continue
# all options has initial value
self.initial[key] = value
if self.initial[key] and isinstance(self.fields[key],
forms.FileField):
from django.core.files.storage import default_storage
from django.db.models.fields.files import FieldFile
self.initial[key] = FieldFile(
None,
type('StumbField', (object, ),
{'storage': default_storage}), self.initial[key])
self.fields[REQUEST_CODE_KEY] = forms.CharField(
widget=forms.HiddenInput, max_length=255, initial=self.get_code())
def test_render_nonimage(self):
"""
``ImageWidget`` renders the file input only, if given a non-image.
"""
widget = ImageWidget()
html = widget.render('fieldname', FieldFile(None, FileField(), 'something.txt'))
self.assertHTMLEqual(html, '<input type="file" name="fieldname" />')
def create(self, validated_data):
source_legend = validated_data.pop("source_legend") if "source_legend" in validated_data else None
instance = super(RecordSerializer,self).create(validated_data)
self.instance = instance
if source_legend:
instance.source_legend = FieldFile(self.instance,Record._meta.get_field("source_legend"),self.legend_file_name(source_legend))
instance.source_legend.save(self.legend_file_name(source_legend),source_legend['content'],save=False)
return instance
def test_clearable_file_widget(self):
field = RevisionFileField()
doc = DocumentFactory()
file_field = FieldFile(doc, field, 'revisions/toto.pdf')
widget = PhaseClearableFileInput()
rendered = widget.render('toto.pdf', file_field)
self.assertTrue('>toto.pdf<' in rendered)
self.assertTrue('>revisions/toto.pdf<' not in rendered)
def update(self, instance, validated_data):
source_legend = validated_data.pop("source_legend") if "source_legend" in validated_data else None
if source_legend:
if instance.source_legend:
instance.source_legend.delete(save=False)
instance.source_legend = FieldFile(instance,Record._meta.get_field("source_legend"),self.legend_file_name(source_legend))
instance.source_legend.save(self.legend_file_name(source_legend),source_legend['content'],save=False)
elif instance.source_legend:
instance.source_legend.delete(save=False)
return super(RecordSerializer,self).update(instance,validated_data)
def test_django_to_filetracker_path(self):
storage = FiletrackerStorage(prefix='/foo', client=DummyClient())
field = FileField(storage=storage)
value = FieldFile(None, field, 'bar')
self.assertEqual(django_to_filetracker_path(value), '/foo/bar')
with self.assertRaises(ValueError):
django_to_filetracker_path(ContentFile('whatever', name='gizmo'))
self.assertEqual('/foo/bar', django_to_filetracker_path(
filetracker_to_django_file('/foo/bar', storage=storage)))
def pre_save(self, model_instance, add):
"Returns field's value just before saving."
file = FieldFile(
model_instance, self,
super(FileField, self).pre_save(model_instance, add).meta_content)
tag = super(FileField, self).pre_save(model_instance,
add) # Let's hack this
if hasattr(tag, '_inmemoryuploadedfile') and getattr(
tag, '_inmemoryuploadedfile'):
file.save(file.name, tag._inmemoryuploadedfile, save=False)
return file
def get_existing_data(self, raw=False):
data = self.steps.get_existing_data()[self.index]
fields = self.get_form_fields()
if not raw:
class FakeField:
storage = self.steps.get_storage()
for field_name, value in data.items():
if field_name in fields and isinstance(fields[field_name],
FileField):
data[field_name] = FieldFile(None, FakeField, value)
return data
def get_some_file(path):
subdirs, files = field.storage.listdir(path)
if files:
result_file = random.choice(files)
instance = field.storage.open("%s/%s" % (path, result_file)).file
return FieldFile(instance, field, result_file)
for subdir in subdirs:
result = get_some_file("%s/%s" % (path, subdir))
if result:
return result
def test_generic(self):
field = FileField(name='test', upload_to=self.upload_to)
fake_model = type(str('fake'), (object, ), {field.name: None})
_file = FieldFile(field=field, instance=fake_model(), name='')
_file._committed = False
with open(self.archive, 'rb') as f:
_file.save('test.zip', ContentFile(f.read()), save=False)
self.assertEqual(
_file.name, 'archive/da39a3ee5e6b4b0d3255bfef95601890afd80709.zip')
_file.delete(save=False)
def __getitem__(self, key):
if key in self.field.thumbnails:
if key not in self.data and 'original' in self.data:
#generate image
name = self.name
base_name, base_ext = os.path.splitext(os.path.basename(name))
try:
source_image = self.image()
except IOError:
if self.field.no_image is not None:
return self.field.no_image
return FieldFile(self.instance, self.field, None)
config = self.field.thumbnails[key]
thumb_name = '%s-%s%s' % (base_name, key, base_ext)
self.data[key] = self._process_thumbnail(source_image, thumb_name, config)
self.instance.save()
if key in self.data:
return ImageFile(self.instance, self.field, self.data, key)
if self.field.no_image is not None:
return self.field.no_image
return FieldFile(self.instance, self.field, None)
raise KeyError
def set_alignment_file_contents(self, value):
# cache the value
self._alignment_file_contents = value
# and save to permanent storage
if not self.local_file:
model_field = self.local_file.field # note this works even though self.local_file is falsy
upload_filename = model_field.generate_filename(
self, "%d.%s" % (self.id, self.format))
self.local_file = FieldFile(instance=self,
field=model_field,
name=upload_filename)
self.save()
# Django FieldFile open() method fails if the file doesn't exist in filesystem (even using mode 'w')
upload_file = open(self.local_file.path, 'w')
upload_file.write(value)
upload_file.close()
def test_serialize_model_instance(self, model_to_dict):
model_to_dict.return_value = {
'date': datetime.date(2014, 12, 31),
'time': datetime.time(0, 0, 0),
'decimal': Decimal(1.0),
'str': b'str',
'unicode': 'unicode',
'file': FieldFile(instance=None, field=MagicMock(), name='foo')
}
expected_result = {
'date': datetime.datetime(2014, 12, 31),
'time': datetime.datetime(1, 1, 1, 0, 0, 0),
'decimal': 1.0,
'str': 'str',
'unicode': 'unicode',
'file': 'foo'
}
serialized_instance = utils.serialize_model_instance(None)
self.assertDictEqual(expected_result, serialized_instance)
from django.core.paginator import Paginator, PageNotAnInteger, EmptyPage
from django.db.models.fields.files import FieldFile
from django.views.generic import FormView
from django.views.generic.base import TemplateView
from django.contrib import messages
from .forms import ContactForm, FilesForm
# http://yuji.wordpress.com/2013/01/30/django-form-field-in-initial-data-requires-a-fieldfile-instance/
class FakeField(object):
storage = default_storage
fieldfile = FieldFile(None, FakeField, 'dummy.txt')
class HomePageView(TemplateView):
template_name = 'demo/home.html'
def get_context_data(self, **kwargs):
context = super(HomePageView, self).get_context_data(**kwargs)
messages.info(self.request, 'This is a demo of a message.')
return context
class DefaultFormView(FormView):
template_name = 'demo/form.html'
form_class = ContactForm
def add_attachment(request, wiki_url):
(article, path, err) = fetch_from_url(request, wiki_url)
if err:
return err
perm_err = check_permissions(request,
article,
check_write=True,
check_locked=True)
if perm_err:
return perm_err
if not WIKI_ALLOW_ATTACHMENTS or (not WIKI_ALLOW_ANON_ATTACHMENTS
and request.user.is_anonymous()):
return HttpResponseForbidden()
if request.method == 'POST':
if request.FILES.__contains__('attachment'):
attachment = ArticleAttachment()
if not request.user.is_anonymous():
attachment.uploaded_by = request.user
attachment.article = article
file = request.FILES['attachment']
file_rel_path = get_attachment_filepath(attachment, file.name)
chunk_size = request.upload_handlers[0].chunk_size
filefield = FieldFile(attachment, attachment.file, file_rel_path)
attachment.file = filefield
file_path = WIKI_ATTACHMENTS_ROOT + attachment.file.name
if not request.POST.__contains__('overwrite') and os.path.exists(
file_path):
c = Context({
'overwrite_warning': True,
'wiki_article': article,
'filename': file.name
})
t = loader.get_template('simplewiki_updateprogressbar.html')
return HttpResponse(t.render(c))
if file.size > WIKI_ATTACHMENTS_MAX:
c = Context({
'too_big': True,
'max_size': WIKI_ATTACHMENTS_MAX,
'wiki_article': article,
'file': file
})
t = loader.get_template('simplewiki_updateprogressbar.html')
return HttpResponse(t.render(c))
def get_extension(fname):
return attachment.file.name.split('.')[-2]
if WIKI_ATTACHMENTS_ALLOWED_EXTENSIONS and not \
get_extension(attachment.file.name) in WIKI_ATTACHMENTS_ALLOWED_EXTENSIONS:
c = Context({
'extension_err': True,
'extensions': WIKI_ATTACHMENTS_ALLOWED_EXTENSIONS,
'wiki_article': article,
'file': file
})
t = loader.get_template('simplewiki_updateprogressbar.html')
return HttpResponse(t.render(c))
# Remove existing attachments
# TODO: Move this until AFTER having removed file.
# Current problem is that Django's FileField delete() method
# automatically deletes files
for a in article.attachments():
if file_rel_path == a.file.name:
a.delete()
def receive_file():
destination = open(file_path, 'wb+')
size = file.size
cnt = 0
c = Context({
'started': True,
})
t = loader.get_template('simplewiki_updateprogressbar.html')
yield t.render(c)
for chunk in file.chunks():
cnt += 1
destination.write(chunk)
c = Context({
'progress_width': (cnt * chunk_size) / size,
'wiki_article': article,
})
t = loader.get_template(
'simplewiki_updateprogressbar.html')
yield t.render(c)
c = Context({
'finished': True,
'wiki_article': article,
})
t = loader.get_template('simplewiki_updateprogressbar.html')
destination.close()
attachment.save()
yield t.render(c)
return HttpResponse(receive_file())
return HttpResponse('')
def setUp(self):
self.f = create_image()
ff = FieldFile(None, RasterStore._meta.get_field('image'),
os.path.basename(self.f.name))
self.data = {'image': ff}
def setUp(self):
name = self.f.name.replace('%s/' % default_storage.location, '')
ff = FieldFile(None, RasterStore._meta.get_field('image'), name)
self.data = {'image': ff}
from django.contrib import messages
from django.core.files.storage import default_storage
from django.core.paginator import EmptyPage, PageNotAnInteger, Paginator
from django.db.models.fields.files import FieldFile
from django.views.generic import FormView
from django.views.generic.base import TemplateView
from .forms import ContactForm, ContactFormSet, FilesForm
# http://yuji.wordpress.com/2013/01/30/django-form-field-in-initial-data-requires-a-fieldfile-instance/
class FakeField(object):
storage = default_storage
fieldfile = FieldFile(None, FakeField, "dummy.txt")
class HomePageView(TemplateView):
template_name = "app/home.html"
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
messages.info(self.request, "hello http://example.com")
return context
class GetParametersMixin:
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context["layout"] = self.request.GET.get("layout", None)
def test_select_model(self, mock_fetchmany, mock_execute):
expected_field_names = [
'"TEST_DHP_COMPLEXMODEL"."BIG_INTEGER_FIELD"',
'"TEST_DHP_COMPLEXMODEL"."BINARY_FIELD"',
'"TEST_DHP_COMPLEXMODEL"."BOOLEAN_FIELD"',
'"TEST_DHP_COMPLEXMODEL"."CHAR_FIELD"',
'"TEST_DHP_COMPLEXMODEL"."DATE_FIELD"',
'"TEST_DHP_COMPLEXMODEL"."DATE_TIME_FIELD"',
'"TEST_DHP_COMPLEXMODEL"."DECIMAL_FIELD"',
'"TEST_DHP_COMPLEXMODEL"."DURATION_FIELD"',
'"TEST_DHP_COMPLEXMODEL"."EMAIL_FIELD"',
'"TEST_DHP_COMPLEXMODEL"."FILE_FIELD"',
'"TEST_DHP_COMPLEXMODEL"."FILE_PATH_FIELD"',
'"TEST_DHP_COMPLEXMODEL"."FLOAT_FIELD"',
'"TEST_DHP_COMPLEXMODEL"."IMAGE_FIELD"',
'"TEST_DHP_COMPLEXMODEL"."INTEGER_FIELD"',
'"TEST_DHP_COMPLEXMODEL"."GENERIC_IP_ADDRESS_FIELD"',
'"TEST_DHP_COMPLEXMODEL"."NULL_BOOLEAN_FIELD"',
'"TEST_DHP_COMPLEXMODEL"."POSITIVE_INTEGER_FIELD"',
'"TEST_DHP_COMPLEXMODEL"."POSITIVE_SMALL_INTEGER_FIELD"',
'"TEST_DHP_COMPLEXMODEL"."SLUG_FIELD"',
'"TEST_DHP_COMPLEXMODEL"."SMALL_INTEGER_FIELD"',
'"TEST_DHP_COMPLEXMODEL"."TEXT_FIELD"',
'"TEST_DHP_COMPLEXMODEL"."TIME_FIELD"',
'"TEST_DHP_COMPLEXMODEL"."URL_FIELD"',
'"TEST_DHP_COMPLEXMODEL"."UUID_FIELD"',
]
expected_statements = [
call(
'SELECT "TEST_DHP_COMPLEXMODEL"."ID", %(field_names)s FROM "TEST_DHP_COMPLEXMODEL"'
% {
'field_names': ', '.join(expected_field_names),
}, ()),
]
mock_fetchmany.side_effect = [
[
tuple(self.valid_db_values),
],
]
objects = list(
ComplexModel.objects.all()) # trigger database query with list()
self.assertEqual(len(objects), 1)
self.assertEqual(objects[0].id, 1234)
self.assertEqual(objects[0].big_integer_field, 9223372036854775807)
self.assertEqual(objects[0].binary_field, b'foobar')
self.assertEqual(objects[0].boolean_field, False)
self.assertEqual(objects[0].char_field, 'foobar')
self.assertEqual(objects[0].date_field, datetime.date(2017, 1, 1))
self.assertEqual(objects[0].date_time_field,
datetime.datetime(2017, 1, 1, 13, 45, 21))
self.assertEqual(objects[0].decimal_field, 123.45)
self.assertEqual(objects[0].duration_field,
datetime.timedelta(0, 1234, 567890))
self.assertEqual(objects[0].email_field, '*****@*****.**')
self.assertEqual(
objects[0].file_field,
FieldFile(objects[0], objects[0].file_field, 'uploads/foobar.txt'))
self.assertEqual(objects[0].file_path_field, 'uploads/barbaz.txt')
self.assertEqual(objects[0].float_field, 12.34567)
self.assertEqual(objects[0].image_field, 'uploads/image.png')
self.assertEqual(objects[0].integer_field, -2147483648)
self.assertEqual(objects[0].generic_ip_address_field, '192.0.2.30')
self.assertEqual(objects[0].null_boolean_field, None)
self.assertEqual(objects[0].positive_integer_field, 2147483647)
self.assertEqual(objects[0].positive_small_integer_field, 32767)
self.assertEqual(objects[0].slug_field, 'something-foobar-1234')
self.assertEqual(objects[0].small_integer_field, -32768)
self.assertEqual(objects[0].text_field, 'some long text')
self.assertEqual(objects[0].time_field, datetime.time(13, 45, 21))
self.assertEqual(objects[0].url_field, 'https://foo.bar.com/baz/')
self.assertEqual(objects[0].uuid_field,
uuid.UUID('12345678-12345678-12345678-12345678'))
self.assertSequenceEqual(mock_execute.call_args_list,
expected_statements)
