class MinSizeModel(models.Model):
image = StdImageField(upload_to=upload_to,
validators=[MinSizeValidator(200, 200)])
class AdminDeleteModel(models.Model):
"""can be deleted through admin"""
image = StdImageField(upload_to=UploadTo(name='image', path='img'),
blank=True)
class ThumbnailModel(models.Model):
"""creates a thumbnail resized to maximum size to fit a 100x75 area"""
image = StdImageField(upload_to=UploadTo(name='image', path='img'),
blank=True,
variations={'thumbnail': (100, 75)})
class MyProfile(UserenaBaseProfile):
user = models.OneToOneField(User,
unique=True,
verbose_name=_('user'),
related_name='my_profile')
user_state_CHOICES = ((u'普通用户', u'普通用户'), (u'高级用户', u'高级用户'), (u'快递人',
u'快递人'))
user_state = models.CharField(u'用户状态',
max_length=20,
choices=user_state_CHOICES,
default=u'普通用户')
GENDER_CHOICES = (
(1, _('Male')),
(2, _('Female')),
)
gender = models.PositiveSmallIntegerField(_('gender'),
choices=GENDER_CHOICES,
blank=True,
null=True)
date_joined = models.DateTimeField(u'注册时间', auto_now_add=True)
real_name = models.CharField(u'真实姓名', max_length=100)
phone = models.CharField(max_length=11,
blank=True,
validators=[
RegexValidator(regex='^\d{11}$',
message='请输入正确的手机号',
code='Invalid number')
])
one_card = StdImageField(
u'一卡通',
upload_to='onecard',
variations={'thumbnail': (100, 75)},
blank=True
) # creates a thumbnail resized to maximum size to fit a 100x75 area
#major=models.CharField(u'专业',max_length=100,blank=True)
#address=models.ForeignKey(ReceiveAddress,verbose_name=u'收货地址',related_name='my_profile',help_text=u"目前只支持华电二校范围")
#address=models.CharField(u'住址',max_length=100,blank=True)
#phone=models.PositiveSmallIntegerField()
#identity_card=models.CharField(u'身份证',max_length=100,blank=True)
# student_number=models.CharField(u'学号',max_length=100,blank=True)
#one_card=models.FileField(u'一卡通',null=True,blank=True,upload_to='onecard')
def image_img(self):
if self.one_card:
return str('<img src="%s" />' % self.one_card.thumbnail.url)
else:
return u'上传一卡通'
image_img.short_description = '一卡通'
image_img.allow_tags = True
def image_img2(self):
if self.mugshot:
return str('<img src="%s" />' % self.mugshot.url)
else:
return u'上传头像'
image_img2.short_description = '头像'
image_img2.allow_tags = True
class Meta:
verbose_name_plural = u'个人资料'
#app_label=u'助学贷款'
ordering = ["-date_joined"]
class UtilVariationsModel(models.Model):
"""delays creation of 150x150 thumbnails until it is called manually"""
image = StdImageField(upload_to=UploadTo(name='image', path='img'),
variations={'thumbnail': (150, 150, True)},
render_variations=render_job)
class AutoSlugClassNameDirModel(models.Model):
name = models.CharField(max_length=50)
image = StdImageField(upload_to=UploadToAutoSlugClassNameDir(
populate_from='name'))
class Profil(AbstractUser):
site_web = models.URLField(null=True, blank=True)
description = models.TextField(null=True, blank=True)
competences = models.TextField(null=True, blank=True)
adresse = models.OneToOneField(Adresse, on_delete=models.CASCADE)
avatar = StdImageField(null=True,
blank=True,
upload_to='avatars/',
variations={
'large': (640, 480),
'thumbnail2': (100, 100, True)
})
date_registration = models.DateTimeField(verbose_name="Date de création",
editable=False)
pseudo_june = models.CharField(_('(optionnel) pseudo Monnaie Libre'),
blank=True,
default=None,
null=True,
max_length=50)
inscrit_newsletter = models.BooleanField(
verbose_name="J'accepte de recevoir des emails de Permacat",
default=False)
statut_adhesion = models.IntegerField(choices=Choix.statut_adhesion,
default="0")
statut_adhesion_rtg = models.IntegerField(
choices=Choix.statut_adhesion_rtg, default="0")
cotisation_a_jour = models.BooleanField(verbose_name="Cotisation à jour",
default=False)
accepter_conditions = models.BooleanField(
verbose_name=
"J'ai lu et j'accepte les conditions d'utilisation du site",
default=False,
null=False)
accepter_annuaire = models.BooleanField(
verbose_name=
"J'accepte d'apparaitre dans l'annuaire du site et la carte et rend mon profil visible par tous",
default=True)
#device_registration_id = models.CharField(_('device reg id'), blank=True, default=None, null=True, max_length=100)
def __str__(self):
return self.username
def __unicode__(self):
return self.username
def save(self, *args, **kwargs):
''' On save, update timestamps '''
if not self.id:
self.date_registration = now()
if not hasattr(self, 'adresse') or not self.adresse:
self.adresse = Adresse.objects.create()
return super(Profil, self).save(*args, **kwargs)
def get_nom_class(self):
return "Profil"
def get_absolute_url(self):
return reverse('profil', kwargs={'user_id': self.id})
def getDistance(self, profil):
x1 = float(self.adresse.latitude) * DEGTORAD
y1 = float(self.adresse.longitude) * DEGTORAD
x2 = float(profil.adresse.latitude) * DEGTORAD
y2 = float(profil.adresse.longitude) * DEGTORAD
x = (y2 - y1) * math.cos((x1 + x2) / 2)
y = (x2 - x1)
return math.sqrt(x * x + y * y) * 6371
@property
def statutMembre(self):
return self.statut_adhesion
@property
def statutMembre_str(self):
if self.statut_adhesion == 0:
return "souhaite devenir membre de l'association"
elif self.statut_adhesion == 1:
return "ne souhaite pas devenir membre"
elif self.statut_adhesion == 2:
return "membre actif"
@property
def statutMembre_rtg(self):
return self.statut_adhesion_rtg
@property
def statutMembre_rtg_str(self):
if self.statut_adhesion_rtg == 0:
return "souhaite devenir membre de l'association"
elif self.statut_adhesion_rtg == 1:
return "ne souhaite pas devenir membre"
elif self.statut_adhesion_rtg == 2:
return "membre actif"
@property
def is_permacat(self):
if self.statut_adhesion == 2:
return True
else:
return False
@property
def is_rtg(self):
if self.statut_adhesion_rtg == 2:
return True
else:
return False
@property
def cotisation_a_jour_str(self):
return "oui" if self.cotisation_a_jour else "non"
@property
def inscrit_newsletter_str(self):
return "oui" if self.inscrit_newsletter else "non"
class Address(ResizeUploadedImageModelMixin, PinYinFieldModelMixin, TenantModelMixin, models.Model):
name = models.CharField(_('name'), max_length=30, null=False, blank=False)
mobile = models.CharField(_('mobile number'), max_length=15, null=True, blank=True)
address = models.CharField(_('address'), max_length=100, null=False, blank=False)
customer = models.ForeignKey(Customer, blank=False, null=False, verbose_name=_('customer'))
id_number = models.CharField(_('ID number'), max_length=20, blank=True, null=True)
id_photo_front = StdImageField(_('ID Front'), upload_to=get_id_photo_front_path, blank=True, null=True,
validators=[FileExtensionValidator(['jpg', 'jpeg', 'gif', 'png'])],
storage=OverwriteStorage(),
variations={
'thumbnail': (200, 200, False)
})
id_photo_back = StdImageField(_('ID Back'), upload_to=get_id_photo_back_path, blank=True, null=True,
validators=[FileExtensionValidator(['jpg', 'jpeg', 'gif', 'png'])],
storage=OverwriteStorage(),
variations={
'thumbnail': (200, 200, False)
})
create_time = models.DateTimeField(_('Create Time'), auto_now_add=True, editable=False)
pinyin_fields_conf = [
('name', Style.NORMAL, False),
('name', Style.FIRST_LETTER, False),
('address', Style.NORMAL, False),
('address', Style.FIRST_LETTER, False),
]
class Meta:
ordering = ['create_time']
def __str__(self):
return self.get_text()
def get_text(self):
text = self.address
if self.mobile:
text = '%s,%s' % (self.mobile, text)
if self.name:
text = '%s,%s' % (self.name, text)
return text
def get_customer_link(self):
url = reverse('admin:customer_customer_change', args=[self.customer.pk])
return '<a href="%s">%s</a>' % (url, self.customer)
get_customer_link.allow_tags = True
get_customer_link.short_description = 'Customer'
def id_photo_link(self):
return self.id_photo_front_link() + self.id_photo_back_link()
id_photo_link.allow_tags = True
id_photo_link.short_description = 'ID_photo'
def id_photo_front_link(self):
if self.id_photo_front:
file_path = str(self.id_photo_front)
# base, file_path = file_path.split('/%s' % settings.ID_PHOTO_FOLDER)
# url = '/%s%s' % (settings.ID_PHOTO_FOLDER, file_path)
url = '%s%s' % (settings.MEDIA_URL, file_path)
return '<a target="_blank" href="%s"><img width="90px" src="%s"></a>' % (url, url)
else:
return ''
id_photo_front_link.allow_tags = True
id_photo_front_link.short_description = 'ID_photo_front'
def id_photo_back_link(self):
if self.id_photo_back:
file_path = str(self.id_photo_back)
# base, file_path = file_path.split('/%s' % settings.ID_PHOTO_FOLDER)
# url = '/%s%s' % (settings.ID_PHOTO_FOLDER, file_path)
url = '%s%s' % (settings.MEDIA_URL, file_path)
return '<a target="_blank" href="%s"><img width="90px" src="%s"></a>' % (url, url)
else:
return ''
id_photo_back_link.allow_tags = True
id_photo_back_link.short_description = 'ID_photo_back'
def get_address(self):
return '%s,%s,%s' % (self.name, self.mobile, self.address)
def save(self, *args, **kwargs):
# resize images when first uploaded
self.resize_image('id_photo_front')
self.resize_image('id_photo_back')
if self.id_number and 'x' in self.id_number:
self.id_number = self.id_number.upper()
self.link_id_photo()
super(Address, self).save(*args, **kwargs)
def link_id_photo(self):
if self.id_number:
existed = None
if not self.id_photo_front:
existed = Address.objects.filter(id_number=self.id_number, id_photo_front__isnull=False).first()
if existed:
self.id_photo_front = existed.id_photo_front
if not self.id_photo_back:
if existed and existed.id_photo_back:
self.id_photo_back = existed.id_photo_back
else:
existed = Address.objects.filter(id_number=self.id_number, id_photo_back__isnull=False).first()
if existed:
self.id_photo_back = existed.id_photo_back
class ResizeModel(models.Model):
# resizes image to maximum size to fit a 640x480 area
image = StdImageField(upload_to='img', size=(640, 480))
class Ads(models.Model):
title = models.CharField(max_length=80)
url = models.URLField()
image = StdImageField(upload_to=UploadToUUID(path='ads'), blank=True)
published = models.BooleanField(default=True)
date = models.DateTimeField(default=timezone.now)
class Address(PinYinFieldModelMixin, ResizeUploadedImageModelMixin,
models.Model):
first_name = models.CharField(_('姓名'), max_length=256, blank=True)
last_name = models.CharField(max_length=256, blank=True)
company_name = models.CharField(max_length=256, blank=True)
street_address_1 = models.CharField(_('街道地址'), max_length=256, blank=True)
street_address_2 = models.CharField(max_length=256, blank=True)
city = models.CharField(pgettext_lazy("City", "City"),
max_length=256,
blank=True)
city_area = models.CharField(pgettext_lazy("City area", "District"),
max_length=128,
blank=True)
postal_code = models.CharField(max_length=20, blank=True)
country = CountryField(pgettext_lazy("Address field", "County"),
blank=True)
country_area = models.CharField(pgettext_lazy("Address field", "Province"),
max_length=128,
blank=True)
phone = models.CharField(pgettext_lazy("Phone number", "Phone number"),
blank=True,
default="",
max_length=32)
id_number = models.CharField(_('ID number'),
max_length=20,
blank=True,
null=True)
id_photo_front = StdImageField(
_('ID Front'),
upload_to=get_id_photo_front_path,
blank=True,
null=True,
validators=[FileExtensionValidator(['jpg', 'jpeg', 'gif', 'png'])],
storage=OverwriteStorage(),
variations={'thumbnail': (300, 200, False)})
id_photo_back = StdImageField(
_('ID Back'),
upload_to=get_id_photo_back_path,
blank=True,
null=True,
validators=[FileExtensionValidator(['jpg', 'jpeg', 'gif', 'png'])],
storage=OverwriteStorage(),
variations={'thumbnail': (300, 200, False)})
pinyin = models.TextField(_('pinyin'), max_length=1024, blank=True)
pinyin_fields_conf = [
('first_name', Style.NORMAL, False),
('first_name', Style.FIRST_LETTER, False),
('street_address_1', Style.NORMAL, False),
('street_address_1', Style.FIRST_LETTER, False),
]
objects = AddressQueryset.as_manager()
class Meta:
ordering = ("pk", )
def __init__(self, *args, **kwargs):
super(Address, self).__init__(*args, **kwargs)
self._state.id_number = self.id_number
@cached_property
def customer(self):
return self.user_addresses.order_by('id').first()
@property
def province(self):
return self.country_area
@property
def district(self):
return self.city_area
@property
def full_name(self):
return self.first_name
@property
def name(self):
return self.first_name
def __str__(self):
return f'{self.first_name}, {self.phone}, {self.street_address_1}'
def __eq__(self, other):
if not isinstance(other, Address):
return False
return self.as_data() == other.as_data()
__hash__ = models.Model.__hash__
def as_data(self):
"""Return the address as a dict suitable for passing as kwargs.
Result does not contain the primary key or an associated user.
"""
data = model_to_dict(self, exclude=["id", "user"])
if isinstance(data["country"], Country):
data["country"] = data["country"].code
if isinstance(data["phone"], PhoneNumber):
data["phone"] = data["phone"].as_e164
return data
def get_copy(self):
"""Return a new instance of the same address."""
return Address.objects.create(**self.as_data())
def save(self, *args, **kwargs):
# resize images when first uploaded
self.resize_image('id_photo_front')
self.resize_image('id_photo_back')
if self.id_number and 'x' in self.id_number:
self.id_number = self.id_number.upper()
self._link_id_photo()
super(Address, self).save(*args, **kwargs)
def _link_id_photo(self):
"""
reuse id photo if already uploaded
"""
if self._state.id_number != self.id_number and self.id_number:
if not self.id_photo_front:
existed = Address.objects.filter(
id_number=self.id_number,
id_photo_front__isnull=False).first()
if existed:
self.id_photo_front = existed.id_photo_front
if not self.id_photo_back:
existed = Address.objects.filter(
id_number=self.id_number,
id_photo_back__isnull=False).first()
if existed:
self.id_photo_back = existed.id_photo_back
class Gallery(models.Model):
facility = models.ForeignKey(Facility, on_delete=models.CASCADE)
image = StdImageField(default='court.png', upload_to='facility', blank=True, variations={'large': (1280, 720), 'thumbnail': (640, 480, True)})
class Uye(AbstractUser):
tcno = models.CharField(max_length=11,
verbose_name='TC Kimlik No',
blank=True,
null=True,
default="")
#eposta = models.EmailField(unique=True, verbose_name='E-posta Adresi', null=True, default=True)
telefon = models.CharField(max_length=20,
verbose_name="Telefon Numarası",
null=True,
blank=True,
default="")
cinsiyet = models.CharField(max_length=1,
choices=cinsiyet_secenekleri,
blank=True,
null=True,
default='B',
verbose_name='Cinsiyet')
egitim = models.ForeignKey(Egitim,
blank=True,
null=True,
default=None,
verbose_name="Egitim Durumu",
on_delete=models.SET_NULL)
askerlik = models.ForeignKey(Askerlik,
blank=True,
null=True,
default=None,
verbose_name="Askerlik Durumu",
on_delete=models.SET_NULL)
uye_tipi = models.CharField(max_length=15,
choices=uye_tipi_secenekleri,
blank=True,
null=True,
default='kullanici',
verbose_name='Üyelik Durumu')
fotograf = StdImageField(upload_to='user-images',
blank=True,
variations={
'thumbnail': (150, 150, True),
'medium': (300, 300)
},
verbose_name='Profil Fotoğrafı')
dogum_tarihi = models.DateField(blank=True,
null=True,
verbose_name='Doğum Tarihi')
sehir = models.ForeignKey(Sehir,
verbose_name="Şehir",
blank=True,
null=True,
default=None,
on_delete=models.CASCADE)
konum = models.CharField(max_length=255,
blank=True,
verbose_name='Yaşadığınız Yer')
hakkinda = RichTextField(config_name='members',
blank=True,
verbose_name='Hakkınızda')
website = models.URLField(max_length=200,
blank=True,
verbose_name='Website Adresi')
facebook = models.URLField(max_length=255,
blank=True,
verbose_name='Facebook Profil Adresi')
twitter = models.URLField(max_length=255,
blank=True,
verbose_name='Twitter Profil Adresi')
google_plus = models.URLField(max_length=255,
blank=True,
verbose_name='Google+ Profil Adresi')
youtube = models.URLField(max_length=255,
blank=True,
verbose_name='Youtube Profil Adresi')
instagram = models.CharField(max_length=255,
blank=True,
verbose_name='İnstagram Kullanıcı Adı')
goruntulenme = models.IntegerField(default=0,
editable=False,
verbose_name='Görüntülenme')
dil_konusma = models.ManyToManyField(
Dil,
verbose_name="Konuşabildiğiniz Diller",
blank=True,
null=True,
default=None,
related_name="konusulabilen_diller")
dil_yazma = models.ManyToManyField(
Dil,
verbose_name="Yazıp, Okuyabildiğiniz Diller",
blank=True,
null=True,
default=None,
related_name="yazilabilen_diller")
c_time = models.DateTimeField(verbose_name="Eklenme Tarihi",
auto_now=True,
editable=False,
blank=True,
null=True)
u_time = models.DateTimeField(verbose_name="Güncellenme Tarihi",
auto_now_add=True,
editable=False,
blank=True,
null=True)
def __str__(self):
return self.username
def get_yas(self):
if not self.dogum_tarihi:
return 0
else:
bugunTarihi = datetime.today()
dogumTarihi = datetime(self.dogum_tarihi.year,
self.dogum_tarihi.month,
self.dogum_tarihi.day)
yas = int((bugunTarihi - dogumTarihi).days / 365)
return yas
def get_avatar(self):
url = static('img/user-mask.jpg')
if self.photo:
url = self.photo.thumbnail.url
else:
if self.gender == 'E':
url = static('img/user-man.png')
elif self.gender == 'K':
url = static('img/user-woman.png')
else:
url = static('img/user-mask.jpg')
return url
def full_name(self):
return '{} {}'.format(self.first_name, self.last_name)
def cinsiyeti(self):
if self.gender == 'E':
return 'Erkek'
elif self.gender == 'K':
return 'Kadın'
else:
return 'Belirtilmemiş'
class Meta:
db_table = 'uyeler'
verbose_name = 'Kullanıcı'
verbose_name_plural = 'Kullanıcılar'
class Product(ResizeUploadedImageModelMixin, PinYinFieldModelMixin, TenantModelMixin, models.Model):
code = models.CharField(_('code'), max_length=32, blank=True)
name_en = models.CharField(_('name_en'), max_length=128, blank=True)
name_cn = models.CharField(_('name_cn'), max_length=128, blank=True)
brand_en = models.CharField(_('brand_en'), max_length=128, blank=True)
brand_cn = models.CharField(_('brand_cn'), max_length=128, blank=True)
alias = models.CharField(_('alias'), max_length=255, blank=True)
country = models.CharField(_('country'), max_length=128, choices=COUNTRIES_CHOICES, default='AU', blank=True)
pic = StdImageField(upload_to=get_product_pic_path, blank=True, null=True, verbose_name=_('picture'),
validators=[FileExtensionValidator(['jpg', 'jpeg', 'gif', 'png'])],
storage=OverwriteStorage(),
variations={
'medium': (800, 800, True),
'thumbnail': (400, 400, True)
})
brand = models.ForeignKey(Brand, blank=True, null=True, verbose_name=_('brand'))
spec = models.CharField(_('spec'), max_length=128, blank=True)
# deliver weight unit: KG
weight = models.DecimalField(_('weight'), max_digits=8, decimal_places=2, blank=True, null=True)
sold_count = models.IntegerField(_('Sold Count'), default=0, null=False, blank=False)
last_sell_price = models.DecimalField(_('last sell price'), max_digits=8, decimal_places=2, blank=True, null=True)
avg_sell_price = models.DecimalField(_('avg sell price'), max_digits=8, decimal_places=2, blank=True, null=True)
min_sell_price = models.DecimalField(_('min sell price'), max_digits=8, decimal_places=2, blank=True, null=True)
max_sell_price = models.DecimalField(_('max sell price'), max_digits=8, decimal_places=2, blank=True, null=True)
avg_cost = models.DecimalField(_('avg cost'), max_digits=8, decimal_places=2, blank=True, null=True)
min_cost = models.DecimalField(_('min cost'), max_digits=8, decimal_places=2, blank=True, null=True)
max_cost = models.DecimalField(_('max cost'), max_digits=8, decimal_places=2, blank=True, null=True)
safe_sell_price = models.DecimalField(_('safe sell price'), max_digits=8, decimal_places=2, blank=True, null=True)
tb_url = models.URLField(_('TB URL'), null=True, blank=True)
wd_url = models.URLField(_('WD URL'), null=True, blank=True)
wx_url = models.URLField(_('WX URL'), null=True, blank=True)
summary = models.TextField(_('summary'), null=True, blank=True)
description = models.TextField(_('description'), null=True, blank=True)
is_active = models.BooleanField(_('is active'), default=True, null=False, blank=False)
tags = TaggableManager()
pinyin_fields_conf = [
('name_cn', Style.NORMAL, False),
('name_cn', Style.FIRST_LETTER, False),
('brand.name_cn', Style.NORMAL, False),
('brand.name_cn', Style.FIRST_LETTER, False),
('alias', Style.NORMAL, False),
('alias', Style.FIRST_LETTER, False),
]
class Meta:
verbose_name_plural = _('Product')
verbose_name = _('Product')
def __str__(self):
brand = self.brand.name if self.brand else self.brand_cn or self.brand_en
name = self.name_cn or self.name_en
return '%s %s' % (brand, name)
def __init__(self, *args, **kwargs):
super(Product, self).__init__(*args, **kwargs)
self.set_uuid()
field_names = ['name_en', 'name_cn', 'brand_id', 'brand_en', 'brand_cn']
for field_name in set(field_names):
init_value = self.get_attr_by_str(field_name)
setattr(self._state, field_name, init_value)
def set_uuid(self):
if not self.uuid:
uuid_str = uuid.uuid4().hex
while (Product.objects.filter(uuid=uuid_str).exists()):
uuid_str = uuid.uuid4().hex
self.uuid = uuid_str
def get_pic_path(self):
if not self.uuid:
self.set_uuid()
return os.path.join(PRODUCT_PHOTO_FOLDER, self.uuid)
def get_edit_link(self):
url = reverse('product:product-update-view', args=[self.pk])
return '<a href="%s">%s</a>' % (url, self.name_cn)
get_edit_link.short_description = 'Name'
def get_detail_link(self):
url = reverse('product:product-detail-view', args=[self.pk])
return '<a href="%s">%s</a>' % (url, self.name_cn)
get_detail_link.short_description = 'Name'
def get_pic_link(self):
if self.pic:
file_path = str(self.pic)
# base, file_path = file_path.split('/%s' % ID_PHOTO_FOLDER)
# url = '/%s%s' % (ID_PHOTO_FOLDER, file_path)
url = '%s%s' % (MEDIA_URL, file_path)
return '<a target="_blank" href="%s"><img height="60px" src="%s"></a>' % (url, url)
else:
return ''
get_pic_link.allow_tags = True
get_pic_link.short_description = 'Pic'
def get_name_cn(self):
if self.brand and self.brand.name_en.lower() != 'none':
return '%s %s' % (self.brand.name, self.name_cn)
else:
return self.name_cn
get_name_cn.allow_tags = True
get_name_cn.short_description = 'CN Name'
def stat(self):
from apps.order.models import OrderProduct
product_sales = OrderProduct.objects.filter(product_id=self.pk).exclude(
sell_price_rmb=0).exclude(cost_price_aud=0).order_by('-create_time')
if product_sales.count():
data = product_sales.aggregate(sold_count=Sum(F('amount')),
avg_sell_price=Avg(F('sell_price_rmb')),
min_sell_price=Min(F('sell_price_rmb')),
max_sell_price=Max(F('sell_price_rmb')),
avg_cost=Avg(F('cost_price_aud')),
min_cost=Min(F('cost_price_aud')),
max_cost=Max(F('cost_price_aud')))
self.last_sell_price = product_sales.first().sell_price_rmb
self.sold_count = data.get('sold_count') or 0
self.avg_sell_price = data.get('avg_sell_price') or None
self.min_sell_price = data.get('min_sell_price') or None
self.max_sell_price = data.get('max_sell_price') or None
self.avg_cost = data.get('avg_cost') or None
self.min_cost = data.get('min_cost') or None
self.max_cost = data.get('max_cost') or None
else:
self.last_sell_price = None
self.sold_count = 0
self.avg_sell_price = None
self.min_sell_price = None
self.max_sell_price = None
self.avg_cost = None
self.min_cost = None
self.max_cost = None
self.save()
def assign_brand(self):
if self.brand:
self.brand_cn = self.brand.name_cn if not self.brand_cn else self.brand_cn
self.brand_en = self.brand.name_en if not self.brand_en else self.brand_en
else:
if self.brand_en:
self.brand = Brand.objects.filter(name_en=self.brand_en).first()
elif self.brand_cn:
self.brand = Brand.objects.filter(name_cn=self.brand_cn).first()
def save(self, *args, **kwargs):
self.assign_brand()
self.resize_image('pic') # resize images when first uploaded
super(Product, self).save(*args, **kwargs)
class MinSizeModel(models.Model):
image = StdImageField(upload_to=UploadTo(name='image', path='img'),
validators=[MinSizeValidator(200, 200)])
class ResizeCropModel(models.Model):
# resizes image to 640x480 croping if necessary
image = StdImageField(upload_to='img', size=(640, 480, True))
class ForceMinSizeModel(models.Model):
"""creates a thumbnail resized to maximum size to fit a 100x75 area"""
image = StdImageField(upload_to=UploadTo(name='image', path='img'),
force_min_size=True,
variations={'thumbnail': (600, 600)})
class ThumbnailModel(models.Model):
# creates a thumbnail resized to maximum size to fit a 100x75 area
image = StdImageField(upload_to='img',
blank=True,
thumbnail_size=(100, 75))
class UUIDModel(models.Model):
image = StdImageField(upload_to=UploadToUUID(path='img'))
class ThumbnailCropModel(models.Model):
# creates a thumbnail resized to 100x100 croping if necessary
image = StdImageField(upload_to='img', thumbnail_size=(100, 100, True))
class Product(ResizeUploadedImageModelMixin, PinYinFieldModelMixin,
models.Model):
"""普通产品库，由爬虫导入，客户输入现用产品时使用，不会推荐给客人, skin_product"""
# sku = models.CharField(max_length=36, unique=True, blank=True)
brand = models.ForeignKey(Brand, blank=True, null=True)
name_en = models.CharField(_(u'name_en'), max_length=512, blank=True)
name_cn = models.CharField(_(u'name_cn'), max_length=512, blank=True)
pinyin = models.CharField(_(u'pinyin'), max_length=1024, blank=True)
pic = StdImageField(upload_to=UploadToClassNameDir(),
blank=True,
null=True,
verbose_name=_('picture'),
variations={
'thumbnail': (64, 64, True),
})
alias = models.CharField(_(u'alias'), max_length=512, blank=True)
category = models.CharField(max_length=64,
choices=PRODUCT_CATEGORY_CHOICES,
blank=True)
description = models.TextField(_(u'description'), blank=True)
created_at = models.DateTimeField(u"创建时间", auto_now_add=True)
ingredients = models.ManyToManyField('product.ProductIngredient',
blank=True,
verbose_name=u'成分组成')
pinyin_fields_conf = [
('name_cn', Style.NORMAL, False),
('alias', Style.NORMAL, False),
]
def __str__(self):
if self.brand and self.name_cn:
if (self.brand.name_cn
and self.brand.name_cn.lower() in self.name_cn.lower()
) or (self.brand.name_en
and self.brand.name_en.lower() in self.name_cn.lower()):
return self.name_cn
if self.brand:
return '%s %s' % (self.brand, self.name_cn)
return self.name_cn
def __init__(self, *args, **kwargs):
super(Product, self).__init__(*args, **kwargs)
field_names = [
'name_en', 'name_cn', 'brand_id', 'brand_en', 'brand_cn'
]
for field_name in set(field_names):
current_value = self.get_attr_by_str(field_name)
self._original_fields_value.update({field_name: current_value})
def save(self, *args, **kwargs):
self.resize_image('pic') # resize images when first uploaded
super(Product, self).save(*args, **kwargs)
def get_analysis(self, oily_type, sensitive_type, pigment_type,
loose_type):
analysis = self.productanalysis_set.filter(
oily_type=oily_type,
sensitive_type=sensitive_type,
pigment_type=pigment_type,
loose_type=loose_type)
return '\n'.join([x.analysis for x in analysis])
def have_duplicated(self):
count = 0
total = self.productanalysis_set.all().count()
for i in range(total):
for j in range(i + 1, total):
if self.productanalysis_set.all()[i].oily_type == self.productanalysis_set.all()[j].oily_type and \
self.productanalysis_set.all()[i].sensitive_type == self.productanalysis_set.all()[
j].sensitive_type and \
self.productanalysis_set.all()[i].pigment_type == self.productanalysis_set.all()[
j].pigment_type and \
self.productanalysis_set.all()[i].loose_type == self.productanalysis_set.all()[
j].loose_type:
count += 1
print(self.productanalysis_set.all()[i].oily_type,
self.productanalysis_set.all()[i].sensitive_type,
self.productanalysis_set.all()[i].pigment_type,
self.productanalysis_set.all()[i].loose_type)
if count > 0:
return True
return False
class MultipleFieldsModel(models.Model):
# creates a thumbnail resized to 100x100 croping if necessary
image1 = StdImageField(upload_to='img', thumbnail_size=(100, 100, True))
image2 = StdImageField(upload_to='img')
image3 = StdImageField('Some label', upload_to='img')
text = models.CharField('Some label', max_length=10)
class Postcard(models.Model):
title = models.CharField(
max_length=100,
help_text="Title of the postcard",
default="",
)
subtitle = models.CharField(max_length=100,
help_text="A subtitle for the postcard",
null=True,
blank=True)
description = models.TextField(
default="",
help_text="""Actual description for a postcard:
* some story behind
* where came it from
* what to see""",
)
image = StdImageField(
upload_to="img/postcardimages",
blank=True,
variations={
"large": (1024, 1024),
"medium": (600, 600),
"small": (300, 300),
"thumbnail": (150, 150, False),
},
delete_orphans=True,
)
image_description = models.TextField(
blank=True,
null=True,
help_text="""
A more formal description of the image for visual
handicapped people -- a description that might not fit to
the main text
""",
)
backside_description_text = models.TextField(
default="",
blank=True,
null=True,
help_text=("The text on the back of a postcard explaining "
"what's printed there."))
country_of_origin = models.ForeignKey(
Country,
on_delete=models.SET_NULL,
null=True,
blank=True,
help_text="Country of origin if known.")
creation_timestamp = models.DateTimeField(auto_now_add=True)
last_updated = models.DateTimeField(auto_now=True)
tags = tagulous.models.TagField(to=Tag)
photo_copyright = models.ManyToManyField(Copyright, related_name="photo")
print_copyright = models.ManyToManyField(Copyright, related_name="print")
urls = models.ManyToManyField(URL,
related_name="further_information",
blank=True)
published = models.BooleanField(
default=False, help_text="Whether this postcard is visible.")
publishing_date = models.DateTimeField(default=django.utils.timezone.now,
null=True,
blank=True)
series = models.ManyToManyField(Series,
related_name="series_member",
blank=True)
def __str__(self):
return self.title
def get_absolute_url(self):
return reverse("postcard_detail", kwargs={"slug": str(self.slug)})
@property
def get_next_item_ID(self):
postcardlist = list(
Postcard.objects.filter(published=True).order_by('-id').all())
pos = postcardlist.index(self)
if pos == 0:
return None
else:
return (postcardlist[pos - 1].id)
@property
def get_previous_item_ID(self):
postcardlist = list(
Postcard.objects.filter(published=True).order_by('-id').all())
pos = postcardlist.index(self)
if pos == len(postcardlist) - 1:
return None
else:
return (postcardlist[pos + 1].id)
class Meta:
ordering = ["-id"]
class SimpleModel(models.Model):
# works as ImageField
image = StdImageField(upload_to='img')
class SimpleModel(models.Model):
"""works as ImageField"""
image = StdImageField(upload_to='img/')
class AllModel(models.Model):
# all previous features in one declaration
image = StdImageField(upload_to='img',
blank=True,
size=(640, 480),
thumbnail_size=(100, 100, True))
class ResizeCropModel(models.Model):
"""resizes image to 640x480 cropping if necessary"""
image = StdImageField(upload_to=UploadTo(name='image', path='img'),
variations={'thumbnail': (150, 150, True)})
class AdminDeleteModel(models.Model):
# can be deleted through admin
image = StdImageField(upload_to='img', blank=True)
class MaxSizeModel(models.Model):
image = StdImageField(upload_to=UploadTo(name='image', path='img'),
validators=[MaxSizeValidator(16, 16)])
class MaxSizeModel(models.Model):
image = StdImageField(upload_to=upload_to,
validators=[MaxSizeValidator(16, 16)])
