You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
639 lines
26 KiB
639 lines
26 KiB
# encoding=utf-8
|
|
import random
|
|
from django.conf import settings
|
|
from django.db import models
|
|
from django.contrib.auth.models import BaseUserManager, AbstractBaseUser
|
|
import datetime
|
|
|
|
from django.db.models import SET_NULL
|
|
|
|
from courses.models import Vertex
|
|
from lms.regex import check_email
|
|
from lms.settings import STATIC_ROOT, DOMAIN
|
|
from lms.tools import random_string, random_int, out_date_format, get_client_ip
|
|
import os
|
|
from management.letters import sent_registration
|
|
from storage.models import Storage
|
|
import django.utils.timezone
|
|
from django.core.files.base import File
|
|
from django.utils.deconstruct import deconstructible
|
|
from uuid import uuid4
|
|
|
|
ROLE = (
|
|
('U', u'Студент школы'),
|
|
('T', u'Преподаватель'),
|
|
('M', u'Менеджер'),
|
|
('S', u'Руководитель'),
|
|
('S2', u'Куратор'),
|
|
('A', u'Администратор'),
|
|
('Ts', u'Тестовый пользователь'),
|
|
('F', u'Пользователь свободного счета')
|
|
)
|
|
|
|
@deconstructible
|
|
class PathAndRename(object):
|
|
|
|
def __init__(self, sub_path):
|
|
self.path = sub_path
|
|
|
|
def __call__(self, instance, filename):
|
|
ext = filename.split('.')[-1]
|
|
# set filename as random string
|
|
filename = '{}.{}'.format(uuid4().hex, ext)
|
|
# return the whole path to the file
|
|
return os.path.join(self.path, filename)
|
|
|
|
path_and_rename = PathAndRename("personal_files")
|
|
|
|
|
|
def insert_in_system(user, sent_letter=True):
|
|
if sent_letter:
|
|
sent_registration(user)
|
|
user.subscription = Subscription.objects.create(owner=user)
|
|
user.interactive_key = gen_interactive_key(user)
|
|
user.save()
|
|
|
|
|
|
def random_avatar():
|
|
ava_dir = os.path.join(STATIC_ROOT, 'img/avs')
|
|
files = os.listdir(ava_dir)
|
|
return os.path.join(ava_dir, random.choice(files))
|
|
|
|
|
|
class UserManager(BaseUserManager):
|
|
def create_user(self, email, password=None, sent_letter=True):
|
|
if not email:
|
|
raise ValueError(u"Пользователь должен иметь email")
|
|
|
|
if not check_email(email):
|
|
raise ValueError(u"Email введен не верно")
|
|
|
|
user = self.model(email=email)
|
|
user.set_password(password)
|
|
user.token = random_string(length=10, postfix=user.get_email())
|
|
user.save(using=self._db)
|
|
insert_in_system(user, sent_letter=sent_letter)
|
|
return user
|
|
|
|
def create_superuser(self, email, password):
|
|
user = self.create_user(email, password=password)
|
|
user.is_admin = True
|
|
user.is_active = True
|
|
user.superuser = True
|
|
user.is_staff = True
|
|
user.token = random_string(length=10, postfix=user.get_email())
|
|
user.save(using=self._db)
|
|
return user
|
|
|
|
def __unicode__(self):
|
|
return u'%s %s' % (self.get_short_name(), self.email)
|
|
|
|
|
|
def get_activate_time():
|
|
return datetime.datetime.now() + datetime.timedelta(days=7)
|
|
|
|
|
|
def gen_interactive_key(user):
|
|
# 1 Надпись ID
|
|
# 2 id в системе
|
|
# 3 #
|
|
# 4 5 случайных чисел
|
|
return 'ID{0}-{1}'.format(user.id, random_int(length=5))
|
|
|
|
|
|
class User(AbstractBaseUser):
|
|
STATUS_CHOICES = (
|
|
('ON', 'on-line'),
|
|
('OFF', 'off-line')
|
|
)
|
|
REG_STATUS = (
|
|
('1', 'Пароль'),
|
|
('2', 'О себе'),
|
|
('3', 'Фото'),
|
|
('4', 'Закончена')
|
|
)
|
|
PRIVATE = (
|
|
('A', 'Всему интернету'),
|
|
('U', 'Только пользователям системы'),
|
|
('L', 'По прямой ссылке'),
|
|
('B', 'Только мне')
|
|
)
|
|
SOURCE = (
|
|
('S', 'Органично'),
|
|
('B', 'Привлечен')
|
|
)
|
|
#sync = models.BooleanField(verbose_name=u'Синхронизирован', default=False)
|
|
#sync_date = models.DateTimeField(verbose_name=u'Дата постановки на синхронизацию', blank=True, null=True)
|
|
block = models.BooleanField(verbose_name=u'Заблокировать', default=False)
|
|
refer = models.CharField(verbose_name=u'Источник', max_length=1, choices=SOURCE, default='S', null=True)
|
|
refer_source = models.CharField(verbose_name=u'Источник пользователя', blank=True, max_length=255, default='')
|
|
traf_source = models.ForeignKey('TrafHistory', verbose_name=u'Обращение', blank=True, null=True)
|
|
private = models.CharField(verbose_name=u'Приватность профиля', max_length=1, choices=PRIVATE, default='A')
|
|
customer = models.BooleanField(verbose_name=u'Покупатель', default=False)
|
|
interactive_key = models.CharField(verbose_name=u'Интерактивый ключ', max_length=255, blank=True)
|
|
deactivate = models.BooleanField(verbose_name=u'Не давать новых студентов', default=False)
|
|
delay = models.BooleanField(verbose_name=u'Могут быть задержки', default=False, help_text=u'Если возможны задержки с проверками')
|
|
delay_description = models.TextField(verbose_name=u'Повод просрочки', blank=True)
|
|
delay_date = models.DateTimeField(verbose_name=u'Задержка до. Не включая этот день.', blank=True, default=django.utils.timezone.now, null=True)
|
|
email = models.EmailField(verbose_name='email', max_length=255, blank=True, db_index=True, unique=True,
|
|
help_text=u'Будьте аккуратны. Менять почту можно. Но только если очень нужно.')
|
|
changed_email = models.EmailField(verbose_name=u'Ящик на замену', blank=True, null=True)
|
|
phone = models.CharField(verbose_name=u'Телефон', max_length=255, default='', blank=True)
|
|
back_phone = models.CharField(verbose_name=u'Предидущий телефон', max_length=255, default='', blank=True)
|
|
status = models.CharField(max_length=9, choices=STATUS_CHOICES, default='ON')
|
|
in_role = models.CharField(verbose_name=u'Роль', choices=ROLE, max_length=2, default='U')
|
|
unique_role = models.CharField(verbose_name=u'Уникальная роль', max_length=255, blank=True, default='')
|
|
city = models.CharField(verbose_name=u'Город', max_length=255, default='', blank=True)
|
|
b_day = models.DateField(verbose_name=u'День рождения', null=True, blank=True)
|
|
token = models.CharField(max_length=255, default='', blank=True)
|
|
activate_time = models.DateTimeField(verbose_name=u"Активировать до", default=get_activate_time)
|
|
reg_status = models.CharField(verbose_name=u'Статус регистрации', choices=REG_STATUS, max_length=1, default='1')
|
|
is_active = models.BooleanField(default=False)
|
|
is_admin = models.BooleanField(default=False, editable=False)
|
|
is_staff = models.BooleanField(default=False, editable=False)
|
|
objects = UserManager()
|
|
avatar = models.CharField(verbose_name=u"Ключ аватара", max_length=255, blank=True, default='')
|
|
in_avatar = models.ImageField(verbose_name=u'Наш аватар', blank=True, null=True, editable=False, upload_to='in_ava')
|
|
fname = models.CharField(verbose_name=u"Фамилия", max_length=255, blank=True, default='')
|
|
name = models.CharField(verbose_name=u"Имя", max_length=255, blank=True, default='')
|
|
oname = models.CharField(verbose_name=u"Отчество", max_length=255, blank=True, default='')
|
|
#
|
|
skype = models.CharField(max_length=300, blank=True, default='')
|
|
facebook = models.CharField(default='', max_length=255, blank=True)
|
|
vk = models.CharField(max_length=255, default='', blank=True)
|
|
linkedin = models.CharField(max_length=255, default='', blank=True)
|
|
odnoklassniki = models.CharField(max_length=255, default='', blank=True)
|
|
#
|
|
last_time = models.DateTimeField(verbose_name=u'Последняя активность', default=datetime.datetime.now)
|
|
date_joined = models.DateTimeField(default=datetime.datetime.now)
|
|
last_ip = models.ForeignKey('UserRequest', verbose_name=u'Последний IP', blank=True, null=True, related_name='user_last_ip', on_delete=SET_NULL)
|
|
|
|
USERNAME_FIELD = 'email'
|
|
|
|
def save(self, *args, **kwargs):
|
|
if self.in_role in ['A', 'S2'] and not self.is_admin:
|
|
self.is_admin = True
|
|
self.is_staff = True
|
|
|
|
if self.in_role in ['M']:
|
|
self.is_staff = True
|
|
|
|
if not self.interactive_key:
|
|
self.interactive_key = gen_interactive_key(self)
|
|
|
|
super(User, self).save(*args, **kwargs)
|
|
|
|
def get_ip_len(self):
|
|
UserRequest.objects.filter(user=self).count()
|
|
|
|
def full_name(self):
|
|
return str(self.id) + ": " + self.fname + " " + self.name + " " + self.oname
|
|
|
|
def set_request_data(self, request):
|
|
ip = get_client_ip(request)
|
|
try:
|
|
_request = UserRequest.objects.get(ip=ip, user=self)
|
|
except UserRequest.DoesNotExist:
|
|
_request = UserRequest.objects.create(ip=ip, user=self)
|
|
|
|
_request.new_count(request)
|
|
self.last_ip = _request
|
|
self.save()
|
|
|
|
def get_ip(self):
|
|
return self.last_ip.ip if self.last_ip else None
|
|
|
|
def get_activation_url(self):
|
|
return u'{3}/access/activate/?step=1&token={0}&email={1}'.format(self.token, self.email, self.reg_status, DOMAIN)
|
|
|
|
def _set_to_sync(self):
|
|
self.sync = False
|
|
self.sync_date = datetime.datetime.now()
|
|
self.save()
|
|
|
|
def _set_synced(self):
|
|
self.sync = True
|
|
self.sync_date = None
|
|
self.save()
|
|
|
|
def change_token(self):
|
|
self.token = random_string(length=10, postfix=self.email)
|
|
self.save()
|
|
|
|
def get_status_point(self):
|
|
return {'title': self.get_status_display(),
|
|
'color': 'green' if self.status == 'ON' else 'red',
|
|
'point': 'glyphicon glyphicon-ok-sign' if self.status == 'ON' else 'glyphicon glyphicon-remove-sign'}
|
|
|
|
def get_full_data(self):
|
|
return self.full_data()
|
|
|
|
def full_data(self):
|
|
return 'Имя: {0} - Телефон: {1} - Почта: {2}'.format(self.get_full_name(), self.get_phone(), self.email)
|
|
|
|
def get_name(self):
|
|
if self.name:
|
|
return self.name
|
|
else:
|
|
return 'Без имени'
|
|
|
|
def get_face(self):
|
|
return {'full_name': self.get_full_name(),
|
|
'short_name': self.get_short_name(),
|
|
'name': self.name if self.name else '',
|
|
'fname': self.fname if self.fname else '',
|
|
'oname': self.oname if self.oname else '',
|
|
'email': self.email,
|
|
'phone': self.get_phone(),
|
|
'ava': self.get_image_url(),
|
|
'date_joined': out_date_format(self.date_joined),
|
|
'status': self.get_status_point(),
|
|
'id': self.id,
|
|
'interactive_key': self.interactive_key,
|
|
'is_staff': self.is_staff or self.is_admin,
|
|
'role': self.unique_role if self.unique_role else self.get_in_role_display(),
|
|
'is_unique_role': bool(self.unique_role),
|
|
'profile': self.get_profile()}
|
|
|
|
def get_username(self):
|
|
return self.get_short_name()
|
|
|
|
def get_image_url(self, type_in=None):
|
|
try:
|
|
image = Storage.objects.get(key=self.avatar)
|
|
except Storage.DoesNotExist:
|
|
if not self.in_avatar:
|
|
self.in_avatar.save('ava', File(open(random_avatar(), 'rb')), save=True)
|
|
return '{0}/{1}'.format(DOMAIN, self.in_avatar.url)
|
|
else:
|
|
try:
|
|
image = image.get_url(type_in)
|
|
except IOError:
|
|
if not self.in_avatar:
|
|
self.in_avatar.save('ava', File(open(random_avatar(), 'rb')), save=True)
|
|
return '{0}/{1}'.format(DOMAIN, self.in_avatar.url)
|
|
return image
|
|
|
|
def clean_image(self):
|
|
self.avatar = ''
|
|
self.save()
|
|
|
|
def get_phone(self):
|
|
return self.phone
|
|
|
|
def get_back_phone(self):
|
|
return self.back_phone
|
|
|
|
def get_email(self):
|
|
return self.email
|
|
|
|
def get_full_name(self):
|
|
result = u""
|
|
# Если есть фамилия пишем: Фамилия Имя Отчество
|
|
if self.fname:
|
|
result += u"%s" % self.fname
|
|
if self.name:
|
|
result += u" %s" % self.name
|
|
if self.oname:
|
|
result += u" %s" % self.oname
|
|
|
|
if result:
|
|
return result
|
|
else:
|
|
return self.email
|
|
|
|
def get_short_name(self):
|
|
result = u""
|
|
# Если есть фамилия пишем: Фамилия И.О.
|
|
if self.fname:
|
|
result += u"%s" % self.fname
|
|
if self.name:
|
|
result += u" %s." % self.name[0].upper()
|
|
if self.oname:
|
|
result += u" %s." % self.oname[0].upper()
|
|
|
|
# Если нет фамилии пишем: Имя Отчество
|
|
elif not self.fname and self.name:
|
|
if self.name:
|
|
result += u"%s" % self.name
|
|
if self.oname:
|
|
result += u" %s" % self.oname
|
|
|
|
if result:
|
|
return result
|
|
else:
|
|
return self.email
|
|
|
|
def has_perm(self, perm, obj=None):
|
|
return True
|
|
|
|
def has_module_perms(self, app_label):
|
|
return True
|
|
|
|
def check_subscription(self, right):
|
|
return Subscription.objects.get_or_create(owner=self)[0].check_right(right)
|
|
|
|
def get_profile(self):
|
|
return u'{0}/{1}'.format(DOMAIN, self.interactive_key)
|
|
|
|
def __unicode__(self): return u'%s:%s' % (self.id, self.get_short_name())
|
|
|
|
def __str__(self): return '%s:%s' % (self.id, self.get_short_name())
|
|
|
|
def name_to_html(self, user):
|
|
if user == self:
|
|
return u"<span class='pseudo_link'>Вы</span>"
|
|
else:
|
|
return u"<span user-id='%s' action-type='user_data' class='pseudo_link' style='margin-right:0;'>%s</span>" \
|
|
% (self.id, self.get_short_name())
|
|
|
|
def check_phone(self, _type='actual'): # actual = self.phone, back = self.back_phone
|
|
phone = self.phone if _type == 'actual' else self.back_phone
|
|
return bool(len(''.join([n for n in phone if n in [str(x) for x in range(0,10)]])) > 9)
|
|
|
|
def clean_phone(self, _type='actual'):
|
|
return ''.join([n for n in self.phone if n in [str(x) for x in range(0,10)]]) if self.check_phone() else ''
|
|
|
|
|
|
class Meta:
|
|
verbose_name = u"Пользователя"
|
|
verbose_name_plural = u"Пользователи"
|
|
|
|
|
|
class UserRequest(models.Model):
|
|
# Информация о сессиях пользователей при авторизации
|
|
ip = models.CharField(verbose_name=u'IP', max_length=255)
|
|
user = models.ForeignKey(User, verbose_name=u'Пользователь')
|
|
count = models.IntegerField(verbose_name=u'Количество использований', default=0)
|
|
date = models.DateTimeField(verbose_name=u'Дата', default=datetime.datetime.now)
|
|
|
|
def __str__(self):
|
|
return self.ip
|
|
|
|
def new_count(self, request):
|
|
self.count += 1
|
|
UserRequestData.objects.create(row=self, data=request)
|
|
self.save()
|
|
|
|
class Meta:
|
|
verbose_name = u'Данные сессии при авторизации'
|
|
verbose_name_plural = u'Данные сессий при авторизации'
|
|
|
|
|
|
class UserRequestData(models.Model):
|
|
# Содержимое сессии пользователя
|
|
row = models.ForeignKey(UserRequest, verbose_name=u'Запрос')
|
|
data = models.TextField(verbose_name=u'Данные')
|
|
date = models.DateTimeField(verbose_name=u'Дата', default=datetime.datetime.now)
|
|
|
|
def __str__(self):
|
|
return str(self.row)
|
|
|
|
class Meta:
|
|
verbose_name = u'Данные запроса'
|
|
verbose_name_plural = u'Данные запроса'
|
|
|
|
|
|
class Subscription(models.Model):
|
|
# Подписки
|
|
owner = models.OneToOneField(User, verbose_name=u"Владелец", unique=True, related_name='rights_owner')
|
|
news = models.BooleanField(verbose_name=u"Подписка на новости", default=True)
|
|
teacher = models.BooleanField(verbose_name=u'Ответы преподователя', default=True)
|
|
new_comments = models.BooleanField(verbose_name=u'Ответы на комментарии', default=True)
|
|
send_sms = models.BooleanField(verbose_name=u'Отправлять sms', default=False)
|
|
courses = models.BooleanField(verbose_name=u'Новые курсы', default=True)
|
|
|
|
def __str__(self): return "%s: %s" % (self.id, self.owner)
|
|
|
|
def __unicode__(self): return u"%s: %s" % (self.id, self.owner)
|
|
|
|
def check_right(self, right):
|
|
# Проверка указанного права для пользователя
|
|
return self.right_map(right)
|
|
|
|
def set_right(self, right, value):
|
|
# Установка права
|
|
if right == 'news':
|
|
self.news = value
|
|
elif right == 'teacher':
|
|
self.teacher = value
|
|
elif right == 'send_sms':
|
|
self.send_sms = value
|
|
elif right == 'courses':
|
|
self.courses = value
|
|
elif right == 'new_comments':
|
|
self.new_comments = value
|
|
self.save()
|
|
|
|
def set_default_values(self):
|
|
# Установка дефолтных значений
|
|
for field in self._meta.fields:
|
|
if field.has_default:
|
|
self.set_right(field.name, field.default)
|
|
|
|
def right_map(self, right):
|
|
# Карта проверки прав
|
|
__right_map = {
|
|
'news': self.news,
|
|
'teacher': self.teacher,
|
|
'send_sms': self.send_sms,
|
|
'courses': self.courses,
|
|
'new_comments': self.new_comments
|
|
}
|
|
if right in __right_map:
|
|
return __right_map[right]
|
|
else:
|
|
return __right_map
|
|
|
|
class Meta:
|
|
verbose_name = u"Подписка"
|
|
verbose_name_plural = u"Подписки"
|
|
|
|
|
|
class ActionJ(models.Model):
|
|
ACTION_TYPE = (
|
|
('B', 'b-default'),
|
|
('P', 'b-primary'),
|
|
('S', 'b-success'),
|
|
('I', 'b-info'),
|
|
('W', 'b-warning'),
|
|
('D', 'b-danger')
|
|
)
|
|
student = models.ForeignKey(User, verbose_name=u'Студент')
|
|
a_type = models.CharField(verbose_name=u'Тип события', choices=ACTION_TYPE, max_length=1, default='B')
|
|
place = models.CharField(verbose_name=u'Место создания события', max_length=100)
|
|
date = models.DateTimeField(verbose_name=u'Время создания', default=django.utils.timezone.now)
|
|
text = models.TextField(verbose_name=u'Текст сообщения')
|
|
|
|
def __str__(self):
|
|
return '%s %s %s' % (self.get_a_type_display(), self.place, self.date)
|
|
|
|
def __unicode__(self):
|
|
return u'%s %s %s' % (self.get_a_type_display(), self.place, self.date)
|
|
|
|
class Meta:
|
|
verbose_name = u'Журнал активности'
|
|
verbose_name_plural = u'Журналы активностей'
|
|
|
|
|
|
class TrafSource(models.Model):
|
|
on = models.BooleanField(verbose_name=u'Ативен', default=True)
|
|
url = models.URLField(verbose_name=u'Источник трафика')
|
|
token = models.CharField(verbose_name=u'Токен доступа', max_length=255, editable=False)
|
|
token_start = models.DateTimeField(verbose_name=u'Точка отсчета жизни токена', editable=False, null=True)
|
|
live_time = models.IntegerField(verbose_name=u'Время жизни токена', blank=True, help_text=u'Указывается в часах. пустое поле - пожизненно', null=True)
|
|
date_start = models.DateTimeField(verbose_name=u'Дата запуска источника', default=datetime.datetime.now)
|
|
|
|
def __str__(self):
|
|
return '%s' % self.url
|
|
|
|
def __unicode__(self):
|
|
return u'%s' % self.url
|
|
|
|
def save(self, *args, **kwargs):
|
|
if not self.token:
|
|
self.token = random_string(length=20)
|
|
self.token_start = datetime.datetime.now()
|
|
super(TrafSource, self).save(*args, **kwargs)
|
|
|
|
class Meta:
|
|
verbose_name = u'Источник трафика'
|
|
verbose_name_plural = u'Источники трафика'
|
|
|
|
|
|
class TrafTokenHistory(models.Model):
|
|
token = models.CharField(verbose_name=u'Токен', max_length=255, editable=False)
|
|
live_time = models.IntegerField(verbose_name=u'Время жизни', help_text=u'В часах', editable=False)
|
|
date_start = models.DateTimeField(verbose_name=u'Дата установки токена', editable=False)
|
|
date_end = models.DateTimeField(verbose_name=u'Дата отключения', editable=False)
|
|
source = models.ForeignKey(TrafSource, verbose_name=u'Использующий источник', editable=False)
|
|
|
|
def __str__(self):
|
|
return '%s %s:%s %s' % (self.token, self.date_start, self.date_end, self.sources)
|
|
|
|
def __unicode__(self):
|
|
return u'%s %s:%s %s' % (self.token, self.date_start, self.date_end, self.sources)
|
|
|
|
class Meta:
|
|
verbose_name = u'История смены токена'
|
|
verbose_name_plural = u'Истории смены токенов'
|
|
|
|
|
|
class TrafHistory(models.Model):
|
|
TRAF_ACTION = (
|
|
('G', 'Получение данных'),
|
|
('D', 'Запись данных'),
|
|
('C', 'Создание пользователя'),
|
|
('O', 'Создание счета')
|
|
)
|
|
action = models.CharField(verbose_name=u'Действие', choices=TRAF_ACTION, max_length=1)
|
|
source = models.ForeignKey(TrafSource, verbose_name=u'Источник запроса')
|
|
token = models.CharField(verbose_name=u'Используемый токен', max_length=255, null=True)
|
|
data = models.TextField(verbose_name=u'Данные в запросе')
|
|
result = models.BooleanField(verbose_name=u'Результат запроса', default=False)
|
|
result_description = models.CharField(verbose_name=u'Описание результата', max_length=255, blank=True)
|
|
date = models.DateTimeField(verbose_name=u'Дата обращения', default=datetime.datetime.now)
|
|
|
|
def __str__(self):
|
|
return '%s %s %s' % (self.source, self.action, self.result)
|
|
|
|
def __unicode__(self):
|
|
return u'%s %s %s' % (self.source, self.action, self.result)
|
|
|
|
class Meta:
|
|
verbose_name = u'Обращение источника'
|
|
verbose_name_plural = u'Обращения источников'
|
|
|
|
|
|
class Document(models.Model):
|
|
DOC_STATUS = (
|
|
('W', u'На оформлении'),
|
|
('F', u'Оформлен')
|
|
)
|
|
title = models.CharField(verbose_name=u'Заголовок', max_length=255)
|
|
status = models.CharField(verbose_name=u'Статус', choices=DOC_STATUS, default='W', editable=False, max_length=1)
|
|
user = models.ForeignKey(User, verbose_name=u'Пользователь')
|
|
date = models.DateField(verbose_name=u'Дата заключения', default=datetime.datetime.now)
|
|
file = models.FileField(verbose_name=u'Скан', upload_to='documents', null=True, blank=True)
|
|
in_date = models.DateTimeField(verbose_name=u'Дата добавления', default=datetime.datetime.now, editable=False)
|
|
|
|
def __str__(self):
|
|
return u'%s %s' % (self.title, self.date)
|
|
|
|
def __unicode__(self):
|
|
return u'%s %s' % (self.title, self.date)
|
|
|
|
def save(self, *args, **kwargs):
|
|
if self.file and self.status != 'F':
|
|
self.status = 'F'
|
|
elif not self.file and self.status != 'W':
|
|
self.status = 'W'
|
|
super(Document, self).save(*args, **kwargs)
|
|
|
|
class Meta:
|
|
verbose_name = u'Документ'
|
|
verbose_name_plural = u'Документы'
|
|
|
|
|
|
class Questionnaire(models.Model):
|
|
GENDER = (
|
|
('M', 'Мужчина'),
|
|
('W', 'Женщина')
|
|
)
|
|
EXP = (
|
|
('1', 'Только начинаю'),
|
|
('2', 'Да, менее года'),
|
|
('3', 'Да, 1-2 года'),
|
|
('4', 'Да, более 2 лет')
|
|
)
|
|
|
|
AIM = (
|
|
('1', 'Да, в офисе'),
|
|
('2', 'Да, свой проект'),
|
|
('3', 'Да, на фрилансе'),
|
|
('4', 'Нет, изучаю для себя')
|
|
)
|
|
AGE = (
|
|
('1', 'до 18'),
|
|
('2', '18-25'),
|
|
('3', '25-30'),
|
|
('4', '30-40'),
|
|
('5', 'больше 40')
|
|
)
|
|
FULLY = (
|
|
('1', 'Флаги'),
|
|
('2', 'Свободный ответ'),
|
|
('3', 'Завершено')
|
|
)
|
|
fully = models.CharField(verbose_name=u'Стадия', max_length=1, choices=FULLY, default=1) # Завершенность заполения
|
|
steps = models.IntegerField(verbose_name=u'Количество показов', default=0, help_text=u'Количество показов для заполнения')
|
|
user = models.ForeignKey(User, verbose_name=u'Пользователь')
|
|
male = models.CharField(verbose_name=u'Пол', choices=GENDER, max_length=1, null=True, blank=True)
|
|
city = models.CharField(verbose_name=u'Город', max_length=255, null=True, blank=True)
|
|
experience = models.CharField(verbose_name=u'Опыт', max_length=1, choices=EXP, null=True, blank=True)
|
|
aim = models.CharField(verbose_name=u'Цель обучения', max_length=1, choices=AIM, null=True, blank=True)
|
|
age = models.CharField(verbose_name=u'Возраст', max_length=1, choices=AGE, null=True, blank=True)
|
|
description = models.TextField(verbose_name=u'Свободны ответ', blank=True)
|
|
|
|
def __str__(self):
|
|
return u'%s %s' % (self.user, self.get_fully_display())
|
|
|
|
def __unicode__(self):
|
|
return u'%s %s' % (self.user, self.get_fully_display())
|
|
|
|
class Meta:
|
|
verbose_name = u'Акета'
|
|
verbose_name_plural = u'Анкеты'
|
|
|
|
|
|
# Новое API
|
|
|
|
class Privilege(models.Model):
|
|
TYPES = (
|
|
('r', 'Отображение'),
|
|
('u', 'Использование'),
|
|
('w', 'Изменение'),
|
|
)
|
|
user = models.ForeignKey(to=settings.AUTH_USER_MODEL, verbose_name=u'Правообладатель')
|
|
value = models.CharField(verbose_name=u'Права', choices=TYPES, max_length=1, default='r')
|
|
subject = models.ForeignKey(to=Vertex, verbose_name=u'Объект')
|
|
|