scj/apps/order/views.py

# coding=utf-8

import traceback
import json
from django.views.decorators.csrf import csrf_exempt
from django.db import transaction
from apps.account.decorators import token_required, permission_required, valid_permission, isHasPermissions
from apps.account.models import User
from apps.order.models import SaleOrder, SaleOrderDetail, GoodsDeliver, GoodsDeliverDetail, GoodsDeliverReturn,GoodsDeliverReturnDetail, SaleOrderMessage
from django.db.models import Q, F, Sum
from django.utils import timezone

from apps.goods.models import GoodsGodownEntryDetail
from apps.warehouse.biz import BizWarehouse, GetWarehouseSrockRecord
from apps.warehouse.models import Warehouse, WarehouseStock, WarehouseRecord, InventoryDetail
from libs.http import JSONResponse, JSONError, DataGridJSONResponse
from _mysql_exceptions import IntegrityError
from django.db.models import ProtectedError
from libs import utils
from apps.exceptions import CustomError, ExportChange
from apps.order.filters import SaleOrderFilter, GoodsDeliverFilter, GoodsDeliverReturnFilter
from apps.order.serializers import SaleOrderSerializer, SaleOrderDetailSerializer, GoodsDeliverSerializer, \
    GoodsDeliverDetailSerializer, GoodsDeliverReturnViewSerializer, GoodsDeliverReturnSerializer, \
    GoodsDeliverReturnDetailSerializer
from apps.goods.models import Goods
from apps.product.models import ProductBase
from apps.base import Formater
from django.conf import settings
from apps.foundation.models import BizLog, Option
from resources import SaleOrderResource, SaleOrderDetailResource, GoodsDeliverDetailResource, GoodsDeliverResource, \
    GoodsDeliverQueryResource, GoodsDeliverReturnQueryResource
from apps.finance.models import dbFinanceIncome
from apps.finance.serializers import FinanceIncomeSerializer


@csrf_exempt
@permission_required('order.view_sale_order')
def sale_order_list(request):
    department_ids = request.user.getSubDepartmentIds()
    user_ids = request.user.getSubEmployeeIds()
    rows = SaleOrder.objects.filter(Q(department_id__in=department_ids) | Q(create_user_id__in=user_ids) | Q(create_user=request.user))
    f = SaleOrderFilter(request.GET, queryset=rows)
    total_row = f.qs.aggregate(
        sum_count=Sum('count'),
        sum_amount=Sum('amount'),
        sum_receive_count=Sum('receive_count'),
        sum_receive_amount=Sum('receive_amount'),
        sum_pay_amount=Sum('pay_amount'),
        sum_put_amount=Sum('put_amount'),
        sum_fare_amount=Sum('fare_amount'),
        sum_loss_amount=Sum('loss_amount')
    )
    more = {
        'sum_count': Formater.formatCountShow(total_row['sum_count']),
        'sum_amount': Formater.formatAmountShow(total_row['sum_amount']),
        'sum_receive_count': Formater.formatCountShow(total_row['sum_receive_count']),
        'sum_receive_amount': Formater.formatAmountShow(total_row['sum_receive_amount']),
        'sum_pay_amount': Formater.formatAmountShow(total_row['sum_pay_amount']),
        'sum_put_amount': Formater.formatAmountShow(total_row['sum_put_amount']),
        'sum_fare_amount': Formater.formatAmountShow(total_row['sum_fare_amount']),
        'sum_loss_amount': Formater.formatAmountShow(total_row['sum_loss_amount']),
        'sum_total_amount': Formater.formatAmountShow((total_row['sum_receive_amount'] or 0)-(total_row['sum_loss_amount'] or 0)),
    }
    rows, total = utils.get_page_data(request, f.qs)
    serializer = SaleOrderSerializer(rows, many=True)
    return DataGridJSONResponse(serializer.data, total, more)


@csrf_exempt
@permission_required('order.export_sale_order')
def sale_order_export(request):
    department_ids = request.user.getSubDepartmentIds()
    user_ids = request.user.getSubEmployeeIds()
    rows = SaleOrder.objects.filter(Q(department_id__in=department_ids) | Q(create_user_id__in=user_ids) | Q(create_user=request.user))
    f = SaleOrderFilter(request.GET, queryset=rows)
    serializer = SaleOrderSerializer(f.qs, many=True)
    export_data = ExportChange.dict_to_obj(serializer)
    export_data = SaleOrderResource().export(export_data)
    filename = utils.attachment_save(export_data)
    BizLog.objects.addnew(request.user, BizLog.EXPORT, u"导出销售单")
    return JSONResponse({'filename': filename})

@csrf_exempt
@permission_required('order.add_sale_order')
def sale_order_save(request):
    source = request.GET.get('source')
    id = request.GET.get('id')
    # detail_id:添加保存，销售计划直接保存，不需要添加明细detail_id=-1，添加明细保存默认detail_id=0，修改保存，detail_id=明细id
    detail_id = -1
    if source == 'touch':
        detail_id = json.loads(request.body)['detail']
    data = json.loads(request.body)

    try:
        with transaction.atomic():
            pb = SaleOrderSerializer.factory(request.user, data['order_data'],id)
            if pb.instance and pb.instance.status == settings.PASS:
                raise CustomError(u'该订单已审核, 不允许修改')
            pb = pb.validSave()
            if source == 'touch' and detail_id >= 0:
                # 手机端保存，如果是修改，先删除要修改的明细
                SaleOrderDetail.objects.filter(id=int(detail_id)).delete()
                for item in data['items']:
                    item['main'] = pb.id
                    pbd = SaleOrderDetailSerializer.factory(request.user, item)
                    pbd.validSave()
            else:
                SaleOrderDetail.objects.filter(main_id=pb.id).delete()
                for item in data['items']:
                    item['main'] = pb.id
                    pbd = SaleOrderDetailSerializer.factory(request.user, item)
                    pbd.validSave()

            pb.updateAmount()

    except CustomError, e:
        return JSONError(e.get_error_msg())
    except Exception, e:
        traceback.print_exc()
        return JSONError(u'保存失败')
    return JSONResponse(pb.id)

@csrf_exempt
@token_required
def sale_order_detail(request):
    id = request.GET.get('id')
    warehouse_id = request.GET.get('warehouse_id')
    sale_order = SaleOrder.getById(id)
    rows = SaleOrderDetail.objects.filter(main_id=id)
    company = SaleOrder.getById(id).department.getCompany()
    if sale_order.status == settings.PASS:
        check_status = u'已审核'
    else:
        check_status = u'待审核'
    main_data = {
        'id': sale_order.id,
        'no': sale_order.no,
        'total_count': Formater.formatCountShow(sale_order.count),
        'total_amount': Formater.formatAmountShow(sale_order.amount),
        'loss_amount': Formater.formatAmountShow(sale_order.loss_amount),
        'name': sale_order.customer.name,
        'mobile': sale_order.customer.mobile,
        'customer_id': sale_order.customer.id,
        'status': check_status,
        'status_id': sale_order.status,
        'check_user': sale_order.check_user and sale_order.check_user.name or '',
        'create_user': sale_order.create_user and sale_order.create_user.name or '',
        'check_time': sale_order.check_time and Formater.formatStrTime(sale_order.check_time) or '',
        'create_time': Formater.formatStrTime(sale_order.create_time),
        'notes': sale_order.notes or '',
        'loss_notes': sale_order.loss_notes or '',
    }
    data = {
        'main_data':main_data,
        'company': company.name,
        'items_data': []
    }
    for row in rows:
        item = {
            'id': row.id,
            'goods_id': row.goods_id,
            'product_id': row.goods.product_base_id,
            'unit': row.goods.product_base.unit,
            'name': row.goods.product_base.name,
            'model': row.goods.product_base.model,
            'quality_request': row.quality_request and row.quality_request.id or '',
            'quality_request_text': row.quality_request and row.quality_request.name or '',
            'warehouse_place': row.goods.product_base.warehouse_place,
            'count': Formater.formatCountShow(row.count),
            'receive_count': Formater.formatCountShow(row.receive_count),
            'price': Formater.formatPriceShow(row.price),
            'amount': Formater.formatAmountShow(row.amount)
        }
        if warehouse_id:
            record_data = GetWarehouseSrockRecord.getRecord(row.goods.product_base.id, warehouse_id)
            item['record_data'] = record_data
        data['items_data'].append(item)
    return JSONResponse(data)

@csrf_exempt
@permission_required('order.delete_sale_order')
def sale_order_delete(request):
    id = int(request.GET.get('id'))
    try:
        with transaction.atomic():
            order = SaleOrder.getById(id)
            if order.status != settings.DEFAULT:
                raise CustomError(u'该订单已审核, 不允许删除')
            BizLog.objects.addnew(request.user, BizLog.DELETE, u"删除销售订单[%s]，id=%d" % (order.no, order.id))
            SaleOrderDetail.objects.filter(main=order).delete()
            order.delete()
    except CustomError, e:
        return JSONError(e.get_error_msg())
    except ProtectedError:
        return JSONError(u'该销售订单已被引用，禁止删除！')
    except IntegrityError:
        return JSONError(u'该销售订单已被引用，禁止删除！')
    except Exception, e:
        traceback.print_exc()
        return JSONError(u'删除失败！')

    return JSONResponse({})

@csrf_exempt
@permission_required('order.check_sale_order')
def sale_order_check(request):
    id = request.GET.get('id')
    status = int(request.GET.get('status'))

    try:
        with transaction.atomic():
            order = SaleOrder.getById(id)
            if status == settings.PASS:
                if order.status != settings.DEFAULT:
                    raise CustomError(u'该订单已审核')
                order.status = settings.PASS
                order.check_user = request.user
                order.check_time = timezone.now()

                SaleOrderDetail.objects.filter(main_id=order.id).update(receive_count=F('count'))

                order.updateReceiveAmount()

                BizLog.objects.addnew(
                    request.user,
                    BizLog.CHECK,
                    u"审核销售订单[%s]，id=%d" % (order.no, order.id),
                )
            else:
                if order.status == settings.DEFAULT:
                    raise CustomError(u'该订单尚未审核')
                deliver = GoodsDeliver.objects.filter(sale_order=order).first()
                if deliver:
                    raise CustomError(u'该订单已转出库, 不允许撤销审核')
                order.status = settings.DEFAULT
                order.check_user = None
                order.check_time = None

                SaleOrderDetail.objects.filter(main_id=order.id).update(receive_count=0)
                order.updateReceiveAmount()

                BizLog.objects.addnew(
                    request.user,
                    BizLog.CHECK,
                    u"取消审核销售订单[%s]，id=%d" % (order.no, order.id),
                )
            order.save()
    except CustomError, e:
        return JSONError(e.get_error_msg())
    except Exception, e:
        traceback.print_exc()
        return JSONError(u'审核失败')
    return JSONResponse({})

@csrf_exempt
@permission_required('order.loss_sale_order')
def sale_order_loss_save(request):
    id = request.GET.get('id')
    data = json.loads(request.body)

    try:
        with transaction.atomic():
            order = SaleOrder.getById(id)
            if order.status == settings.DEFAULT:
                raise CustomError(u'该订单尚未审核')
            loss_amount = data['order_data']['amount']
            loss_notes = data['order_data']['notes']
            for item in data['items']:
                detail = SaleOrderDetail.objects.filter(id=item['detail_id']).first()
                detail.receive_count = Formater.formatCount(item['receive_count'])
                detail.save()

            order.updateReceiveAmount()
            order.loss_amount = Formater.formatAmount(loss_amount)
            order.loss_notes = loss_notes
            order.save()
            BizLog.objects.addnew(
                request.user,
                BizLog.UPDATE,
                u"销售订单[%s]扣减，id=%d" % (order.no, order.id),
            )

    except CustomError, e:
        return JSONError(e.get_error_msg())
    except Exception, e:
        traceback.print_exc()
        return JSONError(u'保存失败')
    return JSONResponse({})


@csrf_exempt
@permission_required('order.pay_sale_order')
def sale_order_pay(request):
    id = request.GET.get('id')
    data = json.loads(request.body)

    try:
        with transaction.atomic():
            order = SaleOrder.getById(id)
            if order.status == settings.DEFAULT:
                raise CustomError(u'该订单尚未审核')
            if order.cleared:
                raise CustomError(u'该订单已结清')

            order.pay_amount += Formater.formatAmount(data['actual_amount'])
            order.save()
            total_amount = order.receive_amount - order.loss_amount

            if order.pay_amount >= total_amount:
                order.cleared = True
                order.save()

            income_data = {
                'referer_no': order.no,
                'type': dbFinanceIncome.SALE_ENTRY_PAY,
                'amount': data['actual_amount'],
                'account': data['account'],
                'check_status': settings.PASS,
                'check_user':request.user.id,
                'department':request.user.department_id,
                'check_time': timezone.now(),
                'notes': data['notes']
            }

            income = FinanceIncomeSerializer.factory(request.user, income_data)
            income.validSave()

    except CustomError, e:
        return JSONError(e.get_error_msg())
    except Exception, e:
        traceback.print_exc()
        return JSONError(u'保存失败')
    return JSONResponse({})


@csrf_exempt
@permission_required('order.pay_sale_order')
def sale_order_fare_save(request):
    id = request.GET.get('id')
    data = json.loads(request.body)

    try:
        with transaction.atomic():
            order = SaleOrder.getById(id)
            fare_amount = data['fare_amount']
            fare_account = data['fare_account']
            put_amount = data['put_amount']
            put_account = data['put_account']

            if fare_amount != 0:
                if not fare_account:
                    raise CustomError(u'请选择运费账户')
                fare_amount = Formater.formatAmount(fare_amount)
                order.fare_amount += fare_amount

                income_data = {
                    'referer_no': order.no,
                    'type': dbFinanceIncome.SALE_ENTRY_FARE,
                    'amount': -data['fare_amount'],
                    'account': fare_account,
                    'check_status': settings.PASS,
                    'check_user': request.user.id,
                    'department': request.user.department_id,
                    'check_time': timezone.now()
                }

                pb = FinanceIncomeSerializer.factory(request.user, income_data)
                pb.validSave()

            if put_amount != 0:
                if not put_account:
                    raise CustomError(u'请选择装车费账户')
                put_amount = Formater.formatAmount(put_amount)
                order.put_amount += put_amount

                income_data = {
                    'referer_no': order.no,
                    'type': dbFinanceIncome.SALE_ENTRY_UNLOAD,
                    'amount': -data['put_amount'],
                    'account': put_account,
                    'check_status': settings.PASS,
                    'check_user': request.user.id,
                    'department': request.user.department_id,
                    'check_time': timezone.now()
                }

                pb = FinanceIncomeSerializer.factory(request.user, income_data)
                pb.validSave()

            order.save()

    except CustomError, e:
        return JSONError(e.get_error_msg())
    except Exception, e:
        traceback.print_exc()
        return JSONError(u'保存失败')
    return JSONResponse({})


@csrf_exempt
@permission_required('order.pay_sale_order')
def sale_order_clear(request):
    id = request.GET.get('id')

    try:
        with transaction.atomic():
            order = SaleOrder.getById(id)
            if order.status == settings.DEFAULT:
                raise CustomError(u'该订单未审核')

            if order.cleared:
                raise CustomError(u'该订单已结清')

            order.cleared = True
            order.save()
            BizLog.objects.addnew(
                request.user,
                BizLog.CHECK,
                u"销售订单[%s]结清，id=%d" % (order.no, order.id),
            )

    except CustomError, e:
        return JSONError(e.get_error_msg())
    except Exception, e:
        traceback.print_exc()
        return JSONError(u'结清失败')
    return JSONResponse({})


@csrf_exempt
@permission_required('order.view_sale_order')
def sale_order_msg_save(request):
    id = request.GET.get('id')
    data = json.loads(request.body)

    try:
        with transaction.atomic():
            order = SaleOrder.getById(id)
            SaleOrderMessage.objects.filter(main=order).delete()
            options = Option.objects.filter(type=Option.SALE_MESSAGE, enabled=True)
            for option in options:
                content = data[str(int(option.id))]
                if content:
                    SaleOrderMessage.objects.create(main=order, item_id=option.id, content=content)

    except CustomError, e:
        return JSONError(e.get_error_msg())
    except Exception, e:
        traceback.print_exc()
        return JSONError(u'完善失败')
    return JSONResponse({})


@csrf_exempt
@permission_required('order.view_sale_order')
def sale_order_msg(request):
    id = request.GET.get('id')

    rows = Option.objects.filter(type=Option.SALE_MESSAGE, enabled=True)
    data = []
    for row in rows:
        item = {
            'id': row.id,
            'name': row.name,
            'content': ''
        }

        msg_row = SaleOrderMessage.objects.filter(main_id=id, item_id=row.id).first()
        if msg_row:
            item['content'] = msg_row.content

        data.append(item)

    return JSONResponse(data)

@csrf_exempt
@permission_required('order.export_sale_order')
def sale_order_export_detail(request):
    id = request.GET.get('id')
    serializer = SaleOrderDetailSerializer(SaleOrderDetail.objects.filter(main_id=id), many=True)
    export_data = ExportChange.dict_to_obj(serializer)
    export_data = SaleOrderDetailResource().export(export_data)
    filename = utils.attachment_save(export_data)
    BizLog.objects.addnew(request.user, BizLog.EXPORT, u"导出销售单明细")
    return JSONResponse({'filename': filename})

@token_required
def sale_order_select(request):
    param = request.GET.get('keywords')
    rows = SaleOrder.objects.filter()
    if param:
        rows = rows.filter(no__icontains=param)
        serializer = SaleOrderSerializer(rows, many=True)
        return JSONResponse(serializer.data)


@csrf_exempt
@permission_required('order.view_goods_deliver')
def deliver_list(request):
    product_notes = request.GET.get('product_notes')
    warehouses_ids = Warehouse.getManagerWarehouses(request.user)
    department_ids = request.user.getSubDepartmentIds()
    user_ids = request.user.getSubEmployeeIds()
    rows = GoodsDeliver.objects.filter(warehouse_id__in=warehouses_ids)
    rows = rows.filter(
        Q(department_id__in=department_ids) | Q(create_user_id__in=user_ids) | Q(create_user=request.user))

    if product_notes:
        g_ids = rows.values_list('id')
        d_ids = GoodsDeliverDetail.objects.filter(main_id__in=g_ids, notes__icontains=product_notes).values_list('main_id')
        rows = rows.filter(id__in=d_ids)
    f = GoodsDeliverFilter(request.GET, queryset=rows)
    total_row = f.qs.aggregate(total_count=Sum('total_count'), total_cost=Sum('total_cost'),
                               total_amount=Sum('total_amount'))
    more = {
        'total_count': Formater.formatCountShow(total_row['total_count']),
        'total_cost': Formater.formatAmountShow(total_row['total_cost']),
        'return_count': Formater.formatAmountShow(total_row['total_amount']),
    }
    rows, total = utils.get_page_data(request, f.qs)
    serializer = GoodsDeliverSerializer(rows, many=True)
    return DataGridJSONResponse(serializer.data, total, more)


@csrf_exempt
@permission_required('order.export_goods_deliver')
def deliver_export(request):
    id = request.GET.get('id')
    try:
        perm = 'goods.view_goods_cost'
        is_show_cost = isHasPermissions(request.user, perm)
        if id:
            instance = GoodsDeliver.getById(id)
            deliver_detail = GoodsDeliverDetail.objects.filter(main=instance)
            serializer = GoodsDeliverDetailSerializer(deliver_detail, many=True)
            export_data = ExportChange.dict_to_obj(serializer)
            export_data = GoodsDeliverDetailResource(is_show_cost).export(export_data)
            filename = utils.attachment_save(export_data)
            BizLog.objects.addnew(request.user, BizLog.EXPORT, u"导出成品出库单[%s]明细，id=%d" % (instance.no, instance.id))
        else:
            warehouses_ids = Warehouse.getManagerWarehouses(request.user)
            department_ids = request.user.getSubDepartmentIds()
            user_ids = request.user.getSubEmployeeIds()
            rows = GoodsDeliver.objects.filter(warehouse_id__in=warehouses_ids)
            rows = rows.filter(
                Q(department_id__in=department_ids) | Q(create_user_id__in=user_ids) | Q(create_user=request.user))
            f = GoodsDeliverFilter(request.GET, queryset=rows)
            serializer = GoodsDeliverSerializer(f.qs, many=True)
            export_data = ExportChange.dict_to_obj(serializer)
            export_data = GoodsDeliverResource(is_show_cost).export(export_data)
            filename = utils.attachment_save(export_data)
            BizLog.objects.addnew(request.user, BizLog.EXPORT, u"导出成品出库单")
    except CustomError, e:
        return JSONError(e.get_error_msg())
    except Exception, e:
        traceback.print_exc()
        return JSONError(u'导出失败！')
    return JSONResponse({'filename': filename})


@csrf_exempt
@permission_required('order.add_goods_deliver')
def deliver_save(request):
    source = request.GET.get('source')
    id = request.GET.get('id')
    detail_id = -1
    if source == 'touch':
        main_data = json.loads(request.body)['main']
        items_data = json.loads(request.body)['item']
        detail_id = json.loads(request.body)['detail']
    else:
        main_data = json.loads(request.POST.get('main'))
        items_data = json.loads(request.POST.get('item'))
    try:
        with transaction.atomic():
            serializer = GoodsDeliverSerializer.factory(request.user, main_data, id)
            if serializer.instance and serializer.instance.status == settings.PASS:
                raise CustomError(u'该出库单已审核，禁止修改！')
            serializer = serializer.validSave()
            if source == 'touch' and detail_id >= 0:
                # 手机端保存，如果是修改，先删除要修改的明细
                GoodsDeliverDetail.objects.filter(id=int(detail_id)).delete()
                for item in items_data:
                    product_base_id = Goods.getById(item['product_base']).product_base.id
                    warehouse_stock = WarehouseStock.getByWarehouseAndProduct(serializer.warehouse,product_base_id)
                    instance = GoodsDeliverDetail.objects.create(
                        main_id=id,
                        product_base_id=item['product_base'],
                        warehouse_stock=warehouse_stock,
                        warehouse_stockrecord_id=item['warehouse_stockrecord'],
                        total_cost=Formater.formatAmount(item['total_cost']),
                        count=Formater.formatCount(item['count']),
                        price=Formater.formatPrice(item['price']),
                        total_amount=Formater.formatPrice(item['price']) * Formater.formatCount(item['count']),
                        notes=item['notes'],
                    )
                    BizLog.objects.addnew(
                        request.user,
                        BizLog.INSERT,
                        u"APP添加原料/耗材出库明细[%s]，id=%d" % (instance.product_base.product_base.name, instance.id),
                        item
                    )
            else:
                GoodsDeliverDetail.objects.filter(main=serializer).delete()
                for item in items_data:
                    item['main'] = serializer.id
                    item['product_base'] = Goods.getByBaseId(item['product_base']).id
                    detail_serializer = GoodsDeliverDetailSerializer.factory(request.user, data=item)
                    detail_serializer.validSave()
            serializer.update_total()
    except CustomError, e:
        return JSONError(e.get_error_msg())
    except Exception, e:
        traceback.print_exc()
        return JSONError(u'保存失败！')
    return JSONResponse(serializer.id)


@csrf_exempt
@permission_required('order.delete_goods_deliver')
def deliver_delete(request):
    id = request.GET.get('id')
    try:
        with transaction.atomic():
            instance = GoodsDeliver.getById(id)
            if instance.status == settings.PASS:
                raise CustomError(u'该出库单已审核，禁止删除！')

            BizLog.objects.addnew(request.user, BizLog.DELETE, u"删除成品出库单[%s]，id=%d" % (instance.no, instance.id))
            GoodsDeliverDetail.objects.filter(main=instance).delete()
            instance.delete()
    except CustomError, e:
        return JSONError(e.get_error_msg())
    except ProtectedError:
        return JSONError(u'该出库单已被以用，禁止删除！')
    except IntegrityError:
        return JSONError(u'该出库单已被以用，禁止删除！')
    except Exception, e:
        traceback.print_exc()
        return JSONError(u'删除失败！')

    return JSONResponse({})


@token_required
def deliver_detail(request):
    id = request.GET.get('id')
    instance = GoodsDeliver.getById(id)
    company = instance.department.getCompany()
    if instance.status == settings.PASS:
        status_text = u'已审核'
    else:
        status_text = u'待审核'
    main_data = {
        'sale_order_id': instance.sale_order_id or '',
        'id': instance.id,
        'company': company.name,
        'sale_order_no': instance.sale_order and instance.sale_order.no or '',
        'customer_name': instance.customer and instance.customer.name or '',
        'customer_id': instance.customer_id or '',
        'customer_tel': instance.customer and instance.customer.mobile or '',
        'agent_user_id': instance.agent_user_id,
        'agent_user_name': instance.agent_user.name,
        'agent_department_name': instance.agent_department and instance.agent_department.name or '',
        'warehouse_id': instance.warehouse_id,
        'warehouse_name': instance.warehouse.name,
        'create_user_name': instance.create_user.name,
        'create_time': Formater.formatStrTime(instance.create_time),
        'total_count': Formater.formatCountShow(instance.total_count),
        'total_amount': Formater.formatAmountShow(instance.total_amount),
        'total_cost': Formater.formatAmountShow(instance.total_cost),
        'status': instance.status,
        'status_text': status_text,
        'check_user_text': instance.check_user and instance.check_user.name or ' ',
        'check_time': Formater.formatStrTime(instance.create_time),
        'notes': instance.notes,
        'no': instance.no
    }

    data = {
        'main_data': main_data,
        'items_data': []
    }
    detail_rows = GoodsDeliverDetail.objects.filter(main=instance)
    for detail_row in detail_rows:
        no = ''
        if detail_row.warehouse_stockrecord_id:
            godownentry = GoodsGodownEntryDetail.objects.filter(stock_record=detail_row.warehouse_stockrecord).first()
            if godownentry:
                no = godownentry.main.no
            else:
                no = InventoryDetail.objects.filter(warehouse_stock_record=detail_row.warehouse_stockrecord).first().main.no
        record_data = GetWarehouseSrockRecord.getRecord(detail_row.product_base.product_base.id, instance.warehouse_id)
        item_data = {
            'id': detail_row.product_base_id,
            'product_base': detail_row.product_base.product_base_id,
            'detail_id': detail_row.id,
            'name': detail_row.product_base.product_base.name,
            'model': detail_row.product_base.product_base.model,
            'total_cost': Formater.formatAmountShow(detail_row.total_cost),
            'total_amount': Formater.formatAmountShow(detail_row.total_amount),
            'count': Formater.formatCountShow(detail_row.count),
            'price': Formater.formatPriceShow(detail_row.price),
            'warehouse_stock_count': Formater.formatCountShow(detail_row.warehouse_stock.count),
            'unit': detail_row.product_base.product_base.unit or '',
            'notes': detail_row.notes or '',
            'entry_no': detail_row.warehouse_stockrecord_id,
            'record_data': record_data,
            'no': no,
        }
        data['items_data'].append(item_data)

    return JSONResponse(data)




@csrf_exempt
@permission_required('order.check_goods_deliver')
def deliver_check(request):
    id = request.GET.get('id')
    try:
        with transaction.atomic():
            instance = GoodsDeliver.getById(id)
            if instance.status == settings.PASS:
                raise CustomError(u'该出库单已审核')
            deliver_details = GoodsDeliverDetail.objects.filter(main=instance)
            for deliver_detail in deliver_details:
                if instance.sale_order:
                    type = WarehouseRecord.CK_XS
                else:
                    type = WarehouseRecord.CK_ZJ
                warehouse_record = BizWarehouse.deliveredByStockRecord(type,
                                                  deliver_detail.warehouse_stockrecord,
                                                  deliver_detail.count)
                deliver_detail.warehouse_record = warehouse_record
                deliver_detail.total_cost = -warehouse_record.amount
                deliver_detail.save()
            instance.update_total()
            instance.status = settings.PASS
            instance.check_user = request.user
            instance.check_time = timezone.now()
            BizLog.objects.addnew(
                request.user,
                BizLog.CHECK,
                u"审核成品出库[%s]，id=%d" % (instance.no, instance.id),
            )

            instance.save()
    except CustomError, e:
        return JSONError(e.get_error_msg())
    except Exception, e:
        traceback.print_exc()
        return JSONError(u'审核失败')
    return JSONResponse({})


@csrf_exempt
@permission_required('order.view_goods_deliver_query')
def deliver_query_list(request):# 成品出库查询
    rows = get_filter_data(request)
    total_row = rows.aggregate(total_count1=Sum('goods_deliver_detail_ref_warehouse_record__count'),
                               total_count2=Sum('inventory_details_ref_warehouse_record__count'),
                               total_cost1=Sum('goods_deliver_detail_ref_warehouse_record__total_cost'),
                               total_cost2=Sum('inventory_details_ref_warehouse_record__amount'),
                               total_amount=Sum('goods_deliver_detail_ref_warehouse_record__total_amount'),
                               return_count=Sum('goods_deliver_detail_ref_warehouse_record__return_count'),
                               return_cost=Sum('goods_deliver_detail_ref_warehouse_record__return_cost'))
    more = {
        'total_count': Formater.formatCountShow((total_row['total_count1'] or 0) + (total_row['total_count2'] or 0)),
        'total_cost': Formater.formatAmountShow((total_row['total_cost1'] or 0) + (total_row['total_cost2'] or 0)),
        'total_amount': Formater.formatAmountShow(total_row['total_amount']),
        'return_count': Formater.formatCountShow(total_row['return_count']),
        'return_cost': Formater.formatAmountShow(total_row['return_cost']),
    }
    rows, total = utils.get_page_data(request, rows)
    data = get_deliver_query_data(rows)
    return DataGridJSONResponse(data, total, more)

@csrf_exempt
@permission_required('order.export_goods_deliver_query')
def deliver_query_export(request):
    try:
        rows = get_filter_data(request)
        data = get_deliver_query_data(rows)
        export_data = ExportChange.dict_to_obj2(data)
        perm = 'goods.view_goods_cost'
        is_show_cost = isHasPermissions(request.user, perm)
        export_data = GoodsDeliverQueryResource(is_show_cost).export(export_data)
        filename = utils.attachment_save(export_data)
        BizLog.objects.addnew(request.user, BizLog.EXPORT, u"导出成品出库查询")
    except CustomError, e:
        return JSONError(e.get_error_msg())
    except Exception, e:
        traceback.print_exc()
        return JSONError(u'导出出库查询失败！')
    return JSONResponse({'filename': filename})


@token_required
def deliver_query_detail(request):
    rows = get_filter_data(request)
    data = get_deliver_query_data(rows)
    return JSONResponse(data)

def get_filter_data(request):
    happen_time = request.GET.get('happen_time')
    no = request.GET.get('no')
    create_user = request.GET.get('create_user')
    name = request.GET.get('name')
    model = request.GET.get('model')
    type = request.GET.get('type')
    warehouse = request.GET.get('warehouse')
    notes = request.GET.get('notes')
    rows = WarehouseRecord.objects.filter(product__type=2, type__in=[3,4,5]).order_by('-id')
    if happen_time:
        happen_time_begin = happen_time.split(' - ')[0]
        happen_time_end = happen_time.split(' - ')[1] + ' 23:59:59'
        rows = rows.filter(happen_time__gt=happen_time_begin,happen_time__lt=happen_time_end)
    if no:
        rows = rows.filter(Q(goods_deliver_detail_ref_warehouse_record__main__no__icontains=no) | Q(inventory_details_ref_warehouse_record__main__no__icontains=no))
    if create_user:
        rows = rows.filter(Q(goods_deliver_detail_ref_warehouse_record__main__create_user__name__icontains=create_user) |
                           Q(inventory_details_ref_warehouse_record__main__create_user__name__icontains=create_user))
    if notes:
        rows = rows.filter(Q(goods_deliver_detail_ref_warehouse_record__notes__icontains=notes) |
                           Q(inventory_details_ref_warehouse_record__notes__icontains=notes))
    if name:
        rows = rows.filter(product__name__icontains=name)
    if model:
        rows = rows.filter(product__model__icontains=model)
    if type:
        rows = rows.filter(type=type)
    if warehouse:
        rows = rows.filter(warehouse__name__icontains=warehouse)

    warehouses_ids = Warehouse.getManagerWarehouses(request.user)
    department_ids = request.user.getSubDepartmentIds()
    user_ids = request.user.getSubEmployeeIds()
    rows = rows.filter(warehouse_id__in=warehouses_ids)
    rows = rows.filter(
        Q(goods_deliver_detail_ref_warehouse_record__main__department_id__in=department_ids) |
        Q(goods_deliver_detail_ref_warehouse_record__main__create_user_id__in=user_ids) |
        Q(goods_deliver_detail_ref_warehouse_record__main__create_user=request.user) |
        Q(inventory_details_ref_warehouse_record__main__department_id__in=department_ids) |
        Q(inventory_details_ref_warehouse_record__main__create_user_id__in=user_ids) |
        Q(inventory_details_ref_warehouse_record__main__create_user=request.user)
    )
    return rows

def get_deliver_query_data(rows):
    rows = rows.values(
        'id',
        'type',
        'product__name',
        'product__model',
        'product__unit',
        'product__type',
        'product__warehouse_place',
        # 盘亏
        'inventory_details_ref_warehouse_record__count',
        'inventory_details_ref_warehouse_record__price',
        'inventory_details_ref_warehouse_record__amount',
        'inventory_details_ref_warehouse_record__notes',


        'warehouse__name',
        'happen_time',
        'cur_count',
        'goods_deliver_detail_ref_warehouse_record__count',
        'goods_deliver_detail_ref_warehouse_record__price',
        'goods_deliver_detail_ref_warehouse_record__total_cost',
        'goods_deliver_detail_ref_warehouse_record__total_amount',
        'goods_deliver_detail_ref_warehouse_record__return_count',
        'goods_deliver_detail_ref_warehouse_record__return_cost',
        'goods_deliver_detail_ref_warehouse_record__notes',
        'goods_deliver_detail_ref_warehouse_record__main__check_user__name',
        'goods_deliver_detail_ref_warehouse_record__main__create_user__name',
        'goods_deliver_detail_ref_warehouse_record__main__check_time',
        'goods_deliver_detail_ref_warehouse_record__main__no',
        'goods_deliver_detail_ref_warehouse_record__warehouse_stockrecord__goods_godown_entry_detail_ref_stock_record__main__no',
        'goods_deliver_detail_ref_warehouse_record__warehouse_stockrecord__inventory_details_ref_warehouse_stock_record__main__no',
        # 盘亏
        'inventory_details_ref_warehouse_record__main__no',
        'inventory_details_ref_warehouse_record__main__check_user__name',
        'inventory_details_ref_warehouse_record__main__create_user__name',
        'inventory_details_ref_warehouse_record__main__check_time',


    )
    data = []
    for row in rows:
        warehouse_record_type = WarehouseRecord.TYPE_CHOICES[row['type']][1]
        product_type_text = ProductBase.TYPE_CHOICES[row['product__type']][1]

        no = row['goods_deliver_detail_ref_warehouse_record__main__no']
        check_user = row['goods_deliver_detail_ref_warehouse_record__main__check_user__name']
        create_user = row['goods_deliver_detail_ref_warehouse_record__main__create_user__name']
        check_time = Formater.formatStrTime(row['goods_deliver_detail_ref_warehouse_record__main__check_time'])
        notes = row['goods_deliver_detail_ref_warehouse_record__notes']
        name = row['product__name']
        model = row['product__model']
        unit = row['product__unit']
        warehouse_place = row['product__warehouse_place']
        count = Formater.formatCountShow(row['goods_deliver_detail_ref_warehouse_record__count'])
        entry_no = row['goods_deliver_detail_ref_warehouse_record__warehouse_stockrecord__goods_godown_entry_detail_ref_stock_record__main__no']
        if not entry_no:
            entry_no = row['goods_deliver_detail_ref_warehouse_record__warehouse_stockrecord__inventory_details_ref_warehouse_stock_record__main__no']
        price = Formater.formatPriceShow(row['goods_deliver_detail_ref_warehouse_record__price'])
        total_cost = Formater.formatAmountShow(row['goods_deliver_detail_ref_warehouse_record__total_cost'])
        total_amount = Formater.formatAmountShow(row['goods_deliver_detail_ref_warehouse_record__total_amount'])
        return_count = Formater.formatCountShow(row['goods_deliver_detail_ref_warehouse_record__return_count'])
        return_cost = Formater.formatAmountShow(row['goods_deliver_detail_ref_warehouse_record__return_cost'])

        if row['type'] == WarehouseRecord.CK_PK:
            no = row['inventory_details_ref_warehouse_record__main__no']
            entry_no = ''
            check_user = row['inventory_details_ref_warehouse_record__main__check_user__name']
            create_user = row['inventory_details_ref_warehouse_record__main__create_user__name']
            check_time = Formater.formatStrTime(row['inventory_details_ref_warehouse_record__main__check_time'])
            notes = row['inventory_details_ref_warehouse_record__notes']
            count = Formater.formatCountShow(row['inventory_details_ref_warehouse_record__count'])
            price = Formater.formatPriceShow(row['inventory_details_ref_warehouse_record__price'])
            total_cost = Formater.formatAmountShow(row['inventory_details_ref_warehouse_record__amount'])
            total_amount = '0.0000'
            return_count = '0.00'
            return_cost = '0.0000'

        item = {
            'id': row['id'],
            'type': warehouse_record_type,
            'product_type': product_type_text,

            'name': name,
            'model': model,
            'unit': unit,
            'warehouse_place': warehouse_place,

            'warehouse': row['warehouse__name'],
            'happen_time': Formater.formatStrTime(row['happen_time']),
            'cur_count': Formater.formatCountShow(row['cur_count']),

            'count': count,
            'price': price,
            'total_cost': total_cost,
            'total_amount': total_amount,
            'return_count': return_count,
            'return_cost': return_cost,

            'check_user': check_user,
            'create_user': create_user,
            'check_time': check_time,
            'notes': notes,
            'no': no,
            'entry_no': entry_no,
        }
        data.append(item)
    return data


@csrf_exempt
@permission_required('order.view_goods_deliver_return')
def deliver_return_list(request):
    product_notes = request.GET.get('product_notes')
    warehouses_ids = Warehouse.getManagerWarehouses(request.user)
    department_ids = request.user.getSubDepartmentIds()
    user_ids = request.user.getSubEmployeeIds()
    rows = GoodsDeliver.objects.filter(status=settings.PASS, warehouse_id__in=warehouses_ids)
    rows = rows.filter(
        Q(department_id__in=department_ids) | Q(create_user_id__in=user_ids) | Q(create_user=request.user))

    if product_notes:
        g_ids = rows.values_list('id')
        d_ids = GoodsDeliverDetail.objects.filter(main_id__in=g_ids, notes__icontains=product_notes).values_list('main_id')
        rows = rows.filter(id__in=d_ids)
    f = GoodsDeliverReturnFilter(request.GET, queryset=rows)
    total_row = f.qs.aggregate(total_count=Sum('total_count'), total_cost=Sum('total_cost'),
                               total_amount=Sum('total_amount'), return_count=Sum('return_count'),
                               return_cost=Sum('return_cost'))
    more = {
        'total_count': Formater.formatCountShow(total_row['total_count']),
        'total_cost': Formater.formatAmountShow(total_row['total_cost']),
        'total_amount': Formater.formatAmountShow(total_row['total_amount']),
        'return_count': Formater.formatCountShow(total_row['return_count']),
        'return_cost': Formater.formatAmountShow(total_row['return_cost']),
    }
    rows, total = utils.get_page_data(request, f.qs)
    serializer = GoodsDeliverReturnViewSerializer(rows, many=True)
    return DataGridJSONResponse(serializer.data, total, more)

@token_required
def deliver_return_select_list(request):
    id = int(request.GET.get('id'))

    ids = GoodsDeliverReturnDetail.objects.filter(deliver_detail__main_id=id).values_list('main_id', flat=True)
    rows = GoodsDeliverReturn.objects.filter(id__in=ids)
    data = []
    for row in rows:
        data.append(row)
    serializer = GoodsDeliverReturnSerializer(data, many=True)
    return DataGridJSONResponse(serializer.data, rows.count())

@token_required
def deliver_return_detail(request):
    id = request.GET.get('id')
    ids = request.GET.get('ids')
    data = {
        'main_data': '',
        'deliver_data': [],
        'items_data': []
    }
    if ids:
        id_list = ids.split(',')
        deliver_returns = GoodsDeliverReturn.getByIds(id_list)
        for deliver_return in deliver_returns:
            deliver_data = {
                'no': deliver_return.no,
                'return_count': Formater.formatCountShow(deliver_return.return_count),
                'return_cost': Formater.formatAmountShow(deliver_return.return_cost),
                'reason': deliver_return.reason
            }
            data['deliver_data'].append(deliver_data)
    instance = GoodsDeliver.getById(id)
    company = instance.department.getCompany()
    main_data = {
        'customer_name': instance.customer and instance.customer.name or '',
        'customer_tel': instance.customer and instance.customer.mobile or '',
        'total_amount': Formater.formatAmountShow(instance.total_amount),
        'warehouse_id': instance.warehouse_id,
        'warehouse_name': instance.warehouse.name,
        'create_user_name': instance.create_user.name,
        'create_time': Formater.formatStrTime(instance.create_time),
        'total_count': Formater.formatCountShow(instance.total_count),
        'total_cost': Formater.formatAmountShow(instance.total_cost),
        'return_count': Formater.formatCountShow(instance.return_count),
        'return_cost': Formater.formatAmountShow(instance.return_cost),
        'notes': instance.notes,
        'no': instance.no,
        'company': company.name,
    }
    data['main_data'] = main_data
    detail_rows = GoodsDeliverDetail.objects.filter(main=instance)
    for detail_row in detail_rows:
        item_data = {
            'id': detail_row.id,
            'product_id': detail_row.product_base.id,
            'name': detail_row.product_base.product_base.name,
            'model': detail_row.product_base.product_base.model,
            'total_cost': Formater.formatAmountShow(detail_row.total_cost),
            'total_amount': Formater.formatAmountShow(detail_row.total_amount),
            'count': Formater.formatCountShow(detail_row.count),
            'price': Formater.formatPriceShow(detail_row.price),
            'warehouse_stock_count': Formater.formatCountShow(detail_row.warehouse_stock.count),
            'unit': detail_row.product_base.product_base.unit or '',
            'cur_count': Formater.formatCountShow(detail_row.count - detail_row.return_count),
            'notes': detail_row.notes or ''
        }
        data['items_data'].append(item_data)

    return JSONResponse(data)

@csrf_exempt
@permission_required('order.add_goods_deliver_return')
def deliver_return_save(request):
    id = request.GET.get('id')
    main_data = json.loads(request.POST.get('main'))
    items_data = json.loads(request.POST.get('item'))
    try:
        with transaction.atomic():
            serializer = GoodsDeliverReturnSerializer.factory(request.user, main_data)
            serializer = serializer.validSave()
            for item in items_data:
                item['main'] = serializer.id
                detail_serializer = GoodsDeliverReturnDetailSerializer.factory(request.user, data=item)
                detail_serializer = detail_serializer.validSave()
                detail_serializer.deliver_detail.updateReturn()
            serializer.update_total()
            deliver = GoodsDeliver.getById(id)
            deliver.update_return()
    except CustomError, e:
        return JSONError(e.get_error_msg())
    except Exception, e:
        traceback.print_exc()
        return JSONError(u'保存失败！')
    return JSONResponse()



@csrf_exempt
@permission_required('order.view_goods_deliver_return_query')
def deliver_return_query_list(request):# 成品退库查询
    rows = get_return_filter_data(request)
    total_row = rows.aggregate(return_count=Sum('goods_return_deliver_detail_ref_warehouse_record__return_count'),
                               return_cost=Sum('goods_return_deliver_detail_ref_warehouse_record__return_cost'))
    more = {
        'return_count': Formater.formatCountShow(total_row['return_count']),
        'return_cost': Formater.formatAmountShow(total_row['return_cost']),
    }
    rows, total = utils.get_page_data(request, rows)
    data = get_deliver_return_query_data(rows)
    return DataGridJSONResponse(data, total, more)

@csrf_exempt
@permission_required('order.export_goods_deliver_return_query')
def deliver_return_query_export(request):
    try:
        rows = get_return_filter_data(request)
        data = get_deliver_return_query_data(rows)
        export_data = ExportChange.dict_to_obj2(data)
        perm = 'goods.view_goods_cost'
        is_show_cost = isHasPermissions(request.user, perm)
        export_data = GoodsDeliverReturnQueryResource(is_show_cost).export(export_data)
        filename = utils.attachment_save(export_data)
        BizLog.objects.addnew(request.user, BizLog.EXPORT, u"导出成品退库查询")
    except CustomError, e:
        return JSONError(e.get_error_msg())
    except Exception, e:
        traceback.print_exc()
        return JSONError(u'导出成品退库查询失败！')
    return JSONResponse({'filename': filename})


@token_required
def deliver_return_query_detail(request):
    rows = get_return_filter_data(request)
    data = get_deliver_return_query_data(rows)
    return JSONResponse(data)

def get_return_filter_data(request):
    create_time = request.GET.get('create_time')
    warehouse = request.GET.get('warehouse')
    return_no = request.GET.get('return_no')
    no = request.GET.get('no')
    name = request.GET.get('name')
    model = request.GET.get('model')
    reason = request.GET.get('reason')
    notes = request.GET.get('notes')
    create_user = request.GET.get('create_user')
    rows = WarehouseRecord.objects.filter(product__type=2, type=7).order_by('-id')
    if create_time:
        create_time_begin = create_time.split(' - ')[0]
        create_time_end = create_time.split(' - ')[1] + ' 23:59:59'
        rows = rows.filter(goods_return_deliver_detail_ref_warehouse_record__main__create_time__gt=create_time_begin,
                           goods_return_deliver_detail_ref_warehouse_record__main__create_time__lt=create_time_end)
    if no:
        rows = rows.filter(goods_return_deliver_detail_ref_warehouse_record__deliver_detail__main__no__icontains=no)
    if create_user:
        rows = rows.filter(goods_return_deliver_detail_ref_warehouse_record__main__create_user__name__icontains=create_user)
    if warehouse:
        rows = rows.filter(goods_return_deliver_detail_ref_warehouse_record__deliver_detail__main__warehouse__name__icontains=warehouse)
    if return_no:
        rows = rows.filter(
            goods_return_deliver_detail_ref_warehouse_record__main__no__icontains=return_no)
    if notes:
        rows = rows.filter(
            goods_return_deliver_detail_ref_warehouse_record__notes__icontains=notes)
    if reason:
        rows = rows.filter(goods_return_deliver_detail_ref_warehouse_record__main__reason__icontains=reason)
    if name:
        rows = rows.filter(goods_return_deliver_detail_ref_warehouse_record__product_base__name__icontains=name)
    if model:
        rows = rows.filter(goods_return_deliver_detail_ref_warehouse_record__product_base__name__icontains=model)
    warehouses_ids = Warehouse.getManagerWarehouses(request.user)
    department_ids = request.user.getSubDepartmentIds()
    user_ids = request.user.getSubEmployeeIds()
    rows = rows.filter(warehouse_id__in=warehouses_ids)
    rows = rows.filter(
        Q(goods_return_deliver_detail_ref_warehouse_record__main__department_id__in=department_ids)
        | Q(goods_return_deliver_detail_ref_warehouse_record__main__create_user_id__in=user_ids)
        | Q(goods_return_deliver_detail_ref_warehouse_record__main__create_user=request.user))
    return rows

def get_deliver_return_query_data(rows):
    rows = rows.values(
        'id',
        'type',
        'goods_return_deliver_detail_ref_warehouse_record__product_base__product_base__name',
        'goods_return_deliver_detail_ref_warehouse_record__product_base__product_base__model',
        'goods_return_deliver_detail_ref_warehouse_record__product_base__product_base__type',
        'goods_return_deliver_detail_ref_warehouse_record__product_base__product_base__warehouse_place',
        'warehouse__name',
        'cur_count',
        'goods_return_deliver_detail_ref_warehouse_record__return_count',
        'goods_return_deliver_detail_ref_warehouse_record__return_cost',
        'goods_return_deliver_detail_ref_warehouse_record__notes',
        'goods_return_deliver_detail_ref_warehouse_record__main__create_user__name',
        'goods_return_deliver_detail_ref_warehouse_record__main__create_time',
        'goods_return_deliver_detail_ref_warehouse_record__main__reason',
        'goods_return_deliver_detail_ref_warehouse_record__main__no',
        'goods_return_deliver_detail_ref_warehouse_record__deliver_detail__main__no',
    )
    data = []
    for row in rows:
        warehouse_record_type = WarehouseRecord.TYPE_CHOICES[row['type']][1]
        product_type_text = ProductBase.TYPE_CHOICES[row['goods_return_deliver_detail_ref_warehouse_record__product_base__product_base__type']][1]
        item = {
            'id': row['id'],
            'type': warehouse_record_type,
            'product_type': product_type_text,

            'name': row['goods_return_deliver_detail_ref_warehouse_record__product_base__product_base__name'],
            'model': row['goods_return_deliver_detail_ref_warehouse_record__product_base__product_base__model'],
            'warehouse_place': row['goods_return_deliver_detail_ref_warehouse_record__product_base__product_base__warehouse_place'],

            'warehouse': row['warehouse__name'],
            'cur_count': Formater.formatCountShow(row['cur_count']),

            'create_user': row['goods_return_deliver_detail_ref_warehouse_record__main__create_user__name'],
            'notes': row['goods_return_deliver_detail_ref_warehouse_record__notes'],
            'create_time': Formater.formatStrTime(row['goods_return_deliver_detail_ref_warehouse_record__main__create_time']),
            'return_count': Formater.formatCountShow(row['goods_return_deliver_detail_ref_warehouse_record__return_count']),
            'return_cost': Formater.formatAmountShow(row['goods_return_deliver_detail_ref_warehouse_record__return_cost']),
            'reason': row['goods_return_deliver_detail_ref_warehouse_record__main__reason'],
            'return_no': row['goods_return_deliver_detail_ref_warehouse_record__main__no'],

            'no': row['goods_return_deliver_detail_ref_warehouse_record__deliver_detail__main__no']
        }
        data.append(item)
    return data