class UserAdmin(BaseUserAdmin):
fieldsets = BaseUserAdmin.fieldsets + (
(None, {
'fields': (
'avatar',
'about',
'city',
)
}),
(_ul('Ключи'), {
'fields': (
'reset_password_key',
'registration_key',
)
}),
(_ul('Подписка'), {
'fields': (
'is_subscribe',
'date_subscribe',
)
}),
)
readonly_fields = (
'reset_password_key',
'registration_key',
)
list_display = BaseUserAdmin.list_display + (
'is_active',
'is_subscribe',
)
class CategoryAdmin(GenericModelAdmin):
list_display = (
'name',
'is_published',
GenericModelAdmin.site_url,
)
list_filter = (
'is_published',
'categorytype'
)
fieldsets = (
(None, {
'fields': (
'name',
'description',
'categorytype',
'image_class',
)
}),
(_ul(u'Доступ'), {
'fields': (
'is_published',
)
}),
(_ul(u'Seo'), {
'fields': (
'slug',
'seo_title',
'seo_description',
'seo_keywords',
'seo_author'
)
}),
)
search_fields = ('name', 'description',)
class PollItem(GenericDateModel):
poll = models.ForeignKey(
Poll,
verbose_name=_ul('Опрос'),
related_name="items",
on_delete=models.CASCADE)
rate = models.IntegerField(
verbose_name=_ul('Кол-во за'),
default=0)
answer = models.CharField(
verbose_name=_ul('Ответ'),
max_length=255)
@property
def rate_percentage(self):
total = sum(self.poll.items.all().values_list('rate', flat=True))
if total:
return int(float(self.rate * 100) / float(total))
return 0
def vote_action(self, session):
if self.poll.has_session_key(session, 'pollitem_vote', setup=True):
return
self.rate += 1
self.save(update_fields=('rate',))
class Meta:
verbose_name = _ul('Ответ')
verbose_name_plural = _ul('Ответы')
def __str__(self):
return u'%s' % self.answer
class Partner(models.Model):
name = models.CharField(verbose_name=_ul('Партнерка'),
max_length=255,
help_text=_ul('Название партнерки'))
def __str__(self):
return self.name
class Meta:
verbose_name = _ul('Партнерка')
verbose_name_plural = _ul('Партнерки')
class PasswordChangeForm(BootstrapForm):
password = forms.CharField(max_length=255,
widget=forms.PasswordInput(),
label=_ul('Ваш новый пароль'))
confirm_password = forms.CharField(max_length=255,
widget=forms.PasswordInput(),
label=_ul('Повторите ваш новый пароль'))
def clean_confirm_password(self):
if not self.cleaned_data['password'] == self.cleaned_data[
'confirm_password']:
raise forms.ValidationError(_ul('Пароли не совпадают.'))
return self.cleaned_data['confirm_password']
class CommentAdmin(GenericModelAdmin):
search_fields = ('comment', 'author_username', 'author__username')
list_display = (
'comment',
'creation_date',
'author_username',
'is_published',
'is_spam',
GenericModelAdmin.site_url,
)
list_filter = (
'is_spam',
'is_published',
)
list_editable = (
'is_spam',
'is_published',
)
fieldsets = (
(None, {
'fields': (
'comment',
)
}),
(_ul(u'Доступ'), {
'fields': (
'is_published',
'is_spam'
)
}),
(_ul(u'Голосование'), {
'fields': (
'rate',
)
}),
(_ul(u'Связи'), {
'fields': (
'parent',
'post',
)
}),
(_ul(u'Автор'), {
'fields': (
'author',
'author_username',
'ip_address',
)
}),
)
readonly_fields = ('parent', 'post', 'author', 'author_username')
def _send_email(self, bundle, user):
token_url = "%s://%s/#confirm/%s/%s/" % (
bundle.request.scheme,
bundle.request.get_host(),
user.api_key.key,
user.username
)
send_mail(
_ul(u'Account confirmation'),
_ul(u'Go to %s for complete registration') % token_url,
settings.EMAIL_HOST_USER,
[user.email],
fail_silently=False
)
class Store(models.Model):
"""Model for store."""
name = models.CharField(max_length=200, verbose_name=_ul('Name'))
address = models.ForeignKey('webstore.StoreAddress',
verbose_name=_ul('Address'))
def __str__(self):
"""String representation of store model."""
return '<{model_name}#{id}: {name}>'.format(
model_name=self.__class__.__name__,
id=self.id,
name=self.name,
)
class UserForm(BootstrapModelForm):
username = forms.EmailField(label=_ul('Логин'))
nickname = forms.CharField(label=_ul('Ник'))
class Meta:
model = User
fields = (
'username',
'nickname',
'first_name',
'last_name',
'avatar',
'city',
'about',
)
class GenericDateModel(models.Model):
creation_date = models.DateTimeField(verbose_name=_ul('Дата создания'),
auto_now_add=True)
modification_date = models.DateTimeField(
verbose_name=_ul('Дата изменения'), auto_now=True)
def has_session_key(self, session, key, setup=False):
key = key + '_%s' % self.id
result = session.get(key, False)
if setup:
session[key] = True
return result
class Meta:
abstract = True
class Poll(GenericDateModel):
question = models.CharField(
verbose_name=_ul('Вопрос'),
max_length=255)
is_published = models.BooleanField(
verbose_name=_ul('Опубликован?'),
default=False,
db_index=True)
class Meta:
verbose_name = _ul('Опрос')
verbose_name_plural = _ul('Опросы')
def __str__(self):
return u'%s' % self.question
class LoginForm(BootstrapForm):
email = forms.EmailField(max_length=255, label=_ul('Введите вашу почту'))
password = forms.CharField(max_length=255,
widget=forms.PasswordInput(),
label=_ul('Введите ваш пароль'))
def clean(self):
self.cleaned_data = super(LoginForm, self).clean()
if ('password' in self.cleaned_data and 'email' in self.cleaned_data):
self.cleaned_data['user'] = authenticate(
username=self.cleaned_data['email'],
password=self.cleaned_data['password'])
if not self.cleaned_data['user']:
raise forms.ValidationError(
_ul('Не правильно введена почта или пароль.'))
return self.cleaned_data
def send_registration(self, user, key):
registration_url = 'http://obelektrike.ru' + reverse(
'u-registration-uuid', kwargs={'uuid': key})
message = _ul("""
Для окончания регистрации перейдите по следующей ссылке:\n
%s \n
\n
С уважением,
Команда obelektrike.ru
""") % registration_url
send_mail(
subject=_ul(u'Регистрация пользователя на сайте obelektrike.ru'),
message=message,
from_email=settings.SUPPORT_EMAIL,
recipient_list=[user.email],
fail_silently=True)
class ArticleField(models.CharField):
"""Article field."""
description = _ul('Article string')
def __init__(self, *args, **kwargs):
"""Override default max length."""
defaults = {
'max_length': 50,
}
defaults.update(kwargs)
super(ArticleField, self).__init__(*args, **defaults)
def formfield(self, **kwargs):
"""Add min value validation."""
defaults = {
'form_class': forms.RegexField,
'regex': ARTICLE_RE,
'max_length': self.max_length,
'error_messages': {
'invalid':
_ul('Should contain only letters, digits, dashes and whitespaces'
),
},
}
defaults.update(kwargs)
return super(ArticleField, self).formfield(**defaults)
class SubscribeUser(MessageMixin, FormView):
template_name = ''
form_class = SubscribeForm
extra_tags = 'subscribe'
success_msg = _ul(
u'Теперь уведомление о каждой новой статьи будет приходить Вам на email.'
)
def get(self, request, *args, **kwargs):
raise Http404
def get_success_url(self):
next_url = self.request.GET.get('next', None)
if next_url is not None:
return next_url
return reverse_lazy('index')
def form_valid(self, form):
user, _ = User.objects.get_or_create(
username=form.cleaned_data['email'],
defaults=dict(email=form.cleaned_data['email'], is_active=False))
user.is_subscribe = True
user.date_subscribe = timezone.now()
user.save()
return super(SubscribeUser, self).form_valid(form)
def form_invalid(self, form):
messages.error(self.request,
form.errors.as_text(),
extra_tags=self.extra_tags)
return redirect(self.get_success_url())
class PasswordResetView(MessageMixin, FormView):
template_name = 'password-reset.html'
form_class = PasswordResetForm
success_url = reverse_lazy('u-reset-password')
success_msg = _ul(
u'Ссылка для сброса пароля отправлена Вам на почту (если письмо не пришло поищите его в спаме).'
)
def send_resetpassword(self, user, key):
reset_url = 'http://obelektrike.ru' + reverse('u-reset-password-uuid',
kwargs={'uuid': key})
message = _ul("""
Для сброса пароль перейдите по следующей ссылке:\n
%s \n
\n
С уважением,
Команда obelektrike.ru
""") % reset_url
send_mail(
subject=_ul(u'Сброс пароля для пользователя %s на obelektrike.ru')
% user.get_full_name(),
message=message,
from_email=settings.SUPPORT_EMAIL,
recipient_list=[user.email],
fail_silently=True)
def form_valid(self, form):
key = uuid.uuid4()
user = User.objects.get(username=form.cleaned_data['email'])
user.reset_password_key = key
user.save()
self.send_resetpassword(user, key)
return super(PasswordResetView, self).form_valid(form)
def clean_email(self):
qs = User.objects.filter(username=self.cleaned_data['email'],
is_subscribe=True)
if qs.exists():
raise forms.ValidationError(
_ul('Пользователь с такой почтой уже подписан.'))
return self.cleaned_data['email']
def send_resetpassword(self, user, key):
reset_url = 'http://obelektrike.ru' + reverse('u-reset-password-uuid',
kwargs={'uuid': key})
message = _ul("""
Для сброса пароль перейдите по следующей ссылке:\n
%s \n
\n
С уважением,
Команда obelektrike.ru
""") % reset_url
send_mail(
subject=_ul(u'Сброс пароля для пользователя %s на obelektrike.ru')
% user.get_full_name(),
message=message,
from_email=settings.SUPPORT_EMAIL,
recipient_list=[user.email],
fail_silently=True)
class Feedback(GenericDateModel):
name = models.CharField(
verbose_name = _ul('Ваше имя'),
max_length=255)
email = models.EmailField(
verbose_name = _ul('Контактный email'),
max_length=255)
message = RichTextUploadingField(
verbose_name = _ul('Сообщение'),
config_name='feedback')
class Meta:
verbose_name = _ul('Обратная связь')
verbose_name_plural = _ul('Обратная связь')
def __str__(self):
return u'%s - %s' % (self.creation_date, self.name)
class StoreAddress(models.Model):
"""Model for address of the store."""
line1 = models.CharField(max_length=100, verbose_name=_ul('Line1'))
line2 = models.CharField(max_length=100,
null=True,
blank=True,
verbose_name=_ul('Line2'))
street = models.CharField(max_length=40, verbose_name=_ul('Street'))
city = models.CharField(max_length=40, verbose_name=_ul('City'))
state = models.CharField(max_length=40,
null=True,
blank=True,
verbose_name=_ul('State'))
zip = models.CharField(max_length=20, verbose_name=_ul('ZIP'))
country = models.CharField(max_length=20, verbose_name=_ul('Country'))
def __str__(self):
"""String representation of store address model."""
address_line = ', '.join([
token for token in [
self.zip,
self.country,
self.state,
self.city,
self.street,
self.line1,
self.line2,
] if token
], )
return '<{model_name}#{id}: {address_line}>'.format(
model_name=self.__class__.__name__,
id=self.id,
address_line=address_line,
)
class ProductCategory(models.Model):
"""Model for category of the product."""
class Meta:
verbose_name_plural = 'ProductCategories'
name = models.CharField(max_length=50, verbose_name=_ul('Name'))
parent = models.ForeignKey('webstore.ProductCategory',
null=True,
blank=True,
verbose_name=_ul('Category'))
def __str__(self):
"""String representation of product category model."""
return '<{model_name}#{id}: {name}>'.format(
model_name=self.__class__.__name__,
id=self.id,
name=self.name,
)
class PasswordResetForm(BootstrapForm):
email = forms.EmailField(label=_ul('Введите вашу почту'))
def clean_email(self):
qs = User.objects.filter(username=self.cleaned_data['email'])
if not qs.exists():
raise forms.ValidationError(
_ul('Пользователь с такой почтой не существует.'))
return self.cleaned_data['email']
class SubscribeForm(BootstrapForm):
email = forms.EmailField(label=_ul('Введите вашу почту'))
def clean_email(self):
qs = User.objects.filter(username=self.cleaned_data['email'],
is_subscribe=True)
if qs.exists():
raise forms.ValidationError(
_ul('Пользователь с такой почтой уже подписан.'))
return self.cleaned_data['email']
def send_feedback(self, feedback):
admins = [admin[1] for admin in settings.ADMINS]
send_mail(
subject=_ul(u'Вам написал пользователь %s %s на obelektrike.ru') %
(feedback.name, feedback.email),
message=feedback.message,
from_email=settings.SUPPORT_EMAIL,
recipient_list=admins + [settings.SUPPORT_EMAIL],
fail_silently=True,
html_message=feedback.message)
def clean(self):
self.cleaned_data = super(LoginForm, self).clean()
if ('password' in self.cleaned_data and 'email' in self.cleaned_data):
self.cleaned_data['user'] = authenticate(
username=self.cleaned_data['email'],
password=self.cleaned_data['password'])
if not self.cleaned_data['user']:
raise forms.ValidationError(
_ul('Не правильно введена почта или пароль.'))
return self.cleaned_data
def send_email_to_subscribers(self, post):
post_url = 'http://obelektrike.ru' + reverse(
'posts-category-detail', kwargs={'slug': post.slug})
message = _ul("""
С удовольствием сообщаем, что на портале obelektrike.ru появилась новая статья:\n
%s \n
%s \n
\n
С уважением,
Команда obelektrike.ru
""") % (post.title, post_url)
emails = list(
self.filter(is_subscribe=True).values_list('email', flat=True))
for email in emails:
send_mail(subject=_ul('Новые статья на сайте obelektrike.ru'),
message=message,
from_email=settings.SUPPORT_EMAIL,
recipient_list=[email],
fail_silently=True)
class EmailAdmin(admin.ModelAdmin):
list_display = ("created_date", "sender", "recipients", "subject")
search_fields = ("sender", "recipients", "subject", "body")
exclude = ("raw", "body")
readonly_fields = ("body_html", )
fieldsets = (
(
_ul("Users"),
{
"classes": ("collapse", "close"),
"fields": (
"sender",
"recipients",
),
},
),
(_ul("Body"), {
"fields": ("subject", "body_html")
}),
)
def clean_on_spam(self, text):
msg = _ul(
u'Система пометила Ваше сообщение как спам. Возможно Вы используете ссылки или Ваше сообщение содержит спам'
) # noqa
is_spam = False
soup = bs(text, "html.parser")
hrefs = soup.findAll('a')
if hrefs or 'http' in text or 'https' in text or 'www' in text:
is_spam = True
if is_spam:
raise forms.ValidationError(msg)
def form_invalid(self, form):
result = super(MessageMixin, self).form_invalid(form)
if form.errors:
if '__all__' in form.errors.keys():
messages.error(self.request,
form.errors['__all__'].as_text(),
extra_tags=self.extra_tags)
else:
messages.error(self.request,
_ul(u'* Ошибки ввода'),
extra_tags=self.extra_tags)
return result
class RegistrationForm(BootstrapForm):
email = forms.EmailField(label=_ul('Введите вашу почту'))
password = forms.CharField(max_length=255,
widget=forms.PasswordInput(),
label=_ul('Ваш новый пароль'))
confirm_password = forms.CharField(max_length=255,
widget=forms.PasswordInput(),
label=_ul('Повторите ваш новый пароль'))
def clean_email(self):
qs = User.objects.filter(username=self.cleaned_data['email'])
if qs.exists():
raise forms.ValidationError(
_ul('Пользователь с такой почтой уже существует.'))
return self.cleaned_data['email']
def clean_confirm_password(self):
if not self.cleaned_data['password'] == self.cleaned_data[
'confirm_password']:
raise forms.ValidationError(_ul('Пароли не совпадают.'))
return self.cleaned_data['confirm_password']
