def get_upload_foldername(file_name, upload_to='%Y/%m'):
# Generate date based path to put uploaded file.
file_field = FileField(upload_to=upload_to)
if not file_name:
file_name = 'no_name'
filename = file_field.generate_filename(None, file_name)
filename = re.sub(r'[_\-]+', '_', filename)
if six.PY2 and isinstance(filename, unicode):
filename = filename.encode('utf-8')
root_dir = os.path.splitext(filename)[0]
parent_dir, _, basename = root_dir.rpartition('/')
image_dir = ''
i = 1
dir_name = basename
while not image_dir:
try:
sub_dirs, _ = default_storage.listdir(parent_dir)
while dir_name in sub_dirs:
dir_name = "%s-%d" % (basename, i)
i += 1
except OSError:
os.makedirs(os.path.join(settings.MEDIA_ROOT, parent_dir))
else:
image_dir = os.path.join(parent_dir, dir_name)
return image_dir
def test_FileField(self):
lazy_func = lazy(lambda: 'filename.ext', six.text_type)
self.assertIsInstance(FileField().get_prep_value(lazy_func()),
six.text_type)
lazy_func = lazy(lambda: 0, int)
self.assertIsInstance(FileField().get_prep_value(lazy_func()),
six.text_type)
def __init__(self, name, storage=None, upload_to=None):
super(FieldFile, self).__init__(None, name)
self.instance = None
self.field = FileField(name='file',
upload_to=upload_to,
storage=storage)
self.storage = self.field.storage
self._committed = True
def get_seedling_img(self):
if self.seedling_img and hasattr(self.seedling_img, 'url'):
return self.seedling_img.url
return ImageFieldFile(
instance=None,
field=FileField(),
name='/media/seedling_img/seedling_default_img.png')
def test_template_tag_imagefield(self):
image = ImageFieldFile(instance=None,
field=FileField(),
name='cat.png')
rendered = self.TEMPLATE.render(Context({'image': image, 'spec': ''}))
self.assertEqual(rendered, '/cat.png.EcGFxfc.png')
class Download(models.Model):
album = models.ForeignKey(Album)
titulo = models.CharField(max_length=100, verbose_name='Título')
data = models.DateTimeField(auto_now_add=True, editable=False)
descricao = models.CharField(max_length=140,
blank=True,
null=True,
verbose_name='Descrição')
arquivo = FileField(upload_to=upload_to_download,
max_length=255,
verbose_name=u'Arquivo')
def __unicode__(self):
return u'%s' % (self.titulo)
def get_extensao(self):
return self.arquivo.path.split('.')[-1]
def icone_existe(self):
extensao = self.arquivo.path.split('.')[-1]
try:
image = Image.open(
os.path.join(
STATIC_ROOT,
os.path.join('imprensa',
os.path.join('images', '%s.png' % extensao))))
return True
except Exception, e:
print e
return False
def get_cart_img(self):
if self.cart_species_img and hasattr(self.cart_species_img, 'url'):
return self.cart_species_img.url
return ImageFieldFile(
instance=None,
field=FileField(),
name='/media/cart_species_img/cart_img_default.png')
def register(request):
if request.method == "POST":
form = RegistrationForm(request.POST)
if form.is_valid():
new_user = form.save(commit=False)
new_user.set_password(form.cleaned_data["password"])
new_user.save()
if settings.AVATAR_SITE:
Profile.objects.create(user = new_user, avatar = ImageFieldFile(instance=None, field=FileField(), name='user_avatars/default.png'))
else:
Profile.objects.create(user = new_user, field=FileField(), name='user_avatars/default.png')
# from django.contrib.auth.models import User
# from django.db.models.fields.files import ImageFieldFile, FileField
# from accounts.forms import Profile
# u = User.objects.get(username = "******")
# p = Profile.objects.get(user = u)
# p.avatar = ImageFieldFile(instance=None, field=FileField(), name='user_avatars/default.png')
return render(request, "accounts/registration_complete.html",
{"new_user": new_user})
else:
form = RegistrationForm()
return render(request, "accounts/register.html", {"user_form": form})
def get_programme_img(self):
if self.programme_img and hasattr(self.programme_img, 'url'):
return self.programme_img.url
return ImageFieldFile(
instance=None,
field=FileField(),
name='/media/programme_img/programme_img_default.png')
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 get_image_display(self):
if self.type == 'video' and not hasattr(self.image, 'url'):
if self._video_update_thumbnail():
return self.image
else:
return ImageFieldFile(instance=None, field=FileField(), name='processing.jpg')
else:
return self.image
def get(self, request):
gdr = GdrService()
m = RtmeFileModel()
m.content = FileField()
files = RtmeFileModel.objects.all()
serializer = RtmeFileSerializer(files, many=True)
return Response(serializer.data, status=status.HTTP_201_CREATED)
class VirtualFieldFile(FieldFile):
def __init__(self, name, storage=None, upload_to=None):
super(FieldFile, self).__init__(None, name)
self.instance = None
self.field = FileField(name='file',
upload_to=upload_to,
storage=storage)
self.storage = self.field.storage
self._committed = True
def get_directory_name(self):
return self.field.get_directory_name()
def get_filename(self, filename):
return self.field.get_filename(filename)
def generate_filename(self, filename):
return self.field.generate_filename(None, filename)
def save(self, *args, **kwargs):
raise NotImplementedError
def delete(self, *args, **kwargs):
raise NotImplementedError
@cached_property
def dimensions(self):
try:
close = self.closed
self.open()
return get_image_dimensions(self, close=close)
except:
return (0, 0)
@cached_property
def width(self):
w, h = self.dimensions
return w
@cached_property
def height(self):
w, h = self.dimensions
return h
class Software(models.Model):
title = CharField(max_length=1000, blank=True, default="")
versionName = CharField(max_length=1000, blank=True, default="")
versionCode = IntegerField(default=0)
lastUpdate = DateField(default=0)
executable = FileField(upload_to="softwares/collector")
class ChartVersion(models.Model):
chart = models.ForeignKey(Chart, related_name='versions', on_delete=models.CASCADE)
version = models.CharField(max_length=14, blank=False, null=False)
tgz = FileField(upload_to='charts')
class Meta:
ordering = ['-version']
def __unicode__(self):
return self.version
class VirtualFieldFile(FieldFile):
def __init__(self, name, storage=None, upload_to=None):
super(FieldFile, self).__init__(None, name)
self.instance = None
self.field = FileField(name='file', upload_to=upload_to, storage=storage)
self.storage = self.field.storage
self._committed = True
def get_directory_name(self):
return self.field.get_directory_name()
def get_filename(self, filename):
return self.field.get_filename(filename)
def generate_filename(self, filename):
return self.field.generate_filename(None, filename)
def save(self, *args, **kwargs):
raise NotImplementedError
def delete(self, *args, **kwargs):
raise NotImplementedError
@cached_property
def dimensions(self):
try:
pil_image = PIL.Image.open(self.path)
except:
return (0, 0)
else:
return pil_image.size
@cached_property
def width(self):
w, h = self.dimensions
return w
@cached_property
def height(self):
w, h = self.dimensions
return h
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 save(self, *args, **kwargs):
if not self.profilepicture:
im = Image.open(DEFAULT_PROFILE_IMAGE_PATH)
full_path = PROJECT_ROOT + MEDIA_URL + 'profilepictures/' + self.user.username + '.png'
print full_path + " :This is the fullpath\n"
im.save(full_path, 'PNG')
short_path = 'profilepictures/' + self.user.username + '.png'
self.profilepicture = ImageFieldFile(instance=None,
name=short_path,
field=FileField())
super(UserProfile, self).save(*args, **kwargs)
class DownloadableProduct(models.Model):
"""
This type of Product is a file to be downloaded
"""
product = models.OneToOneField(Product,
verbose_name=_("Product"),
primary_key=True)
file = FileField(_("File"), upload_to=_protected_dir)
num_allowed_downloads = models.IntegerField(
_("Num allowed downloads"),
help_text=_(
"Number of times link can be accessed. Enter 0 for unlimited."),
default=0)
expire_minutes = models.IntegerField(
_("Expire minutes"),
help_text=
_("Number of minutes the link should remain active. Enter 0 for unlimited."
),
default=0)
active = models.BooleanField(
_("Active"),
help_text=_("Is this download currently active?"),
default=True)
is_shippable = False
is_downloadable = True
def __unicode__(self):
return self.product.slug
def _get_subtype(self):
return 'DownloadableProduct'
def create_key(self):
salt = sha_constructor(str(random.random())).hexdigest()[:5]
download_key = sha_constructor(
salt + smart_str(self.product.name)).hexdigest()
return download_key
def order_success(self, order, order_item):
signals.subtype_order_success.send(self,
product=self,
order=order,
subtype="download")
class Meta:
verbose_name = _("Downloadable Product")
verbose_name_plural = _("Downloadable Products")
def save(self, *args, **kwargs):
if hasattr(self.product, '_sub_types'):
del self.product._sub_types
super(DownloadableProduct, self).save(*args, **kwargs)
def get_upload_foldername(file_name, upload_to='%Y/%m'):
# Generate date based path to put uploaded file.
file_field = FileField(upload_to=upload_to)
if not file_name:
file_name = 'no_name'
filename = file_field.generate_filename(None, file_name)
filename = re.sub(r'[_\-]+', '_', filename)
if six.PY2 and isinstance(filename, unicode):
filename = filename.encode('utf-8')
root_dir = os.path.splitext(filename)[0]
root_dir = dir_name = os.path.join(settings.MEDIA_ROOT, root_dir)
i = 1
while os.path.exists(dir_name):
if six.PY2:
dir_name = b'%s-%d' % (root_dir, i)
else:
dir_name = '%s-%d' % (root_dir, i)
i += 1
os.makedirs(dir_name)
return dir_name
class Track(models.Model):
photo = models.ImageField(default='', null=True)
title = CharField(max_length=100, null=False)
file = FileField(null=False, unique=True)
album = models.ForeignKey(Album,
on_delete=models.CASCADE,
related_name="tracks",
null=False,
blank=False)
date = models.DateField(default=date.today)
fans = models.ManyToManyField(User, related_name='fav_tracks', blank=True)
kinds = models.ManyToManyField(Kind, related_name="tracks", blank=True)
def __str__(self):
return f"{self.id}, {self.title}"
class CourseFiles(models.Model):
sourceSection = ForeignKey(
"Section",
verbose_name="所属节",
on_delete=SET_NULL,
related_name="sourceSection",
blank=True,
null=True,
)
courseFile = FileField(upload_to=Upload_File_Path, blank=True, null=True)
def __str__(self) -> str:
return self.courseFile.name
def filename(self):
return os.path.basename(self.courseFile.name)
class Meta:
ordering = ["sourceSection"]
verbose_name = "文件名"
verbose_name_plural = "文件名"
def render(self, name, value, attrs=None):
output = []
flag = False
if value and getattr(value, "url", None):
image_url = value.url
image_url = '/static/' + image_url
output.append(u' <a href="%s" target="_blank"><img style="width:280px;" src="%s"/></a> ' % \
(image_url, image_url))
file_field = FileField()
file_field.name = image_url
file_field.path = value.path
file_field.url = '/static/' + value.name
file_field.model = Product
flag = True
if flag:
output.append(super(AdminFileWidget, self).render(name,
file_field,
attrs))
else:
output.append(super(AdminFileWidget, self).render(name,
value,
attrs))
return mark_safe(u''.join(output))
class TestModel(models.Model):
File = FileField()
def test_FileField(self):
self.assertIsInstance(FileField().get_prep_value('filename.ext'), unicode)
self.assertIsInstance(FileField().get_prep_value(0), unicode)
def get_photo(self):
if self.photo:
return self.photo
return ImageFieldFile(instance=None,
field=FileField(),
name='photo/g.jpg')
class File(models.Model):
file = FileField(upload_to=UPLOAD_DIRS)
created_on = DateTimeField(auto_now_add=True)
modifed_on = DateTimeField(auto_now_add=True, auto_now=True)
def test_FileField(self):
self.assertIsInstance(FileField().get_prep_value('filename.ext'),
six.text_type)
self.assertIsInstance(FileField().get_prep_value(0), six.text_type)
def get_post_thumbnail(self):
if self.thumbnail_img and hasattr(self.thumbnail_img, 'url'):
return self.thumbnail_img.url
return ImageFieldFile(instance=None,
field=FileField(),
name='/media/thumbnail/blog_default.png')
def __init__(self, name, storage=None, upload_to=None):
super(FieldFile, self).__init__(None, name)
self.instance = None
self.field = FileField(name='file', upload_to=upload_to, storage=storage)
self.storage = self.field.storage
self._committed = True
def handle(self, *args, **options):
print("Populating database...")
start_time = datetime.datetime.now().replace(microsecond=0)
file = open("/home/cole/Desktop/members.csv", "r")
file.readline()
file.readline()
current_line = file.readline()
count = 1
while current_line != '':
processed = current_line.split(",")
name = self.fix_name_format(processed[0])
if name == "Cole Polyak":
account = User.objects.get(username="******")
brother = Members.objects.get_or_create(
user=account,
name=name,
legal_name=legal_name,
phone=processed[2].strip(),
address=processed[3].strip().replace("\"", ""),
email=processed[4].strip(),
rollnumber=int(processed[5].strip()),
member_score=0,
inactive_flag=not bool(processed[6].strip()),
abroad_flag=not bool(processed[7].strip()),
present=0,
position=self.get_position(processed[8]),
avatar=ImageFieldFile(instance=None, field=FileField(), name='static/images/default.jpg')
)[0]
count += 1
current_line = file.readline()
continue
legal_name = self.fix_name_format(processed[1])
account = User.objects.create_user(
username=name.lower().replace(" ", "."),
email=processed[4].strip(),
password='******'
)
brother = Members.objects.get_or_create(
user=account,
name=name,
legal_name=legal_name,
phone=processed[2].strip(),
address=processed[3].strip().replace("\"", ""),
email=processed[4].strip(),
rollnumber=int(processed[5].strip()),
member_score=0,
inactive_flag=not bool(processed[6].strip()),
abroad_flag=not bool(processed[7].strip()),
present=0,
position=self.get_position(processed[8]),
avatar=ImageFieldFile(instance=None, field=FileField(), name='static/images/default.jpg')
)[0]
count += 1
current_line = file.readline()
end_time = datetime.datetime.now().replace(microsecond=0)
print("Populating complete...")
print("Wrote " + str(count) + " entries in " + str(end_time - start_time))
def __init__(self, verbose_name=None, name=None, duration_field=None, bitrate_field=None, **kwargs):
self.duration_field, self.bitrate_field = duration_field, bitrate_field
FileField.__init__(self, verbose_name, name, **kwargs)
from django.test import TestCase
from django.contrib.auth.models import User
from django.db.models.fields.files import FileField, ImageFieldFile
from django.utils import timezone
from Post.models import Post
user = User.objects.create(username='******',
email="*****@*****.**",
password="******")
title = "Testing Title"
category = 0
post_img = ImageFieldFile(instance=None,
field=FileField(),
name="products/1397908421/1397908421.jpg")
published = True
published_date = timezone.now()
created_date = timezone.now()
description = "Just a description for testing Kali Scientist Blog Model"
class PostModelTest(TestCase):
@classmethod
def setUpTestData(cls):
Post.objects.create(author=user,
title=title,
category=category,
post_img=post_img,
published=published,
published_date=published_date,
created_date=created_date,
