class User(ModelBase):
email = fields.EmailField(unique=True)
class Meta:
indexes = [
models.Index(fields=['email']),
]
class BaseSubscriber(AbstractSubscriber, models.Model):
objects = BaseSubscriberManager()
email = fields.EmailField(max_length=255, verbose_name=_("Email"))
subscriber_status = fields.IntegerField(
choices=AbstractSubscriber.STATUS_CHOICES,
verbose_name=_("Subscriber status"))
class Meta(AbstractSubscriber.Meta):
swappable = "NUNTIUS_SUBSCRIBER_MODEL"
class SignupForm(UserCreationForm):
"""
A form that creates a user, with no privileges, from the given username and
password.
"""
error_messages = {
'password_mismatch': _("The two password fields didn't match."),
}
password1 = forms.CharField(
label=_("Password"),
strip=False,
widget=forms.PasswordInput,
help_text=password_validation.password_validators_help_text_html(),
)
password2 = forms.CharField(
label=_("Password confirmation"),
widget=forms.PasswordInput,
strip=False,
help_text=_("Enter the same password as before, for verification."),
)
email = fields.EmailField(help_text='Required')
class Meta:
model = get_user_model() #### figure it out !!!!
fields = ("email", "first_name", "last_name", "password1", "password2")
def __init__(self, *args, **kwargs):
super(SignupForm, self).__init__(*args, **kwargs) # UserCreationForm Changed to SignupForm
if self._meta.model.EMAIL_FIELD in self.fields:
self.fields[self._meta.model.EMAIL_FIELD].widget.attrs.update({'autofocus': True})
def clean_password2(self):
password1 = self.cleaned_data.get("password1")
password2 = self.cleaned_data.get("password2")
if password1 and password2 and password1 != password2:
raise forms.ValidationError(
self.error_messages['password_mismatch'],
code='password_mismatch',
)
self.instance.username = self.cleaned_data.get('username')
password_validation.validate_password(self.cleaned_data.get('password2'), self.instance)
return password2
def save(self, commit=True):
user = SignupForm.save(commit=False)
user.set_password(self.cleaned_data["password1"])
if commit:
user.save()
return user
class Registration(Model):
camp = ForeignKey(Camp, on_delete=CASCADE)
clan = ForeignKey(Clan, on_delete=PROTECT)
telephone = fields.CharField(max_length=100)
contact_name = fields.CharField(max_length=100)
email = fields.EmailField(max_length=100)
comment = fields.TextField(max_length=1000, null=True, blank=True)
paid = fields.DecimalField(decimal_places=2, max_digits=6, default=0)
rules_accepted = fields.BooleanField(default=False,
validators=[validate_true])
present_participants = fields.PositiveIntegerField(null=True)
def get_price(self):
price = 0
for info in self.ticketinfo_set.all():
price += info.quantity * info.fee.price
return price
def get_quantity(self):
quantity = 0
for info in self.ticketinfo_set.all():
quantity += info.quantity
return quantity
def get_quantities(self):
quantities = list()
for fee in self.camp.fee_set.all().order_by('pk'):
value = 0
for info in self.ticketinfo_set.all():
if info.fee == fee:
value = info.quantity
quantities.append(value)
return quantities
def get_ticket_count(self):
tickets = list()
for info in self.ticketinfo_set.all():
tickets.extend(info.ticket_set.all())
return len(tickets)
def get_registrated_participant_count(self):
count = 0
for info in self.ticketinfo_set.all():
for ticket in info.ticket_set.all():
if ticket.registrated:
count += 1
return count
def __str__(self):
return "Registration from {}".format(self.clan.name)
class ParentCard(models.Model):
fio = f.CharField(max_length=100, verbose_name='ФИО')
address = f.CharField(max_length=100, verbose_name='Адрес')
phone_number = PhoneNumberField(null=False,
unique=True,
verbose_name='Номер телефона')
gender = f.CharField(max_length=7,
choices=GENDER_CHOICES,
verbose_name='Пол')
date_of_birth = f.DateTimeField(verbose_name='Дата рождения',
blank=True,
null=True)
email = f.EmailField(verbose_name='E-mail')
def __str__(self):
return self.fio
class Contact(ModelBase):
contact_book = models.ForeignKey(ContactBook)
email = fields.EmailField(unique=True, null=False, blank=False)
first_name = fields.CharField(max_length=127)
last_name = fields.CharField(max_length=127, null=True, blank=True)
phone = fields.CharField(max_length=20, null=True, blank=True)
address = models.TextField(blank=True, null=True)
class Meta:
indexes = [
models.Index(fields=[
'first_name',
'last_name',
]),
models.Index(fields=['email']),
]
class User(Model):
"user model to be quried from"
username_validator = UnicodeUsernameValidator()
username = fields.CharField(
_('username'),
max_length=150,
unique=True,
help_text=_('Required. 150 characters or fewer. Letters, digits and @/./+/-/_ only.'),
validators=[username_validator],
error_messages={
'unique': _("A user with that username already exists."),
},
)
first_name = fields.CharField(_('first name'), max_length=30, blank=True)
last_name = fields.CharField(_('last name'), max_length=30, blank=True)
email = fields.EmailField(_('email address'), blank=True)
password = fields.CharField(_('password'), max_length=255, blank=True)
fcm_id = fields.CharField(_('fcm id'), max_length=255, blank=True)
objects = UserManager()
class User(AbstractUser):
first_name = None
last_name = None
email = fields.EmailField(unique=True)
full_name = fields.CharField(max_length=250)
class User(_Abstract, _Model):
from django.db.models import fields as _field
from app.fields import timezone as _timezone
email = _field.EmailField(
verbose_name='E-mail',
null=False,
blank=False,
unique=True,
max_length=256,
)
phone = _field.CharField(
verbose_name='Телефон',
max_length=30,
null=False,
blank=False,
)
activation = _field.CharField(
verbose_name='Код активации/восстановления пароля',
max_length=255,
null=True,
editable=False,
default=_activation_key)
timezone = _timezone.TimeZoneField(
verbose_name='Локальное время пользователя',
default='UTC',
null=False,
blank=True,
)
is_active = _field.BooleanField(
verbose_name='Активирован',
default=
True, # Causes problems with super users if is not set to True. Handle base user active in views.
)
is_banned = _field.BooleanField(
verbose_name='Забанен',
default=False,
)
def new_activation(self):
self.activation = _activation_key()
return self.activation
def check_activation(self, code):
if self.activation is None or code is None or code == '':
return False
return self.activation == code
def activate(self):
""" Modificates user activation and save """
self.is_active = True
self.activation = None
self.save()
def deactivate(self):
""" Modificates user activation and save """
self.is_active = False
self.activation = None
self.save()
def get_token(self):
from entry.jwt import create_token
return create_token(self)
def __str__(self):
return "%s %s (%s)" % (self.first_name, self.last_name,
self.username) if (self.first_name
or self.last_name) else (
"%s" % self.username)
def reactivate(self):
self.new_activation()
self.save()
# Mails part
def mail_default(self, subject, template):
from django.conf import settings
_Mail(mail_from=settings.EMAIL_ADDRESSES.get('main'),
mail_to=self.email,
subject=subject,
template=template,
context={
'user': self,
}).start()
def mail_activation(self):
self.mail_default(
template='user%sregister' % _os.sep,
subject="Registration",
)
def mail_activation_resend(self):
self.reactivate()
self.mail_default(
template='user%sregister' % _os.sep,
subject="Repeat registration mail",
)
def mail_reset_password(self):
self.reactivate()
self.mail_default(
template='user%snew_password' % _os.sep,
subject="Password restoration",
)
class Meta(_Abstract.Meta):
swappable = 'AUTH_USER_MODEL'
verbose_name = 'Пользователь'
verbose_name_plural = 'Пользователи'
class Campaign(AbstractCampaign):
message_from_name = fields.CharField(_('"From" name'),
max_length=255,
blank=True)
message_from_email = fields.EmailField(_('"From" email address'),
max_length=255)
message_reply_to_name = fields.CharField(_('"Reply to" name'),
max_length=255,
blank=True)
message_reply_to_email = fields.CharField(_('"Reply to" email address'),
max_length=255,
blank=True)
message_subject = fields.CharField(_("Message subject line"),
max_length=255,
blank=True)
message_mosaico_data = fields.TextField(_("Mosaico data"), blank=True)
message_content_html = fields.TextField(_("Message content (HTML)"),
blank=True)
message_content_text = fields.TextField(_("Message content (text)"),
blank=True)
def save(self, *args, **kwargs):
if self.message_mosaico_data:
self.message_content_text = generate_plain_text(
self.message_content_html)
super().save(*args, **kwargs)
def get_sent_count(self):
return (CampaignSentEvent.objects.filter(campaign=self).exclude(
result=CampaignSentStatusType.PENDING).count())
def get_ok_count(self):
return (CampaignSentEvent.objects.filter(campaign=self).filter(
result=CampaignSentStatusType.OK).count())
def get_bounced_count(self):
return (CampaignSentEvent.objects.filter(campaign=self).filter(
result=CampaignSentStatusType.BOUNCED).count())
def get_complained_count(self):
return (CampaignSentEvent.objects.filter(campaign=self).filter(
result=CampaignSentStatusType.COMPLAINED).count())
def get_blocked_count(self):
return (CampaignSentEvent.objects.filter(campaign=self).filter(
result=CampaignSentStatusType.BLOCKED).count())
def get_open_count(self):
return CampaignSentEvent.objects.filter(campaign=self).aggregate(
count=Coalesce(Sum("open_count"), Value(0)))["count"]
def get_unique_open_count(self):
return (CampaignSentEvent.objects.filter(campaign=self).filter(
open_count__gt=0).count())
def get_click_count(self):
return CampaignSentEvent.objects.filter(campaign=self).aggregate(
count=Coalesce(Sum("click_count"), Value(0)))["count"]
def get_unique_click_count(self):
return (CampaignSentEvent.objects.filter(campaign=self).filter(
click_count__gt=0).count())
def get_event_for_subscriber(self, subscriber):
event, _ = CampaignSentEvent.objects.get_or_create(
campaign=self,
subscriber=subscriber,
defaults={"email": subscriber.get_subscriber_email()},
)
return event
def __repr__(self):
return f"Campaign(id={self.id!r}, name={self.name!r})"
@cached_property
def html_template(self):
from nuntius.messages import insert_tracking_image_template
return Template(
insert_tracking_image_template(self.message_content_html))
@cached_property
def text_template(self):
return Template(self.message_content_text)
@property
def from_header(self):
if self.message_from_name:
return f"{self.message_from_name} <{self.message_from_email}>"
return self.message_from_email
@property
def reply_to_header(self):
if self.message_reply_to_email:
if self.message_reply_to_name:
return f"{self.message_reply_to_name} <{self.message_reply_to_email}>"
return self.message_reply_to_email
return None
class Meta:
verbose_name = _("email campaign")
verbose_name_plural = _("email campaigns")
class Employee(_Model):
from django.db.models import fields as _field
from app.fields import timezone as _timezone
from django.db.models.fields import related as _related
from django.db.models import deletion as _deletion
first_name = _field.CharField(
max_length=200,
verbose_name="Имя",
)
last_name = _field.CharField(
max_length=200,
verbose_name="Фамилия",
)
phone = _field.CharField(
max_length=200,
verbose_name="Телефон",
null=True,
blank=True,
)
company = _related.ForeignKey(
'holding.Company',
on_delete=_deletion.SET_NULL,
verbose_name="Компания",
null=True,
blank=True,
related_name="employees",
)
is_manager = _field.BooleanField(
verbose_name="Менеджер",
default=False,
)
is_fired = _field.BooleanField(
verbose_name="Уволен",
default=False,
)
import uuid as _uuid
auth_key = _field.UUIDField(
verbose_name="Уникальный авторизационный ключ",
editable=False,
unique=True,
null=True,
blank=False,
default=_uuid.uuid4,
)
email = _field.EmailField(
verbose_name="E-mail",
null=True,
blank=True,
)
timezone = _timezone.TimeZoneField(
verbose_name="Пояс",
default="UTC",
null=False,
blank=True,
)
invitation = _field.DateTimeField(
verbose_name="Последнее приглашение",
null=True,
blank=True,
)
is_invited = _field.BooleanField(
verbose_name="Приглашён",
null=False,
default=False,
)
is_active = _field.BooleanField(
verbose_name="Активен",
null=False,
default=False,
)
face_id = _field.UUIDField(
verbose_name="Face ID",
null=True,
blank=True,
)
user = _related.ForeignKey(
'entry.User',
on_delete=_deletion.CASCADE,
verbose_name="Физический пользователь",
null=True,
blank=True,
)
department = _related.ForeignKey(
'holding.Department',
on_delete=_deletion.SET_NULL,
default=None,
null=True,
blank=True,
related_name="employees",
)
position = _related.ForeignKey(
'holding.Position',
on_delete=_deletion.SET_NULL,
default=None,
null=True,
blank=True,
related_name="employees",
)
def clear_face_id(self):
self.face_id = None
def new_face_id(self):
self.face_id = self._uuid.uuid4()
def new_invitation(self):
from datetime import datetime
old = self.invitation
self.invitation = datetime.now()
return old
def activate(self):
self.is_invited = True
self.is_active = True
self.auth_key = None
def __str__(self):
user = self.user
ttl = {}
if self.last_name and self.first_name:
ttl['first_name'] = self.first_name
ttl['last_name'] = self.last_name
elif user:
if user.last_name and user.first_name:
ttl['first_name'] = user.first_name
ttl['last_name'] = user.last_name
ttl['username'] = user.username
if ttl.get('first_name'):
if ttl.get('username'):
return "%(first_name)s %(last_name)s [%(username)s]" % ttl
else:
return "%(first_name)s %(last_name)s" % ttl
elif ttl.get('username'):
return "%(username)s" % ttl
else:
return "Employee №[%d]" % self.id
@classmethod
def create_from_user(cls, user, **kwargs):
"""
:type user: entry.models.User
"""
from factory.faker import faker
fake = faker.Faker(locale='ru_RU')
employee = cls(
user=user,
first_name=user.first_name if user.first_name else fake.first_name(),
last_name=user.last_name if user.last_name else fake.last_name(),
timezone=user.timezone,
phone=user.phone,
email=user.email,
is_active=True,
**kwargs
)
employee.save()
return employee
def set_position(self, position, department=None):
self.position = position
if not department and not self.department:
related = position.departments.first()
if related:
self.department = related.department
elif department:
self.department = department
class Meta:
verbose_name = "Сотрудник"
verbose_name_plural = "Сотрудники"
unique_together = (('user', 'company'),)
def create_user(self, username=None):
"""
Creates user from employee, save it and send email if application not in debug mode
:type username: str
"""
from django.conf import settings
from entry.models import User
if not self.auth_key and not username:
raise AttributeError('No username provided or can\'t be get from auth')
user = User(
username=username if username else self.auth_key,
first_name=self.first_name,
last_name=self.last_name,
email=self.email,
phone=self.phone,
timezone=self.timezone,
)
user.save()
self.user = user
if user.email and not settings.DEBUG:
user.mail_activation()
if settings.DEBUG:
user.activate()
self.activate()
return user
class Company(_Model):
from app.fields import timezone as _timezone
name = _field.CharField(
verbose_name='Название компании',
max_length=255,
null=False,
)
description = _field.TextField(
verbose_name='Описание компании',
max_length=4000,
null=True,
blank=True,
)
address = _field.CharField(
verbose_name='Адрес компании',
max_length=512,
null=True,
blank=True,
)
phone = _field.CharField(
verbose_name='Телефон',
max_length=32,
null=True,
blank=True,
)
email = _field.EmailField(
verbose_name='Почтовый ящик',
max_length=255,
null=False,
)
owner = _related.ForeignKey(
'holding.Employee', # Changed company owner from user to employee because of the system flow
verbose_name='Владелец',
on_delete=_deletion.DO_NOTHING,
null=False,
related_name='owner',
)
discount = _related.ForeignKey(
to='pay.Discount',
on_delete=_deletion.SET_NULL,
null=True,
blank=True,
)
timezone = _timezone.TimeZoneField(
verbose_name='Локальное время компании',
default='UTC',
null=False,
blank=True,
)
def __str__(self):
return self.name
@property
def last_payment(self):
from pay.models import Payment
return Payment.objects.filter(details__company=self).last()
@property
def rate(self):
return self.last_payment.details.rate if self.last_payment else None
rate.fget.short_description = u'Тариф'
@property
def time_left(self):
return self.last_payment.time_left if self.last_payment else -1
time_left.fget.short_description = u"Оплаченное время"
@property
def employee_amount(self):
return self.employees.count()
employee_amount.fget.short_description = u"Сотрудников"
@property
def departments_amount(self):
return self.departments.count()
departments_amount.fget.short_description = u"Отделов"
def save(self,
force_insert=False,
force_update=False,
using=None,
update_fields=None):
creation = True
if self.id:
creation = False
super(Company, self).save(force_insert, force_update, using,
update_fields)
self.owner.company = self
self.owner.save()
if creation:
CompanyCreator(creator=self.owner, company=self).save()
class Meta:
verbose_name = "Компания"
verbose_name_plural = "Компании"
class User(AbstractBaseUser, PermissionsMixin):
id = fields.AutoField(
verbose_name=_('ID'),
primary_key=True,
)
site = models.ForeignKey(
Site,
related_name='users',
null=True,
blank=True,
db_index=True,
)
email = fields.EmailField(
verbose_name=_('Email Address'),
max_length=255,
null=False,
blank=False,
unique=True,
)
first_name = fields.CharField(
verbose_name=_('First Name'),
max_length=32,
null=True,
blank=False,
)
last_name = fields.CharField(
verbose_name=_('Last Name'),
max_length=32,
null=True,
blank=False,
)
is_active = fields.BooleanField(
verbose_name=_('Is Active'),
null=False,
blank=False,
default=True,
db_index=True,
)
create_date = fields.DateTimeField(
verbose_name=_('Create Date'),
null=False,
blank=True,
auto_now_add=True,
)
update_date = fields.DateTimeField(
verbose_name=_('Update Date'),
null=True,
blank=True,
auto_now=True,
)
@property
def is_staff(self):
return self.is_superuser
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = []
objects = UserManager()
class Meta:
db_table = 'auth_user'
verbose_name = _('User')
verbose_name_plural = _('Users')
get_latest_by = 'create_date'
default_related_name = 'users'
def get_short_name(self):
return self.first_name if self.first_name is not None else self.email
def get_full_name(self):
return '{0} {1}'.format(self.first_name, self.last_name)
def __str__(self):
return self.email
