МОДЕЛИ
# -*- coding: utf-8 -*-

# Core
from django.contrib.auth.models import AbstractBaseUser, PermissionsMixin
from django.template.loader import render_to_string
from django.core.mail import EmailMultiAlternatives
from django.utils.translation import ugettext as _
from django.utils import timezone, six
from django.conf import settings
from django.db import models
import datetime
import hashlib
import random

# Project
from .managers import CustomUserManager


class AbstractCustomUser(AbstractBaseUser, PermissionsMixin):
    """
    User fields
    """
    email = models.EmailField(_(u'Email'), max_length=255, unique=True)
    phone = models.CharField(_(u'Телефон'), max_length=20)
    city = models.CharField(_(u'Город'), max_length=30)
    street = models.CharField(_(u'Улица'), max_length=30)
    house = models.CharField(_(u'Дом'), max_length=30)
    flat = models.CharField(_(u'Квартира'), max_length=30, null=True, blank=True)
    note = models.CharField(_(u'Описание'), max_length=255, null=True, blank=True)
    votes = models.IntegerField(_(u'Количество голосов'), default=0)
    likes = models.IntegerField(_(u'Количество лайков'), default=0)
    dislikes = models.IntegerField(_(u'Количество дизлайков'), default=0)

    """
    Customer fields
    """
    first_name = models.CharField(_(u'Имя'), max_length=30, null=True, blank=True)
    last_name = models.CharField(_(u'Фамилия'), max_length=30, null=True, blank=True)

    """
    Manufacturer fields
    """
    TYPE = (
        ('1', u"ИП"),
        ('2', u"ООО"),
        ('3', u"Физическое лицо"),
    )

    company_name = models.CharField(_(u'Название организации'), max_length=50, null=True, blank=True)
    company_type = models.CharField(_(u'Тип организации'), max_length=1, null=True, blank=True, choices=TYPE)
    company_logotype = models.ImageField(_(u'Логотип организации'), null=True, blank=True)

    """
    System fields
    """
    ACTIVATED = u"ALREADY_ACTIVATED"
    RESETED = u"ALREADY_RESETED"
    activation_key = models.CharField(_(u'Ключ активании'), max_length=40)
    reset_password_key = models.CharField(_(u'Ключ сброса пароля'), max_length=40, null=True)
    date_joined = models.DateTimeField(_(u'Дата регистрации'), default=timezone.now)
    is_active = models.BooleanField(_(u'Активный'), default=False)
    is_customer = models.BooleanField(_(u'Покупатель'), default=False)
    is_manufacturer = models.BooleanField(_(u'Продавец'), default=False)

    USERNAME_FIELD = 'email'

    REQUIRED_FIELDS = ['first_name', 'last_name', 'phone']

    objects = CustomUserManager()

    class Meta:
        verbose_name = _(u'Пользователь')
        verbose_name_plural = _(u'Пользователи')
        abstract = True

    def make_key(self):
        salt = hashlib.sha1(six.text_type(random.random())
                            .encode('ascii')).hexdigest()[:5]
        salt = salt.encode('ascii')
        user_pk = str(self.pk)
        if isinstance(user_pk, six.text_type):
            user_pk = user_pk.encode('utf-8')
        return hashlib.sha1(salt+user_pk).hexdigest()

    def make_activation_key(self):
        self.activation_key = self.make_key()
        self.save()

    def make_reset_password_key(self):
        self.reset_password_key = self.make_key()
        self.save()

    def activation_key_expired(self):
        expiration_date = datetime.timedelta(days=settings.ACCOUNT_ACTIVATION_DAYS)
        return (self.activation_key == self.ACTIVATED or
                (self.date_joined + expiration_date <= timezone.now()))

    def send_activation_email(self, password=None):
        ctx = {
            'activation_key': self.activation_key,
            'expiration_days': settings.ACCOUNT_ACTIVATION_DAYS
        }

        if password is not None:
            ctx.update({'login': self.email, 'password': password})

        subject = _(u'Активация аккаунта в BakeStreet')
        message_txt = render_to_string('profiles/activation_email.txt', ctx)
        message_html = render_to_string('profiles/activation_email.html', ctx)
        self.send_email(subject, message_txt, message_html)

    def send_reset_password_email(self):
        ctx = {
            'login': self.email,
            'reset_password_key': self.reset_password_key,
        }

        subject = u'Сброс пароля в BakeStreet'
        message_txt = render_to_string('profiles/reset_password_email.txt', ctx)
        message_html = render_to_string('profiles/reset_password_email.html', ctx)
        self.send_email(subject, message_txt, message_html)

    def send_email(self, subject, message_txt, message_html):
        email_message = EmailMultiAlternatives(subject, message_txt,
                                               settings.EMAIL_HOST_USER, [self.email])
        email_message.attach_alternative(message_html, 'text/html')
        email_message.send()

    def make_password_reseted(self):
        self.reset_password_key = self.RESETED

    def get_full_name(self):
        return u'{} {}'.format(self.last_name, self.first_name)

    def get_short_name(self):
        return self.first_name

    @property
    def address(self):
        if self.city and self.street and self.house and self.flat:
            return u'{}, {}, {}, {}'.format(self.city, self.street, self.house, self.flat)
        elif self.city and self.street and self.house:
            return u'{}, {}, {}'.format(self.city, self.street, self.house)
        return u''

    @property
    def percent_likes(self):
        if self.votes > 0:
            return u'{0:.0%}'.format(self.likes/self.votes)
        return u'{0:.0%}'.format(0)

    @property
    def percent_dislikes(self):
        if self.votes > 0:
            return u'{0:.0%}'.format(self.dislikes/self.votes)
        return u'{0:.0%}'.format(0)

    @property
    def is_staff(self):
        return self.is_superuser

    @property
    def is_activated(self):
        return self.activation_key == self.ACTIVATED

    def __str__(self):
        return self.email


class User(AbstractCustomUser):
    class Meta(AbstractCustomUser.Meta):
        swappable = "AUTH_USER_MODEL"



ФОРМЫ
# -*- coding: utf-8 -*-

# Core
from django import forms

# Project
from .models import User


class CustomerForm(forms.ModelForm):
    class Meta:
        model = User
        fields = ['email', 'first_name', 'last_name', 'phone',
                  'city', 'street', 'house', 'flat']

    def __init__(self, *args, **kwargs):
        super(CustomerForm, self).__init__(*args, **kwargs)
        self.fields['first_name'].required = True
        self.fields['last_name'].required = True


class ManufacturerForm(forms.ModelForm):
    class Meta:
        model = User
        fields = ['company_name', 'company_type', 'company_logotype', 'phone',
                  'city', 'street', 'house', 'note', 'email']

    def __init__(self, *args, **kwargs):
        super(ManufacturerForm, self).__init__(*args, **kwargs)
        self.fields['company_name'].required = True
        self.fields['company_type'].required = True
        self.fields['company_logotype'].required = True



ВЬЮХИ
# -*- coding: utf-8 -*-

# Core
from django.contrib.auth.forms import AuthenticationForm, PasswordChangeForm, PasswordResetForm, SetPasswordForm
from django.views.generic import CreateView, UpdateView, FormView, View, DetailView
from django.shortcuts import redirect, render, get_object_or_404, Http404
from django.contrib.auth import login, logout, update_session_auth_hash
from django.contrib.auth.decorators import login_required
from django.utils.translation import ugettext as _
from django.core.urlresolvers import reverse_lazy
from django.contrib import messages
import re

# Project
from .forms import CustomerForm, ManufacturerForm
from utils.paginator import get_page_object
from categories.models import Category
from products.models import Product
from .models import User

# Django-braces
from braces.views import JSONResponseMixin, AjaxResponseMixin, LoginRequiredMixin


def activation_view(request, activation_key):
    activated_user = User.objects.activate_user(activation_key)
    if activated_user:
        if activated_user.is_manufacturer:
            messages.success(request, _(u'Ваша аккаунт подтвержден!'
                                        u'Ожидайте подтвержения администрацией сайта'))
        else:
            messages.success(request, _(u'Ваш аккаунт активирован!'))
        return redirect('signin')
    else:
        raise Http404


class SignInView(FormView):
    form_class = AuthenticationForm
    template_name = 'profiles/signin_form.html'
    success_url = 'index'

    def dispatch(self, *args, **kwargs):
        if self.request.user.is_authenticated():
            return redirect('index')
        return super(SignInView, self).dispatch(*args, **kwargs)

    def form_valid(self, form):
        next_url = self.request.GET.get('next', None)
        print(next_url)
        if next_url is not None:
            self.success_url = next_url
        user = form.get_user()
        login(self.request, user)
        return redirect(self.success_url)


class SignInAjaxView(JSONResponseMixin, AjaxResponseMixin, View):
    def post_ajax(self, request, *args, **kwargs):
        form = AuthenticationForm(data=request.POST)
        if form.is_valid():
            user = form.get_user()
            login(self.request, user)
            return self.render_json_response({}, status=200)
        else:
            return self.render_json_response({'msg': _(u'Неправильный email или пароль')}, status=400)


def signout(request):
    logout(request)
    response = redirect('index')
    """
    response.delete_cookie('cart_count')
    response.delete_cookie('cart_total')
    """
    return response


class ChangePasswordView(LoginRequiredMixin, View):
    form_class = PasswordChangeForm
    success_url = 'profiles:profile'
    login_url = 'signin'
    template_name = 'profiles/password_change_form.html'

    def get(self, request):
        form = self.form_class(user=request.user)
        return render(request, self.template_name, {'form': form})

    def post(self, request):
        form = self.form_class(user=request.user, data=request.POST)
        if form.is_valid():
            form.save()
            update_session_auth_hash(request, form.user)
            messages.success(request, _(u'Ваш пароль изменен!'))
            return redirect(self.success_url)
        return render(request, self.template_name, {'form': form})


class ResetPasswordView(FormView):
    form_class = PasswordResetForm
    success_url = 'index'
    template_name = 'profiles/password_reset_form.html'

    def form_valid(self, form):
        email = form.cleaned_data['email']
        User.objects.reset_password(email)
        messages.success(self.request, _(u'Инструкции по сбросу пароля отправлены на Вашу почту!'))
        return redirect(self.success_url)


class SetPasswordView(View):
    form_class = SetPasswordForm
    success_url = 'index'
    template_name = 'profiles/set_new_password_form.html'
    user = None

    def get(self, request, reset_key):
        self.user = get_object_or_404(User, reset_password_key=reset_key)
        form = self.form_class(user=self.user)
        return render(request, self.template_name, {'form': form})

    def post(self, request, reset_key):
        form = self.form_class(user=self.user, data=request.POST)
        if form.is_valid():
            user = form.save(commit=False)
            user.make_password_reseted()
            form.save()
        messages.success(request, _(u'Ваш пароль изменен!'))
        return redirect(self.success_url)

    def dispatch(self, *args, **kwargs):
        self.user = User.objects.check_reset_password_key(self.kwargs['reset_key'])
        if self.user:
            return super(SetPasswordView, self).dispatch(*args, **kwargs)
        raise Http404


class SignUpMixin(CreateView):
    success_url = 'index'
    success_message = _(u'Спасибо за регистрацию! '
                        u'Письмо с активацией аккаунта отправлено на ваш телефон')


class CustomerSignUpView(SignUpMixin):
    form_class = CustomerForm
    template_name = 'profiles/customer_signup_form.html'

    def form_valid(self, form):
        User.objects.create_customer(**form.cleaned_data)
        messages.success(self.request, self.success_message)
        return redirect(self.success_url)


class ManufacturerSignUpView(SignUpMixin):
    form_class = ManufacturerForm
    template_name = 'profiles/manufacturer_signup_form.html'

    def form_valid(self, form):
        User.objects.create_manufacturer(**form.cleaned_data)
        messages.success(self.request, self.success_message)
        return redirect(self.success_url)


@login_required(login_url='signin')
def profile_update(request):
    user = request.user
    if user.is_customer:
        return CustomerUpdateView.as_view()(request)
    if user.is_manufacturer:
        return ManufacturerUpdateView.as_view()(request)


class UpdateMixin(LoginRequiredMixin, UpdateView):
    login_url = 'signin'
    success_url = reverse_lazy('profiles:profile')
    success_message = _(u'Информация изменена!')

    def get_object(self, queryset=None):
        return self.request.user

    def form_valid(self, form):
        messages.success(self.request, self.success_message)
        return super(UpdateMixin, self).form_valid(form)


class CustomerUpdateView(UpdateMixin):
    form_class = CustomerForm
    template_name = 'profiles/customer_update_form.html'


class ManufacturerUpdateView(UpdateMixin):
    form_class = ManufacturerForm
    template_name = 'profiles/manufacturer_update_form.html'


@login_required(login_url='signin')
def profile_view(request):
    user = request.user
    if user.is_customer:
        return CustomerView.as_view()(request)
    if user.is_manufacturer:
        return ManufacturerView.as_view()(request)


class DetailMixin(LoginRequiredMixin, DetailView):
    model = User
    login_url = 'signin'

    def get_object(self, queryset=None):
        return self.request.user


class CustomerView(DetailMixin):
    context_object_name = 'customer'
    template_name = 'profiles/customer_detail.html'


class ManufacturerView(DetailMixin):
    context_object_name = 'manufacturer'
    template_name = 'profiles/manufacturer_detail.html'


class ManufacturerDetailView(DetailView):
    model = User
    context_object_name = 'manufacturer'
    template_name = 'profiles/manufacturer_detail_for_customers.html'

    def get_object(self, queryset=None):
        manufacturer = get_object_or_404(User, pk=self.kwargs['pk'])
        if manufacturer.is_manufacturer and not manufacturer.is_superuser:
            return manufacturer
        raise Http404


def manufacturer_list_view(request):
    categories = Category.objects.all()
    manufacturers = User.objects.filter(is_manufacturer=True).filter(is_active=True).filter(is_superuser=False)
    param_categories = request.GET.getlist('category')
    url = request.build_absolute_uri()
    if param_categories:
        products = Product.objects.filter(category__eng_name__in=param_categories).filter(is_published=True)
        manufacturers = manufacturers.select_related().filter(product__in=products).distinct()
        url = re.sub(r"(&page=)(\d+)", '', url)
    manufacturers = get_page_object(request, manufacturers, 10)
    return render(request, 'manufacturers.html', {'url': url,
                                                  'params': param_categories,
                                                  'categories': categories,
                                                  'manufacturers': manufacturers})



МЕНЕДЖЕРЫ
# -*- coding: utf-8 -*-

# Core
from django.contrib.auth.models import BaseUserManager
from django.utils.translation import ugettext as _
from django.utils import timezone
import re


class CustomUserManager(BaseUserManager):
    use_in_migrations = True

    def _create_user(self, email, password=None, first_name=None,
                     last_name=None, company_name=None,
                     company_type=None, is_customer=False,
                     is_manufacturer=False, is_superuser=False,
                     is_active=False, send_email=True, **extra_fields):

        now = timezone.now()

        if not email:
            raise ValueError(_(u'Введите email!'))
        email = self.normalize_email(email)

        user = self.model(email=email, first_name=first_name,
                          last_name=last_name, company_name=company_name,
                          company_type=company_type, is_customer=is_customer,
                          is_manufacturer=is_manufacturer, is_superuser=is_superuser,
                          is_active=is_active, date_joined=now, **extra_fields)

        if password is None:
            password = self.make_random_password()

        user.set_password(password)
        user.save(using=self._db)

        user.make_activation_key()

        if is_superuser:
            user.activation_key = self.model.ACTIVATED
            user.save()

        if send_email:
            user.send_activation_email(password)

        return user

    def create_customer(self, email, first_name, last_name, **extra_fields):
        return self._create_user(email=email, first_name=first_name,
                                 last_name=last_name, is_customer=True,
                                 **extra_fields)

    def create_manufacturer(self, email, company_name, company_type, **extra_fields):
        return self._create_user(email=email, company_name=company_name,
                                 company_type=company_type, is_manufacturer=True,
                                 **extra_fields)

    def create_superuser(self, email, password, **extra_fields):
        return self._create_user(email=email, password=password, is_customer=True,
                                 is_manufacturer=True, is_superuser=True,
                                 is_active=True, send_email=False, **extra_fields)

    def activate_user(self, activation_key):
        SHA1_RE = re.compile('^[a-f0-9]{40}$')
        if SHA1_RE.search(activation_key):
            try:
                user = self.get(activation_key=activation_key)
            except self.model.DoesNotExist:
                return False
            if not user.activation_key_expired():
                if not user.is_manufacturer:
                    user.is_active = True
                user.activation_key = self.model.ACTIVATED
                user.save()
                return user
        return False

    def delete_expired_users(self):
        for user in self.all():
            if user.activation_key_expired():
                if not user.is_active:
                    user.delete()

    def reset_password(self, email):
        try:
            user = self.get(email=email)
        except self.model.DoesNotExist:
            return False
        user.make_reset_password_key()
        user.send_reset_password_email()
        return user

    def check_reset_password_key(self, reset_password_key):
        SHA1_RE = re.compile('^[a-f0-9]{40}$')
        if SHA1_RE.search(reset_password_key):
            try:
                user = self.get(reset_password_key=reset_password_key)
                return user
            except self.model.DoesNotExist:
                return False
        return False



УРЛЫ
# -*- coding: utf-8 -*-

# Core
from django.conf.urls import url

# Project
from .views import ChangePasswordView, ResetPasswordView, SetPasswordView, profile_update
from .views import SignInAjaxView, profile_view, activation_view
from portfolio.views import OwnerPortfolioListView
from products.views import OwnerProductListView
from reviews.views import ReviewsView

urlpatterns = [

    url(r'^$',
        profile_view,
        name='profile'),

    url(r'^ajaxsignin/$',
        SignInAjaxView.as_view(),
        name='ajax_signin'),

    url(r'^update/$',
        profile_update,
        name='update'),

    url(r'^rating/$',
        ReviewsView.as_view(),
        name='reviews'),

    url(r'^products/$',
        OwnerProductListView.as_view(),
        name='products'),

    url(r'^portfolio/$',
        OwnerPortfolioListView.as_view(),
        name='portfolio'),

    url(r'^activate/(?P<activation_key>\w+)/$',
        activation_view,
        name='activate'),

    url(r'^change_password/$',
        ChangePasswordView.as_view(),
        name='change_password'),

    url('^reset_password/$',
        ResetPasswordView.as_view(),
        name='reset_password'),

    url('^reset_password/(?P<reset_key>\w+)/$',
        SetPasswordView.as_view(),
        name='reset_password'),

]