class Image(Model):
"""Uploaded image model."""
name = CharField(max_length=255)
original = ImageField(upload_to='original')
resized = ImageField(upload_to='resized', null=True)
def resize(self, width, height):
image = pillow_image.open(self.original)
image.thumbnail((width or height, height or width))
image_bytes = BytesIO()
image.save(image_bytes, format='png')
image.close()
self.resized.delete(save=False)
self.resized.save(self.name, ImageFile(image_bytes))
def delete(self):
self.original.delete(save=False)
self.resized.delete(save=False)
return super().delete()
def assert_existence(self):
if self.original.storage.exists(self.original.path):
return True
self.delete()
return False
class Item(Model):
seller = ForeignKey(Seller)
name = CharField(max_length=30)
image = ImageField(null=True, blank=True)
image_b = ImageField(null=True, blank=True)
image_c = ImageField(null=True, blank=True)
image_d = ImageField(null=True, blank=True)
class Image(Model):
user = ForeignKey(User, on_delete=CASCADE)
image = ImageField(upload_to=get_file_path)
thumbnail200 = ImageField(blank=True, null=True, upload_to=get_file_path)
thumbnail400 = ImageField(blank=True, null=True, upload_to=get_file_path)
def __str__(self):
return f"{self.user}, {self.image}"
def update_dimension_fields(self, instance, force=False, *args, **kwargs):
"""
Since we're encrypting the file, any attempts to force recalculation of
the dimensions will always fail, resulting in a null value for height
and width. To avoid that, we just set force=False all the time and
expect that if you want to change those values, you'll do it on your
own.
"""
ImageField.update_dimension_fields(
self, instance, force=False, *args, **kwargs)
class Post(models.Model):
title = models.CharField(max_length=155)
url = models.URLField(max_length=255)
description = models.TextField(max_length=255)
photo = ImageField(blank=True, manual_crop="")
technologies = models.CharField(max_length=200, blank=True)
user = models.ForeignKey(User,
on_delete=models.CASCADE,
related_name="posts")
date = models.DateTimeField(auto_now_add=True, blank=True)
def __str__(self):
return f'{self.title}'
def delete_post(self):
self.delete()
@classmethod
def search_project(cls, title):
return cls.objects.filter(title__icontains=title).all()
@classmethod
def all_posts(cls):
return cls.objects.all()
def save_post(self):
self.save()
class EventoBase(Model, CT):
categoria = ForeignKey(CategoriaEvento)
title = CharField('titulo', max_length=250)
description = TextField('descripción', blank=True, null=True)
slug = SlugField(db_index=True)
rating = GenericRelation(Rating)
start = DateTimeField('comienzo')
end = DateTimeField('fin')
precio = CharField('precio', max_length=250)
poster = ImageField(upload_to='cartelera/posters', blank=True, null=True)
type = CharField(max_length=250)
def __unicode__(self):
return self.title
def render(self):
return render_to_string(
[
'cartelera/%s_lead.html' % self.categoria.slug,
'cartelera/evento_lead.html'
],
{'%s' % self.categoria.slug: self},
)
def get_absolute_url(self):
return reverse('evento', kwargs={'slug': self.slug})
class BlogPost(models.Model):
STATUS_CHOICE = (
('draft', 'Draft'),
('published', 'Published'),
)
author = models.ForeignKey(Author,
on_delete=models.CASCADE,
related_name='blog_posts')
title = models.CharField(max_length=200, )
overview = models.CharField(max_length=150, default='', blank=True)
slug = models.SlugField(null=True, unique=True)
thumbnail = models.ImageField(upload_to=upload_location,
null=True,
blank=True)
icon = ImageField(upload_to=upload_location, null=True, blank=True)
content = HTMLField()
publish = models.DateTimeField(default=timezone.now)
date_created = models.DateTimeField(auto_now_add=True,
verbose_name="date_published")
date_updated = models.DateTimeField(auto_now=True,
verbose_name="date_updated")
status = models.CharField(max_length=10,
choices=STATUS_CHOICE,
default='draft')
featured = models.BooleanField()
def save(self, *args, **kwargs):
self.slug = self.slug or slugify(self.title)
super().save(*args, **kwargs)
class Meta:
ordering = ('-publish', )
def __str__(self):
return self.title
class Company(models.Model):
name = models.CharField(max_length=30, null=True, blank=True)
about = models.CharField(max_length=1500, null=True, blank=True)
logo = ImageField(upload_to=get_image_path, blank=True, null=True)
def __str__(self):
return self.name
class Member(AbstractUser):
username = None
USERNAME_FIELD = 'phone'
REQUIRED_FIELDS = []
phone = models.CharField(max_length=11, blank=False, null=False, unique=True,
validators=[mobile_regex],
error_messages={
'unique': _("A user with that phone already exists."),
})
birth_date = models.DateField(null=True, blank=True)
profile_picture = ImageField(upload_to='profile_pictures/', null=True, blank=True)
profession = models.CharField(max_length=32)
education = models.CharField(max_length=30, choices=EDUCATION_CHOICES)
city = models.CharField(max_length=60)
province = models.CharField(max_length=60)
address = models.CharField(max_length=60)
balance = models.IntegerField(default=1000, unique=False)
invitation_code = models.CharField(max_length=10, blank=True, null=True)
objects = MemberManager()
invited_with = models.CharField(max_length=10, blank=True, null=True)
@property
def age(self):
if self.birth_date is not None:
return datetime.date.today() - self.birth_date
return None
@property
def image_url(self):
if self.profile_picture is not None and self.profile_picture != "":
return self.profile_picture
else:
return get_url(None, 'members/icons/default_profile.png')
@auto_save
def increase_balance(self, amount):
self.balance += amount
@auto_save
def decrease_balance(self, amount):
self.balance -= amount
@property
def full_name(self):
full_name = self.first_name + " " + self.last_name
full_name = full_name.strip()
if full_name == "":
full_name = self.phone
return full_name
def get_invitation_code(self):
if self.invitation_code is None:
self.invitation_code = generate_invitation_unique_code()
self.save()
return self.invitation_code
@property
def new_loan_requests(self):
return Loan.objects.all().filter(book__owner=self, state__state=LoanState.STATE_NEW)
class Entrada_Blog(models.Model):
productor = models.ForeignKey(Productor, on_delete=models.CASCADE)
#comentarios
############################
titulo = models.CharField(max_length=100)
cuerpo = models.CharField(max_length=2500)
imagen = ImageField(upload_to=get_image_path, blank=True, null=True)
fecha = models.DateTimeField()
class Image(models.Model):
user = ForeignKey(User, on_delete=models.SET_NULL, null=True)
original = ImageField(upload_to='images/')
thumbnail_m = ImageField(upload_to='images/thumbnails/m/',
blank=True,
null=True)
thumbnail_s = ImageField(upload_to='images/thumbnails/s/',
blank=True,
null=True)
def __str__(self):
return str(self.original.url)
def save(self, *args, **kwargs):
self.thumbnail_s = make_thumbnail(self.original, (200, 200))
self.thumbnail_m = make_thumbnail(self.original, (400, 400))
super().save(*args, **kwargs)
class BaskDrink(TimeStampedModel):
name = CharField(max_length=50)
image = ImageField()
description = TextField(null=True, blank=True)
class Meta:
abstract = True
def test_custom_file_widget(self):
"""
``ClearableFileInput`` respects its ``file_widget`` argument.
"""
widget = ClearableFileInput(file_widget=ImageWidget())
html = widget.render('fieldname', ImageFieldFile(None, ImageField(), 'tiny.png'))
self.assertTrue('<img' in html)
class Worksheet(ContentModel):
instructions = TextField(blank=True, null=True)
background = ImageField(upload_to="lessons/worksheets/backgrounds/")
field_data = json.JSONField(blank=True, null=True)
related_content = ManyToManyField(RelatedContent,
blank=True,
null=True,
related_name='worksheets')
class CardType(Model):
name = CharField(max_length=30)
logo = ImageField(upload_to='type', null=True, blank=True)
def __unicode__(self):
"""
The string representation of the card type.
"""
return self.name
class Rarity(Model):
name = CharField(max_length=30)
logo = ImageField(upload_to='rarity', null=True, blank=True)
def __unicode__(self):
"""
The string representation of the rarity.
"""
return self.name
class Station(models.Model):
Address = models.CharField(max_length=255, blank=True)
TelephoneNumber = models.CharField(max_length=255, blank=True)
PhoneNumbers = models.CharField(max_length=255, blank=True)
EmailAddress = models.EmailField(blank=True, null=True)
BFPLogo = ImageField(
null=True,
blank=True,
)
StationLogo = ImageField(null=True, blank=True)
ChiefOfficer = models.ForeignKey(Personnel,
on_delete=models.SET_NULL,
null=True,
blank=True,
related_name='officer_bfp')
def __str__(self):
return self.Address
def test_custom_template(self):
"""
``ImageWidget`` respects a custom template.
"""
widget = ImageWidget(template='<div>%(image)s</div>'
'<div>%(input)s</div>')
html = widget.render('fieldname', ImageFieldFile(None, ImageField(), 'tiny.png'))
self.assertTrue(html.startswith('<div><img'))
class Badge(Model):
name = CharField(max_length=50)
picture = ImageField()
description = CharField(max_length=200, default="Test")
def __str__(self):
return self.name
def __unicode__(self):
return self.name
def save_form_data(self, instance, data):
""" override StdImageField save data to run validators
before delete file """
if self.delete_orphans and self.blank and (data is False
or data is not None):
file = getattr(instance, self.name)
if file and file._committed and file != data:
if data is False:
# clear file
file.delete(save=False)
else:
# run validators and delete file if no error
try:
self.run_validators(data)
except ValidationError:
pass
else:
file.delete(save=False)
ImageField.save_form_data(self, instance, data)
class User(AbstractBaseUser, PermissionsMixin):
"""カスタムユーザーモデル"""
username = models.CharField("ユーザー名", unique=True, blank=False, max_length=100)
email = models.EmailField("メールアドレス")
avatar = models.URLField("アイコン(SNSから取得)", max_length=200, blank=True)
profile_icon = ImageField("アイコン", upload_to='profile_icons', blank=True, null=True)
is_staff = models.BooleanField("is_staff", default=False)
is_active = models.BooleanField("is_active", default=True)
date_joined = models.DateTimeField("date_joined", default=timezone.now)
faved_characters = models.ManyToManyField(
Character,
verbose_name='好きなキャラ',
through="FavedCharacter",
blank=True,
)
faved_movies = models.ManyToManyField(
Movie,
verbose_name='お気に入り映画',
through="FavedMovie",
blank=True,
related_name='faved_users' # 逆参照時の定義。movie.faved_usersでお気に入りしているユーザー一覧が取れる。ユーザーの数が取れるため、多い順などでとれる
)
watched_movies = models.ManyToManyField(
Movie,
verbose_name='閲覧済',
through="WatchedMovie",
blank=True,
related_name='watched_movie'
)
objects = UserManager()
USERNAME_FIELD = "username"
EMAIL_FIELD = "email"
REQUIRED_FIELDS = ['email']
DEFAULT_PROFILE_ICON_PATH = 'images/user_icon.png'
class Meta:
verbose_name = "user"
verbose_name_plural = "users"
# メールの送信に関するメソッド
def email_user(self, subject, message, from_email=None, **kwargs):
send_mail(subject, message, from_email, [self.email], **kwargs)
@property
def profile_icon_url(self):
if self.profile_icon:
return self.profile_icon.url
elif self.avatar:
return self.avatar
else:
return staticfiles_storage.url(self.DEFAULT_PROFILE_ICON_PATH)
def test_custom_file_widget_via_subclass(self):
"""
Default ``file_widget`` class can also be customized by
subclassing.
"""
class ClearableImageWidget(ClearableFileInput):
default_file_widget_class = ImageWidget
widget = ClearableImageWidget()
html = widget.render('fieldname', ImageFieldFile(None, ImageField(), 'tiny.png'))
self.assertTrue('<img' in html)
def test_render(self):
"""
``ImageWidget`` renders the file input and the image thumb.
"""
widget = ImageWidget()
html = widget.render('fieldname', ImageFieldFile(None, ImageField(), 'tiny.png'))
# test only this much of the html, because the remainder will
# vary depending on whether we have sorl-thumbnail
self.assertTrue('<img' in html)
self.assertTrue('/media/tiny' in html)
def test_custom_template(self):
"""
``ClearableFileInput`` respects its ``template`` argument.
"""
widget = ClearableFileInput(template='Clear: %(checkbox)s %(input)s')
html = widget.render('fieldname',
ImageFieldFile(None, ImageField(), 'tiny.png'))
self.assertHTMLEqual(
html, 'Clear: '
'<input type="checkbox" name="fieldname_1" /> '
'<input type="file" name="fieldname_0" />')
class BlogPosts(models.Model):
poster = models.CharField(max_length=50)
title = models.CharField(max_length=250)
body = models.TextField(max_length=500)
created_at = models.DateTimeField(default=datetime.now, blank=True)
image = ImageField(upload_to='blog-pic')
def __str__(self):
return self.title
class Meta:
verbose_name_plural = "BlogPosts"
class Usuario(models.Model):
user = models.OneToOneField(User, on_delete=models.CASCADE)
#comentario_blog
#sender_m
receiver_m = models.ForeignKey('Mensaje',
on_delete=models.CASCADE,
null=True,
blank=True,
default=None)
###############################
telefono = models.CharField(max_length=15)
pais = models.CharField(max_length=20)
ciudad = models.CharField(max_length=30)
provincia = models.CharField(max_length=2, choices=PROVINCIAS)
codigo_postal = models.CharField(max_length=10)
direccion = models.CharField(max_length=30)
foto = ImageField(upload_to=get_image_path, blank=True, null=True)
fondo = ImageField(upload_to=get_image_path, blank=True, null=True)
def __str__(self):
return self.user.username + "-usuario-"
class ImageCoin(models.Model):
name = CharField(max_length=100)
coin = models.ForeignKey(Coin, on_delete=models.CASCADE)
image = ImageField(upload_to='coins', blank=True, null=True)
default = models.BooleanField(default=False)
user = models.ForeignKey(
settings.AUTH_USER_MODEL, # new
on_delete=models.CASCADE,
blank=False,
null=True)
def __str__(self):
return self.coin.name + "_" + self.name
class Photograph(models.Model):
image = ImageField(upload_to=PHOTO_UPLOAD_TO, height_field='image_height', width_field='image_width', max_length=1000)
thumbnail = ImageField(upload_to=PHOTO_UPLOAD_TO, height_field='thumb_height', width_field='thumb_width', max_length=1000, blank=True)
image_width = PositiveIntegerField()
image_height = PositiveIntegerField()
thumb_width = PositiveIntegerField(null=True)
thumb_height = PositiveIntegerField(null=True)
description = models.TextField(blank=True, null=True, default='')
date = models.DateTimeField(default=timezone.now)
notes = models.TextField(blank=True, null=True, default='')
content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE, blank=True, null=True)
occurrence_fk = models.PositiveIntegerField(blank=True, null=True)
occurrence = GenericForeignKey('content_type', 'occurrence_fk')
def save(self, force_insert=False, force_update=False, using=None, update_fields=None):
try:
(thumb, date) = get_thumbnail_and_date(self.image, self.image.path)
self.thumbnail = thumb
self.date = date
except:
pass
super(Photograph, self).save(force_insert=force_insert, force_update=force_update, using=using, update_fields=update_fields)
class Slide(Model):
title = CharField(max_length=255)
description = CharField(max_length=255)
url = URLField(blank=True)
image = ImageField(storage=FileSystemStorage('{}/carousel/slides/'.format(MEDIA_ROOT), '{}/carousel/slides/'.format(MEDIA_URL)))
order = PositiveIntegerField(default=0)
active = BooleanField()
def __unicode__(self):
return self.title
class Meta:
ordering = ['order']
class HomeImage(models.Model):
image = models.ForeignKey(Image)
image_field = ImageCropField(blank=True, null=True, upload_to='home_slide/')
active = models.BooleanField(default=0)
cropping = ImageRatioField('image_field', '625x350', size_warning=True)
croppedImage = ImageField(blank=True, null=True, upload_to='home_slide/')
def __unicode__(self):
return self.image.collection.artist.__unicode__()
def save(self, *args, **kwargs):
# Get file name from image
strImagePath = self.image.photo.name
strImageName = strImagePath.split('/')[3]
strUploadTo = 'home_slide/'
strExtention = '.300x300_q85_detail.jpg'
# Set image field path
strDesImage = strUploadTo + strImageName
self.image_field = strDesImage
if(self.id is not None):
homeImage = HomeImage.objects.get(pk=self.id)
else:
homeImage = None
if(homeImage is None or homeImage.image != self.image):
# Copy file into image field path
im = PImage.open(settings.MEDIA_ROOT + strImagePath)
im.save(settings.MEDIA_ROOT + strDesImage)
# Copy image into image field path with extension for Cropping field
exIm = PImage.open(settings.MEDIA_ROOT + strImagePath)
exIm.save(settings.MEDIA_ROOT + strDesImage + strExtention)
if(self.cropping != ''):
# Crop image
cropImage = PImage.open(settings.MEDIA_ROOT + strImagePath)
cropP = self.cropping.split(',')
box = (int(cropP[0]), int(cropP[1]), int(cropP[2]), int(cropP[3]))
croppedImageName = strUploadTo + 'slide_' + str(self.image.id) + '.jpg'
self.croppedImage = croppedImageName
cropImage.crop(box).save(settings.MEDIA_ROOT + croppedImageName)
# Resize cropped image
size = 625,350
im = PImage.open(settings.MEDIA_ROOT + croppedImageName)
im = im.resize(size, PImage.ANTIALIAS)
im.save(settings.MEDIA_ROOT + croppedImageName)
super(HomeImage, self).save(*args, **kwargs)
