MTP20_WEB_GLOBAL/src/business/trade/index.ts

import { reactive, ref, shallowRef, computed } from 'vue'
import { v4 } from 'uuid'
import { ClientType, EBuildType, EDelistingType, EListingSelectType, EOperateType, EOrderOperateType, EValidType, OrderSrc } from '@/constants/client'
import { useLoginStore, useAccountStore } from '@/stores'
import {
    spotPresaleDestingOrder,
    spotPresaleTransferCancel,
    spotPresaleTransferDesting,
    spotPresaleTransferListing,
    spotPresalePlayment,
    wrListingCancelOrder,
    spotPresaleDeliveryConfirm,
    wrOutApply,
    spotPresaleBreachOfContractApply,
    hdWROrder,
    hdWRDealOrder,
    thjProfitDrawApply,
    spotPresalePointPrice,
    cancelOrder,
    holderClose,
    order
} from '@/services/api/trade'
import { formatDate } from "@/filters";
import Long from 'long'
import { BuyOrSell } from '@/constants/order'

const loginStore = useLoginStore()
const accountStore = useAccountStore()


// 采购摘牌
export function usePurchaseOrderDesting() {
    const loading = shallowRef(false)

    const formData = ref<Partial<Proto.SpotPresaleDestingOrderReq>>({
        UserID: loginStore.userId, // 用户ID，必填
        AccountID: accountStore.accountId, // 资金账号，必填
        ClientType: ClientType.Web, // 终端类型
        UpdatorID: loginStore.loginId, // 操作人，必填
    })

    const formSubmit = async () => {
        try {
            loading.value = true
            return await spotPresaleDestingOrder({
                data: {
                    ...formData.value,
                    Qty: Number(formData.value.Qty),
                    ClientSerialNo: v4() // 客户端流水号
                }
            })
        } finally {
            loading.value = false
        }
    }

    return {
        loading,
        formData,
        formSubmit,
    }
}

// 铁合金现货预售交收确认
export function useSpotPresaleDeliveryConfirm() {
    const loading = shallowRef(false)

    const confirmSubmit = async (id: string) => {
        try {
            loading.value = true
            return await spotPresaleDeliveryConfirm({
                data: {
                    UserID: loginStore.userId,
                    Remark: '',
                    WRTradeDetailID: Long.fromString(id),
                    ClientSerialNo: v4(),
                    ClientType: ClientType.Web // 终端类型
                }
            })
        } finally {
            loading.value = false
        }
    }

    return {
        loading,
        confirmSubmit
    }
}

// 铁合金现货预售违约申请
export function useSpotPresaleBreachOfContractApply() {
    const loading = shallowRef(false)

    const applySubmit = async (id: string) => {
        try {
            loading.value = true
            return await spotPresaleBreachOfContractApply({
                data: {
                    UserID: loginStore.userId,
                    WRTradeDetailID: Long.fromString(id),
                    ClientSerialNo: v4(),
                    ClientType: ClientType.Web // 终端类型
                }
            })
        } finally {
            loading.value = false
        }
    }

    return {
        loading,
        applySubmit,
    }
}

// 铁合金现货预售付款处理接口
export function useSpotPresalePlayment() {
    const loading = shallowRef(false)

    const formData = reactive<Partial<Proto.SpotPresalePlaymentReq>>({
        UserID: loginStore.userId, // 用户ID，必填
        ClientType: ClientType.Web, // 终端类型
        ClientSerialNo: v4(), // 客户端流水号
    })

    const playmentSubmit = async (id: string) => {
        try {
            loading.value = true
            return await spotPresalePlayment({
                data: {
                    ...formData,
                    WRTradeDetailID: Long.fromString(id),
                }
            })
        } finally {
            loading.value = false
        }
    }

    return {
        loading,
        playmentSubmit
    }
}

// 铁合金现货预售转让挂牌接口
export function useSpotPresaleTransferListing() {
    const loading = shallowRef(false)

    const formData = reactive<Partial<Proto.SpotPresaleTransferListingReq>>({
        UserID: loginStore.userId, // 用户ID，必填
        ClientType: ClientType.Web, // 终端类型
        ClientSerialNo: v4(), // 客户端流水号
    })

    const listingSubmit = async (id: string) => {
        try {
            loading.value = true
            /// 转让价格不能为0
            if (!formData.TransferPrice) {
                return Promise.reject('转让价格不能为0')
            }

            return await spotPresaleTransferListing({
                data: {
                    ...formData,
                    WRTradeDetailID: Long.fromString(id),
                }
            })
        } finally {
            loading.value = false
        }
    }

    return {
        loading,
        formData,
        listingSubmit
    }
}

// 铁合金现货预售转让撤销接口请求
export function useSpotPresaleTransferCancel() {
    const loading = shallowRef(false)

    const transferCancelSubmit = async (wrtradedetailid?: string) => {
        try {
            loading.value = true
            return await spotPresaleTransferCancel({
                data: {
                    UserID: loginStore.userId,
                    WRTradeDetailID: Long.fromString(wrtradedetailid ?? '0'),
                    ClientSerialNo: v4(),
                    ClientType: ClientType.Web // 终端类型
                }
            })
        } finally {
            loading.value = false
        }
    }

    return {
        loading,
        transferCancelSubmit
    }
}

// 铁合金现货预售转让摘牌接口请求
export function useSpotPresaleTransferDesting() {
    const loading = shallowRef(false)

    const formData = reactive<Proto.SpotPresaleTransferDestingReq>({
        UserID: loginStore.userId,
        AccountID: accountStore.accountId,
        TransferID: Long.fromNumber(0),
        ClientType: ClientType.Web // 终端类型
    })

    const destingSubmit = async () => {
        try {
            loading.value = true
            return await spotPresaleTransferDesting({
                data: {
                    ...formData,
                    ClientSerialNo: v4(), // 客户端流水号
                }
            })
        } finally {
            loading.value = false
        }
    }

    return {
        loading,
        formData,
        destingSubmit
    }
}

// 挂牌撤单请求接口
export function useWrListingCancelOrder() {
    const loading = shallowRef(false)

    const cancelSubmit = async (id: string, buyorsell: number) => {
        try {
            loading.value = true
            return await wrListingCancelOrder({
                data: {
                    UserID: loginStore.userId,
                    AccountID: accountStore.accountId,
                    OperatorID: loginStore.loginId,
                    OrderSrc: OrderSrc.ORDERSRC_CLIENT,
                    OldWRTradeOrderID: Long.fromString(id),
                    ClientOrderTime: formatDate(new Date().toString(), 'YYYY-MM-DD HH:mm:ss'),
                    ClientSerialNo: v4(),
                    ClientType: ClientType.Web,
                    BuyOrSell: buyorsell,
                }
            })
        } finally {
            loading.value = false
        }
    }

    return {
        loading,
        cancelSubmit
    }
}

// 仓单明细提货请求接口
export function useWrOutInApply(holdlb: Model.HoldLBRsp) {
    const loading = shallowRef(false)
    const orderQty = shallowRef(0.0)

    const formData = reactive<Partial<Proto.WROutApplyReq>>({
        AppointmentRemark: '',
        UserID: loginStore.userId,             // 用户ID，必填
        AccountID: accountStore.accountId,  // 申请人账户ID
        CreatorID: loginStore.loginId,         // 创建人ID
        WRStandardID: holdlb.wrstandardid,
        WarehouseID: holdlb.warehouseid,
        AppointmentModel: 1,
        ClientSerialID: new Date().getTime(),    // 客户端流水号
        AppointmentDate: formatDate(new Date().toISOString(), 'YYYY-MM-DD'),
    })

    const applySubmit = async () => {
        try {
            loading.value = true
            return await wrOutApply({
                data: {
                    ...formData,
                    WROutInDetails: [{
                        LadingBillID: holdlb.ladingbillid,
                        SubNum: holdlb.subnum,
                        Qty: orderQty.value,
                        OutQty: orderQty.value,
                    }]
                }
            })
        } finally {
            loading.value = false
        }
    }

    return {
        loading,
        formData,
        applySubmit,
        orderQty,
    }
}

// 仓单明细挂牌请求接口
export function useHdWROrder() {
    const loading = shallowRef(false)

    const formData = reactive<Proto.HdWROrderReq>({
        IsSpecified: 0,
        PriceFactor: 1.0,
        FirstRatio: 0.0,
        CanBargain: 0,
        CanPart: 1,
        UserID: loginStore.userId,
        AccountID: accountStore.accountId,
        OperatorID: loginStore.loginId,
        ClientType: ClientType.Web,
        BuyOrSell: BuyOrSell.Sell,
        WRPriceType: 1,
        MarginFlag: 0,
        TimevalidType: 4,
        HasWr: 1,
        PerformanceTemplateID: -1,
    })

    const amount = computed(() => {
        const { OrderQty = 0, FixedPrice = 0 } = formData
        return (OrderQty * FixedPrice).toFixed(2)
    })

    const listingSubmit = async () => {
        try {
            loading.value = true
            const date = new Date().toISOString()

            return await hdWROrder({
                data: {
                    ...formData,
                    TradeDate: formatDate(date, 'YYYYMMDD'),
                    ClientSerialNo: v4(),
                    ClientOrderTime: formatDate(date),
                }
            })
        } finally {
            loading.value = false
        }
    }

    return {
        loading,
        formData,
        listingSubmit,
        amount
    }
}

// 仓单摘牌
export function useHdWRDealOrder() {
    const loading = shallowRef(false)

    const formData = reactive<Proto.HdWRDealOrderReq>({
        UserID: loginStore.userId, // 用户ID
        AccountID: accountStore.accountId, // 资金账号
        RelatedWRTradeOrderID: '0', // 关联委托单号(摘牌委托关联挂牌委托单ID)
        WRTransferUserID: loginStore.userId, // 仓单受让用户
        OrderQty: 0, // 委托数量
        OrderSrc: OrderSrc.ORDERSRC_CLIENT, // 委托来源
        ClientSerialNo: '', // 客户端流水号
        ClientOrderTime: '', // 客户端委托时间
        ClientType: ClientType.Web, // 终端类型
        OperatorID: loginStore.loginId, // 操作员账号ID
        TradeDate: '', // 交易日
        HasWr: 1, // 是否有仓单-0:没有仓单1:有仓单
        IsFinancing: 0, // 是否融资购买(买摘牌时有效)-0:否1:是
    })

    const formSubmit = async () => {
        try {
            loading.value = true
            const date = new Date().toISOString()

            return await hdWRDealOrder({
                data: {
                    ...formData,
                    TradeDate: formatDate(date, 'YYYYMMDD'),
                    ClientSerialNo: v4(),
                    ClientOrderTime: formatDate(date),
                }
            })
        } finally {
            loading.value = false
        }
    }

    return {
        loading,
        formData,
        formSubmit,
    }
}

// 铁合金收益支取申请接口
export function useTHJProfitDrawApplyReq() {
    const loading = shallowRef(false)

    const formData = reactive<Proto.THJProfitDrawApplyReq>({
        UserID: loginStore.userId, // 用户ID
        ApplySrc: ClientType.Web,
        ApplyerID: loginStore.loginId,
        ClientType: ClientType.Web
    })

    const onSubmit = async (drawMonth: string, amount: number) => {
        try {
            loading.value = true
            return await thjProfitDrawApply({
                data: {
                    ...formData,
                    DrawMonth: formatDate(drawMonth, 'YYYYMM'),
                    DrawAmount: amount,
                    ClientSerialNo: v4(),
                }
            })
        } finally {
            loading.value = false
        }
    }

    return {
        loading,
        formData,
        onSubmit,
    }
}

// 铁合金预售点价
export function useSpotPresalePointPrice(WRTradeDetailID = '0') {
    const loading = shallowRef(false)

    const formData = reactive<Proto.SpotPresalePointPriceReq>({
        UserID: loginStore.userId, // 用户ID，必填
        WRTradeDetailID: Long.fromString(WRTradeDetailID), // 预售成交明细ID
        ClientType: ClientType.Web, // 终端类型
        ClientSerialNo: '' // 客户端流水号
    })

    const formSubmit = async () => {
        try {
            loading.value = true
            return await spotPresalePointPrice({
                data: {
                    ...formData,
                    ClientSerialNo: v4(),
                }
            })
        } finally {
            loading.value = false
        }
    }

    return {
        loading,
        formData,
        formSubmit,
    }
}

// 撤单请求接口
export function useCancelOrder() {
    const loading = shallowRef(false)
    /// 参数信息
    const formData = reactive<Partial<Proto.CancelOrderReq>> ({
        OperatorID: loginStore.loginId,
        OrderSrc: OrderSrc.ORDERSRC_CLIENT,
        AccountID: accountStore.accountId,
        ClientSerialNo: v4(),
        ClientOrderTime: formatDate(new Date().toString(), 'YYYY-MM-DD HH:mm:ss'),
        ClientType: ClientType.Web,
        OperateType: EOperateType.OPERATETYPE_ORDERCANCEL,
    })
    const cancelSubmit = async (orderid: string) => {
        try {
            loading.value = true
            return await cancelOrder({
                data: {
                    ...formData,
                    OldOrderId: orderid
                }
            })
        } finally {
            loading.value = false
        }
    }

    return {
        loading,
        cancelSubmit,
        formData
    }
}

// 按单平仓
export function useHolderClose() {
    const loading = shallowRef(false)

    /// 参数信息
    const formData = reactive<Partial<Proto.HolderCloseReq>>({
        ClientSerialNo: v4(),
        ClientOrderTime: formatDate(new Date().toString(), 'YYYY-MM-DD HH:mm:ss'),
        ClientType: ClientType.Web,
        LoginID: loginStore.loginId,
        AccountID: accountStore.accountId,
        OrderSrc: OrderSrc.ORDERSRC_CLIENT,
        OperatorID: loginStore.loginId,
    })

    const holderCloseSubmit = async () => {
        try {
            loading.value = true
            return await holderClose({
                data: {
                    ...formData
                }
            })
        } finally {
            loading.value = false
        }
    }

    return {
        formData,
        loading,
        holderCloseSubmit
    }
}

// 交易委托
export function useOrder() {
    const loading = shallowRef(false)

    const formData = reactive<Partial<Proto.OrderReq>>({
        ClientSerialNo: v4(),
        ClientOrderTime: formatDate(new Date().toISOString()),
        ClientType: ClientType.Web,
        LoginID: loginStore.loginId,
        AccountID: accountStore.accountId,
        ValidType: EValidType.VALIDTYPE_DR,
        OperateType: EOrderOperateType.ORDEROPERATETYPE_NORMAL,
        OrderSrc: OrderSrc.ORDERSRC_CLIENT,
        OperatorID: loginStore.loginId,
        ListingSelectType: EListingSelectType.LISTINGSELECTTYPE_DELISTING,
        DelistingType: EDelistingType.DELISTINGTYPE_SELECTED,
        BuildType: EBuildType.BUILDTYPE_OPEN,
        TimevalidType: 1,
        OrderFlag: 1,
    })

    const formSubmit = async () => {
        try {
            loading.value = true

            return await order({
                data: formData
            })
        } finally {
            loading.value = false
        }
    }

    return {
        loading,
        formData,
        formSubmit
    }
}