PuppyServer/aiDogProject_docker/aiDogProject/aiDogApp/user.py

from . import aidog_request_tools,aidog_tools
from django.http import HttpResponse,JsonResponse
from datetime import datetime, timedelta
import jwt
import os
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "aiDogProject.settings")
import django
django.setup()
from aiDogApp.models import *
from django.views.decorators.csrf import csrf_exempt
import json
from django.core import serializers
import hashlib
SECRET_KEY='#tdfnrcn1s610h4*csa2-p+=lfqz-ol+=uo$+n2sa'

# 获取用户信息接口
# 使用access_token登录  请求参数：access_token、user_id
# 返回格式：result、message、user_info
# 2025-2-19 author Feng
# 2025-3-27 新增返回道具列表
@csrf_exempt
def get_user_info(request):

    try:

        # 获取请求参数
        params = aidog_request_tools.handle_post_request_parameters(request, ["access_token","user_id"])
        access_token,user_id = params["access_token"],params["user_id"]

        res = None
        date_now = datetime.strftime(datetime.today(), '%Y-%m-%d %H:%M:%S')
        if not access_token or not user_id:
            raise ValueError("Invalid input parameters: mobile_number or password or UUID is empty")

        # 验证access_token是否有效
        try:
            decoded_token = jwt.decode(access_token, SECRET_KEY, algorithms=['HS256'])
            user_id = decoded_token['user_id']
            print(user_id)
            # 判断数据库uid是否有效

        except jwt.ExpiredSignatureError:
            # 旧access_token已过期，返回失败信息
            return JsonResponse({
                "status": "error",
                "code": 400,
                "message": "AccessToken expired, please refresh!"
            })


        # 取出数据库的uid：
        try:
            user = User.objects.get(uid=user_id)

        except User.DoesNotExist:
            return {"status": "error", "message": f"No user found with uid={user_id}"}

        # 处理isRegUser的布尔值转换
        isRegUser = True if getattr(user, 'isRegUser', 0) == 1 else False

        dog_info = Doginfo.objects.filter(owner_id=user_id)

        # 获取用户道具库存

        user_inventory = UserInventory.objects.filter(owner_id=user_id)

        # 返回用户名下的道具数量
        # props_list = []
        # for prop in user_inventory:
        #     prop_serialized = serializers.serialize('json', [prop])
        #     prop_data = json.loads(prop_serialized)[0]['fields']
        #     props_list.append(prop_data)
        props_dict = {
            "food": {},
            "toy": {},
            "other": {}
        }

        for prop in user_inventory:
            prop_serialized = serializers.serialize('json', [prop])
            prop_data = json.loads(prop_serialized)[0]['fields']
            if prop_data['quantity']>0:
                # Determine the category based on item_id prefix
                if prop_data['item_id'].startswith('food_') or prop_data['item_id'].startswith('water_'):
                    category = 'food'
                elif prop_data['item_id'].startswith('toy_'):
                    category = 'toy'
                else:
                    category = 'other'

                # Add to the corresponding category dictionary
                props_dict[category][prop_data['item_id']] = prop_data['quantity']


        # print(dog_info)
        dog_list = []
        dog_id_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())

            # new_dog_status = DogStatus.objects.filter(d_id=dog_id).first()
            # new_dog_training = DogTraining.objects.filter(d_id=dog_id).first()
            # new_dog_body_attributes = DogBodyAttributes.objects.filter(d_id=dog_id).first()
            # new_dog_personality_relationship = DogPersonalityRelationship.objects.filter(d_id=dog_id).first()

            # 合并所有相关信息
            # dog_info_combined = {
            #     **dog_data,
            #     **(new_dog_status.__dict__ if new_dog_status else {}),
            #     **(new_dog_training.__dict__ if new_dog_training else {}),
            #     **(new_dog_body_attributes.__dict__ if new_dog_body_attributes else {}),
            #     **(new_dog_personality_relationship.__dict__ if new_dog_personality_relationship else {}),
            # }
            # 合并所有相关信息
            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)



        res = {
            "status": "success",
            "message": "request UserInfo successful!",
            "user_info": {
                "user_name":user.user_name,
                "coin": user.coin,
                "isRegUser": isRegUser,
                "mobile": user.mobile,
                "email": user.email,
                "level": user.level,
                "uuid":user.uuid,
                "registration_time": user.registration_time,
            },
            "dogs": dog_list,
            "props":props_dict,
        }

        return  JsonResponse(res)



    except Exception as e:
        import traceback
        traceback.print_exc()
        return JsonResponse({"status": "error", "message": str(e)}, status=500)



# 更新用户信息接口
# 使用access_token登录  请求参数：access_token、user_id
# 返回格式：result、message、user_info
# 2025-3-31 author Feng
@csrf_exempt
def update_user_info(request):

    try:

        # 获取请求参数
        required_params = ["mobile_number", "email", "password", "access_token",
                           "user_name", "user_id", "client_language"]
        params = aidog_request_tools.handle_post_request_has_empty_parameters(request, required_params)

        client_language = params["client_language"]
        user_id = params["user_id"]
        password = params["password"]
        access_token = params["access_token"]
        user_name = params["user_name"]
        mobile_number = params["mobile_number"]
        email = params["email"]

        # 参数验证
        if not client_language:
            return JsonResponse({
                "status": "error",
                "code": 400,
                "message": "Invalid input parameters: client_language is empty"
            })


        # 根据系统语言判断必填参数
        if client_language == "zh-cn" and (not mobile_number or not password or not user_name or not user_id):
            # 使用mobile_number登录
            return JsonResponse({
                "status": "error",
                "code": 400,
                "message": "Invalid input parameters: mobile_number or password or username or user_id is empty"
            })
        elif client_language != "zh-cn" and (not email or not password or not user_name or not user_id):
            # 使用Email登录
            return JsonResponse({
                "status": "error",
                "code": 400,
                "message": "Invalid input parameters: Email or password or username or user_id is empty"
            })

        # 验证access_token是否有效
        try:
            decoded_token = jwt.decode(access_token, SECRET_KEY, algorithms=['HS256'])
            token_user_id = decoded_token['user_id']

            if token_user_id != user_id:
                return JsonResponse({
                    "status": "error",
                    "code": 400,
                    "message": "AccessToken doesn't match!"
                })

        except jwt.ExpiredSignatureError:
            return JsonResponse({
                "status": "error",
                "code": 400,
                "message": "AccessToken expired, please refresh!"
            })
        except jwt.InvalidTokenError:
            return JsonResponse({
                "status": "error",
                "code": 400,
                "message": "Invalid access token"
            })

        # 取出数据库的uid：
        try:
            user = User.objects.get(uid=user_id)
            # 处理密码 - 如果是 ******** 则保留原密码，否则更新
            if password != '********':
                password = hashlib.sha256(password.encode()).hexdigest()
            else:
                password = user.password

            # 更新用户信息
            user.mobile = mobile_number
            user.user_name = user_name
            user.email = email
            user.password = password
            user.save()

            res = {
                "status": "success",
                "message": "User updated successfully！",
                "user_id": user_id,
                "user_name": user_name,
                "mobile_number": mobile_number,
                "email": email,

            }

            return  JsonResponse(res)


        except User.DoesNotExist:
            return JsonResponse({
                "status": "error",
                "code": 404,
                "message": f"No user found with uid={user_id}"
            }, status=404)



    except Exception as e:
        import traceback
        traceback.print_exc()
        return JsonResponse({"status": "error", "message": str(e)}, status=500)



# 用户反馈接口
# 使用access_token登录  请求参数：access_token、user_id，feedback,date_time，type(bug/comment),log(file)
# 返回格式：result、message、user_info
# 2025-3-31 author Feng
@csrf_exempt
def feedback(request):

    try:
        current_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
        # 获取请求参数
        required_params = ["access_token", "user_id","feedback", "date_time", "type"]
        params = aidog_request_tools.handle_post_request_has_empty_parameters(request, required_params)
        access_token = params["access_token"]
        user_id = params["user_id"]
        feedback=params["feedback"]
        # date_time = params["date_time"]
        type = params["type"]
        # 尝试从FILES获取文件（multipart/form-data方式）
        file_stream = request.FILES.get("log") or request.FILES.get("file")

        # 如果FILES中没有找到文件，并且Content-Type是application/octet-stream，
        # 则从请求体中读取二进制数据
        if not file_stream and request.content_type == 'application/octet-stream':
            from django.core.files.uploadedfile import SimpleUploadedFile
            file_stream = SimpleUploadedFile("log.zip", request.body, content_type="application/octet-stream")


        # 验证请求参数
        # 验证文件是否存在
        # if not file_stream:
        #     return JsonResponse({
        #         "status": "error",
        #         "message": "log file was not uploaded",
        #         "date": current_time
        #     })
        # if type not in ["comment", "bug"]:
        #     return JsonResponse({
        #         "status": "error",
        #         "date": current_time,
        #         "message": "Please ensure type field is correctly provided!",
        #         "end_time": current_time
        #     })

        if not all([user_id,type, access_token,feedback]):
            return JsonResponse({
                "status": "error",
                "date": current_time,
                "message": "Please ensure all required fields are provided!",
                "end_time": current_time
            })

        # 验证access_token是否有效
        try:
            decoded_token = jwt.decode(access_token, SECRET_KEY, algorithms=['HS256'])
            token_user_id = decoded_token['user_id']

            if token_user_id != user_id:
                return JsonResponse({
                    "status": "error",
                    "code": 400,
                    "message": "AccessToken doesn't match!"
                })

        except jwt.ExpiredSignatureError:
            return JsonResponse({
                "status": "error",
                "code": 400,
                "message": "AccessToken expired, please refresh!"
            })
        except jwt.InvalidTokenError:
            return JsonResponse({
                "status": "error",
                "code": 400,
                "message": "Invalid access token"
            })

        # 取出数据库的uid：
        try:
            raining_log = AidogFeedbacks.objects.create(
                uid=user_id,
                create_time=current_time,
                feedback_type=type,
                feedback_content=feedback,
            )
            res = {
                "status": "success",
                "message": "feedback successfully！",

            }

            return  JsonResponse(res)


        except AidogFeedbacks.DoesNotExist:
            return JsonResponse({
                "status": "error",
                "code": 404,
                "message": f"No user found with uid={user_id}"
            }, status=404)



    except Exception as e:
        import traceback
        traceback.print_exc()
        return JsonResponse({"status": "error", "message": str(e)}, status=500)