consumocuidado-server/companies/views.py

import logging
import json

from django.shortcuts import render, get_object_or_404
from django.core.mail import EmailMessage
from django.template.loader import render_to_string
from django.contrib.gis.geoip2 import GeoIP2

# Create your views here.
from rest_framework import viewsets, status
from rest_framework.response import Response
from rest_framework.permissions import IsAuthenticatedOrReadOnly, IsAuthenticated
from rest_framework.decorators import api_view, permission_classes, action

from ipware import get_client_ip

from stats.models import StatsLog
from companies.models import Company
from companies.serializers import CompanySerializer
from utils.tag_filters import CompanyTagFilter
from back_latienda.permissions import IsCreator

from utils import woocommerce


class CompanyViewSet(viewsets.ModelViewSet):
    queryset = Company.objects.filter(is_validated=True).order_by('-created')
    serializer_class = CompanySerializer
    permission_classes = [IsAuthenticatedOrReadOnly, IsCreator]
    filterset_class = CompanyTagFilter

    def perform_create(self, serializer):
        serializer.save(creator=self.request.user)

    @action(detail=True, methods=['POST', ])
    def email_manager(self, request, **kwargs):
        """
        Send email to company.creator
        """
        try:
            instance = self.queryset.filter(pk=kwargs['pk']).first()
            if instance:
                # IP stuff
                client_ip, is_routable = get_client_ip(request)
                g = GeoIP2()

                # deserialize payload
                data = json.loads(request.body)
                if request.user.is_authenticated:
                    # send email to manager
                    company_message = render_to_string('company_contact.html', {
                        'company': instance,
                        'email': request.user.email,
                        'full_name': request.user.full_name,
                        'quantity': data['quantity'],
                        'phone_number': data.get('phone_number'),
                        'comments': data['comments'],
                        'product_info': data['product_info'],
                    })
                    user_message = render_to_string('confirm_company_contact.html', {
                        'company': instance,
                        'username': request.user.full_name,
                        'data': data,
                    })
                    # send email to company
                    subject = "Contacto de usuario"
                    email = EmailMessage(subject, company_message, to=[instance.creator.email])
                    email.send()
                    logging.info(f"Email sent to {instance.creator.email} as manager of {instance.name}")
                    # send confirmation email to user
                    subject = 'Confirmación de contacto'
                    email = EmailMessage(subject, message, to=[request.user.email])
                    email.send()
                    logging.info(f"Contact confirmation email sent to {request.user.email}")
                    stats_data = {
                        'action_object': instance,
                        'user': None,
                        'anonymous': True,
                        'ip_address': client_ip,
                        'geo': g.geos(client_ip),
                        'contact': True,
                        'shop': instance.shop,
                    }
                else:
                    # for unauthenticated users
                    company_message = render_to_string('company_contact.html', {
                        'company': instance,
                        'email': data['email'],
                        'full_name': data['full_name'],
                        'quantity': data['quantity'],
                        'phone_number': data.get('phone_number'),
                        'comments': data['comments'],
                        'product_info': data['product_info'],
                    })
                    user_message = render_to_string('confirm_company_contact.html', {
                        'company': instance,
                        'username': data['full_name'],
                    })
                    # send email to company
                    email = EmailMessage(subject, company_message, to=[instance.creator.email])
                    email.send()
                    logging.info(f"Email sent to {instance.creator.email} as manager of {instance.name}")
                    # send confirmation email to user
                    email = EmailMessage(subject, user_message, to=[data['email']])
                    email.send()
                    logging.info(f"Contact confirmation email sent to anonymous user {data['email']}")
                    # statslog  data to register interaction
                    stats_data = {
                        'action_object': instance,
                        'user': request.user,
                        'anonymous': False,
                        'ip_address': client_ip,
                        'geo': g.geos(client_ip),
                        'contact': True,
                        'shop': instance.shop,
                    }
                #  create statslog instance to register interaction
                StatsLog.objects.create(**stats_data)

                return Response(data=data)
            else:
                return Response({"errors":{"details": f"No instance of company with id {kwargs['pk']}",}})
        except Exception as e:
                return Response({"errors":{"details": str(e),}}, status=500)

    @action(detail=True, methods=['GET', ])
    def import_products(self, request, **kwargs):
        instance = self.queryset.filter(pk=kwargs['pk']).first()
        # check if it's a shop
        if instance.shop is not True:
                return Response({'error': 'This company is not a shop'})
        # check required credentials
        credentials = instance.credentials
        if credentials is None or credentials == {}:
                return Response({'error': 'This company has no registered credentials'})
        # check what platform
        platform = instance.platform
        if platform is None:
                message = {'error': 'This company is not registered with any platforms'}
        elif platform == 'WOO_COMMERCE':
                # recheck credentials
                if 'key' in credentials.keys() and 'secret' in credentials.keys():
                    # execute import
                    products = woocommerce.migrate_shop_products(
                            instance.web_link,
                            credentials['key'],
                            credentials['secret'],
                            request.user,
                            )
                    message = {'details': f'{len(products)} products added for {instance.company_name}'}
                else:
                    message = {"error": 'Credentials have wrong format'}
        else:
                message = {'error': f'Platform {plaform} not registered'}
        return Response(message)


@api_view(['GET',])
@permission_classes([IsAuthenticated,])
def my_company(request):
    limit = request.GET.get('limit')
    offset = request.GET.get('offset')
    qs = Company.objects.filter(creator=request.user)
    company_serializer = CompanySerializer(qs, many=True)
    data = company_serializer.data
    # RESULTS PAGINATION
    if limit is not None and offset is not None:
        limit = int(limit)
        offset = int(offset)
        data = data[offset:(limit+offset)]
    elif limit is not None:
        limit = int(limit)
        data = data[:limit]
    return Response(data=data)


@api_view(['GET',])
@permission_classes([IsAuthenticatedOrReadOnly,])
def random_company_sample(request):
    """Return an slice of a randomized list of companies

    Takes optional parameter size (int)
    """
    try:
        size = request.GET.get('size', 6)
        size = int(size)
    except:
        return Response({"error": "Wrong value for size, must be a  number"}, status=status.HTTP_406_NOT_ACCEPTABLE)

    queryset = Company.objects.filter(is_validated=True).order_by('?')[:size]
    serializer = CompanySerializer(queryset, many=True)
    return Response(serializer.data)