proekton.com/users/views.py

from django.conf import settings
from django.contrib import messages
from django.contrib.auth.models import Group
from django.core.mail import send_mail
from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
from django.core.urlresolvers import reverse
from django.db.models import Q
from django.http import HttpResponse
from django.shortcuts import render, get_object_or_404, redirect
from django.views.generic import ListView, DetailView, View, UpdateView, CreateView
from pprint import pprint, pformat
import itertools
import natsort
import pydash as _; _.map = _.map_; _.filter = _.filter_

from .forms import UserEditForm, ContractorFilterForm, ContractorFinancicalInfoForm
from .mixins import CheckForUserMixin
from .models import User, Team, ContractorFinancialInfo
from archilance.mixins import BaseMixin
from common.utils import get_or_none
from projects.forms import PortfolioForm
from specializations.models import Specialization
from work_sell.forms import WorkSellForm


def send_mail_test(request):
    send_mail('Subject here', 'Here is the message.Mukhtar hello ', '', ['muhtarzubanchi05@gmail.com'], fail_silently=False)
    return HttpResponse("Mail send")


class UserListView(ListView):
    model = User
    template_name = 'users_list.html'
    context_object_name = 'users'


class ContractorFilterView(BaseMixin, View):
    template_name = 'contractor_filter.html'
    form_class = ContractorFilterForm
    
    def get(self, request, *args, **kwargs):
        form = self.form_class(request.GET, request=request)
        context = self.get_context_data(**_.merge({}, request.GET, kwargs))
        coll = []
        
        if form.is_valid():
            contractors = teams = None
            contr_count = team_count = None
            get_contractors = get_teams = None
            ord = None
            
            cro = form.cleaned_data.get('cro')
            specialization = form.cleaned_data.get('specialization')
            location = form.cleaned_data.get('location')
            work_type = form.cleaned_data.get('work_type')
            build_classif = form.cleaned_data.get('building_classification')
            constr_type = form.cleaned_data.get('construction_type')
            
            
            party_types = form.cleaned_data.get('party_types')
            last_party_types = form.cleaned_data.get('last_party_types')
            
            if party_types == 'all':
                get_contractors = get_teams = True
            elif party_types == 'contractors':
                get_contractors = True
            elif party_types == 'teams':
                get_teams = True
            elif not party_types:
                if last_party_types == 'contractors':
                    get_contractors = True
                elif last_party_types == 'teams':
                    get_teams = True
                else:
                    get_contractors = get_teams = True
            
            if party_types:
                last_party_types = party_types
            
            context.update({'last_party_types': last_party_types})
            
            
            
            if get_contractors:
                contractors = User.contractor_objects.filter(cro=cro)
                
                if specialization:
                    contractors = contractors.filter(
                        contractor_specializations__lft__gte=specialization.lft,
                        contractor_specializations__rght__lte=specialization.rght,
                    )
                
                if location:
                    contractors = contractors.filter(
                        location__lft__gte=location.lft,
                        location__rght__lte=location.rght,
                    )
                
                if work_type:
                    contractors = contractors.filter(orders__project__work_type=work_type)
                
                if build_classif:
                    contractors = contractors.filter(orders__project__realty__building_classification=build_classif)
                
                if constr_type:
                    contractors = contractors.filter(orders__project__realty__construction_type=constr_type)
            
            
            
            if get_teams:
                teams = Team.objects.filter(Q(users__cro=cro) | Q(owner__cro=cro))
                
                if specialization:
                    teams = teams.filter(
                        (
                            Q(users__contractor_specializations__lft__gte=specialization.lft)
                            & Q(users__contractor_specializations__rght__lte=specialization.rght)
                        ) | (
                            Q(owner__contractor_specializations__lft__gte=specialization.lft)
                            & Q(owner__contractor_specializations__rght__lte=specialization.rght)
                        ),
                    )
                
                if location:
                    teams = teams.filter(
                        (
                            Q(users__location__lft__gte=location.lft)
                            & Q(users__location__rght__lte=location.rght)
                        ) | (
                            Q(owner__location__lft__gte=location.lft)
                            & Q(owner__location__rght__lte=location.rght)
                        ),
                    )
                
                if work_type:
                    teams = teams.filter(
                        Q(users__orders__project__work_type=work_type)
                        | Q(owner__orders__project__work_type=work_type),
                    )
                
                if build_classif:
                    teams = teams.filter(
                        Q(users__orders__project__realty__building_classification=build_classif)
                        | Q(owner__orders__project__realty__building_classification=build_classif),
                    )
                
                if constr_type:
                    teams = teams.filter(
                        Q(users__orders__project__realty__construction_type=constr_type)
                        | Q(owner__orders__project__realty__construction_type=constr_type),
                    )
            
            if get_contractors and get_teams:
                coll = tuple(itertools.chain(contractors.distinct(), teams.distinct()))
                count = len(coll)
                display_msg = 'Найдено %s элементов' % count if count > 0 else 'Ничего не найдено'
            elif get_contractors:
                coll = contractors.distinct()
                count = coll.count()
                display_msg = 'Найдено %s исполнителей' % count if count > 0 else 'Ничего не найдено'
            elif get_teams:
                coll = teams.distinct()
                count = coll.count()
                display_msg = 'Найдено %s групп' % count if count > 0 else 'Ничего не найдено'
            
            
            order_by = form.cleaned_data.get('order_by')
            last_order_by = form.cleaned_data.get('last_order_by')
            reverse_order = form.cleaned_data.get('reverse_order')
            
            if order_by:
                reverse_order = not reverse_order if order_by == last_order_by else False
                ord = order_by
                last_order_by = ord
            elif last_order_by:
                ord = last_order_by
            
            if ord:
                if ord == 'name':
                    coll = natsort.natsorted(coll, key=lambda obj: getattr(obj, 'username', None) or obj.name, reverse=reverse_order)
                else:
                    coll = natsort.natsorted(coll, key=lambda obj: getattr(obj, ord), reverse=reverse_order)
            
            context.update({
                'last_order_by': last_order_by,
                'reverse_order': reverse_order,
            })
        else:
            display_msg = 'Пожалуйста, введите корректные данные'
            
            if form.errors:
                messages.info(request, (
                    '<p>Произошла ошибка (form)</p>'
                    '<pre>{form}</pre>'
                ).format(form=pformat(form.errors)))
        
        paginator = Paginator(coll, settings.PAGE_SIZE)
        page = request.GET.get('page')
        
        try:
            coll = paginator.page(page)
        except PageNotAnInteger:
            coll = paginator.page(1)
        except EmptyPage:
            coll = paginator.page(paginator.num_pages)
        
        context.update({
            'form': form,
            'coll': coll,
            'is_paginated': True,
            'page_obj': coll,
            'display_msg': display_msg,
        })
        
        return render(request, self.template_name, context)


class ContractorProfileDetailView(DetailView):
    model = User
    worksell_form_class = WorkSellForm
    portfolio_form_class = PortfolioForm
    template_name = 'contractor_profile.html'
    context_object_name = 'contractor'

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['worksell_form'] = self.worksell_form_class
        context['portfolio_form'] = self.portfolio_form_class
        context['resume_diploms'] = self.object.contractor_resume.resume_files.filter(type='diplom')
        context['resume_cro'] = self.object.contractor_resume.resume_files.filter(type='cro')
        return context


class ContractorOfficeDetailView(DetailView):
    model = User
    template_name = 'contractor_office.html'
    context_object_name = 'contractor'


class CustomerProfileOpenProjectsView(BaseMixin, DetailView):
    model = User
    template_name = 'customer_profile_open_projects.html'
    context_object_name = 'customer'
    
    def get_context_data(self, **kwargs):
        c = super().get_context_data(**kwargs)
        c['projects'] = self.object.projects.filter(state='active')
        return c


class CustomerProfileTrashedProjectsView(BaseMixin, DetailView):
    model = User
    template_name = 'customer_profile_trashed_projects.html'
    context_object_name = 'customer'
    
    def get_context_data(self, **kwargs):
        c = super().get_context_data(**kwargs)
        c['projects'] = self.object.projects.filter(state='trashed')
        return c


class CustomerProfileCurrentProjectsView(BaseMixin, DetailView):
    model = User
    template_name = 'customer_profile_current_projects.html'
    context_object_name = 'customer'


class CustomerProfileReviewsView(BaseMixin, DetailView):
    model = User
    template_name = 'customer_profile_reviews.html'
    context_object_name = 'customer'


class CustomerProfileEditView(CheckForUserMixin, View):
    form_class = UserEditForm
    template_name = 'customer_profile_edit.html'

    def get(self, request, *args, **kwargs):
        instance = get_object_or_404(User, pk=request.user.pk)
        form = self.form_class(instance=instance)
        nodes = Specialization.objects.all()
        return render(request, self.template_name, {'form': form, 'nodes': nodes})

    def post(self, request, *args, **kwargs):
        instance = request.user
        form = self.form_class(request.POST, request.FILES, instance=instance)
        if form.is_valid():
            # import code; code.interact(local=dict(globals(), **locals()))
            form.save()
            messages.info(request, 'Отправили post запрос')
            return redirect(reverse('users:customer-profile-open-projects', kwargs={'pk': request.user.pk}))
        return render(request, self.template_name, {'form': form})


class ContractorProfileEditView(CheckForUserMixin, View):
    form_class = UserEditForm
    template_name = 'contractor_profile_edit.html'

    def get(self, request, *args, **kwargs):
        instance = get_object_or_404(User, pk=request.user.pk)
        form = self.form_class(instance=instance)
        root = get_or_none(Specialization, name='_root')
        nodes = root.get_descendants('lft')

        return render(request, self.template_name, {'form': form, 'nodes': nodes})

    def post(self, request, *args, **kwargs):
        instance = request.user
        form = self.form_class(request.POST, request.FILES, instance=instance)
        if form.is_valid():
            # import code; code.interact(local=dict(globals(), **locals()))
            instance = form.save(commit=False)
            instance.save()
            messages.info(request, 'Данные успешно отредактированы')
            return redirect(reverse('users:contractor-edit', kwargs={'pk': request.user.pk}))

        return render(request, self.template_name, {'form': form})


class ContractorFinancialInfoEdit(CheckForUserMixin, View):
    template_name = 'contractor_financical_info_edit.html'
    form_class = ContractorFinancicalInfoForm

    def get(self, request, *args, **kwargs):
        instance = request.user.contractor_financial_info
        # import code; code.interact(local=dict(globals(), **locals()))
        form = self.form_class(instance=instance)
        return render(request, self.template_name, {'form': form})

    def post(self, request, *args, **kwargs):
        instance = request.user.contractor_financial_info
        form = self.form_class(request.POST, request.FILES, instance=instance)
        if form.is_valid():
            financical_instance = form.save()
            request.user.contractor_financial_info = financical_instance
            request.user.save()
            messages.info(request, 'Данные успешно отредактированы')
            return redirect(reverse('users:contractor-financical', kwargs={'pk': request.user.pk}))

        return render(request, self.template_name, {'form': form})


# import code; code.interact(local=dict(globals(), **locals()))