PuppyServer/aiDogProject_docker/aiDogProject/aiDogApp/dog_transfer.py

import hashlib

from django.http import HttpResponse,JsonResponse
from django.views.decorators.csrf import csrf_exempt
from datetime import datetime, timedelta
from django.utils import timezone
from django.core import serializers
import time
import json
import os
import jwt

from .models import DogTrainingNew

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "aiDogProject.settings")
import django
django.setup()
from aiDogApp.models import *
from . import aidog_tools,aidog_request_tools

# 转移一只狗（赠送者）接口
# 使用access_token登录  请求参数：access_token、user_id,dog_id,datetime
# 返回格式：result、message、"transfer_code": "string"
# 赠送中：pending，赠送完成：completed，赠送取消：cancelled，赠送失败：failed
# 2025-5-19 author Feng
@csrf_exempt
@csrf_exempt
def send_dog_2_other(request):
    # 记录请求时间
    current_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')

    try:
        # 获取请求参数
        access_token = request.POST.get("access_token", '')
        user_id = request.POST.get("user_id", '')
        dog_id = request.POST.get("dog_id", '')
        req_datetime = request.POST.get("datetime", '')

        # 验证请求参数
        if not all([access_token, dog_id]):
            return JsonResponse({
                "status": "error",
                "date": current_time,
                "message": "Please ensure all required fields are provided!",
                "end_time": current_time
            })

        # 验证访问令牌
        token_validation = aidog_tools.validate_access_token(access_token)
        if isinstance(token_validation, JsonResponse):
            return token_validation

        # 从令牌验证中获取验证后的用户ID
        validated_user_id = token_validation['user_id']

        # 确保用户ID与令牌匹配
        if user_id and user_id != validated_user_id:
            return JsonResponse({
                "status": "error",
                "date": current_time,
                "message": "User ID does not match with access token",
                "end_time": current_time
            })

        # 使用验证过的用户ID
        user_id = validated_user_id

        try:
            # 检查当前用户拥有的狗数量是否 >= 2
            # owner_dogs = Doginfo.objects.filter(owner_id=user_id, is_active=True)
            owner_dogs = Doginfo.objects.filter(owner_id=user_id)
            owner_dog_count = owner_dogs.count()


            if owner_dog_count < 2:
                return JsonResponse({
                    "status": "error",
                    "date": current_time,
                    "message": "You must have at least 2 dogs to transfer one",
                    "end_time": current_time
                })

            # 检查要转移的狗是否存在且属于当前用户
            try:
                # dog = Doginfo.objects.get(d_id=dog_id, owner_id=user_id, is_active=True)
                dog = Doginfo.objects.get(d_id=dog_id, owner_id=user_id)
            except Doginfo.DoesNotExist:
                return JsonResponse({
                    "status": "error",
                    "date": current_time,
                    "message": f"Dog with ID {dog_id} not found or does not belong to you",
                    "end_time": current_time
                })

            # 检查要转移的狗当前是否已经在转移中
            if dog.transfer_status == 1:
                # 生成一个新的有效期为2分钟的唯一转移码
                try:
                    dog_transfer=DogTransfer.objects.get(d_id=dog_id, sender_id=user_id,status='pending')
                except DogTransfer.DoesNotExist:
                    return JsonResponse({
                        "status": "error",
                        "date": current_time,
                        "message": f"Dog with ID {dog_id} not found or does not belong to you",
                        "end_time": current_time
                    })
                expiry_time = datetime.now() + timedelta(minutes=2)
                dog_transfer.expiry_time = expiry_time
                transfer_data = f"{dog_id}:{user_id}:{expiry_time.strftime('%Y%m%d%H%M%S')}"
                transfer_code = hashlib.sha256(transfer_data.encode()).hexdigest()[:16]
                dog_transfer.transfer_code=transfer_code
                dog_transfer.save()
                return JsonResponse({
                    "status": "success",
                    "code": 200,
                    "message": "Transfer code refresh successfully",
                    "transfer_code": transfer_code,
                })

            # 更新狗的转移状态
            dog.transfer_status = 1
            dog.save()

            # 生成一个有效期为2分钟的唯一转移码
            expiry_time = datetime.now() + timedelta(minutes=2)
            transfer_data = f"{dog_id}:{user_id}:{expiry_time.strftime('%Y%m%d%H%M%S')}"
            transfer_code = hashlib.sha256(transfer_data.encode()).hexdigest()[:16]

            # 保存转移记录
            DogTransfer.objects.create(
                d_id=dog_id,
                sender_id=user_id,
                transfer_code=transfer_code,
                expiry_time=expiry_time,
                status='pending'
            )

            return JsonResponse({
                "status": "success",
                "code": 200,
                "message": "Transfer code generated successfully",
                "transfer_code": transfer_code,
            })

        except Exception as e:
            # 处理数据库操作中的异常
            return JsonResponse({
                "status": "error",
                "date": current_time,
                "message": f"Database operation error: {str(e)}",
                "end_time": current_time
            })

    except Exception as e:
        # 全局异常处理
        import traceback
        traceback.print_exc()
        return JsonResponse({
            "status": "error",
            "message": f"Server processing exception: {str(e)}",
            "date": current_time
        })



# 接收转移狗（接受者）接口
# 使用access_token登录  请求参数：access_token、user_id,datetime
# 返回格式：result、message、"transfer_code": "string"
# 赠送中：pending，赠送完成：completed，赠送取消：cancelled，赠送失败：failed
# 2025-5-19 author Feng
@csrf_exempt
def receive_dog_transfer(request):
    current_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')

    try:
        # 获取请求参数
        access_token = request.POST.get("access_token", '')
        transfer_code = request.POST.get("transfer_code", '')
        user_id= request.POST.get("user_id", '')
        datetime_request= request.POST.get("datetime", '')

        print(f"transfer_code for dog ID------------- {transfer_code}")
        # 验证请求参数
        if not all([access_token, user_id,transfer_code]):
            return JsonResponse({
                "status": "error",
                "date": current_time,
                "message": "Please ensure all required fields are provided!",
                "end_time": current_time
            })

        # 验证访问令牌
        token_validation = aidog_tools.validate_access_token(access_token)
        if isinstance(token_validation, JsonResponse):
            return token_validation

        # 获取接收者用户ID
        receiver_id = token_validation['user_id']

        # 检查接收者拥有的狗数量是否 <= 2
        # receiver_dogs = Doginfo.objects.filter(owner_id=receiver_id, is_active=True)
        receiver_dogs = Doginfo.objects.filter(owner_id=receiver_id)
        receiver_dog_count = receiver_dogs.count()

        if receiver_dog_count >= 2:
            return JsonResponse({
                "status": "error",
                "date": current_time,
                "message": "You cannot have more than 2 dogs",
                "end_time": current_time
            })

        # 查找转移记录
        try:
            transfer = DogTransfer.objects.get(
                transfer_code=transfer_code,
                status='pending'
            )
        except DogTransfer.DoesNotExist:
            return JsonResponse({
                "status": "error",
                "date": current_time,
                "message": "Invalid or expired transfer code",
                "end_time": current_time
            })

        # 新增：检查转移码是否过期
        # 从 transfer 记录中获取创建时间，计算是否已过期

        expiry_time = transfer.expiry_time
        # 检查是否过期（2分钟有效期）
        current_datetime = timezone.now()

        if current_datetime > expiry_time:
            # 转移码已过期，更新状态为过期
            # transfer.status = 'expired'
            # transfer.completed_time = datetime.now()
            # transfer.save()

            return JsonResponse({
                "status": "error",
                "date": current_time,
                "error_code": "620",
                "message": "Transfer code has expired, please generate a new one",
                "end_time": current_time
            })

        # 阻止用户向自己转移
        if transfer.sender_id == receiver_id:
            return JsonResponse({
                "status": "error",
                "date": current_time,
                "message": "You cannot transfer a dog to yourself",
                "end_time": current_time
            })

        # 获取要转移的狗
        try:
            dog = Doginfo.objects.get(d_id=transfer.d_id, transfer_status=1)
            dog_relationship_personality = DogPersonalityRelationship.objects.get(d_id=transfer.d_id)
        except Doginfo.DoesNotExist:
            # 更新转移记录状态
            transfer.status = 'failed'
            transfer.save()

            return JsonResponse({
                "status": "error",
                "date": current_time,
                "message": "Dog not found or not available for transfer",
                "end_time": current_time
            })

        # 执行转移
        dog.owner_id = receiver_id
        # 重置为可转移状态
        dog.transfer_status = 0
        dog.save()

        # 更新转移记录
        transfer.receiver_id = receiver_id
        transfer.status = 'completed'
        transfer.completed_time = datetime.now()
        transfer.save()

        # 更新狗与主人关系属性
        dog_relationship_personality.intimate = aidog_tools.generate_random_number(20, 30)
        dog_relationship_personality.friendly = aidog_tools.generate_random_number(20, 30)
        dog_relationship_personality.obedience = aidog_tools.generate_random_number(20, 30)
        dog_relationship_personality.friendlyToHost = aidog_tools.generate_random_number(20, 30)
        dog_relationship_personality.friendlyToStranger = aidog_tools.generate_random_number(20, 30)
        dog_relationship_personality.save()

        # 获取用户信息
        try:
            user = User.objects.get(uid=user_id)
            user_info = aidog_tools._build_user_info(user)
        except User.DoesNotExist:
            user_info = {}

        # 获取用户的所有狗列表
        try:
            dog_info = Doginfo.objects.filter(owner_id=user_id)
            dog_list = []
            for dog in dog_info:
                dog_serialized = serializers.serialize('json', [dog])
                dog_data = json.loads(dog_serialized)[0]['fields']
                dog_id = dog_data['d_id']
                # 获取狗的信息并转换为字典
                new_dog_status = aidog_tools.model_to_dict_without_id(DogStatus.objects.filter(d_id=dog_id).first())
                new_dog_training = aidog_tools.model_to_dict_without_id(
                    DogTrainingNew.objects.filter(d_id=dog_id).first())
                new_dog_body_attributes = aidog_tools.model_to_dict_without_id(
                    DogBodyAttributes.objects.filter(d_id=dog_id).first())
                new_dog_personality_relationship = aidog_tools.model_to_dict_without_id(
                    DogPersonalityRelationship.objects.filter(d_id=dog_id).first())
                # 合并所有相关信息
                dog_info_combined = {
                    **dog_data,
                    **new_dog_status,
                    **new_dog_training,
                    **new_dog_body_attributes,
                    **new_dog_personality_relationship,
                }

                # 只保留字段而不是数据库内部的元数据（如 '_state'）
                dog_info_clean = {key: value for key, value in dog_info_combined.items() if not key.startswith('_')}

                dog_list.append(dog_info_clean)

        except Exception as e:
            dog_list = []

        return JsonResponse({
            "status": "success",
            "code": 200,
            "message": "Dog transfer completed successfully",
            "date": current_time,
            "dog_id": dog.d_id,
            "dog_name": dog.dog_name,
            "user_info": user_info,
            "dog_list": dog_list
        })


    except Exception as e:
        # 全局异常处理
        import traceback
        traceback.print_exc()
        return JsonResponse({
            "status": "error",
            "message": f"Server processing exception: {str(e)}",
            "date": current_time
        })



# 取消转移狗（赠送者）接口
# 使用access_token登录  请求参数：access_token、user_id,transfer_code,datetime
# 返回格式：result、message、"transfer_code": "string"
# 赠送中：pending，赠送完成：completed，赠送取消：cancelled，赠送失败：failed
# 2025-5-19 author Feng
@csrf_exempt
def transfer_dog_cancel(request):
    current_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')

    try:
        # 获取请求参数
        # 获取请求参数
        access_token = request.POST.get("access_token", '')
        user_id = request.POST.get("user_id", '')
        transfer_code = request.POST.get("transfer_code", '')
        req_datetime = request.POST.get("datetime", '')

        # 验证请求参数
        if not all([access_token, transfer_code]):
            return JsonResponse({
                "status": "error",
                "date": current_time,
                "message": "Please ensure all required fields are provided!",
                "end_time": current_time
            })
        # 验证访问令牌
        token_validation = aidog_tools.validate_access_token(access_token)
        if isinstance(token_validation, JsonResponse):
            return token_validation

        # 从令牌验证中获取验证后的用户ID
        validated_user_id = token_validation['user_id']
        # 确保用户ID与令牌匹配（提供了user_id）
        if user_id and user_id != validated_user_id:
            return JsonResponse({
                "status": "error",
                "date": current_time,
                "message": "User ID does not match with access token",
                "end_time": current_time
            })

        # 使用验证过的用户ID
        user_id = validated_user_id

        try:
            # 根据transfer_code查找转移记录
            try:
                transfer = DogTransfer.objects.get(
                    transfer_code=transfer_code,
                    status='pending',
                    expiry_time__gt=datetime.now()
                )
            except DogTransfer.DoesNotExist:
                return JsonResponse({
                    "status": "error",
                    "date": current_time,
                    "message": "Invalid or expired transfer code",
                    "end_time": current_time
                })

            # 验证用户是否为该转移记录的发送者
            if transfer.sender_id != user_id:
                return JsonResponse({
                    "status": "error",
                    "date": current_time,
                    "message": "You do not have permission to cancel this transfer",
                    "end_time": current_time
                })

            # 获取要取消转移的狗
            try:
                dog = Doginfo.objects.get(d_id=transfer.d_id, transfer_status=1)
            except Doginfo.DoesNotExist:
                # 转移记录存在但狗不存在或不在转移状态，标记转移记录为失败
                transfer.status = 'failed'
                transfer.save()

                return JsonResponse({
                    "status": "error",
                    "date": current_time,
                    "message": "Dog not found or not in transfer status",
                    "end_time": current_time
                })

            # 取消转移记录
            transfer.status = 'cancelled'
            transfer.cancelled_time = datetime.now()
            transfer.save()

            # 重置狗的转移状态
            dog.transfer_status = 0
            dog.save()

            return JsonResponse({
                "status": "success",
                "code": 200,
                "message": "Dog transfer cancelled successfully",
                "date": current_time,
                "dog_id": dog.d_id
            })

        except Exception as e:
            # 处理数据库操作中的异常
            return JsonResponse({
                "status": "error",
                "date": current_time,
                "message": f"Database operation error: {str(e)}",
                "end_time": current_time
            })

    except Exception as e:
        # 全局异常处理
        import traceback
        traceback.print_exc()
        return JsonResponse({
            "status": "error",
            "message": f"Server processing exception: {str(e)}",
            "date": current_time
        })