from rest_framework.views import APIView from rest_framework.response import Response from rest_framework import status import json import ast import re from decimal import Decimal, InvalidOperation from User.models import User, Approval from User.utils import log_operation, normalize_approvers_param, build_missing_approvers_message from .models import PreFiling, ProjectRegistration, Bid, Case, Invoice, Caselog, SealApplication, Warehousing, \ RegisterPlatform, Announcement, LawyerFlie, Schedule, permission, role, CaseChangeRequest, CaseTag,Propaganda,System, ContractCounter from .contract_no import generate_next_contract_no, get_next_contract_no_preview from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger from utility.utility import flies from datetime import datetime from django.db.models import Count, Q from django.db import transaction import os def get_user_team_name(username): if not username: return None try: user = User.objects.get(username=username, is_deleted=False) return user.team except User.DoesNotExist: return None def get_team_name_from_responsiblefor(responsiblefor): if not responsiblefor: return None try: data = json.loads(responsiblefor) if isinstance(responsiblefor, str) else responsiblefor except (json.JSONDecodeError, TypeError): return None if isinstance(data, dict): responsible_person = data.get('responsible_person') if responsible_person is None: return None # 兼容负责人人员ID或用户名 if str(responsible_person).strip().isdigit(): try: user = User.objects.get(id=int(responsible_person), is_deleted=False) return user.team except User.DoesNotExist: return None return get_user_team_name(responsible_person) return None def search_related_records(client_info, party_info, exclude_project_id=None): """ 根据委托人和相对方信息检索预立案、投标、立项三个表的冲突记录 只返回委托人和相对方都匹配的记录（冲突数据） Args: client_info: 委托人身份信息（字符串） party_info: 相对方身份信息（字符串） exclude_project_id: 要排除的立项ID（可选，用于排除当前正在创建的记录） Returns: dict: 包含三个表的冲突记录信息 { 'prefiling_conflicts': [...], # 预立案冲突记录列表 'project_conflicts': [...], # 立项冲突记录列表 'bid_conflicts': [...] # 投标冲突记录列表 } """ result = { 'prefiling_conflicts': [], 'project_conflicts': [], 'bid_conflicts': [] } if not client_info and not party_info: return result # 解析委托人信息和相对方信息 client_parsed = parse_person_info(client_info) if client_info else {'name': '', 'id_number': '', 'original': ''} party_parsed = parse_person_info(party_info) if party_info else {'name': '', 'id_number': '', 'original': ''} # 提取姓名/名称（用于匹配） client_name = client_parsed['name'] client_id_number = client_parsed['id_number'] client_original = client_parsed['original'] party_name = party_parsed['name'] party_id_number = party_parsed['id_number'] party_original = party_parsed['original'] # 检索预立案表 - 查找委托人和相对方都匹配的记录（冲突数据） # 注意：预立案和立项是完全独立的，没有关联关系，只根据委托人和相对方信息匹配 # 预立案表字段：client_username/party_username（JSON数组格式字符串，如：[{"index":1,"name":"张三","idNumber":"110101199001011234"}]） # 立项表字段：client_info/party_info（完整身份信息，如"张三，身份证号：110101199001011234"） # # 冲突判断逻辑： # 1. 委托人和相对方都匹配（顺序相同或相反） # 2. 预立案中委托人和相对方是同一个人，且这个人在立项的委托人或相对方中 # 3. 立项中委托人和相对方是同一个人，且这个人在预立案的委托人或相对方中 if (client_info or client_name) and (party_info or party_name): matched_prefilings = [] # 检查立项中委托人和相对方是否是同一个人 is_same_person_in_project = False if client_name and party_name and client_name.strip() == party_name.strip(): is_same_person_in_project = True elif client_id_number and party_id_number and client_id_number == party_id_number: # 通过身份证号判断是否为同一人 is_same_person_in_project = True # 遍历预立案记录，解析JSON格式并匹配 prefiling_all = PreFiling.objects.filter(is_deleted=False) for pf in prefiling_all[:100]: # 限制查询数量以提高性能 if len(matched_prefilings) >= 10: break if not pf.client_username or not pf.party_username: continue # 解析预立案的client_username（JSON数组格式） pf_client_names = [] try: client_data = json.loads(pf.client_username) if isinstance(pf.client_username, str) else pf.client_username if isinstance(client_data, list): for item in client_data: if isinstance(item, dict) and 'name' in item: pf_client_names.append(item['name'].strip()) elif isinstance(client_data, dict) and 'name' in client_data: pf_client_names.append(client_data['name'].strip()) except (json.JSONDecodeError, TypeError, AttributeError): # 如果不是JSON格式，尝试直接使用字符串（兼容旧数据） pf_client_names = [pf.client_username.strip()] # 解析预立案的party_username（JSON数组格式） pf_party_names = [] try: party_data = json.loads(pf.party_username) if isinstance(pf.party_username, str) else pf.party_username if isinstance(party_data, list): for item in party_data: if isinstance(item, dict) and 'name' in item: pf_party_names.append(item['name'].strip()) elif isinstance(party_data, dict) and 'name' in party_data: pf_party_names.append(party_data['name'].strip()) except (json.JSONDecodeError, TypeError, AttributeError): # 如果不是JSON格式，尝试直接使用字符串（兼容旧数据） pf_party_names = [pf.party_username.strip()] if not pf_client_names or not pf_party_names: continue # 检查预立案中委托人和相对方是否是同一个人（所有委托人和所有相对方中有相同的名字） is_same_person_in_prefiling = bool(set(pf_client_names) & set(pf_party_names)) # 对每个委托人名字和相对方名字进行匹配 client_match = False party_match = False reverse_client_match = False reverse_party_match = False # 检查正向匹配：预立案的委托人是否在立项的委托人信息中，预立案的相对方是否在立项的相对方信息中 for pf_client in pf_client_names: if client_name and pf_client in client_name: client_match = True break elif client_original and pf_client in client_original: client_match = True break for pf_party in pf_party_names: if party_name and pf_party in party_name: party_match = True break elif party_original and pf_party in party_original: party_match = True break # 检查反向匹配：预立案的委托人是否在立项的相对方信息中，预立案的相对方是否在立项的委托人信息中 for pf_client in pf_client_names: if party_name and pf_client in party_name: reverse_client_match = True break elif party_original and pf_client in party_original: reverse_client_match = True break for pf_party in pf_party_names: if client_name and pf_party in client_name: reverse_party_match = True break elif client_original and pf_party in client_original: reverse_party_match = True break # 判断是否冲突： # 1. 正向匹配或反向匹配都成功 # 2. 预立案中委托人和相对方是同一个人，且这个人在立项的委托人或相对方信息中 # 3. 立项中委托人和相对方是同一个人，且这个人在预立案的委托人或相对方信息中 is_conflict = False if (client_match and party_match) or (reverse_client_match and reverse_party_match): is_conflict = True elif is_same_person_in_prefiling: # 预立案中委托人和相对方是同一个人，检查这个共同的名字是否在立项信息中 common_names = set(pf_client_names) & set(pf_party_names) for common_name in common_names: if (client_name and common_name in client_name) or (party_name and common_name in party_name) or \ (client_original and common_name in client_original) or (party_original and common_name in party_original): is_conflict = True break elif is_same_person_in_project: # 立项中委托人和相对方是同一个人，检查这个共同的名字是否在预立案信息中 for pf_client in pf_client_names: if (client_name and pf_client in client_name) or (party_name and pf_client in party_name) or \ (client_original and pf_client in client_original) or (party_original and pf_client in party_original): is_conflict = True break if not is_conflict: for pf_party in pf_party_names: if (client_name and pf_party in client_name) or (party_name and pf_party in party_name) or \ (client_original and pf_party in client_original) or (party_original and pf_party in party_original): is_conflict = True break if is_conflict: matched_prefilings.append({ 'id': pf.id, 'times': pf.times, 'client_username': pf.client_username, 'party_username': pf.party_username, 'description': pf.description }) result['prefiling_conflicts'] = matched_prefilings # 检索立项表（排除当前正在创建的记录）- 只查找委托人和相对方都匹配的记录（冲突数据） if client_info and party_info: project_records = ProjectRegistration.objects.filter(is_deleted=False) if exclude_project_id: project_records = project_records.exclude(id=exclude_project_id) # 委托人和相对方都匹配，或者相对方和委托人都匹配（可能是顺序相反） # 支持姓名和完整信息匹配 project_q = Q() if client_name and party_name: project_q |= (Q(client_info__icontains=client_name) & Q(party_info__icontains=party_name)) project_q |= (Q(client_info__icontains=party_name) & Q(party_info__icontains=client_name)) if client_original and party_original: project_q |= (Q(client_info__icontains=client_original[:50]) & Q(party_info__icontains=party_original[:50])) project_q |= (Q(client_info__icontains=party_original[:50]) & Q(party_info__icontains=client_original[:50])) if client_id_number and party_id_number: project_q |= (Q(client_info__icontains=client_id_number) & Q(party_info__icontains=party_id_number)) project_q |= (Q(client_info__icontains=party_id_number) & Q(party_info__icontains=client_id_number)) if project_q: project_records = project_records.filter(project_q) # 获取项目列表（最多10条） project_list = list(project_records[:10].values('id', 'ContractNo', 'times', 'type', 'client_info', 'party_info')) result['project_conflicts'] = project_list # 检索投标表 - 投标表只有BiddingUnit字段，需要检查是否包含委托人或相对方信息 # BiddingUnit可能同时包含委托人和相对方，或者只包含其中一方 bid_records = Bid.objects.filter(is_deleted=False) bid_q = Q() # 如果有提取出的名称，优先使用名称匹配 if client_name: bid_q |= Q(BiddingUnit__icontains=client_name) if party_name: bid_q |= Q(BiddingUnit__icontains=party_name) # 如果有完整信息，也尝试匹配 if client_original: bid_q |= Q(BiddingUnit__icontains=client_original[:50]) if party_original: bid_q |= Q(BiddingUnit__icontains=party_original[:50]) # 如果有身份证号，也尝试匹配 if client_id_number: bid_q |= Q(BiddingUnit__icontains=client_id_number) if party_id_number: bid_q |= Q(BiddingUnit__icontains=party_id_number) # 如果构建了查询条件，执行查询 if bid_q: bid_records = bid_records.filter(bid_q) bid_list = list(bid_records[:10].values('id', 'ProjectName', 'times', 'BiddingUnit')) result['bid_conflicts'] = bid_list return result def get_change_approvers(): """获取变更审批人（管委会或行政部）""" try: approvers = ( User.objects.filter(is_deleted=False) .filter( Q(role__RoleName__in=["管委会", "行政部"]) | Q(department__username="行政部") ) .distinct() .order_by("id") ) return [user.username for user in approvers if user.username] except Exception: return [] def build_change_approval_content(applicant_name, case, change_item, change_reason, agreement_urls): agreement_display = "，".join(agreement_urls) if agreement_urls else "无" return ( f"{applicant_name}提交案件变更申请，" f"案件ID：{case.id}，" f"变更事项：{change_item}，" f"变更原因：{change_reason}，" f"变更协议：{agreement_display}" ) def build_case_approval_content(project_registration, times, change_request=False): times_str = times or "未填写日期" content_parts = [f"{times_str}提交了一份案件信息"] if change_request: content_parts[0] = f"{times_str}提交了一份案件信息，更改了变更申请" if project_registration: if project_registration.ContractNo: content_parts.append(f"合同编号：{project_registration.ContractNo}") if project_registration.type: content_parts.append(f"项目类型：{project_registration.type}") if project_registration.client_info: # 解析客户名称：如果是JSON格式，只提取name字段 client_info_str = project_registration.client_info try: # 尝试解析为JSON数组 client_info_list = json.loads(client_info_str) if isinstance(client_info_list, list) and len(client_info_list) > 0: # 提取所有name字段，用逗号连接 client_names = [item.get('name', '') for item in client_info_list if isinstance(item, dict) and item.get('name')] client_info_str = '、'.join(client_names) if client_names else client_info_str except (json.JSONDecodeError, TypeError, AttributeError): # 如果不是JSON格式，保持原样 pass content_parts.append(f"客户名称：{client_info_str}") if project_registration.party_info: # 解析相对方名称：如果是JSON格式，只提取name字段 party_info_str = project_registration.party_info try: # 尝试解析为JSON数组 party_info_list = json.loads(party_info_str) if isinstance(party_info_list, list) and len(party_info_list) > 0: # 提取所有name字段，用逗号连接 party_names = [item.get('name', '') for item in party_info_list if isinstance(item, dict) and item.get('name')] party_info_str = '、'.join(party_names) if party_names else party_info_str except (json.JSONDecodeError, TypeError, AttributeError): # 如果不是JSON格式，保持原样 pass content_parts.append(f"相对方名称：{party_info_str}") if project_registration.description: content_parts.append(f"项目简述：{project_registration.description}") try: responsiblefor_dict = json.loads(project_registration.responsiblefor) if project_registration.responsiblefor else {} except (json.JSONDecodeError, TypeError): responsiblefor_dict = project_registration.responsiblefor if project_registration.responsiblefor else {} if isinstance(responsiblefor_dict, dict) and responsiblefor_dict.get("responsible_person"): content_parts.append(f"承办人：{responsiblefor_dict.get('responsible_person')}") if project_registration.charge: content_parts.append(f"收费情况：{project_registration.charge}") if change_request: content_parts.append("请审核变更申请") else: content_parts.append("请审核") return "，".join(content_parts) def normalize_amount_value(value): if value is None: return "0" if isinstance(value, (int, float, Decimal)): return str(value) value_str = str(value).strip() if value_str in ["", "未开票", "None", "null"]: return "0" numbers = re.findall(r"\d+\.?\d*", value_str) return numbers[0] if numbers else "0" class registration(APIView): def post(self, request, *args, **kwargs): """ 预立案登记 :param request: :param args: :param kwargs: :return: """ token = request.META.get('token') times = request.data.get('times') client_username = request.data.get('client_username') party_username = request.data.get('party_username') description = request.data.get('description') Undertaker = request.data.get('Undertaker') user = User.objects.get(token=token, is_deleted=False).username if not all([times, description, Undertaker]): return Response({'status': 'error', 'message': '缺少参数', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) prefiling = PreFiling.objects.create( times=times, client_username=client_username, party_username=party_username, description=description, Undertaker=Undertaker, submit=user ) # 记录操作日志 new_data = { 'id': prefiling.id, 'client_username': prefiling.client_username, 'party_username': prefiling.party_username, 'undertaker': prefiling.Undertaker } log_operation( request=request, operation_type='CREATE', module='Business', action='新增预立案登记', target_type='PreFiling', target_id=prefiling.id, target_name=f'{prefiling.client_username} vs {prefiling.party_username}', new_data=new_data, remark=f'新增预立案登记：委托人 {prefiling.client_username}，相对方 {prefiling.party_username}' ) return Response({'message': '登记成功', 'code': 0}, status=status.HTTP_200_OK) class registrationList(APIView): def post(self, request, *args, **kwargs): """ 预立案登记列表接口 注意：由于预立案和立项登记、投标登记已经拆分，现在返回所有未删除的预立案 :param request: :param args: :param kwargs: :return: """ # 由于预立案和立项登记、投标登记已经拆分，不再需要检查关联 # 直接返回所有未删除的预立案 prefiling_list = PreFiling.objects.filter(is_deleted=False) data = [] for prefiling in prefiling_list: data.append({ "id": prefiling.id, "client_username": prefiling.client_username, "party_username": prefiling.party_username, }) return Response({'message': '展示成功', 'data': data, 'code': 0}, status=status.HTTP_200_OK) class registrationDetail(APIView): def post(self, request, *args, **kwargs): """ 预立案登记展示 :param request: :param args: :param kwargs: :return: """ page = request.data.get('page') per_page = request.data.get('per_page') times = request.data.get('times') end_time = request.data.get('end_time') Undertaker = request.data.get('Undertaker') if not all([page, per_page]): return Response({'status': 'error', 'message': '缺少参数', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) Q_obj = Q() if times and end_time: Q_obj &= Q(times__gte=times) & Q(times__lte=end_time) if Undertaker: Q_obj &= Q(Undertaker__icontains=Undertaker) pre = PreFiling.objects.filter(Q_obj, is_deleted=False).order_by('-id') total = len(pre) paginator = Paginator(pre, per_page) try: user_agents_page = paginator.page(page) except PageNotAnInteger: user_agents_page = paginator.page(1) except EmptyPage: user_agents_page = paginator.page(paginator.num_pages) data = [] for info in user_agents_page.object_list: data.append({ "id": info.id, 'times': info.times, "client_username": info.client_username, "party_username": info.party_username, "description": info.description, "Undertaker": info.Undertaker, }) return Response({'message': '展示成功', "total": total, 'data': data, 'code': 0}, status=status.HTTP_200_OK) class EditRegistration(APIView): def post(self, request, *args, **kwargs): """ 编辑预立案登记 :param request: :param args: :param kwargs: :return: """ id = request.data.get('id') times = request.data.get('times') client_username = request.data.get('client_username') party_username = request.data.get('party_username') description = request.data.get('description') Undertaker = request.data.get('Undertaker') if not id: return Response({'status': 'error', 'message': '缺少参数', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) try: pre = PreFiling.objects.get(id=id, is_deleted=False) except PreFiling.DoesNotExist: return Response({'status': 'error', 'message': '预立案登记不存在', 'code': 1}, status=status.HTTP_404_NOT_FOUND) # 更新字段（如果提供了值） if times: pre.times = times pre.save(update_fields=['times']) if client_username: pre.client_username = client_username pre.save(update_fields=['client_username']) if party_username: pre.party_username = party_username pre.save(update_fields=['party_username']) if description: pre.description = description pre.save(update_fields=['description']) if Undertaker: pre.Undertaker = Undertaker pre.save(update_fields=['Undertaker']) return Response({'message': '编辑成功', 'code': 0}, status=status.HTTP_200_OK) class Project(APIView): def post(self, request, *args, **kwargs): """ 立项登记 - 独立创建，不再需要预立案。 必填：项目类型、立项日期、项目简述、收费情况、承办人信息、合同。 合同编号(ContractNo)可选：不传或传空时由后端按规则自动生成（校准(字)字【年份】第n号）。 相对方(party_info)为非必填项，委托人(client_info)可为空。 :param request: :param args: :param kwargs: :return: """ project_type = request.data.get('type') ContractNo = request.data.get('ContractNo') if ContractNo is not None and not isinstance(ContractNo, str): ContractNo = str(ContractNo) times = request.data.get('times') client_info = request.data.get('client_info') # 委托人身份信息（可选） party_info = request.data.get('party_info') # 相对方身份信息（非必填） description = request.data.get('description') # 项目简述 responsiblefor = request.data.get('responsiblefor') # 承办人信息（字典格式） charge = request.data.get('charge') contract = request.FILES.getlist('contract') approvers = request.data.get('approvers') # 审核人列表（可选，多人团队时需要，推荐：用户ID数组如[1,2,3]，兼容：用户名数组） # 兼容旧接口：如果传了 personincharge，转换为 approvers personincharge = request.data.get('personincharge') approvers = normalize_approvers_param(approvers, personincharge) import datetime import json # 明确拒绝 user_id 参数（此接口不再需要预立案，不需要 user_id） if 'user_id' in request.data: return Response({'status': 'error', 'message': '此接口不需要 user_id 参数，立项登记已独立创建', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) # 验证必填字段（合同编号可选，不传则后端自动生成） if not all([project_type, times, description, charge]): return Response({'status': 'error', 'message': '缺少必填参数（项目类型、立项日期、项目简述、收费情况）', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) # 验证承办人信息（字典格式） if not responsiblefor: return Response({'status': 'error', 'message': '承办人信息不能为空', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) # 解析承办人信息（支持字符串JSON或字典） try: if isinstance(responsiblefor, str): responsiblefor_dict = json.loads(responsiblefor) else: responsiblefor_dict = responsiblefor # 验证承办人（responsible_person）必填 if not responsiblefor_dict.get('responsible_person'): return Response({'status': 'error', 'message': '承办人不能为空', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) # 将字典转换为JSON字符串存储 responsiblefor_str = json.dumps(responsiblefor_dict, ensure_ascii=False) except (json.JSONDecodeError, TypeError, AttributeError): return Response({'status': 'error', 'message': '承办人信息格式错误，应为字典格式', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) if contract: contract = flies(contract) else: contract = [] # 将文件URL列表转换为字符串存储（如果有多个URL，用逗号分隔） if contract: # 如果只有一个URL，直接存储；如果有多个，用逗号分隔 contract_str = contract[0] if len(contract) == 1 else ','.join(contract) else: contract_str = "" need_auto_contract_no = not (ContractNo and ContractNo.strip()) if not need_auto_contract_no: # 用户传入合同编号：检查是否已存在 existing_project = ProjectRegistration.objects.filter(ContractNo=ContractNo.strip(), is_deleted=False).first() if existing_project: return Response({'status': 'error', 'message': '该合同编号已存在，不能重复创建', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) contract_year = int(times[:4]) if times and len(times) >= 4 else datetime.now().year # 使用事务确保创建立项和更新计数器是原子操作 with transaction.atomic(): if need_auto_contract_no: ContractNo = generate_next_contract_no(project_type, contract_year) if not ContractNo: return Response({ 'status': 'error', 'message': f'项目类型「{project_type}」未配置合同编号规则，无法自动生成。请手动填写合同编号，或选择已配置的类型（如：法律顾问、专项服务、民事案件代理等）', 'code': 1 }, status=status.HTTP_400_BAD_REQUEST) # 创建立项登记（相对方可为空，空字符串统一为 None） pro = ProjectRegistration.objects.create( type=project_type, ContractNo=ContractNo.strip() if isinstance(ContractNo, str) else ContractNo, times=times, client_info=client_info or None, party_info=party_info if party_info not in (None, '') else None, description=description, responsiblefor=responsiblefor_str, charge=charge, contract=contract_str, state="审核中", ) # 仅当用户手动传入合同编号时，更新计数器（与自动生成逻辑一致，保证序号连续） if not need_auto_contract_no: try: counter, created = ContractCounter.objects.select_for_update().get_or_create( project_type=project_type, year=contract_year, defaults={'current_number': 1} ) if not created: counter.current_number += 1 counter.save(update_fields=['current_number', 'updated_at']) except Exception as e: import logging logging.warning(f"更新合同编号计数器失败: {e}") today = datetime.datetime.now() formatted_date = today.strftime("%Y-%m-%d") # 获取团队信息：优先承办人，其次当前登录用户 team_name = get_team_name_from_responsiblefor(responsiblefor_dict) request_user = None token = request.META.get('token') or request.META.get('HTTP_AUTHORIZATION', '').replace('Bearer ', '') if token: try: request_user = User.objects.get(token=token, is_deleted=False) if not team_name: team_name = request_user.team except User.DoesNotExist: pass # 使用统一的审核流程函数 from User.utils import create_approval_with_team_logic # 构建承办人信息描述 responsible_desc = responsiblefor_dict.get('responsible_person', '') if responsiblefor_dict.get('main_lawyer'): responsible_desc += f"，主办律师：{responsiblefor_dict.get('main_lawyer')}" if responsiblefor_dict.get('assistant_lawyer'): responsible_desc += f"，协办律师：{responsiblefor_dict.get('assistant_lawyer')}" if responsiblefor_dict.get('case_manager_lawyer'): responsible_desc += f"，案管律师：{responsiblefor_dict.get('case_manager_lawyer')}" # 检索相关记录（预立案、投标、立项）- 使用 conflict_search 函数，支持更灵活的参数组合 related_records_info = conflict_search(client_info=client_info, party_info=party_info, exclude_project_id=pro.id) # 构建冲突信息文本（用于content字段，保持向后兼容） conflict_parts = [] if related_records_info['prefiling_conflicts']: conflict_parts.append(f"预立案冲突：{len(related_records_info['prefiling_conflicts'])}条（ID：{','.join([str(r['id']) for r in related_records_info['prefiling_conflicts'][:5]])}{'...' if len(related_records_info['prefiling_conflicts']) > 5 else ''}）") if related_records_info['project_conflicts']: conflict_parts.append(f"立项冲突：{len(related_records_info['project_conflicts'])}条（合同编号：{','.join([r['ContractNo'] for r in related_records_info['project_conflicts'][:3]])}{'...' if len(related_records_info['project_conflicts']) > 3 else ''}）") if related_records_info['bid_conflicts']: conflict_parts.append(f"投标冲突：{len(related_records_info['bid_conflicts'])}条（项目：{','.join([r['ProjectName'][:20] if r['ProjectName'] else '' for r in related_records_info['bid_conflicts'][:3]])}{'...' if len(related_records_info['bid_conflicts']) > 3 else ''}）") conflict_text = "；冲突记录：" + "；".join(conflict_parts) if conflict_parts else "" applicant_name = request_user.username if request_user else "" content = f"{responsiblefor_dict.get('responsible_person')}在{times}办理立项登记，项目类型：{project_type}，合同编号：{ContractNo}，{responsible_desc}，收费情况：{charge}，申请人：{applicant_name}{conflict_text}" approval, approvers_order_json, needs_approval = create_approval_with_team_logic( team_name=team_name, approvers=approvers, title=responsiblefor_dict.get('responsible_person', '') + "立项登记", content=content, approval_type="立项登记", user_id=pro.id, business_record=pro, today=formatted_date, applicant=applicant_name ) # 如果返回None且需要审核，说明缺少审核人 if approval is None and needs_approval: return Response({ 'status': 'error', 'message': build_missing_approvers_message(team_name, approvers), 'code': 1 }, status=status.HTTP_400_BAD_REQUEST) # 记录操作日志 new_data = { 'id': pro.id, 'contract_no': pro.ContractNo, 'type': pro.type, 'responsiblefor': responsiblefor_dict, 'times': pro.times } log_operation( request=request, operation_type='CREATE', module='Business', action='新增立项登记', target_type='ProjectRegistration', target_id=pro.id, target_name=pro.ContractNo, new_data=new_data, remark=f'新增立项登记：合同编号 {pro.ContractNo}，承办人 {responsiblefor_dict.get("responsible_person", "")}' ) return Response({ 'message': '登记成功', 'code': 0, 'contract_no': pro.ContractNo, }, status=status.HTTP_200_OK) class Projectquerytype(APIView): def post(self, request, *args, **kwargs): """ 根据年份和项目类型，先查该年份该项目类型的编号（序号），再组装成合同编号返回。 入参： - type（必填）：项目类型，如 法律顾问、专项服务 - year（可选）：年份，如 2025；不传则用 times 或当前年 - times（可选）：日期字符串，取前四位作为年份 逻辑：1) 按 年份 + 项目类型 查询当前已用到的编号（序号） 2) 下一个可用编号 = 当前编号 + 1，组装成「校准(字)字【年份】第n号」 返回 data： - contract_no：组装好的合同编号（下一个可用），如 校准(顾)字【2025】第1号 - number：下一个可用序号 - count：该年份该项目类型当前已用数量（已用到的最大序号） """ project_type = request.data.get('type') if not project_type: return Response({'status': 'error', 'message': '缺少参数type', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) # 解析年份：优先 year，其次 times 前四位，否则当前年 year_param = request.data.get('year') times = request.data.get('times') if year_param is not None and str(year_param).strip(): try: current_year = int(str(year_param).strip()[:4]) except ValueError: current_year = datetime.now().year elif times and len(str(times)) >= 4: try: current_year = int(str(times)[:4]) except ValueError: current_year = datetime.now().year else: current_year = datetime.now().year # 1) 根据年份 + 项目类型 查询该年份该项目类型的编号（当前已用到的序号） try: with transaction.atomic(): counter = ContractCounter.objects.filter( project_type=project_type, year=current_year ).first() count = counter.current_number if counter else 0 except Exception: start_of_year = datetime(current_year, 1, 1) end_of_year = datetime(current_year, 12, 31) start_of_year_str = start_of_year.strftime("%Y-%m-%d") end_of_year_str = end_of_year.strftime("%Y-%m-%d") count = ProjectRegistration.objects.filter( type=project_type, times__gte=start_of_year_str, times__lte=end_of_year_str, is_deleted=False ).count() # 2) 下一个可用编号 = 当前数量 + 1，组装成合同编号 next_number, contract_no = get_next_contract_no_preview(project_type, current_year) if not contract_no: return Response({ 'status': 'error', 'message': f'项目类型「{project_type}」未配置合同编号规则，无法组装编号', 'code': 1 }, status=status.HTTP_400_BAD_REQUEST) data = { "contract_no": contract_no, "number": next_number, "count": count, } return Response({'message': '查询成功', "data": data, 'code': 0}, status=status.HTTP_200_OK) def _get_project_registration_queryset_by_permission(request, base_q=None): """ 立项登记权限：管理员可见全部，承办人仅可见自己承办的立项。 base_q: 额外筛选条件（Q 对象），可为 None。 返回 (queryset, error_response)。error_response 非 None 时直接 return 给前端。 """ token = request.META.get('token') if not token: return None, Response({'status': 'error', 'message': '需要登录', 'code': 1}, status=status.HTTP_401_UNAUTHORIZED) try: current_user = User.objects.get(token=token, is_deleted=False) except User.DoesNotExist: return None, Response({'status': 'error', 'message': '用户不存在或未登录', 'code': 1}, status=status.HTTP_401_UNAUTHORIZED) is_admin = (current_user.username == 'admin' or current_user.account == 'admin') q = base_q if base_q is not None else Q() q &= Q(is_deleted=False) if not is_admin: # 承办人只能看到自己承办的立项（responsiblefor 中包含当前用户名，如 responsible_person 等） q &= Q(responsiblefor__icontains=current_user.username) return ProjectRegistration.objects.filter(q), None class ProjectDetail(APIView): def post(self, request, *args, **kwargs): """ 立项登记展示 权限：管理员可见全部立项；承办人仅可见自己承办的立项（负责人修改为承办人）。 :param request: :param args: :param kwargs: :return: """ page = request.data.get('page') per_page = request.data.get('per_page') times = request.data.get('times') end_time = request.data.get('end_time') client_info = request.data.get('client_info') # 委托人信息搜索 party_info = request.data.get('party_info') # 相对方信息搜索 if not all([page, per_page]): return Response({'status': 'error', 'message': '缺少参数', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) Q_obj = Q() if times and end_time: Q_obj &= Q(times__gte=times) & Q(times__lte=end_time) if client_info: Q_obj &= Q(client_info__icontains=client_info) if party_info: Q_obj &= Q(party_info__icontains=party_info) pre_qs, err = _get_project_registration_queryset_by_permission(request, Q_obj) if err is not None: return err pre = pre_qs.order_by('-id') total = len(pre) paginator = Paginator(pre, per_page) try: user_agents_page = paginator.page(page) except PageNotAnInteger: user_agents_page = paginator.page(1) except EmptyPage: user_agents_page = paginator.page(paginator.num_pages) data = [] import json for info in user_agents_page.object_list: # 解析承办人信息（JSON字符串转字典，原负责人即承办人） try: responsiblefor_dict = json.loads(info.responsiblefor) if info.responsiblefor else {} except Exception: responsiblefor_dict = info.responsiblefor if info.responsiblefor else {} data.append({ "id": info.id, 'times': info.times, "type": info.type, "ContractNo": info.ContractNo, "client_info": info.client_info, "party_info": info.party_info, "description": info.description, "responsiblefor": responsiblefor_dict, # 承办人信息（字典格式） "charge": info.charge, "contract": info.contract, "state": info.state, }) return Response({'message': '展示成功', "total": total, 'data': data, 'code': 0}, status=status.HTTP_200_OK) class EditProject(APIView): def post(self, request, *args, **kwargs): """ 编辑立案登记 :param request: :param args: :param kwargs: :return: """ id = request.data.get('id') if not id: return Response({'status': 'error', 'message': '缺少参数id', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) # 检查不可修改的参数（前端不会传入，但作为安全措施进行检查） forbidden_params = [] if 'type' in request.data: forbidden_params.append('type') if 'ContractNo' in request.data: forbidden_params.append('ContractNo') if forbidden_params: return Response({ 'status': 'error', 'message': f'以下参数不允许修改: {", ".join(forbidden_params)}', 'code': 1 }, status=status.HTTP_400_BAD_REQUEST) # 获取可修改的参数（前端只传入这些参数） times = request.data.get('times') client_info = request.data.get('client_info') party_info = request.data.get('party_info') description = request.data.get('description') responsiblefor = request.data.get('responsiblefor') # 承办人信息（字典格式） charge = request.data.get('charge') contract = request.FILES.getlist('contract') approvers = request.data.get('approvers') # 审核人列表（可选，团队类型时需要） personincharge = request.data.get('personincharge') approvers = normalize_approvers_param(approvers, personincharge) import json try: pro = ProjectRegistration.objects.get(id=id, is_deleted=False) except ProjectRegistration.DoesNotExist: return Response({'status': 'error', 'message': '立案登记不存在', 'code': 1}, status=status.HTTP_404_NOT_FOUND) import datetime # 保存原始值用于日志记录 original_type = pro.type original_ContractNo = pro.ContractNo try: original_responsiblefor = json.loads(pro.responsiblefor) if pro.responsiblefor else {} except: original_responsiblefor = {} original_times = pro.times original_charge = pro.charge update_fields_list = [] if contract: contract = flies(contract) # 将文件URL列表转换为字符串存储（如果有多个URL，用逗号分隔） if contract: contract_str = contract[0] if len(contract) == 1 else ','.join(contract) else: contract_str = "" pro.contract = contract_str update_fields_list.append('contract') if times: pro.times = times update_fields_list.append('times') if responsiblefor: # 解析承办人信息（支持字符串JSON或字典） try: if isinstance(responsiblefor, str): responsiblefor_dict = json.loads(responsiblefor) else: responsiblefor_dict = responsiblefor # 验证承办人（responsible_person）必填 if not responsiblefor_dict.get('responsible_person'): return Response({'status': 'error', 'message': '承办人不能为空', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) # 将字典转换为JSON字符串存储 responsiblefor_str = json.dumps(responsiblefor_dict, ensure_ascii=False) pro.responsiblefor = responsiblefor_str update_fields_list.append('responsiblefor') except (json.JSONDecodeError, TypeError, AttributeError): return Response({'status': 'error', 'message': '承办人信息格式错误，应为字典格式', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) if charge: pro.charge = charge update_fields_list.append('charge') if client_info: pro.client_info = client_info update_fields_list.append('client_info') if party_info: pro.party_info = party_info update_fields_list.append('party_info') if description: pro.description = description update_fields_list.append('description') pro.state = "审核中" update_fields_list.append('state') # 记录操作前的数据（original_responsiblefor已经是字典格式） old_data = { 'id': pro.id, 'contract_no': original_ContractNo, 'type': original_type, 'responsiblefor': original_responsiblefor if isinstance(original_responsiblefor, dict) else {}, 'times': original_times, 'charge': original_charge } if update_fields_list: pro.save(update_fields=update_fields_list) # 记录操作后的数据 try: current_responsiblefor = json.loads(pro.responsiblefor) if pro.responsiblefor else {} except: current_responsiblefor = pro.responsiblefor if pro.responsiblefor else {} new_data = { 'id': pro.id, 'contract_no': pro.ContractNo, 'type': pro.type, 'responsiblefor': current_responsiblefor, 'times': pro.times, 'charge': pro.charge } today = datetime.datetime.now() formatted_date = today.strftime("%Y-%m-%d") # 获取承办人名称用于审批记录 if responsiblefor: current_responsiblefor = responsiblefor_dict.get('responsible_person', '') # 构建承办人信息描述 responsible_desc = current_responsiblefor if responsiblefor_dict.get('main_lawyer'): responsible_desc += f"，主办律师：{responsiblefor_dict.get('main_lawyer')}" if responsiblefor_dict.get('assistant_lawyer'): responsible_desc += f"，助理律师：{responsiblefor_dict.get('assistant_lawyer')}" if responsiblefor_dict.get('case_manager_lawyer'): responsible_desc += f"，案管律师：{responsiblefor_dict.get('case_manager_lawyer')}" else: current_responsiblefor = original_responsiblefor.get('responsible_person', '') if isinstance(original_responsiblefor, dict) else '' responsible_desc = current_responsiblefor edit_user = None token = request.META.get('token') or request.META.get('HTTP_AUTHORIZATION', '').replace('Bearer ', '') if token: try: edit_user = User.objects.get(token=token, is_deleted=False) except User.DoesNotExist: pass applicant_name = edit_user.username if edit_user else "" from User.utils import create_approval_with_team_logic team_name = get_team_name_from_responsiblefor(responsiblefor_dict if responsiblefor else original_responsiblefor) content = current_responsiblefor + "在" + ( times or original_times) + "办理立项登记，项目类型：" + original_type + ",合同编号：" + original_ContractNo + "描述：" + ",承办人:" + responsible_desc + ",收费情况：" + (charge or original_charge) + "，申请人：" + applicant_name approval, approvers_order_json, needs_approval = create_approval_with_team_logic( team_name=team_name, approvers=approvers, title=current_responsiblefor + "立项登记重新编辑", content=content, approval_type="立项登记", user_id=pro.id, business_record=pro, today=formatted_date, applicant=applicant_name ) if approval is None and needs_approval: return Response({ 'status': 'error', 'message': build_missing_approvers_message(team_name, approvers), 'code': 1 }, status=status.HTTP_400_BAD_REQUEST) # 记录操作日志 log_operation( request=request, operation_type='UPDATE', module='Business', action='编辑立项登记', target_type='ProjectRegistration', target_id=pro.id, target_name=pro.ContractNo, old_data=old_data, new_data=new_data, remark=f'编辑立项登记：合同编号 {pro.ContractNo}' ) return Response({'message': '编辑成功', 'code': 0}, status=status.HTTP_200_OK) class DeleteProject(APIView): def post(self, request, *args, **kwargs): """ 删除立项登记 :param request: :param args: :param kwargs: :return: """ id = request.data.get('id') if not id: return Response({'status': 'error', 'message': '缺少参数', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) try: pro = ProjectRegistration.objects.get(id=id, is_deleted=False) except ProjectRegistration.DoesNotExist: return Response({'status': 'error', 'message': '立项登记不存在', 'code': 1}, status=status.HTTP_404_NOT_FOUND) # 检查是否已经被案件管理关联 case_exists = Case.objects.filter(project_id=pro.id, is_deleted=False).exists() if case_exists: return Response({'status': 'error', 'message': '该立项已被案件管理关联，无法删除', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) # 记录操作前的数据 old_data = { 'id': pro.id, 'contract_no': pro.ContractNo, 'type': pro.type, 'responsiblefor': pro.responsiblefor, 'client_info': pro.client_info } # 软删除：更新 is_deleted 字段 pro.is_deleted = True pro.save() # 记录操作日志 log_operation( request=request, operation_type='DELETE', module='Business', action='删除立项登记', target_type='ProjectRegistration', target_id=pro.id, target_name=pro.ContractNo, old_data=old_data, remark=f'删除立项登记：合同编号 {pro.ContractNo}' ) return Response({'message': '删除成功', 'code': 0}, status=status.HTTP_200_OK) class BidRegistration(APIView): def post(self, request, *args, **kwargs): """ 投标登记 - 独立创建，不再关联预立案 :param request: :param args: :param kwargs: :return: """ BiddingUnit = request.data.get('BiddingUnit') ProjectName = request.data.get('ProjectName') times = request.data.get('times') BiddingAnnouncement = request.FILES.getlist('BiddingAnnouncement') approvers = request.data.get('approvers') # 审核人列表（可选，多人团队时需要，推荐：用户ID数组如[1,2,3]，兼容：用户名数组） # 兼容旧接口：如果传了 personincharge，转换为 approvers personincharge = request.data.get('personincharge') approvers = normalize_approvers_param(approvers, personincharge) if not all([BiddingUnit, ProjectName, times]): return Response({'status': 'error', 'message': '缺少必填参数', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) import datetime # 获取当前用户信息（用于团队信息及申请人） token = request.META.get('token') team_name = None user = None try: user = User.objects.get(token=token, is_deleted=False) team_name = user.team except User.DoesNotExist: pass bib = Bid.objects.create( BiddingUnit=BiddingUnit, ProjectName=ProjectName, times=times, BiddingAnnouncement=json.dumps(flies(BiddingAnnouncement)), state="审核中", ) today = datetime.datetime.now() formatted_date = today.strftime("%Y-%m-%d") # 利益冲突检索（与立项相同逻辑）：比对预立案、立项、投标三张表 conflict_result = conflict_search(bidding_unit=BiddingUnit, exclude_bid_id=bib.id) conflict_parts = [] if conflict_result['prefiling_conflicts']: conflict_parts.append(f"预立案冲突：{len(conflict_result['prefiling_conflicts'])}条（ID：{','.join([str(r['id']) for r in conflict_result['prefiling_conflicts'][:5]])}{'...' if len(conflict_result['prefiling_conflicts']) > 5 else ''}）") if conflict_result['project_conflicts']: conflict_parts.append(f"立项冲突：{len(conflict_result['project_conflicts'])}条（合同编号：{','.join([r['ContractNo'] for r in conflict_result['project_conflicts'][:3]])}{'...' if len(conflict_result['project_conflicts']) > 3 else ''}）") if conflict_result['bid_conflicts']: conflict_parts.append(f"投标冲突：{len(conflict_result['bid_conflicts'])}条（项目：{','.join([(r.get('ProjectName') or '')[:20] for r in conflict_result['bid_conflicts'][:3]])}{'...' if len(conflict_result['bid_conflicts']) > 3 else ''}）") conflict_text = "；冲突记录：" + "；".join(conflict_parts) if conflict_parts else "" # 使用统一的审核流程函数 from User.utils import create_approval_with_team_logic applicant_name = user.username if user else "" content = f"项目名称：{ProjectName}，申请日期：{times}，招标单位：{BiddingUnit}，申请人：{applicant_name}{conflict_text}" approval, approvers_order_json, needs_approval = create_approval_with_team_logic( team_name=team_name, approvers=approvers, title=ProjectName + "投标登记", content=content, approval_type="投标登记", user_id=bib.id, business_record=bib, today=formatted_date, applicant=applicant_name ) # 如果返回None且需要审核，说明缺少审核人 if approval is None and needs_approval: return Response({ 'status': 'error', 'message': build_missing_approvers_message(team_name, approvers), 'code': 1 }, status=status.HTTP_400_BAD_REQUEST) return Response({'message': '登记成功', 'code': 0}, status=status.HTTP_200_OK) class BidDetail(APIView): def post(self, request, *args, **kwargs): """ 投标登记展示（列表+搜索） 支持搜索：project_name 项目名称、client_username 招标单位名字、times/end_time 日期范围、keyword 关键词。 """ page = request.data.get('page') per_page = request.data.get('per_page') times = request.data.get('times') end_time = request.data.get('end_time') # 项目名称：兼容 project_name / projectName project_name = (request.data.get('project_name') or request.data.get('projectName') or '').strip() # 招标单位名字：变量名 client_username，对应库表字段 BiddingUnit client_username = (request.data.get('client_username') or '').strip() # 关键词：同时匹配项目名称和招标单位 keyword = (request.data.get('keyword') or request.data.get('search') or '').strip() if not all([page, per_page]): return Response({'status': 'error', 'message': '缺少参数 page 或 per_page', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) Q_obj = Q(is_deleted=False) if times and end_time: Q_obj &= Q(times__gte=times) & Q(times__lte=end_time) if project_name: Q_obj &= Q(ProjectName__icontains=project_name) if client_username: Q_obj &= Q(BiddingUnit__icontains=client_username) if keyword: Q_obj &= (Q(ProjectName__icontains=keyword) | Q(BiddingUnit__icontains=keyword)) qs = Bid.objects.filter(Q_obj).order_by('-id') total = qs.count() paginator = Paginator(qs, per_page) try: user_agents_page = paginator.page(int(page)) except PageNotAnInteger: user_agents_page = paginator.page(1) except EmptyPage: user_agents_page = paginator.page(paginator.num_pages) data = [] for info in user_agents_page.object_list: data.append({ "id": info.id, "times": info.times, "BiddingUnit": info.BiddingUnit, "ProjectName": info.ProjectName, "BiddingAnnouncement": info.BiddingAnnouncement, "state": info.state, }) return Response({'message': '展示成功', "total": total, 'data': data, 'code': 0}, status=status.HTTP_200_OK) class EditBid(APIView): def post(self, request, *args, **kwargs): """ 编辑投标登记 :param request: :param args: :param kwargs: :return: """ id = request.data.get('id') BiddingUnit = request.data.get('BiddingUnit') ProjectName = request.data.get('ProjectName') times = request.data.get('times') BiddingAnnouncement = request.FILES.getlist('BiddingAnnouncement') approvers = request.data.get('approvers') personincharge = request.data.get('personincharge') approvers = normalize_approvers_param(approvers, personincharge) if not id: return Response({'status': 'error', 'message': '缺少参数', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) try: bid = Bid.objects.get(id=id, is_deleted=False) except Bid.DoesNotExist: return Response({'status': 'error', 'message': '投标登记不存在', 'code': 1}, status=status.HTTP_404_NOT_FOUND) if BiddingUnit: bid.BiddingUnit = BiddingUnit bid.save(update_fields=['BiddingUnit']) if ProjectName: bid.ProjectName = ProjectName bid.save(update_fields=['ProjectName']) if times: bid.times = times bid.save(update_fields=['times']) if BiddingAnnouncement: bid.BiddingAnnouncement = json.dumps(flies(BiddingAnnouncement)) bid.save(update_fields=['BiddingAnnouncement']) if approvers: import datetime today = datetime.datetime.now() formatted_date = today.strftime("%Y-%m-%d") team_name = None edit_user = None token = request.META.get('token') if token: try: edit_user = User.objects.get(token=token, is_deleted=False) team_name = edit_user.team except User.DoesNotExist: team_name = None from User.utils import create_approval_with_team_logic applicant_name = edit_user.username if edit_user else "" content_edit = f"项目名称：{bid.ProjectName}，申请日期：{times or bid.times}，申请人：{applicant_name}" approval, approvers_order_json, needs_approval = create_approval_with_team_logic( team_name=team_name, approvers=approvers, title=bid.ProjectName + "投标登记重新编辑", content=content_edit, approval_type="投标登记", user_id=bid.id, business_record=bid, today=formatted_date, applicant=applicant_name ) if approval is None and needs_approval: return Response({ 'status': 'error', 'message': build_missing_approvers_message(team_name, approvers), 'code': 1 }, status=status.HTTP_400_BAD_REQUEST) return Response({'message': '编辑成功', 'code': 0}, status=status.HTTP_200_OK) class DeleteBid(APIView): def post(self, request, *args, **kwargs): """ 删除投标登记 :param request: :param args: :param kwargs: :return: """ id = request.data.get('id') if not id: return Response({'status': 'error', 'message': '缺少参数', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) try: bid = Bid.objects.get(id=id, is_deleted=False) except Bid.DoesNotExist: return Response({'status': 'error', 'message': '投标登记不存在', 'code': 1}, status=status.HTTP_404_NOT_FOUND) # 记录操作前的数据 old_data = { 'id': bid.id, 'project_name': bid.ProjectName, 'times': bid.times } # 软删除：更新 is_deleted 字段 bid.is_deleted = True bid.save() # 记录操作日志 log_operation( request=request, operation_type='DELETE', module='Business', action='删除投标登记', target_type='Bid', target_id=bid.id, target_name=bid.ProjectName, old_data=old_data, remark=f'删除投标登记：{bid.ProjectName}' ) return Response({'message': '删除成功', 'code': 0}, status=status.HTTP_200_OK) class caseManagement(APIView): def post(self, request, *args, **kwargs): """ 补充案件资料（立项审批通过即成案件，本接口用于创建/补充案件材料） - 立项审批通过后，用本接口补充合同返还、结案申请等资料。 - 首次调用（该立项尚无案件）：创建案件，立案时间 = 立项审批通过时间（无则用请求 times 或当前日期）。 - 再次调用（该立项已有案件）：仅更新/补充材料，不修改立案时间。 :param request: :param args: :param kwargs: :return: """ project_id = request.data.get('project_id') # 立项登记ID times = request.data.get('times') # 立案时间（仅当无审批通过时间时使用） Contractreturn = request.FILES.getlist('Contractreturn') Closingapplication = request.FILES.getlist('Closingapplication') invoice_status = request.data.get('invoice_status') # 已开票 paymentcollection = request.data.get('paymentcollection') tag_ids = request.data.get('tag_ids') # 标签ID列表（数组或逗号分隔的字符串） approvers = request.data.get('approvers') personincharge = request.data.get('personincharge') approvers = normalize_approvers_param(approvers, personincharge) # 检查是否已立项 if not project_id: return Response({'status': 'error', 'message': '缺少参数project_id（立项登记ID）', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) # 使用事务和行级锁防止并发重复创建 try: with transaction.atomic(): # 使用 select_for_update 锁定立项登记记录，防止并发问题 project_registration = ProjectRegistration.objects.select_for_update().get(id=project_id, is_deleted=False) # 再次检查是否已经存在案件（在锁内检查，防止并发重复创建） case = Case.objects.filter(project_id=project_id, is_deleted=False).first() if not case: # 立案时间：优先取立项审批通过时间，否则用请求 times 或当前日期 project_approval = Approval.objects.filter( type='立项登记', user_id=str(project_id), state='已通过', is_deleted=False ).order_by('-id').first() if project_approval and getattr(project_approval, 'completeTiem', None): filing_time = project_approval.completeTiem.strftime('%Y-%m-%d') else: filing_time = times if times else datetime.now().strftime('%Y-%m-%d') # 处理材料：上传后存储URL列表（代理合同字段已从案件管理移除，创建时存空） contract_return_list = flies(Contractreturn) closing_application_list = flies(Closingapplication) project_contract_no = project_registration.ContractNo if project_registration else None project_type = project_registration.type if project_registration else None project_client_name = project_registration.client_info if project_registration else None project_party_name = project_registration.party_info if project_registration else None project_description = project_registration.description if project_registration else None project_responsiblefor = project_registration.responsiblefor if project_registration else None project_charge = project_registration.charge if project_registration else None # 创建新案件（立案时间 = 审批通过时间） case_id = Case.objects.create( project_id=project_id, contract_no=project_contract_no, project_type=project_type, client_name=project_client_name, party_name=project_party_name, project_description=project_description, responsiblefor=project_responsiblefor, charge=project_charge, times=filing_time, AgencyContract=json.dumps([], ensure_ascii=False), # 代理合同已从案件管理移除，库字段保留 Contractreturn=json.dumps(contract_return_list, ensure_ascii=False), Closingapplication=json.dumps(closing_application_list, ensure_ascii=False), ChangeRequest="", invoice_status=normalize_amount_value(invoice_status), paymentcollection=normalize_amount_value(paymentcollection), state="审核中" ) from User.utils import create_approval_with_team_logic team_name = get_team_name_from_responsiblefor(project_registration.responsiblefor) approval, approvers_order_json, needs_approval = create_approval_with_team_logic( team_name=team_name, approvers=approvers, title="案件管理信息提交", content=build_case_approval_content(project_registration, filing_time), approval_type="案件管理", user_id=case_id.id, business_record=case_id, today=filing_time ) if approval is None and needs_approval: return Response({ 'status': 'error', 'message': build_missing_approvers_message(team_name, approvers), 'code': 1 }, status=status.HTTP_400_BAD_REQUEST) # 处理标签关联 if tag_ids: try: # 支持数组或逗号分隔的字符串 if isinstance(tag_ids, str): if ',' in tag_ids: tag_id_list = [int(x.strip()) for x in tag_ids.split(',') if x.strip()] else: tag_id_list = [int(tag_ids)] elif isinstance(tag_ids, list): tag_id_list = [int(x) for x in tag_ids if x] else: tag_id_list = [] # 验证标签是否存在 valid_tags = CaseTag.objects.filter(id__in=tag_id_list, is_deleted=False) case_id.tags.set(valid_tags) except (ValueError, TypeError) as e: # 标签ID格式错误，但不影响案件创建，只记录警告 pass # 创建成功，直接返回 return Response({'message': '创建成功', 'code': 0}, status=status.HTTP_200_OK) # 如果已存在，事务结束，在事务外处理更新逻辑 except ProjectRegistration.DoesNotExist: return Response({'status': 'error', 'message': '该立项登记不存在或已删除，请先完成立项登记', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) # 如果代码执行到这里，说明案件已存在，需要执行更新逻辑 # 注意：这里不需要再次锁定，因为更新操作不会造成重复创建问题 case = Case.objects.filter(project_id=project_id, is_deleted=False).first() if not case: # 这种情况理论上不应该发生，因为事务内已检查，但为了安全起见 return Response({'status': 'error', 'message': '案件不存在', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) # 执行更新逻辑（代理合同已从案件管理移除，不再接收或更新） update_fields_list = [] if times: case.times = times update_fields_list.append('times') if Contractreturn: case.Contractreturn = json.dumps(flies(Contractreturn), ensure_ascii=False) update_fields_list.append('Contractreturn') if Closingapplication: case.Closingapplication = json.dumps(flies(Closingapplication), ensure_ascii=False) update_fields_list.append('Closingapplication') if paymentcollection is not None: case.paymentcollection = normalize_amount_value(paymentcollection) update_fields_list.append('paymentcollection') if invoice_status is not None: case.invoice_status = normalize_amount_value(invoice_status) update_fields_list.append('invoice_status') if update_fields_list: case.save(update_fields=update_fields_list) return Response({'message': '编辑成功', 'code': 0}, status=status.HTTP_200_OK) class CaseAttachmentUpload(APIView): def post(self, request, *args, **kwargs): """ 案件材料上传（合同返还/结案申请） 通过 type 指定上传类型，返回文件URL列表 """ upload_type = request.data.get('type') files = request.FILES.getlist('file') or request.FILES.getlist('files') allowed_types = ["Contractreturn", "Closingapplication"] if upload_type not in allowed_types: return Response({ 'status': 'error', 'message': f'type参数错误，支持类型：{", ".join(allowed_types)}', 'code': 1 }, status=status.HTTP_400_BAD_REQUEST) if not files: return Response({'status': 'error', 'message': '请上传文件', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) file_urls = flies(files) return Response({ 'message': '上传成功', 'code': 0, 'data': { 'type': upload_type, 'files': file_urls } }, status=status.HTTP_200_OK) class CaseAttachmentUpdate(APIView): def post(self, request, *args, **kwargs): """ 案件材料更新（合同返还/结案申请） 通过 type 指定更新哪一种材料 """ case_id = request.data.get('case_id') upload_type = request.data.get('type') files = request.FILES.getlist('file') or request.FILES.getlist('files') Contractreturn = request.data.get('Contractreturn') approvers = request.data.get('approvers') personincharge = request.data.get('personincharge') approvers = normalize_approvers_param(approvers, personincharge) if not case_id: return Response({'status': 'error', 'message': '缺少参数case_id', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) allowed_types = ["Contractreturn", "Closingapplication","AgencyContract"] if upload_type not in allowed_types: return Response({ 'status': 'error', 'message': f'type参数错误，支持类型：{", ".join(allowed_types)}', 'code': 1 }, status=status.HTTP_400_BAD_REQUEST) # if not files: # return Response({'status': 'error', 'message': '请上传文件', 'code': 1}, # status=status.HTTP_400_BAD_REQUEST) try: case = Case.objects.get(id=case_id, is_deleted=False) except Case.DoesNotExist: return Response({'status': 'error', 'message': '案件不存在', 'code': 1}, status=status.HTTP_404_NOT_FOUND) file_urls = flies(files) update_fields = [] if upload_type == "Contractreturn": case.Contractreturn = Contractreturn update_fields = ['Contractreturn'] elif upload_type == "Closingapplication": # 结案申请需要审批通过后才更新 Case.Closingapplication 字段 # 这里不直接更新，文件URL保存在 Schedule.remark 中，审批通过后再更新到 Case pass elif upload_type == "AgencyContract": case.AgencyContract = json.dumps(file_urls, ensure_ascii=False) update_fields = ['AgencyContract'] if update_fields: case.save(update_fields=update_fields) # 结案申请：加入审批流程（独立于“案件管理”审批，避免覆盖 Case.approvers_order / Case.state） if upload_type == "Closingapplication": # 审批通过后才更新 Case.Closingapplication 字段 try: token = request.META.get('token') submitter = User.objects.get(token=token, is_deleted=False) except Exception: submitter = None # 以 Schedule 作为承载对象，复用统一审批流 try: from datetime import date today = date.today().strftime("%Y-%m-%d") contract_no = case.contract_no or "" title = f"结案申请（合同号：{contract_no or ('案件#' + str(case.id))}）" remark = json.dumps({ "case_id": case.id, "contract_no": contract_no, "closing_application_files": file_urls }, ensure_ascii=False) schedule = Schedule.objects.create( title=title, tiems=today, end_time=today, remark=remark, state="未完成", submit=submitter.username if submitter else None ) from User.utils import create_approval_with_team_logic team_name = submitter.team if submitter else None content = f"{submitter.username if submitter else '系统'}提交了结案申请，合同号：{contract_no or ('案件#' + str(case.id))}" approval, approvers_order_json, needs_approval = create_approval_with_team_logic( team_name=team_name, approvers=approvers, title="结案申请审批", content=content, approval_type="结案申请", user_id=schedule.id, business_record=schedule, today=today, applicant=submitter.username if submitter else None # 传入申请人，用于"待查看"流程 ) if approval is None and needs_approval: return Response({ 'status': 'error', 'message': build_missing_approvers_message(team_name, approvers), 'code': 1 }, status=status.HTTP_400_BAD_REQUEST) except Exception as e: # 不影响材料更新主流程，但记录错误信息 import logging logger = logging.getLogger(__name__) logger.error(f"结案申请审批创建失败(case_id={case.id}): {str(e)}") return Response({ 'message': '更新成功', 'code': 0, 'data': { 'case_id': case.id, 'type': upload_type, 'files': file_urls } }, status=status.HTTP_200_OK) class caseManagementDetail(APIView): def post(self, request, *args, **kwargs): """ 案件管理版块展示 搜索支持按标签：传 tags（标签名称，模糊匹配）或 tag_ids（标签ID列表/逗号分隔，匹配拥有任一标签的案件），可同时使用。 :param request: page, per_page 必填；可选 times, end_time, type, contract_no, party_name, client_name, tags, tag_ids :return: """ page = request.data.get('page') per_page = request.data.get('per_page') times = request.data.get('times') end_time = request.data.get('end_time') type = request.data.get('type') serialnumber = request.data.get('contract_no') party_name = request.data.get('party_name') client_name = request.data.get('client_name') tags = request.data.get('tags') # 标签：传字符串为名称模糊匹配，传数组 [2,3] 为标签ID列表 tag_ids = request.data.get('tag_ids') # 标签ID列表（与 tags 传 ID 时等效） if not all([page, per_page]): return Response({'status': 'error', 'message': '缺少参数', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) Q_obj = Q() if times and end_time: Q_obj &= Q(times__gte=times) & Q(times__lte=end_time) if type: por_id = ProjectRegistration.objects.filter(type=type, is_deleted=False).values_list('id', flat=True) Q_obj &= Q(project_id__in=por_id) if serialnumber: Q_obj &= Q(contract_no__icontains=serialnumber) if party_name: Q_obj &= Q(party_name__icontains=party_name) if client_name: Q_obj &= Q(client_name__icontains=client_name) # 按标签搜索：tags 可为字符串(名称模糊)、数组(标签ID)、或 form 传来的字符串 "[2]"；tag_ids 为标签ID列表；满足任一标签即匹配 tag_id_list = [] if tags is not None and tags != '': if isinstance(tags, list): try: tag_id_list.extend([int(x) for x in tags if x is not None and str(x).strip() != '']) except (ValueError, TypeError): pass elif isinstance(tags, str): tags_stripped = tags.strip() # 前端 form-data 可能把 [2] 或 [2,3] 当成字符串传，先尝试按 JSON 数组解析 if tags_stripped.startswith('[') and tags_stripped.endswith(']'): try: parsed = json.loads(tags_stripped) if isinstance(parsed, list): tag_id_list.extend([int(x) for x in parsed if x is not None and str(x).strip() != '']) except (ValueError, TypeError, json.JSONDecodeError): pass if not tag_id_list: tag_id_list.extend( CaseTag.objects.filter(name__icontains=tags, is_deleted=False).values_list('id', flat=True) ) if tag_ids: try: if isinstance(tag_ids, str): tag_id_list.extend([int(x.strip()) for x in tag_ids.split(',') if x.strip()]) elif isinstance(tag_ids, list): tag_id_list.extend([int(x) for x in tag_ids if x is not None and str(x).strip() != '']) except (ValueError, TypeError): pass tag_id_list = list(set(tag_id_list)) if tag_id_list: Q_obj &= Q(tags__in=tag_id_list) pre = Case.objects.filter(Q_obj, is_deleted=False).order_by('-id') if tag_id_list: pre = pre.distinct() total = len(pre) paginator = Paginator(pre, per_page) try: user_agents_page = paginator.page(page) except PageNotAnInteger: user_agents_page = paginator.page(1) except EmptyPage: user_agents_page = paginator.page(paginator.num_pages) # 导入财务模型，用于统计开票金额和收入确认金额 from finance.models import Invoice as FinanceInvoice, Income # 收集所有合同号，用于批量查询财务数据 case_list = list(user_agents_page.object_list) contract_nos = [] case_contract_map = {} # 案件ID -> 合同号的映射 for info in case_list: pro = None if info.project_id: try: pro = ProjectRegistration.objects.get(id=info.project_id, is_deleted=False) except ProjectRegistration.DoesNotExist: pro = None contract_no = info.contract_no or (pro.ContractNo if pro else None) if contract_no: contract_nos.append(contract_no) case_contract_map[info.id] = contract_no # 批量查询开票金额（按合同号统计） invoice_amounts = {} # 合同号 -> 总开票金额 if contract_nos: # 查询所有未删除的开票记录（一次性查询，避免N+1问题） invoices = FinanceInvoice.objects.filter( ContractNo__in=contract_nos, is_deleted=False ).values('ContractNo', 'amount') # 计算每个合同号的总开票金额（需要解析金额字符串） for invoice in invoices: contract_no = invoice['ContractNo'] amount_str = normalize_amount_value(invoice['amount']) try: amount = float(amount_str) except (ValueError, TypeError): amount = 0.0 if contract_no in invoice_amounts: invoice_amounts[contract_no] = str(float(invoice_amounts[contract_no]) + amount) else: invoice_amounts[contract_no] = str(amount) # 批量查询收入确认金额（按合同号统计，只统计审核通过的） income_amounts = {} # 合同号 -> 总收入确认金额 if contract_nos: # 查询所有未删除且审核通过的收入确认记录（一次性查询，避免N+1问题） # 只统计 state="已通过" 的记录 incomes = Income.objects.filter( ContractNo__in=contract_nos, is_deleted=False, state="已通过" # 只统计审核通过的收入确认 ).values('ContractNo', 'amount') # 计算每个合同号的总收入确认金额 for income in incomes: contract_no = income['ContractNo'] amount_str = normalize_amount_value(income['amount']) try: amount = float(amount_str) except (ValueError, TypeError): amount = 0.0 if contract_no in income_amounts: income_amounts[contract_no] = str(float(income_amounts[contract_no]) + amount) else: income_amounts[contract_no] = str(amount) data = [] for info in case_list: pro = None if info.project_id: try: pro = ProjectRegistration.objects.get(id=info.project_id, is_deleted=False) except ProjectRegistration.DoesNotExist: pro = None contract_no = info.contract_no or (pro.ContractNo if pro else None) project_type = info.project_type or (pro.type if pro else None) client_name = info.client_name or (pro.client_info if pro else None) party_name = info.party_name or (pro.party_info if pro else None) project_description = info.project_description or (pro.description if pro else None) responsiblefor_raw = info.responsiblefor or (pro.responsiblefor if pro else None) charge = info.charge or (pro.charge if pro else None) # 解析负责人信息（JSON字符串转字典） try: responsiblefor_dict = json.loads(responsiblefor_raw) if responsiblefor_raw else {} except (json.JSONDecodeError, TypeError): responsiblefor_dict = responsiblefor_raw if responsiblefor_raw else {} # 解析结案申请（JSON字符串转列表）；代理合同已从案件管理移除，不再返回 try: closing_application_list = json.loads(info.Closingapplication) if info.Closingapplication else [] except (json.JSONDecodeError, TypeError): closing_application_list = [] if not closing_application_list: closing_application_list = "" contractreturn_str = info.Contractreturn or "" if contractreturn_str.strip() in ["[]", ""]: contractreturn_str = "" closing_application_str = info.Closingapplication or "" if closing_application_str.strip() in ["[]", ""]: closing_application_str = "" # 从财务数据动态获取开票金额和收入确认金额 invoice_status_value = "0" paymentcollection_value = "0" if contract_no: # 从财务数据获取开票金额 invoice_status_value = invoice_amounts.get(contract_no, "0") # 从财务数据获取收入确认金额 paymentcollection_value = income_amounts.get(contract_no, "0") else: # 如果没有合同号，使用Case表中的旧数据（向后兼容） invoice_status_value = normalize_amount_value(info.invoice_status) paymentcollection_value = normalize_amount_value(info.paymentcollection) # 获取案件标签 tags = info.tags.filter(is_deleted=False) tag_list = [] for tag in tags: tag_list.append({ 'id': tag.id, 'name': tag.name, 'color': tag.color }) # 如果没有标签，返回空字符串而不是空数组 tags_value = tag_list if tag_list else "" tag_ids_value = [tag['id'] for tag in tag_list] if tag_list else "" # 如果没有负责人信息，返回空字符串而不是空字典 # 检查 responsiblefor_dict 是否为有效的非空字典 if responsiblefor_dict and isinstance(responsiblefor_dict, dict) and len(responsiblefor_dict) > 0: responsiblefor_value = responsiblefor_dict else: responsiblefor_value = "" data.append({ "id": info.id, "ContractNo": contract_no or "", # 合同编号 "type": project_type or "", # 项目类型 "client_info": client_name or "", # 客户名称（委托人身份信息） "party_info": party_name or "", # 相对方名称 "description": project_description or "", # 项目简述（没有数据时返回空字符串） "responsiblefor": responsiblefor_value, # 负责人信息（字典格式，没有数据时返回空字符串） "charge": charge or "", # 收费情况（没有数据时返回空字符串） 'times': info.times or "", # 立案时间（没有数据时返回空字符串） "Contractreturn": contractreturn_str, # 合同返还（没有数据时返回空字符串） "Closingapplication": closing_application_str, # 结案申请（JSON字符串，没有文件时返回空字符串） "ClosingapplicationUrls": closing_application_list if closing_application_list else "", # 结案申请（URL列表，没有文件时返回空字符串） "ChangeRequest": info.ChangeRequest or "", # 变更申请（兼容旧字段，没有数据时返回空字符串） "ChangeItem": info.ChangeItem or "", # 变更事项（没有数据时返回空字符串） "ChangeReason": info.ChangeReason or "", # 变更原因（没有数据时返回空字符串） "ChangeAgreement": info.ChangeAgreement or "", # 变更协议（没有数据时返回空字符串） "invoice_status": invoice_status_value or "0", # 已开票（从财务数据动态计算，没有数据时返回"0"） "paymentcollection": paymentcollection_value or "0", # 已收款（从财务数据动态计算，没有数据时返回"0"） "state": info.state or "", # 状态（没有数据时返回空字符串） "project_id": info.project_id if info.project_id is not None else "", # 项目ID（没有数据时返回空字符串） "tags": tags_value, # 标签列表（没有数据时返回空字符串） "tag_ids": tag_ids_value, # 标签ID列表（没有数据时返回空字符串） "AgencyContract":info.AgencyContract }) return Response({'message': '展示成功', "total": total, 'data': data, 'code': 0}, status=status.HTTP_200_OK) class EditCase(APIView): def post(self, request, *args, **kwargs): """ 编辑案件管理 :param request: :param args: :param kwargs: :return: """ id = request.data.get('id') times = request.data.get('times') Contractreturn = request.FILES.getlist('Contractreturn') Closingapplication = request.FILES.getlist('Closingapplication') invoice_status = request.data.get('invoice_status') # 已开票 paymentcollection = request.data.get('paymentcollection') tag_ids = request.data.get('tag_ids') # 标签ID列表（数组或逗号分隔的字符串） approvers = request.data.get('approvers') personincharge = request.data.get('personincharge') approvers = normalize_approvers_param(approvers, personincharge) # 检查不可修改的参数（前端不会传入，但作为安全措施进行检查） forbidden_params = [] if 'project_id' in request.data: forbidden_params.append('project_id') if forbidden_params: return Response({ 'status': 'error', 'message': f'以下参数不允许修改: {", ".join(forbidden_params)}', 'code': 1 }, status=status.HTTP_400_BAD_REQUEST) if not id: return Response({'status': 'error', 'message': '缺少参数id', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) try: case = Case.objects.get(id=id, is_deleted=False) except Case.DoesNotExist: return Response({'status': 'error', 'message': '案件管理不存在', 'code': 1}, status=status.HTTP_404_NOT_FOUND) update_fields_list = [] if times: case.times = times update_fields_list.append('times') if Contractreturn: case.Contractreturn = json.dumps(flies(Contractreturn), ensure_ascii=False) update_fields_list.append('Contractreturn') if Closingapplication: case.Closingapplication = json.dumps(flies(Closingapplication), ensure_ascii=False) update_fields_list.append('Closingapplication') if paymentcollection is not None: case.paymentcollection = normalize_amount_value(paymentcollection) update_fields_list.append('paymentcollection') if invoice_status is not None: case.invoice_status = normalize_amount_value(invoice_status) update_fields_list.append('invoice_status') if update_fields_list: case.save(update_fields=update_fields_list) # 处理标签更新 if tag_ids is not None: try: # 支持数组或逗号分隔的字符串 if isinstance(tag_ids, str): if tag_ids.strip() == '': tag_id_list = [] elif ',' in tag_ids: tag_id_list = [int(x.strip()) for x in tag_ids.split(',') if x.strip()] else: tag_id_list = [int(tag_ids)] elif isinstance(tag_ids, list): tag_id_list = [int(x) for x in tag_ids if x] else: tag_id_list = [] # 验证标签是否存在并更新关联 valid_tags = CaseTag.objects.filter(id__in=tag_id_list, is_deleted=False) case.tags.set(valid_tags) except (ValueError, TypeError) as e: # 标签ID格式错误，但不影响案件更新 pass return Response({'message': '编辑成功', 'code': 0}, status=status.HTTP_200_OK) class DeleteCase(APIView): def post(self, request, *args, **kwargs): """ 删除案件管理 :param request: :param args: :param kwargs: :return: """ id = request.data.get('id') if not id: return Response({'status': 'error', 'message': '缺少参数', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) try: case = Case.objects.get(id=id, is_deleted=False) except Case.DoesNotExist: return Response({'status': 'error', 'message': '案件管理不存在', 'code': 1}, status=status.HTTP_404_NOT_FOUND) # 记录操作前的数据 old_data = { 'id': case.id, 'times': case.times, 'state': case.state } # 软删除：更新 is_deleted 字段 case.is_deleted = True case.save() # 记录操作日志 log_operation( request=request, operation_type='DELETE', module='Business', action='删除案件管理', target_type='Case', target_id=case.id, target_name=f'案件-{case.id}', old_data=old_data, remark=f'删除案件管理：ID {case.id}' ) return Response({'message': '删除成功', 'code': 0}, status=status.HTTP_200_OK) class Uploadinvoice(APIView): def post(self, request, *args, **kwargs): """案件管理发票 - 关联案件""" case_id = request.data.get('case_id') # 案件ID amount = request.data.get('amount') file = request.FILES.getlist('file') if not case_id: return Response({'status': 'error', 'message': '缺少参数case_id', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) # 检查案件是否存在 try: case = Case.objects.get(id=case_id, is_deleted=False) except Case.DoesNotExist: return Response({'status': 'error', 'message': '案件不存在', 'code': 1}, status=status.HTTP_404_NOT_FOUND) Invoice.objects.create( case_id=case_id, amount=amount, file=json.dumps(flies(file)), ) return Response({'message': '上传成功', 'code': 0}, status=status.HTTP_200_OK) class InvoiceDetail(APIView): def post(self, request, *args, **kwargs): """ 发票展示 - 关联案件 :param request: :param args: :param kwargs: :return: """ case_id = request.data.get('case_id') # 案件ID if not case_id: return Response({'status': 'error', 'message': '缺少参数case_id', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) invoices = Invoice.objects.filter(case_id=case_id, is_deleted=False) data = [] for invoice in invoices: data.append({ "id": invoice.id, "amount": invoice.amount, "file": invoice.file, }) return Response({'message': '展示成功', 'data': data, 'code': 0}, status=status.HTTP_200_OK) class Log(APIView): def post(self, request, *args, **kwargs): """ 案件日志 - 关联案件 """ token = request.META.get('token') # 明确拒绝 user_id 参数（此接口使用案件ID，不再使用预立案ID） if 'user_id' in request.data: return Response({'status': 'error', 'message': '此接口不需要 user_id 参数，请使用 case_id（案件ID）', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) case_id = request.data.get('case_id') # 案件ID content = request.data.get('content') file = request.FILES.getlist('file') if not all([case_id, content]): return Response({'status': 'error', 'message': '缺少参数case_id或content', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) # 检查案件是否存在 try: case = Case.objects.get(id=case_id, is_deleted=False) except Case.DoesNotExist: return Response({'status': 'error', 'message': '案件不存在', 'code': 1}, status=status.HTTP_404_NOT_FOUND) user = User.objects.get(token=token, is_deleted=False) now = datetime.now() date_str = now.strftime('%Y-%m-%d') Caselog.objects.create( case_id=case_id, content=content, file=json.dumps(flies(file)), times=date_str, username=user.username, ) return Response({'message': '添加成功', 'code': 0}, status=status.HTTP_200_OK) class LogDetail(APIView): def post(self, request, *args, **kwargs): """ 案件日志展示（按案件ID查询） 必填参数：case_id（案件ID）、page、per_page """ page = request.data.get('page') per_page = request.data.get('per_page') case_id = request.data.get('case_id') # 案件ID（必填） if not all([page, per_page]): return Response({'status': 'error', 'message': '缺少参数page或per_page', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) if not case_id: return Response({'status': 'error', 'message': '缺少参数case_id（案件ID）', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) # 根据案件ID过滤日志 pre = Caselog.objects.filter(is_deleted=False, case_id=case_id) total = pre.count() paginator = Paginator(pre, per_page) try: user_agents_page = paginator.page(page) except PageNotAnInteger: user_agents_page = paginator.page(1) except EmptyPage: user_agents_page = paginator.page(paginator.num_pages) data = [] for info in user_agents_page.object_list: data.append({ "id": info.id, "case_id": info.case_id if info.case else None, # 案件ID "content": info.content, # 日志内容 "times": info.times, # 时间 "username": info.username, # 提交人（保留兼容性） "recorder": info.username, # 记录人 "file": info.file, # 文件 }) return Response({'message': '展示成功', "total": total, 'data': data, 'code': 0}, status=status.HTTP_200_OK) class accumulate(APIView): def post(self, request, *args, **kwargs): """ 累加 - 关联案件 :param request: :param args: :param kwargs: :return: """ case_id = request.data.get('case_id') # 案件ID paymentcollection = request.data.get('paymentcollection') if not case_id: return Response({'status': 'error', 'message': '缺少参数case_id', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) try: case = Case.objects.get(id=case_id, is_deleted=False) except Case.DoesNotExist: return Response({'status': 'error', 'message': '案件不存在', 'code': 1}, status=status.HTTP_404_NOT_FOUND) current_amount_str = normalize_amount_value(case.paymentcollection) add_amount_str = normalize_amount_value(paymentcollection) try: current_amount = Decimal(current_amount_str) except InvalidOperation: current_amount = Decimal("0") try: add_amount = Decimal(add_amount_str) except InvalidOperation: add_amount = Decimal("0") case.paymentcollection = str(current_amount + add_amount) case.save(update_fields=['paymentcollection']) return Response({'message': '成功', 'code': 0}, status=status.HTTP_200_OK) class preFilingLinkedCases(APIView): def post(self, request, *args, **kwargs): """ 立项登记列表接口（用于新增案件） 权限：管理员可见全部；承办人仅可见自己承办的立项。 返回可以用于新增案件的立项登记列表，排除已有案件的立项登记 :param request: :param args: :param kwargs: :return: """ pre_qs, err = _get_project_registration_queryset_by_permission(request) if err is not None: return err case_project_ids = Case.objects.filter(is_deleted=False).values_list('project_id', flat=True) projects = pre_qs.exclude(id__in=case_project_ids) data = [] for project in projects: data.append({ "id": project.id, "ContractNo": project.ContractNo, "type": project.type, "client_info": project.client_info, "party_info": project.party_info, "description": project.description, }) return Response({'message': '展示成功', 'data': data, 'code': 0}, status=status.HTTP_200_OK) class ProjectDropdownList(APIView): """获取成功立项的下拉列表接口""" def post(self, request, *args, **kwargs): """ 获取已通过审核的立项登记列表（用于下拉选择） 权限：管理员可见全部；承办人仅可见自己承办的立项。 返回成功立项的数据，格式简洁，适合下拉列表使用 :param request: :param args: :param kwargs: :return: """ # 权限过滤：管理员全部，承办人只看自己承办的 pre_qs, err = _get_project_registration_queryset_by_permission(request) if err is not None: return err # 已通过审核的立项 projects = pre_qs.filter(state="已通过").order_by('-id') # 可选参数：是否排除已有案件的立项 exclude_has_case = request.data.get('exclude_has_case', False) if exclude_has_case: case_project_ids = Case.objects.filter(is_deleted=False).values_list('project_id', flat=True) projects = projects.exclude(id__in=case_project_ids) data = [] import json for project in projects: # 解析承办人信息（原 responsible_person 即承办人） responsible_person = "" try: responsiblefor_dict = json.loads(project.responsiblefor) if project.responsiblefor else {} if isinstance(responsiblefor_dict, dict): responsible_person = responsiblefor_dict.get('responsible_person', '') except (json.JSONDecodeError, TypeError): pass display_text = f"{project.ContractNo}" if project.type: display_text += f" - {project.type}" if responsible_person: display_text += f" ({responsible_person})" data.append({ "id": project.id, "value": project.id, "label": display_text, "ContractNo": project.ContractNo, "type": project.type, "client_info": project.client_info, "party_info": project.party_info, "description": project.description, "responsible_person": responsible_person, # 承办人（保留字段名兼容） "times": project.times, }) return Response({ 'message': '查询成功', 'data': data, 'total': len(data), 'code': 0 }, status=status.HTTP_200_OK) class CaseDropdownList(APIView): """获取案件的下拉列表接口""" def post(self, request, *args, **kwargs): """ 获取案件列表（用于下拉选择） 返回案件数据，格式简洁，适合下拉列表使用。 可选按标签筛选：传 tags（字符串为名称模糊，数组如 [2,3] 为标签ID）或 tag_ids，匹配拥有任一标签的案件。 :param request: 可选 state, tags, tag_ids :return: """ state_filter = request.data.get('state', None) tags = request.data.get('tags') # 字符串=名称模糊，数组=标签ID如 [2,3] tag_ids = request.data.get('tag_ids') Q_obj = Q(is_deleted=False) if state_filter: Q_obj &= Q(state=state_filter) tag_id_list = [] if tags is not None and tags != '': if isinstance(tags, list): try: tag_id_list.extend([int(x) for x in tags if x is not None and str(x).strip() != '']) except (ValueError, TypeError): pass elif isinstance(tags, str): tags_stripped = tags.strip() if tags_stripped.startswith('[') and tags_stripped.endswith(']'): try: parsed = json.loads(tags_stripped) if isinstance(parsed, list): tag_id_list.extend([int(x) for x in parsed if x is not None and str(x).strip() != '']) except (ValueError, TypeError, json.JSONDecodeError): pass if not tag_id_list: tag_id_list.extend( CaseTag.objects.filter(name__icontains=tags, is_deleted=False).values_list('id', flat=True) ) if tag_ids: try: if isinstance(tag_ids, str): tag_id_list.extend([int(x.strip()) for x in tag_ids.split(',') if x.strip()]) elif isinstance(tag_ids, list): tag_id_list.extend([int(x) for x in tag_ids if x is not None and str(x).strip() != '']) except (ValueError, TypeError): pass tag_id_list = list(set(tag_id_list)) if tag_id_list: Q_obj &= Q(tags__in=tag_id_list) cases = Case.objects.filter(Q_obj).order_by('-id') if tag_id_list: cases = cases.distinct() data = [] for case in cases: # 解析负责人信息，获取负责人姓名 responsible_person = "" try: responsiblefor_dict = json.loads(case.responsiblefor) if case.responsiblefor else {} if isinstance(responsiblefor_dict, dict): responsible_person = responsiblefor_dict.get('responsible_person', '') except (json.JSONDecodeError, TypeError): pass # 构建显示文本（用于下拉列表显示） display_text = case.contract_no or f"案件#{case.id}" if case.project_type: display_text += f" - {case.project_type}" if case.client_name: display_text += f" ({case.client_name})" elif responsible_person: display_text += f" ({responsible_person})" data.append({ "id": case.id, "value": case.id, # 下拉列表的值 "label": display_text, # 下拉列表的显示文本 "contract_no": case.contract_no or "", # 合同编号 "project_type": case.project_type or "", # 项目类型 "client_name": case.client_name or "", # 客户名称 "party_name": case.party_name or "", # 相对方名称 "project_description": case.project_description or "", # 项目简述 "responsible_person": responsible_person, # 负责人 "times": case.times, # 立案时间 "state": case.state, # 状态 }) return Response({ 'message': '查询成功', 'data': data, 'total': len(data), 'code': 0 }, status=status.HTTP_200_OK) class Application(APIView): def post(self, request, *args, **kwargs): """ 申请用印 :param request: :param args: :param kwargs: :return: """ token = request.META.get('token') Printingpurpose = request.data.get('Printingpurpose') # 案件编号（前端可不传），后端自动同步为“合同号” # 兼容：仍支持直接传 CaseNumber（即合同号） CaseNumber = request.data.get('CaseNumber') case_id = request.data.get('case_id') project_id = request.data.get('project_id') Reason = request.data.get('Reason') seal_number = request.data.get('seal_number') seal_type = request.data.get('seal_type') file = request.FILES.getlist('file') approvers = request.data.get('approvers') personincharge = request.data.get('personincharge') approvers = normalize_approvers_param(approvers, personincharge) if not all([Printingpurpose, Reason, seal_number, seal_type, file]): return Response({'status': 'error', 'message': '缺少参数', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) now = datetime.now() date_str = now.strftime('%Y-%m-%d') user = User.objects.get(token=token, is_deleted=False) # 自动查询合同号写入 CaseNumber（案件编号） # 优先级：case_id > project_id > CaseNumber（兼容旧传参） contract_no = None if case_id: try: case = Case.objects.select_related('project').get(id=case_id, is_deleted=False) contract_no = case.contract_no or (case.project.ContractNo if case.project else None) except Case.DoesNotExist: return Response({'status': 'error', 'message': '案件不存在或已被删除', 'code': 1}, status=status.HTTP_404_NOT_FOUND) elif project_id: try: project = ProjectRegistration.objects.get(id=project_id, is_deleted=False) contract_no = project.ContractNo except ProjectRegistration.DoesNotExist: return Response({'status': 'error', 'message': '立项登记不存在或已被删除', 'code': 1}, status=status.HTTP_404_NOT_FOUND) else: contract_no = CaseNumber if not contract_no: return Response({ 'status': 'error', 'message': '缺少案件信息：请传 case_id 或 project_id 以自动获取合同号，或直接传 CaseNumber（合同号）', 'code': 1 }, status=status.HTTP_400_BAD_REQUEST) sea = SealApplication.objects.create( Printingpurpose=Printingpurpose, CaseNumber=contract_no, Reason=Reason, seal_number=seal_number, seal_type=seal_type, file=json.dumps(flies(file)), times=date_str, state="审核中", username=user.username, ) team_name = user.team from User.utils import create_approval_with_team_logic approval, approvers_order_json, needs_approval = create_approval_with_team_logic( team_name=team_name, approvers=approvers, title=user.username + "申请用印", content=user.username + "在" + date_str + "申请用印，合同编号：" + str(contract_no) + "，用印事由：" + Reason + ",盖章份数：" + seal_number + "盖着类型：" + seal_type, approval_type="申请用印", user_id=sea.id, business_record=sea, today=date_str ) if approval is None and needs_approval: return Response({ 'status': 'error', 'message': build_missing_approvers_message(team_name, approvers), 'code': 1 }, status=status.HTTP_400_BAD_REQUEST) return Response({'message': '添加成功', 'code': 0}, status=status.HTTP_200_OK) class ApplicationDetail(APIView): def post(self, request, *args, **kwargs): """ 申请用印展示 :param request: :param args: :param kwargs: :return: """ page = request.data.get('page') per_page = request.data.get('per_page') times = request.data.get('times') end_time = request.data.get('end_time') seal_type = request.data.get('seal_type') CaseNumber = request.data.get('CaseNumber') if not all([page, per_page]): return Response({'status': 'error', 'message': '缺少参数', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) Q_obj = Q() if times and end_time: Q_obj &= Q(times__gte=times) & Q(times__lte=end_time) if seal_type: Q_obj &= Q(seal_type=seal_type) if CaseNumber: Q_obj &= Q(CaseNumber__icontains=CaseNumber) seas = SealApplication.objects.filter(Q_obj, is_deleted=False).order_by('-id') total = len(seas) paginator = Paginator(seas, per_page) try: user_agents_page = paginator.page(page) except PageNotAnInteger: user_agents_page = paginator.page(1) except EmptyPage: user_agents_page = paginator.page(paginator.num_pages) data = [] for info in user_agents_page.object_list: data.append({ "id": info.id, "Printingpurpose": info.Printingpurpose, "CaseNumber": info.CaseNumber, "Reason": info.Reason, "seal_number": info.seal_number, "seal_type": info.seal_type, "file": info.file, 'times': info.times, "state": info.state, "username": info.username, }) return Response({'message': '展示成功', "total": total, 'data': data, 'code': 0}, status=status.HTTP_200_OK) class EditApplication(APIView): def post(self, request, *args, **kwargs): """ 编辑申请用印 :param request: :param args: :param kwargs: :return: """ id = request.data.get('id') Printingpurpose = request.data.get('Printingpurpose') # 案件编号（合同号）：支持前端直接传，也支持通过 case_id/project_id 自动同步 CaseNumber = request.data.get('CaseNumber') case_id = request.data.get('case_id') project_id = request.data.get('project_id') Reason = request.data.get('Reason') seal_number = request.data.get('seal_number') seal_type = request.data.get('seal_type') file = request.FILES.getlist('file') approvers = request.data.get('approvers') personincharge = request.data.get('personincharge') approvers = normalize_approvers_param(approvers, personincharge) if not id: return Response({'status': 'error', 'message': '缺少参数', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) try: app = SealApplication.objects.get(id=id, is_deleted=False) except SealApplication.DoesNotExist: return Response({'status': 'error', 'message': '申请用印不存在', 'code': 1}, status=status.HTTP_404_NOT_FOUND) if Printingpurpose: app.Printingpurpose = Printingpurpose app.save(update_fields=['Printingpurpose']) # 优先通过 case_id / project_id 自动同步合同号 contract_no = None if case_id: try: case = Case.objects.select_related('project').get(id=case_id, is_deleted=False) contract_no = case.contract_no or (case.project.ContractNo if case.project else None) except Case.DoesNotExist: return Response({'status': 'error', 'message': '案件不存在或已被删除', 'code': 1}, status=status.HTTP_404_NOT_FOUND) elif project_id: try: project = ProjectRegistration.objects.get(id=project_id, is_deleted=False) contract_no = project.ContractNo except ProjectRegistration.DoesNotExist: return Response({'status': 'error', 'message': '立项登记不存在或已被删除', 'code': 1}, status=status.HTTP_404_NOT_FOUND) elif CaseNumber: contract_no = CaseNumber if contract_no: app.CaseNumber = contract_no app.save(update_fields=['CaseNumber']) if Reason: app.Reason = Reason app.save(update_fields=['Reason']) if seal_number: app.seal_number = seal_number app.save(update_fields=['seal_number']) if seal_type: app.seal_type = seal_type app.save(update_fields=['seal_type']) if file: app.file = json.dumps(flies(file)) app.save(update_fields=['file']) if approvers: now = datetime.now() date_str = now.strftime('%Y-%m-%d') from User.utils import create_approval_with_team_logic team_name = get_user_team_name(app.username) approval, approvers_order_json, needs_approval = create_approval_with_team_logic( team_name=team_name, approvers=approvers, title=app.username + "申请用印重新编辑", content=app.username + "在" + date_str + "申请用印，合同编号：" + str(contract_no or app.CaseNumber) + "，用印事由：" + ( Reason or app.Reason) + ",盖章份数：" + (seal_number or app.seal_number) + "盖着类型：" + ( seal_type or app.seal_type), approval_type="申请用印", user_id=app.id, business_record=app, today=date_str ) if approval is None and needs_approval: return Response({ 'status': 'error', 'message': build_missing_approvers_message(team_name, approvers), 'code': 1 }, status=status.HTTP_400_BAD_REQUEST) return Response({'message': '编辑成功', 'code': 0}, status=status.HTTP_200_OK) class DeleteApplication(APIView): def post(self, request, *args, **kwargs): """ 删除申请用印 :param request: :param args: :param kwargs: :return: """ id = request.data.get('id') if not id: return Response({'status': 'error', 'message': '缺少参数', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) try: app = SealApplication.objects.get(id=id, is_deleted=False) except SealApplication.DoesNotExist: return Response({'status': 'error', 'message': '申请用印不存在', 'code': 1}, status=status.HTTP_404_NOT_FOUND) # 软删除：更新 is_deleted 字段 app.is_deleted = True app.save() return Response({'message': '删除成功', 'code': 0}, status=status.HTTP_200_OK) class WarehousingRegistration(APIView): def post(self, request, *args, **kwargs): """ 入库登记 :param request: :param args: :param kwargs: :return: """ unit = request.data.get('unit') mark = request.data.get('mark') lawyer = request.data.get('lawyer') deadline = request.data.get('deadline') contract = request.FILES.getlist('contract') if not all([unit, mark, lawyer, deadline, contract]): return Response({'status': 'error', 'message': '缺少参数', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) now = datetime.now() date_str = now.strftime('%Y-%m-%d') Warehousing.objects.create( unit=unit, mark=mark, lawyer=lawyer, deadline=deadline, contract=json.dumps(flies(contract)), times=date_str, ) return Response({'message': '添加成功', 'code': 0}, status=status.HTTP_200_OK) class WarehousingDetail(APIView): def post(self, request, *args, **kwargs): """ 入库登记展示 :param request: :param args: :param kwargs: :return: """ page = request.data.get('page') per_page = request.data.get('per_page') times = request.data.get('times') end_time = request.data.get('end_time') unit = request.data.get('unit') if not all([page, per_page]): return Response({'status': 'error', 'message': '缺少参数', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) Q_obj = Q() if times and end_time: Q_obj &= Q(times__gte=times) & Q(times__lte=end_time) if unit: Q_obj &= Q(unit__icontains=unit) seas = Warehousing.objects.filter(Q_obj, is_deleted=False).order_by('-id') total = len(seas) paginator = Paginator(seas, per_page) try: user_agents_page = paginator.page(page) except PageNotAnInteger: user_agents_page = paginator.page(1) except EmptyPage: user_agents_page = paginator.page(paginator.num_pages) data = [] for info in user_agents_page.object_list: data.append({ "id": info.id, "unit": info.unit, "mark": info.mark, "lawyer": info.lawyer, "deadline": info.deadline, "contract": info.contract, "times": info.times, }) return Response({'message': '展示成功', "total": total, 'data': data, 'code': 0}, status=status.HTTP_200_OK) class EditWarehousing(APIView): def post(self, request, *args, **kwargs): """ 编辑入库登记 :param request: :param args: :param kwargs: :return: """ id = request.data.get('id') unit = request.data.get('unit') mark = request.data.get('mark') lawyer = request.data.get('lawyer') deadline = request.data.get('deadline') contract = request.FILES.getlist('contract') if not id: return Response({'status': 'error', 'message': '缺少参数', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) try: ware = Warehousing.objects.get(id=id, is_deleted=False) except Warehousing.DoesNotExist: return Response({'status': 'error', 'message': '入库登记不存在', 'code': 1}, status=status.HTTP_404_NOT_FOUND) if unit: ware.unit = unit ware.save(update_fields=['unit']) if mark: ware.mark = mark ware.save(update_fields=['mark']) if lawyer: ware.lawyer = lawyer ware.save(update_fields=['lawyer']) if deadline: ware.deadline = deadline ware.save(update_fields=['deadline']) if contract: ware.contract = json.dumps(flies(contract)) ware.save(update_fields=['contract']) return Response({'message': '编辑成功', 'code': 0}, status=status.HTTP_200_OK) class DeleteWarehousing(APIView): def post(self, request, *args, **kwargs): """ 删除入库登记 :param request: :param args: :param kwargs: :return: """ id = request.data.get('id') if not id: return Response({'status': 'error', 'message': '缺少参数', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) try: ware = Warehousing.objects.get(id=id, is_deleted=False) except Warehousing.DoesNotExist: return Response({'status': 'error', 'message': '入库登记不存在', 'code': 1}, status=status.HTTP_404_NOT_FOUND) # 软删除：更新 is_deleted 字段 ware.is_deleted = True ware.save() return Response({'message': '删除成功', 'code': 0}, status=status.HTTP_200_OK) class PlatformRegistration(APIView): def post(self, request, *args, **kwargs): """ 注册平台登记 :param request: :param args: :param kwargs: :return: """ platform = request.data.get('platform') number = request.data.get('number') password = request.data.get('password') username = request.data.get('username') if not all([platform, number, password, username]): return Response({'status': 'error', 'message': '缺少参数', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) RegisterPlatform.objects.create( platform=platform, number=number, password=password, username=username, ) return Response({'message': '添加成功', 'code': 0}, status=status.HTTP_200_OK) class PlatformDetail(APIView): def post(self, request, *args, **kwargs): """ 注册平台登记展示 :param request: :param args: :param kwargs: :return: """ page = request.data.get('page') per_page = request.data.get('per_page') seas = RegisterPlatform.objects.filter(is_deleted=False).order_by('-id') total = len(seas) paginator = Paginator(seas, per_page) try: user_agents_page = paginator.page(page) except PageNotAnInteger: user_agents_page = paginator.page(1) except EmptyPage: user_agents_page = paginator.page(paginator.num_pages) data = [] for info in user_agents_page.object_list: data.append({ "id": info.id, "platform": info.platform, "number": info.number, "password": info.password, "username": info.username, }) return Response({'message': '展示成功', "total": total, 'data': data, 'code': 0}, status=status.HTTP_200_OK) class EditPlatformDetail(APIView): def post(self, request, *args, **kwargs): """ 注册平台登记编辑 :param request: :param args: :param kwargs: :return: """ ID = request.data.get('id') platform = request.data.get('platform') number = request.data.get('number') password = request.data.get('password') username = request.data.get('username') if not all([platform, number, password, username, ID]): return Response({'status': 'error', 'message': '缺少参数', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) reg = RegisterPlatform.objects.get(id=ID, is_deleted=False) reg.platform = platform reg.number = number reg.password = password reg.username = username reg.save(update_fields=['platform', 'number', 'password', 'username']) return Response({'message': '修改成功', 'code': 0}, status=status.HTTP_200_OK) class DeletePlatformDetail(APIView): def post(self, request, *args, **kwargs): """ 删除注册平台登记 :param request: :param args: :param kwargs: :return: """ ID = request.data.get('id') try: platform = RegisterPlatform.objects.get(id=ID, is_deleted=False) # 软删除：更新 is_deleted 字段 platform.is_deleted = True platform.save() return Response({'message': '删除成功', 'code': 0}, status=status.HTTP_200_OK) except RegisterPlatform.DoesNotExist: return Response({'status': 'error', 'message': '注册平台登记不存在', 'code': 1}, status=status.HTTP_404_NOT_FOUND) class bulletin(APIView): def post(self, request, *args, **kwargs): """ 公告 :param request: :param args: :param kwargs: :return: """ title = request.data.get('title') content = request.data.get('content') file = request.FILES.getlist('file') state = request.data.get('state') token = request.META.get('token') if not all([title, content]): return Response({'status': 'error', 'message': '缺少参数', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) now = datetime.now() date_str = now.strftime('%Y-%m-%d') bol = 0 if state == "置顶": bol = 1 user = User.objects.get(token=token, is_deleted=False).username Announcement.objects.create( title=title, content=content, file=json.dumps(flies(file)), username=user, times=date_str, state=bol ) return Response({'message': '添加成功', 'code': 0}, status=status.HTTP_200_OK) class BulletinDetail(APIView): def post(self, request, *args, **kwargs): """ 公告展示 :param request: :param args: :param kwargs: :return: """ page = request.data.get('page') per_page = request.data.get('per_page') seas = Announcement.objects.filter(is_deleted=False).order_by('-state', '-times') total = len(seas) paginator = Paginator(seas, per_page) try: user_agents_page = paginator.page(page) except PageNotAnInteger: user_agents_page = paginator.page(1) except EmptyPage: user_agents_page = paginator.page(paginator.num_pages) data = [] for info in user_agents_page.object_list: # 解析 file 字段：有文件返回数组，无文件返回空字符串 try: file_list = json.loads(info.file) if info.file else [] except (json.JSONDecodeError, TypeError): file_list = [] # 空列表返回空字符串 file_result = file_list if file_list else "" if file_list !="": file_result = json.dumps(file_result) data.append({ "id": info.id, "title": info.title, "content": info.content, "times": info.times, "file": file_result,#file_result, "username": info.username, "state": info.state, }) return Response({'message': '展示成功', "total": total, 'data': data, 'code': 0}, status=status.HTTP_200_OK) class EditBulletin(APIView): def post(self, request, *args, **kwargs): """ 编辑公告 :param request: :param args: :param kwargs: :return: """ ID = request.data.get('id') title = request.data.get('title') content = request.data.get('content') file = request.FILES.getlist('file') state = request.data.get('state') token = request.META.get('token') # 从中间件设置的 token 获取 if not all([title, content, ID]): return Response({'status': 'error', 'message': '缺少参数', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) try: ann = Announcement.objects.get(id=ID, is_deleted=False) except Announcement.DoesNotExist: return Response({'status': 'error', 'message': '公告不存在', 'code': 1}, status=status.HTTP_404_NOT_FOUND) now = datetime.now() date_str = now.strftime('%Y-%m-%d') if state: bol = 0 if state == "置顶": bol = 1 ann.state = bol ann.save(update_fields=['state']) # 获取用户信息（如果 token 存在） if token: try: user = User.objects.get(token=token, is_deleted=False).username except User.DoesNotExist: # 如果用户不存在，使用原有用户名 user = ann.username else: # 如果 token 不存在，使用原有用户名 user = ann.username if title: ann.title = title ann.save(update_fields=['title']) if content: ann.content = content ann.save(update_fields=['content']) if file: ann.file = json.dumps(flies(file)) # 使用 flies 函数处理文件 ann.save(update_fields=['file']) ann.username = user ann.times = date_str ann.save(update_fields=['username', 'times']) return Response({'message': '编辑成功', 'code': 0}, status=status.HTTP_200_OK) class deleteBulletin(APIView): def post(self, request, *args, **kwargs): ID = request.data.get('id') try: announcement = Announcement.objects.get(id=ID, is_deleted=False) # 软删除：更新 is_deleted 字段 announcement.is_deleted = True announcement.save() return Response({'message': '删除成功', 'code': 0}, status=status.HTTP_200_OK) except Announcement.DoesNotExist: return Response({'status': 'error', 'message': '公告不存在', 'code': 1}, status=status.HTTP_404_NOT_FOUND) class Lawyersdocuments(APIView): def post(self, request, *args, **kwargs): token = request.META.get('token') file = request.FILES.getlist('file') filename = file[0].name name_without_extension, extension = os.path.splitext(filename) user = User.objects.get(token=token, is_deleted=False).username title = name_without_extension + extension if not all([file]): return Response({'status': 'error', 'message': '缺少参数', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) now = datetime.now() date_str = now.strftime('%Y-%m-%d') LawyerFlie.objects.create( title=title, remark=user, file=json.dumps(flies(file)), times=date_str, ) return Response({'message': '文件上传成功', 'code': 0}, status=status.HTTP_200_OK) class LawyersdocumentsDetail(APIView): def post(self, request, *args, **kwargs): title = request.data.get('title') obj =Q(is_deleted=False) if title: obj &= Q(title__contains=title) law = LawyerFlie.objects.filter(obj).order_by('-id') total = law.count() data = [] for info in law: data.append({ "id": info.id, "title": info.title, "remark": info.remark, "file": info.file, "times": info.times, }) return Response({'message': '展示成功', "total": total, 'data': data, 'code': 0}, status=status.HTTP_200_OK) class LwaDetail(APIView): def post(self, request, *args, **kwargs): id = request.data.get('id') try: lawyer_file = LawyerFlie.objects.get(id=id, is_deleted=False) # 软删除：更新 is_deleted 字段 lawyer_file.is_deleted = True lawyer_file.save() return Response({'message': '删除成功', 'code': 0}, status=status.HTTP_200_OK) except LawyerFlie.DoesNotExist: return Response({'status': 'error', 'message': '律师文件不存在', 'code': 1}, status=status.HTTP_404_NOT_FOUND) class EditLawyerFlie(APIView): def post(self, request, *args, **kwargs): """ 编辑律师文件 :param request: :param args: :param kwargs: :return: """ id = request.data.get('id') title = request.data.get('title') file = request.FILES.getlist('file') remark = request.data.get('remark') if not id: return Response({'status': 'error', 'message': '缺少参数', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) try: law = LawyerFlie.objects.get(id=id, is_deleted=False) except LawyerFlie.DoesNotExist: return Response({'status': 'error', 'message': '律师文件不存在', 'code': 1}, status=status.HTTP_404_NOT_FOUND) if title: law.title = title law.save(update_fields=['title']) if remark: law.remark = remark law.save(update_fields=['remark']) if file: law.file = json.dumps(flies(file)) law.save(update_fields=['file']) return Response({'message': '编辑成功', 'code': 0}, status=status.HTTP_200_OK) class CreateSchedule(APIView): def post(self, request, *args, **kwargs): """ 待办创建 :param request: :param args: :param kwargs: :return: """ title = request.data.get('title') tiems = request.data.get('tiems') end_time = request.data.get('end_time') remark = request.data.get('remark') approvers = request.data.get('approvers') # 审核人列表（团队类型时需要，推荐：用户ID数组如[1,2,3]，兼容：用户名数组） personincharge = request.data.get('personincharge') approvers = normalize_approvers_param(approvers, personincharge) if not all([title, tiems, end_time]): return Response({'status': 'error', 'message': '缺少参数', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) # 获取当前用户 token = request.META.get('token') try: user = User.objects.get(token=token, is_deleted=False) except User.DoesNotExist: return Response({'status': 'error', 'message': '用户不存在', 'code': 1}, status=status.HTTP_404_NOT_FOUND) Schedule.objects.create( title=title, tiems=tiems, end_time=end_time, remark=remark, state="未完成", submit=user.username # 记录提交人 ) return Response({'message': '添加成功', 'code': 0}, status=status.HTTP_200_OK) class DeleteSchedule(APIView): def post(self, request, *args, **kwargs): """ 删除日程 :param request: :param args: :param kwargs: :return: """ id = request.data.get('id') try: schedule = Schedule.objects.get(id=id, is_deleted=False) # 软删除：更新 is_deleted 字段 schedule.is_deleted = True schedule.save() return Response({'message': '删除成功', 'code': 0}, status=status.HTTP_200_OK) except Schedule.DoesNotExist: return Response({'status': 'error', 'message': '日程不存在', 'code': 1}, status=status.HTTP_404_NOT_FOUND) class ScheduleDetail(APIView): def post(self, request, *args, **kwargs): """ 日程展示（仅展示用户主动创建的日程/待办，不包含结案申请等审批承载的 Schedule） :param request: :param args: :param kwargs: :return: """ title = request.data.get('title') obj = Q(is_deleted=False) if title: obj &= Q(title__contains=title) # 排除作为「结案申请」审批承载的 Schedule，结案申请应出现在「审核中」而非「日程中」 closing_application_schedule_ids = Approval.objects.filter( type="结案申请", is_deleted=False ).values_list('user_id', flat=True) closing_application_schedule_ids = [int(sid) for sid in closing_application_schedule_ids if sid and str(sid).isdigit()] if closing_application_schedule_ids: obj &= ~Q(id__in=closing_application_schedule_ids) sches = Schedule.objects.filter(obj).order_by('-id') page = request.data.get('page') per_page = request.data.get('per_page') total = len(sches) paginator = Paginator(sches, per_page) try: user_agents_page = paginator.page(page) except PageNotAnInteger: user_agents_page = paginator.page(1) except EmptyPage: user_agents_page = paginator.page(paginator.num_pages) data = [] for info in user_agents_page.object_list: data.append({ "id": info.id, "title": info.title, "tiems": info.tiems, "end_time": info.end_time, "remark": info.remark, 'state': info.state, }) return Response({'message': '展示成功', "total": total, 'data': data, 'code': 0}, status=status.HTTP_200_OK) class EditSchedule(APIView): def post(self, request, *args, **kwargs): """ 编辑日程 :param request: :param args: :param kwargs: :return: """ id = request.data.get('id') title = request.data.get('title') tiems = request.data.get('tiems') end_time = request.data.get('end_time') remark = request.data.get('remark') if not id: return Response({'status': 'error', 'message': '缺少参数', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) try: schedule = Schedule.objects.get(id=id, is_deleted=False) except Schedule.DoesNotExist: return Response({'status': 'error', 'message': '日程不存在', 'code': 1}, status=status.HTTP_404_NOT_FOUND) if title: schedule.title = title schedule.save(update_fields=['title']) if tiems: schedule.tiems = tiems schedule.save(update_fields=['tiems']) if end_time: schedule.end_time = end_time schedule.save(update_fields=['end_time']) if remark: schedule.remark = remark schedule.save(update_fields=['remark']) return Response({'message': '编辑成功', 'code': 0}, status=status.HTTP_200_OK) class handleSchedule(APIView): def post(self, request, *args, **kwargs): id = request.data.get('id') state = request.data.get('state') if not all([id, state]): return Response({'status': 'error', 'message': '缺少参数', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) try: sc = Schedule.objects.get(id=id, is_deleted=False) sc.state = "已完成" sc.save(update_fields=['state']) return Response({'message': '修改成功', 'code': 0}, status=status.HTTP_200_OK) except Schedule.DoesNotExist: return Response({'status': 'error', 'message': '日程不存在', 'code': 1}, status=status.HTTP_404_NOT_FOUND) class AddRermission(APIView): """ 添加权限 """ def post(self, request, *args, **kwargs): permission_name = request.data.get('permission_name') permission_logo = request.data.get('permission_logo') parent = request.data.get('parent') if not all([permission_name, permission_logo, parent]): return Response({'status': 'error', 'message': '缺少参数', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) permission.objects.create( permission_name=permission_name, permission_logo=permission_logo, parent=parent, ) return Response({'message': '添加成功', 'code': 0}, status=status.HTTP_200_OK) class DisplayRermission(APIView): def post(self, request, *args, **kwargs): """ 权限列表展示 """ permissions = permission.objects.filter(is_deleted=False) # 先将数据转换为字典格式 data = [] permission_dict = {} for per in permissions: item = { "id": str(per.id), "permission_name": per.permission_name, "permission_logo": per.permission_logo, "parent": str(per.parent), "children": [] } data.append(item) permission_dict[str(per.id)] = item # 构建树形结构 tree = [] for item in data: parent_id = item["parent"] # 如果parent是0或者不存在，说明是根节点 if parent_id == "0" or parent_id not in permission_dict: tree.append(item) else: # 找到父节点并添加到children中 parent_node = permission_dict.get(parent_id) if parent_node: parent_node["children"].append(item) return Response({ 'message': '展示成功', "data": tree, 'code': 0 }, status=status.HTTP_200_OK) class DeleteRermission(APIView): def post(self, request, *args, **kwargs): """ 删除权限 """ ID = request.data.get('id') try: perm = permission.objects.get(id=ID, is_deleted=False) # 记录操作前的数据 old_data = { 'id': perm.id, 'permission_name': perm.permission_name, 'permission_logo': perm.permission_logo } # 软删除：更新 is_deleted 字段 perm.is_deleted = True perm.save() # 记录操作日志 log_operation( request=request, operation_type='DELETE', module='Business', action='删除权限', target_type='Permission', target_id=perm.id, target_name=perm.permission_name, old_data=old_data, remark=f'删除权限：{perm.permission_name}' ) return Response({'message': '删除成功', 'code': 0}, status=status.HTTP_200_OK) except permission.DoesNotExist: return Response({'status': 'error', 'message': '权限不存在', 'code': 1}, status=status.HTTP_404_NOT_FOUND) class EditRermission(APIView): def post(self, request, *args, **kwargs): """ 编辑权限 """ id = request.data.get('id') permission_name = request.data.get('permission_name') permission_logo = request.data.get('permission_logo') parent = request.data.get('parent') per = permission.objects.get(id=id) if permission_name: per.permission_name = permission_name per.save(update_fields=['permission_name']) if permission_logo: per.permission_logo = permission_logo per.save(update_fields=['permission_logo']) if parent: per.parent = parent per.save(update_fields=['parent']) return Response({'message': '修改成功', 'code': 0}, status=status.HTTP_200_OK) class addRole(APIView): def post(self, request, *args, **kwargs): RoleName = request.data.get('RoleName') remark = request.data.get('remark') if not all([RoleName]): return Response({'status': 'error', 'message': '缺少参数', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) # 检查角色名是否已存在 if role.objects.filter(RoleName=RoleName).exists(): return Response({'status': 'error', 'message': '角色名已存在，不能重复', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) role.objects.create(RoleName=RoleName, remark=remark) return Response({'message': '添加成功', 'code': 0}, status=status.HTTP_200_OK) class DeleteRole(APIView): def post(self, request, *args, **kwargs): id = request.data.get('id') try: r = role.objects.get(id=id, is_deleted=False) # 记录操作前的数据 old_data = { 'id': r.id, 'role_name': r.RoleName, 'permission_id': r.permissionId } # 软删除：更新 is_deleted 字段 r.is_deleted = True r.save() # 记录操作日志 log_operation( request=request, operation_type='DELETE', module='Business', action='删除角色', target_type='Role', target_id=r.id, target_name=r.RoleName, old_data=old_data, remark=f'删除角色：{r.RoleName}' ) return Response({'message': '删除成功', 'code': 0}, status=status.HTTP_200_OK) except role.DoesNotExist: return Response({'status': 'error', 'message': '角色不存在', 'code': 1}, status=status.HTTP_404_NOT_FOUND) class EditRole(APIView): def post(self, request, *args, **kwargs): id = request.data.get('id') RoleName = request.data.get('RoleName') remark = request.data.get('remark') if not all([id]): return Response({'status': 'error', 'message': '缺少参数', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) ro = role.objects.get(id=id) if RoleName: # 检查角色名是否已被其他角色使用（排除当前角色） if role.objects.filter(RoleName=RoleName).exclude(id=id).exists(): return Response({'status': 'error', 'message': '角色名已存在，不能重复', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) ro.RoleName = RoleName ro.save(update_fields=['RoleName']) if remark: ro.remark = remark ro.save(update_fields=['remark']) return Response({'message': '编辑成功', 'code': 0}, status=status.HTTP_200_OK) class displayRole(APIView): """ 角色列表展示 """ def post(self, request, *args, **kwargs): RoleName = request.data.get('RoleName') obj = Q() if RoleName: obj = Q(RoleName__icontains=RoleName) roles = role.objects.filter(obj) data = [] for ro in roles: data.append({ "id": str(ro.id), "RoleName": ro.RoleName, "remark": ro.remark, }) return Response({'message': '展示成功', 'data': data, 'code': 0}, status=status.HTTP_200_OK) class modifypermissions(APIView): def post(self, request, *args, **kwargs): """ 修改角色权限 """ id = request.data.get('id') permissionId = request.data.get('permissionId') if not all([id, permissionId]): return Response({'status': 'error', 'message': '缺少参数', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) permissionId = ast.literal_eval(permissionId) ro = role.objects.get(id=id) # Convert list to compact comma-separated string format to save space if isinstance(permissionId, list): ro.permissionId = ','.join(map(str, permissionId)) else: ro.permissionId = str(permissionId) ro.save(update_fields=['permissionId']) return Response({'message': '权限修改成功', 'code': 0}, status=status.HTTP_200_OK) class getRolePermissions(APIView): def post(self, request, *args, **kwargs): """ 查询角色权限 :param request: :param args: :param kwargs: :return: """ role_id = request.data.get('roleId') if not role_id: return Response({'status': 'error', 'message': '缺少参数', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) try: ro = role.objects.get(id=role_id) except role.DoesNotExist: return Response({'status': 'error', 'message': '角色不存在', 'code': 1}, status=status.HTTP_404_NOT_FOUND) # 解析权限ID列表 try: if ro.permissionId: # Try to parse as comma-separated format first (new format) if ',' in ro.permissionId and not ro.permissionId.strip().startswith('['): permission_ids = [int(x.strip()) for x in ro.permissionId.split(',') if x.strip()] else: # Fall back to ast.literal_eval for backward compatibility permission_ids = ast.literal_eval(ro.permissionId) if not isinstance(permission_ids, list): permission_ids = [] else: permission_ids = [] except (ValueError, SyntaxError): # 如果解析失败，返回空列表 permission_ids = [] return Response({'message': '查询成功', 'data': permission_ids, 'code': 0}, status=status.HTTP_200_OK) class DeleteRegistration(APIView): def post(self, request, *args, **kwargs): """ 删除预立案登记 :param request: :param args: :param kwargs: :return: """ id = request.data.get('id') if not id: return Response({'status': 'error', 'message': '缺少参数', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) try: pre = PreFiling.objects.get(id=id, is_deleted=False) # 注意：由于预立案和立项登记、投标登记已经拆分，不再需要检查关联 # 预立案现在可以独立删除（如果不再需要的话） # 如果将来需要保留预立案用于其他用途，可以保留此检查逻辑 # 软删除：更新 is_deleted 字段 pre.is_deleted = True pre.save() return Response({'message': '删除成功', 'code': 0}, status=status.HTTP_200_OK) except PreFiling.DoesNotExist: return Response({'status': 'error', 'message': '预立案登记不存在', 'code': 1}, status=status.HTTP_404_NOT_FOUND) class TransferCase(APIView): def post(self, request, *args, **kwargs): """ 案件转移接口 将案件的承办人员从离职用户转移到新用户 :param request: :param args: :param kwargs: :return: """ old_undertaker = request.data.get('old_undertaker') # 原承办人员（离职用户） new_undertaker = request.data.get('new_undertaker') # 新承办人员 case_ids = request.data.get('case_ids') # 要转移的案件ID列表（可选，如果不传则转移所有案件） project_ids = request.data.get('project_ids') # 要转移的立项ID列表（可选） if not all([old_undertaker, new_undertaker]): return Response({ 'status': 'error', 'message': '缺少参数：原承办人员和新承办人员不能为空', 'code': 1 }, status=status.HTTP_400_BAD_REQUEST) # 检查原承办人员是否存在（排除软删除用户） try: old_user = User.objects.get(username=old_undertaker, is_deleted=False) except User.DoesNotExist: return Response({ 'status': 'error', 'message': '原承办人员不存在或已被删除', 'code': 1 }, status=status.HTTP_404_NOT_FOUND) # 检查新承办人员是否存在（排除软删除用户） try: new_user = User.objects.get(username=new_undertaker, is_deleted=False) except User.DoesNotExist: return Response({ 'status': 'error', 'message': '新承办人员不存在或已被删除', 'code': 1 }, status=status.HTTP_404_NOT_FOUND) # 查询要转移的预立案 if case_ids and isinstance(case_ids, list): prefiling_cases = PreFiling.objects.filter(Undertaker=old_undertaker, id__in=case_ids) else: prefiling_cases = PreFiling.objects.filter(Undertaker=old_undertaker) prefiling_count = prefiling_cases.count() def _replace_responsible(responsiblefor_value, old_name, new_name): try: data = json.loads(responsiblefor_value) if responsiblefor_value else {} except (json.JSONDecodeError, TypeError): data = responsiblefor_value if responsiblefor_value else {} if not isinstance(data, dict): return None, False changed = False for key, value in list(data.items()): if value == old_name: data[key] = new_name changed = True return data, changed # 查询要转移的正式案件 formal_cases_qs = Case.objects.filter(is_deleted=False, responsiblefor__icontains=old_undertaker) if case_ids and isinstance(case_ids, list): formal_cases_qs = formal_cases_qs.filter(id__in=case_ids) # 查询要转移的立项登记 formal_projects_qs = ProjectRegistration.objects.filter(is_deleted=False, responsiblefor__icontains=old_undertaker) if project_ids and isinstance(project_ids, list): formal_projects_qs = formal_projects_qs.filter(id__in=project_ids) formal_cases = list(formal_cases_qs) formal_projects = list(formal_projects_qs) total_count = prefiling_count + len(formal_cases) + len(formal_projects) if total_count == 0: return Response({ 'status': 'error', 'message': '没有找到需要转移的案件', 'code': 1 }, status=status.HTTP_400_BAD_REQUEST) # 执行转移 transferred_prefilings = [] for case in prefiling_cases: case.Undertaker = new_undertaker case.save(update_fields=['Undertaker']) transferred_prefilings.append({ 'id': case.id, 'times': case.times, 'client_username': case.client_username, 'party_username': case.party_username, 'description': case.description }) transferred_formal_cases = [] for case in formal_cases: updated_data, changed = _replace_responsible(case.responsiblefor, old_undertaker, new_undertaker) if changed: case.responsiblefor = json.dumps(updated_data, ensure_ascii=False) case.save(update_fields=['responsiblefor']) transferred_formal_cases.append({ 'id': case.id, 'project_id': case.project_id, 'contract_no': case.contract_no, 'project_type': case.project_type, 'times': case.times }) transferred_projects = [] for project in formal_projects: updated_data, changed = _replace_responsible(project.responsiblefor, old_undertaker, new_undertaker) if changed: project.responsiblefor = json.dumps(updated_data, ensure_ascii=False) project.save(update_fields=['responsiblefor']) transferred_projects.append({ 'id': project.id, 'contract_no': project.ContractNo, 'type': project.type, 'times': project.times }) return Response({ 'message': f'案件转移成功，共转移{total_count}个案件', 'code': 0, 'data': { 'old_undertaker': old_undertaker, 'new_undertaker': new_undertaker, 'transferred_count': total_count, 'prefiling_count': prefiling_count, 'formal_case_count': len(transferred_formal_cases), 'formal_project_count': len(transferred_projects), 'prefiling_cases': transferred_prefilings, 'formal_cases': transferred_formal_cases, 'formal_projects': transferred_projects } }, status=status.HTTP_200_OK) class CaseChangeRequestCreate(APIView): """创建案件变更申请（需传入审批人）""" def post(self, request, *args, **kwargs): case_id = request.data.get('case_id') # 案件ID（可选） contract_no = request.data.get('contract_no') # 合同编号（必填） change_item = request.data.get('change_item') # 变更事项 change_reason = request.data.get('change_reason') # 变更原因 change_agreement = request.FILES.getlist('change_agreement') or request.FILES.getlist('ChangeAgreement') # 变更协议文件 approvers = request.data.get('approvers') # 审批人（必填）：用户ID数组如[1,2,3]，或用户名数组["张三","李四"]，或逗号分隔字符串 personincharge = request.data.get('personincharge') # 兼容旧接口，未传approvers时使用 approvers = normalize_approvers_param(approvers, personincharge) # 验证必填参数 if not contract_no: return Response({ 'status': 'error', 'message': '缺少参数contract_no（合同编号）', 'code': 1 }, status=status.HTTP_400_BAD_REQUEST) if not all([change_item, change_reason, change_agreement]): return Response({ 'status': 'error', 'message': '变更申请需要填写变更事项、变更原因并上传变更协议', 'code': 1 }, status=status.HTTP_400_BAD_REQUEST) if not approvers: return Response({ 'status': 'error', 'message': '缺少参数approvers（审批人），请传入审批人列表，如用户ID数组[1,2,3]或用户名数组["张三","李四"]', 'code': 1 }, status=status.HTTP_400_BAD_REQUEST) # 如果提供了case_id，验证案件是否存在（可选） case = None if case_id: try: case = Case.objects.get(id=case_id, is_deleted=False) except Case.DoesNotExist: return Response({ 'status': 'error', 'message': '案件不存在或已删除', 'code': 1 }, status=status.HTTP_404_NOT_FOUND) # 获取申请人 applicant_name = "未知用户" token = request.META.get('token') if token: try: applicant = User.objects.get(token=token, is_deleted=False) applicant_name = applicant.username except User.DoesNotExist: pass # 上传变更协议文件 agreement_urls = flies(change_agreement) if not agreement_urls: return Response({ 'status': 'error', 'message': '变更协议上传失败', 'code': 1 }, status=status.HTTP_400_BAD_REQUEST) # 创建变更申请（审批人由入参 approvers 传入，create_approval_with_team_logic 会解析并回写 approvers_order） today = datetime.now().strftime("%Y-%m-%d") change_request = CaseChangeRequest.objects.create( case=case, # 案件关联（可选） contract_no=contract_no, # 合同编号（必填） change_item=change_item, change_reason=change_reason, change_agreement=json.dumps(agreement_urls, ensure_ascii=False), times=today, applicant=applicant_name, state='审核中', approvers_order=None, # 由 create_approval_with_team_logic 根据 approvers 入参回写 need_approval=True ) # 如果提供了case_id，更新案件的change_request字段 if case: case.change_request = change_request case.save(update_fields=['change_request']) # 构建审批内容（不含审批流程，由 create_approval_with_team_logic 追加） if case: content = build_change_approval_content( applicant_name, case, change_item, change_reason, agreement_urls ) else: content = f"{applicant_name}提交案件变更申请，合同编号：{contract_no}，变更事项：{change_item}，变更原因：{change_reason}，变更协议：{', '.join(agreement_urls)}" from User.utils import create_approval_with_team_logic approval, approvers_order_json, needs_approval = create_approval_with_team_logic( team_name=None, approvers=approvers, title="案件变更申请", content=content, approval_type="案件变更", user_id=str(change_request.id), business_record=change_request, today=today, applicant=applicant_name ) if approval is None and needs_approval: return Response({ 'status': 'error', 'message': '审批人无效或不存在，请检查approvers参数（需为系统中的用户ID或用户名）', 'code': 1 }, status=status.HTTP_400_BAD_REQUEST) return Response({ 'message': '变更申请提交成功', 'code': 0, 'data': { 'change_request_id': change_request.id } }, status=status.HTTP_200_OK) class CaseChangeRequestList(APIView): """ 案件变更申请列表查询。 默认仅展示审批通过的数据（审批通过后才进变更申请表格）。 我的申请/全部：传 show_all=true 或 state=审核中,待查看,已通过,未通过 可查全部或按状态筛选。 """ def post(self, request, *args, **kwargs): page = request.data.get('page') per_page = request.data.get('per_page') case_id = request.data.get('case_id') # 可选：按案件ID筛选 state = request.data.get('state') # 可选：按状态筛选；不传且不传 show_all 时默认只返回已通过 approved_only = request.data.get('approved_only') # 可选：为 true 时仅返回已通过 show_all = request.data.get('show_all') # 可选：为 true 时返回全部状态（我的申请用），不传则默认只返回已通过 # 参数验证和默认值处理 try: page = int(page) if page and str(page).lower() != 'undefined' else 1 per_page = int(per_page) if per_page and str(per_page).lower() != 'undefined' else 10 except (ValueError, TypeError): return Response({ 'status': 'error', 'message': '参数page和per_page必须是有效的数字', 'code': 1 }, status=status.HTTP_400_BAD_REQUEST) if page < 1: page = 1 if per_page < 1: per_page = 10 Q_obj = Q(is_deleted=False) if case_id: Q_obj &= Q(case_id=case_id) # 变更申请表格：默认只展示审批通过的数据；传 show_all=true 可查全部（我的申请） if show_all in (True, 'true', '1', 1): pass # 不按状态筛选，返回全部 elif approved_only in (True, 'true', '1', 1) or state == '已通过': Q_obj &= Q(state='已通过') elif state: # 支持单状态或逗号分隔多状态 if isinstance(state, str) and ',' in state: states = [s.strip() for s in state.split(',') if s.strip()] if states: Q_obj &= Q(state__in=states) else: Q_obj &= Q(state=state) else: # 默认：仅展示已通过，数据审批通过后才进变更申请表格 Q_obj &= Q(state='已通过') queryset = CaseChangeRequest.objects.filter(Q_obj).order_by('-id') total = queryset.count() paginator = Paginator(queryset, per_page) try: page_obj = paginator.page(page) except PageNotAnInteger: page_obj = paginator.page(1) except EmptyPage: page_obj = paginator.page(paginator.num_pages) data = [] for change_request in page_obj.object_list: try: agreement_list = json.loads(change_request.change_agreement) if change_request.change_agreement else [] except (json.JSONDecodeError, TypeError): agreement_list = [] try: approvers_list = json.loads(change_request.approvers_order) if change_request.approvers_order else [] except (json.JSONDecodeError, TypeError): approvers_list = [] data.append({ 'id': change_request.id, 'contract_no': change_request.contract_no, # 合同编号 'case_id': change_request.case.id if change_request.case else None, 'case_contract_no': change_request.case.contract_no if change_request.case else None, 'case_project_type': change_request.case.project_type if change_request.case else None, 'change_item': change_request.change_item, # 变更事项 'change_reason': change_request.change_reason, # 变更原因 'change_agreement': change_request.change_agreement, # 变更协议（JSON字符串） 'change_agreement_urls': agreement_list, # 解析后的URL列表 'times': change_request.times, 'applicant': change_request.applicant, 'state': change_request.state, 'approvers_order': approvers_list }) return Response({ 'message': '查询成功', 'total': total, 'data': data, 'code': 0 }, status=status.HTTP_200_OK) class CaseChangeRequestDetail(APIView): """案件变更申请详情查询""" def post(self, request, *args, **kwargs): change_request_id = request.data.get('change_request_id') or request.data.get('id') if not change_request_id: return Response({ 'status': 'error', 'message': '缺少参数change_request_id或id', 'code': 1 }, status=status.HTTP_400_BAD_REQUEST) try: change_request = CaseChangeRequest.objects.get(id=change_request_id, is_deleted=False) except CaseChangeRequest.DoesNotExist: return Response({ 'status': 'error', 'message': '变更申请不存在或已删除', 'code': 1 }, status=status.HTTP_404_NOT_FOUND) try: agreement_list = json.loads(change_request.change_agreement) if change_request.change_agreement else [] except (json.JSONDecodeError, TypeError): agreement_list = [] try: approvers_list = json.loads(change_request.approvers_order) if change_request.approvers_order else [] except (json.JSONDecodeError, TypeError): approvers_list = [] # 获取案件信息（如果有关联） case_data = None if change_request.case: case = change_request.case case_data = { 'id': case.id, 'contract_no': case.contract_no, 'project_type': case.project_type, 'client_name': case.client_name, 'party_name': case.party_name, 'project_description': case.project_description } data = { 'id': change_request.id, 'contract_no': change_request.contract_no, # 合同编号 'case': case_data, # 案件信息（如果有关联） 'change_item': change_request.change_item, # 变更事项 'change_reason': change_request.change_reason, # 变更原因 'change_agreement': change_request.change_agreement, # 变更协议（JSON字符串） 'change_agreement_urls': agreement_list, # 解析后的URL列表 'times': change_request.times, 'applicant': change_request.applicant, 'state': change_request.state, 'approvers_order': approvers_list } return Response({ 'message': '查询成功', 'data': data, 'code': 0 }, status=status.HTTP_200_OK) def parse_person_info(person_str): """ 解析人员信息字符串，支持多种格式： - "张三（3263452342342342）" - "张三，身份证号：3263452342342342" - "张三,3263452342342342" - "张三" Returns: dict: { 'name': '张三', 'id_number': '3263452342342342', # 可能为空 'original': '张三（3263452342342342）' # 原始字符串 } """ if not person_str: return {'name': '', 'id_number': '', 'original': ''} person_str = str(person_str).strip() result = { 'name': '', 'id_number': '', 'original': person_str } # 匹配格式：张三（3263452342342342）或张三(3263452342342342) match = re.match(r'^([^（(]+?)[（(]([^）)]+)[）)]', person_str) if match: result['name'] = match.group(1).strip() result['id_number'] = match.group(2).strip() return result # 匹配格式：张三，身份证号：3263452342342342 或 张三,身份证号:3263452342342342 match = re.match(r'^([^，,]+?)[，,]\s*[身身]份证[号号]?[：:]?\s*([^\s，,]+)', person_str) if match: result['name'] = match.group(1).strip() result['id_number'] = match.group(2).strip() return result # 匹配格式：张三,3263452342342342（逗号分隔） match = re.match(r'^([^，,]+?)[，,]\s*(\d{15,18})', person_str) if match: result['name'] = match.group(1).strip() result['id_number'] = match.group(2).strip() return result # 如果没有匹配到特定格式，尝试提取姓名（去除可能的身份证号） # 先尝试提取姓名部分（去除末尾的数字） name_match = re.match(r'^([^，,\d（(]+)', person_str) if name_match: result['name'] = name_match.group(1).strip() else: result['name'] = person_str # 尝试提取身份证号（15-18位数字） id_match = re.search(r'(\d{15,18})', person_str) if id_match: result['id_number'] = id_match.group(1) return result def conflict_search(client_info=None, party_info=None, undertaker=None, bidding_unit=None, exclude_prefiling_id=None, exclude_project_id=None, exclude_bid_id=None): """ 利益冲突检索函数 - 比对预立案登记、投标登记、立项登记三张表 Args: client_info: 委托人身份信息（可选） party_info: 相对方身份信息（可选） undertaker: 承办人员（可选） bidding_unit: 招标单位（可选） exclude_prefiling_id: 要排除的预立案ID（可选） exclude_project_id: 要排除的立项ID（可选） exclude_bid_id: 要排除的投标ID（可选） Returns: dict: 包含三个表的冲突记录信息 { 'prefiling_conflicts': [...], # 预立案冲突记录列表 'project_conflicts': [...], # 立项冲突记录列表 'bid_conflicts': [...] # 投标冲突记录列表 } """ result = { 'prefiling_conflicts': [], 'project_conflicts': [], 'bid_conflicts': [] } # 如果没有提供任何查询条件，返回空结果 if not any([client_info, party_info, undertaker, bidding_unit]): return result # 解析委托人信息和相对方信息 client_parsed = parse_person_info(client_info) if client_info else {'name': '', 'id_number': '', 'original': ''} party_parsed = parse_person_info(party_info) if party_info else {'name': '', 'id_number': '', 'original': ''} # 提取姓名/名称（用于匹配） client_name = client_parsed['name'] client_id_number = client_parsed['id_number'] client_original = client_parsed['original'] party_name = party_parsed['name'] party_id_number = party_parsed['id_number'] party_original = party_parsed['original'] # 1. 检索预立案表 prefiling_q = Q(is_deleted=False) if exclude_prefiling_id: prefiling_q &= ~Q(id=exclude_prefiling_id) matched_prefilings = [] prefiling_all = PreFiling.objects.filter(prefiling_q) for pf in prefiling_all: if len(matched_prefilings) >= 50: # 限制返回数量 break is_match = False match_reason = [] # 检查委托人/相对方匹配 if client_info or client_name: pf_client_names = [] try: client_data = json.loads(pf.client_username) if isinstance(pf.client_username, str) else pf.client_username if isinstance(client_data, list): for item in client_data: if isinstance(item, dict) and 'name' in item: pf_client_names.append(item['name'].strip()) elif isinstance(client_data, dict) and 'name' in client_data: pf_client_names.append(client_data['name'].strip()) except (json.JSONDecodeError, TypeError, AttributeError): pf_client_names = [pf.client_username.strip()] if pf.client_username else [] pf_party_names = [] try: party_data = json.loads(pf.party_username) if isinstance(pf.party_username, str) else pf.party_username if isinstance(party_data, list): for item in party_data: if isinstance(item, dict) and 'name' in item: pf_party_names.append(item['name'].strip()) elif isinstance(party_data, dict) and 'name' in party_data: pf_party_names.append(party_data['name'].strip()) except (json.JSONDecodeError, TypeError, AttributeError): pf_party_names = [pf.party_username.strip()] if pf.party_username else [] # 检查委托人匹配（支持姓名和身份证号匹配） if client_info or client_name: for pf_client in pf_client_names: # 匹配姓名 if client_name and pf_client in client_name: is_match = True match_reason.append(f"委托人姓名匹配：{pf_client}") break # 匹配完整信息 if client_original and pf_client in client_original: is_match = True match_reason.append(f"委托人信息匹配：{pf_client}") break # 检查相对方是否匹配委托人 for pf_party in pf_party_names: if client_name and pf_party in client_name: is_match = True match_reason.append(f"相对方与委托人姓名匹配：{pf_party}") break if client_original and pf_party in client_original: is_match = True match_reason.append(f"相对方与委托人信息匹配：{pf_party}") break # 检查相对方匹配（支持姓名和身份证号匹配） if party_info or party_name: for pf_party in pf_party_names: # 匹配姓名 if party_name and pf_party in party_name: is_match = True match_reason.append(f"相对方姓名匹配：{pf_party}") break # 匹配完整信息 if party_original and pf_party in party_original: is_match = True match_reason.append(f"相对方信息匹配：{pf_party}") break # 检查委托人是否匹配相对方 for pf_client in pf_client_names: if party_name and pf_client in party_name: is_match = True match_reason.append(f"委托人与相对方姓名匹配：{pf_client}") break if party_original and pf_client in party_original: is_match = True match_reason.append(f"委托人与相对方信息匹配：{pf_client}") break # 检查身份证号匹配（如果提供了身份证号） if client_id_number: # 检查预立案中的身份证号 try: client_data = json.loads(pf.client_username) if isinstance(pf.client_username, str) else pf.client_username if isinstance(client_data, list): for item in client_data: if isinstance(item, dict): pf_id = item.get('idNumber', '') or item.get('id_number', '') if pf_id and client_id_number in str(pf_id): is_match = True match_reason.append(f"委托人身份证号匹配") break elif isinstance(client_data, dict): pf_id = client_data.get('idNumber', '') or client_data.get('id_number', '') if pf_id and client_id_number in str(pf_id): is_match = True match_reason.append(f"委托人身份证号匹配") except (json.JSONDecodeError, TypeError, AttributeError): pass if party_id_number: # 检查预立案中的身份证号 try: party_data = json.loads(pf.party_username) if isinstance(pf.party_username, str) else pf.party_username if isinstance(party_data, list): for item in party_data: if isinstance(item, dict): pf_id = item.get('idNumber', '') or item.get('id_number', '') if pf_id and party_id_number in str(pf_id): is_match = True match_reason.append(f"相对方身份证号匹配") break elif isinstance(party_data, dict): pf_id = party_data.get('idNumber', '') or party_data.get('id_number', '') if pf_id and party_id_number in str(pf_id): is_match = True match_reason.append(f"相对方身份证号匹配") except (json.JSONDecodeError, TypeError, AttributeError): pass # 检查承办人员匹配 if undertaker and pf.Undertaker: if undertaker in pf.Undertaker or pf.Undertaker in undertaker: is_match = True match_reason.append(f"承办人员匹配：{pf.Undertaker}") if is_match: matched_prefilings.append({ 'id': pf.id, 'times': pf.times, 'client_username': pf.client_username, 'party_username': pf.party_username, 'description': pf.description, 'Undertaker': pf.Undertaker, 'match_reason': '；'.join(match_reason) if match_reason else '匹配' }) result['prefiling_conflicts'] = matched_prefilings # 2. 检索立项表 project_q = Q(is_deleted=False) if exclude_project_id: project_q &= ~Q(id=exclude_project_id) project_records = ProjectRegistration.objects.filter(project_q) project_list = [] for pro in project_records[:50]: # 限制查询数量 is_match = False match_reason = [] # 检查委托人/相对方匹配（支持姓名和身份证号匹配） if client_info or client_name: if pro.client_info: # 匹配姓名 if client_name and client_name in pro.client_info: is_match = True match_reason.append("委托人姓名匹配") # 匹配完整信息 elif client_original and client_original in pro.client_info: is_match = True match_reason.append("委托人信息匹配") # 匹配身份证号 elif client_id_number and client_id_number in pro.client_info: is_match = True match_reason.append("委托人身份证号匹配") if pro.party_info: # 匹配姓名 if client_name and client_name in pro.party_info: is_match = True match_reason.append("相对方与委托人姓名匹配") # 匹配完整信息 elif client_original and client_original in pro.party_info: is_match = True match_reason.append("相对方与委托人信息匹配") # 匹配身份证号 elif client_id_number and client_id_number in pro.party_info: is_match = True match_reason.append("相对方与委托人身份证号匹配") if party_info or party_name: if pro.party_info: # 匹配姓名 if party_name and party_name in pro.party_info: is_match = True match_reason.append("相对方姓名匹配") # 匹配完整信息 elif party_original and party_original in pro.party_info: is_match = True match_reason.append("相对方信息匹配") # 匹配身份证号 elif party_id_number and party_id_number in pro.party_info: is_match = True match_reason.append("相对方身份证号匹配") if pro.client_info: # 匹配姓名 if party_name and party_name in pro.client_info: is_match = True match_reason.append("委托人与相对方姓名匹配") # 匹配完整信息 elif party_original and party_original in pro.client_info: is_match = True match_reason.append("委托人与相对方信息匹配") # 匹配身份证号 elif party_id_number and party_id_number in pro.client_info: is_match = True match_reason.append("委托人与相对方身份证号匹配") # 检查负责人匹配 if undertaker and pro.responsiblefor: try: responsiblefor_data = json.loads(pro.responsiblefor) if isinstance(pro.responsiblefor, str) else pro.responsiblefor if isinstance(responsiblefor_data, dict): responsible_person = responsiblefor_data.get('responsible_person', '') main_lawyer = responsiblefor_data.get('main_lawyer', '') assistant_lawyer = responsiblefor_data.get('assistant_lawyer', '') case_manager_lawyer = responsiblefor_data.get('case_manager_lawyer', '') if undertaker in str(responsible_person) or undertaker in str(main_lawyer) or \ undertaker in str(assistant_lawyer) or undertaker in str(case_manager_lawyer): is_match = True match_reason.append("负责人匹配") except (json.JSONDecodeError, TypeError): if undertaker in pro.responsiblefor: is_match = True match_reason.append("负责人匹配") if is_match: project_list.append({ 'id': pro.id, 'ContractNo': pro.ContractNo, 'times': pro.times, 'type': pro.type, 'client_info': pro.client_info, 'party_info': pro.party_info, 'description': pro.description, 'responsiblefor': pro.responsiblefor, 'match_reason': '；'.join(match_reason) if match_reason else '匹配' }) result['project_conflicts'] = project_list # 3. 检索投标表 bid_q = Q(is_deleted=False) if exclude_bid_id: bid_q &= ~Q(id=exclude_bid_id) bid_records = Bid.objects.filter(bid_q) bid_list = [] for bid in bid_records[:50]: # 限制查询数量 is_match = False match_reason = [] # 检查招标单位匹配 if bidding_unit and bid.BiddingUnit: if bidding_unit in bid.BiddingUnit or bid.BiddingUnit in bidding_unit: is_match = True match_reason.append("招标单位匹配") # 检查委托人/相对方是否在招标单位中（支持姓名和身份证号匹配） if (client_info or client_name) and bid.BiddingUnit: if client_name and client_name in bid.BiddingUnit: is_match = True match_reason.append("委托人姓名在招标单位中") elif client_original and client_original in bid.BiddingUnit: is_match = True match_reason.append("委托人信息在招标单位中") elif client_id_number and client_id_number in bid.BiddingUnit: is_match = True match_reason.append("委托人身份证号在招标单位中") if (party_info or party_name) and bid.BiddingUnit: if party_name and party_name in bid.BiddingUnit: is_match = True match_reason.append("相对方姓名在招标单位中") elif party_original and party_original in bid.BiddingUnit: is_match = True match_reason.append("相对方信息在招标单位中") elif party_id_number and party_id_number in bid.BiddingUnit: is_match = True match_reason.append("相对方身份证号在招标单位中") if is_match: bid_list.append({ 'id': bid.id, 'ProjectName': bid.ProjectName, 'times': bid.times, 'BiddingUnit': bid.BiddingUnit, 'state': bid.state, 'match_reason': '；'.join(match_reason) if match_reason else '匹配' }) result['bid_conflicts'] = bid_list return result class ConflictSearch(APIView): """ 利益冲突检索查询接口 比对预立案登记、投标登记、立项登记三张表，返回冲突数据 """ def post(self, request, *args, **kwargs): """ 利益冲突检索 请求参数（至少提供一个）： - client_info: 委托人身份信息（可选），支持格式： * "张三（3263452342342342）" * "张三，身份证号：3263452342342342" * "张三,3263452342342342" * "张三" - party_info: 相对方身份信息（可选），支持格式同上 - undertaker: 承办人员（可选） - bidding_unit: 招标单位（可选） - exclude_prefiling_id: 要排除的预立案ID（可选） - exclude_project_id: 要排除的立项ID（可选） - exclude_bid_id: 要排除的投标ID（可选） """ client_info = request.data.get('client_info', '').strip() if request.data.get('client_info') else None party_info = request.data.get('party_info', '').strip() if request.data.get('party_info') else None undertaker = request.data.get('undertaker', '').strip() if request.data.get('undertaker') else None bidding_unit = request.data.get('bidding_unit', '').strip() if request.data.get('bidding_unit') else None exclude_prefiling_id = request.data.get('exclude_prefiling_id') exclude_project_id = request.data.get('exclude_project_id') exclude_bid_id = request.data.get('exclude_bid_id') # 至少需要提供一个查询条件 if not any([client_info, party_info, undertaker, bidding_unit]): return Response({ 'status': 'error', 'message': '至少需要提供一个查询条件（client_info、party_info、undertaker、bidding_unit之一）', 'code': 1 }, status=status.HTTP_400_BAD_REQUEST) # 执行冲突检索 conflict_result = conflict_search( client_info=client_info, party_info=party_info, undertaker=undertaker, bidding_unit=bidding_unit, exclude_prefiling_id=exclude_prefiling_id, exclude_project_id=exclude_project_id, exclude_bid_id=exclude_bid_id ) # 归一化冲突记录为前端期望格式 [{ index, name, idNumber }, ...]（预立案用 client_username/party_username，立项用 client_info/party_info，投标用 BiddingUnit） def _normalize_person_list(val): if not val: return [] try: lst = json.loads(val) if isinstance(val, str) else val if not isinstance(lst, list): return None out = [] for i, item in enumerate(lst): if not isinstance(item, dict): continue name = item.get('name') or item.get('name_original') or '' id_num = item.get('idNumber') or item.get('id_number') or '' if not isinstance(name, str): name = str(name) if name else '' if not isinstance(id_num, str): id_num = str(id_num) if id_num else '' out.append({ 'index': item.get('index') if isinstance(item.get('index'), (int, float)) else (i + 1), 'name': name, 'idNumber': id_num }) return out except (json.JSONDecodeError, TypeError, ValueError): return None def _normalize_conflict_records(records): processed = [] for record in records: new_record = dict(record) for key in ('client_info', 'party_info', 'BiddingUnit', 'client_username', 'party_username'): if key not in new_record or not new_record[key]: continue normalized = _normalize_person_list(new_record[key]) if normalized is not None: new_record[key] = normalized processed.append(new_record) return processed prefiling = _normalize_conflict_records(conflict_result['prefiling_conflicts']) project = _normalize_conflict_records(conflict_result['project_conflicts']) bid = _normalize_conflict_records(conflict_result['bid_conflicts']) # 统计冲突数量 total_conflicts = len(prefiling) + len(project) + len(bid) return Response({ 'message': '检索成功', 'code': 0, 'data': { 'total_conflicts': total_conflicts, 'prefiling_conflicts_count': len(prefiling), 'project_conflicts_count': len(project), 'bid_conflicts_count': len(bid), 'prefiling_conflicts': prefiling, 'project_conflicts': project, 'bid_conflicts': bid } }, status=status.HTTP_200_OK) # ==================== 案件标签管理接口 ==================== class CreateCaseTag(APIView): """创建案件标签""" def post(self, request, *args, **kwargs): name = request.data.get('name') color = request.data.get('color', '#1890ff') description = request.data.get('description', '') if not name: return Response({'status': 'error', 'message': '缺少参数：标签名称', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) # 检查标签名是否已存在 if CaseTag.objects.filter(name=name, is_deleted=False).exists(): return Response({'status': 'error', 'message': '标签名称已存在', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) import datetime now = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') tag = CaseTag.objects.create( name=name, color=color, description=description, created_at=now, updated_at=now ) # 记录操作日志 log_operation( request=request, operation_type='CREATE', module='Business', action='创建案件标签', target_type='CaseTag', target_id=tag.id, target_name=tag.name, new_data={'name': name, 'color': color, 'description': description}, remark=f'创建案件标签：{name}' ) return Response({ 'message': '创建成功', 'code': 0, 'data': { 'id': tag.id, 'name': tag.name, 'color': tag.color, 'description': tag.description } }, status=status.HTTP_200_OK) class CaseTagList(APIView): """案件标签列表""" def post(self, request, *args, **kwargs): page = request.data.get('page', 1) per_page = request.data.get('per_page', 10) name = request.data.get('name', '') # 搜索标签名称 Q_obj = Q(is_deleted=False) if name: Q_obj &= Q(name__icontains=name) tags = CaseTag.objects.filter(Q_obj).order_by('-id') total = len(tags) paginator = Paginator(tags, per_page) try: tags_page = paginator.page(page) except PageNotAnInteger: tags_page = paginator.page(1) except EmptyPage: tags_page = paginator.page(paginator.num_pages) data = [] for tag in tags_page.object_list: # 统计使用该标签的案件数量 case_count = tag.cases.filter(is_deleted=False).count() data.append({ 'id': tag.id, 'name': tag.name, 'color': tag.color, 'description': tag.description, 'case_count': case_count, # 使用该标签的案件数量 'created_at': tag.created_at, 'updated_at': tag.updated_at }) return Response({ 'message': '查询成功', 'total': total, 'data': data, 'code': 0 }, status=status.HTTP_200_OK) class CaseTagDetail(APIView): """案件标签详情""" def post(self, request, *args, **kwargs): id = request.data.get('id') if not id: return Response({'status': 'error', 'message': '缺少参数：id', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) try: tag = CaseTag.objects.get(id=id, is_deleted=False) except CaseTag.DoesNotExist: return Response({'status': 'error', 'message': '标签不存在', 'code': 1}, status=status.HTTP_404_NOT_FOUND) # 获取使用该标签的案件列表 cases = tag.cases.filter(is_deleted=False) case_list = [] for case in cases: case_list.append({ 'id': case.id, 'contract_no': case.contract_no or '', 'project_type': case.project_type or '', 'client_name': case.client_name or '', 'times': case.times }) return Response({ 'message': '查询成功', 'code': 0, 'data': { 'id': tag.id, 'name': tag.name, 'color': tag.color, 'description': tag.description, 'case_count': len(case_list), 'cases': case_list, 'created_at': tag.created_at, 'updated_at': tag.updated_at } }, status=status.HTTP_200_OK) class EditCaseTag(APIView): """编辑案件标签""" def post(self, request, *args, **kwargs): id = request.data.get('id') name = request.data.get('name') color = request.data.get('color') description = request.data.get('description') if not id: return Response({'status': 'error', 'message': '缺少参数：id', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) try: tag = CaseTag.objects.get(id=id, is_deleted=False) except CaseTag.DoesNotExist: return Response({'status': 'error', 'message': '标签不存在', 'code': 1}, status=status.HTTP_404_NOT_FOUND) # 记录操作前的数据 old_data = { 'id': tag.id, 'name': tag.name, 'color': tag.color, 'description': tag.description } update_fields = [] if name: # 检查新名称是否已被其他标签使用 if CaseTag.objects.filter(name=name, is_deleted=False).exclude(id=id).exists(): return Response({'status': 'error', 'message': '标签名称已存在', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) tag.name = name update_fields.append('name') if color: tag.color = color update_fields.append('color') if description is not None: tag.description = description update_fields.append('description') if update_fields: import datetime tag.updated_at = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') update_fields.append('updated_at') tag.save(update_fields=update_fields) # 记录操作日志 log_operation( request=request, operation_type='UPDATE', module='Business', action='编辑案件标签', target_type='CaseTag', target_id=tag.id, target_name=tag.name, old_data=old_data, new_data={'name': tag.name, 'color': tag.color, 'description': tag.description}, remark=f'编辑案件标签：{tag.name}' ) return Response({'message': '编辑成功', 'code': 0}, status=status.HTTP_200_OK) class DeleteCaseTag(APIView): """删除案件标签""" def post(self, request, *args, **kwargs): id = request.data.get('id') if not id: return Response({'status': 'error', 'message': '缺少参数：id', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) try: tag = CaseTag.objects.get(id=id, is_deleted=False) except CaseTag.DoesNotExist: return Response({'status': 'error', 'message': '标签不存在', 'code': 1}, status=status.HTTP_404_NOT_FOUND) # 记录操作前的数据 old_data = { 'id': tag.id, 'name': tag.name, 'color': tag.color, 'description': tag.description } # 软删除：更新 is_deleted 字段 tag.is_deleted = True tag.save() # 记录操作日志 log_operation( request=request, operation_type='DELETE', module='Business', action='删除案件标签', target_type='CaseTag', target_id=tag.id, target_name=tag.name, old_data=old_data, remark=f'删除案件标签：{tag.name}' ) return Response({'message': '删除成功', 'code': 0}, status=status.HTTP_200_OK) class CaseTagDropdownList(APIView): """获取标签下拉列表（用于案件管理中选择标签）""" def post(self, request, *args, **kwargs): tags = CaseTag.objects.filter(is_deleted=False).order_by('name') data = [] for tag in tags: data.append({ 'id': tag.id, 'name': tag.name, 'color': tag.color }) return Response({ 'message': '查询成功', 'data': data, 'code': 0 }, status=status.HTTP_200_OK) class SetCaseTags(APIView): """给案件设置标签""" def post(self, request, *args, **kwargs): """ 给案件设置标签 支持设置多个标签，也可以清空所有标签 """ case_id = request.data.get('case_id') tag_ids = request.data.get('tag_ids') # 标签ID列表（数组或逗号分隔的字符串） if not case_id: return Response({ 'status': 'error', 'message': '缺少参数：case_id（案件ID）', 'code': 1 }, status=status.HTTP_400_BAD_REQUEST) # 验证案件是否存在 try: case = Case.objects.get(id=case_id, is_deleted=False) except Case.DoesNotExist: return Response({ 'status': 'error', 'message': '案件不存在或已被删除', 'code': 1 }, status=status.HTTP_404_NOT_FOUND) # 记录操作前的标签 old_tags = list(case.tags.filter(is_deleted=False).values('id', 'name')) old_tag_ids = [tag['id'] for tag in old_tags] # 处理标签ID列表 tag_id_list = [] if tag_ids is not None: try: # 支持数组或逗号分隔的字符串 if isinstance(tag_ids, str): if tag_ids.strip() == '': tag_id_list = [] # 空字符串表示清空所有标签 elif ',' in tag_ids: tag_id_list = [int(x.strip()) for x in tag_ids.split(',') if x.strip()] else: tag_id_list = [int(tag_ids)] elif isinstance(tag_ids, list): tag_id_list = [int(x) for x in tag_ids if x] else: tag_id_list = [] except (ValueError, TypeError) as e: return Response({ 'status': 'error', 'message': f'标签ID格式错误：{str(e)}', 'code': 1 }, status=status.HTTP_400_BAD_REQUEST) # 验证标签是否存在 if tag_id_list: valid_tags = CaseTag.objects.filter(id__in=tag_id_list, is_deleted=False) valid_tag_ids = list(valid_tags.values_list('id', flat=True)) # 检查是否有无效的标签ID invalid_tag_ids = set(tag_id_list) - set(valid_tag_ids) if invalid_tag_ids: return Response({ 'status': 'error', 'message': f'以下标签ID不存在或已被删除：{", ".join(map(str, invalid_tag_ids))}', 'code': 1 }, status=status.HTTP_400_BAD_REQUEST) # 设置标签关联 case.tags.set(valid_tags) else: # 清空所有标签 case.tags.clear() # 获取更新后的标签信息 new_tags = list(case.tags.filter(is_deleted=False).values('id', 'name', 'color')) new_tag_ids = [tag['id'] for tag in new_tags] # 记录操作日志 log_operation( request=request, operation_type='UPDATE', module='Business', action='设置案件标签', target_type='Case', target_id=case.id, target_name=case.contract_no or f'案件ID-{case.id}', old_data={'tag_ids': old_tag_ids, 'tags': old_tags}, new_data={'tag_ids': new_tag_ids, 'tags': new_tags}, remark=f'设置案件标签：案件ID {case_id}，标签ID {new_tag_ids}' ) return Response({ 'message': '设置成功', 'code': 0, 'data': { 'case_id': case.id, 'tags': new_tags, 'tag_ids': new_tag_ids } }, status=status.HTTP_200_OK) class CaseListByTag(APIView): """按标签筛选案件列表""" def post(self, request, *args, **kwargs): """ 根据标签ID筛选案件列表 """ page = request.data.get('page') per_page = request.data.get('per_page') tag_ids = request.data.get('tag_ids') # 标签ID列表（数组或逗号分隔的字符串） times = request.data.get('times') end_time = request.data.get('end_time') type = request.data.get('type') if not all([page, per_page]): return Response({'status': 'error', 'message': '缺少参数：page和per_page', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) if not tag_ids: return Response({'status': 'error', 'message': '缺少参数：tag_ids', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) # 解析标签ID try: if isinstance(tag_ids, str): if ',' in tag_ids: tag_id_list = [int(x.strip()) for x in tag_ids.split(',') if x.strip()] else: tag_id_list = [int(tag_ids)] elif isinstance(tag_ids, list): tag_id_list = [int(x) for x in tag_ids if x] else: tag_id_list = [] except (ValueError, TypeError): return Response({'status': 'error', 'message': '标签ID格式错误', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) if not tag_id_list: return Response({'status': 'error', 'message': '标签ID列表为空', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) # 验证标签是否存在 valid_tags = CaseTag.objects.filter(id__in=tag_id_list, is_deleted=False) if not valid_tags.exists(): return Response({'status': 'error', 'message': '标签不存在', 'code': 1}, status=status.HTTP_404_NOT_FOUND) # 构建查询条件 Q_obj = Q(is_deleted=False) # 按标签筛选（多标签取交集，即案件必须同时拥有所有指定标签） for tag_id in tag_id_list: Q_obj &= Q(tags__id=tag_id) # 时间范围筛选 if times and end_time: Q_obj &= Q(times__gte=times) & Q(times__lte=end_time) # 项目类型筛选 if type: por_id = ProjectRegistration.objects.filter(type=type, is_deleted=False).values_list('id', flat=True) Q_obj &= Q(project_id__in=por_id) # 查询案件（使用distinct去重，因为多对多关系可能产生重复） cases = Case.objects.filter(Q_obj).distinct().order_by('-id') total = len(cases) paginator = Paginator(cases, per_page) try: cases_page = paginator.page(page) except PageNotAnInteger: cases_page = paginator.page(1) except EmptyPage: cases_page = paginator.page(paginator.num_pages) data = [] for info in cases_page.object_list: pro = None if info.project_id: try: pro = ProjectRegistration.objects.get(id=info.project_id, is_deleted=False) except ProjectRegistration.DoesNotExist: pro = None contract_no = info.contract_no or (pro.ContractNo if pro else None) project_type = info.project_type or (pro.type if pro else None) client_name = info.client_name or (pro.client_info if pro else None) party_name = info.party_name or (pro.party_info if pro else None) project_description = info.project_description or (pro.description if pro else None) responsiblefor_raw = info.responsiblefor or (pro.responsiblefor if pro else None) charge = info.charge or (pro.charge if pro else None) # 解析负责人信息 try: responsiblefor_dict = json.loads(responsiblefor_raw) if responsiblefor_raw else {} except (json.JSONDecodeError, TypeError): responsiblefor_dict = responsiblefor_raw if responsiblefor_raw else {} # 解析结案申请；代理合同已从案件管理移除，不再返回 try: closing_application_list = json.loads(info.Closingapplication) if info.Closingapplication else [] except (json.JSONDecodeError, TypeError): closing_application_list = [] if not closing_application_list: closing_application_list = "" contractreturn_str = info.Contractreturn or "" if contractreturn_str.strip() in ["[]", ""]: contractreturn_str = "" closing_application_str = info.Closingapplication or "" if closing_application_str.strip() in ["[]", ""]: closing_application_str = "" # 处理已开票/已收款字段 invoice_status_value = normalize_amount_value(info.invoice_status) paymentcollection_value = normalize_amount_value(info.paymentcollection) # 获取案件标签 tags = info.tags.filter(is_deleted=False) tag_list = [] for tag in tags: tag_list.append({ 'id': tag.id, 'name': tag.name, 'color': tag.color }) data.append({ "id": info.id, "ContractNo": contract_no or "", "type": project_type or "", "client_info": client_name or "", "party_info": party_name or "", "description": project_description, "responsiblefor": responsiblefor_dict, "charge": charge, 'times': info.times, "Contractreturn": contractreturn_str, # 合同返还（没有数据时返回空字符串） "Closingapplication": closing_application_str, # 结案申请（JSON字符串，没有文件时返回空字符串） "ClosingapplicationUrls": closing_application_list if closing_application_list else "", # 结案申请（URL列表，没有文件时返回空字符串） "ChangeRequest": info.ChangeRequest, "ChangeItem": info.ChangeItem, "ChangeReason": info.ChangeReason, "ChangeAgreement": info.ChangeAgreement, "invoice_status": invoice_status_value, "paymentcollection": paymentcollection_value, "state": info.state, "project_id": info.project_id, "tags": tag_list, "tag_ids": [tag['id'] for tag in tag_list], }) return Response({ 'message': '查询成功', "total": total, 'data': data, 'code': 0 }, status=status.HTTP_200_OK) class PropagandaEit(APIView): def post(self, request): content = request.data.get('content') pro = Propaganda.objects.get(id="1") pro.content = content pro.save() return Response({ 'message': '更新成功', 'code': 0 }, status=status.HTTP_200_OK) class addSystem(APIView): def post(self, request): title = request.data.get('title') content = request.data.get('content') file = request.FILES.getlist('file') state = request.data.get('state') token = request.META.get('token') if not all([title, content]): return Response({'status': 'error', 'message': '缺少参数', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) now = datetime.now() date_str = now.strftime('%Y-%m-%d') bol = 0 if state == "置顶": bol = 1 user = User.objects.get(token=token, is_deleted=False).username System.objects.create( title=title, content=content, file=json.dumps(flies(file)), username=user, times=date_str, state=bol ) return Response({'message': '添加成功', 'code': 0}, status=status.HTTP_200_OK) class SystemList(APIView): def post(self, request): page = request.data.get('page') per_page = request.data.get('per_page') seas = System.objects.filter(is_deleted=False).order_by('-state', '-times') total = len(seas) paginator = Paginator(seas, per_page) try: user_agents_page = paginator.page(page) except PageNotAnInteger: user_agents_page = paginator.page(1) except EmptyPage: user_agents_page = paginator.page(paginator.num_pages) data = [] for info in user_agents_page.object_list: # 解析 file 字段：有文件返回数组，无文件返回空字符串 try: file_list = json.loads(info.file) if info.file else [] except (json.JSONDecodeError, TypeError): file_list = [] # 空列表返回空字符串 file_result = file_list if file_list else "" if file_result !="": file_result = json.dumps(file_result) data.append({ "id": info.id, "title": info.title, "content": info.content, "times": info.times, "file": file_result, # file 字段解析, "username": info.username, "state": info.state, }) return Response({'message': '展示成功', "total": total, 'data': data, 'code': 0}, status=status.HTTP_200_OK) class eitSystem(APIView): def post(self, request): ID = request.data.get('id') title = request.data.get('title') content = request.data.get('content') file = request.FILES.getlist('file') state = request.data.get('state') token = request.META.get('token') # 从中间件设置的 token 获取 if not all([title, content, ID]): return Response({'status': 'error', 'message': '缺少参数', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) try: system_record = System.objects.get(id=ID, is_deleted=False) except System.DoesNotExist: return Response({'status': 'error', 'message': '系统公告不存在', 'code': 1}, status=status.HTTP_404_NOT_FOUND) now = datetime.now() date_str = now.strftime('%Y-%m-%d') if state: bol = 0 if state == "置顶": bol = 1 system_record.state = bol system_record.save(update_fields=['state']) # 获取用户信息（如果 token 存在） if token: try: user = User.objects.get(token=token, is_deleted=False).username except User.DoesNotExist: # 如果用户不存在，使用原有用户名 user = system_record.username else: # 如果 token 不存在，使用原有用户名 user = system_record.username if title: system_record.title = title system_record.save(update_fields=['title']) if content: system_record.content = content system_record.save(update_fields=['content']) if file: system_record.file = json.dumps(flies(file)) # 使用 flies 函数处理文件 system_record.save(update_fields=['file']) system_record.username = user system_record.times = date_str system_record.save(update_fields=['username', 'times']) return Response({'message': '编辑成功', 'code': 0}, status=status.HTTP_200_OK) class deleteSystem(APIView): def post(self, request, *args, **kwargs): ID = request.data.get('id') try: system_record = System.objects.get(id=ID, is_deleted=False) # 软删除：更新 is_deleted 字段 system_record.is_deleted = True system_record.save() return Response({'message': '删除成功', 'code': 0}, status=status.HTTP_200_OK) except System.DoesNotExist: return Response({'status': 'error', 'message': '系统公告不存在', 'code': 1}, status=status.HTTP_404_NOT_FOUND) class ExportCaseLogExcel(APIView): def post(self, request, *args, **kwargs): """ 导出指定案件的日志到Excel，上传到OSS并返回下载链接 必填参数：case_id（案件ID） 可选参数：start_time（开始时间）、end_time（结束时间） 返回：下载链接 """ import pandas as pd import oss2 import uuid from io import BytesIO case_id = request.data.get('case_id') start_time = request.data.get('start_time') end_time = request.data.get('end_time') if not case_id: return Response({'status': 'error', 'message': '缺少参数case_id', 'code': 1}, status=status.HTTP_400_BAD_REQUEST) # 获取案件信息 try: case = Case.objects.get(id=case_id, is_deleted=False) except Case.DoesNotExist: return Response({'status': 'error', 'message': '案件不存在', 'code': 1}, status=status.HTTP_404_NOT_FOUND) # 构建查询条件 Q_obj = Q(is_deleted=False, case_id=case_id) if start_time: Q_obj &= Q(times__gte=start_time) if end_time: Q_obj &= Q(times__lte=end_time) # 查询日志 logs = Caselog.objects.filter(Q_obj).order_by('-times', '-id') if not logs.exists(): return Response({'status': 'error', 'message': '该案件没有日志记录', 'code': 1}, status=status.HTTP_404_NOT_FOUND) # 构建Excel数据（只保留：记录人、记录时间、工作内容） excel_data = [] for log in logs: excel_data.append({ '记录人': log.username or '', '记录时间': log.times or '', '工作内容': log.content or '', }) # 生成Excel文件 df = pd.DataFrame(excel_data) output = BytesIO() with pd.ExcelWriter(output, engine='openpyxl') as writer: df.to_excel(writer, index=False, sheet_name='案件日志') ws = writer.sheets['案件日志'] for idx, col in enumerate(df.columns): width = min(max(df[col].astype(str).map(len).max(), len(col)) + 2, 50) ws.column_dimensions[chr(65 + idx) if idx < 26 else chr(64 + idx // 26) + chr(65 + idx % 26)].width = width output.seek(0) # 上传到阿里云OSS try: endpoint = 'https://oss-cn-beijing.aliyuncs.com' access_key_id = "LTAI5tRMxrM95Pi8JEEmqRcg" access_key_secret = "8vueGCsRVeFyQMcAA7sysO7LSnuJDG" bucket_name = 'oss-bucket-yj' auth = oss2.Auth(access_key_id, access_key_secret) bucket = oss2.Bucket(auth, endpoint, bucket_name) # 生成唯一文件名 contract_no_safe = (case.contract_no or f'case{case_id}').replace('/', '_').replace('\\', '_') filename = f'{uuid.uuid4().hex[:12]}_{contract_no_safe}_日志_{datetime.now().strftime("%Y%m%d%H%M%S")}.xlsx' # 上传文件 result = bucket.put_object(filename, output.getvalue()) if result.status == 200: # 生成下载链接 download_url = f'http://{bucket_name}.{endpoint.replace("https://", "")}/{filename}' return Response({ 'message': '导出成功', 'code': 0, 'data': { 'url': download_url, 'filename': f'{case.contract_no or f"案件{case_id}"}_日志.xlsx' } }, status=status.HTTP_200_OK) else: return Response({'status': 'error', 'message': '文件上传失败', 'code': 1}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) except Exception as e: return Response({'status': 'error', 'message': f'文件上传失败: {str(e)}', 'code': 1}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)