expomap/accounts/admin.py

# -*- coding: utf-8 -*-

import datetime
import json
import random
from datetime import date
from hashlib import md5

from company.models import Company
from django.conf import settings
from django.contrib.auth.decorators import login_required
from django.core.context_processors import csrf
from django.core.exceptions import ImproperlyConfigured
from django.http import HttpResponse, HttpResponseRedirect
from django.shortcuts import render_to_response
from django.utils import timezone
from django.utils.translation import ugettext as _
from django.views.generic import DeleteView, TemplateView, UpdateView
from django.views.generic.dates import DateMixin, MonthMixin, YearMixin
from forms import (
    ChangePasswordForm,
    EmailAnnouncementForm,
    UserCreationForm,
    UserFilterForm,
    UserForm
)
# custom views
from functions.admin_views import AdminListView, AdminView, paginate_results

# models and forms
from .models import User


class DeleteAccount(DeleteView):
    model = User
    success_url = '/admin/accounts/all/'


class UserListView(AdminListView):
    template_name = 'c_admin/accounts/user_list.html'
    form_class = UserFilterForm
    model = User

    def get_context_data(self, **kwargs):
        context = super(UserListView, self).get_context_data(**kwargs)
        qs = self.model.objects.all()
        result = paginate_results(qs, page=self.request.GET.get('page'))
        context['object_list'] = result
        return context


class EditUser(UpdateView):
    model = User
    form_class = UserForm
    success_url = '/admin/accounts/all'
    template_name = 'user_change.html'


def user_change(request, url):
    """
    Return form of user and post it on the server.
    If form is posted redirect on the page of all users.
    """
    try:
        user = User.objects.get(url=url)
    except User.DoesNotExist:
        try:
            user = User.objects.get(id=url)
        except User.DoesNotExist, User.MultipleObjectsReturned:
            return HttpResponseRedirect('/admin/accounts/all')

    except User.MultipleObjectsReturned:
        return HttpResponseRedirect('/admin/accounts/all')

    if request.POST:
        # bug with saving staff users(set is_staff to False)
        staff = user.is_staff

        form = UserForm(request.POST, request.FILES, instance=user)
        if form.is_valid():

            user = form.save()
            if staff:
                #
                user.is_staff = True
                user.save()
            return HttpResponseRedirect('/admin/accounts/all')
        else:
            if user.profile.city:
                form.fields['city'].widget.attrs['data-init-text'] = user.profile.city.name

    else:
        profile = user.profile
        data = {'country':profile.country_id, 'city': profile.city_id,
                'title': profile.title, 'descriptions': profile.descriptions,
                'keywords': profile.keywords, 'phone': profile.phone, 'web_page': profile.web_page,
                'about': profile.about, 'skype':profile.skype,'facebook':profile.facebook, 'linkedin':profile.linkedin,
                'twitter':profile.twitter, 'vk':profile.vk}

        form = UserForm(instance=user,initial=data)

        if user.profile.city:
            form.fields['city'].widget.attrs['data-init-text'] = user.profile.city.name

    context = {}
    context.update(csrf(request))

    context['form'] = form
    context['object'] = user

    return render_to_response('user_change.html', context)

def create_admin(request):
    if request.POST:
        form = UserCreationForm(request.POST)
        if form.is_valid():
            user = form.save(commit=False)
            user.is_admin = False
            user.save()
            return HttpResponseRedirect('/admin/accounts/all')

    else:
        form = UserCreationForm()

    args = {}
    args.update(csrf(request))
    args['form'] = form

    return render_to_response('create_admin.html', args)

def create_md5(request):
    if request.POST:
        form = UserCreationForm(request.POST)
        if form.is_valid():
            user = User()
            user.email = request.POST['email']
            user.first_name = request.POST['first_name']
            user.last_name = request.POST['last_name']
            user.password = md5(request.POST['password2']).hexdigest()
            user.is_admin = True
            user.save()

            return HttpResponseRedirect('/admin/accounts/all')

    else:
        form = UserCreationForm()

    args = {}
    args.update(csrf(request))
    args['form'] = form

    return render_to_response('create_admin.html', args)


def generatePassword():
    """
    generate random password from 8 symbols
    """
    SYMBOLS = [',', '.', '?', '!', '-', '+', '1', '2', '3', '4', '5', '6', '7', '8',
           '9', '0', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
           'm', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A',
           'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
           'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '#']
    PASSWORD_LENGTH = 8
    newPassword = []
    for i in range(PASSWORD_LENGTH):
        newPassword.append(SYMBOLS[random.randrange(0, len(SYMBOLS))])
    return ''.join(newPassword)


def reset_password_email(request):
    """
    generate random password
    set this password to user and send on email
    """
    if request.GET:
        user = User.objects.get(email=request.GET['email'])
        new_pass = generatePassword()
        user.email_user('Reset password', 'Your new password: "%s" '%new_pass, settings.DEFAULT_FROM_EMAIL, )
        user.set_password(u'%s'%new_pass)
        user.save()
        return HttpResponse('success')

    return HttpResponse('error')


@login_required
def change_password(request):
    """
    Change current user password if new password is valid
    """
    success = {'success': False}
    if request.POST:
        form = ChangePasswordForm(request.POST)
        if form.is_valid():
            user = request.user
            if(user.check_password(form.cleaned_data.get('old_password'))):
                #user.set_password(form.cleaned_data.get('new_password'))
                #user.save()
                success['success'] = True
                success['message'] = _(u'Пароль изменен')
                return HttpResponse(json.dumps(success), content_type='application/json')
            else:
                errors = {'errors': [_(u'Не правильный пароль')]}
                success.update(errors)
                return HttpResponse(json.dumps(success), content_type='application/json')
        else:
            errors = [err[0] for err in form.errors.values()]
            errors = {'errors': errors}
            success.update(errors)
            return HttpResponse(json.dumps(success), content_type='application/json')
    else:
        return HttpResponse(json.dumps(success), content_type='application/json')


class AccountsStatistic(TemplateView, YearMixin, MonthMixin, DateMixin):
    queryset = None
    model = User
    template_name = 'c_admin/accounts/user_stat.html'
    date_field = 'date_joined'

    def _get_prev_day(self, date=None):
        """Return previous day of the given date.
        """
        date = getattr(self, 'date', date)
        return date - datetime.timedelta(days=1)

    def _get_prev_year(self, date):
        """Return previous year of the given date.
        """
        return date.replace(year=date.year - 1, month=1, day=1)

    def _get_prev_month(self, date):
        """Return previous month of the given date.
        """
        if date.month == 1:
            return date.replace(year=date.year - 1, month=12, day=1)
        else:
            return date.replace(month=date.month - 1, day=1)

    def make_lookup_kwargs(self, since, until):
        date_field = self.get_date_field()
        lookup_kwargs = {
            '%s__gte' % date_field: since,
            '%s__lt' % date_field: until,
        }
        return lookup_kwargs

    def get_current_day_lookup(self):
        return self._make_single_date_lookup(self.date)

    def get_prev_day_lookup(self):
        return self._make_single_date_lookup(self._get_prev_day())

    def get_current_month_lookup(self):
        since = self._make_date_lookup_arg(self._get_current_month(self.date))
        until = self._make_date_lookup_arg(self._get_next_month(self.date))
        return self.make_lookup_kwargs(since, until)

    def get_prev_month_lookup(self):
        since = self._make_date_lookup_arg(self._get_prev_month(self.date))
        until = self._make_date_lookup_arg(self._get_current_month(self.date))
        return self.make_lookup_kwargs(since, until)

    def get_current_year_lookup(self):
        since = self._make_date_lookup_arg(self._get_current_year(self.date))
        until = self._make_date_lookup_arg(self._get_next_year(self.date))
        return self.make_lookup_kwargs(since, until)

    def get_prev_year_lookup(self):
        since = self._make_date_lookup_arg(self._get_prev_year(self.date))
        until = self._make_date_lookup_arg(self._get_current_year(self.date))
        return self.make_lookup_kwargs(since, until)

    def get_queryset(self):
        """
        Get the queryset to look an object up against. May not be called if
        `get_object` is overridden.
        """
        if self.queryset is None:
            if self.model:
                return self.model._default_manager.all()
            else:
                raise ImproperlyConfigured("%(cls)s is missing a queryset. Define "
                                           "%(cls)s.model, %(cls)s.queryset, or override "
                                           "%(cls)s.get_queryset()." % {
                                                'cls': self.__class__.__name__
                                        })
        return self.queryset._clone()

    def get_qs_count(self, lookup_kwargs):
        return self.queryset.filter(**lookup_kwargs).count()

    def get(self, request, *args, **kwargs):
        self.date = date.today()
        self.year = self.date.year
        self.month = self.date.month
        return super(AccountsStatistic, self).get(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        self.queryset = self.get_queryset()
        context = super(AccountsStatistic, self).get_context_data(**kwargs)
        context['accounts_overall'] = self.queryset.count()
        context['companies_overall'] = Company.objects.count()
        context['current_day'] = \
            self.get_qs_count(self.get_current_day_lookup())
        context['prev_day'] = \
            self.get_qs_count(self.get_prev_day_lookup())
        context['current_month'] = \
            self.get_qs_count(self.get_current_month_lookup())
        context['prev_month'] = \
            self.get_qs_count(self.get_prev_month_lookup())
        context['current_year'] = \
            self.get_qs_count(self.get_current_year_lookup())
        context['prev_year'] = \
            self.get_qs_count(self.get_prev_year_lookup())
        return context