feat: 企业

wupengfei

9 天以前 61c935836c947aaf3421731045d024d064cc6688

 src/views/EnterpriseManage/EnterpriseManageList.vue

@@ -5,8 +5,8 @@
        <template #query>
          <QueryFilterItem tip-content="配置状态">
            <FieldRadio
              v-model="extraParamState.flexEnterpriseSettingStatus"
              :value-enum="FlexEnterpriseSettingStatusText"
              v-model="extraParamState.isConfigured"
              :value-enum="IsConfiguredText"
              buttonStyle
              showAllBtn
              @change="getList()"
@@ -14,8 +14,8 @@
          </QueryFilterItem>
          <QueryFilterItem>
            <SearchInput
              v-model="extraParamState.searchWord"
              style="width: 200px"
              v-model="extraParamState.keywords"
              style="width: 300px"
              placeholder="企业名称/法人/联系人"
              @on-click-search="getList"
              @keyup.enter="getList()"
@@ -54,23 +54,10 @@
  FieldRadio,
} from '@bole-core/components';
import { useAccess, useGlobalEventContext } from '@/hooks';
import * as flexEnterpriseServices from '@/services/api/FlexEnterprise';
import {
  SearchType,
  FlexEnterpriseSettingStatusText,
  FlexEnterpriseSettingStatus,
  FlexEnterpriseCertificationStatusText,
  EnterpriseConfigureType,
  MessageChannelEnum,
  VerifyStatus,
  SignChannelEnum,
  ChargeTypeEnum,
  FlexEnterpriseStatus,
} from '@/constants';
import { EnterpriseConfigureType, IsConfiguredText } from '@/constants';
import ConfigureDialog from './components/ConfigureDialog.vue';
import { OrderInputType, Message } from '@bole-core/core';
import { useQueryClient } from '@tanstack/vue-query';
import { useSearchSettingType } from '@/hooks';
import { Message } from '@bole-core/core';
import * as enterpriseServices from '@/services/api/enterprise';

defineOptions({
  name: 'EnterpriseManageList',
@@ -80,7 +67,6 @@
  editBtn: { emits: { onClick: (role) => addOrEditEnterprise(role) } },
  detailBtn: { emits: { onClick: (role) => handleDetail(role) } },
  configBtn: { emits: { onClick: (role) => openDialog(role) } },
  freezeBtn: { emits: { onClick: (role) => handleSetStatus(role) } },
};

const { checkSubModuleItemShow, column, operationBtns } = useAccess({
@@ -102,10 +88,6 @@
const BaseState = {
  loading: true,
};
const queryClient = useQueryClient();
const { searchSettingTypeList: typeList } = useSearchSettingType({
  searchType: SearchType.IndustryCategory,
});

const state = reactive({ ...BaseState });

@@ -123,17 +105,17 @@
} = useTable(
  async ({ pageIndex, pageSize }, extraParamState) => {
    try {
      let params: API.GetFlexEnterpriseInput = {
      let params: API.GetEnterprisesQuery = {
        pageModel: {
          rows: pageSize,
          page: pageIndex,
          orderInput: extraParamState.orderInput,
        },
        flexEnterpriseSettingStatus: extraParamState.flexEnterpriseSettingStatus,
        searchWord: extraParamState.searchWord,
        isConfigured: extraParamState.isConfigured,
        keywords: extraParamState.keywords,
      };

      let res = await flexEnterpriseServices.getFlexEnterpriseList(params, {
      let res = await enterpriseServices.getEnterprises(params, {
        showLoading: !state.loading,
      });
      return res;
@@ -143,39 +125,50 @@
  },
  {
    defaultExtraParams: {
      searchWord: '',
      orderInput: [{ property: 'id', order: OrderInputType.Desc }],
      flexEnterpriseSettingStatus: '' as any as FlexEnterpriseSettingStatus,
      keywords: '',
      orderInput: [{ property: 'id', order: EnumPagedListOrder.Desc }],
      isConfigured: '' as any as boolean,
    },
    queryKey: ['flexEnterpriseServices/getFlexEnterpriseList'],
    queryKey: ['enterpriseServices/getEnterprises'],
    columnsRenderProps: {
      settingStatus: { type: 'enum', valueEnum: FlexEnterpriseSettingStatusText },
      certificationStatus: { type: 'enum', valueEnum: FlexEnterpriseCertificationStatusText },
      isReal: { type: 'enum', valueEnum: IsRealText },
      isConfigured: { type: 'enum', valueEnum: IsConfiguredText },
    },
  }
);

function openDialog(row?: API.FlexEnterpriseDto) {
async function getEnterpriseElectronSignSetting(id: string) {
  try {
    return await enterpriseServices.getEnterpriseElectronSignSetting({ id: id });
  } catch (error) {}
}

async function getEnterpriseSmsSetting(id: string) {
  try {
    return await enterpriseServices.getEnterpriseSmsSetting({ id: id });
  } catch (error) {}
}

async function openDialog(row?: API.GetEnterprisesQueryResultItem) {
  if (row) {
    let electronSignSetting = await getEnterpriseElectronSignSetting(row.id);
    let smsSetting = await getEnterpriseSmsSetting(row.id);
    handleEdit({
      id: row.id,
      enterpriseConfigureType: EnterpriseConfigureType.Bank,
      flexEnterpirseId: row.id,
      openBank: row.flexEnterpriseBankDto?.openBank,
      openBranchBank: row.flexEnterpriseBankDto?.openBranchBank,
      bankAccount: row.flexEnterpriseBankDto?.bankAccount,
      verifyStatus: row.flexEnterpriseBankDto?.verifyStatus,
      signChannel: row.enterpriseSignSettingDto?.signChannel,
      chargeType: row.enterpriseSignSettingDto?.chargeType,
      realVerifyCost: row.enterpriseSignSettingDto?.realVerifyCost ?? 0,
      signCost: row.enterpriseSignSettingDto?.signCost ?? 0,
      mergeSignCost: row.enterpriseSignSettingDto?.mergeSignCost ?? 0,
      messageCost: row.flexEnterpriseMessageSettingDto?.messageCost ?? 0,
      messageChannel: row.flexEnterpriseMessageSettingDto?.messageChannel,
      enterpriseConfigureType: EnterpriseConfigureType.Electronic,
      realAccess: electronSignSetting.realAccess,
      realVerifyCost: electronSignSetting.realVerifyCost,
      signCost: electronSignSetting.signCost,
      mergeSignCost: electronSignSetting.mergeSignCost,

      smsAccess: smsSetting.smsAccess,
      chargeType: ChargeTypeEnum.Group,
      smsCost: smsSetting.smsCost,
    });
  } else {
    handleAdd({
      enterpriseConfigureType: EnterpriseConfigureType.Bank,
      enterpriseConfigureType: EnterpriseConfigureType.Electronic,
      chargeType: ChargeTypeEnum.Group,
    });
  }
}
@@ -184,32 +177,27 @@
  onConfirm: handleAddOrEdit,
  defaultFormParams: {
    id: '',
    flexEnterpirseId: '',
    enterpriseConfigureType: '' as any as EnterpriseConfigureType,
    openBank: '',
    openBranchBank: '',
    bankAccount: '',
    verifyStatus: '' as any as VerifyStatus,
    signChannel: '' as any as SignChannelEnum,
    chargeType: '' as any as ChargeTypeEnum,
    enterpriseConfigureType: EnterpriseConfigureType.Electronic,
    realAccess: '' as any as EnumRealAccess,
    realVerifyCost: 0,
    signCost: 0,
    mergeSignCost: 0,
    messageCost: 0,
    messageChannel: '' as any as MessageChannelEnum,
    chargeType: ChargeTypeEnum.Group,
    smsAccess: '' as any as EnumSmsAccess,
    smsCost: 0,
  },
});

async function handleAddOrEdit(type: EnterpriseConfigureType) {
async function handleAddOrEdit() {
  try {
    let res;
    if (type === EnterpriseConfigureType.Bank) {
      res = await createOrEditFlexEnterpriseBankSetting();
    }
    if (type === EnterpriseConfigureType.Electronic) {
    // if (type === EnterpriseConfigureType.Bank) {
    //   res = await createOrEditFlexEnterpriseBankSetting();
    // }
    if (editForm.enterpriseConfigureType === EnterpriseConfigureType.Electronic) {
      res = await createOrEditFlexEnterpriseSignSetting();
    }
    if (type === EnterpriseConfigureType.ShortMessage) {
    if (editForm.enterpriseConfigureType === EnterpriseConfigureType.ShortMessage) {
      res = await createOrEditFlexEnterpriseMessageSetting();
    }
    if (res) {
@@ -220,66 +208,46 @@
  } catch (error) {}
}

async function createOrEditFlexEnterpriseBankSetting() {
  try {
    let params: API.CreateOrEditFlexEnterpriseBankInput = {
      id: editForm.id,
      openBank: editForm.openBank,
      openBranchBank: editForm.openBranchBank,
      bankAccount: editForm.bankAccount,
      verifyStatus: editForm.verifyStatus,
      flexEnterpirseId: editForm.flexEnterpirseId,
    };
    return await flexEnterpriseServices.createOrEditFlexEnterpriseBankSetting(params);
  } catch (error) {}
}
// async function createOrEditFlexEnterpriseBankSetting() {
//   try {
//     let params: API.CreateOrEditFlexEnterpriseBankInput = {
//       id: editForm.id,
//       openBank: editForm.openBank,
//       openBranchBank: editForm.openBranchBank,
//       bankAccount: editForm.bankAccount,
//       verifyStatus: editForm.verifyStatus,
//       flexEnterpirseId: editForm.flexEnterpirseId,
//     };
//     return await flexEnterpriseServices.createOrEditFlexEnterpriseBankSetting(params);
//   } catch (error) {}
// }
async function createOrEditFlexEnterpriseSignSetting() {
  try {
    let params: API.CreateOrEditFlexEnterpriseSignSettingInput = {
    let params: API.SetEnterpriseElectronSignSettingCommand = {
      id: editForm.id,
      flexEnterpirseId: editForm.flexEnterpirseId,
      signChannel: editForm.signChannel,
      chargeType: editForm.chargeType,
      realAccess: editForm.realAccess,
      realVerifyCost: editForm.realVerifyCost,
      signCost: editForm.signCost,
      mergeSignCost: editForm.mergeSignCost,
    };
    return await flexEnterpriseServices.createOrEditFlexEnterpriseSignSetting(params);
    return await enterpriseServices.setEnterpriseElectronSignSetting(params);
  } catch (error) {}
}
async function createOrEditFlexEnterpriseMessageSetting() {
  try {
    let params: API.CreateOrEditFlexEnterpriseMessageSettingInput = {
    let params: API.SetEnterpriseSmsSettingCommand = {
      id: editForm.id,
      flexEnterpirseId: editForm.flexEnterpirseId,
      messageChannel: editForm.messageChannel,
      messageCost: editForm.messageCost,
      smsAccess: editForm.smsAccess,
      smsCost: editForm.smsCost,
    };
    return await flexEnterpriseServices.createOrEditFlexEnterpriseMessageSetting(params);
    return await enterpriseServices.setEnterpriseSmsSetting(params);
  } catch (error) {}
}

async function handleSetStatus(row: API.FlexEnterpriseDto) {
  try {
    let params: API.SetFlexEnterpriseStatusInput = {
      id: row.id,
      status:
        row.status === FlexEnterpriseStatus.Frozen
          ? FlexEnterpriseStatus.Normal
          : FlexEnterpriseStatus.Frozen,
    };
    let res = await flexEnterpriseServices.setFlexEnterpriseStatus(params);
    if (res) {
      Message.successMessage('操作成功');
      getList(paginationState.pageIndex);
    }
  } catch (error) {}
}

function addOrEditEnterprise(row?: API.FlexEnterpriseDto) {
function addOrEditEnterprise(row?: API.GetEnterprisesQueryResultItem) {
  router.push({ name: 'AddOrEditEnterprise', params: { id: row?.id ?? '' } });
}
function handleDetail(row: API.FlexEnterpriseDto) {
function handleDetail(row: API.GetEnterprisesQueryResultItem) {
  router.push({ name: 'EnterpriseDetail', params: { id: row?.id ?? '' } });
}
</script>