codeboy/api.py

## api.py
import base64
import os
import coreapi
import coreschema
import re
import requests
from urllib.parse import urlencode

from django.contrib.auth.forms import PasswordResetForm
from django.contrib.auth.tokens import PasswordResetTokenGenerator
from django.contrib.sites.shortcuts import get_current_site
from django.core.files.base import ContentFile
from django.core.validators import EmailValidator
from django.db.models import Q
from django.shortcuts import render, get_object_or_404
from django.contrib.auth import authenticate, login
from django.template.loader import render_to_string
from django.urls import reverse
from django.utils.encoding import force_text, force_bytes
from django.utils.http import urlsafe_base64_encode
from django.utils.translation import ugettext_lazy as _

# Create your views here.
from rest_framework import permissions

from rest_framework import viewsets
from rest_framework import parsers
from rest_framework import mixins
from rest_framework.decorators import list_route, detail_route
from rest_framework.fields import SkipField
from rest_framework.filters import BaseFilterBackend
from rest_framework.generics import ListAPIView, CreateAPIView, GenericAPIView, \
    UpdateAPIView, RetrieveAPIView, RetrieveUpdateAPIView
from rest_framework.pagination import LimitOffsetPagination
from rest_framework.response import Response
from rest_framework import status
from rest_framework import serializers

from rest_framework.views import APIView

from urllib.parse import urlparse

from common import utils as common_utils
from common.vt_mail import mail_send

from . import models as core_models


class ExLimitOffsetPagination(LimitOffsetPagination):
    max_limit = 20
    default_limit = 10


def _paginate_cls(i_max_limit=20, i_default_limit=10):
    class _LimitOffsetPagination(LimitOffsetPagination):
        max_limit = i_max_limit
        default_limit = i_default_limit

    return _LimitOffsetPagination


class BaseFilter(BaseFilterBackend):
    action_map = {}

    def get_schema_fields(self, view):
        return self.action_map.get(view.action, [])


class MeasureViewSet(viewsets.ReadOnlyModelViewSet):
    """
    Measure - единица измерения
    """
    permission_classes = [permissions.IsAuthenticated]
    pagination_class = _paginate_cls(1000, 1000)

    def get_queryset(self):
        return core_models.Measure.objects.all()

    def get_serializer_class(self):
        class _Serializer(serializers.ModelSerializer):
            class Meta:
                model = core_models.Measure
                fields = ['id', 'full_title', 'short_title']
        return _Serializer


class MaterialViewSet(viewsets.ReadOnlyModelViewSet):
    """
    Material - Материалы
    """
    permission_classes = [permissions.IsAuthenticated]
    pagination_class = _paginate_cls(1000, 1000)

    def get_queryset(self):
        return core_models.Material.objects.all()

    def get_serializer_class(self):
        class _Serializer(serializers.ModelSerializer):
            class Meta:
                model = core_models.Material
                fields = ['id', 'title']
        return _Serializer


class BuildingObjectViewSet(viewsets.ModelViewSet):
    """
    BuildingObject - строительный объект
    """
    permission_classes = [permissions.IsAuthenticated]
    pagination_class = ExLimitOffsetPagination

    def get_queryset(self):
        # return core_models.BuildingObject.objects.filter(user=self.request.user)
        return core_models.BuildingObject.objects.all()

    def get_serializer_class(self):
        class _Serializer(serializers.ModelSerializer):
            class Meta:
                model = core_models.BuildingObject
                # exclude = ['user', 'order', 'created_at', 'updated_at', 'state']
                fields = ['id', 'name', 'user']
        return _Serializer


class ConstructionObjectViewSet(viewsets.ModelViewSet):
    """
    ConstructionObject - Наименование конструкции
    """
    permission_classes = [permissions.IsAuthenticated]
    pagination_class = ExLimitOffsetPagination

    def get_queryset(self):
        return core_models.ConstructionObject.objects.all()

    def get_serializer_class(self):
        class _Serializer(serializers.ModelSerializer):
            class Meta:
                model = core_models.ConstructionObject
                fields = ['id', 'building_object', 'title']
        return _Serializer


class ObjectWorkViewSet(viewsets.ModelViewSet):
    """
    ObjectWork - работы на объекте
    """
    permission_classes = [permissions.IsAuthenticated]
    pagination_class = ExLimitOffsetPagination

    def get_queryset(self):
        return core_models.ObjectWork.objects.all()

    def get_serializer_class(self):
        class _Serializer(serializers.ModelSerializer):
            class Meta:
                model = core_models.ObjectWork
                fields = ['id', 'name', 'status']
        return _Serializer


class WorkMaterialViewSet(viewsets.ModelViewSet):
    """
    WorkMaterial - материалы для работ
    """
    permission_classes = [permissions.IsAuthenticated]
    pagination_class = ExLimitOffsetPagination

    def get_queryset(self):
        return core_models.WorkMaterial.objects.all()

    def get_serializer_class(self):
        class _Serializer(serializers.ModelSerializer):
            class Meta:
                model = core_models.WorkMaterial
                fields = ['id', 'work', 'material', 'planed_value']
        return _Serializer


class ProducedWorkViewSet(viewsets.ModelViewSet):
    """
    WorkMaterial - материалы для работ
    """
    permission_classes = [permissions.IsAuthenticated]
    pagination_class = ExLimitOffsetPagination

    def get_queryset(self):
        return core_models.ProducedWork.objects.all()

    def get_serializer_class(self):
        class _Serializer(serializers.ModelSerializer):
            class Meta:
                model = core_models.ProducedWork
                fields = ['id', 'work', 'done_at', 'material', 'value']
        return _Serializer


from thirdparty.cutstock.cuttingstock.GreedySolver import *
#todo: rework response for statuses and content
class CutCalculateViewSet(viewsets.GenericViewSet):
    permission_classes = [permissions.IsAuthenticated]

    def get_serializer_class(self):
        class _Serializer(serializers.Serializer):
            cut_pieces = serializers.ListField(help_text='list like - [1,2,3]')
            cut_length = serializers.IntegerField()
        return _Serializer

    @list_route(['post'])
    def cut_log(self, request, *args, **kwargs):
        r_status = 'ok'

        # print(request.data)
        srz = self.get_serializer(data=request.data)
        # srz.is_valid(raise_exception=True)
        srz_valid = srz.is_valid()

        cut_pieces = request.data.get('cut_pieces', False)
        cut_length = request.data.get('cut_length', False)

        if srz_valid and cut_pieces and cut_length:
            result, count_logs = self._calculate(cut_pieces, cut_length)
            r_content = {
                'cut_pieces':cut_pieces,
                'cut_length':cut_length,
                'result': result,
                'count_logs': count_logs
            }

        else:
            r_status = 'error'
            r_content = srz.errors

        r_data = {'status': r_status, 'content': r_content}
        return Response(r_data)

    # todo: add type checking for integer
    def _calculate(self, cut_pieces, cut_length):
        cut_input = dict()
        # перебираем кусочки в словаре и создаём другой для расчётов
        for piece in cut_pieces:
            quantity = int(piece['quantity'])
            size = int(piece['size'])

            if not cut_input.get(size, False): # проверка на уже существующий элемент todo: rework in frontend
                if quantity >= 1 and size >= 1: # не ноль
                    cut_input[size] = quantity

        cut_length = int(cut_length)
        a = GreedySolver(cut_input, cut_length)

        cutPatterns = a.getResult()
        count_logs = len(cutPatterns)

        new_cut = list()
        new_count = dict()
        for combination in cutPatterns:
            comb = combination.size_qty
            if comb in new_cut:
                new_count[new_cut.index(comb)]['count'] += 1
            else:
                new_cut.append(comb)
                new_count[new_cut.index(comb)] = {
                    'count': 1,
                    'waste': cut_length - combination.getCombinationSize(),
                    'combination':combination.printCombi()
                }

        final_cut = list()
        for k,v in new_count.items():
            final_cut.append({
                'combination': new_cut[k],
                'combination_clean': v['combination'],
                'count': v['count'],
                'waste': v['waste']
            })
        return final_cut, count_logs


###################################################################
class Base64FileField(serializers.FileField):
    def to_internal_value(self, data):
        if isinstance(data, str) and 'base64' in data[0:100]:
            # base64 encoded image - decode
            # our custom format file:1.jpg;data:
            format, filestr = data.split(
                ';base64,')  # format ~= file:;Mime type;encoding, b64code
            filename = format.split(';')[0].split(':')[-1]  # guess file name

            data = ContentFile(base64.b64decode(filestr), name=filename)

        return super(Base64FileField, self).to_internal_value(data)


class Base64ImageField(serializers.ImageField):
    def to_internal_value(self, data):
        if isinstance(data, str) and data.startswith('data:image'):
            # base64 encoded image - decode
            format, imgstr = data.split(';base64,')  # format ~= data:image/X,
            ext = format.split('/')[-1]  # guess file extension

            data = ContentFile(base64.b64decode(imgstr), name='temp.' + ext)

        return super(Base64ImageField, self).to_internal_value(data)


class ExCharField(serializers.CharField):
    def get_attribute(self, instance):
        raise SkipField()


class ExEmailField(serializers.EmailField):
    def get_attribute(self, instance):
        raise SkipField()


class ExBooleanField(serializers.BooleanField):
    def get_attribute(self, instance):
        raise SkipField()


class BaseDictViewSet(viewsets.ReadOnlyModelViewSet):
    class BaseDictBackend(BaseFilter):
        action_map = {
            'list': [
                coreapi.Field(
                    name='term',
                    location='path',
                    required=False,
                    type='string'
                )
            ]
        }

        def filter_queryset(self, request, queryset, view):
            term = request.query_params.get('term')
            if term:
                return queryset.filter(title__icontains=term)
            return queryset

    permission_classes = [permissions.AllowAny]
    pagination_class = _paginate_cls(1000, 1000)
    filter_backends = [BaseDictBackend]

    def get_serializer_class(self):
        self_model = self.queryset.model

        class _Serializer(serializers.ModelSerializer):
            class Meta:
                fields = ['id', 'title']
                model = self_model

        return _Serializer


class UserCreateAPIView(CreateAPIView):
    permission_classes = [permissions.AllowAny]

    def get_serializer_class(self):
        request = self.request

        class _Serializer(serializers.ModelSerializer):
            password = ExCharField()
            password_repeat = ExCharField()
            sms = ExCharField()
            is_agreement = ExBooleanField()

            def validate(self, attrs):
                if core_models.User.objects.filter(email=attrs['email']):
                    raise serializers.ValidationError(
                        {'email': [_('User with same email exists')]})

                if core_models.User.objects.filter(phone=attrs['phone']):
                    raise serializers.ValidationError(
                        {'phone': [_('User with same phone exists')]})

                if attrs['password'] != attrs['password_repeat']:
                    raise serializers.ValidationError({
                        'password': [_('Passwords not equal')],
                        'password_repeat': [_('Passwords not equal')]
                    })

                if attrs['sms'] != request.session.get('sms'):
                    raise serializers.ValidationError({
                        'sms': [_('Wrong sms')]
                    })


                return attrs

            def create(self, validated_data):
                user = core_models.User.objects.create(
                    email=validated_data['email'],
                    first_name=validated_data['first_name'],
                    last_name=validated_data['last_name'],
                    phone=validated_data['phone']
                )

                user.set_password(validated_data['password'])
                user.save()

                user_auth = authenticate(
                    username=user.email,
                    password=validated_data['password'],
                )

                login(request, user_auth)
                return user

            class Meta:
                model = core_models.User
                fields = ['first_name',
                          'last_name',
                          'middle_name',
                          'is_agreement',
                          'sms',
                          'email',
                          'phone',
                          'password',
                          'password_repeat']
                write_only_fields = ['password', 'password_repeat']
                read_only_fields = ['id']

        return _Serializer


class ProfileUpdateAPIView(RetrieveUpdateAPIView):
    # class UserUpdateAPIView(RetrieveAPIView):
    permission_classes = [permissions.IsAuthenticated]
    pagination_class = None

    def get_object(self):
        return self.request.user

    #
    # def get_queryset(self):
    #     return core_models.User.objects.filter(pk=self.request.user.pk)

    def get_serializer_class(self):
        data = self.request.data
        required = {'required': True, 'allow_blank': False}
        ekw = {'first_name': required, 'last_name': required}
        user = self.request.user

        if data and data['is_breeder']:
            for field_name in ['address', 'office', 'education']:
                ekw[field_name] = required

            ekw['language'] = {'required': True, 'allow_null': False}
            ekw['country'] = {'required': True, 'allow_null': False}
            ekw['birth'] = {'required': True, 'allow_null': False}

        if self.request.method == 'PUT' and data.get('image') and data[
            'image'].startswith('http') and user.image:
            data['image'] = user.image

        class _Serializer(serializers.ModelSerializer):
            image = Base64ImageField(allow_null=True)
            parser_classes = [parsers.FormParser, parsers.MultiPartParser]

            class Meta:
                model = core_models.User
                fields = ['first_name', 'last_name', 'middle_name',
                          'image',
                          'country', 'city', 'address', 'office', 'birth',
                          'about', 'language', 'education', 'course', 'link']
                extra_kwargs = ekw

        return _Serializer


class LoginAPIView(APIView):
    permission_classes = [permissions.AllowAny]

    class _Serializer(serializers.Serializer):
        username = serializers.CharField()
        password = serializers.CharField()

        def validate(self, attrs):
            user = core_models.User.objects.filter(Q(email=attrs['username'])
                                                   | Q(
                phone=attrs['username'])).first()
            err = {
                'username': [_('wrong password or email or phone')],
                'password': [_('wrong password or email or phone')]
            }

            if not user:
                raise serializers.ValidationError(err)

            user_auth = authenticate(
                username=user.email,
                password=attrs['password'],
            )

            if not user_auth:
                raise serializers.ValidationError(err)

            attrs['user_auth'] = user_auth
            return attrs

    def post(self, request, *args, **kwargs):
        serializer = LoginAPIView._Serializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        validated_data = serializer.validated_data
        login(request, validated_data['user_auth'])

        return Response({'success': True})


class AuthManagerViewSet(viewsets.GenericViewSet):
    # filter_backends = [PetViewSetBackend]
    email_template_name = 'apps/activation/mails/password_reset.j2',

    permission_classes = [permissions.AllowAny]

    # def _msg_email_get(self, request, **kwargs):
    #     from django.utils.http import urlsafe_base64_encode
    #     from django.contrib.auth.tokens import PasswordResetTokenGenerator
    #     from django.conf import settings
    #
    #     current_site = get_current_site(request)
    #     site_name = current_site.name
    #     domain = current_site.domain
    #     context = {                'domain': domain,
    #             'site_name': site_name,
    #             'uid': urlsafe_base64_encode(force_bytes(self.user.pk)),
    #             'user': self.user,
    #             'token': PasswordResetTokenGenerator().make_token(self.user),
    #             'protocol': 'https' if kwargs.get('use_https') else 'http'}
    #     return render_to_string(self.email_template_name, context)
    #
    # def _email_send(self, request):
    #     from django.core.mail import EmailMultiAlternatives
    #     email_message = EmailMultiAlternatives(_('password recovery'),
    #     self._msg_email_get(request), getattr(settings, 'DEFAULT_FROM_EMAIL'), [self.user.email])
    #         html_email = loader.render_to_string(html_email_template_name, context)
    #         email_message.attach_alternative(html_email, 'text/html')
    #
    #     email_message.send()


    def get_serializer_class(self):
        if self.action == 'reset_password':
            class _Serializer(serializers.Serializer):
                username = serializers.CharField()

                def validate(self, attrs):
                    self.is_phone = False
                    # EmailValidator(message=self.error_messages['invalid'])
                    # +7950 0376541 (11)
                    username = attrs['username'].strip('+')
                    if '@' in username:
                        try:
                            EmailValidator(message=_('invalid email'))(username)
                            self.user = core_models.User.objects.get(
                                email=username)
                        except Exception as e:
                            raise serializers.ValidationError(
                                {'username': [_('invalid email')]})
                            # if not core_models.User.objects.filter()

                    else:
                        self.is_phone = True
                        try:
                            re.match('\d{11}', username).group(0)
                            self.user = core_models.User.objects.get(
                                phone=username)
                        except Exception as e:
                            raise serializers.ValidationError(
                                {'username': [_('invalid phone')]})

                    return attrs

            return _Serializer
        return None

    @list_route(['post'])
    def reset_password(self, request, *args, **kwargs):
        srz = self.get_serializer(data=request.data)
        srz.is_valid(raise_exception=True)

        if srz.is_phone:
            # TODO: maybe add phone rcovery
            pass

        site = get_current_site(request)
        token = PasswordResetTokenGenerator().make_token(srz.user)

        url = 'http://{}{}'.format(site.domain,
            reverse('activation:password_reset_confirm',
                kwargs={'uidb64': urlsafe_base64_encode(
                    force_bytes(srz.user.pk)), 'token': token}))

        html = render_to_string(self.email_template_name, {
            'user': srz.user,
            'url': url,
            'site': site
        })
        try:
            mail_send(srz.user.email, message_html=html,
                subject=_('password reset'))
            return Response({'success': True, 'email': srz.user.email})
        except Exception as e:
            return Response({'success': False, 'error': str(e)})

        return Response({'hello': 'world'})


class CountryViewSet(BaseDictViewSet):
    queryset = core_models.Country.objects.all()


class CityViewSet(viewsets.ReadOnlyModelViewSet):
    queryset = core_models.City.objects.all()
    permission_classes = [permissions.AllowAny]
    pagination_class = _paginate_cls(1000, 1000)

    def get_serializer_class(self):
        self_model = self.queryset.model

        class _Serializer(serializers.ModelSerializer):
            class Meta:
                fields = ['id', 'title']
                model = self_model

        return _Serializer

    class CityDictBackend(BaseFilter):
        action_map = {
            'list': [
                coreapi.Field(
                    name='term',
                    location='path',
                    required=False,
                    type='string'
                ),
                coreapi.Field(
                    name='country_id',
                    location='path',
                    required=False,
                    type='string'
                )
            ],

        }

        def filter_queryset(self, request, queryset, view):
            term = request.query_params.get('term')
            country_id = request.query_params.get('country_id')

            if term:
                queryset = queryset.filter(title__icontains=term)

            if country_id:
                queryset = queryset.filter(country_id=country_id)

            return queryset

    filter_backends = [CityDictBackend]

    @list_route(['post'])
    def city_set(self, request, *args, **kwargs):
        city = get_object_or_404(core_models.City,
                                 pk=request.data.get('city_id'))
        if request.user.is_authenticated():
            request.user.city = city
            request.user.country_id = city.country_id
            request.user.save()
        else:
            request.session['current_city_id'] = city.pk

        return Response({'city': city.title, 'country': city.country.title})


class LanguageViewSet(BaseDictViewSet):
    queryset = core_models.Language.objects.all()
	import base64
	import os
	import coreapi
	import coreschema
	import re
	import requests
	from urllib.parse import urlencode

	from django.contrib.auth.forms import PasswordResetForm
	from django.contrib.auth.tokens import PasswordResetTokenGenerator
	from django.contrib.sites.shortcuts import get_current_site
	from django.core.files.base import ContentFile
	from django.core.validators import EmailValidator
	from django.db.models import Q
	from django.shortcuts import render, get_object_or_404
	from django.contrib.auth import authenticate, login
	from django.template.loader import render_to_string
	from django.urls import reverse
	from django.utils.encoding import force_text, force_bytes
	from django.utils.http import urlsafe_base64_encode
	from django.utils.translation import ugettext_lazy as _

	# Create your views here.
	from rest_framework import permissions

	from rest_framework import viewsets
	from rest_framework import parsers
	from rest_framework import mixins
	from rest_framework.decorators import list_route, detail_route
	from rest_framework.fields import SkipField
	from rest_framework.filters import BaseFilterBackend
	from rest_framework.generics import ListAPIView, CreateAPIView, GenericAPIView, \
	UpdateAPIView, RetrieveAPIView, RetrieveUpdateAPIView
	from rest_framework.pagination import LimitOffsetPagination
	from rest_framework.response import Response
	from rest_framework import status
	from rest_framework import serializers

	from rest_framework.views import APIView

	from urllib.parse import urlparse

	from common import utils as common_utils
	from common.vt_mail import mail_send

	from . import models as core_models


	class ExLimitOffsetPagination(LimitOffsetPagination):
	max_limit = 20
	default_limit = 10


	def _paginate_cls(i_max_limit=20, i_default_limit=10):
	class _LimitOffsetPagination(LimitOffsetPagination):
	max_limit = i_max_limit
	default_limit = i_default_limit

	return _LimitOffsetPagination


	class BaseFilter(BaseFilterBackend):
	action_map = {}

	def get_schema_fields(self, view):
	return self.action_map.get(view.action, [])


	class MeasureViewSet(viewsets.ReadOnlyModelViewSet):
	"""
	Measure - единица измерения
	"""
	permission_classes = [permissions.IsAuthenticated]
	pagination_class = _paginate_cls(1000, 1000)

	def get_queryset(self):
	return core_models.Measure.objects.all()

	def get_serializer_class(self):
	class _Serializer(serializers.ModelSerializer):
	class Meta:
	model = core_models.Measure
	fields = ['id', 'full_title', 'short_title']
	return _Serializer


	class MaterialViewSet(viewsets.ReadOnlyModelViewSet):
	"""
	Material - Материалы
	"""
	permission_classes = [permissions.IsAuthenticated]
	pagination_class = _paginate_cls(1000, 1000)

	def get_queryset(self):
	return core_models.Material.objects.all()

	def get_serializer_class(self):
	class _Serializer(serializers.ModelSerializer):
	class Meta:
	model = core_models.Material
	fields = ['id', 'title']
	return _Serializer


	class BuildingObjectViewSet(viewsets.ModelViewSet):
	"""
	BuildingObject - строительный объект
	"""
	permission_classes = [permissions.IsAuthenticated]
	pagination_class = ExLimitOffsetPagination

	def get_queryset(self):
	# return core_models.BuildingObject.objects.filter(user=self.request.user)
	return core_models.BuildingObject.objects.all()

	def get_serializer_class(self):
	class _Serializer(serializers.ModelSerializer):
	class Meta:
	model = core_models.BuildingObject
	# exclude = ['user', 'order', 'created_at', 'updated_at', 'state']
	fields = ['id', 'name', 'user']
	return _Serializer


	class ConstructionObjectViewSet(viewsets.ModelViewSet):
	"""
	ConstructionObject - Наименование конструкции
	"""
	permission_classes = [permissions.IsAuthenticated]
	pagination_class = ExLimitOffsetPagination

	def get_queryset(self):
	return core_models.ConstructionObject.objects.all()

	def get_serializer_class(self):
	class _Serializer(serializers.ModelSerializer):
	class Meta:
	model = core_models.ConstructionObject
	fields = ['id', 'building_object', 'title']
	return _Serializer


	class ObjectWorkViewSet(viewsets.ModelViewSet):
	"""
	ObjectWork - работы на объекте
	"""
	permission_classes = [permissions.IsAuthenticated]
	pagination_class = ExLimitOffsetPagination

	def get_queryset(self):
	return core_models.ObjectWork.objects.all()

	def get_serializer_class(self):
	class _Serializer(serializers.ModelSerializer):
	class Meta:
	model = core_models.ObjectWork
	fields = ['id', 'name', 'status']
	return _Serializer


	class WorkMaterialViewSet(viewsets.ModelViewSet):
	"""
	WorkMaterial - материалы для работ
	"""
	permission_classes = [permissions.IsAuthenticated]
	pagination_class = ExLimitOffsetPagination

	def get_queryset(self):
	return core_models.WorkMaterial.objects.all()

	def get_serializer_class(self):
	class _Serializer(serializers.ModelSerializer):
	class Meta:
	model = core_models.WorkMaterial
	fields = ['id', 'work', 'material', 'planed_value']
	return _Serializer


	class ProducedWorkViewSet(viewsets.ModelViewSet):
	"""
	WorkMaterial - материалы для работ
	"""
	permission_classes = [permissions.IsAuthenticated]
	pagination_class = ExLimitOffsetPagination

	def get_queryset(self):
	return core_models.ProducedWork.objects.all()

	def get_serializer_class(self):
	class _Serializer(serializers.ModelSerializer):
	class Meta:
	model = core_models.ProducedWork
	fields = ['id', 'work', 'done_at', 'material', 'value']
	return _Serializer



	from thirdparty.cutstock.cuttingstock.GreedySolver import *
	#todo: rework response for statuses and content
	class CutCalculateViewSet(viewsets.GenericViewSet):
	permission_classes = [permissions.IsAuthenticated]

	def get_serializer_class(self):
	class _Serializer(serializers.Serializer):
	cut_pieces = serializers.ListField(help_text='list like - [1,2,3]')
	cut_length = serializers.IntegerField()
	return _Serializer

	@list_route(['post'])
	def cut_log(self, request, args, *kwargs):
	r_status = 'ok'

	# print(request.data)
	srz = self.get_serializer(data=request.data)
	# srz.is_valid(raise_exception=True)
	srz_valid = srz.is_valid()

	cut_pieces = request.data.get('cut_pieces', False)
	cut_length = request.data.get('cut_length', False)

	if srz_valid and cut_pieces and cut_length:
	result, count_logs = self._calculate(cut_pieces, cut_length)
	r_content = {
	'cut_pieces':cut_pieces,
	'cut_length':cut_length,
	'result': result,
	'count_logs': count_logs
	}

	else:
	r_status = 'error'
	r_content = srz.errors

	r_data = {'status': r_status, 'content': r_content}
	return Response(r_data)

	# todo: add type checking for integer
	def _calculate(self, cut_pieces, cut_length):
	cut_input = dict()
	# перебираем кусочки в словаре и создаём другой для расчётов
	for piece in cut_pieces:
	quantity = int(piece['quantity'])
	size = int(piece['size'])

	if not cut_input.get(size, False): # проверка на уже существующий элемент todo: rework in frontend
	if quantity >= 1 and size >= 1: # не ноль
	cut_input[size] = quantity

	cut_length = int(cut_length)
	a = GreedySolver(cut_input, cut_length)

	cutPatterns = a.getResult()
	count_logs = len(cutPatterns)

	new_cut = list()
	new_count = dict()
	for combination in cutPatterns:
	comb = combination.size_qty
	if comb in new_cut:
	new_count[new_cut.index(comb)]['count'] += 1
	else:
	new_cut.append(comb)
	new_count[new_cut.index(comb)] = {
	'count': 1,
	'waste': cut_length - combination.getCombinationSize(),
	'combination':combination.printCombi()
	}

	final_cut = list()
	for k,v in new_count.items():
	final_cut.append({
	'combination': new_cut[k],
	'combination_clean': v['combination'],
	'count': v['count'],
	'waste': v['waste']
	})
	return final_cut, count_logs



	###################################################################
	class Base64FileField(serializers.FileField):
	def to_internal_value(self, data):
	if isinstance(data, str) and 'base64' in data[0:100]:
	# base64 encoded image - decode
	# our custom format file:1.jpg;data:
	format, filestr = data.split(
	';base64,') # format ~= file:;Mime type;encoding, b64code
	filename = format.split(';')[0].split(':')[-1] # guess file name

	data = ContentFile(base64.b64decode(filestr), name=filename)

	return super(Base64FileField, self).to_internal_value(data)


	class Base64ImageField(serializers.ImageField):
	def to_internal_value(self, data):
	if isinstance(data, str) and data.startswith('data:image'):
	# base64 encoded image - decode
	format, imgstr = data.split(';base64,') # format ~= data:image/X,
	ext = format.split('/')[-1] # guess file extension

	data = ContentFile(base64.b64decode(imgstr), name='temp.' + ext)

	return super(Base64ImageField, self).to_internal_value(data)


	class ExCharField(serializers.CharField):
	def get_attribute(self, instance):
	raise SkipField()


	class ExEmailField(serializers.EmailField):
	def get_attribute(self, instance):
	raise SkipField()


	class ExBooleanField(serializers.BooleanField):
	def get_attribute(self, instance):
	raise SkipField()


	class BaseDictViewSet(viewsets.ReadOnlyModelViewSet):
	class BaseDictBackend(BaseFilter):
	action_map = {
	'list': [
	coreapi.Field(
	name='term',
	location='path',
	required=False,
	type='string'
	)
	]
	}

	def filter_queryset(self, request, queryset, view):
	term = request.query_params.get('term')
	if term:
	return queryset.filter(title__icontains=term)
	return queryset

	permission_classes = [permissions.AllowAny]
	pagination_class = _paginate_cls(1000, 1000)
	filter_backends = [BaseDictBackend]

	def get_serializer_class(self):
	self_model = self.queryset.model

	class _Serializer(serializers.ModelSerializer):
	class Meta:
	fields = ['id', 'title']
	model = self_model

	return _Serializer


	class UserCreateAPIView(CreateAPIView):
	permission_classes = [permissions.AllowAny]

	def get_serializer_class(self):
	request = self.request

	class _Serializer(serializers.ModelSerializer):
	password = ExCharField()
	password_repeat = ExCharField()
	sms = ExCharField()
	is_agreement = ExBooleanField()

	def validate(self, attrs):
	if core_models.User.objects.filter(email=attrs['email']):
	raise serializers.ValidationError(
	{'email': [_('User with same email exists')]})

	if core_models.User.objects.filter(phone=attrs['phone']):
	raise serializers.ValidationError(
	{'phone': [_('User with same phone exists')]})

	if attrs['password'] != attrs['password_repeat']:
	raise serializers.ValidationError({
	'password': [_('Passwords not equal')],
	'password_repeat': [_('Passwords not equal')]
	})

	if attrs['sms'] != request.session.get('sms'):
	raise serializers.ValidationError({
	'sms': [_('Wrong sms')]
	})


	return attrs

	def create(self, validated_data):
	user = core_models.User.objects.create(
	email=validated_data['email'],
	first_name=validated_data['first_name'],
	last_name=validated_data['last_name'],
	phone=validated_data['phone']
	)

	user.set_password(validated_data['password'])
	user.save()

	user_auth = authenticate(
	username=user.email,
	password=validated_data['password'],
	)

	login(request, user_auth)
	return user

	class Meta:
	model = core_models.User
	fields = ['first_name',
	'last_name',
	'middle_name',
	'is_agreement',
	'sms',
	'email',
	'phone',
	'password',
	'password_repeat']
	write_only_fields = ['password', 'password_repeat']
	read_only_fields = ['id']

	return _Serializer


	class ProfileUpdateAPIView(RetrieveUpdateAPIView):
	# class UserUpdateAPIView(RetrieveAPIView):
	permission_classes = [permissions.IsAuthenticated]
	pagination_class = None

	def get_object(self):
	return self.request.user

	#
	# def get_queryset(self):
	# return core_models.User.objects.filter(pk=self.request.user.pk)

	def get_serializer_class(self):
	data = self.request.data
	required = {'required': True, 'allow_blank': False}
	ekw = {'first_name': required, 'last_name': required}
	user = self.request.user

	if data and data['is_breeder']:
	for field_name in ['address', 'office', 'education']:
	ekw[field_name] = required

	ekw['language'] = {'required': True, 'allow_null': False}
	ekw['country'] = {'required': True, 'allow_null': False}
	ekw['birth'] = {'required': True, 'allow_null': False}

	if self.request.method == 'PUT' and data.get('image') and data[
	'image'].startswith('http') and user.image:
	data['image'] = user.image

	class _Serializer(serializers.ModelSerializer):
	image = Base64ImageField(allow_null=True)
	parser_classes = [parsers.FormParser, parsers.MultiPartParser]

	class Meta:
	model = core_models.User
	fields = ['first_name', 'last_name', 'middle_name',
	'image',
	'country', 'city', 'address', 'office', 'birth',
	'about', 'language', 'education', 'course', 'link']
	extra_kwargs = ekw

	return _Serializer


	class LoginAPIView(APIView):
	permission_classes = [permissions.AllowAny]

	class _Serializer(serializers.Serializer):
	username = serializers.CharField()
	password = serializers.CharField()

	def validate(self, attrs):
	user = core_models.User.objects.filter(Q(email=attrs['username'])
	\| Q(
	phone=attrs['username'])).first()
	err = {
	'username': [_('wrong password or email or phone')],
	'password': [_('wrong password or email or phone')]
	}

	if not user:
	raise serializers.ValidationError(err)

	user_auth = authenticate(
	username=user.email,
	password=attrs['password'],
	)

	if not user_auth:
	raise serializers.ValidationError(err)

	attrs['user_auth'] = user_auth
	return attrs

	def post(self, request, args, *kwargs):
	serializer = LoginAPIView._Serializer(data=request.data)
	serializer.is_valid(raise_exception=True)
	validated_data = serializer.validated_data
	login(request, validated_data['user_auth'])

	return Response({'success': True})


	class AuthManagerViewSet(viewsets.GenericViewSet):
	# filter_backends = [PetViewSetBackend]
	email_template_name = 'apps/activation/mails/password_reset.j2',

	permission_classes = [permissions.AllowAny]

	# def _msg_email_get(self, request, **kwargs):
	# from django.utils.http import urlsafe_base64_encode
	# from django.contrib.auth.tokens import PasswordResetTokenGenerator
	# from django.conf import settings
	#
	# current_site = get_current_site(request)
	# site_name = current_site.name
	# domain = current_site.domain
	# context = { 'domain': domain,
	# 'site_name': site_name,
	# 'uid': urlsafe_base64_encode(force_bytes(self.user.pk)),
	# 'user': self.user,
	# 'token': PasswordResetTokenGenerator().make_token(self.user),
	# 'protocol': 'https' if kwargs.get('use_https') else 'http'}
	# return render_to_string(self.email_template_name, context)
	#
	# def _email_send(self, request):
	# from django.core.mail import EmailMultiAlternatives
	# email_message = EmailMultiAlternatives(_('password recovery'),
	# self._msg_email_get(request), getattr(settings, 'DEFAULT_FROM_EMAIL'), [self.user.email])
	# html_email = loader.render_to_string(html_email_template_name, context)
	# email_message.attach_alternative(html_email, 'text/html')
	#
	# email_message.send()


	def get_serializer_class(self):
	if self.action == 'reset_password':
	class _Serializer(serializers.Serializer):
	username = serializers.CharField()

	def validate(self, attrs):
	self.is_phone = False
	# EmailValidator(message=self.error_messages['invalid'])
	# +7950 0376541 (11)
	username = attrs['username'].strip('+')
	if '@' in username:
	try:
	EmailValidator(message=_('invalid email'))(username)
	self.user = core_models.User.objects.get(
	email=username)
	except Exception as e:
	raise serializers.ValidationError(
	{'username': [_('invalid email')]})
	# if not core_models.User.objects.filter()

	else:
	self.is_phone = True
	try:
	re.match('\d{11}', username).group(0)
	self.user = core_models.User.objects.get(
	phone=username)
	except Exception as e:
	raise serializers.ValidationError(
	{'username': [_('invalid phone')]})

	return attrs

	return _Serializer
	return None

	@list_route(['post'])
	def reset_password(self, request, args, *kwargs):
	srz = self.get_serializer(data=request.data)
	srz.is_valid(raise_exception=True)

	if srz.is_phone:
	# TODO: maybe add phone rcovery
	pass

	site = get_current_site(request)
	token = PasswordResetTokenGenerator().make_token(srz.user)

	url = 'http://{}{}'.format(site.domain,
	reverse('activation:password_reset_confirm',
	kwargs={'uidb64': urlsafe_base64_encode(
	force_bytes(srz.user.pk)), 'token': token}))

	html = render_to_string(self.email_template_name, {
	'user': srz.user,
	'url': url,
	'site': site
	})
	try:
	mail_send(srz.user.email, message_html=html,
	subject=_('password reset'))
	return Response({'success': True, 'email': srz.user.email})
	except Exception as e:
	return Response({'success': False, 'error': str(e)})

	return Response({'hello': 'world'})


	class CountryViewSet(BaseDictViewSet):
	queryset = core_models.Country.objects.all()


	class CityViewSet(viewsets.ReadOnlyModelViewSet):
	queryset = core_models.City.objects.all()
	permission_classes = [permissions.AllowAny]
	pagination_class = _paginate_cls(1000, 1000)

	def get_serializer_class(self):
	self_model = self.queryset.model

	class _Serializer(serializers.ModelSerializer):
	class Meta:
	fields = ['id', 'title']
	model = self_model

	return _Serializer

	class CityDictBackend(BaseFilter):
	action_map = {
	'list': [
	coreapi.Field(
	name='term',
	location='path',
	required=False,
	type='string'
	),
	coreapi.Field(
	name='country_id',
	location='path',
	required=False,
	type='string'
	)
	],

	}

	def filter_queryset(self, request, queryset, view):
	term = request.query_params.get('term')
	country_id = request.query_params.get('country_id')

	if term:
	queryset = queryset.filter(title__icontains=term)

	if country_id:
	queryset = queryset.filter(country_id=country_id)

	return queryset

	filter_backends = [CityDictBackend]

	@list_route(['post'])
	def city_set(self, request, args, *kwargs):
	city = get_object_or_404(core_models.City,
	pk=request.data.get('city_id'))
	if request.user.is_authenticated():
	request.user.city = city
	request.user.country_id = city.country_id
	request.user.save()
	else:
	request.session['current_city_id'] = city.pk

	return Response({'city': city.title, 'country': city.country.title})


	class LanguageViewSet(BaseDictViewSet):
	queryset = core_models.Language.objects.all()