1、增加流程卡进度查询，可根据工程号，流程卡号，玻璃id查看进度情况 2、钢化界面增加颜色对应注释，版图增加落架顺序 3、两个大理片界面笼子上色块显示...

ZengTao

3 天以前 b804d88d626d1df675a3278c859b37758c55432b

1、增加流程卡进度查询，可根据工程号，流程卡号，玻璃id查看进度情况
2、钢化界面增加颜色对应注释，版图增加落架顺序
3、两个大理片界面笼子上色块显示修改为根据玻璃宽度显示
4、中空大理片右侧缺片情况显示优化
5、是否除膜从领取工程取消，在中空领取任务时选择除膜膜系（不除膜时不选择膜系），当配方中是需要除膜时并且选择的膜系与小片膜系一样时发送除膜信息
6、中空领取任务界面流程卡数量不等于已配对数量时高亮显示
7、磨边队列当后面玻璃磨边完成扫码但前面玻璃还未扫到码时高亮显示

 UI-Project/src/lang/en.js

@@ -36,7 +36,7 @@
    basicData: {
        untask: 'No task',
        tonumber: 'Total number of films uploaded',
        sectionUpperSuccessful:'Upper section operation successful！',
        sectionUpperSuccessful: 'Upper section operation successful！',
        finishnumber: 'Completed quantity',
        rackreset: 'Rack reset',
        prackreset: 'Is the rack reset？',
@@ -130,11 +130,11 @@
    },
    order: {
        projectnumber: 'Please enter the project number',
        noGlassToDamage:'No broken glass！',
        noGlassToDamage: 'No broken glass！',
        dilapidation: 'Breakage',
        dilapidationDetails:'Damage details',
        dilapidationAll:'One-click damage',
        dilapidationWhether:'Whether it is broken with one click？',
        dilapidationDetails: 'Damage details',
        dilapidationAll: 'One-click damage',
        dilapidationWhether: 'Whether it is broken with one click？',
        takeaway: 'Manual removal',
        takeawaya: 'Should the information be manually taken away？',
        takeon: 'The arrangement is complete',
@@ -143,8 +143,8 @@
        loadingText: 'Loading data, please wait...',
        firstLinePriority: 'First-line priority',
        secondLinePriority: 'second-line priority',
        hollowPriority:'Hollow priority',
        furnaces:'Number of full furnaces',
        hollowPriority: 'Hollow priority',
        furnaces: 'Number of full furnaces',
        furnfullTemp: 'Total amount of glass',
        startCell: 'Target layer number',
        endCell: 'Reserved layer number',
@@ -241,7 +241,7 @@
        startstatus: 'Start status',
        startstatusa: 'Start status：',
        instartstatus: 'Please enter the enabled status',
        choicestartstatus:'Please select Enable status',
        choicestartstatus: 'Please select Enable status',
        glassgaps: 'Glass gap',
        glassgapsa: 'Glass gap：',
        inglassgaps: 'Please enter the glass gap',
@@ -366,6 +366,14 @@
        glasstakeout: 'Glass take away list',
        layoutID: 'Drawing ID of loading for tempering furnace',
        glassID: 'Glass ID',
        tempState1: 'Task Generated',        // -1 生成任务
        tempState2: 'Sheet Output Completed', // 0 出片完成
        tempState3: 'Sheet Arrangement Completed', // 1 摆片完成
        tempState4: 'Furnace Entry Completed', // 2 进炉完成
        tempState5: 'Tempering Completed',    // 3 钢化完成
        tempState6: 'Sheet Output Completed', // 4 出片完成
        tempState7: 'Damaged',                // 8 破损
        tempState8: 'Taken Away',             // 9 拿走
    },
    reportWork: {
        details: 'Drop off details',
@@ -418,9 +426,9 @@
        inputNewPassword: 'Please enter a new password',
        userIdError: 'Failed to obtain user ID',
        configName: 'configure name',
        configNamea:'configure name：',
        configNamea: 'configure name：',
        configCode: 'Configuration Code',
        inconfigValue:'Please enter the configured values',
        inconfigValue: 'Please enter the configured values',
        configValue: 'Configuration value',
        addusers: 'Add user',
        username: 'User name',
@@ -529,19 +537,19 @@
        createTime: 'Return date',
    },
    large: {
        patchCount:'Quantity Replenished',
        Productionsituation:'Production situation',
        Productionandoperationstatus:'Production and operation status',
        cuttingState:'Operation status on the day of cutting',
        edgingState:'Operation status on the day of edge grinding',
        temperingState:'Operation status of tempered steel on the day of tempering',
        hollowState:'Production and operation status of hollow on the same day',
        patchCount: 'Quantity Replenished',
        Productionsituation: 'Production situation',
        Productionandoperationstatus: 'Production and operation status',
        cuttingState: 'Operation status on the day of cutting',
        edgingState: 'Operation status on the day of edge grinding',
        temperingState: 'Operation status of tempered steel on the day of tempering',
        hollowState: 'Production and operation status of hollow on the same day',
        switch: 'Switch',
        running: 'Running',
        stopping:'Stopping',
        diffMinutes:'diffMinutes',
        loadstart:'Load start',
        loadend:'Load end',
        stopping: 'Stopping',
        diffMinutes: 'diffMinutes',
        loadstart: 'Load start',
        loadend: 'Load end',
        loadtotal: 'Load total',
        loadfree: 'Load free',
        loaddiff: 'Load diff',
@@ -552,7 +560,7 @@
        temptotal: 'Temp total',
        tempfree: 'Temp free',
        tempdiff: 'Temp diff',
        tempstove:  'temp stove',
        tempstove: 'temp stove',
        tempnumber: 'Temp number',
        temparea: 'Temp area',
        hollowstart: 'Hollow start',
@@ -568,8 +576,8 @@
        totalnumber: 'Total number',
        tatalarea: 'Total area',
        statistics: 'Statistics',
        ExporttoExcel:'Export to Excel',
        slice:'slice',
        ExporttoExcel: 'Export to Excel',
        slice: 'slice',
        load: 'load',
        edg: 'edg',
        temp: 'temp',
@@ -816,13 +824,13 @@
        claimed: 'Already claimed',
        claimFailed: 'Failed to receive task',
        claimedTasksCleared: 'The received task status has been cleared',
        Content:'Content',
        idSame:'The glass ID for the entry task is the same',
        sizeSame:'There are glass pieces of the same specification inside the cage',
        slotLess:'Insufficient remaining slots',
        overSize:'There is glass in the straight-through feeder, end this feeding process.',
        noGlass:'Glass information not found, please collect the project',
        projectMsg2:'Please select a label template',
        Content: 'Content',
        idSame: 'The glass ID for the entry task is the same',
        sizeSame: 'There are glass pieces of the same specification inside the cage',
        slotLess: 'Insufficient remaining slots',
        overSize: 'There is glass in the straight-through feeder, end this feeding process.',
        noGlass: 'Glass information not found, please collect the project',
        projectMsg2: 'Please select a label template',
        clickmakesure: 'Whether or not to confirm the click？',
        logarithm: 'logarithm：',
        totalPairQuantitya: 'Total number of task allocation pairs',

 UI-Project/src/lang/kr.js

@@ -1,547 +1,555 @@
export  default {
export default {
    "northglassMESsystem": "베이보 MES 시스템",
      login:{
          userErr:'계정 ID 입력',
          pwErr:'비밀번호 입력',
          user:'사용자 계정',
          password:'비밀번호',
          login:'로그인',
          loginSuccessful:'로그인 성공！',
          register:'등록',
          namea:'성명 미입력 오류',
          len:'16자 이내 입력 필수',
          passnull:'비밀번호 필수',
          leng:'비밀번호 6~16자 필수',
          spwn:'확인 비밀번호 필수',
          depass:'비밀번호 불일치',
      },
      register:{
          registerSuccessful:'등록 완료',
          newuserregister:'신규 사용자 등록',
          name:'성명：',
          inputname:'성명 입력 필수',
          password:'비밀번호:',
          pwErr:'비밀번호 입력',
          passwordation:'비밀번호 확인:',
          pwErration:'비밀번호 재입력',
          registration:'등록 확인',
          false:'취소',
      },
      main:{
          connectErr:'서버 연결 불안정, 잠시 후 재시도',
          titleFirst:"베이",
          titleLast:'보 MES 시스템에 오신 것을 환영합니다！',
          quit:"로그아웃",
      },
      basicData:{
          untask:'작업 없음',
          tonumber:'총 영화 수',
          sectionUpperSuccessful:'상부 조작 성공！',
          finishnumber:'완료된 수량',
          rackreset:'쉘프 재설정',
          prackreset:'쉘프가 재설정되는지 여부？',
          laserprinting:'마킹기 준비 상태 ：',
          cuttingmachine:'커팅기 준비 상태：',
          machine:'로딩 머신 온라인 상태：',
          machineaa:'로딩 머신 수동 모드：',
          selectproject:"프로젝트 선택",
          startloading:'로딩 시작',
          stop:'일시정지',
          yes:'확인',
          change:'전환',
          projectnumber:'프로젝트 선택',
          glasswidth:'원판 너비',
          glassheight:'원판 높이',
          coatingtypes:'코팅 타입',
          coatingtypesa:'코팅 타입：',
          quantity:'수량',
          quantitya:'수량：',
          thickness:'두께',
          thicknessa:'두께：',
          startstatus:'활성화 상태',
          pass:'승인',
          waiting:'대기 중',
          up:'로딩 중',
          finish:'완료됨',
          project:'공정 카드 번호',
          plselectproject:'프로젝트 선택',
          confirm:'확인',
          cancel:'취소',
          startfilm:'로딩 시작 확인？',
          whetherpause:'일시정지 확인？',
          station:'스테이션',
          width:'너비',
          widtha:'너비：',
          height:'높이',
          heighta:'높이：',
          operate:'작업',
          add:'추가',
          delete:'삭제',
          addglass:'원판 추가',
          selectwidth:'너비 선택 필수',
          selectheight:'높이 선택 필수',
          selectcoatingtypes:'코팅 타입 선택 필수',
          selectthickness:'두께 선택 필수',
          selectquantity:'수량 입력 필수',
          pause:'2행과 4행 높이 >2700mm 필수！',
          pausea:'마킹기/커팅기 가동 준비 상태 확인！',
          infonull:'프로젝트 ID 필수！',
          updatanull:'프로젝트 상장 테이블 저장 실패！',
          glassnull:'유리 상태 업데이트 오류 발생',
          deletemessage:'해당 정보 삭제 확인?',
          layoutSequence:'일련번호',
      },
      sorter:{
          onesort:'깨진 조각 한 줄',
          twosort:'2선식 차단기 부품',
          inPlace:'장소',
          ninPlace:'제자리에 있지 않음',
          emptymissions:'빈 임무',
          advancetask:'고급 작업',
          outputtasks:'출력 작업',
          schedulingtasks:'작업 스케줄링',
          advancerequests:'사전 요청',
          releaserequest:'석방 요청',
          straighttasks:'간단한 작업',
          endingtask:'끝나다',
          another:'기타',
          id:'테두리 이전 케이지의 ID',
          remainWidth:'나머지',
          taskRunning:'작업 요청',
          updateTime:'업데이트',
          place:'그것이 제자리에 있는지 여부',
          layernow:'현재 레이어 번호',
          gridnumber:'그리드 번호',
          glassnumber:'유리 ID',
          width:'너비',
          height:'높이',
          startstatus:'활성화 상태',
          disable:'비활성화',
          start:'사용',
          deficiencieste:'부족 신고',
          updown:'인공촬영',
          operate:'작업',
          prompt:'알림',
          information:'해당 정보 부족 신고 확인？',
          infor:'이 정보를 수동으로 다운로드할지 여부？',
          yes:'예',
          cancel:'취소',
      },
      order:{
          projectnumber:'프로젝트 번호를 입력해 주세요',
          noGlassToDamage:'깨진 유리 없음！',
          dilapidation:'파손',
          dilapidationDetails:'파손 상세',
          dilapidationAll:'원터치 파손',
          dilapidationWhether:'한 번의 클릭으로 깨졌는지 여부？',
          takeaway:'수동 제거',
          takeawaya:'정보가 수동으로 수집되었는지 여부？',
          takeon:'준비가 완료되었습니다',
      },
      searchOrder:{
    login: {
        userErr: '계정 ID 입력',
        pwErr: '비밀번호 입력',
        user: '사용자 계정',
        password: '비밀번호',
        login: '로그인',
        loginSuccessful: '로그인 성공！',
        register: '등록',
        namea: '성명 미입력 오류',
        len: '16자 이내 입력 필수',
        passnull: '비밀번호 필수',
        leng: '비밀번호 6~16자 필수',
        spwn: '확인 비밀번호 필수',
        depass: '비밀번호 불일치',
    },
    register: {
        registerSuccessful: '등록 완료',
        newuserregister: '신규 사용자 등록',
        name: '성명：',
        inputname: '성명 입력 필수',
        password: '비밀번호:',
        pwErr: '비밀번호 입력',
        passwordation: '비밀번호 확인:',
        pwErration: '비밀번호 재입력',
        registration: '등록 확인',
        false: '취소',
    },
    main: {
        connectErr: '서버 연결 불안정, 잠시 후 재시도',
        titleFirst: "베이",
        titleLast: '보 MES 시스템에 오신 것을 환영합니다！',
        quit: "로그아웃",
    },
    basicData: {
        untask: '작업 없음',
        tonumber: '총 영화 수',
        sectionUpperSuccessful: '상부 조작 성공！',
        finishnumber: '완료된 수량',
        rackreset: '쉘프 재설정',
        prackreset: '쉘프가 재설정되는지 여부？',
        laserprinting: '마킹기 준비 상태 ：',
        cuttingmachine: '커팅기 준비 상태：',
        machine: '로딩 머신 온라인 상태：',
        machineaa: '로딩 머신 수동 모드：',
        selectproject: "프로젝트 선택",
        startloading: '로딩 시작',
        stop: '일시정지',
        yes: '확인',
        change: '전환',
        projectnumber: '프로젝트 선택',
        glasswidth: '원판 너비',
        glassheight: '원판 높이',
        coatingtypes: '코팅 타입',
        coatingtypesa: '코팅 타입：',
        quantity: '수량',
        quantitya: '수량：',
        thickness: '두께',
        thicknessa: '두께：',
        startstatus: '활성화 상태',
        pass: '승인',
        waiting: '대기 중',
        up: '로딩 중',
        finish: '완료됨',
        project: '공정 카드 번호',
        plselectproject: '프로젝트 선택',
        confirm: '확인',
        cancel: '취소',
        startfilm: '로딩 시작 확인？',
        whetherpause: '일시정지 확인？',
        station: '스테이션',
        width: '너비',
        widtha: '너비：',
        height: '높이',
        heighta: '높이：',
        operate: '작업',
        add: '추가',
        delete: '삭제',
        addglass: '원판 추가',
        selectwidth: '너비 선택 필수',
        selectheight: '높이 선택 필수',
        selectcoatingtypes: '코팅 타입 선택 필수',
        selectthickness: '두께 선택 필수',
        selectquantity: '수량 입력 필수',
        pause: '2행과 4행 높이 >2700mm 필수！',
        pausea: '마킹기/커팅기 가동 준비 상태 확인！',
        infonull: '프로젝트 ID 필수！',
        updatanull: '프로젝트 상장 테이블 저장 실패！',
        glassnull: '유리 상태 업데이트 오류 발생',
        deletemessage: '해당 정보 삭제 확인?',
        layoutSequence: '일련번호',
    },
    sorter: {
        onesort: '깨진 조각 한 줄',
        twosort: '2선식 차단기 부품',
        inPlace: '장소',
        ninPlace: '제자리에 있지 않음',
        emptymissions: '빈 임무',
        advancetask: '고급 작업',
        outputtasks: '출력 작업',
        schedulingtasks: '작업 스케줄링',
        advancerequests: '사전 요청',
        releaserequest: '석방 요청',
        straighttasks: '간단한 작업',
        endingtask: '끝나다',
        another: '기타',
        id: '테두리 이전 케이지의 ID',
        remainWidth: '나머지',
        taskRunning: '작업 요청',
        updateTime: '업데이트',
        place: '그것이 제자리에 있는지 여부',
        layernow: '현재 레이어 번호',
        gridnumber: '그리드 번호',
        glassnumber: '유리 ID',
        width: '너비',
        height: '높이',
        startstatus: '활성화 상태',
        disable: '비활성화',
        start: '사용',
        deficiencieste: '부족 신고',
        updown: '인공촬영',
        operate: '작업',
        prompt: '알림',
        information: '해당 정보 부족 신고 확인？',
        infor: '이 정보를 수동으로 다운로드할지 여부？',
        yes: '예',
        cancel: '취소',
    },
    order: {
        projectnumber: '프로젝트 번호를 입력해 주세요',
        noGlassToDamage: '깨진 유리 없음！',
        dilapidation: '파손',
        dilapidationDetails: '파손 상세',
        dilapidationAll: '원터치 파손',
        dilapidationWhether: '한 번의 클릭으로 깨졌는지 여부？',
        takeaway: '수동 제거',
        takeawaya: '정보가 수동으로 수집되었는지 여부？',
        takeon: '준비가 완료되었습니다',
    },
    searchOrder: {
        loadingText: '데이터를 불러오는 중입니다. 잠시만 기다려 주세요....',
          firstLinePriority: '일선 우선 순위',
          secondLinePriority: '2선 우선순위',
          hollowPriority:'중공 우선 순위',
          furnaces:'가득 차있는 용광로의 수',
          furnfullTemp:'유리의 총량',
          startCell:'대상 레이어 번호',
          endCell:'등급 번호 예약',
          begin:'시작',
          finish:'완료',
          uncar:'미승차',
          inkage:'입편',
          successfullyprocessed:'작업이 성공적으로 처리되었습니다.',
          psuccessfullyprocessed:'작업이 성공적으로 처리되었는지 여부？',
          taskfailure:'작업 실패 처리',
          ptaskfailure:'작업 실패 처리 여부？',
          totallogarithms:'총 대수',
          numberpairs:'짝수',
          numberoccupied:'점유 칸 수',
          totalfurnaces:'총 난로 수',
          cagesnumber:'케이지 내 수량',
          slotnumber:'칸수를 차지하다',
          progress:'진행률%',
          whethersame:'동일 여부',
          same:'동일',
          notsame:'다름',
          partask:'작업 재설정',
          partasks:'작업 재설정 여부？',
          empty:'기본 빈 작업',
          historicaltasks:'역사적 임무',
          cagedetails:'케이지 내 상세 정보',
          inkageEntity:'슬라이스 입력 온라인 상태：',
          requestEntity:'수신 요청 상태：',
          mesReplyEntity:'시작 명령：',
          outInkageEntity:'플롯 온라인 상태：',
          outRequestEntity:'플롯 요청 상태：',
          breakagn:'파손되지 않음',
          lacknumber:'결편 수량',
          processcard:'프로세스 카드 지정',
          filminformation:'수동 하편 정보',
          currentglassinformation:'스캔총 현재 유리 정보',
          printlabels:'레이블 인쇄',
          deleteTask:'공사를 끝내다',
          pdeleteTask:'공사 종료 여부？',
          searchlayout:'비강화 프로세스 카드 조회',
          fullfurnaces:'만로 수량',
          specifiedproject:'현재 지정된 프로젝트',
          undesignate:'강화 취소',
          allnumber:'총 수량',
          numbercages:'우리내 수량',
          missingquantity:'부족 수량',
          breakquantity:'파손/가져가기 수량',
          ceng:'레이어',
          cageinformation:'분류 케이지 정보',
          productionqueue:'배출 대기열',
          outputglassID:'배출 유리 ID',
          startposition:'출발 위치',
          targetlocation:'도착 위치',
          trips:'차량 회차',
          number:'일련번호',
          taskstatus:'작업 상태',
          filmenter:'투입 대기',
          infilm:'진행 중',
          endtask:'작업 종료',
          completetask:'작업 완료',
          intoglassid:'투입 유리 ID',
          line:'라인',
          Usage:'사용률',
          free:'유휴 슬롯(개)',
          addcage:'분류 케이지 정보 추가',
          glassIDa:'유리 ID：',
          glassID:'유리 ID',
          inglassID:'유리 ID 입력 필수',
          pieceingrid:'셀 내 유리 순서 입력 필수',
          pieceingrida:'셀 내 유리 순서 입력 필수：',
          inpieceingrid:'셀 내 유리 순서 입력 필수',
          cardnumber:'공정 카드 번호',
          cardnumbera:'공정 카드 번호：',
          incardnumber:'공정 카드 번호 입력 필수',
          typeglass:'유리 유형',
          typeglassa:'유리 유형：',
          intypeglass:'유리 유형 입력 필수',
          width:'너비',
          widtha:'너비：',
          inwidth:'너비 입력 필수',
          height:'높이',
          heighta:'높이：',
          inheight:'높이 입력 필수',
          coatingtypes:'코팅 타입',
          thickness:'두께',
          thicknessa:'두께：',
          inthickness:'두께 입력 필수',
          layoutID:'강화 레이아웃 ID 입력 필수',
          layoutIDa:'강화 레이아웃 ID 입력 필수：',
          inlayoutID:'강화 레이아웃 ID 입력 필수',
          picturesequence:'강화 레이아웃 조각 순서',
          picturesequencea:'강화 레이아웃 조각 순서：',
          inpicturesequence:'강화 레이아웃 조각 순서 입력',
          startstatus:'활성화 상태',
          startstatusa:'활성화 상태：',
          instartstatus:'활성화 상태 입력',
          choicestartstatus:'사용 상태를 선택하십시오.',
          glassgaps:'유리 간격',
          glassgapsa:'유리 간격：',
          inglassgaps:'유리 간격 입력 필수',
          sure:'확인',
          cancel:'취소',
          operate:'작업',
          breakage:'파손',
          delete:'삭제',
          outfilm:'배출',
          cagetableID:'분류 케이지 테이블 ID',
          cagenumber:'분류 케이지 번호',
          gridnumber:'그리드 번호',
          gridnumbera:'그리드 번호：',
          grid:'격자선 번호를 입력하십시오.',
          enable:'사용 가능',
          disable:'비활성화',
          remainingwidth:'잔여 너비',
          add:'추가',
          sheetID:'강화 소편 정보 ID',
          processcards:'공정 카드',
          processcardtype:'공정 카드 유리 유형',
          acceptshorizontal:'강화 가로 배치 수용 여부',
          xcoordinates:'X 좌표',
          ycoordinates:'Y 좌표',
          rotationangle:'회전 각도(° 시계 반대 방향)',
          state:'상태',
          takeout:'제거',
          deletemessage:'해당 정보 삭제 확인?',
          prompt:'알림',
          yes:'예',
          accept:'예',
          noaccept:'아니오',
          filmcomplete:'배출 완료',
          waiting:'대기 중',
          broke:'해당 정보 파손 처리 확인？',
          brokeb:'해당 정보 제거 확인？',
          outfil:'이 메시지를 출력할지 여부？',
          inputid:'유리 ID 입력 필수',
          search:'검색',
          tabid:'대리편롱 상세표 id',
          tid:'장치 id',
          tida:'장치 id：',
          fin:'작업 완료 여부？',
          sureadd:'추가 확인',
          sureadda:'추가 확인 여부？',
          zailong:'새장 속에',
          rengongxp:'인공 하편',
          up:'이전 페이지',
          down:'다음 페이지',
          now:'현재 페이지 표시',
          tit:'스트라이프 데이터',
          temperingqueries:'강화 조회',
          specifytempering:'한 난로를 지정하다',
          specifyout:'수동 플롯 지정',
          specifyengineerid:'프로젝트 지정',
          projectnumber:'프로젝트 선택',
          layoutnumber:'강화 레이아웃 번호',
          numberglasses:'유리 수량',
          specifytemperinga:'디바이스가 MES 온라인을 종료했는지 확인하십시오.？',
          temperedswitch:'강화 스위치',
          dutyinformation:'당직 정보',
          process:'공정',
          team:'그룹',
          basic:'장치',
          makesure:'저장 확인',
          temperingtotal:'강화로 수：',
          glasstotal:'총 유리 수：',
          Labelprinting:'레이블 인쇄',
          Schedulingswitch:'스케줄러 스위치',
      },
      workOrder:{
          upnumber:'이전 슬라이스 번호',
          glassID:'유리 ID',
          height:'높이',
          width:'너비',
          thickness:'두께',
          coatingtypes:'코팅 타입',
          coatingtypesbe:'원편막계',
          productionsequence:'배출 순서',
          cardnumber:'공정 카드 번호',
          operate:'작업',
          messagedamaged:'해당 정보 파손 처리 확인?',
          prompt:'알림',
          yes:'예',
          cancel:'취소',
          takemessage:'해당 정보 제거 확인？',
          breakage:'파손',
          takeout:'제거',
          glasstype:'유리막계',
          line:'라인',
          status:'상태',
          time:'시간대',
          cway:'회선을 선택하세요',
          cstate:'상태 선택',
          edgingone:'가장자리를 갈다',
          edgingtwo:'사이드 라인 을 갈다',
          nedging:'미갈 변',
          edging:'가장자리를 가는 중',
          finedging:'이미 가장자리를 갈았다',
      },
      processCard:{
          intofurnace:'로 진입 중',
          beforefurnace:'로 진입 전',
          outfurnace:'강화 완료 유리',
          print:'프린트를 가져가다',
          printing:'인쇄',
          projectnumber:'프로젝트 번호를 입력하십시오.',
          inquire:'질의',
          project:'프로젝트 선택',
          awayprocess:'공정을 가져가다',
          awayequipment:'설비를 가져가다',
          awayteam:'반을 가져가다',
          flowcard:'공정 카드',
          layer:'레이어 번호',
          temperinglayout:'난로 번호',
          temperingfeed:'편차',
          width:'너비',
          height:'높이',
          thickness:'두께',
          glasstakeout:'유리 가져가기 리스트',
          layoutID:'판도 ID',
          glassID:'유리 ID',
      },
      reportWork:{
          details:'낙하 상세 정보',
          filming:'인공 하편',
          printing:'자동 인쇄',
          cenumber:'계층 수',
          artificialorder:'인공 하편수',
          processcard:'인쇄 프로세스 카드',
          printlabels:'레이블 인쇄',
          information:'로딩 정보',
          cstation:'작업 공간을 선택하십시오.',
          all:'모두',
          timeperiod:'시간대',
          stationnumber:'작업 위치 번호',
          order:'순서',
          filminformation:'수동 하편 정보',
          glassmation:'인공 하편 현재 유리 정보',
          barcodescanner:'스캔총 현재 유리 정보',
          lowerbit:'언로딩 포지션',
          shelfnumber:'랙 번호',
          cardnumber:'공정 카드 번호',
          totalquantity:'총 수량',
          beendropped:'랙 적재 완료 수량',
          state:'상태',
          devicenumber:'장비 번호',
          startstatus:'활성화 상태',
          enable:'사용 가능',
          unenable:'비활성화',
          operate:'작업',
          bindingshelves:'랙 바인딩',
          clear:'초기화',
          workstation:'스테이션',
          shelfnumbera:'랙 번호：',
          cardnumbera:'공정 카드 번호：',
          incardnumber:'공정 카드 번호 선택 ',
          clearglass:'랙 유리 클리어',
          sure:'확인',
          cancel:'취소',
          glassinformation:'유리 정보',
          glassID:'유리 ID',
          coatingtypes:'코팅 타입',
          thickness:'두께',
          width:'너비',
          height:'높이',
      },
      productStock:{
          inconfirmpassword: '비밀번호를 확인해 입력하세요',
          passwordNotMatch: '두 번 입력한 비밀번호가 일치하지 않습니다',
          confirmpassword: '비밀번호 확인',
          inputNewPassword: '새 비밀번호를 입력하세요',
          userIdError: '사용자 ID 가져오기 실패',
          addconfigName:'구성 추가',
          editconfigName:'구성 수정',
          configName:'구성 이름',
          configNamea:'구성 이름：',
          configCode:'구성 코드',
          configValue:'구성 값',
          inconfigValue:'구성 값을 입력하십시오.',
          configValuea:'구성 값：',
          addusers:'사용자 추가',
          username:'사용자명',
          usernamea:'사용자명：',
          inusername:'사용자명 입력',
          role:'역할',
          rolea:'역할：',
          inrole:'역할 선택',
          test:'테스트',
          admin:'관리자',
          operate:'작업',
          resetpassword:'비밀번호 재설정',
          exit:'편집',
          delete:'삭제',
          prompt:'알림',
          repassword:'비밀번호 초기화 확인？',
          yes:'예',
          cancel:'취소',
          reusername:'사용자 수정',
          addusername:'사용자 추가',
          password:'비밀번호：',
          sure:'확인',
          inpassword:'비밀번호 입력',
          deusername:'사용자 삭제 확인？',
      },
      customer:{
          addmenua:'2단계 메뉴 추가',
          addmenu:'수준 1 메뉴 추가',
          firstmenu:'1단계 메뉴',
          firstmenuname:'수준 1 메뉴 이름:',
          link:'링크',
          inlink:'링크 입력',
          linka:'링크：',
          sort:'정렬 순서',
          insort:'정렬 순서 입력',
          sorta:'정렬 순서：',
          operate:'작업',
          exit:'편집',
          delete:'삭제',
          semenu:'2단계 메뉴 표시줄',
          semenuname:'2단계 메뉴 이름:',
          menu:'메뉴 바：',
          inmenu:'메뉴 이름을 입력하십시오.',
          sure:'확인',
          cancel:'취소',
          exmene:'레벨 1 메뉴 수정',
          exmenea:'2단계 메뉴 수정',
          yes:'예',
          demenu:'메뉴 항목 삭제 확인？', 
          prompt:'알림',
      },
      delivery:{
          addrole:'역할 추가',
          editrole:'역할 수정',
          role :'역할',
          rolea :'역할：',
          inrole :'역할 선택 필수',
          operate :'작업',
          edit :'편집',
          delete :'삭제',
          yes:'예',
          sure :'확인',
          cancel :'취소',
          derole :'해당 역할 삭제 확인',
          prompt:'알림',
          choice:'메뉴 권한：',
          inchoice:'메뉴 사용 권한을 선택하십시오.',
      },
      replenish:{
          patchManagement:'패치 관리',
      },
      rework:{
          reworkManagement:'재작업 관리',
          addRework:"재작업 신규 ",
      },
      role:{
          id:'ID',
          characterHomepage:'캐릭터 첫 페이지',
      },
      user:{
          userId:'사용자 ID',
          userHomepage:'사용자 홈 페이지',
      },
      orderBasicData:{
          order:'주문',
          orderType:'주문 유형',
      },
      machine:{
          basicId:'장치 번호',
          basicName:'장치 이름',
          basicCategory:'소재 공정',
          tempering:'강화',
      },
      report:{
          productionReport:'생산 보고서',
          workInProgressReport:'제품 보고서',
      },
      productionBasicData:{
          basicDataQuery :'기본 데이터 쿼리',
      },
      mainIngredient:{
          materialInformation :'재료 자료',
      },
      mainIngredientStock:{
          materialName :'재료 이름',
          createTime :'반환 날짜',
      },
      large:{
        patchCount:'보충 수량',
        Productionsituation:'생산 상황',
        Productionandoperationstatus:'운영 상태',
        cuttingState:'가공 당일 상태',
        edgingState:'맷돌 당일 운행 상황',
        temperingState:'강화 당일 운행 상황',
        hollowState:'중공 당일 운행 상황',
        switch:'전환',
        running:'실행 중',
        stopping:'중지',
        diffMinutes:'분',
        loadstart:'가공 시작 시간',
        loadend:'컷 종료 시간',
        firstLinePriority: '일선 우선 순위',
        secondLinePriority: '2선 우선순위',
        hollowPriority: '중공 우선 순위',
        furnaces: '가득 차있는 용광로의 수',
        furnfullTemp: '유리의 총량',
        startCell: '대상 레이어 번호',
        endCell: '등급 번호 예약',
        begin: '시작',
        finish: '완료',
        uncar: '미승차',
        inkage: '입편',
        successfullyprocessed: '작업이 성공적으로 처리되었습니다.',
        psuccessfullyprocessed: '작업이 성공적으로 처리되었는지 여부？',
        taskfailure: '작업 실패 처리',
        ptaskfailure: '작업 실패 처리 여부？',
        totallogarithms: '총 대수',
        numberpairs: '짝수',
        numberoccupied: '점유 칸 수',
        totalfurnaces: '총 난로 수',
        cagesnumber: '케이지 내 수량',
        slotnumber: '칸수를 차지하다',
        progress: '진행률%',
        whethersame: '동일 여부',
        same: '동일',
        notsame: '다름',
        partask: '작업 재설정',
        partasks: '작업 재설정 여부？',
        empty: '기본 빈 작업',
        historicaltasks: '역사적 임무',
        cagedetails: '케이지 내 상세 정보',
        inkageEntity: '슬라이스 입력 온라인 상태：',
        requestEntity: '수신 요청 상태：',
        mesReplyEntity: '시작 명령：',
        outInkageEntity: '플롯 온라인 상태：',
        outRequestEntity: '플롯 요청 상태：',
        breakagn: '파손되지 않음',
        lacknumber: '결편 수량',
        processcard: '프로세스 카드 지정',
        filminformation: '수동 하편 정보',
        currentglassinformation: '스캔총 현재 유리 정보',
        printlabels: '레이블 인쇄',
        deleteTask: '공사를 끝내다',
        pdeleteTask: '공사 종료 여부？',
        searchlayout: '비강화 프로세스 카드 조회',
        fullfurnaces: '만로 수량',
        specifiedproject: '현재 지정된 프로젝트',
        undesignate: '강화 취소',
        allnumber: '총 수량',
        numbercages: '우리내 수량',
        missingquantity: '부족 수량',
        breakquantity: '파손/가져가기 수량',
        ceng: '레이어',
        cageinformation: '분류 케이지 정보',
        productionqueue: '배출 대기열',
        outputglassID: '배출 유리 ID',
        startposition: '출발 위치',
        targetlocation: '도착 위치',
        trips: '차량 회차',
        number: '일련번호',
        taskstatus: '작업 상태',
        filmenter: '투입 대기',
        infilm: '진행 중',
        endtask: '작업 종료',
        completetask: '작업 완료',
        intoglassid: '투입 유리 ID',
        line: '라인',
        Usage: '사용률',
        free: '유휴 슬롯(개)',
        addcage: '분류 케이지 정보 추가',
        glassIDa: '유리 ID：',
        glassID: '유리 ID',
        inglassID: '유리 ID 입력 필수',
        pieceingrid: '셀 내 유리 순서 입력 필수',
        pieceingrida: '셀 내 유리 순서 입력 필수：',
        inpieceingrid: '셀 내 유리 순서 입력 필수',
        cardnumber: '공정 카드 번호',
        cardnumbera: '공정 카드 번호：',
        incardnumber: '공정 카드 번호 입력 필수',
        typeglass: '유리 유형',
        typeglassa: '유리 유형：',
        intypeglass: '유리 유형 입력 필수',
        width: '너비',
        widtha: '너비：',
        inwidth: '너비 입력 필수',
        height: '높이',
        heighta: '높이：',
        inheight: '높이 입력 필수',
        coatingtypes: '코팅 타입',
        thickness: '두께',
        thicknessa: '두께：',
        inthickness: '두께 입력 필수',
        layoutID: '강화 레이아웃 ID 입력 필수',
        layoutIDa: '강화 레이아웃 ID 입력 필수：',
        inlayoutID: '강화 레이아웃 ID 입력 필수',
        picturesequence: '강화 레이아웃 조각 순서',
        picturesequencea: '강화 레이아웃 조각 순서：',
        inpicturesequence: '강화 레이아웃 조각 순서 입력',
        startstatus: '활성화 상태',
        startstatusa: '활성화 상태：',
        instartstatus: '활성화 상태 입력',
        choicestartstatus: '사용 상태를 선택하십시오.',
        glassgaps: '유리 간격',
        glassgapsa: '유리 간격：',
        inglassgaps: '유리 간격 입력 필수',
        sure: '확인',
        cancel: '취소',
        operate: '작업',
        breakage: '파손',
        delete: '삭제',
        outfilm: '배출',
        cagetableID: '분류 케이지 테이블 ID',
        cagenumber: '분류 케이지 번호',
        gridnumber: '그리드 번호',
        gridnumbera: '그리드 번호：',
        grid: '격자선 번호를 입력하십시오.',
        enable: '사용 가능',
        disable: '비활성화',
        remainingwidth: '잔여 너비',
        add: '추가',
        sheetID: '강화 소편 정보 ID',
        processcards: '공정 카드',
        processcardtype: '공정 카드 유리 유형',
        acceptshorizontal: '강화 가로 배치 수용 여부',
        xcoordinates: 'X 좌표',
        ycoordinates: 'Y 좌표',
        rotationangle: '회전 각도(° 시계 반대 방향)',
        state: '상태',
        takeout: '제거',
        deletemessage: '해당 정보 삭제 확인?',
        prompt: '알림',
        yes: '예',
        accept: '예',
        noaccept: '아니오',
        filmcomplete: '배출 완료',
        waiting: '대기 중',
        broke: '해당 정보 파손 처리 확인？',
        brokeb: '해당 정보 제거 확인？',
        outfil: '이 메시지를 출력할지 여부？',
        inputid: '유리 ID 입력 필수',
        search: '검색',
        tabid: '대리편롱 상세표 id',
        tid: '장치 id',
        tida: '장치 id：',
        fin: '작업 완료 여부？',
        sureadd: '추가 확인',
        sureadda: '추가 확인 여부？',
        zailong: '새장 속에',
        rengongxp: '인공 하편',
        up: '이전 페이지',
        down: '다음 페이지',
        now: '현재 페이지 표시',
        tit: '스트라이프 데이터',
        temperingqueries: '강화 조회',
        specifytempering: '한 난로를 지정하다',
        specifyout: '수동 플롯 지정',
        specifyengineerid: '프로젝트 지정',
        projectnumber: '프로젝트 선택',
        layoutnumber: '강화 레이아웃 번호',
        numberglasses: '유리 수량',
        specifytemperinga: '디바이스가 MES 온라인을 종료했는지 확인하십시오.？',
        temperedswitch: '강화 스위치',
        dutyinformation: '당직 정보',
        process: '공정',
        team: '그룹',
        basic: '장치',
        makesure: '저장 확인',
        temperingtotal: '강화로 수：',
        glasstotal: '총 유리 수：',
        Labelprinting: '레이블 인쇄',
        Schedulingswitch: '스케줄러 스위치',
    },
    workOrder: {
        upnumber: '이전 슬라이스 번호',
        glassID: '유리 ID',
        height: '높이',
        width: '너비',
        thickness: '두께',
        coatingtypes: '코팅 타입',
        coatingtypesbe: '원편막계',
        productionsequence: '배출 순서',
        cardnumber: '공정 카드 번호',
        operate: '작업',
        messagedamaged: '해당 정보 파손 처리 확인?',
        prompt: '알림',
        yes: '예',
        cancel: '취소',
        takemessage: '해당 정보 제거 확인？',
        breakage: '파손',
        takeout: '제거',
        glasstype: '유리막계',
        line: '라인',
        status: '상태',
        time: '시간대',
        cway: '회선을 선택하세요',
        cstate: '상태 선택',
        edgingone: '가장자리를 갈다',
        edgingtwo: '사이드 라인 을 갈다',
        nedging: '미갈 변',
        edging: '가장자리를 가는 중',
        finedging: '이미 가장자리를 갈았다',
    },
    processCard: {
        intofurnace: '로 진입 중',
        beforefurnace: '로 진입 전',
        outfurnace: '강화 완료 유리',
        print: '프린트를 가져가다',
        printing: '인쇄',
        projectnumber: '프로젝트 번호를 입력하십시오.',
        inquire: '질의',
        project: '프로젝트 선택',
        awayprocess: '공정을 가져가다',
        awayequipment: '설비를 가져가다',
        awayteam: '반을 가져가다',
        flowcard: '공정 카드',
        layer: '레이어 번호',
        temperinglayout: '난로 번호',
        temperingfeed: '편차',
        width: '너비',
        height: '높이',
        thickness: '두께',
        glasstakeout: '유리 가져가기 리스트',
        layoutID: '판도 ID',
        glassID: '유리 ID',
        tempState1: '작업 생성됨',            // -1 生成任务
        tempState2: '출판 완료',              // 0 出片完成
        tempState3: '진열 완료',              // 1 摆片完成
        tempState4: '입로 완료',              // 2 进炉完成
        tempState5: '강화 완료',              // 3 钢化完成
        tempState6: '출판 완료',              // 4 出片完成
        tempState7: '파손됨',                // 8 破损
        tempState8: '반출됨',                // 9 拿走
    },
    reportWork: {
        details: '낙하 상세 정보',
        filming: '인공 하편',
        printing: '자동 인쇄',
        cenumber: '계층 수',
        artificialorder: '인공 하편수',
        processcard: '인쇄 프로세스 카드',
        printlabels: '레이블 인쇄',
        information: '로딩 정보',
        cstation: '작업 공간을 선택하십시오.',
        all: '모두',
        timeperiod: '시간대',
        stationnumber: '작업 위치 번호',
        order: '순서',
        filminformation: '수동 하편 정보',
        glassmation: '인공 하편 현재 유리 정보',
        barcodescanner: '스캔총 현재 유리 정보',
        lowerbit: '언로딩 포지션',
        shelfnumber: '랙 번호',
        cardnumber: '공정 카드 번호',
        totalquantity: '총 수량',
        beendropped: '랙 적재 완료 수량',
        state: '상태',
        devicenumber: '장비 번호',
        startstatus: '활성화 상태',
        enable: '사용 가능',
        unenable: '비활성화',
        operate: '작업',
        bindingshelves: '랙 바인딩',
        clear: '초기화',
        workstation: '스테이션',
        shelfnumbera: '랙 번호：',
        cardnumbera: '공정 카드 번호：',
        incardnumber: '공정 카드 번호 선택 ',
        clearglass: '랙 유리 클리어',
        sure: '확인',
        cancel: '취소',
        glassinformation: '유리 정보',
        glassID: '유리 ID',
        coatingtypes: '코팅 타입',
        thickness: '두께',
        width: '너비',
        height: '높이',
    },
    productStock: {
        inconfirmpassword: '비밀번호를 확인해 입력하세요',
        passwordNotMatch: '두 번 입력한 비밀번호가 일치하지 않습니다',
        confirmpassword: '비밀번호 확인',
        inputNewPassword: '새 비밀번호를 입력하세요',
        userIdError: '사용자 ID 가져오기 실패',
        addconfigName: '구성 추가',
        editconfigName: '구성 수정',
        configName: '구성 이름',
        configNamea: '구성 이름：',
        configCode: '구성 코드',
        configValue: '구성 값',
        inconfigValue: '구성 값을 입력하십시오.',
        configValuea: '구성 값：',
        addusers: '사용자 추가',
        username: '사용자명',
        usernamea: '사용자명：',
        inusername: '사용자명 입력',
        role: '역할',
        rolea: '역할：',
        inrole: '역할 선택',
        test: '테스트',
        admin: '관리자',
        operate: '작업',
        resetpassword: '비밀번호 재설정',
        exit: '편집',
        delete: '삭제',
        prompt: '알림',
        repassword: '비밀번호 초기화 확인？',
        yes: '예',
        cancel: '취소',
        reusername: '사용자 수정',
        addusername: '사용자 추가',
        password: '비밀번호：',
        sure: '확인',
        inpassword: '비밀번호 입력',
        deusername: '사용자 삭제 확인？',
    },
    customer: {
        addmenua: '2단계 메뉴 추가',
        addmenu: '수준 1 메뉴 추가',
        firstmenu: '1단계 메뉴',
        firstmenuname: '수준 1 메뉴 이름:',
        link: '링크',
        inlink: '링크 입력',
        linka: '링크：',
        sort: '정렬 순서',
        insort: '정렬 순서 입력',
        sorta: '정렬 순서：',
        operate: '작업',
        exit: '편집',
        delete: '삭제',
        semenu: '2단계 메뉴 표시줄',
        semenuname: '2단계 메뉴 이름:',
        menu: '메뉴 바：',
        inmenu: '메뉴 이름을 입력하십시오.',
        sure: '확인',
        cancel: '취소',
        exmene: '레벨 1 메뉴 수정',
        exmenea: '2단계 메뉴 수정',
        yes: '예',
        demenu: '메뉴 항목 삭제 확인？',
        prompt: '알림',
    },
    delivery: {
        addrole: '역할 추가',
        editrole: '역할 수정',
        role: '역할',
        rolea: '역할：',
        inrole: '역할 선택 필수',
        operate: '작업',
        edit: '편집',
        delete: '삭제',
        yes: '예',
        sure: '확인',
        cancel: '취소',
        derole: '해당 역할 삭제 확인',
        prompt: '알림',
        choice: '메뉴 권한：',
        inchoice: '메뉴 사용 권한을 선택하십시오.',
    },
    replenish: {
        patchManagement: '패치 관리',
    },
    rework: {
        reworkManagement: '재작업 관리',
        addRework: "재작업 신규 ",
    },
    role: {
        id: 'ID',
        characterHomepage: '캐릭터 첫 페이지',
    },
    user: {
        userId: '사용자 ID',
        userHomepage: '사용자 홈 페이지',
    },
    orderBasicData: {
        order: '주문',
        orderType: '주문 유형',
    },
    machine: {
        basicId: '장치 번호',
        basicName: '장치 이름',
        basicCategory: '소재 공정',
        tempering: '강화',
    },
    report: {
        productionReport: '생산 보고서',
        workInProgressReport: '제품 보고서',
    },
    productionBasicData: {
        basicDataQuery: '기본 데이터 쿼리',
    },
    mainIngredient: {
        materialInformation: '재료 자료',
    },
    mainIngredientStock: {
        materialName: '재료 이름',
        createTime: '반환 날짜',
    },
    large: {
        patchCount: '보충 수량',
        Productionsituation: '생산 상황',
        Productionandoperationstatus: '운영 상태',
        cuttingState: '가공 당일 상태',
        edgingState: '맷돌 당일 운행 상황',
        temperingState: '강화 당일 운행 상황',
        hollowState: '중공 당일 운행 상황',
        switch: '전환',
        running: '실행 중',
        stopping: '중지',
        diffMinutes: '분',
        loadstart: '가공 시작 시간',
        loadend: '컷 종료 시간',
        loadtotal: '총 가공 시간',
        loadfree: '가공 유휴 시간',
        loaddiff: '가공 작업 시간',
@@ -552,7 +560,7 @@
        temptotal: '강화 총 시간',
        tempfree: '강화 유휴 시간',
        tempdiff: '강화 작업 시간',
        tempstove:  '강화로호',
        tempstove: '강화로호',
        tempnumber: '강화 총 수량',
        temparea: '강화 총면적',
        hollowstart: '빈 시작 시간',
@@ -567,262 +575,262 @@
        totalnumber: '총 수량',
        tatalarea: '총면적',
        statistics: '생산 통계',
        ExporttoExcel:'excel 내보내기',
          slice:'영화',
          load:'절단',
          edg:'에징 ',
          temp:'강화',
          hollow:'중공',
          oneFinish:'일선 완성',
          twoFinish:'2선 완성',
          oneunFinish:'일선 미완성',
          twounFinish:'2선 미완성',
          ondDamage:'일선파손',
          percent:'진행률',
          time: '차파 시간',
          tionnumber: '주문 번호',
          jobnumber: '신문 기사 번호',
          productionnumber: '생산 주문 번호',
          cardnumber: '공정 카드 번호',
          projectname: '프로젝트 이름',
          batch: '배치',
          detailID: '내역 ID',
          building: '건물 번호',
          serialnumber: '주문 번호',
          productname: '제품 이름',
          engineername: '공정명칭',
          inproductname: '제품 이름을 입력하십시오.',
          serial: '프로세스 확인 번호',
          slicemarker: '레이어 번호',
          numberpatches: '패치 수',
          width: '너비',
          height: '높이',
          shape: '모양',
          responsibleprocess: '책임 공정',
          process: '이 절차',
          numberfractions: '차파 미보충 수량',
          breakreason: '차파 원인',
          breaktype: '보조 브레이크 유형',
          responsiblepersonnel: '책임자',
          responsiblequipment: '책임 장치',
          responsibleteam: '책임반',
          area: '차파면적',
          inspector: '품질 검사원',
          operate: '작업',
          mes: '상세 정보',
          projectnumber: '프로젝트 번호',
          brokeno: '차수를 보고하고도 아직 보충하지 않았다.',
          close: '닫기',
          orderId: '주문 ID',
          order: '주문 상세 정보',
          customerName: '고객 이름',
          incustomerName: '고객의 이름을 입력하십시오.',
          project: '프로젝트 이름',
          are: '면적',
          quantity: '수량',
          warehousing: '상태',
          deliveryDate: '배송 시간',
          notstocked: '입고되지 않음',
          inboundstatus: '부분 입고 상태',
          allstatus: '모든 입고 상태',
          completedquantity: '완료 수량',
          scrapquantity: '폐기 수량',
          number: '수량',
          method: '가공 방식',
          innumber: '입력한 수량',
          productstatus: '프로덕션 상태',
          right: '정상',
          stop: '종료',
          inquire: '질의',
          starttime :'시작 시간',
          endtime :'종료 시간',
          loading :'게시 중：',
          brokenNum:'파손 수량',
          inventory:'재고',
          inventoryarea:'재고 면적',
          shippedQuantity:'배송 수량',
          reportWorkQuantity:'완공 수량',
          reportWorkQuantityCount:'파손 수량',
          processId:'공정 카드 번호',
          historicaltasks1:'원본 창고',
          historicaltasks2:'전편 일선',
          historicaltasks3:'전편 2선.',
          historicaltasks4:'수평식 일선',
          historicaltasks5:'수평 2선',
          historicaltasks6:'강화 대리편',
          historicaltasks7:'중공 일선',
          historicaltasks8:'중공 2선',
          historicaltasks9:'중공대리편',
          historicaltasks10:'생산 통계',
          date:'날짜',
          countOutOne: '절단선',
          totalAreaOutOne: '절단선 면적',
          countOutTwo: '2선 절단',
          totalAreaOutTwo: '절단 2선 면적',
          countIn: '강화 전 대리편',
          totalAreaIn: '강화 전 대리편 면적',
          countOut: '강화',
          totalAreaOut: '강화 면적',
          hollowCountOutOne: '중공 일선',
          hollowTotalAreaOutOne: '중공 일선 면적',
          hollowCountOutTwo: '중공 2선',
          hollowTotalAreaOutTwo: '중공 2선 면적',
      },
      reportmanage:{
          productiontime :'생산 시간',
          starttime :'시작 시간',
          endtime :'종료 시간',
          ctype :'유형 선택',
          cstate :'상태 선택',
          cprocess :'절차를 선택하십시오.',
          all :'모두',
          completed :'완공',
          broke :'파손',
          takeout :'제거',
          dreportwork :'미등록 노동자',
          pendingwork :'이미 보충',
          reportwork :'이미 일을 신청하였다.',
          reportworked :'동기화됨',
          incise :'절단',
          edging :'에징',
          steel :'강화',
          inquire :'질의',
          signingwork :'신문 기사',
          reporteam :'작업반에 보고하다.',
          reportingequipment :'공사 신청 설비',
          line :'라인',
          process :'공정',
          glassID :'유리 ID',
          projectnumber :'프로젝트 선택',
          layoutID :'강화 레이아웃 ID 입력 필수',
          type :'유형',
          state :'상태',
          processcards :'공정 카드',
          number :'일련번호',
          layer :'레이어',
          typebreakage :'파손 유형',
          ptypebreakage :'파손 유형을 선택하십시오.',
          causebreakage :'파손 원인',
          pcausebreakage :'파손 원인을 선택하십시오.',
          responsibleprocess :'책임 공정',
          responsiblepersonnel :'책임자',
          presponsiblepersonnel :'담당자를 입력하십시오.',
          responsibleteam :'책임반',
          presponsibleteam :'책임 그룹을 선택하십시오.',
          responsibleequipment :'책임 장치',
          presponsibleequipment :'책임 장치를 선택하십시오.',
          remark :'설명',
          premark :'설명을 입력하십시오.',
      },
      film:{
          resetnumber:'선반 번호',
          fail:'실패',
          mes:'원본 창고 저장 상세 정보',
          warehousing:'원본 입고',
          pwarehousing:'입고 요청',
          wareout:'원편 출고',
          information:'이 메시지의 출고 여부？',
          pwareout:'출고 요청',
          position:'조립 위치：',
          cposition:'조립 위치를 선택하세요',
          position1:'조립 위치 1',
          position2:'조립 비트2',
          addglass:'원본 정보',
          operate: '작업',
          exit:'편집',
          delete:'삭제',
          outbound:'출고',
          deviceid:'장치 ID',
          enablestatea:'태그 사용',
          disable:'비활성화',
          start:'활성화',
          startslot:'작업 시작',
          endslot:'목표 작업 위치',
          slotid:'체크 ID',
          slot:'체크 번호',
          width:'원판 너비',
          widtha:'원판 너비：',
          inwidth:'원본 너비를 입력하십시오.',
          height:'원판 높이',
          inheight:'원본 높이를 입력하십시오.',
          heighta:'원판 높이：',
          thickness:'원본 시트의 두께',
          inthickness:'请输入原片厚度',
          thicknessa:'원본 시트의 두께：',
          films:'코팅 타입',
          infilms:'필름계를 입력하세요',
          filmsa:'코팅 타입：',
          createtime:'생성 시간',
          remainquantity:'남은 수량',
          thickremainquantity:'원편 남은 수량 (장)：',
          thickremainquant:'원편 남은 수량 (장)',
          inquantity:'수량 입력 필수',
          quantitya:'수량：',
          enableid:'작업 ID',
          originateslot:'시작 칸',
          endoriginateslot:'목표 칸',
          patternquantity:'원본 수량',
          enabletype:'작업 유형',
          enablestate:'작업 위치 상태',
          finish:'완료됨',
          unfinish:'미완성',
          dedelete:'이 항목의 삭제 여부？',
          dedisable:'이 항목의 비활성화 여부？',
          deoutbound:'이 항목의 출고 여부？',
          selectwarehousing:'조립 위치를 선택하세요',
          inwarehousing:'조립 위치：',
          warehousing1:'조립 위치 1',
          warehousing2:'조립 비트2',
          starttime :'시작 시간',
          endtime :'종료 시간',
          taskstatus :'작업 상태',
          built :'새로 만들기',
          execution :'실행 중',
          tasktype :'작업 유형',
          stocke :'입고',
          dispatch :'스케줄링',
          inquire :'질의',
          station :'작업 위치',
      },
      Mounting:{
          previewproject: '프로젝트 미리 보기 선택',
          loadinglinea: '윗선',
          loadingline: '윗선：',
          inloadingline: '이전 슬라이스 선을 선택하십시오.',
          oneloadingline: '1 번 윗선',
          twoloadingline: '2번 윗선',
          waiting: '대기 중',
          pass: '승인',
          setparameters: '매개변수 설정',
          project: '프로젝트 선택',
          projecta: '프로젝트 선택：',
          width: '원판 너비',
          height: '원판 높이',
          thickness: '원본 시트의 두께',
          projectnumber: '원본 필름의 일련 번호입니다.',
          state: '상태',
          createtime: '생성 시간',
          all: '모두 선택',
          removalmethod: '필름 제거 방식을 선택하세요',
          removalmethodp: '제막 방식',
          removalmethoda: '제막 방식：',
          noremoval: '불제막',
          removal: '제막',
          coarselyground: '굵게 갈다',
          finegrinding: '정교하게 갈다',
      },
        ExporttoExcel: 'excel 내보내기',
        slice: '영화',
        load: '절단',
        edg: '에징 ',
        temp: '강화',
        hollow: '중공',
        oneFinish: '일선 완성',
        twoFinish: '2선 완성',
        oneunFinish: '일선 미완성',
        twounFinish: '2선 미완성',
        ondDamage: '일선파손',
        percent: '진행률',
        time: '차파 시간',
        tionnumber: '주문 번호',
        jobnumber: '신문 기사 번호',
        productionnumber: '생산 주문 번호',
        cardnumber: '공정 카드 번호',
        projectname: '프로젝트 이름',
        batch: '배치',
        detailID: '내역 ID',
        building: '건물 번호',
        serialnumber: '주문 번호',
        productname: '제품 이름',
        engineername: '공정명칭',
        inproductname: '제품 이름을 입력하십시오.',
        serial: '프로세스 확인 번호',
        slicemarker: '레이어 번호',
        numberpatches: '패치 수',
        width: '너비',
        height: '높이',
        shape: '모양',
        responsibleprocess: '책임 공정',
        process: '이 절차',
        numberfractions: '차파 미보충 수량',
        breakreason: '차파 원인',
        breaktype: '보조 브레이크 유형',
        responsiblepersonnel: '책임자',
        responsiblequipment: '책임 장치',
        responsibleteam: '책임반',
        area: '차파면적',
        inspector: '품질 검사원',
        operate: '작업',
        mes: '상세 정보',
        projectnumber: '프로젝트 번호',
        brokeno: '차수를 보고하고도 아직 보충하지 않았다.',
        close: '닫기',
        orderId: '주문 ID',
        order: '주문 상세 정보',
        customerName: '고객 이름',
        incustomerName: '고객의 이름을 입력하십시오.',
        project: '프로젝트 이름',
        are: '면적',
        quantity: '수량',
        warehousing: '상태',
        deliveryDate: '배송 시간',
        notstocked: '입고되지 않음',
        inboundstatus: '부분 입고 상태',
        allstatus: '모든 입고 상태',
        completedquantity: '완료 수량',
        scrapquantity: '폐기 수량',
        number: '수량',
        method: '가공 방식',
        innumber: '입력한 수량',
        productstatus: '프로덕션 상태',
        right: '정상',
        stop: '종료',
        inquire: '질의',
        starttime: '시작 시간',
        endtime: '종료 시간',
        loading: '게시 중：',
        brokenNum: '파손 수량',
        inventory: '재고',
        inventoryarea: '재고 면적',
        shippedQuantity: '배송 수량',
        reportWorkQuantity: '완공 수량',
        reportWorkQuantityCount: '파손 수량',
        processId: '공정 카드 번호',
        historicaltasks1: '원본 창고',
        historicaltasks2: '전편 일선',
        historicaltasks3: '전편 2선.',
        historicaltasks4: '수평식 일선',
        historicaltasks5: '수평 2선',
        historicaltasks6: '강화 대리편',
        historicaltasks7: '중공 일선',
        historicaltasks8: '중공 2선',
        historicaltasks9: '중공대리편',
        historicaltasks10: '생산 통계',
        date: '날짜',
        countOutOne: '절단선',
        totalAreaOutOne: '절단선 면적',
        countOutTwo: '2선 절단',
        totalAreaOutTwo: '절단 2선 면적',
        countIn: '강화 전 대리편',
        totalAreaIn: '강화 전 대리편 면적',
        countOut: '강화',
        totalAreaOut: '강화 면적',
        hollowCountOutOne: '중공 일선',
        hollowTotalAreaOutOne: '중공 일선 면적',
        hollowCountOutTwo: '중공 2선',
        hollowTotalAreaOutTwo: '중공 2선 면적',
    },
    reportmanage: {
        productiontime: '생산 시간',
        starttime: '시작 시간',
        endtime: '종료 시간',
        ctype: '유형 선택',
        cstate: '상태 선택',
        cprocess: '절차를 선택하십시오.',
        all: '모두',
        completed: '완공',
        broke: '파손',
        takeout: '제거',
        dreportwork: '미등록 노동자',
        pendingwork: '이미 보충',
        reportwork: '이미 일을 신청하였다.',
        reportworked: '동기화됨',
        incise: '절단',
        edging: '에징',
        steel: '강화',
        inquire: '질의',
        signingwork: '신문 기사',
        reporteam: '작업반에 보고하다.',
        reportingequipment: '공사 신청 설비',
        line: '라인',
        process: '공정',
        glassID: '유리 ID',
        projectnumber: '프로젝트 선택',
        layoutID: '강화 레이아웃 ID 입력 필수',
        type: '유형',
        state: '상태',
        processcards: '공정 카드',
        number: '일련번호',
        layer: '레이어',
        typebreakage: '파손 유형',
        ptypebreakage: '파손 유형을 선택하십시오.',
        causebreakage: '파손 원인',
        pcausebreakage: '파손 원인을 선택하십시오.',
        responsibleprocess: '책임 공정',
        responsiblepersonnel: '책임자',
        presponsiblepersonnel: '담당자를 입력하십시오.',
        responsibleteam: '책임반',
        presponsibleteam: '책임 그룹을 선택하십시오.',
        responsibleequipment: '책임 장치',
        presponsibleequipment: '책임 장치를 선택하십시오.',
        remark: '설명',
        premark: '설명을 입력하십시오.',
    },
    film: {
        resetnumber: '선반 번호',
        fail: '실패',
        mes: '원본 창고 저장 상세 정보',
        warehousing: '원본 입고',
        pwarehousing: '입고 요청',
        wareout: '원편 출고',
        information: '이 메시지의 출고 여부？',
        pwareout: '출고 요청',
        position: '조립 위치：',
        cposition: '조립 위치를 선택하세요',
        position1: '조립 위치 1',
        position2: '조립 비트2',
        addglass: '원본 정보',
        operate: '작업',
        exit: '편집',
        delete: '삭제',
        outbound: '출고',
        deviceid: '장치 ID',
        enablestatea: '태그 사용',
        disable: '비활성화',
        start: '활성화',
        startslot: '작업 시작',
        endslot: '목표 작업 위치',
        slotid: '체크 ID',
        slot: '체크 번호',
        width: '원판 너비',
        widtha: '원판 너비：',
        inwidth: '원본 너비를 입력하십시오.',
        height: '원판 높이',
        inheight: '원본 높이를 입력하십시오.',
        heighta: '원판 높이：',
        thickness: '원본 시트의 두께',
        inthickness: '请输入原片厚度',
        thicknessa: '원본 시트의 두께：',
        films: '코팅 타입',
        infilms: '필름계를 입력하세요',
        filmsa: '코팅 타입：',
        createtime: '생성 시간',
        remainquantity: '남은 수량',
        thickremainquantity: '원편 남은 수량 (장)：',
        thickremainquant: '원편 남은 수량 (장)',
        inquantity: '수량 입력 필수',
        quantitya: '수량：',
        enableid: '작업 ID',
        originateslot: '시작 칸',
        endoriginateslot: '목표 칸',
        patternquantity: '원본 수량',
        enabletype: '작업 유형',
        enablestate: '작업 위치 상태',
        finish: '완료됨',
        unfinish: '미완성',
        dedelete: '이 항목의 삭제 여부？',
        dedisable: '이 항목의 비활성화 여부？',
        deoutbound: '이 항목의 출고 여부？',
        selectwarehousing: '조립 위치를 선택하세요',
        inwarehousing: '조립 위치：',
        warehousing1: '조립 위치 1',
        warehousing2: '조립 비트2',
        starttime: '시작 시간',
        endtime: '종료 시간',
        taskstatus: '작업 상태',
        built: '새로 만들기',
        execution: '실행 중',
        tasktype: '작업 유형',
        stocke: '입고',
        dispatch: '스케줄링',
        inquire: '질의',
        station: '작업 위치',
    },
    Mounting: {
        previewproject: '프로젝트 미리 보기 선택',
        loadinglinea: '윗선',
        loadingline: '윗선：',
        inloadingline: '이전 슬라이스 선을 선택하십시오.',
        oneloadingline: '1 번 윗선',
        twoloadingline: '2번 윗선',
        waiting: '대기 중',
        pass: '승인',
        setparameters: '매개변수 설정',
        project: '프로젝트 선택',
        projecta: '프로젝트 선택：',
        width: '원판 너비',
        height: '원판 높이',
        thickness: '원본 시트의 두께',
        projectnumber: '원본 필름의 일련 번호입니다.',
        state: '상태',
        createtime: '생성 시간',
        all: '모두 선택',
        removalmethod: '필름 제거 방식을 선택하세요',
        removalmethodp: '제막 방식',
        removalmethoda: '제막 방식：',
        noremoval: '불제막',
        removal: '제막',
        coarselyground: '굵게 갈다',
        finegrinding: '정교하게 갈다',
    },
    hellow: {
        pleaseConfirm: '문제가 처리된 후에 이 장애를 확인하려면 더블 클릭하여 시스템이 정상적으로 작동하도록 하세요!',
        taskAlreadyClaimed: '이 작업은 이미 수령되었으며, 반복 수행할 수 없습니다.',
        claimed: '받음',
        claimFailed: '임무 받기 실패',
        claimedTasksCleared: '받은 임무 상태가 초기화되었습니다',
        content:'내용',
        idSame:'진입 작업 유리 ID가 동일합니다.',
        sizeSame:'우리 안에 동일한 규격의 유리가 존재합니다.',
        slotLess:'나머지 그리드가 부족합니다.',
        overSize:'직통 피딩대에 유리가 있어 이번 피딩을 종료합니다',
        noGlass:'유리 정보를 찾을 수 없습니다. 공정을 받으세요.',
        content: '내용',
        idSame: '진입 작업 유리 ID가 동일합니다.',
        sizeSame: '우리 안에 동일한 규격의 유리가 존재합니다.',
        slotLess: '나머지 그리드가 부족합니다.',
        overSize: '직통 피딩대에 유리가 있어 이번 피딩을 종료합니다',
        noGlass: '유리 정보를 찾을 수 없습니다. 공정을 받으세요.',
        clickmakesure: '클릭 확인 여부？',
        logarithm: '대수：',
        totalPairQuantitya: '총 임무 짝수',
@@ -839,7 +847,7 @@
        pairQuantity: '완료된 쌍 수',
        isForceList: '강제 여부',
        yesisForceList: '강제',
        noisForceList: '비강제', 
        noisForceList: '비강제',
        hollowCountOutOne: '중공 1선 유리 수량',
        hollowCountOutTwo: '중공 2선 유리 수량',
        hollowTotalAreaOutOne: '중공 1선 유리 면적',
@@ -888,11 +896,11 @@
        intervalFrameHeightaOne: '간격 상자 높이 1 을 입력하십시오.',
        intervalFrameHeightaTwo: '간격 상자 높이 2를 입력하십시오.',
        intervalFrameHeightaThree: '간격 상자 높이 3을 입력하십시오.',
        intervalFrameHeightaFour:  '간격 상자 높이 4 를 입력하십시오.',
        intervalFrameHeightaFour: '간격 상자 높이 4 를 입력하십시오.',
        intervalFrameHeightbOne: '간격 상자 높이 11：',
        intervalFrameHeightbTwo: '간격 상자 높이 2：',
        intervalFrameHeightbThree: '간격 상자 높이 3：',
        intervalFrameHeightbFour:  '간격 상자 높이 4：',
        intervalFrameHeightbFour: '간격 상자 높이 4：',
        intervalFrameTypeOne: '간격 상자 유형 1',
        intervalFrameTypeTwo: '간격 상자 유형 2',
        intervalFrameTypeThree: '간격 상자 유형 3',
@@ -910,15 +918,15 @@
        intervalFrameWidthOne: '간격 상자 너비 1',
        intervalFrameWidthTwo: '간격 상자 너비 2',
        intervalFrameWidthThree: '간격 상자 너비 3',
        intervalFrameWidthFour:  '간격 상자 너비 4',
        intervalFrameWidthFour: '간격 상자 너비 4',
        intervalFrameWidthaOne: '간격 상자 너비 1을 입력하십시오.',
        intervalFrameWidthaTwo: '간격 상자 너비 2를 입력하십시오.',
        intervalFrameWidthaThree: '간격 상자 너비 3을 입력하십시오.',
        intervalFrameWidthaFour:  '간격 상자 너비 4 를 입력하십시오.',
        intervalFrameWidthaFour: '간격 상자 너비 4 를 입력하십시오.',
        intervalFrameWidthbOne: '간격 상자 너비 1：',
        intervalFrameWidthbTwo: '간격 상자 너비 2：',
        intervalFrameWidthbThree: '간격 상자 너비 3：',
        intervalFrameWidthbFour:  '간격 상자 너비 4：',
        intervalFrameWidthbFour: '간격 상자 너비 4：',
        sealInsert: '밀봉 내장',
        sealInsertb: '밀봉 내장：',
        sealInserta: '밀봉 포함 입력',
@@ -990,10 +998,10 @@
        cpairQuantity: '총 쌍 수를 입력하십시오.',
        schedulingswitch: '스케줄러 스위치',
    },
    screendisplay:{
    screendisplay: {
        pchoice: '선택하십시오.',
        pwidth: '너비를 입력하십시오.',
        pheight: '높이를 입력하십시오.',
        upnumber: '이전 슬라이스 수',
    } 
    }
}

 UI-Project/src/lang/py.js

@@ -363,6 +363,14 @@
        glasstakeout:'玻璃拿走清单',
        layoutID:'版图ID',
        glassID:'Стеклянный ID',
        tempState1: '生成任务',        // -1 生成任务
        tempState2: '出片完成',        // 0 出片完成
        tempState3: '摆片完成',        // 1 摆片完成
        tempState4: '进炉完成',        // 2 进炉完成
        tempState5: '钢化完成',        // 3 钢化完成
        tempState6: '出片完成',        // 4 出片完成
        tempState7: '破损',            // 8 破损
        tempState8: '拿走',            // 9 拿走
    },
    reportWork: {
        details:'Сведения о сдаче',

 UI-Project/src/lang/zh.js

@@ -1,554 +1,562 @@
export  default {
export default {
    "northglassMESsystem": "北玻MES系统",
      login:{
          userErr:'请输入账号',
          pwErr:'请输入密码',
          user:'账号',
          password:'密码',
          login:'登录',
          loginSuccessful:'登录成功！',
          register:'注册',
          namea:'姓名不能为空',
          len:'长度不能超过16',
          passnull:'密码不能为空',
          leng:'密码长度不能低于6或超过16',
          spwn:'确认密码不能为空',
          depass:'两次密码不相同',
      },
      register:{
          registerSuccessful:'注册成功',
          newuserregister:'注册新用户',
          name:'姓名：',
          inputname:'请输入姓名',
          password:'密码:',
          pwErr:'请输入密码',
          passwordation:'确认密码:',
          pwErration:'请确认密码',
          registration:'确认注册',
          false:'取消',
      },
      main:{
          connectErr:'服务器连接异常，请稍后再试',
          titleFirst:"欢迎 ",
          titleLast:' 使用北玻MES系统！',
          quit:"退出",
      },
      basicData:{
          untask:'无任务',
          tonumber:'上片总数量',
          sectionUpperSuccessful:'上片操作成功！',
          finishnumber:'已完成数量',
          rackreset:'架子复位',
          prackreset:'是否架子复位？',
          laserprinting:'打标机就绪状态：',
          cuttingmachine:'切割机就绪状态：',
          machine:'上片机联机状态：',
          machineaa:'上片机手动状态：',
          selectproject:"选择工程",
          startloading:'开始上片',
          stop:'暂停',
          yes:'确认',
          change:'切换',
          projectnumber:'工程号',
          glasswidth:'原片宽',
          glassheight:'原片高',
          coatingtypes:'膜系',
          coatingtypesa:'膜系：',
          quantity:'数量',
          quantitya:'数量：',
          thickness:'厚度',
          thicknessa:'厚度：',
          startstatus:'启用状态',
          pass:'通过',
          waiting:'等待中',
          up:'上片中',
          finish:'已完成',
          project:'工程',
          plselectproject:'请选择工程',
          confirm:'确认',
          cancel:'取消',
          startfilm:'是否开始上片？',
          whetherpause:'是否暂停？',
          station:'工位',
          width:'宽',
          widtha:'宽：',
          height:'高',
          heighta:'高：',
          operate:'操作',
          add:'添加',
          delete:'删除',
          addglass:'添加原片',
          selectwidth:'请选择宽',
          selectheight:'请选择高',
          selectcoatingtypes:'请选择膜系',
          selectthickness:'请选择厚度',
          selectquantity:'请输入数量',
          pause:'第二行和第四行的高必须大于2700才能保存！',
          pausea:'请确认打标机和切割机的就绪状态！',
          infonull:'工程号不能为空！',
          updatanull:'该工程未保存到上片表！',
          glassnull:'更新玻璃状态时发生错误',
          deletemessage:'是否删除该条信息?',
          layoutSequence:'序号',
      },
      sorter:{
          onesort:'一线掰片',
          twosort:'二线掰片',
          inPlace:'到位',
          ninPlace:'未到位',
          emptymissions:'空任务',
          advancetask:'进片任务',
          outputtasks:'出片任务',
          schedulingtasks:'调度任务',
          advancerequests:'进片请求',
          releaserequest:'出片请求',
          straighttasks:'直通任务',
          endingtask:'结束',
          another:'其他',
          id:'磨边前理片笼表ID',
          remainWidth:'剩余',
          taskRunning:'任务请求',
          updateTime:'更新时间',
          place:'是否到位',
          layernow:'当前层号',
          gridnumber:'栅格号',
          glassnumber:'玻璃编号',
          width:'宽',
          height:'高',
          startstatus:'启用状态',
          disable:'已禁用',
          start:'已启用',
          deficiencieste:'报缺',
          updown:'人工下片',
          operate:'操作',
          prompt:'提示',
          information:'是否报缺该条信息？',
          infor:'是否人工下片该条信息？',
          yes:'是',
          cancel:'取消',
      },
      order:{
          projectnumber:'请输入工程号',
          noGlassToDamage:'没有可破损的玻璃！',
          dilapidation:'破损',
          dilapidationDetails:'破损详情',
          dilapidationAll:'一键破损',
          dilapidationWhether:'是否一键破损？',
          takeaway:'人工拿走',
          takeawaya:'是否人工拿走该条信息？',
          takeon:'摆片完成',
      },
      searchOrder:{
          loadingText: '数据加载中，请稍候...',
          firstLinePriority: '一线优先',
          secondLinePriority: '二线优先',
          hollowPriority:'中空优先级',
          furnaces:'满炉炉数',
          furnfullTemp:'玻璃总量',
          startCell:'目标层号',
          endCell:'预留层号',
          begin:'开始',
          finish:'完成',
          uncar:'未上车',
          inkage:'进片',
          successfullyprocessed:'任务成功处理',
          psuccessfullyprocessed:'是否进行任务成功处理？',
          taskfailure:'任务失败处理',
          ptaskfailure:'是否进行任务失败处理？',
          totallogarithms:'总对数',
          numberpairs:'配对数',
          numberoccupied:'占用格子数',
          totalfurnaces:'总炉数',
          cagesnumber:'笼内数量',
          slotnumber:'占有格子数',
          progress:'进度%',
          whethersame:'是否相同',
          same:'相同',
          notsame:'不相同',
          partask:'任务重置',
          partasks:'是否任务重置？',
          empty:'默认空任务',
          historicaltasks:'历史任务',
          cagedetails:'笼内详情',
          inkageEntity:'进片联机状态：',
          requestEntity:'进片请求状态：',
          mesReplyEntity:'启动命令：',
          outInkageEntity:'出片联机状态：',
          outRequestEntity:'出片请求状态：',
          breakagn:'未破损',
          lacknumber:'缺片数量',
          processcard:'指定流程卡',
          filminformation:'人工下片信息',
          currentglassinformation:'扫码枪当前玻璃信息',
          printlabels:'打印标签',
          deleteTask:'结束工程',
          pdeleteTask:'是否结束工程？',
          searchlayout:'非钢化流程卡查询',
          fullfurnaces:'满炉数量',
          specifiedproject:'当前指定工程',
          undesignate:'取消钢化',
          allnumber:'总数量',
          numbercages:'笼子内数量',
          missingquantity:'缺少数量',
          breakquantity:'破损/拿走数量',
          ceng:'层',
          cageinformation:'理片笼信息',
          productionqueue:'出片队列',
          outputglassID:'出片玻璃ID',
          startposition:'起始位置',
          targetlocation:'目标位置',
          trips:'车次',
          number:'序号',
          taskstatus:'任务状态',
          filmenter:'等待进片',
          infilm:'进行中',
          endtask:'结束任务',
          completetask:'完成任务',
          intoglassid:'进片玻璃ID',
          line:'线路',
          Usage:'使用率',
          free:'空闲（格子数）',
          addcage:'添加理片笼信息',
          glassIDa:'玻璃ID：',
          glassID:'玻璃ID',
          inglassID:'请输入玻璃ID',
          pieceingrid:'小片在格内的顺序',
          pieceingrida:'小片在格内的顺序：',
          inpieceingrid:'请输入小片在格内的顺序',
          cardnumber:'流程卡号',
          cardnumbera:'流程卡号：',
          incardnumber:'请输入流程卡号',
          typeglass:'玻璃类型',
          typeglassa:'玻璃类型：',
          intypeglass:'请输入玻璃类型',
          width:'宽',
          widtha:'宽：',
          inwidth:'请输入宽',
          height:'高',
          heighta:'高：',
          inheight:'请输入高',
          coatingtypes:'膜系',
          thickness:'厚度',
          thicknessa:'厚度：',
          inthickness:'请输入厚度',
          layoutID:'钢化版图ID',
          layoutIDa:'钢化版图ID：',
          inlayoutID:'请输入钢化版图ID',
          picturesequence:'钢化版图片序',
          picturesequencea:'钢化版图片序：',
          inpicturesequence:'请输入钢化版图片序',
          startstatus:'启用状态',
          startstatusa:'启用状态：',
          instartstatus:'请输入启用状态',
          choicestartstatus:'请选择启用状态',
          glassgaps:'玻璃间隙',
          glassgapsa:'玻璃间隙：',
          inglassgaps:'请输入玻璃间隙',
          sure:'确认',
          cancel:'取消',
          operate:'操作',
          breakage:'破损',
          delete:'删除',
          outfilm:'出片',
          cagetableID:'大理片笼表ID',
          cagenumber:'理片笼号',
          gridnumber:'栅格号',
          gridnumbera:'栅格号：',
          grid:'请输入栅格号',
          enable:'已启用',
          disable:'已禁用',
          remainingwidth:'剩余宽度',
          add:'添加',
          sheetID:'钢化小片信息表ID',
          processcards:'流程卡',
          processcardtype:'流程卡玻璃类型',
          acceptshorizontal:'钢化是否接受横放',
          xcoordinates:'x坐标',
          ycoordinates:'y坐标',
          rotationangle:'旋转角度（逆时针）',
          state:'状态',
          takeout:'拿走',
          deletemessage:'是否删除该条信息?',
          prompt:'提示',
          yes:'是',
          accept:'接受',
          noaccept:'不接受',
          filmcomplete:'出片完成',
          waiting:'等待中',
          broke:'是否破损该条信息？',
          brokeb:'是否拿走该条信息？',
          outfil:'是否出片该条信息？',
          inputid:'请输入玻璃ID',
          search:'搜索',
          tabid:'大理片笼详情表id',
          tid:'设备id',
          tida:'设备id：',
          fin:'是否完成任务？',
          sureadd:'确认添加',
          sureadda:'是否确认添加？',
          zailong:'在笼中',
          rengongxp:'人工下片',
          up:'上一页',
          down:'下一页',
          now:'当前页显示',
          tit:'条数据',
          temperingqueries:'钢化查询',
          specifytempering:'指定一炉',
          specifyout:'指定人工出片',
          specifyengineerid:'指定工程',
          projectnumber:'工程号',
          layoutnumber:'钢化版图号',
          numberglasses:'玻璃数量',
          specifytemperinga:'请确认设备是否已关闭MES联机？',
          temperedswitch:'钢化开关',
          dutyinformation:'值班信息',
          process:'工序',
          team:'班组',
          basic:'设备',
          makesure:'确认保存',
          temperingtotal:'钢化炉数：',
          glasstotal:'玻璃总数：',
          Labelprinting:'标签打印',
          Schedulingswitch:'调度开关',
      },
      workOrder:{
          upnumber:'上片位编号',
          glassID:'玻璃ID',
          height:'高',
          width:'宽',
          thickness:'厚度',
          coatingtypes:'膜系',
          coatingtypesbe:'原片膜系',
          productionsequence:'出片顺序',
          cardnumber:'流程卡号',
          operate:'操作',
          messagedamaged:'是否破损该条信息?',
          prompt:'提示',
          yes:'是',
          cancel:'取消',
          takemessage:'是否拿走该条信息？',
          breakage:'破损',
          takeout:'拿走',
          glasstype:'玻璃膜系',
          line:'线路',
          status:'状态',
          time:'时间段',
          cway:'请选择线路',
          cstate:'请选择状态',
          edgingone:'磨边一线',
          edgingtwo:'磨边二线',
          nedging:'未磨边',
          edging:'磨边中',
          finedging:'已磨边',
      },
      processCard:{
          thisIsTheIndoorSurface: '此面为室内面',
          thisSideIsOutsideTheRoom: '此面为室外面',
          intofurnace:'进炉中',
          beforefurnace:'进炉前',
          outfurnace:'已出炉玻璃',
          print:'拿走打印',
          printing:'打印',
          projectnumber:'请输入工程号',
          inquire:'查询',
          project:'工程号',
          awayprocess:'拿走工序',
          awayequipment:'拿走设备',
          awayteam:'拿走班组',
          flowcard:'流程卡',
          layer:'层号',
          temperinglayout:'炉号',
          temperingfeed:'片序',
          width:'宽',
          height:'高',
          thickness:'厚',
          glasstakeout:'玻璃拿走清单',
          layoutID:'版图ID',
          glassID:'玻璃ID',
      },
      reportWork:{
          details:'落架详情',
          filming:'人工下片',
          printing:'自动打印',
          cenumber:'层数',
          artificialorder:'人工下片数',
          processcard:'打印流程卡',
          printlabels:'打印标签',
          information:'落架信息',
          cstation:'请选择工位',
          all:'全部',
          timeperiod:'时间段',
          stationnumber:'工位号',
          order:'顺序',
          filminformation:'人工下片信息',
          glassmation:'人工下片当前玻璃信息',
          barcodescanner:'扫码枪当前玻璃信息',
          lowerbit:'下片位',
          shelfnumber:'架号',
          cardnumber:'流程卡号',
          totalquantity:'总数量',
          beendropped:'已落架数量',
          state:'状态',
          devicenumber:'设备号',
          startstatus:'启用状态',
          enable:'已启用',
          unenable:'未启用',
          operate:'操作',
          bindingshelves:'绑定架子',
          clear:'清空',
          workstation:'号工位',
          shelfnumbera:'架号：',
          cardnumbera:'流程卡号：',
          incardnumber:'请选择流程卡号',
          clearglass:'清除架子玻璃',
          sure:'确认',
          cancel:'取消',
          glassinformation:'玻璃信息',
          glassID:'玻璃ID',
          coatingtypes:'膜系',
          thickness:'厚度',
          width:'宽度',
          height:'高度',
      },
      productStock:{
          inconfirmpassword: '请输入确认密码',
          passwordNotMatch: '两次输入的密码不一致',
          confirmpassword: '确认密码',
          inputNewPassword: '请输入新密码',
          userIdError: '用户ID获取失败',
          addconfigName:'添加配置',
          editconfigName:'修改配置',
          configName:'配置名',
          configNamea:'配置名：',
          configCode:'配置代码',
          configValue:'配置值',
          inconfigValue:'请输入配置值',
          configValuea:'配置值：',
          addusers:'添加用户',
          username:'用户名',
          usernamea:'用户名：',
          inusername:'请输入用户名',
          role:'角色',
          rolea:'角色：',
          inrole:'请选择角色',
          test:'测试',
          admin:'管理员',
          operate:'操作',
          resetpassword:'重置密码',
          exit:'编辑',
          delete:'删除',
          prompt:'提示',
          repassword:'是否重置用户密码？',
          yes:'是',
          cancel:'取消',
          reusername:'修改用户',
          addusername:'添加用户',
          password:'密码：',
          sure:'确认',
          inpassword:'请输入密码',
          deusername:'是否删除该用户？',
      },
      customer:{
          addmenua:'添加二级菜单',
          addmenu:'添加一级菜单',
          firstmenu:'一级菜单栏',
          firstmenuname:'一级菜单名称:',
          link:'链接',
          inlink:'请输入链接',
          linka:'链接：',
          sort:'排序',
          insort:'请输入排序',
          sorta:'排序：',
          operate:'操作',
          exit:'编辑',
          delete:'删除',
          semenu:'二级菜单栏',
          semenuname:'二级菜单名称:',
          menu:'菜单栏：',
          inmenu:'请输入菜单名称',
          sure:'确认',
          cancel:'取消',
          exmene:'修改一级菜单',
          exmenea:'修改二级菜单',
          yes:'是',
          demenu:'是否删除该菜单？', 
          prompt:'提示',
      },
      delivery:{
          alarmStartTime:'报警开始时间',
          alarmEndTime:'报警结束时间',
          equipment:'设备',
          content:'内容',
          confirmer:'确认人',
          addrole:'添加角色',
          editrole:'修改角色',
          role :'角色',
          rolea :'角色：',
          inrole :'请输入角色',
          operate :'操作',
          edit :'编辑',
          delete :'删除',
          yes:'是',
          sure :'确认',
          cancel :'取消',
          derole :'是否删除该角色',
          prompt:'提示',
          choice:'菜单权限：',
          inchoice:'请选择菜单权限',
      },
      replenish:{
          patchManagement:'补片管理',
      },
      rework:{
          reworkManagement:'返工管理',
          addRework:"返工新增 ",
      },
      role:{
          id:'ID',
          characterHomepage:'角色首页',
      },
      user:{
          userId:'用户ID',
          userHomepage:'用户首页',
      },
      orderBasicData:{
          order:'订单',
          orderType:'订单类型',
      },
      machine:{
          basicId:'设备编号',
          basicName:'设备名称',
          basicCategory:'所在工序',
          tempering:'钢化',
      },
      report:{
          productionReport:'生产报表',
          workInProgressReport:'在制品报表',
      },
      productionBasicData:{
          basicDataQuery :'基础数据查询',
      },
      mainIngredient:{
          materialInformation :'物料资料',
      },
      mainIngredientStock:{
          materialName :'物料名称',
          createTime :'返库日期',
      },
      large:{
        patchCount:'已补数量',
        Productionsituation:'生产情况',
        Productionandoperationstatus:'生产运行情况',
        cuttingState:'切割当天运行情况',
        edgingState:'磨边当天运行情况',
        temperingState:'钢化当天运行情况',
        hollowState:'中空当天运行情况',
        switch:'切换',
        running:'运行中',
        stopping:'停止',
        diffMinutes:'分钟',
        loadstart:'切割开始时间',
        loadend:'切割结束时间',
    login: {
        userErr: '请输入账号',
        pwErr: '请输入密码',
        user: '账号',
        password: '密码',
        login: '登录',
        loginSuccessful: '登录成功！',
        register: '注册',
        namea: '姓名不能为空',
        len: '长度不能超过16',
        passnull: '密码不能为空',
        leng: '密码长度不能低于6或超过16',
        spwn: '确认密码不能为空',
        depass: '两次密码不相同',
    },
    register: {
        registerSuccessful: '注册成功',
        newuserregister: '注册新用户',
        name: '姓名：',
        inputname: '请输入姓名',
        password: '密码:',
        pwErr: '请输入密码',
        passwordation: '确认密码:',
        pwErration: '请确认密码',
        registration: '确认注册',
        false: '取消',
    },
    main: {
        connectErr: '服务器连接异常，请稍后再试',
        titleFirst: "欢迎 ",
        titleLast: ' 使用北玻MES系统！',
        quit: "退出",
    },
    basicData: {
        untask: '无任务',
        tonumber: '上片总数量',
        sectionUpperSuccessful: '上片操作成功！',
        finishnumber: '已完成数量',
        rackreset: '架子复位',
        prackreset: '是否架子复位？',
        laserprinting: '打标机就绪状态：',
        cuttingmachine: '切割机就绪状态：',
        machine: '上片机联机状态：',
        machineaa: '上片机手动状态：',
        selectproject: "选择工程",
        startloading: '开始上片',
        stop: '暂停',
        yes: '确认',
        change: '切换',
        projectnumber: '工程号',
        glasswidth: '原片宽',
        glassheight: '原片高',
        coatingtypes: '膜系',
        coatingtypesa: '膜系：',
        quantity: '数量',
        quantitya: '数量：',
        thickness: '厚度',
        thicknessa: '厚度：',
        startstatus: '启用状态',
        pass: '通过',
        waiting: '等待中',
        up: '上片中',
        finish: '已完成',
        project: '工程',
        plselectproject: '请选择工程',
        confirm: '确认',
        cancel: '取消',
        startfilm: '是否开始上片？',
        whetherpause: '是否暂停？',
        station: '工位',
        width: '宽',
        widtha: '宽：',
        height: '高',
        heighta: '高：',
        operate: '操作',
        add: '添加',
        delete: '删除',
        addglass: '添加原片',
        selectwidth: '请选择宽',
        selectheight: '请选择高',
        selectcoatingtypes: '请选择膜系',
        selectthickness: '请选择厚度',
        selectquantity: '请输入数量',
        pause: '第二行和第四行的高必须大于2700才能保存！',
        pausea: '请确认打标机和切割机的就绪状态！',
        infonull: '工程号不能为空！',
        updatanull: '该工程未保存到上片表！',
        glassnull: '更新玻璃状态时发生错误',
        deletemessage: '是否删除该条信息?',
        layoutSequence: '序号',
    },
    sorter: {
        onesort: '一线掰片',
        twosort: '二线掰片',
        inPlace: '到位',
        ninPlace: '未到位',
        emptymissions: '空任务',
        advancetask: '进片任务',
        outputtasks: '出片任务',
        schedulingtasks: '调度任务',
        advancerequests: '进片请求',
        releaserequest: '出片请求',
        straighttasks: '直通任务',
        endingtask: '结束',
        another: '其他',
        id: '磨边前理片笼表ID',
        remainWidth: '剩余',
        taskRunning: '任务请求',
        updateTime: '更新时间',
        place: '是否到位',
        layernow: '当前层号',
        gridnumber: '栅格号',
        glassnumber: '玻璃编号',
        width: '宽',
        height: '高',
        startstatus: '启用状态',
        disable: '已禁用',
        start: '已启用',
        deficiencieste: '报缺',
        updown: '人工下片',
        operate: '操作',
        prompt: '提示',
        information: '是否报缺该条信息？',
        infor: '是否人工下片该条信息？',
        yes: '是',
        cancel: '取消',
    },
    order: {
        projectnumber: '请输入工程号',
        noGlassToDamage: '没有可破损的玻璃！',
        dilapidation: '破损',
        dilapidationDetails: '破损详情',
        dilapidationAll: '一键破损',
        dilapidationWhether: '是否一键破损？',
        takeaway: '人工拿走',
        takeawaya: '是否人工拿走该条信息？',
        takeon: '摆片完成',
    },
    searchOrder: {
        loadingText: '数据加载中，请稍候...',
        firstLinePriority: '一线优先',
        secondLinePriority: '二线优先',
        hollowPriority: '中空优先级',
        furnaces: '满炉炉数',
        furnfullTemp: '玻璃总量',
        startCell: '目标层号',
        endCell: '预留层号',
        begin: '开始',
        finish: '完成',
        uncar: '未上车',
        inkage: '进片',
        successfullyprocessed: '任务成功处理',
        psuccessfullyprocessed: '是否进行任务成功处理？',
        taskfailure: '任务失败处理',
        ptaskfailure: '是否进行任务失败处理？',
        totallogarithms: '总对数',
        numberpairs: '配对数',
        numberoccupied: '占用格子数',
        totalfurnaces: '总炉数',
        cagesnumber: '笼内数量',
        slotnumber: '占有格子数',
        progress: '进度%',
        whethersame: '是否相同',
        same: '相同',
        notsame: '不相同',
        partask: '任务重置',
        partasks: '是否任务重置？',
        empty: '默认空任务',
        historicaltasks: '历史任务',
        cagedetails: '笼内详情',
        inkageEntity: '进片联机状态：',
        requestEntity: '进片请求状态：',
        mesReplyEntity: '启动命令：',
        outInkageEntity: '出片联机状态：',
        outRequestEntity: '出片请求状态：',
        breakagn: '未破损',
        lacknumber: '缺片数量',
        processcard: '指定流程卡',
        filminformation: '人工下片信息',
        currentglassinformation: '扫码枪当前玻璃信息',
        printlabels: '打印标签',
        deleteTask: '结束工程',
        pdeleteTask: '是否结束工程？',
        searchlayout: '非钢化流程卡查询',
        fullfurnaces: '满炉数量',
        specifiedproject: '当前指定工程',
        undesignate: '取消钢化',
        allnumber: '总数量',
        numbercages: '笼子内数量',
        missingquantity: '缺少数量',
        breakquantity: '破损/拿走数量',
        ceng: '层',
        cageinformation: '理片笼信息',
        productionqueue: '出片队列',
        outputglassID: '出片玻璃ID',
        startposition: '起始位置',
        targetlocation: '目标位置',
        trips: '车次',
        number: '序号',
        taskstatus: '任务状态',
        filmenter: '等待进片',
        infilm: '进行中',
        endtask: '结束任务',
        completetask: '完成任务',
        intoglassid: '进片玻璃ID',
        line: '线路',
        Usage: '使用率',
        free: '空闲（格子数）',
        addcage: '添加理片笼信息',
        glassIDa: '玻璃ID：',
        glassID: '玻璃ID',
        inglassID: '请输入玻璃ID',
        pieceingrid: '小片在格内的顺序',
        pieceingrida: '小片在格内的顺序：',
        inpieceingrid: '请输入小片在格内的顺序',
        cardnumber: '流程卡号',
        cardnumbera: '流程卡号：',
        incardnumber: '请输入流程卡号',
        typeglass: '玻璃类型',
        typeglassa: '玻璃类型：',
        intypeglass: '请输入玻璃类型',
        width: '宽',
        widtha: '宽：',
        inwidth: '请输入宽',
        height: '高',
        heighta: '高：',
        inheight: '请输入高',
        coatingtypes: '膜系',
        thickness: '厚度',
        thicknessa: '厚度：',
        inthickness: '请输入厚度',
        layoutID: '钢化版图ID',
        layoutIDa: '钢化版图ID：',
        inlayoutID: '请输入钢化版图ID',
        picturesequence: '钢化版图片序',
        picturesequencea: '钢化版图片序：',
        inpicturesequence: '请输入钢化版图片序',
        startstatus: '启用状态',
        startstatusa: '启用状态：',
        instartstatus: '请输入启用状态',
        choicestartstatus: '请选择启用状态',
        glassgaps: '玻璃间隙',
        glassgapsa: '玻璃间隙：',
        inglassgaps: '请输入玻璃间隙',
        sure: '确认',
        cancel: '取消',
        operate: '操作',
        breakage: '破损',
        delete: '删除',
        outfilm: '出片',
        cagetableID: '大理片笼表ID',
        cagenumber: '理片笼号',
        gridnumber: '栅格号',
        gridnumbera: '栅格号：',
        grid: '请输入栅格号',
        enable: '已启用',
        disable: '已禁用',
        remainingwidth: '剩余宽度',
        add: '添加',
        sheetID: '钢化小片信息表ID',
        processcards: '流程卡',
        processcardtype: '流程卡玻璃类型',
        acceptshorizontal: '钢化是否接受横放',
        xcoordinates: 'x坐标',
        ycoordinates: 'y坐标',
        rotationangle: '旋转角度（逆时针）',
        state: '状态',
        takeout: '拿走',
        deletemessage: '是否删除该条信息?',
        prompt: '提示',
        yes: '是',
        accept: '接受',
        noaccept: '不接受',
        filmcomplete: '出片完成',
        waiting: '等待中',
        broke: '是否破损该条信息？',
        brokeb: '是否拿走该条信息？',
        outfil: '是否出片该条信息？',
        inputid: '请输入玻璃ID',
        search: '搜索',
        tabid: '大理片笼详情表id',
        tid: '设备id',
        tida: '设备id：',
        fin: '是否完成任务？',
        sureadd: '确认添加',
        sureadda: '是否确认添加？',
        zailong: '在笼中',
        rengongxp: '人工下片',
        up: '上一页',
        down: '下一页',
        now: '当前页显示',
        tit: '条数据',
        temperingqueries: '钢化查询',
        specifytempering: '指定一炉',
        specifyout: '指定人工出片',
        specifyengineerid: '指定工程',
        projectnumber: '工程号',
        layoutnumber: '钢化版图号',
        numberglasses: '玻璃数量',
        specifytemperinga: '请确认设备是否已关闭MES联机？',
        temperedswitch: '钢化开关',
        dutyinformation: '值班信息',
        process: '工序',
        team: '班组',
        basic: '设备',
        makesure: '确认保存',
        temperingtotal: '钢化炉数：',
        glasstotal: '玻璃总数：',
        Labelprinting: '标签打印',
        Schedulingswitch: '调度开关',
    },
    workOrder: {
        upnumber: '上片位编号',
        glassID: '玻璃ID',
        height: '高',
        width: '宽',
        thickness: '厚度',
        coatingtypes: '膜系',
        coatingtypesbe: '原片膜系',
        productionsequence: '出片顺序',
        cardnumber: '流程卡号',
        operate: '操作',
        messagedamaged: '是否破损该条信息?',
        prompt: '提示',
        yes: '是',
        cancel: '取消',
        takemessage: '是否拿走该条信息？',
        breakage: '破损',
        takeout: '拿走',
        glasstype: '玻璃膜系',
        line: '线路',
        status: '状态',
        time: '时间段',
        cway: '请选择线路',
        cstate: '请选择状态',
        edgingone: '磨边一线',
        edgingtwo: '磨边二线',
        nedging: '未磨边',
        edging: '磨边中',
        finedging: '已磨边',
    },
    processCard: {
        thisIsTheIndoorSurface: '此面为室内面',
        thisSideIsOutsideTheRoom: '此面为室外面',
        intofurnace: '进炉中',
        beforefurnace: '进炉前',
        outfurnace: '已出炉玻璃',
        print: '拿走打印',
        printing: '打印',
        projectnumber: '请输入工程号',
        inquire: '查询',
        project: '工程号',
        awayprocess: '拿走工序',
        awayequipment: '拿走设备',
        awayteam: '拿走班组',
        flowcard: '流程卡',
        layer: '层号',
        temperinglayout: '炉号',
        temperingfeed: '片序',
        width: '宽',
        height: '高',
        thickness: '厚',
        glasstakeout: '玻璃拿走清单',
        layoutID: '版图ID',
        glassID: '玻璃ID',
        tempState1: '生成任务',        // -1 生成任务
        tempState2: '出片完成',        // 0 出片完成
        tempState3: '摆片完成',        // 1 摆片完成
        tempState4: '进炉完成',        // 2 进炉完成
        tempState5: '钢化完成',        // 3 钢化完成
        tempState6: '出片完成',        // 4 出片完成
        tempState7: '破损',            // 8 破损
        tempState8: '拿走',            // 9 拿走
    },
    reportWork: {
        details: '落架详情',
        filming: '人工下片',
        printing: '自动打印',
        cenumber: '层数',
        artificialorder: '人工下片数',
        processcard: '打印流程卡',
        printlabels: '打印标签',
        information: '落架信息',
        cstation: '请选择工位',
        all: '全部',
        timeperiod: '时间段',
        stationnumber: '工位号',
        order: '顺序',
        filminformation: '人工下片信息',
        glassmation: '人工下片当前玻璃信息',
        barcodescanner: '扫码枪当前玻璃信息',
        lowerbit: '下片位',
        shelfnumber: '架号',
        cardnumber: '流程卡号',
        totalquantity: '总数量',
        beendropped: '已落架数量',
        state: '状态',
        devicenumber: '设备号',
        startstatus: '启用状态',
        enable: '已启用',
        unenable: '未启用',
        operate: '操作',
        bindingshelves: '绑定架子',
        clear: '清空',
        workstation: '号工位',
        shelfnumbera: '架号：',
        cardnumbera: '流程卡号：',
        incardnumber: '请选择流程卡号',
        clearglass: '清除架子玻璃',
        sure: '确认',
        cancel: '取消',
        glassinformation: '玻璃信息',
        glassID: '玻璃ID',
        coatingtypes: '膜系',
        thickness: '厚度',
        width: '宽度',
        height: '高度',
    },
    productStock: {
        inconfirmpassword: '请输入确认密码',
        passwordNotMatch: '两次输入的密码不一致',
        confirmpassword: '确认密码',
        inputNewPassword: '请输入新密码',
        userIdError: '用户ID获取失败',
        addconfigName: '添加配置',
        editconfigName: '修改配置',
        configName: '配置名',
        configNamea: '配置名：',
        configCode: '配置代码',
        configValue: '配置值',
        inconfigValue: '请输入配置值',
        configValuea: '配置值：',
        addusers: '添加用户',
        username: '用户名',
        usernamea: '用户名：',
        inusername: '请输入用户名',
        role: '角色',
        rolea: '角色：',
        inrole: '请选择角色',
        test: '测试',
        admin: '管理员',
        operate: '操作',
        resetpassword: '重置密码',
        exit: '编辑',
        delete: '删除',
        prompt: '提示',
        repassword: '是否重置用户密码？',
        yes: '是',
        cancel: '取消',
        reusername: '修改用户',
        addusername: '添加用户',
        password: '密码：',
        sure: '确认',
        inpassword: '请输入密码',
        deusername: '是否删除该用户？',
    },
    customer: {
        addmenua: '添加二级菜单',
        addmenu: '添加一级菜单',
        firstmenu: '一级菜单栏',
        firstmenuname: '一级菜单名称:',
        link: '链接',
        inlink: '请输入链接',
        linka: '链接：',
        sort: '排序',
        insort: '请输入排序',
        sorta: '排序：',
        operate: '操作',
        exit: '编辑',
        delete: '删除',
        semenu: '二级菜单栏',
        semenuname: '二级菜单名称:',
        menu: '菜单栏：',
        inmenu: '请输入菜单名称',
        sure: '确认',
        cancel: '取消',
        exmene: '修改一级菜单',
        exmenea: '修改二级菜单',
        yes: '是',
        demenu: '是否删除该菜单？',
        prompt: '提示',
    },
    delivery: {
        alarmStartTime: '报警开始时间',
        alarmEndTime: '报警结束时间',
        equipment: '设备',
        content: '内容',
        confirmer: '确认人',
        addrole: '添加角色',
        editrole: '修改角色',
        role: '角色',
        rolea: '角色：',
        inrole: '请输入角色',
        operate: '操作',
        edit: '编辑',
        delete: '删除',
        yes: '是',
        sure: '确认',
        cancel: '取消',
        derole: '是否删除该角色',
        prompt: '提示',
        choice: '菜单权限：',
        inchoice: '请选择菜单权限',
    },
    replenish: {
        patchManagement: '补片管理',
    },
    rework: {
        reworkManagement: '返工管理',
        addRework: "返工新增 ",
    },
    role: {
        id: 'ID',
        characterHomepage: '角色首页',
    },
    user: {
        userId: '用户ID',
        userHomepage: '用户首页',
    },
    orderBasicData: {
        order: '订单',
        orderType: '订单类型',
    },
    machine: {
        basicId: '设备编号',
        basicName: '设备名称',
        basicCategory: '所在工序',
        tempering: '钢化',
    },
    report: {
        productionReport: '生产报表',
        workInProgressReport: '在制品报表',
    },
    productionBasicData: {
        basicDataQuery: '基础数据查询',
    },
    mainIngredient: {
        materialInformation: '物料资料',
    },
    mainIngredientStock: {
        materialName: '物料名称',
        createTime: '返库日期',
    },
    large: {
        patchCount: '已补数量',
        Productionsituation: '生产情况',
        Productionandoperationstatus: '生产运行情况',
        cuttingState: '切割当天运行情况',
        edgingState: '磨边当天运行情况',
        temperingState: '钢化当天运行情况',
        hollowState: '中空当天运行情况',
        switch: '切换',
        running: '运行中',
        stopping: '停止',
        diffMinutes: '分钟',
        loadstart: '切割开始时间',
        loadend: '切割结束时间',
        loadtotal: '切割总时间',
        loadfree: '切割空闲时间',
        loaddiff: '切割工作时间',
@@ -559,7 +567,7 @@
        temptotal: '钢化总时间',
        tempfree: '钢化空闲时间',
        tempdiff: '钢化工作时间',
        tempstove:  '钢化炉号',
        tempstove: '钢化炉号',
        tempnumber: '钢化总数量',
        temparea: '钢化总面积',
        hollowstart: '中空开始时间',
@@ -575,263 +583,263 @@
        tatalarea: '总面积',

        statistics: '生产统计',
        ExporttoExcel:'导出excel',
          slice:'片',
          load:'切割',
          edg:'磨边',
          temp:'钢化',
          hollow:'中空',
          oneFinish:'一线完成',
          twoFinish:'二线完成',
          oneunFinish:'一线未完成',
          twounFinish:'二线未完成',
          ondDamage:'一线破损',
          percent:'进度百分比',
          time: '次破时间',
          tionnumber: '订单号',
          jobnumber: '报工编号',
          productionnumber: '生产订单号',
          cardnumber: '流程卡号',
          projectname: '项目名称',
          batch: '批次',
          detailID: '明细ID',
          building: '楼号',
          serialnumber: '订单序号',
          productname: '产品名称',
          engineername: '工程名称',
          inproductname: '请输入产品名称',
          serial: '工艺确认序号',
          slicemarker: '层号',
          numberpatches: '补片数量',
          width: '宽',
          height: '高',
          shape: '形状',
          responsibleprocess: '责任工序',
          process: '本工序',
          numberfractions: '次破未补数量',
          breakreason: '次破原因',
          breaktype: '次破类型',
          responsiblepersonnel: '责任人员',
          responsiblequipment: '责任设备',
          responsibleteam: '责任班组',
          area: '次破面积',
          inspector: '质检员',
          operate: '操作',
          mes: '详情',
          projectnumber: '工程单号',
          brokeno: '报次破未补',
          close: '关闭',
          orderId: '订单ID',
          order: '订单详情',
          customerName: '客户名称',
          incustomerName: '请输入客户名称',
          project: '项目名称',
          are: '面积',
          quantity: '数量',
          warehousing: '状态',
          deliveryDate: '送货时间',
          notstocked: '未入库',
          inboundstatus: '部分入库状态',
          allstatus: '全部入库状态',
          completedquantity: '完成数量',
          scrapquantity: '报废数量',
          number: '数量',
          method: '加工方式',
          innumber: '已入数量',
          productstatus: '生产状态',
          right: '正常',
          stop: '终止',
          inquire: '查询',
          starttime :'开始时间',
          endtime :'结束时间',
          loading :'正在上片：',
          brokenNum:'破损数量',
          inventory:'库存',
          inventoryarea:'库存面积',
          shippedQuantity:'已发货数量',
          reportWorkQuantity:'完工数量',
          reportWorkQuantityCount:'破损数量',
          processId:'流程卡号',
          historicaltasks1:'原片仓储',
          historicaltasks2:'上片一线',
          historicaltasks3:'上片二线',
          historicaltasks4:'卧式一线',
          historicaltasks5:'卧式二线',
          historicaltasks6:'钢化大理片',
          historicaltasks7:'中空一线',
          historicaltasks8:'中空二线',
          historicaltasks9:'中空大理片',
          historicaltasks10:'生产统计',
          date:'日期',
          countOutOne: '切割一线',
          totalAreaOutOne: '切割一线面积',
          countOutTwo: '切割二线',
          totalAreaOutTwo: '切割二线面积',
          countIn: '钢化前大理片',
          totalAreaIn: '钢化前大理片面积',
          countOut: '钢化',
          totalAreaOut: '钢化面积',
          hollowCountOutOne: '中空一线',
          hollowTotalAreaOutOne: '中空一线面积',
          hollowCountOutTwo: '中空二线',
          hollowTotalAreaOutTwo: '中空二线面积',
      },
      reportmanage:{
          productiontime :'生产时间',
          starttime :'开始时间',
          endtime :'结束时间',
          ctype :'请选择类型',
          cstate :'请选择状态',
          cprocess :'请选择工序',
          all :'全部',
          completed :'完工',
          broke :'破损',
          takeout :'拿走',
          dreportwork :'未报工',
          pendingwork :'已现补',
          reportwork :'已报工',
          reportworked :'已同步',
          incise :'切割',
          edging :'磨边',
          steel :'钢化',
          inquire :'查询',
          signingwork :'报工',
          reporteam :'报工班组',
          reportingequipment :'报工设备',
          line :'线路',
          process :'工序',
          glassID :'玻璃ID',
          projectnumber :'工程号',
          layoutID :'钢化版图ID',
          type :'类型',
          state :'状态',
          processcards :'流程卡',
          number :'序号',
          layer :'层',
          typebreakage :'破损类型',
          ptypebreakage :' 请选择破损类型',
          causebreakage :'破损原因',
          pcausebreakage :'请选择破损原因',
          responsibleprocess :'责任工序',
          responsiblepersonnel :'责任人员',
          presponsiblepersonnel :'请输入责任人员',
          responsibleteam :'责任班组',
          presponsibleteam :'请选择责任班组',
          responsibleequipment :'责任设备',
          presponsibleequipment :'请选择责任设备',
          remark :'备注',
          premark :'请输入备注',
      },
      film:{
          resetnumber:'架子号',
          fail:'失败',
          mes:'原片仓储详情',
          warehousing:'原片入库',
          pwarehousing:'入库请求',
          wareout:'原片出库',
          information:'是否出库该条信息？',
          pwareout:'出库请求',
          position:'吊装位：',
          cposition:'请选择吊装位',
          position1:'吊装位1',
          position2:'吊装位2',
          addglass:'原片信息',
          operate: '操作',
          exit:'编辑',
          delete:'删除',
          outbound:'出库',
          deviceid:'设备ID',
          enablestatea:'启用标记',
          disable:'禁用',
          start:'启用',
          startslot:'开始工位',
          endslot:'目标工位',
          slotid:'格子ID',
          slot:'格子号',
          width:'原片宽',
          widtha:'原片宽：',
          inwidth:'请输入原片宽',
          height:'原片高',
          inheight:'请输入原片高',
          heighta:'原片高：',
          thickness:'原片厚度',
          inthickness:'请输入原片厚度',
          thicknessa:'原片厚度：',
          films:'膜系',
          infilms:'请输入膜系',
          filmsa:'膜系：',
          createtime:'创建时间',
          remainquantity:'剩余数量',
          thickremainquantity:'原片剩余数量（张）：',
          thickremainquant:'原片剩余数量（张）',
          inquantity:'请输入数量',
          quantitya:'数量：',
          enableid:'任务ID',
          originateslot:'起始格子',
          endoriginateslot:'目标格子',
          patternquantity:'原片数量',
          enabletype:'任务类型',
          enablestate:'工位状态',
          finish:'已完成',
          unfinish:'未完成',
          dedelete:'是否删除该条内容？',
          dedisable:'是否禁用该条内容？',
          deoutbound:'是否出库该条内容？',
          selectwarehousing:'请选择吊装位',
          inwarehousing:'吊装位：',
          warehousing1:'吊装位1',
          warehousing2:'吊装位2',
          starttime :'开始时间',
          endtime :'结束时间',
          taskstatus :'任务状态',
          built :'新建',
          execution :'执行中',
          tasktype :'任务类型',
          stocke :'入库',
          dispatch :'调度',
          inquire :'查询',
          station :'工位',
      },
      Mounting:{
          previewproject: '选择预览工程',
          loadinglinea: '上片线',
          loadingline: '上片线：',
          inloadingline: '请选择上片线',
          oneloadingline: '一号上片线',
          twoloadingline: '二号上片线',
          waiting: '等待中',
          pass: '通过',
          setparameters: '设置参数',
          project: '工程号',
          projecta: '工程号：',
          width: '原片宽',
          height: '原片高',
          thickness: '原片厚',
          projectnumber: '工程原片序号',
          state: '状态',
          createtime: '创建时间',
          all: '全选',
          removalmethod: '请选择除膜方式',
          removalmethodp: '除膜方式',
          removalmethoda: '除膜方式：',
          noremoval: '不除膜',
          removal: '除膜',
          coarselyground: '粗磨',
          finegrinding: '精磨',
      },
        ExporttoExcel: '导出excel',
        slice: '片',
        load: '切割',
        edg: '磨边',
        temp: '钢化',
        hollow: '中空',
        oneFinish: '一线完成',
        twoFinish: '二线完成',
        oneunFinish: '一线未完成',
        twounFinish: '二线未完成',
        ondDamage: '一线破损',
        percent: '进度百分比',
        time: '次破时间',
        tionnumber: '订单号',
        jobnumber: '报工编号',
        productionnumber: '生产订单号',
        cardnumber: '流程卡号',
        projectname: '项目名称',
        batch: '批次',
        detailID: '明细ID',
        building: '楼号',
        serialnumber: '订单序号',
        productname: '产品名称',
        engineername: '工程名称',
        inproductname: '请输入产品名称',
        serial: '工艺确认序号',
        slicemarker: '层号',
        numberpatches: '补片数量',
        width: '宽',
        height: '高',
        shape: '形状',
        responsibleprocess: '责任工序',
        process: '本工序',
        numberfractions: '次破未补数量',
        breakreason: '次破原因',
        breaktype: '次破类型',
        responsiblepersonnel: '责任人员',
        responsiblequipment: '责任设备',
        responsibleteam: '责任班组',
        area: '次破面积',
        inspector: '质检员',
        operate: '操作',
        mes: '详情',
        projectnumber: '工程单号',
        brokeno: '报次破未补',
        close: '关闭',
        orderId: '订单ID',
        order: '订单详情',
        customerName: '客户名称',
        incustomerName: '请输入客户名称',
        project: '项目名称',
        are: '面积',
        quantity: '数量',
        warehousing: '状态',
        deliveryDate: '送货时间',
        notstocked: '未入库',
        inboundstatus: '部分入库状态',
        allstatus: '全部入库状态',
        completedquantity: '完成数量',
        scrapquantity: '报废数量',
        number: '数量',
        method: '加工方式',
        innumber: '已入数量',
        productstatus: '生产状态',
        right: '正常',
        stop: '终止',
        inquire: '查询',
        starttime: '开始时间',
        endtime: '结束时间',
        loading: '正在上片：',
        brokenNum: '破损数量',
        inventory: '库存',
        inventoryarea: '库存面积',
        shippedQuantity: '已发货数量',
        reportWorkQuantity: '完工数量',
        reportWorkQuantityCount: '破损数量',
        processId: '流程卡号',
        historicaltasks1: '原片仓储',
        historicaltasks2: '上片一线',
        historicaltasks3: '上片二线',
        historicaltasks4: '卧式一线',
        historicaltasks5: '卧式二线',
        historicaltasks6: '钢化大理片',
        historicaltasks7: '中空一线',
        historicaltasks8: '中空二线',
        historicaltasks9: '中空大理片',
        historicaltasks10: '生产统计',
        date: '日期',
        countOutOne: '切割一线',
        totalAreaOutOne: '切割一线面积',
        countOutTwo: '切割二线',
        totalAreaOutTwo: '切割二线面积',
        countIn: '钢化前大理片',
        totalAreaIn: '钢化前大理片面积',
        countOut: '钢化',
        totalAreaOut: '钢化面积',
        hollowCountOutOne: '中空一线',
        hollowTotalAreaOutOne: '中空一线面积',
        hollowCountOutTwo: '中空二线',
        hollowTotalAreaOutTwo: '中空二线面积',
    },
    reportmanage: {
        productiontime: '生产时间',
        starttime: '开始时间',
        endtime: '结束时间',
        ctype: '请选择类型',
        cstate: '请选择状态',
        cprocess: '请选择工序',
        all: '全部',
        completed: '完工',
        broke: '破损',
        takeout: '拿走',
        dreportwork: '未报工',
        pendingwork: '已现补',
        reportwork: '已报工',
        reportworked: '已同步',
        incise: '切割',
        edging: '磨边',
        steel: '钢化',
        inquire: '查询',
        signingwork: '报工',
        reporteam: '报工班组',
        reportingequipment: '报工设备',
        line: '线路',
        process: '工序',
        glassID: '玻璃ID',
        projectnumber: '工程号',
        layoutID: '钢化版图ID',
        type: '类型',
        state: '状态',
        processcards: '流程卡',
        number: '序号',
        layer: '层',
        typebreakage: '破损类型',
        ptypebreakage: ' 请选择破损类型',
        causebreakage: '破损原因',
        pcausebreakage: '请选择破损原因',
        responsibleprocess: '责任工序',
        responsiblepersonnel: '责任人员',
        presponsiblepersonnel: '请输入责任人员',
        responsibleteam: '责任班组',
        presponsibleteam: '请选择责任班组',
        responsibleequipment: '责任设备',
        presponsibleequipment: '请选择责任设备',
        remark: '备注',
        premark: '请输入备注',
    },
    film: {
        resetnumber: '架子号',
        fail: '失败',
        mes: '原片仓储详情',
        warehousing: '原片入库',
        pwarehousing: '入库请求',
        wareout: '原片出库',
        information: '是否出库该条信息？',
        pwareout: '出库请求',
        position: '吊装位：',
        cposition: '请选择吊装位',
        position1: '吊装位1',
        position2: '吊装位2',
        addglass: '原片信息',
        operate: '操作',
        exit: '编辑',
        delete: '删除',
        outbound: '出库',
        deviceid: '设备ID',
        enablestatea: '启用标记',
        disable: '禁用',
        start: '启用',
        startslot: '开始工位',
        endslot: '目标工位',
        slotid: '格子ID',
        slot: '格子号',
        width: '原片宽',
        widtha: '原片宽：',
        inwidth: '请输入原片宽',
        height: '原片高',
        inheight: '请输入原片高',
        heighta: '原片高：',
        thickness: '原片厚度',
        inthickness: '请输入原片厚度',
        thicknessa: '原片厚度：',
        films: '膜系',
        infilms: '请输入膜系',
        filmsa: '膜系：',
        createtime: '创建时间',
        remainquantity: '剩余数量',
        thickremainquantity: '原片剩余数量（张）：',
        thickremainquant: '原片剩余数量（张）',
        inquantity: '请输入数量',
        quantitya: '数量：',
        enableid: '任务ID',
        originateslot: '起始格子',
        endoriginateslot: '目标格子',
        patternquantity: '原片数量',
        enabletype: '任务类型',
        enablestate: '工位状态',
        finish: '已完成',
        unfinish: '未完成',
        dedelete: '是否删除该条内容？',
        dedisable: '是否禁用该条内容？',
        deoutbound: '是否出库该条内容？',
        selectwarehousing: '请选择吊装位',
        inwarehousing: '吊装位：',
        warehousing1: '吊装位1',
        warehousing2: '吊装位2',
        starttime: '开始时间',
        endtime: '结束时间',
        taskstatus: '任务状态',
        built: '新建',
        execution: '执行中',
        tasktype: '任务类型',
        stocke: '入库',
        dispatch: '调度',
        inquire: '查询',
        station: '工位',
    },
    Mounting: {
        previewproject: '选择预览工程',
        loadinglinea: '上片线',
        loadingline: '上片线：',
        inloadingline: '请选择上片线',
        oneloadingline: '一号上片线',
        twoloadingline: '二号上片线',
        waiting: '等待中',
        pass: '通过',
        setparameters: '设置参数',
        project: '工程号',
        projecta: '工程号：',
        width: '原片宽',
        height: '原片高',
        thickness: '原片厚',
        projectnumber: '工程原片序号',
        state: '状态',
        createtime: '创建时间',
        all: '全选',
        removalmethod: '请选择除膜方式',
        removalmethodp: '除膜方式',
        removalmethoda: '除膜方式：',
        noremoval: '不除膜',
        removal: '除膜',
        coarselyground: '粗磨',
        finegrinding: '精磨',
    },
    hellow: {
        pleaseConfirm: '请在问题处理完后，双击确认此故障，保证系统正常运行！',
        taskAlreadyClaimed: '该任务已领取，不可重复操作',
        claimed: '已领取',
        claimFailed: '领取任务失败',
        claimedTasksCleared: '已领取任务状态已清除',
        content:'内容',
        idSame:'进片任务玻璃ID相同',
        sizeSame:'笼内存在相同规格的玻璃',
        slotLess:'剩余格子不足',
        overSize:'直通片台存在玻璃，结束本次进片',
        noGlass:'未找到玻璃信息，请领取工程',
        projectMsg2:'请选择标签模板',
        content: '内容',
        idSame: '进片任务玻璃ID相同',
        sizeSame: '笼内存在相同规格的玻璃',
        slotLess: '剩余格子不足',
        overSize: '直通片台存在玻璃，结束本次进片',
        noGlass: '未找到玻璃信息，请领取工程',
        projectMsg2: '请选择标签模板',
        clickmakesure: '是否确认点击？',
        logarithm: '对数：',
        totalPairQuantitya: '任务总配对数',
@@ -848,7 +856,7 @@
        pairQuantity: '已完成配对数量',
        isForceList: '是否强制',
        yesisForceList: '强制',
        noisForceList: '非强制', 
        noisForceList: '非强制',
        hollowCountOutOne: '中空一线玻璃数量',
        hollowCountOutTwo: '中空二线玻璃数量',
        hollowTotalAreaOutOne: '中空一线玻璃面积',
@@ -897,11 +905,11 @@
        intervalFrameHeightaOne: '请输入间隔框高度1',
        intervalFrameHeightaTwo: '请输入间隔框高度2',
        intervalFrameHeightaThree: '请输入间隔框高度3',
        intervalFrameHeightaFour:  '请输入间隔框高度4',
        intervalFrameHeightaFour: '请输入间隔框高度4',
        intervalFrameHeightbOne: '间隔框高度1：',
        intervalFrameHeightbTwo: '间隔框高度2：',
        intervalFrameHeightbThree: '间隔框高度3：',
        intervalFrameHeightbFour:  '间隔框高度4：',
        intervalFrameHeightbFour: '间隔框高度4：',
        intervalFrameTypeOne: '间隔框类型1',
        intervalFrameTypeTwo: '间隔框类型2',
        intervalFrameTypeThree: '间隔框类型3',
@@ -919,15 +927,15 @@
        intervalFrameWidthOne: '间隔框宽度1',
        intervalFrameWidthTwo: '间隔框宽度2',
        intervalFrameWidthThree: '间隔框宽度3',
        intervalFrameWidthFour:  '间隔框宽度4',
        intervalFrameWidthFour: '间隔框宽度4',
        intervalFrameWidthaOne: '请输入间隔框宽度1',
        intervalFrameWidthaTwo: '请输入间隔框宽度2',
        intervalFrameWidthaThree: '请输入间隔框宽度3',
        intervalFrameWidthaFour:  '请输入间隔框宽度4',
        intervalFrameWidthaFour: '请输入间隔框宽度4',
        intervalFrameWidthbOne: '间隔框宽度1：',
        intervalFrameWidthbTwo: '间隔框宽度2：',
        intervalFrameWidthbThree: '间隔框宽度3：',
        intervalFrameWidthbFour:  '间隔框宽度4：',
        intervalFrameWidthbFour: '间隔框宽度4：',
        sealInsert: '密封嵌入',
        sealInsertb: '密封嵌入：',
        sealInserta: '请输入密封嵌入',
@@ -1000,20 +1008,20 @@
        cpairQuantity: '请输入总配对数量',
        schedulingswitch: '调度开关',
    },
    screendisplay:{
    screendisplay: {
        pchoice: '请选择',
        pwidth: '请输入宽度',
        pheight: '请输入高度',
        upnumber: '上片数量',
    },
    scheduling:{
    scheduling: {
        cuttingCount: '切割',
        edgingCount: '磨边',
        temperingCount: '钢化',
        insulatingCount: '中空',
        completed:"已排产",
        completed: "已排产",
        completedCount: '完成数量',
        unfinished:'待排产',
        unfinished: '待排产',
        serial: '序号',
        projectNo: '工程ID',
        thickness: '厚度(mm)',

 UI-Project/src/views/PurchaseReturn/purchaseReturn.vue

@@ -1,12 +1,12 @@
<script setup lang="ts">
import {nextTick, onBeforeUnmount, onMounted, ref} from "vue";
import { nextTick, onBeforeUnmount, onMounted, ref } from "vue";
import request from "@/utils/request"
import {host, WebSocketHost} from '@/utils/constants'
import {ElMessage} from 'element-plus'
import {closeWebSocket, initializeWebSocket} from '@/utils/WebSocketService';
import {useI18n} from 'vue-i18n'
import {useRouter} from 'vue-router'
const {t} = useI18n()
import { host, WebSocketHost } from '@/utils/constants'
import { ElMessage } from 'element-plus'
import { closeWebSocket, initializeWebSocket } from '@/utils/WebSocketService';
import { useI18n } from 'vue-i18n'
import { useRouter } from 'vue-router'
const { t } = useI18n()
let language = ref(localStorage.getItem('lang') || 'zh')
const dialogFormVisible = ref(false)
const dialogFormVisiblea = ref(true)
@@ -37,74 +37,74 @@
const router = useRouter()
const currentGlassId = ref(null);
const currenttemperingFeedSequence = ref(null);
onMounted(async () => {  
  try {  
onMounted(async () => {
  try {
    const response = await request.post('/loadGlass/damage/selectDamagePrint', {
    type: 9,
    workingProcedure: '钢化',
      type: 9,
      workingProcedure: '钢化',
    })
    if (response.code === 200) {  
          tableData.value = response.data
    } else {  
    if (response.code === 200) {
      tableData.value = response.data
    } else {
      ElMessage.warning(response.message)
    }  
  } catch (error) {  
  }  
}); 
    }
  } catch (error) {
  }
});
// 方法定义
function handlePageChange(page: number) {
  currentPage.value = page;
}
const socketUrl = `ws://${window.ipConfig.serverUrl}/api/temperingGlass/api/talk/temperingGlass`;
const handleMessage = (data) => {  
const handleMessage = (data) => {
  // 进炉中右
  if (data.intoGlass2 && data.intoGlass2.length > 0) {  
    const newGlassIds = new Set(data.intoGlass2[0].map(rect => rect.glassId));  
    const existingRects = adjustedRects2.value.filter(rect => newGlassIds.has(rect.glassId));  
    const newRects = data.intoGlass2[0].map(rect => {  
      const scaleFactor =  1621.78/6000; 
      const scaleFactorY =  700/2800; 
      let adjustedWidth, adjustedHeight, adjustedWidtha, adjustedHeighta,widtha,heighta;; 
  let newX = rect.yCoordinate; 
  if (data.intoGlass2 && data.intoGlass2.length > 0) {
    const newGlassIds = new Set(data.intoGlass2[0].map(rect => rect.glassId));
    const existingRects = adjustedRects2.value.filter(rect => newGlassIds.has(rect.glassId));
    const newRects = data.intoGlass2[0].map(rect => {
      const scaleFactor = 1621.78 / 6000;
      const scaleFactorY = 700 / 2800;
      let adjustedWidth, adjustedHeight, adjustedWidtha, adjustedHeighta, widtha, heighta;;
      let newX = rect.yCoordinate;
      if (rect.width < rect.height) {
        widtha = rect.height;
        heighta = rect.width;
      }else {
      } else {
        widtha = rect.width;
        heighta = rect.height;
      }
  if (rect.angle === 0) {  
    adjustedWidth = widtha * scaleFactor;  
    adjustedHeight = heighta * scaleFactorY;
    // adjustedWidtha = widtha;  
    // adjustedHeighta = heighta;  
    newX = 6000 - (rect.yCoordinate + widtha); 
    } else {  
    adjustedWidth = heighta * scaleFactor;  
    adjustedHeight = widtha * scaleFactorY;  
    // adjustedWidtha = widtha;  
    // adjustedHeighta = heighta;  
    newX = 6000 - (rect.yCoordinate + heighta);  
  }  
  return {  
    ...rect, 
    x: newX * scaleFactor,  
    y: rect.xCoordinate * scaleFactorY,  
    width: adjustedWidth,  
    height: adjustedHeight,  
    widtha: rect.width, 
    heighta: rect.height,
  }
    }); 
      if (rect.angle === 0) {
        adjustedWidth = widtha * scaleFactor;
        adjustedHeight = heighta * scaleFactorY;
        // adjustedWidtha = widtha;  
        // adjustedHeighta = heighta;  
        newX = 6000 - (rect.yCoordinate + widtha);
      } else {
        adjustedWidth = heighta * scaleFactor;
        adjustedHeight = widtha * scaleFactorY;
        // adjustedWidtha = widtha;  
        // adjustedHeighta = heighta;  
        newX = 6000 - (rect.yCoordinate + heighta);
      }
      return {
        ...rect,
        x: newX * scaleFactor,
        y: rect.xCoordinate * scaleFactorY,
        width: adjustedWidth,
        height: adjustedHeight,
        widtha: rect.width,
        heighta: rect.height,
      }
    });
    // 合并新旧矩形，并保留 isActive 状态  
    adjustedRects2.value = existingRects.map(oldRect => {  
      const newRect = newRects.find(r => r.glassId === oldRect.glassId);  
      if (newRect) {  
        return { ...oldRect, ...newRect, isActive: oldRect.isActive };  
      }  
    adjustedRects2.value = existingRects.map(oldRect => {
      const newRect = newRects.find(r => r.glassId === oldRect.glassId);
      if (newRect) {
        return { ...oldRect, ...newRect, isActive: oldRect.isActive };
      }
      return oldRect; // 如果旧矩形在新数据中不存在，但保留在newGlassIds中，则保留原样  
    }).concat(newRects.filter(r => !existingRects.some(o => o.glassId === r.glassId)));  
  }  
    }).concat(newRects.filter(r => !existingRects.some(o => o.glassId === r.glassId)));
  }
  // if (data.intoGlass2 && data.intoGlass2.length > 0) {  
  //   // 提取新的矩形ID  
  //   const newGlassIds = new Set(data.intoGlass2[0].map(rect => rect.glassId));  
@@ -159,56 +159,56 @@
    adjustedRects2.value = []
  }
  // 进炉中左
  if (data.intoGlass && data.intoGlass.length > 0) {  
    const newGlassIds = new Set(data.intoGlass[0].map(rect => rect.glassId));  
    const existingRects = adjustedRects1.value.filter(rect => newGlassIds.has(rect.glassId));  
    const newRects = data.intoGlass[0].map(rect => {  
      const scaleFactor =  1621.78/6000; 
      const scaleFactorY =  700/2800; 
      let adjustedWidth, adjustedHeight, adjustedWidtha, adjustedHeighta,widtha,heighta;; 
  let newX = rect.yCoordinate; 
  if (data.intoGlass && data.intoGlass.length > 0) {
    const newGlassIds = new Set(data.intoGlass[0].map(rect => rect.glassId));
    const existingRects = adjustedRects1.value.filter(rect => newGlassIds.has(rect.glassId));
    const newRects = data.intoGlass[0].map(rect => {
      const scaleFactor = 1621.78 / 6000;
      const scaleFactorY = 700 / 2800;
      let adjustedWidth, adjustedHeight, adjustedWidtha, adjustedHeighta, widtha, heighta;;
      let newX = rect.yCoordinate;
      if (rect.width < rect.height) {
        widtha = rect.height;
        heighta = rect.width;
      }else {
      } else {
        widtha = rect.width;
        heighta = rect.height;
      }
  if (rect.angle === 0) {  
    adjustedWidth = widtha * scaleFactor;  
    adjustedHeight = heighta * scaleFactorY;
    // adjustedWidtha = widtha;  
    // adjustedHeighta = heighta;  
    newX = 6000 - (rect.yCoordinate + widtha); 
    } else {  
    adjustedWidth = heighta * scaleFactor;  
    adjustedHeight = widtha * scaleFactorY;  
    // adjustedWidtha = widtha;  
    // adjustedHeighta = heighta;  
    newX = 6000 - (rect.yCoordinate + heighta);  
  }  
  return {  
    ...rect, 
    x: newX * scaleFactor,  
    y: rect.xCoordinate * scaleFactorY,  
    width: adjustedWidth,  
    height: adjustedHeight,  
    widtha: rect.width, 
    heighta: rect.height,
  }
    }); 
      if (rect.angle === 0) {
        adjustedWidth = widtha * scaleFactor;
        adjustedHeight = heighta * scaleFactorY;
        // adjustedWidtha = widtha;  
        // adjustedHeighta = heighta;  
        newX = 6000 - (rect.yCoordinate + widtha);
      } else {
        adjustedWidth = heighta * scaleFactor;
        adjustedHeight = widtha * scaleFactorY;
        // adjustedWidtha = widtha;  
        // adjustedHeighta = heighta;  
        newX = 6000 - (rect.yCoordinate + heighta);
      }
      return {
        ...rect,
        x: newX * scaleFactor,
        y: rect.xCoordinate * scaleFactorY,
        width: adjustedWidth,
        height: adjustedHeight,
        widtha: rect.width,
        heighta: rect.height,
      }
    });
    // 合并新旧矩形，并保留 isActive 状态  
    adjustedRects1.value = existingRects.map(oldRect => {  
      const newRect = newRects.find(r => r.glassId === oldRect.glassId);  
      if (newRect) {  
        return { ...oldRect, ...newRect, isActive: oldRect.isActive };  
      }  
    adjustedRects1.value = existingRects.map(oldRect => {
      const newRect = newRects.find(r => r.glassId === oldRect.glassId);
      if (newRect) {
        return { ...oldRect, ...newRect, isActive: oldRect.isActive };
      }
      return oldRect; // 如果旧矩形在新数据中不存在，但保留在newGlassIds中，则保留原样  
    }).concat(newRects.filter(r => !existingRects.some(o => o.glassId === r.glassId)));  
  }  
    }).concat(newRects.filter(r => !existingRects.some(o => o.glassId === r.glassId)));
  }
  // if (data.intoGlass && data.intoGlass.length > 0) {
  //   console.log(data.intoGlass);
    

  //   const newGlassIds = new Set(data.intoGlass[0].map(rect => rect.glassId));
  //   const existingRects = adjustedRects1.value.filter(rect => newGlassIds.has(rect.glassId));
  //   const newRects = data.intoGlass[0].map(rect => {
@@ -259,103 +259,103 @@
    adjustedRects1.value = []
  }
  // 进炉前
  if (data.waitingGlass && data.waitingGlass.length > 0) {  
    const newGlassIds = new Set(data.waitingGlass[0].map(rect => rect.glassId));  
    const existingRects = adjustedRectsa.value.filter(rect => newGlassIds.has(rect.glassId));  
    const newRects = data.waitingGlass[0].map(rect => {  
      const scaleFactor =  1621.78/6000; 
      const scaleFactorY =  700/2800; 
      let adjustedWidth, adjustedHeight, adjustedWidtha, adjustedHeighta,widtha,heighta;; 
  let newX = rect.yCoordinate; 
  if (data.waitingGlass && data.waitingGlass.length > 0) {
    const newGlassIds = new Set(data.waitingGlass[0].map(rect => rect.glassId));
    const existingRects = adjustedRectsa.value.filter(rect => newGlassIds.has(rect.glassId));
    const newRects = data.waitingGlass[0].map(rect => {
      const scaleFactor = 1621.78 / 6000;
      const scaleFactorY = 700 / 2800;
      let adjustedWidth, adjustedHeight, adjustedWidtha, adjustedHeighta, widtha, heighta;;
      let newX = rect.yCoordinate;
      if (rect.width < rect.height) {
        widtha = rect.height;
        heighta = rect.width;
      }else {
      } else {
        widtha = rect.width;
        heighta = rect.height;
      }
  if (rect.angle === 0) {  
    adjustedWidth = widtha * scaleFactor;  
    adjustedHeight = heighta * scaleFactorY;
    // adjustedWidtha = widtha;  
    // adjustedHeighta = heighta;  
    newX = 6000 - (rect.yCoordinate + widtha); 
    } else {  
    adjustedWidth = heighta * scaleFactor;  
    adjustedHeight = widtha * scaleFactorY;  
    // adjustedWidtha = widtha;  
    // adjustedHeighta = heighta;  
    newX = 6000 - (rect.yCoordinate + heighta);  
  }  
  return {  
    ...rect, 
    x: newX * scaleFactor,  
    y: rect.xCoordinate * scaleFactorY,  
    width: adjustedWidth,  
    height: adjustedHeight,  
    widtha: rect.width, 
    heighta: rect.height,
  }
    }); 
      if (rect.angle === 0) {
        adjustedWidth = widtha * scaleFactor;
        adjustedHeight = heighta * scaleFactorY;
        // adjustedWidtha = widtha;  
        // adjustedHeighta = heighta;  
        newX = 6000 - (rect.yCoordinate + widtha);
      } else {
        adjustedWidth = heighta * scaleFactor;
        adjustedHeight = widtha * scaleFactorY;
        // adjustedWidtha = widtha;  
        // adjustedHeighta = heighta;  
        newX = 6000 - (rect.yCoordinate + heighta);
      }
      return {
        ...rect,
        x: newX * scaleFactor,
        y: rect.xCoordinate * scaleFactorY,
        width: adjustedWidth,
        height: adjustedHeight,
        widtha: rect.width,
        heighta: rect.height,
      }
    });
    // 合并新旧矩形，并保留 isActive 状态  
    adjustedRectsa.value = existingRects.map(oldRect => {  
      const newRect = newRects.find(r => r.glassId === oldRect.glassId);  
      if (newRect) {  
        return { ...oldRect, ...newRect, isActive: oldRect.isActive };  
      }  
    adjustedRectsa.value = existingRects.map(oldRect => {
      const newRect = newRects.find(r => r.glassId === oldRect.glassId);
      if (newRect) {
        return { ...oldRect, ...newRect, isActive: oldRect.isActive };
      }
      return oldRect; // 如果旧矩形在新数据中不存在，但保留在newGlassIds中，则保留原样  
    }).concat(newRects.filter(r => !existingRects.some(o => o.glassId === r.glassId)));  
  }  
    }).concat(newRects.filter(r => !existingRects.some(o => o.glassId === r.glassId)));
  }
  else if (data.waitingGlass == null) {
    adjustedRectsa.value = []
  }
  // 已出炉
  if (data.outGlass && data.outGlass.length > 0) {  
    const newGlassIds = new Set(data.outGlass[0].map(rect => rect.glassId));  
    const existingRects = adjustedRectsb.value.filter(rect => newGlassIds.has(rect.glassId));  
    const newRects = data.outGlass[0].map(rect => {  
      const scaleFactor =  1621.78/6000; 
      const scaleFactorY =  700/2800; 
      let adjustedWidth, adjustedHeight, adjustedWidtha, adjustedHeighta,widtha,heighta;; 
  let newX = rect.yCoordinate; 
  if (data.outGlass && data.outGlass.length > 0) {
    const newGlassIds = new Set(data.outGlass[0].map(rect => rect.glassId));
    const existingRects = adjustedRectsb.value.filter(rect => newGlassIds.has(rect.glassId));
    const newRects = data.outGlass[0].map(rect => {
      const scaleFactor = 1621.78 / 6000;
      const scaleFactorY = 700 / 2800;
      let adjustedWidth, adjustedHeight, adjustedWidtha, adjustedHeighta, widtha, heighta;;
      let newX = rect.yCoordinate;
      if (rect.width < rect.height) {
        widtha = rect.height;
        heighta = rect.width;
      }else {
      } else {
        widtha = rect.width;
        heighta = rect.height;
      }
  if (rect.angle === 0) {  
    adjustedWidth = widtha * scaleFactor;  
    adjustedHeight = heighta * scaleFactorY;
    // adjustedWidtha = widtha;  
    // adjustedHeighta = heighta;  
    newX = 6000 - (rect.yCoordinate + widtha); 
    } else {  
    adjustedWidth = heighta * scaleFactor;  
    adjustedHeight = widtha * scaleFactorY;  
    // adjustedWidtha = widtha;  
    // adjustedHeighta = heighta;  
    newX = 6000 - (rect.yCoordinate + heighta);  
  }  
  return {  
    ...rect, 
    x: newX * scaleFactor,  
    y: rect.xCoordinate * scaleFactorY,  
    width: adjustedWidth,  
    height: adjustedHeight,  
    widtha: rect.width, 
    heighta: rect.height,
  }
    }); 
      if (rect.angle === 0) {
        adjustedWidth = widtha * scaleFactor;
        adjustedHeight = heighta * scaleFactorY;
        // adjustedWidtha = widtha;  
        // adjustedHeighta = heighta;  
        newX = 6000 - (rect.yCoordinate + widtha);
      } else {
        adjustedWidth = heighta * scaleFactor;
        adjustedHeight = widtha * scaleFactorY;
        // adjustedWidtha = widtha;  
        // adjustedHeighta = heighta;  
        newX = 6000 - (rect.yCoordinate + heighta);
      }
      return {
        ...rect,
        x: newX * scaleFactor,
        y: rect.xCoordinate * scaleFactorY,
        width: adjustedWidth,
        height: adjustedHeight,
        widtha: rect.width,
        heighta: rect.height,
      }
    });
    // 合并新旧矩形，并保留 isActive 状态  
    adjustedRectsb.value = existingRects.map(oldRect => {  
      const newRect = newRects.find(r => r.glassId === oldRect.glassId);  
      if (newRect) {  
        return { ...oldRect, ...newRect, isActive: oldRect.isActive };  
      }  
    adjustedRectsb.value = existingRects.map(oldRect => {
      const newRect = newRects.find(r => r.glassId === oldRect.glassId);
      if (newRect) {
        return { ...oldRect, ...newRect, isActive: oldRect.isActive };
      }
      return oldRect;
    }).concat(newRects.filter(r => !existingRects.some(o => o.glassId === r.glassId)));  
    }).concat(newRects.filter(r => !existingRects.some(o => o.glassId === r.glassId)));
  }
  // if (data.outGlass && data.outGlass.length > 0) {  
  //   // 提取新的矩形ID  
@@ -400,7 +400,7 @@
  //       heighta: rect.height,
  // }
  //   });   
  

  //   // 合并新旧矩形，并保留 isActive 状态  
  //   adjustedRectsb.value = existingRects.map(oldRect => {  
  //     const newRect = newRects.find(r => r.glassId === oldRect.glassId);  
@@ -413,94 +413,82 @@
  else if (data.outGlass == null) {
    adjustedRectsb.value = []
  }
}; 
};
onMounted(() => {
  initializeWebSocket(socketUrl, handleMessage);
});
function updateRectColorsa() {
  adjustedRectsa.value.forEach(rect => {  
    if (rect.glassId === glassId) {  
      rect.state = 8;
    }
  });  
}  
function updateoutColorsa() {
  adjustedRectsa.value.forEach(rect => {  
    if (rect.glassId === glassId) {  
      rect.state = 9;
    }
  });  
} 
function updateoutColorsc() {
  adjustedRects1.value.forEach(rect => {  
    if (rect.glassId === glassId) {  
      rect.state = 9;
    }
  });  
}
function updateoutColorsd() {
  adjustedRects2.value.forEach(rect => {  
    if (rect.glassId === glassId) {  
      rect.state = 9;
    }
  });  
} 
function updateonColorsa() {
  adjustedRectsa.value.forEach(rect => {  
    if (rect.glassId === glassId) {  
      rect.state = 1;
    }
  });  
}  
function updateRectColorsb() {
  adjustedRectsb.value.forEach(rect => {  
    if (rect.glassId === glassId) {  
      rect.state = 8;
    }
  });  
}  
function updateoutColorsb() {
  adjustedRectsb.value.forEach(rect => {  
    if (rect.glassId === glassId) {  
      rect.state = 9;
    }
  });  
} 
function updateonColorsb() {
  adjustedRectsb.value.forEach(rect => {  
    if (rect.glassId === glassId) {  
      rect.state = 3;
    }
  });  
} 
function updateRectColors1() {  
  adjustedRects1.value.forEach(rect => {  
    if (rect.glassId === glassId) {  
  adjustedRectsa.value.forEach(rect => {
    if (rect.glassId === glassId) {
      rect.state = 8;
    }
  });
}  
function updateRectColors2() {  
  adjustedRects2.value.forEach(rect => {  
    if (rect.glassId === glassId) {  
}
function updateoutColorsa() {
  adjustedRectsa.value.forEach(rect => {
    if (rect.glassId === glassId) {
      rect.state = 9;
    }
  });
}
function updateoutColorsc() {
  adjustedRects1.value.forEach(rect => {
    if (rect.glassId === glassId) {
      rect.state = 9;
    }
  });
}
function updateoutColorsd() {
  adjustedRects2.value.forEach(rect => {
    if (rect.glassId === glassId) {
      rect.state = 9;
    }
  });
}
function updateonColorsa() {
  adjustedRectsa.value.forEach(rect => {
    if (rect.glassId === glassId) {
      rect.state = 1;
    }
  });
}
function updateRectColorsb() {
  adjustedRectsb.value.forEach(rect => {
    if (rect.glassId === glassId) {
      rect.state = 8;
    }
  });  
  });
}
function updateoutColorsb() {
  adjustedRectsb.value.forEach(rect => {
    if (rect.glassId === glassId) {
      rect.state = 9;
    }
  });
}
function updateonColorsb() {
  adjustedRectsb.value.forEach(rect => {
    if (rect.glassId === glassId) {
      rect.state = 3;
    }
  });
}
function updateRectColors1() {
  adjustedRects1.value.forEach(rect => {
    if (rect.glassId === glassId) {
      rect.state = 8;
    }
  });
}
function updateRectColors2() {
  adjustedRects2.value.forEach(rect => {
    if (rect.glassId === glassId) {
      rect.state = 8;
    }
  });
}
function getRectColor1(state) {
  switch (state) {  
    case 2:  
      return 'lightblue';
    case 8:
      return '#911005';
    case 9:
      return '#4682B4';
    default:
      return '#CDAF95'; 
  }
} 
function getRectColor2(state) {
  switch (state) {  
  switch (state) {
    case 2:
      return 'lightblue';
    case 8:
@@ -508,12 +496,24 @@
    case 9:
      return '#4682B4';
    default:
      return '#CDAF95'; 
      return '#CDAF95';
  }
}
function getRectColor2(state) {
  switch (state) {
    case 2:
      return 'lightblue';
    case 8:
      return '#911005';
    case 9:
      return '#4682B4';
    default:
      return '#CDAF95';
  }
}
function getRectColora(state) {
  switch (state) {  
    case 0:  
  switch (state) {
    case 0:
      return '#7AC5CD';
    case 1:
      return '#95d475';
@@ -524,31 +524,31 @@
    case 9:
      return '#4682B4';
    default:
      return '#CDAF95'; 
      return '#CDAF95';
  }
}
function getRectColorb(state) {  
  switch (state) {  
    case 3:  
      return '#eebe77';  
    case 4:  
function getRectColorb(state) {
  switch (state) {
    case 3:
      return '#eebe77';
    case 4:
      return '#CD6090';
    case 8:  
      return '#911005'; 
    case 8:
      return '#911005';
    case 9:
      return '#4682B4'; 
      return '#4682B4';
    default:
      return '#CDAF95'; 
  }  
      return '#CDAF95';
  }
}
function showDialog1(rect) {
  const index = adjustedRects1.value.findIndex(r => r.glassId === rect.glassId);  
  if (index !== -1) {  
    adjustedRects1.value[index].isActive = true;  
  }  
  currentGlassId.value = rect.glassId;  
  currenttemperingFeedSequence.value = rect.temperingFeedSequence;  
  blind1.value = true;  
  const index = adjustedRects1.value.findIndex(r => r.glassId === rect.glassId);
  if (index !== -1) {
    adjustedRects1.value[index].isActive = true;
  }
  currentGlassId.value = rect.glassId;
  currenttemperingFeedSequence.value = rect.temperingFeedSequence;
  blind1.value = true;
  currentRect.value = rect;
  if (currentRect.value.state == 8) {
    canSelectProject1.value = false;
@@ -559,16 +559,16 @@
    cantakea.value = false;
  } else if (currentRect.value.state !== 9) {
    cantakea.value = true;
  } 
} 
  }
}
function showDialog2(rect) {
  const index = adjustedRects2.value.findIndex(r => r.glassId === rect.glassId);  
  if (index !== -1) {  
    adjustedRects2.value[index].isActive = true;  
  }  
  currentGlassId.value = rect.glassId;  
  currenttemperingFeedSequence.value = rect.temperingFeedSequence;  
  blind2.value = true;  
  const index = adjustedRects2.value.findIndex(r => r.glassId === rect.glassId);
  if (index !== -1) {
    adjustedRects2.value[index].isActive = true;
  }
  currentGlassId.value = rect.glassId;
  currenttemperingFeedSequence.value = rect.temperingFeedSequence;
  blind2.value = true;
  currentRect.value = rect;
  if (currentRect.value.state == 8) {
    canSelectProject2.value = false;
@@ -580,40 +580,40 @@
  } else if (currentRect.value.state !== 9) {
    cantakea.value = true;
  }
} 
}
function showDialoga(rect) {
  const index = adjustedRectsa.value.findIndex(r => r.glassId === rect.glassId);  
  if (index !== -1) {  
    adjustedRectsa.value[index].isActive = true;  
  }  
  currentGlassId.value = rect.glassId;  
  currenttemperingFeedSequence.value = rect.temperingFeedSequence;  
  blinda.value = true; 
  const index = adjustedRectsa.value.findIndex(r => r.glassId === rect.glassId);
  if (index !== -1) {
    adjustedRectsa.value[index].isActive = true;
  }
  currentGlassId.value = rect.glassId;
  currenttemperingFeedSequence.value = rect.temperingFeedSequence;
  blinda.value = true;
  currentRect.value = rect;
  if (currentRect.value.state == 8) {
    canSelectProjecta.value = false;
  } else if (currentRect.value.state !== 8) {
    canSelectProjecta.value = true;
  } 
  }
  if (currentRect.value.state == 9) {
    cantakea.value = false;
  } else if (currentRect.value.state !== 9) {
    cantakea.value = true;
  } 
  }
  if (currentRect.value.state == 1) {
    canona.value = false;
  } else if (currentRect.value.state == 0) {
    canona.value = true;
  } 
} 
  }
}
function showDialogb(rect) {
  const index = adjustedRectsb.value.findIndex(r => r.glassId === rect.glassId);  
  if (index !== -1) {  
    adjustedRectsb.value[index].isActive = true;  
  }  
  currentGlassId.value = rect.glassId;  
  currenttemperingFeedSequence.value = rect.temperingFeedSequence;  
  blindb.value = true;  
  const index = adjustedRectsb.value.findIndex(r => r.glassId === rect.glassId);
  if (index !== -1) {
    adjustedRectsb.value[index].isActive = true;
  }
  currentGlassId.value = rect.glassId;
  currenttemperingFeedSequence.value = rect.temperingFeedSequence;
  blindb.value = true;
  currentRect.value = rect;
  if (currentRect.value.state == 8) {
    canSelectProjectb.value = false;
@@ -624,46 +624,46 @@
    cantakeb.value = false;
  } else if (currentRect.value.state !== 9) {
    cantakeb.value = true;
  } 
  }
  if (currentRect.value.state == 3) {
    canonb.value = false;
  } else if (currentRect.value.state !== 3) {
    canonb.value = true;
  } 
} 
  const handleDialogClose1 = () => {  
  adjustedRects1.value.forEach(rect => {  
    rect.isActive = false;  
  });  
  blind1.value = false; 
};  
  const handleDialogClose2 = () => {  
  adjustedRects2.value.forEach(rect => {  
    rect.isActive = false;  
  });  
  blind2.value = false; 
};  
  const handleDialogClosea = () => {  
  adjustedRectsa.value.forEach(rect => {  
    rect.isActive = false;  
  });  
  blinda.value = false; 
};  
  const handleDialogCloseb = () => {  
  adjustedRectsb.value.forEach(rect => {  
    rect.isActive = false;  
  });  
  blindb.value = false; 
};  
  }
}
const handleDialogClose1 = () => {
  adjustedRects1.value.forEach(rect => {
    rect.isActive = false;
  });
  blind1.value = false;
};
const handleDialogClose2 = () => {
  adjustedRects2.value.forEach(rect => {
    rect.isActive = false;
  });
  blind2.value = false;
};
const handleDialogClosea = () => {
  adjustedRectsa.value.forEach(rect => {
    rect.isActive = false;
  });
  blinda.value = false;
};
const handleDialogCloseb = () => {
  adjustedRectsb.value.forEach(rect => {
    rect.isActive = false;
  });
  blindb.value = false;
};
// 破损
const handleDamage1 = async () => {
  try  {
  const response = await request.post('/temperingGlass/temperingGlassInfo/updateTemperingState', {
    glassId: currentGlassId.value,
    // temperingFeedSequence: currenttemperingFeedSequence.value,
    line: 4001,
    state: 8,
    workingProcedure: '钢化',
  try {
    const response = await request.post('/temperingGlass/temperingGlassInfo/updateTemperingState', {
      glassId: currentGlassId.value,
      // temperingFeedSequence: currenttemperingFeedSequence.value,
      line: 4001,
      state: 8,
      workingProcedure: '钢化',
    })
    if (response.code == 200) {
      ElMessage.success('成功！');
@@ -672,18 +672,18 @@
    } else {
      ElMessage.error(response.message);
    }
}
catch (error) {
  }
  catch (error) {
    console.error(error);
  }
}
const handleDamage2 = async () => {
  try  {
  const response = await request.post('/temperingGlass/temperingGlassInfo/updateTemperingState', {
    glassId: currentGlassId.value,
    line: 4001,
    state: 8,
    workingProcedure: '钢化',
  try {
    const response = await request.post('/temperingGlass/temperingGlassInfo/updateTemperingState', {
      glassId: currentGlassId.value,
      line: 4001,
      state: 8,
      workingProcedure: '钢化',
    })
    if (response.code == 200) {
      ElMessage.success('成功！');
@@ -692,19 +692,19 @@
    } else {
      ElMessage.error(response.message);
    }
}
catch (error) {
  }
  catch (error) {
    console.error(error);
  }
}
// 进炉前破损
const handleDamagea = async () => {
  try  {
  const response = await request.post('/temperingGlass/temperingGlassInfo/updateTemperingState', {
    glassId: currentGlassId.value,
    line: 4001,
    state: 8,
    workingProcedure: '钢化',
  try {
    const response = await request.post('/temperingGlass/temperingGlassInfo/updateTemperingState', {
      glassId: currentGlassId.value,
      line: 4001,
      state: 8,
      workingProcedure: '钢化',
    })
    if (response.code == 200) {
      ElMessage.success('成功！');
@@ -713,19 +713,19 @@
    } else {
      ElMessage.error(response.message);
    }
}
catch (error) {
  }
  catch (error) {
    console.error(error);
  }
}
// 进炉前人工拿走
const takeouta = async () => {
  try  {
  const response = await request.post('/temperingGlass/temperingGlassInfo/updateTemperingState', {
    glassId: currentGlassId.value,
    line: 4001,
    state: 9,
    workingProcedure: '钢化',
  try {
    const response = await request.post('/temperingGlass/temperingGlassInfo/updateTemperingState', {
      glassId: currentGlassId.value,
      line: 4001,
      state: 9,
      workingProcedure: '钢化',
    })
    if (response.code == 200) {
      ElMessage.success('成功！');
@@ -734,19 +734,19 @@
    } else {
      ElMessage.error(response.message);
    }
}
catch (error) {
  }
  catch (error) {
    console.error(error);
  }
}
// 进炉前放回
const takeona = async () => {
  try  {
  const response = await request.post('/temperingGlass/temperingGlassInfo/updateTemperingState', {
    glassId: currentGlassId.value,
    line: 4001,
    state: 1,
    workingProcedure: '钢化',
  try {
    const response = await request.post('/temperingGlass/temperingGlassInfo/updateTemperingState', {
      glassId: currentGlassId.value,
      line: 4001,
      state: 1,
      workingProcedure: '钢化',
    })
    if (response.code == 200) {
      ElMessage.success('成功！');
@@ -755,19 +755,19 @@
    } else {
      ElMessage.error(response.message);
    }
}
catch (error) {
  }
  catch (error) {
    console.error(error);
  }
}
// 进炉中人工拿走
const takeoutc = async () => {
  try  {
  const response = await request.post('/temperingGlass/temperingGlassInfo/updateTemperingState', {
    glassId: currentGlassId.value,
    line: 4001,
    state: 9,
    workingProcedure: '钢化',
  try {
    const response = await request.post('/temperingGlass/temperingGlassInfo/updateTemperingState', {
      glassId: currentGlassId.value,
      line: 4001,
      state: 9,
      workingProcedure: '钢化',
    })
    if (response.code == 200) {
      ElMessage.success('成功！');
@@ -776,19 +776,19 @@
    } else {
      ElMessage.error(response.message);
    }
}
catch (error) {
  }
  catch (error) {
    console.error(error);
  }
}
// 进炉中人工拿走
const takeoutd = async () => {
  try  {
  const response = await request.post('/temperingGlass/temperingGlassInfo/updateTemperingState', {
    glassId: currentGlassId.value,
    line: 4001,
    state: 9,
    workingProcedure: '钢化',
  try {
    const response = await request.post('/temperingGlass/temperingGlassInfo/updateTemperingState', {
      glassId: currentGlassId.value,
      line: 4001,
      state: 9,
      workingProcedure: '钢化',
    })
    if (response.code == 200) {
      ElMessage.success('成功！');
@@ -797,19 +797,19 @@
    } else {
      ElMessage.error(response.message);
    }
}
catch (error) {
  }
  catch (error) {
    console.error(error);
  }
}
// 已出炉破损
const handleDamageb = async () => {
  try  {
  const response = await request.post('/temperingGlass/temperingGlassInfo/updateTemperingState', {
    glassId: currentGlassId.value,
    line: 4001,
    state: 8,
    workingProcedure: '钢化',
  try {
    const response = await request.post('/temperingGlass/temperingGlassInfo/updateTemperingState', {
      glassId: currentGlassId.value,
      line: 4001,
      state: 8,
      workingProcedure: '钢化',
    })
    if (response.code == 200) {
      ElMessage.success('成功！');
@@ -818,18 +818,18 @@
    } else {
      ElMessage.error(response.message);
    }
}
catch (error) {
  }
  catch (error) {
  }
}
// 已出炉人工拿走
const takeoutb = async () => {
  try  {
  const response = await request.post('/temperingGlass/temperingGlassInfo/updateTemperingState', {
    glassId: currentGlassId.value,
    line: 4001,
    state: 9,
    workingProcedure: '钢化',
  try {
    const response = await request.post('/temperingGlass/temperingGlassInfo/updateTemperingState', {
      glassId: currentGlassId.value,
      line: 4001,
      state: 9,
      workingProcedure: '钢化',
    })
    if (response.code == 200) {
      ElMessage.success('成功！');
@@ -838,18 +838,18 @@
    } else {
      ElMessage.error(response.message);
    }
}
catch (error) {
  }
  catch (error) {
  }
}
// 已出炉放回
const takeonb = async () => {
  try  {
  const response = await request.post('/temperingGlass/temperingGlassInfo/updateTemperingState', {
    glassId: currentGlassId.value,
    line: 4001,
    state: 3,
    workingProcedure: '钢化',
  try {
    const response = await request.post('/temperingGlass/temperingGlassInfo/updateTemperingState', {
      glassId: currentGlassId.value,
      line: 4001,
      state: 3,
      workingProcedure: '钢化',
    })
    if (response.code == 200) {
      ElMessage.success('成功！');
@@ -858,9 +858,9 @@
    } else {
      ElMessage.error(response.message);
    }
}
catch (error) {
}
  }
  catch (error) {
  }
}
onBeforeUnmount(() => {
  closeWebSocket();
@@ -869,250 +869,289 @@
<template>
  <div style="height: 500px;">
    <div style="margin-top: 10px;">
      <el-button style="margin-left: 15px;" id="searchButton" type="primary"
                 @click="dialogFormVisiblea = true;dialogFormVisible = false;dialogFormVisibleb = false;">
        {{ $t('processCard.beforefurnace') }}
      </el-button>
      <el-button style="margin-left: 15px;" id="searchButton" type="primary"
                 @click="dialogFormVisible = true;dialogFormVisiblea = false;dialogFormVisibleb = false;">
        {{ $t('processCard.intofurnace') }}
      </el-button>
      <el-button id="searchButton" type="success"
                 @click="dialogFormVisibleb = true;dialogFormVisible = false;dialogFormVisiblea = false;">
        {{ $t('processCard.outfurnace') }}
      </el-button>
      <div class="dot-tips">
        <el-button style="margin-left: 15px;" id="searchButton" type="primary"
          @click="dialogFormVisiblea = true; dialogFormVisible = false; dialogFormVisibleb = false;">
          {{ $t('processCard.beforefurnace') }}
        </el-button>
        <el-button style="margin-left: 15px;" id="searchButton" type="primary"
          @click="dialogFormVisible = true; dialogFormVisiblea = false; dialogFormVisibleb = false;">
          {{ $t('processCard.intofurnace') }}
        </el-button>
        <el-button id="searchButton" type="success"
          @click="dialogFormVisibleb = true; dialogFormVisible = false; dialogFormVisiblea = false;">
          {{ $t('processCard.outfurnace') }}
        </el-button>
        <div class="dot-item">
          <span class="dot color1"></span>
          <span class="text">{{ $t('processCard.tempState1') }}</span>
        </div>
        <div class="dot-item">
          <span class="dot color2"></span>
          <span class="text">{{ $t('processCard.tempState2') }}</span>
        </div>
        <div class="dot-item">
          <span class="dot color3"></span>
          <span class="text">{{ $t('processCard.tempState3') }}</span>
        </div>
        <div class="dot-item">
          <span class="dot color4"></span>
          <span class="text">{{ $t('processCard.tempState4') }}</span>
        </div>
        <div class="dot-item">
          <span class="dot color5"></span>
          <span class="text">{{ $t('processCard.tempState5') }}</span>
        </div>
        <div class="dot-item">
          <span class="dot color6"></span>
          <span class="text">{{ $t('processCard.tempState6') }}</span>
        </div>
        <div class="dot-item">
          <span class="dot color7"></span>
          <span class="text">{{ $t('processCard.tempState7') }}</span>
        </div>
        <div class="dot-item">
          <span class="dot color8"></span>
          <span class="text">{{ $t('processCard.tempState8') }}</span>
        </div>
      </div>
      <div v-if="dialogFormVisible">
        <!-- 进炉中右 -->
        <el-card style="flex: 1;margin-left: 10px;margin-top: 10px;margin-right: 10px;height: 800px;">
          <!-- <div style="width:900px;background-color: #f4f4f5;height: 420px;"> -->
            <!-- <div v-if="adjustedRects1.length > 0"> -->
              <div v-if="currentPage === 1 && adjustedRects1.length > 0">
              <!-- <div style="text-align: center;">炉号：{{ engineerIdDisplay }}-{{ adjustedRects[0].temperingLayoutId }}</div>   -->
              <div style="text-align: center;"> {{ $t('processCard.temperinglayout') }}：{{
                  adjustedRects1[0].engineerId
                }}-{{ adjustedRects1[0].temperingLayoutId }}
          <!-- <div v-if="adjustedRects1.length > 0"> -->
          <div v-if="currentPage === 1 && adjustedRects1.length > 0">
            <!-- <div style="text-align: center;">炉号：{{ engineerIdDisplay }}-{{ adjustedRects[0].temperingLayoutId }}</div>   -->
            <div style="text-align: center;"> {{ $t('processCard.temperinglayout') }}：{{
              adjustedRects1[0].engineerId
            }}-{{ adjustedRects1[0].temperingLayoutId }}
            </div>
            <el-scrollbar height="750px" style="background-color: #e9e9eb;">
              <div style="position: relative;max-width: 1400px;">
                <div v-for="(rect, index) in adjustedRects1" :key="index" @click="showDialog1(rect)" class="rect"
                  :style="{
                    position: 'absolute',
                    top: `${rect.y}px`,
                    left: `${rect.x}px`,
                    width: `${rect.width}px`,
                    height: `${rect.height}px`,
                    backgroundColor: rect.isActive ? '#ADFF2F' : getRectColor1(rect.state)
                  }">
                  <div class="centered-text">
                    <div style="font-size: 15px;font-weight: bold;">{{ rect.glassId }}</div>
                    <div style="font-size: 15px;font-weight: bold;">{{ rect.flowCardId }}/{{ rect.layer }}/{{ rect.sequence }}</div>
                    <div style="font-size: 30px;font-weight: bold;">{{ rect.widtha }}*{{ rect.heighta }}</div>
                  </div>
                </div>
              </div>
    <el-scrollbar height="750px" style="background-color: #e9e9eb;">
    <div  style="position: relative;max-width: 1400px;">  
      <div  
      v-for="(rect, index) in adjustedRects1"
      :key="index"  
      @click="showDialog1(rect)"  
      class="rect"
      :style="{ position: 'absolute', 
       top: `${rect.y}px`, 
       left: `${rect.x}px`,
        width: `${rect.width}px`, 
        height: `${rect.height}px`,
        backgroundColor: rect.isActive ? '#ADFF2F' : getRectColor1(rect.state) }">
     <div  class="centered-text">
    <div style="font-size: 15px;font-weight: bold;">{{ rect.glassId }}</div>  
    <div style="font-size: 15px;font-weight: bold;">{{ rect.flowCardId }}</div>  
    <div style="font-size: 30px;font-weight: bold;">{{ rect.widtha }}*{{ rect.heighta }}</div>  
  </div>
  </div>
   </div>
   </el-scrollbar>
   </div>
  <!-- </div> -->
  <!-- 进炉中左 -->
<!-- <div style="width: 750px;float: left;background-color: #f4f4f5;height: 350px;"> -->
    <!-- <div v-if="adjustedRects2.length > 0"> -->
      <div v-else-if="currentPage === 2 && adjustedRects2.length > 0">
    <div style="text-align: center;"> {{ $t('processCard.temperinglayout') }}：{{ adjustedRects2[0].engineerId }}-{{ adjustedRects2[0].temperingLayoutId }} </div>
    <el-scrollbar height="750px" style="background-color: #e9e9eb;">
    <div  style="position: relative;max-width: 1400px;">  
      <div  
      v-for="(rect, index) in adjustedRects2"
      :key="index"
      @click="showDialog2(rect)"  
      class="rect"
      :style="{ position: 'absolute', 
       top: `${rect.y}px`, 
       left: `${rect.x}px`, 
       width: `${rect.width}px`, 
       height: `${rect.height}px`,
        backgroundColor: rect.isActive ? '#ADFF2F' : getRectColor2(rect.state) }">
     <div  class="centered-text">
    <div style="font-size: 15px;font-weight: bold;">{{ rect.glassId }}</div>  
    <div style="font-size: 15px;font-weight: bold;">{{ rect.flowCardId }}</div>  
    <div style="font-size: 30px;font-weight: bold;">{{ rect.widtha }}*{{ rect.heighta }}</div>  
  </div>
  </div>
   </div>
   </el-scrollbar>
   </div>
<!-- </div> -->
   </el-card>
   <div style="display: flex;margin-left: 40%;margin-bottom: 10px;">
    <el-pagination
        size="small"
        background
        layout="prev, pager, next"
        :total="20"
        @current-change="handlePageChange"
      />
  </div>
    </div>
<div v-if="dialogFormVisiblea">
  <!-- 进炉前 -->
  <el-card style="flex: 1;margin-left: 10px;margin-top: 10px;margin-right: 10px;height: 800px;">
    <div v-if="adjustedRectsa.length > 0">
    <div style="text-align: center;"> {{ $t('processCard.temperinglayout') }}：{{ adjustedRectsa[0].engineerId }}-{{ adjustedRectsa[0].temperingLayoutId }} </div>
    <!-- <div style="text-align: center;">炉号：{{ engineerIdDisplaya }}-{{ adjustedRects[0].temperingLayoutId }}</div>   -->
      <el-scrollbar height="750px" style="background-color: #e9e9eb;">
    <div  style="position: relative;max-width: 1400px;">  
      <div
      v-for="(rect, index) in adjustedRectsa"  
      :key="index"  
      @click="showDialoga(rect)"  
      class="rect"  
      :style="{ position: 'absolute',  top: `${rect.y}px`, left: `${rect.x}px`,
       width: `${rect.width}px`, height: `${rect.height}px`,
      backgroundColor: rect.isActive ? '#ADFF2F' : getRectColora(rect.state) }">
    <div  class="centered-text">
    <div style="font-size: 15px;font-weight: bold;">{{ rect.glassId }}</div>  
    <div style="font-size: 15px;font-weight: bold;">{{ rect.flowCardId }}</div>  
    <div style="font-size: 30px;font-weight: bold;">{{ rect.widtha }}*{{ rect.heighta }}</div>  
  </div>
  </div> 
   </div>
   </el-scrollbar>
   </div>
   </el-card>
</div>
<div v-if="dialogFormVisibleb">
  <!-- 已出炉 -->
  <el-card style="flex: 1;margin-left: 10px;margin-top: 10px;margin-right: 10px;height: 800px;">
      <div v-if="adjustedRectsb.length > 0">
    <div style="text-align: center;"> {{ $t('processCard.temperinglayout') }}：{{ adjustedRectsb[0].engineerId }}-{{ adjustedRectsb[0].temperingLayoutId }} </div>
    <!-- <div style="text-align: center;">炉号：{{ engineerIdDisplayb }}-{{ adjustedRects[0].temperingLayoutId }}</div>   -->
      <el-scrollbar height="750px" style="background-color: #e9e9eb;">
    <div  style="position: relative;max-width: 1400px;">
      <div  
      v-for="(rect, index) in adjustedRectsb"  
      :key="index"  
      @click="showDialogb(rect)"  
      class="rect"  
      :style="{ position: 'absolute',  top: `${rect.y}px`, left: `${rect.x}px`,
       width: `${rect.width}px`, height: `${rect.height}px`,
      backgroundColor: rect.isActive ? '#ADFF2F' : getRectColorb(rect.state) }">
       <!-- backgroundColor: rect.state === 4 ? '#911005' : '#f8e3c5' }"> -->
     <div  class="centered-text">
    <div style="font-size: 15px;font-weight: bold;">{{ rect.glassId }}</div>  
    <div style="font-size: 15px;font-weight: bold;">{{ rect.flowCardId }}</div>  
    <div style="font-size: 30px;font-weight: bold;">{{ rect.widtha }}*{{ rect.heighta }}</div>  
  </div>
  </div> 
   </div>
   </el-scrollbar>
   </div>
   </el-card>
</div>
<!-- 进炉中 -->
<el-dialog v-model="blind1" top="30vh" width="15%" style="text-align: center;" @close="handleDialogClose1">
        <el-button :disabled="!canSelectProject1" type="warning" plain @click="handleDamage1"  style="width: 150px;margin-left: 10px;">
            </el-scrollbar>
          </div>
          <!-- </div> -->
          <!-- 进炉中左 -->
          <!-- <div style="width: 750px;float: left;background-color: #f4f4f5;height: 350px;"> -->
          <!-- <div v-if="adjustedRects2.length > 0"> -->
          <div v-else-if="currentPage === 2 && adjustedRects2.length > 0">
            <div style="text-align: center;"> {{ $t('processCard.temperinglayout') }}：{{ adjustedRects2[0].engineerId
              }}-{{ adjustedRects2[0].temperingLayoutId }} </div>
            <el-scrollbar height="750px" style="background-color: #e9e9eb;">
              <div style="position: relative;max-width: 1400px;">
                <div v-for="(rect, index) in adjustedRects2" :key="index" @click="showDialog2(rect)" class="rect"
                  :style="{
                    position: 'absolute',
                    top: `${rect.y}px`,
                    left: `${rect.x}px`,
                    width: `${rect.width}px`,
                    height: `${rect.height}px`,
                    backgroundColor: rect.isActive ? '#ADFF2F' : getRectColor2(rect.state)
                  }">
                  <div class="centered-text">
                    <div style="font-size: 15px;font-weight: bold;">{{ rect.glassId }}</div>
                    <div style="font-size: 15px;font-weight: bold;">{{ rect.flowCardId }}/{{ rect.layer }}/{{ rect.sequence }}</div>
                    <div style="font-size: 30px;font-weight: bold;">{{ rect.widtha }}*{{ rect.heighta }}</div>
                  </div>
                </div>
              </div>
            </el-scrollbar>
          </div>
          <!-- </div> -->
        </el-card>
        <div style="display: flex;margin-left: 40%;margin-bottom: 10px;">
          <el-pagination size="small" background layout="prev, pager, next" :total="20"
            @current-change="handlePageChange" />
        </div>
      </div>
      <div v-if="dialogFormVisiblea">
        <!-- 进炉前 -->
        <el-card style="flex: 1;margin-left: 10px;margin-top: 10px;margin-right: 10px;height: 800px;">
          <div v-if="adjustedRectsa.length > 0">
            <div style="text-align: center;"> {{ $t('processCard.temperinglayout') }}：{{ adjustedRectsa[0].engineerId
              }}-{{ adjustedRectsa[0].temperingLayoutId }} </div>
            <!-- <div style="text-align: center;">炉号：{{ engineerIdDisplaya }}-{{ adjustedRects[0].temperingLayoutId }}</div>   -->
            <el-scrollbar height="750px" style="background-color: #e9e9eb;">
              <div style="position: relative;max-width: 1400px;">
                <div v-for="(rect, index) in adjustedRectsa" :key="index" @click="showDialoga(rect)" class="rect"
                  :style="{
                    position: 'absolute', top: `${rect.y}px`, left: `${rect.x}px`,
                    width: `${rect.width}px`, height: `${rect.height}px`,
                    backgroundColor: rect.isActive ? '#ADFF2F' : getRectColora(rect.state)
                  }">
                  <div class="centered-text">
                    <div style="font-size: 15px;font-weight: bold;">{{ rect.glassId }}</div>
                    <div style="font-size: 15px;font-weight: bold;">{{ rect.flowCardId }}/{{ rect.layer }}/{{ rect.sequence }}</div>
                    <div style="font-size: 30px;font-weight: bold;">{{ rect.widtha }}*{{ rect.heighta }}</div>
                  </div>
                </div>
              </div>
            </el-scrollbar>
          </div>
        </el-card>
      </div>
      <div v-if="dialogFormVisibleb">
        <!-- 已出炉 -->
        <el-card style="flex: 1;margin-left: 10px;margin-top: 10px;margin-right: 10px;height: 800px;">
          <div v-if="adjustedRectsb.length > 0">
            <div style="text-align: center;"> {{ $t('processCard.temperinglayout') }}：{{ adjustedRectsb[0].engineerId
              }}-{{ adjustedRectsb[0].temperingLayoutId }} </div>
            <!-- <div style="text-align: center;">炉号：{{ engineerIdDisplayb }}-{{ adjustedRects[0].temperingLayoutId }}</div>   -->
            <el-scrollbar height="750px" style="background-color: #e9e9eb;">
              <div style="position: relative;max-width: 1400px;">
                <div v-for="(rect, index) in adjustedRectsb" :key="index" @click="showDialogb(rect)" class="rect"
                  :style="{
                    position: 'absolute', top: `${rect.y}px`, left: `${rect.x}px`,
                    width: `${rect.width}px`, height: `${rect.height}px`,
                    backgroundColor: rect.isActive ? '#ADFF2F' : getRectColorb(rect.state)
                  }">
                  <!-- backgroundColor: rect.state === 4 ? '#911005' : '#f8e3c5' }"> -->
                  <div class="centered-text">
                    <div style="font-size: 15px;font-weight: bold;">{{ rect.glassId }}</div>
                    <div style="font-size: 15px;font-weight: bold;">{{ rect.flowCardId }}/{{ rect.layer }}/{{ rect.sequence }}</div>
                    <div style="font-size: 30px;font-weight: bold;">{{ rect.widtha }}*{{ rect.heighta }}</div>
                  </div>
                </div>
              </div>
            </el-scrollbar>
          </div>
        </el-card>
      </div>
      <!-- 进炉中 -->
      <el-dialog v-model="blind1" top="30vh" width="15%" style="text-align: center;" @close="handleDialogClose1">
        <el-button :disabled="!canSelectProject1" type="warning" plain @click="handleDamage1"
          style="width: 150px;margin-left: 10px;">
          {{ $t('order.dilapidation') }}
        </el-button>
        <el-button :disabled="!cantakea" type="danger" plain @click="takeoutc"  style="width: 150px;margin-left: 10px;margin-top: 10px;">
          <el-icon class="el-icon--right"><Upload /></el-icon>
        <el-button :disabled="!cantakea" type="danger" plain @click="takeoutc"
          style="width: 150px;margin-left: 10px;margin-top: 10px;">
          <el-icon class="el-icon--right">
            <Upload />
          </el-icon>
          {{ $t('order.takeaway') }}
        </el-button>
  </el-dialog>  
<el-dialog v-model="blind2" top="30vh" width="15%" style="text-align: center;" @close="handleDialogClose2">
        <el-button :disabled="!canSelectProject2" type="warning" plain @click="handleDamage2"  style="width: 150px;margin-left: 10px;">
      </el-dialog>
      <el-dialog v-model="blind2" top="30vh" width="15%" style="text-align: center;" @close="handleDialogClose2">
        <el-button :disabled="!canSelectProject2" type="warning" plain @click="handleDamage2"
          style="width: 150px;margin-left: 10px;">
          {{ $t('order.dilapidation') }}
        </el-button>
        <el-button :disabled="!cantakea" type="danger" plain @click="takeoutd"  style="width: 150px;margin-left: 10px;margin-top: 10px;">
          <el-icon class="el-icon--right"><Upload /></el-icon>
        <el-button :disabled="!cantakea" type="danger" plain @click="takeoutd"
          style="width: 150px;margin-left: 10px;margin-top: 10px;">
          <el-icon class="el-icon--right">
            <Upload />
          </el-icon>
          {{ $t('order.takeaway') }}
        </el-button>
  </el-dialog>  
  <!-- 进炉前 -->
<el-dialog v-model="blinda" top="30vh" width="15%" style="text-align: center;" @close="handleDialogClosea">
  <el-button type="warning" plain @click="handleDamagea" :disabled="!canSelectProjecta" style="width: 150px;margin-left: 10px;">
      </el-dialog>
      <!-- 进炉前 -->
      <el-dialog v-model="blinda" top="30vh" width="15%" style="text-align: center;" @close="handleDialogClosea">
        <el-button type="warning" plain @click="handleDamagea" :disabled="!canSelectProjecta"
          style="width: 150px;margin-left: 10px;">
          {{ $t('order.dilapidation') }}
        </el-button>
        <el-button :disabled="!cantakea" type="danger" plain @click="takeouta"  style="width: 150px;margin-left: 10px;margin-top: 10px;">
          <el-icon class="el-icon--right"><Upload /></el-icon>
        <el-button :disabled="!cantakea" type="danger" plain @click="takeouta"
          style="width: 150px;margin-left: 10px;margin-top: 10px;">
          <el-icon class="el-icon--right">
            <Upload />
          </el-icon>
          {{ $t('order.takeaway') }}
        </el-button>
        <el-button type="success" plain @click="takeona" :disabled="!canona" style="width: 150px;margin-left: 10px;margin-top: 10px;">
        <el-button type="success" plain @click="takeona" :disabled="!canona"
          style="width: 150px;margin-left: 10px;margin-top: 10px;">
          {{ $t('order.takeon') }}
        </el-button>
  </el-dialog>  
  <!-- 已出炉 -->
<el-dialog v-model="blindb" top="30vh" width="15%" style="text-align: center;" @close="handleDialogCloseb">
        <el-button :disabled="!canSelectProjectb" type="warning" plain  @click="handleDamageb"  style="width: 150px;margin-left: 10px;">
      </el-dialog>
      <!-- 已出炉 -->
      <el-dialog v-model="blindb" top="30vh" width="15%" style="text-align: center;" @close="handleDialogCloseb">
        <el-button :disabled="!canSelectProjectb" type="warning" plain @click="handleDamageb"
          style="width: 150px;margin-left: 10px;">
          {{ $t('order.dilapidation') }}
        </el-button>
        <el-button :disabled="!cantakeb" type="danger" plain @click="takeoutb"  style="width: 150px;margin-left: 10px;margin-top: 10px;">
          <el-icon class="el-icon--right"><Upload /></el-icon>
        <el-button :disabled="!cantakeb" type="danger" plain @click="takeoutb"
          style="width: 150px;margin-left: 10px;margin-top: 10px;">
          <el-icon class="el-icon--right">
            <Upload />
          </el-icon>
          {{ $t('order.takeaway') }}
        </el-button>
        <!-- <el-button type="success" plain  @click="takeonb" :disabled="!canonb" style="width: 150px;margin-left: 10px;margin-top: 10px;">
          {{ $t('order.takeon') }}
        </el-button> -->
  </el-dialog> 
  <el-dialog  
      v-model="dialogVisible"
      width="100%" 
      top="0vh"
      :show-close="false"
      >  
      <div class="custom-title" style="text-align: center; margin-bottom: 20px;">  
      {{ $t('processCard.glasstakeout') }}  
    </div>  
      <el-table  
        :data="tableData"  
        style="width: 100%;height: 760px"  
      >
        <el-table-column prop="flowCardId" :label="$t('processCard.flowcard')" width="140" align="center"/>
        <el-table-column prop="layer" :label="$t('processCard.layer')" align="center" width="52"/>
        <el-table-column prop="engineerId" :label="$t('processCard.project')" align="center" width="110"/>
        <el-table-column prop="temperingLayoutId" :label="$t('processCard.temperinglayout')" align="center" width="52"/>
        <el-table-column prop="temperingFeedSequence" :label="$t('processCard.temperingfeed')" align="center" width="52"/>
        <el-table-column prop="width" :label="$t('processCard.width')" align="center" width="80"/>
        <el-table-column prop="height" :label="$t('processCard.height')" align="center" width="80"/>
        <el-table-column prop="thickness" :label="$t('processCard.thickness')" align="center" width="52"/>
      </el-table>
  </el-dialog>
      </el-dialog>
      <el-dialog v-model="dialogVisible" width="100%" top="0vh" :show-close="false">
        <div class="custom-title" style="text-align: center; margin-bottom: 20px;">
          {{ $t('processCard.glasstakeout') }}
        </div>
        <el-table :data="tableData" style="width: 100%;height: 760px">
          <el-table-column prop="flowCardId" :label="$t('processCard.flowcard')" width="140" align="center" />
          <el-table-column prop="layer" :label="$t('processCard.layer')" align="center" width="52" />
          <el-table-column prop="engineerId" :label="$t('processCard.project')" align="center" width="110" />
          <el-table-column prop="temperingLayoutId" :label="$t('processCard.temperinglayout')" align="center"
            width="52" />
          <el-table-column prop="temperingFeedSequence" :label="$t('processCard.temperingfeed')" align="center"
            width="52" />
          <el-table-column prop="width" :label="$t('processCard.width')" align="center" width="80" />
          <el-table-column prop="height" :label="$t('processCard.height')" align="center" width="80" />
          <el-table-column prop="thickness" :label="$t('processCard.thickness')" align="center" width="52" />
        </el-table>
      </el-dialog>
    </div>
  </div>
</template>
<style scoped>
#boxa{
#boxa {
  border: 1px solid rgb(119, 116, 116);
  background-color:  #529b2e;
  background-color: #529b2e;
  text-align: center;
  display: inline-block;
    /* align-items:center; */
    /* justify-content:center; */
  /* align-items:center; */
  /* justify-content:center; */
  margin-left: 20px;
}
#boxb{

#boxb {
  border: 1px solid rgb(119, 116, 116);
  background-color:  #a0cfff;
  background-color: #a0cfff;
  /* display:flex; */
  text-align: center;
  display: inline-block;
  align-items:center;
  justify-content:center;
  align-items: center;
  justify-content: center;
  margin-left: 20px;
}
#box{

#box {
  border: 1px solid black;
  background-color:  #337ecc;
  display:flex;
  align-items:center; 
  justify-content:center;
  background-color: #337ecc;
  display: flex;
  align-items: center;
  justify-content: center;
}

#home-card {
  width: 100%;
  overflow: hidden;
  padding: 10px 0px;
  display: flex;
  flex-wrap: wrap;

  #home-item {
    border-style: solid;
    border-width: 1px;
@@ -1125,6 +1164,7 @@
    justify-content: center;
    /* align-items: center; */
    background: #fff;

    #home-img {
      display: inline-block;
      width: 160px;
@@ -1132,36 +1172,107 @@
      margin: 0;
      padding: 0;
    }
      #home-right {
        display: flex;
        flex-direction: column;
        justify-content: center;
        align-items: flex-start;
        margin-left: 10px;
        #home-num {
          font-size: 40px;
          margin: 5px 0;
        }

    #home-right {
      display: flex;
      flex-direction: column;
      justify-content: center;
      align-items: flex-start;
      margin-left: 10px;

      #home-num {
        font-size: 40px;
        margin: 5px 0;
      }
    }
  }
  .rect {  
  border: 1px solid black; /* 设置矩形的边框 */  
}

.rect {
  border: 1px solid black;
  /* 设置矩形的边框 */
  /* background-color: lightblue; 设置矩形的背景色   */
} 
#rect {  
  position: relative; /* 确保箭头可以相对于矩形定位 */  
}  
}

#rect {
  position: relative;
  /* 确保箭头可以相对于矩形定位 */
}

.centered-text {
  /* 设置文字居中样式 */  
  /* 设置文字居中样式 */
  /* display: flex; */
  justify-content: center;  
  align-items: center; 
  height: 100%; /* 确保div占据整个矩形的高度 */  
  justify-content: center;
  align-items: center;
  height: 100%;
  /* 确保div占据整个矩形的高度 */
  /* font-size: small; */
} 
.custom-title {  
}

.custom-title {
  font-size: 20px;
  font-weight: bold;
} 
}

.dot-tips {
  display: flex;
  align-items: center;
  gap: 20px;
  /* 每个圆点项之间的间距 */
  padding: 10px;
}

/* 单个圆点+文字项 */
.dot-item {
  display: flex;
  align-items: center;
  font-size: 14px;
}

/* 圆点样式：核心是圆形 */
.dot {
  width: 12px;
  height: 12px;
  border-radius: 50%;
  /* 圆形 */
  margin-right: 6px;
  /* 圆点和文字的间距 */
}

/* 不同颜色的圆点（可自定义） */
.color1 {
  background-color: #99BBFF;
}

.color2 {
  background-color: #7AC5CD;
}

.color3 {
  background-color: #95d475;
}

.color4 {
  background-color: lightblue;
}

.color5 {
  background-color: #eebe77;
}

.color6 {
  background-color: #CD6090;
}

.color7 {
  background-color: #911005;
}

.color8 {
  background-color: #4682B4;
}
/* 文字样式 */
.text {
  color: #666;
}
</style>

 UI-Project/src/views/Returns/upreturns.vue

@@ -180,7 +180,7 @@
    try {
      const response = await request.post('/loadGlass/engineering/engineering/changeTask', {
        stationCell: 5,
        filmRemove: filmRemove,
        filmRemove: 0,
        engineerId: engineeringId,
        state: 1,
      })

 UI-Project/src/views/Returns/upreturns2.vue

@@ -249,7 +249,7 @@
    try {
      const response = await request.post('/loadGlass/engineering/engineering/changeTask', {
        stationCell: 6,
        filmRemove: filmRemove,
        filmRemove: 0,
        engineerId: engineeringId,
        state: 1,
      })

 UI-Project/src/views/Slicecage/slicecage.vue

@@ -1,13 +1,13 @@
<script lang="ts" setup>
import {useI18n} from 'vue-i18n'
import {useRouter} from "vue-router"
import { useI18n } from 'vue-i18n'
import { useRouter } from "vue-router"
import request from "@/utils/request"
import {host, WebSocketHost} from '@/utils/constants'
import {onBeforeUnmount, onMounted, onUnmounted, reactive, ref} from "vue";
import {closeWebSocket, initializeWebSocket} from '@/utils/WebSocketService';
import {ElMessage, ElMessageBox} from 'element-plus'
import { host, WebSocketHost } from '@/utils/constants'
import { onBeforeUnmount, onMounted, onUnmounted, reactive, ref } from "vue";
import { closeWebSocket, initializeWebSocket } from '@/utils/WebSocketService';
import { ElMessage, ElMessageBox } from 'element-plus'
const scanGlass = ref([])
const {t} = useI18n()
const { t } = useI18n()
let language = ref(localStorage.getItem('lang') || 'zh')
import { inject } from 'vue';
const router = useRouter()
@@ -81,25 +81,25 @@
const endDate = ref('');
const thickness = ref('');
const width = ref('');
const cell1=ref(true);
const cell2=ref(true);
const cell3=ref(true);
const cell4=ref(true);
const cell5=ref(true);
const cell6=ref(true);
const cell1 = ref(true);
const cell2 = ref(true);
const cell3 = ref(true);
const cell4 = ref(true);
const cell5 = ref(true);
const cell6 = ref(true);
const canEdit = ref(true);
const selectedRow = ref(null);
const temperingtotal = ref(0);
const glasstotal = ref(0);
const fulltotals = ref(0);
const temperingengineerId=ref('');
const temperingengineerId = ref('');
const printFlowCardId = ref('')
const printLayer = ref('')
const printGlassId = ref('')
const open1 = async (row) => {
printFlowCardId.value = row.flowCardId;
printLayer.value = row.layer
printGlassId.value = row.glassId
  printFlowCardId.value = row.flowCardId;
  printLayer.value = row.layer
  printGlassId.value = row.glassId
}
const selectGong = async () => {
  try {
@@ -116,13 +116,13 @@
// }
// // 假设我们每2分钟执行一次清理  
// setInterval(cleanUp, 1 * 60 * 1000);
const getTableRow = (row,type) =>{
const getTableRow = (row, type) => {
  switch (type) {
    case 'edit' :{
      router.push({path: '/main/returns/createReturns', query: { ReturnID: 'TH24010101' }})
    case 'edit': {
      router.push({ path: '/main/returns/createReturns', query: { ReturnID: 'TH24010101' } })
      break
    }
    case 'delete':{
    case 'delete': {
      alert('我接收到子组件传送的删除信息')
      break
    }
@@ -135,8 +135,8 @@
};
const handleBindRack = (row) => {
  selectedRow.value = row; // 更新选中的行数据  
  currentRow.deviceId  = row.deviceId; // 直接设置响应式属性  
  currentRow.slot = row.slot;  
  currentRow.deviceId = row.deviceId; // 直接设置响应式属性
  currentRow.slot = row.slot;
  window.localStorage.setItem('deviceId', row.deviceId)
  window.localStorage.setItem('slot', row.slot)
  add.value = true;
@@ -144,8 +144,8 @@
// 搜索
const searchout = async () => {
  try {
    const response = await request.post('/cacheVerticalGlass/bigStorageCageDetails/selectBigStorageCageDetails',{
      glassId:glassId.value
    const response = await request.post('/cacheVerticalGlass/bigStorageCageDetails/selectBigStorageCageDetails', {
      glassId: glassId.value
    });
    if (response.code == 200) {
      tableDataf.value = response.data;
@@ -158,371 +158,371 @@
};
// 是否禁用
const toggleEnableState = async (row) => {
  const newState = row.enableState === 1 ? 0 : 1;  
  var url="/cacheVerticalGlass/bigStorageCage/updateStorageCageDisabled?slot="+row.slot + "&enableState=" + newState;
      const response = await request.get(url) 
  const newState = row.enableState === 1 ? 0 : 1;
  var url = "/cacheVerticalGlass/bigStorageCage/updateStorageCageDisabled?slot=" + row.slot + "&enableState=" + newState;
  const response = await request.get(url)
  if (response.code === 200) {
      ElMessage.success(response.message);
      } else {  
      ElMessage.error(response.message);
      }  
  row.enableState = newState;  
}; 
    ElMessage.success(response.message);
  } else {
    ElMessage.error(response.message);
  }
  row.enableState = newState;
};
// 是否破损
const broken = async (row) => {
  try  {
  const newState = row.isDamage === 1 ? 0 : 1;
  const response = await request.post('/cacheVerticalGlass/bigStorageCageDetails/bigStorageGlassDamageByGlassId', { glassId: row.glassId });  
  try {
    const newState = row.isDamage === 1 ? 0 : 1;
    const response = await request.post('/cacheVerticalGlass/bigStorageCageDetails/bigStorageGlassDamageByGlassId', { glassId: row.glassId });
    if (response.code == 200) {
      ElMessage.success(response.message);
    } else {
      ElMessage.error(response.message);
    }
  row.isDamage = newState;   
}
catch (error) {
    row.isDamage = newState;
  }
  catch (error) {
  }
}
 // 删除 
 const opena = async(row) => {  
// 删除
const opena = async (row) => {
  try {
    const confirmResult = await ElMessageBox.confirm(  
      t('searchOrder.deletemessage'), 
      t('searchOrder.prompt'),  
      {  
        confirmButtonText: t('searchOrder.yes'), 
    const confirmResult = await ElMessageBox.confirm(
      t('searchOrder.deletemessage'),
      t('searchOrder.prompt'),
      {
        confirmButtonText: t('searchOrder.yes'),
        cancelButtonText: t('searchOrder.cancel'),
        type: 'warning',  
      } 
    ); 
        type: 'warning',
      }
    );
    if (confirmResult === 'confirm') {
      const response = await request.post("/cacheVerticalGlass/bigStorageCageDetails/deleteBigStorageCageDetails",row)
    if (response.code === 200) {
     tableDataa.value = response.data;
     ElMessage.success(response.message);
      const response = await request.post("/cacheVerticalGlass/bigStorageCageDetails/deleteBigStorageCageDetails", row)
      if (response.code === 200) {
        tableDataa.value = response.data;
        ElMessage.success(response.message);
      } else {
      ElMessage.error(response.message);
      }  
    }  
        ElMessage.error(response.message);
      }
    }
  } catch (error) {
  }  
}; 
 // 破损
 const broke = async(row) => {  
  }
};
// 破损
const broke = async (row) => {
  try {
    const confirmResult = await ElMessageBox.confirm(  
      t('searchOrder.broke'), 
      t('searchOrder.prompt'),  
      {  
        confirmButtonText: t('searchOrder.yes'), 
    const confirmResult = await ElMessageBox.confirm(
      t('searchOrder.broke'),
      t('searchOrder.prompt'),
      {
        confirmButtonText: t('searchOrder.yes'),
        cancelButtonText: t('searchOrder.cancel'),
        type: 'warning',  
      } 
    ); 
    if (confirmResult === 'confirm') {  
      const response = await request.post("/cacheVerticalGlass/bigStorageCageDetails/damageBigStorageCageDetails?status="+8, row)
    if (response.code === 200) {
     tableDataa.value = response.data;
     ElMessage.success(response.message);
      } else {  
      ElMessage.error(response.message);
      }  
    }  
        type: 'warning',
      }
    );
    if (confirmResult === 'confirm') {
      const response = await request.post("/cacheVerticalGlass/bigStorageCageDetails/damageBigStorageCageDetails?status=" + 8, row)
      if (response.code === 200) {
        tableDataa.value = response.data;
        ElMessage.success(response.message);
      } else {
        ElMessage.error(response.message);
      }
    }
  } catch (error) {
  }  
}; 
  }
};
// 历史任务
const iframeUrl = ref('');
const handlehistorical = (row) => {
  blindb.value = true;
  iframeUrl.value = `${window.location.origin}/#/Slicecage/slicecagehistory`;
};
 // 拿走
 const brokec = async(row) => {  
// 拿走
const brokec = async (row) => {
  try {
    const confirmResult = await ElMessageBox.confirm(  
      t('searchOrder.brokeb'), 
      t('searchOrder.prompt'),  
      {  
        confirmButtonText: t('searchOrder.yes'), 
    const confirmResult = await ElMessageBox.confirm(
      t('searchOrder.brokeb'),
      t('searchOrder.prompt'),
      {
        confirmButtonText: t('searchOrder.yes'),
        cancelButtonText: t('searchOrder.cancel'),
        type: 'warning',  
      } 
    ); 
    if (confirmResult === 'confirm') {  
      const response = await request.post("/cacheVerticalGlass/bigStorageCageDetails/damageBigStorageCageDetails?status="+9, row)
    if (response.code === 200) {
     tableDataa.value = response.data;
     ElMessage.success(response.message);
      } else {  
      ElMessage.error(response.message);
      }  
    }  
        type: 'warning',
      }
    );
    if (confirmResult === 'confirm') {
      const response = await request.post("/cacheVerticalGlass/bigStorageCageDetails/damageBigStorageCageDetails?status=" + 9, row)
      if (response.code === 200) {
        tableDataa.value = response.data;
        ElMessage.success(response.message);
      } else {
        ElMessage.error(response.message);
      }
    }
  } catch (error) {
  }  
}; 
 // 出片
 const outfil = async(row) => {  
  }
};
// 出片
const outfil = async (row) => {
  try {
    const confirmResult = await ElMessageBox.confirm(  
      t('searchOrder.outfil'), 
      t('searchOrder.prompt'),  
      {  
        confirmButtonText: t('searchOrder.yes'), 
    const confirmResult = await ElMessageBox.confirm(
      t('searchOrder.outfil'),
      t('searchOrder.prompt'),
      {
        confirmButtonText: t('searchOrder.yes'),
        cancelButtonText: t('searchOrder.cancel'),
        type: 'warning',  
      } 
    ); 
        type: 'warning',
      }
    );
    if (confirmResult === 'confirm') {
      const response = await request.post("/cacheVerticalGlass/bigStorageCageDetails/outBigStorageCageDetails", row)
    if (response.code === 200) {
      ElMessage.success(response.message);
      } else {  
      ElMessage.error(response.message);
      }  
    }  
      if (response.code === 200) {
        ElMessage.success(response.message);
      } else {
        ElMessage.error(response.message);
      }
    }
  } catch (error) {
  }  
}; 
 // 出片队列破损
 const brokea = async(row) => {  
  }
};
// 出片队列破损
const brokea = async (row) => {
  try {
    const confirmResult = await ElMessageBox.confirm(  
      t('searchOrder.broke'), 
      t('searchOrder.prompt'),  
      {  
        confirmButtonText: t('searchOrder.yes'), 
    const confirmResult = await ElMessageBox.confirm(
      t('searchOrder.broke'),
      t('searchOrder.prompt'),
      {
        confirmButtonText: t('searchOrder.yes'),
        cancelButtonText: t('searchOrder.cancel'),
        type: 'warning',  
      } 
    ); 
    if (confirmResult === 'confirm') {  
      const response = await request.post("/cacheVerticalGlass/temperingGlassInfo/damageTemperingGlassInfo?status="+8, row)
    if (response.code === 200) {
      ElMessage.success(response.message);
      } else {  
      ElMessage.error(response.message);
      }  
    }  
        type: 'warning',
      }
    );
    if (confirmResult === 'confirm') {
      const response = await request.post("/cacheVerticalGlass/temperingGlassInfo/damageTemperingGlassInfo?status=" + 8, row)
      if (response.code === 200) {
        ElMessage.success(response.message);
      } else {
        ElMessage.error(response.message);
      }
    }
  } catch (error) {
  }  
}; 
 // 指定钢化
 const brokee = async(row,temperingFeedSequence) => {  
  }
};
// 指定钢化
const brokee = async (row, temperingFeedSequence) => {
  try {
    const confirmResult = await ElMessageBox.confirm(  
      t('searchOrder.specifytemperinga'), 
      t('searchOrder.prompt'),  
      {  
        confirmButtonText: t('searchOrder.yes'), 
    const confirmResult = await ElMessageBox.confirm(
      t('searchOrder.specifytemperinga'),
      t('searchOrder.prompt'),
      {
        confirmButtonText: t('searchOrder.yes'),
        cancelButtonText: t('searchOrder.cancel'),
        type: 'warning',  
      } 
    ); 
    if (confirmResult === 'confirm') {  
      const response = await request.post("/cacheVerticalGlass/bigStorageCageDetails/TemperingGlass",{
        type: 'warning',
      }
    );
    if (confirmResult === 'confirm') {
      const response = await request.post("/cacheVerticalGlass/bigStorageCageDetails/TemperingGlass", {
        engineerId: row.engineerId,
        temperingLayoutId: row.temperingLayoutId,
        temperingFeedSequence:temperingFeedSequence
    });
    if (response.code === 200) {
      ElMessage.success(response.message);
      } else {  
      ElMessage.error(response.message);
      }  
    }  
        temperingFeedSequence: temperingFeedSequence
      });
      if (response.code === 200) {
        ElMessage.success(response.message);
      } else {
        ElMessage.error(response.message);
      }
    }
  } catch (error) {
  }  
  }
  handleganghua();
}; 
 // 指定工程
 const brokek = async(row) => {  
};
// 指定工程
const brokek = async (row) => {
  try {
    const confirmResult = await ElMessageBox.confirm(  
      t('searchOrder.specifytemperinga'), 
      t('searchOrder.prompt'),  
      {  
        confirmButtonText: t('searchOrder.yes'), 
    const confirmResult = await ElMessageBox.confirm(
      t('searchOrder.specifytemperinga'),
      t('searchOrder.prompt'),
      {
        confirmButtonText: t('searchOrder.yes'),
        cancelButtonText: t('searchOrder.cancel'),
        type: 'warning',  
      } 
    ); 
        type: 'warning',
      }
    );
    if (confirmResult === 'confirm') {
      const response = await request.post("/cacheVerticalGlass/bigStorageCageDetails/appointTemperingEngineerId?engineerId=" + row.engineerId);
    if (response.code === 200) {
      ElMessage.success(response.message);
      } else {  
      ElMessage.error(response.message);
      }  
    }  
      if (response.code === 200) {
        ElMessage.success(response.message);
      } else {
        ElMessage.error(response.message);
      }
    }
  } catch (error) {
  }  
}; 
  }
};
// 取消指定
const broked = async() => {  
const broked = async () => {
  try {
    const confirmResult = await ElMessageBox.confirm(  
      t('searchOrder.specifytemperinga'), 
      t('searchOrder.prompt'),  
      {  
        confirmButtonText: t('searchOrder.yes'), 
    const confirmResult = await ElMessageBox.confirm(
      t('searchOrder.specifytemperinga'),
      t('searchOrder.prompt'),
      {
        confirmButtonText: t('searchOrder.yes'),
        cancelButtonText: t('searchOrder.cancel'),
        type: 'warning',  
      } 
    ); 
    if (confirmResult === 'confirm') {  
        type: 'warning',
      }
    );
    if (confirmResult === 'confirm') {
      const response = await request.post("/cacheVerticalGlass/bigStorageCageDetails/cancelTemperingTask");
    if (response.code === 200) {
      ElMessage.success(response.message);
      } else {  
      ElMessage.error(response.message);
      }  
    }  
      if (response.code === 200) {
        ElMessage.success(response.message);
      } else {
        ElMessage.error(response.message);
      }
    }
  } catch (error) {
  }  
}; 
 // 指定流程卡
 const brokes = async(row) => {  
  }
};
// 指定流程卡
const brokes = async (row) => {
  try {
    const confirmResult = await ElMessageBox.confirm(  
      t('searchOrder.specifytemperinga'), 
      t('searchOrder.prompt'),  
      {  
        confirmButtonText: t('searchOrder.yes'), 
    const confirmResult = await ElMessageBox.confirm(
      t('searchOrder.specifytemperinga'),
      t('searchOrder.prompt'),
      {
        confirmButtonText: t('searchOrder.yes'),
        cancelButtonText: t('searchOrder.cancel'),
        type: 'warning',  
      } 
    ); 
    if (confirmResult === 'confirm') { 
      const response = await request.post("/cacheVerticalGlass/bigStorageCageDetails/appointFlowCard",{
        type: 'warning',
      }
    );
    if (confirmResult === 'confirm') {
      const response = await request.post("/cacheVerticalGlass/bigStorageCageDetails/appointFlowCard", {
        flowCardId: row.flow_card_id,
        layer: row.layer,
    });
    if (response.code === 200) {
      ElMessage.success(response.message);
      } else {  
      ElMessage.error(response.message);
      }  
    }  
      });
      if (response.code === 200) {
        ElMessage.success(response.message);
      } else {
        ElMessage.error(response.message);
      }
    }
  } catch (error) {
  }  
}; 
  }
};
// 出片队列拿走
const brokeb = async(row) => {  
const brokeb = async (row) => {
  try {
    const confirmResult = await ElMessageBox.confirm(  
      t('searchOrder.brokeb'), 
      t('searchOrder.prompt'),  
      {  
        confirmButtonText: t('searchOrder.yes'), 
    const confirmResult = await ElMessageBox.confirm(
      t('searchOrder.brokeb'),
      t('searchOrder.prompt'),
      {
        confirmButtonText: t('searchOrder.yes'),
        cancelButtonText: t('searchOrder.cancel'),
        type: 'warning',  
      } 
    ); 
    if (confirmResult === 'confirm') {  
      const response = await request.post("/cacheVerticalGlass/temperingGlassInfo/damageTemperingGlassInfo?status="+9, row)
    if (response.code === 200) {
      ElMessage.success(response.message);
      } else {  
      ElMessage.error(response.message);
      }  
    }  
        type: 'warning',
      }
    );
    if (confirmResult === 'confirm') {
      const response = await request.post("/cacheVerticalGlass/temperingGlassInfo/damageTemperingGlassInfo?status=" + 9, row)
      if (response.code === 200) {
        ElMessage.success(response.message);
      } else {
        ElMessage.error(response.message);
      }
    }
  } catch (error) {
  }  
}; 
  }
};
// 出片队列删除
const deletea = async(row) => {  
const deletea = async (row) => {
  try {
    const confirmResult = await ElMessageBox.confirm(  
      t('searchOrder.deletemessage'), 
      t('searchOrder.prompt'),  
      {  
        confirmButtonText: t('searchOrder.yes'), 
    const confirmResult = await ElMessageBox.confirm(
      t('searchOrder.deletemessage'),
      t('searchOrder.prompt'),
      {
        confirmButtonText: t('searchOrder.yes'),
        cancelButtonText: t('searchOrder.cancel'),
        type: 'warning',  
      } 
    ); 
    if (confirmResult === 'confirm') {  
      const dataToSend = {  
        type: 'warning',
      }
    );
    if (confirmResult === 'confirm') {
      const dataToSend = {
        ...row,
        status: 1
      };  
      };
      const response = await request.post("/cacheVerticalGlass/temperingGlassInfo/deleteTemperingGlassInfo", dataToSend)
    if (response.code === 200) {
      ElMessage.success(response.message);
      } else {  
      ElMessage.error(response.message);
      }  
    }  
      if (response.code === 200) {
        ElMessage.success(response.message);
      } else {
        ElMessage.error(response.message);
      }
    }
  } catch (error) {
  }  
}; 
  }
};
// 完成任务
const finish = async(row) => {  
const finish = async (row) => {
  try {
    const confirmResult = await ElMessageBox.confirm(  
      t('searchOrder.fin'), 
      t('searchOrder.prompt'),  
      {  
        confirmButtonText: t('searchOrder.yes'), 
    const confirmResult = await ElMessageBox.confirm(
      t('searchOrder.fin'),
      t('searchOrder.prompt'),
      {
        confirmButtonText: t('searchOrder.yes'),
        cancelButtonText: t('searchOrder.cancel'),
        type: 'warning',  
      } 
    ); 
    if (confirmResult === 'confirm') {  
        type: 'warning',
      }
    );
    if (confirmResult === 'confirm') {
      const response = await request.post("/cacheVerticalGlass/bigStorageCageDetails/finishBigStorageCageDetails", row)
    if (response.code === 200) {
      ElMessage.success(response.message);
      } else {  
      ElMessage.error(response.message);
      }  
    }  
      if (response.code === 200) {
        ElMessage.success(response.message);
      } else {
        ElMessage.error(response.message);
      }
    }
  } catch (error) {
  }  
}; 
  }
};
// 确认添加
const finisha = async(row) => {  
const finisha = async (row) => {
  try {
    const confirmResult = await ElMessageBox.confirm(  
      t('searchOrder.sureadda'), 
      t('searchOrder.prompt'),  
      {  
        confirmButtonText: t('searchOrder.yes'), 
    const confirmResult = await ElMessageBox.confirm(
      t('searchOrder.sureadda'),
      t('searchOrder.prompt'),
      {
        confirmButtonText: t('searchOrder.yes'),
        cancelButtonText: t('searchOrder.cancel'),
        type: 'warning',  
      } 
    ); 
    if (confirmResult === 'confirm') {  
    let deviceId = window.localStorage.getItem('deviceId')
    let slot = window.localStorage.getItem('slot')
      const dataToSend = {  
        type: 'warning',
      }
    );
    if (confirmResult === 'confirm') {
      let deviceId = window.localStorage.getItem('deviceId')
      let slot = window.localStorage.getItem('slot')
      const dataToSend = {
        ...row,
        deviceId: deviceId,
        slot: slot
      };  
  const response = await request.post("/cacheVerticalGlass/bigStorageCageDetails/insertBigStorageCageDetails", dataToSend)
    if (response.code === 200) {
      tableDataa.value = response.data;
      add.value = false;
      ElMessage.success(response.message);
      glassId.value = '';
      tableDataf.value = '';
 
      } else {  
      ElMessage.error(response.message);
      }  
    }  
      };
      const response = await request.post("/cacheVerticalGlass/bigStorageCageDetails/insertBigStorageCageDetails", dataToSend)
      if (response.code === 200) {
        tableDataa.value = response.data;
        add.value = false;
        ElMessage.success(response.message);
        glassId.value = '';
        tableDataf.value = '';

      } else {
        ElMessage.error(response.message);
      }
    }
  } catch (error) {
  }  
  }
};
const handleganghua = () => {
  dialogFormVisiblec.value = true;
  fetchFlow(); 
  fetchFlow();
};
const handlexiang = () => {
  isLoading.value = true;  // 开启加载状态
  dialogFormVisiblea.value = true;
  fetchxiang(); 
  fetchxiang();
  currentPage2.value = 1;
  window.localStorage.setItem('pagenumber', currentPage2.value)
  filmsId.value = ''
@@ -531,13 +531,13 @@
// 缺片数量
const handlelack = (row) => {
  const { engineerId, temperingLayoutId } = row;
  fetchlack(engineerId, temperingLayoutId); 
  fetchlack(engineerId, temperingLayoutId);
  dialogFormVisibled.value = true;
};
// 笼内详情
const handlecagedetails = (row) => {
  const { engineerId, temperingLayoutId } = row;
  fetchcagedetails(engineerId, temperingLayoutId); 
  fetchcagedetails(engineerId, temperingLayoutId);
  dialogFormVisiblef.value = true;
};
// 警报双击弹窗
@@ -552,44 +552,44 @@
    overSize: 'hellow.overSize',
    noGlass: 'hellow.noGlass'
  };
  return alarmCode in codeMap 
    ? t(codeMap[alarmCode]) 
  return alarmCode in codeMap
    ? t(codeMap[alarmCode])
    : t('hellow.unknownAlert');
};
// 钢化查询
onMounted(async () => {  
  try {  
    var url="/cacheVerticalGlass/bigStorageCageDetails/selectTemperingGlass?isTempering="+1;
onMounted(async () => {
  try {
    var url = "/cacheVerticalGlass/bigStorageCageDetails/selectTemperingGlass?isTempering=" + 1;
    const response = await request.post(url)
    if (response.code === 200) {  
    if (response.code === 200) {
      ElMessage.success(response.message);
      tableDatagh.value = response.data
    } else {  
    } else {
      ElMessage.warning(response.msg)
    }  
    }
  } catch (error) {
  }
}); 
});
// 理片笼信息
const fetchxiang = async () => {
    isLoading.value = true;
  isLoading.value = true;
  try {
    const response = await request.post('/cacheVerticalGlass/bigStorageCageDetails/queryVerticalSheetCageDetailsList',{
        // deviceId: page,
        engineerId: engineerId.value,
        filmsId: filmsId.value,
        flowCardId: flowCardId.value,
        glassId: glassId.value,
        thickness: -1,
    const response = await request.post('/cacheVerticalGlass/bigStorageCageDetails/queryVerticalSheetCageDetailsList', {
      // deviceId: page,
      engineerId: engineerId.value,
      filmsId: filmsId.value,
      flowCardId: flowCardId.value,
      glassId: glassId.value,
      thickness: -1,
    })
    // 模拟最小加载时间
    await new Promise(resolve => setTimeout(resolve, 300));
    if (response.code === 200) {
      ElMessage.success(response.message);
      tableDataa.value = response.data
    } else {  
    } else {
      ElMessage.warning(response.msg)
    }  
    }
  } catch (error) {
  } finally {
    isLoading.value = false;
@@ -598,46 +598,46 @@
}
const fetchxianga = async () => {
  let page = window.localStorage.getItem('pagenumber')
  try {     
    const response = await request.post('/cacheVerticalGlass/bigStorageCageDetails/queryVerticalSheetCageDetailsList',{
        deviceId: page,
        engineerId: engineerId.value,
        filmsId: filmsId.value,
        flowCardId: flowCardId.value,
        glassId: glassId.value,
        thickness: thickness.value ? thickness.value : -1,
  try {
    const response = await request.post('/cacheVerticalGlass/bigStorageCageDetails/queryVerticalSheetCageDetailsList', {
      deviceId: page,
      engineerId: engineerId.value,
      filmsId: filmsId.value,
      flowCardId: flowCardId.value,
      glassId: glassId.value,
      thickness: thickness.value ? thickness.value : -1,
    })
    if (response.code === 200) {  
    if (response.code === 200) {
      ElMessage.success(response.message);
      tableDataa.value = response.data
      // filmsId.value = ''
      // flowCardId.value = ''
    } else {  
    } else {
      ElMessage.warning(response.msg)
    }  
    }
  } catch (error) {
  } 
  }
}
// 非钢化流程卡
const fetchFlows = async () => {
  try {  
    var url="/cacheVerticalGlass/bigStorageCageDetails/selectTemperingGlass?isTempering="+0;
  try {
    var url = "/cacheVerticalGlass/bigStorageCageDetails/selectTemperingGlass?isTempering=" + 0;
    const response = await request.post(url)
    if (response.code === 200) {  
    if (response.code === 200) {
      ElMessage.success(response.message);
      tableDatas.value = response.data
    } else {  
    } else {
      ElMessage.warning(response.msg)
    }  
    }
  } catch (error) {
  } 
  }
}
// 缺片数量
const fetchlack = async (engineerId, temperingLayoutId) => {
  try  {
    const response = await request.post('/cacheVerticalGlass/bigStorageCageDetails/queryLackGlassInfo',{
        engineerId: engineerId,
        temperingLayoutId: temperingLayoutId,
  try {
    const response = await request.post('/cacheVerticalGlass/bigStorageCageDetails/queryLackGlassInfo', {
      engineerId: engineerId,
      temperingLayoutId: temperingLayoutId,
    })
    if (response.code == 200) {
      ElMessage.success(response.message);
@@ -645,17 +645,17 @@
    } else {
      ElMessage.error(response.message);
    }
}
catch (error) {
  }
  catch (error) {
    // 处理错误
  }
}
// 笼内详情
const fetchcagedetails = async (engineerId, temperingLayoutId) => {
  try  {
    const response = await request.post('/cacheVerticalGlass/bigStorageCageDetails/queryRealGlassInfo',{
        engineerId: engineerId,
        temperingLayoutId: temperingLayoutId,
  try {
    const response = await request.post('/cacheVerticalGlass/bigStorageCageDetails/queryRealGlassInfo', {
      engineerId: engineerId,
      temperingLayoutId: temperingLayoutId,
    })
    if (response.code == 200) {
      ElMessage.success(response.message);
@@ -663,13 +663,13 @@
    } else {
      ElMessage.error(response.message);
    }
}
catch (error) {
  }
  catch (error) {
  }
}
const fetchFlow = async () => {
  try  {
    var url="/cacheVerticalGlass/bigStorageCageDetails/selectTemperingGlass?isTempering="+1;
  try {
    var url = "/cacheVerticalGlass/bigStorageCageDetails/selectTemperingGlass?isTempering=" + 1;
    const response = await request.post(url)
    if (response.code == 200) {
      ElMessage.success(response.message);
@@ -677,60 +677,60 @@
      temperingtotal.value = response.data.length
      let totalCount = 0;
      let fullCount = 0;
      response.data.forEach(item => { 
      response.data.forEach(item => {
        totalCount += item.realCount || 0;
        if(item.lackCount==0){
          fullCount+=1;
        if (item.lackCount == 0) {
          fullCount += 1;
        }
      });
      glasstotal.value = totalCount;
      fulltotals.value = fullCount;
 

    } else {
      ElMessage.error(response.message);
    }
}
catch (error) {
  }
  catch (error) {
  }
}
function handleRowClick(row) {  
function handleRowClick(row) {
  selectedRow.value = row; // 更新选中的行数据  
}  
}
// 钢化开关
  const handleChange = async () => {
  try  {
    const body = {  
const handleChange = async () => {
  try {
    const body = {
      flag: ganghua.value,
    }; 
    
    var url="/cacheVerticalGlass/bigStorageCageDetails/temperingSwitch?flag="+ganghua.value;
  const response = await request.post(url)
    };

    var url = "/cacheVerticalGlass/bigStorageCageDetails/temperingSwitch?flag=" + ganghua.value;
    const response = await request.post(url)
    if (response.code == 200) {
      ElMessage.success(response.message);
      ganghua.value = response.data
    }else {  
    } else {
      ElMessage.error(response.message);
      }  
}
catch (error) {
    }
  }
  catch (error) {
  }
}
// 调度开关
const handlediaodu = async () => {
  try  {
    const body = {  
  try {
    const body = {
      flag: diaodu.value,
    };
    var url="/cacheVerticalGlass/bigStorageCageDetails/dispatchSwitch?flag="+diaodu.value;
  const response = await request.post(url)
    var url = "/cacheVerticalGlass/bigStorageCageDetails/dispatchSwitch?flag=" + diaodu.value;
    const response = await request.post(url)
    if (response.code == 200) {
      ElMessage.success(response.message);
      diaodu.value = response.data
    }else {  
    } else {
      ElMessage.error(response.message);
      }  
}
catch (error) {
    }
  }
  catch (error) {
  }
}
// 任务重置
@@ -789,40 +789,40 @@
const socketUrl = `ws://${window.ipConfig.serverUrl}/api/cacheVerticalGlass/api/talk/slicecage`;
const handleMessage = (data) => {
  // 报警信息
if (data.alarmInfo[0] != null && data.alarmInfo[0].length > 0) {
  const alert = data.alarmInfo[0];
  const { id, alarmMessage, ...rest } = alert[0];
  alertMessage.value = `${alarmMessage}`;
  alertMessage.value = `${alert[0].alarmMessage}`;
  if (alert[0].alarmCode === 'sizeSame') {
    alertText.value = t('hellow.sizeSame');
  } else if (alert[0].alarmCode === 'idSame') {
    alertText.value = t('hellow.idSame');
  } else if (alert[0].alarmCode === 'slotLess') {
    alertText.value = t('hellow.slotLess');
  } else if (alert[0].alarmCode === 'overSize') {
    alertText.value = t('hellow.overSize');
  } else if (alert[0].alarmCode === 'noGlass') {
    alertText.value = t('hellow.noGlass');
  } else {
    alertText.value = t('hellow.unknownAlert');
  }
  if (data.alarmInfo[0] != null && data.alarmInfo[0].length > 0) {
    const alert = data.alarmInfo[0];
    const { id, alarmMessage, ...rest } = alert[0];
    alertMessage.value = `${alarmMessage}`;
    alertMessage.value = `${alert[0].alarmMessage}`;
    if (alert[0].alarmCode === 'sizeSame') {
      alertText.value = t('hellow.sizeSame');
    } else if (alert[0].alarmCode === 'idSame') {
      alertText.value = t('hellow.idSame');
    } else if (alert[0].alarmCode === 'slotLess') {
      alertText.value = t('hellow.slotLess');
    } else if (alert[0].alarmCode === 'overSize') {
      alertText.value = t('hellow.overSize');
    } else if (alert[0].alarmCode === 'noGlass') {
      alertText.value = t('hellow.noGlass');
    } else {
      alertText.value = t('hellow.unknownAlert');
    }
    alarmData.value = data; // 存储完整数据用于弹窗
    showAlert.value = true;
}
   const formattedData = data.alarmInfo[0].map(record => ({
     ...record,
     formattedCreateTime: formatTimestamp(record.createTime),
     alarmCode: record.alarmCode,
     alarmMessage: record.alarmMessage
   }));
    tableDataAlert.value = formattedData;
  }
  const formattedData = data.alarmInfo[0].map(record => ({
    ...record,
    formattedCreateTime: formatTimestamp(record.createTime),
    alarmCode: record.alarmCode,
    alarmMessage: record.alarmMessage
  }));
  tableDataAlert.value = formattedData;

  if(data.bigStorageSummary!=null){
  if (data.bigStorageSummary != null) {
    tableDatass.value = data.bigStorageSummary[0]
  }else{
  } else {
    tableDatass.value = ''
      }
  }
  if (data.inkageEntity != null) {
    inkageEntity.value = data.inkageEntity[0] == true ? 'green' : '#911005';
  }
@@ -838,7 +838,7 @@
  if (data.outRequestEntity != null) {
    outRequestEntity.value = data.outRequestEntity == 1 ? 'green' : '#911005';
  }
    if (data.scanGlass != null) {
  if (data.scanGlass != null) {
    scanGlass.value = data.scanGlass[0];
    let width = scanGlass.value.width;
    let height = scanGlass.value.height;
@@ -851,104 +851,74 @@
    }
  }
  //当前指定工程
  if(data.temperingEngineerId!=null){
    temperingengineerId.value=data.temperingEngineerId[0];
  if (data.temperingEngineerId != null) {
    temperingengineerId.value = data.temperingEngineerId[0];
  }
  if(data.bigStorageCageDetailsOutTask!=null){
  if (data.bigStorageCageDetailsOutTask != null) {
    tableDatac.value = data.bigStorageCageDetailsOutTask[0]
    adjusta.value = data.bigStorageCageDetailsOutTask[0].filter(rect => rect.slot !== null && rect.slot !== undefined);
  } else {
    tableDatac.value = '',
    adjusta.value = ''
      adjusta.value = ''
  }
  if(data.bigStorageCageDetailsFeedTask!=null){
  if (data.bigStorageCageDetailsFeedTask != null) {
    tableDatax.value = data.bigStorageCageDetailsFeedTask[0]
  } else {
    tableDatax.value = ''
  }
  if(data.bigStorageCageDetailsFeedTask!=null){
  if (data.bigStorageCageDetailsFeedTask != null) {
    tableDatad.value = data.bigStorageCageDetailsFeedTask[0]
    adjust.value = data.bigStorageCageDetailsFeedTask[0].filter(rect => rect.slot !== null && rect.slot !== undefined); 
  }else{
    adjust.value = data.bigStorageCageDetailsFeedTask[0].filter(rect => rect.slot !== null && rect.slot !== undefined);
  } else {
    tableDatad.value = ''
      }
if(data.temperingGlassInfoList!=null){
  tableDatab.value = data.temperingGlassInfoList[0]
}else{
  }
  if (data.temperingGlassInfoList != null) {
    tableDatab.value = data.temperingGlassInfoList[0]
  } else {
    tableDatab.value = ''
      }
if(data.bigStorageCageUsage!=null){
  tableDatae.value = data.bigStorageCageUsage[0]
}else{
  }
  if (data.bigStorageCageUsage != null) {
    tableDatae.value = data.bigStorageCageUsage[0]
  } else {
    tableDatae.value = ''
      }
if(data.carPostion!=null){
  carPosition.value = data.carPostion[0]
}else{
  carPosition.value = ''
  }
if(data.temperingSwitch!=null){
  ganghua.value = data.temperingSwitch[0]
}else{
  ganghua.value = ''
  if (data.carPostion != null) {
    carPosition.value = data.carPostion[0]
  } else {
    carPosition.value = ''
  }
if(data.dispatchSwitch!=null){
  diaodu.value = data.dispatchSwitch[0]
}else{
  diaodu.value = ''
  if (data.temperingSwitch != null) {
    ganghua.value = data.temperingSwitch[0]
  } else {
    ganghua.value = ''
  }
  if(data.bigStorageCageInfos!=null){
  adjustedRects.value = data.bigStorageCageInfos[0][1].map((rect, index) => ({
    id: index + 1,
    height: 20/55,
    top: 53/55,
  }));
subRectsCounts.value = data.bigStorageCageInfos[0][1].map(rect => rect.count);
adjustedRectsa.value = data.bigStorageCageInfos[0][2].map((rect, index) => ({
    id: index + 1,
    height: 20/55,
    top: 53/55,
  }));
subRectsCountsa.value = data.bigStorageCageInfos[0][2].map(rect => rect.count);
adjustedRectsb.value = data.bigStorageCageInfos[0][3].map((rect, index) => ({
    id: index + 1,
    height: 20/55,
    top: 53/55,
  }));
subRectsCountsb.value = data.bigStorageCageInfos[0][3].map(rect => rect.count);
adjustedRectsc.value = data.bigStorageCageInfos[0][4].map((rect, index) => ({
    id: index + 1,
    height: 20/55,
    top: 53/55,
  }));
subRectsCountsc.value = data.bigStorageCageInfos[0][4].map(rect => rect.count);
adjustedRectsd.value = data.bigStorageCageInfos[0][5].map((rect, index) => ({
    id: index + 1,
    height: 20/55,
    top: 53/55,
  }));
subRectsCountsd.value = data.bigStorageCageInfos[0][5].map(rect => rect.count);
adjustedRectse.value = data.bigStorageCageInfos[0][6].map((rect, index) => ({
    id: index + 1,
    height: 20/55,
    top: 53/55,
  }));
subRectsCountse.value = data.bigStorageCageInfos[0][6].map(rect => rect.count);
  }else{
  if (data.dispatchSwitch != null) {
    diaodu.value = data.dispatchSwitch[0]
  } else {
    diaodu.value = ''
  }
  if (data.bigStorageCageInfos != null) {
    adjustedRects.value = data.bigStorageCageInfos[0][1];
    adjustedRectsa.value = data.bigStorageCageInfos[0][2];
    adjustedRectsb.value = data.bigStorageCageInfos[0][3];
    adjustedRectsc.value = data.bigStorageCageInfos[0][4];
    adjustedRectsd.value = data.bigStorageCageInfos[0][5];
    adjustedRectse.value = data.bigStorageCageInfos[0][6];
  } else {
    adjustedRects.value = '',
    adjustedRectsa.value = '',
    adjustedRectsb.value = '',
    adjustedRectsc.value = '',
    adjustedRectsd.value = '',
    adjustedRectse.value = ''
      adjustedRectsa.value = '',
      adjustedRectsb.value = '',
      adjustedRectsc.value = '',
      adjustedRectsd.value = '',
      adjustedRectse.value = ''
  }
};
// 计算每个大矩形的样式
const rectStyle = (rect, index) => ({
const rectStyle = (rect, index, high) => ({
  position: 'absolute',
  width: '170px',
  right: '0px',
  top: `${index*rect.top}px`,
  top: `${index * high}px`,
  height: `${rect.height}px`,
});
// 计算每个小矩形的样式和数量
@@ -960,18 +930,19 @@
  }
  return subRects;
};
const proportion=ref((170/6200).toFixed(2));
// 计算每个小矩形的样式
const subRectStyle = (rectIndex, subIndex) => {
  const width = '18px';
  const marginRight = '8px';
  const width = `${rectIndex.length* proportion.value}px`;
  const marginRight = '6.85px';
  const totalWidth = 6 * (parseInt(width) + parseInt(marginRight));
  const right = `${(subIndex * (parseInt(width) + parseInt(marginRight))) / totalWidth * 100}%`;
  return {
    position: 'absolute',
    width,
    height: '100%',
    height: '1px',
    marginRight,
    top: '0px',
    top: '1px',
    backgroundColor: '#911005',
    right,
  };
@@ -981,7 +952,7 @@
  position: 'absolute',
  width: '170px',
  right: '0px',
  top: `${index*rect.top}px`,
  top: `${index * rect.top}px`,
  height: `${rect.height}px`,
});
// 计算每个小矩形的样式和数量
@@ -1014,7 +985,7 @@
  position: 'absolute',
  width: '170px',
  right: '0px',
  top: `${index*rect.top}px`,
  top: `${index * rect.top}px`,
  height: `${rect.height}px`,
});
// 计算每个小矩形的样式和数量
@@ -1047,7 +1018,7 @@
  position: 'absolute',
  width: '170px',
  right: '0px',
  top: `${index*rect.top}px`,
  top: `${index * rect.top}px`,
  height: `${rect.height}px`,
});
// 计算每个小矩形的样式和数量
@@ -1064,7 +1035,7 @@
  position: 'absolute',
  width: '170px',
  right: '0px',
  top: `${index*rect.top}px`,
  top: `${index * rect.top}px`,
  height: `${rect.height}px`,
});
// 计算每个小矩形的样式和数量
@@ -1081,7 +1052,7 @@
  position: 'absolute',
  width: '170px',
  right: '0px',
  top: `${index*rect.top}px`,
  top: `${index * rect.top}px`,
  height: `${rect.height}px`,
});
// 计算每个小矩形的样式和数量
@@ -1150,65 +1121,65 @@
  timeRange.value = [formatTimestamp(oneWeekAgo), formatTimestamp(backendTime)];
  window.localStorage.setItem('startTime', formatTimestamp(oneWeekAgo))
}
  onMounted(() => {
onMounted(() => {
  socket = initializeWebSocket(socketUrl, handleMessage);
  parseAndSetTime();
  selectGong()
});
  onUnmounted(() => {
    if (socket) {
onUnmounted(() => {
  if (socket) {
    closeWebSocket(socket);
    }
    });
function getStatusTypea(ishorizontal: number) {  
  switch (ishorizontal) {  
  }
});
function getStatusTypea(ishorizontal: number) {
  switch (ishorizontal) {
    case 0:
      return 'warning';  
    case 1: 
      return 'success';  
  }  
}  
      return 'warning';
    case 1:
      return 'success';
  }
}
function getStatusTexta(ishorizontal: number) {
  switch (ishorizontal) {
    case 0:  
      return t('searchOrder.noaccept');
    case 1:  
    return t('searchOrder.accept');
  }  
}
function getStatusTypeb(state: number) {  
  switch (state) {  
    case 0:
      return 'success';  
    case 1: 
      return 'primary';  
  }  
}  
      return t('searchOrder.noaccept');
    case 1:
      return t('searchOrder.accept');
  }
}
function getStatusTypeb(state: number) {
  switch (state) {
    case 0:
      return 'success';
    case 1:
      return 'primary';
  }
}
function getStatusTextb(state: number) {
  switch (state) {
    case 0:  
    case 0:
      return t('searchOrder.filmcomplete');
    case 1:  
      return t('searchOrder.waiting');
    case 2:  
    return t('searchOrder.waiting');
  }  
}
function getcasOnea(isSame) {  
  switch (isSame) {  
    case 1:
      return 'danger';  
    case 0: 
      return 'info';  
  }  
}  
      return t('searchOrder.waiting');
    case 2:
      return t('searchOrder.waiting');
  }
}
function getcasOnea(isSame) {
  switch (isSame) {
    case 1:
      return 'danger';
    case 0:
      return 'info';
  }
}
function getStatuscasOnea(isSame) {
  switch (isSame) {
    case 1:  
    case 1:
      return t('searchOrder.same');
    case 0:  
      return t('searchOrder.notsame'); 
  }  
    case 0:
      return t('searchOrder.notsame');
  }
}
function tableRowClassName({ row }) {
  if (row.isSame === 1) {
@@ -1244,355 +1215,307 @@
<template>
  <div style="height: 600px;">
    <div v-if="showAlert" class="global-alert-bar" @dblclick="handleDoubleClick">
    <div class="alert-content">
      <el-icon><WarnTriangleFilled /></el-icon>
      <span class="alert-text">
        {{ alertText }} (id:{{ alertMessage }})
        <span class="confirm-text">{{ $t('hellow.pleaseConfirm') }}</span>
      </span>
      <div class="alert-content">
        <el-icon>
          <WarnTriangleFilled />
        </el-icon>
        <span class="alert-text">
          {{ alertText }} (id:{{ alertMessage }})
          <span class="confirm-text">{{ $t('hellow.pleaseConfirm') }}</span>
        </span>
      </div>
      <button @click="showAlert = false" class="close-btn">×</button>
    </div>
    <button @click="showAlert = false" class="close-btn">×</button>
  </div>
  <el-dialog
    v-model="showModal"
    width="40%"
    center
  >
      <el-table 
      ref="table"
      border
      :data="tableDataAlert" 
      max-height="calc(500px - 35px)"
      style="width: 100%;"
    >
      <el-table-column prop="formattedCreateTime" align="center" :label="$t('film.createtime')" min-width="100" />
      <el-table-column
       :label="$t('hellow.content')" 
       align="center" 
       min-width="220"
     >
       <template #default="scope">
           <span>
             {{ getAlertText(scope.row.alarmCode) }} 
             (id:{{ scope.row.alarmMessage }})
           </span>
       </template>
     </el-table-column>
      <el-table-column fixed="right" :label="$t('film.operate')" align="center" width="100">
        <template #default="scope">
          <el-button type="text" plain
            @click="handleSure(scope.row)">{{ $t('basicData.yes') }}</el-button>
        </template>
      </el-table-column>
    </el-table>
  </el-dialog>
    <el-button style="margin-top: 7px;margin-left: 10px;" id="searchButton" type="primary" @click="handlexiang">{{ $t('searchOrder.cageinformation') }}</el-button>
    <el-button style="margin-top: 7px;margin-left: 10px;" id="searchButton" type="success" @click="handlehistorical">{{ $t('searchOrder.historicaltasks') }}</el-button>
    <el-button style="margin-top: 7px;margin-left: 10px;" id="searchButton" type="warning" @click="handleganghua">{{ $t('searchOrder.temperingqueries') }}</el-button>
    <el-button style="margin-top: 7px;margin-left: 10px;" id="searchButton" type="info" @click="dialogFormVisibles=true;fetchFlows()">{{ $t('searchOrder.searchlayout') }}</el-button>
    <el-dialog v-model="showModal" width="40%" center>
      <el-table ref="table" border :data="tableDataAlert" max-height="calc(500px - 35px)" style="width: 100%;">
        <el-table-column prop="formattedCreateTime" align="center" :label="$t('film.createtime')" min-width="100" />
        <el-table-column :label="$t('hellow.content')" align="center" min-width="220">
          <template #default="scope">
            <span>
              {{ getAlertText(scope.row.alarmCode) }}
              (id:{{ scope.row.alarmMessage }})
            </span>
          </template>
        </el-table-column>
        <el-table-column fixed="right" :label="$t('film.operate')" align="center" width="100">
          <template #default="scope">
            <el-button type="text" plain @click="handleSure(scope.row)">{{ $t('basicData.yes') }}</el-button>
          </template>
        </el-table-column>
      </el-table>
    </el-dialog>
    <el-button style="margin-top: 7px;margin-left: 10px;" id="searchButton" type="primary" @click="handlexiang">{{
      $t('searchOrder.cageinformation') }}</el-button>
    <el-button style="margin-top: 7px;margin-left: 10px;" id="searchButton" type="success" @click="handlehistorical">{{
      $t('searchOrder.historicaltasks') }}</el-button>
    <el-button style="margin-top: 7px;margin-left: 10px;" id="searchButton" type="warning" @click="handleganghua">{{
      $t('searchOrder.temperingqueries') }}</el-button>
    <el-button style="margin-top: 7px;margin-left: 10px;" id="searchButton" type="info"
      @click="dialogFormVisibles = true; fetchFlows()">{{ $t('searchOrder.searchlayout') }}</el-button>
    <!-- <el-button style="margin-top: 7px;margin-left: 10px;" id="searchButton" type="danger" @click="handleptask()">{{ $t('searchOrder.partask') }}</el-button> -->
    <el-switch style="margin-top: 7px;margin-left: 10px;" v-model="ganghua" class="mb-2" :inactive-text="$t('searchOrder.temperedswitch')" @change="handleChange" />
    <el-switch style="margin-top: 7px;margin-left: 10px;" v-model="diaodu" class="mb-2" :inactive-text="$t('searchOrder.Schedulingswitch')" @change="handlediaodu" />
    <el-switch style="margin-top: 7px;margin-left: 10px;" v-model="ganghua" class="mb-2"
      :inactive-text="$t('searchOrder.temperedswitch')" @change="handleChange" />
    <el-switch style="margin-top: 7px;margin-left: 10px;" v-model="diaodu" class="mb-2"
      :inactive-text="$t('searchOrder.Schedulingswitch')" @change="handlediaodu" />
    <div id="dotClass">
        <div>{{ $t('searchOrder.inkageEntity') }}</div>
        <i :style="{ marginTop: '2px', backgroundColor: inkageEntity, width: '18px', height: '18px', borderRadius: '50%', display: 'block' }"></i>
        <div style="margin-left: 70px;">{{ $t('searchOrder.requestEntity') }}</div>
        <i :style="{ marginTop: '2px', backgroundColor: requestEntity, width: '18px', height: '18px', borderRadius: '50%', display: 'block' }"></i>
        <div style="margin-left: 70px;">{{ $t('searchOrder.mesReplyEntity') }}</div>
        <i :style="{ marginTop: '2px', backgroundColor: mesReplyEntity, width: '18px', height: '18px', borderRadius: '50%', display: 'block' }"></i>
        <div style="margin-left: 70px;">{{ $t('searchOrder.outInkageEntity') }}</div>
        <i :style="{ marginTop: '2px', backgroundColor: outInkageEntity, width: '18px', height: '18px', borderRadius: '50%', display: 'block' }"></i>
        <div style="margin-left: 70px;">{{ $t('searchOrder.outRequestEntity') }}</div>
        <i :style="{ marginTop: '2px', backgroundColor: outRequestEntity, width: '18px', height: '18px', borderRadius: '50%', display: 'block' }"></i>
  </div>
<!-- // 父级框 -->
<div class="img-dlpl" >
    <div class="img-car1" :style="'z-index:999;left:240px;top:' + 350*carPosition[0] + 'px;position:absolute;'">
      <div  
      v-for="(rect, index) in adjusta"  
      :key="rect.id"  
      :style="{
       width: '30px',
       height: '5px',
       backgroundColor: '#409EFF',
       marginLeft: 5+ `px`,
       top: '10px',
       }"  
    >
      <div>{{ $t('searchOrder.inkageEntity') }}</div>
      <i
        :style="{ marginTop: '2px', backgroundColor: inkageEntity, width: '18px', height: '18px', borderRadius: '50%', display: 'block' }"></i>
      <div style="margin-left: 70px;">{{ $t('searchOrder.requestEntity') }}</div>
      <i
        :style="{ marginTop: '2px', backgroundColor: requestEntity, width: '18px', height: '18px', borderRadius: '50%', display: 'block' }"></i>
      <div style="margin-left: 70px;">{{ $t('searchOrder.mesReplyEntity') }}</div>
      <i
        :style="{ marginTop: '2px', backgroundColor: mesReplyEntity, width: '18px', height: '18px', borderRadius: '50%', display: 'block' }"></i>
      <div style="margin-left: 70px;">{{ $t('searchOrder.outInkageEntity') }}</div>
      <i
        :style="{ marginTop: '2px', backgroundColor: outInkageEntity, width: '18px', height: '18px', borderRadius: '50%', display: 'block' }"></i>
      <div style="margin-left: 70px;">{{ $t('searchOrder.outRequestEntity') }}</div>
      <i
        :style="{ marginTop: '2px', backgroundColor: outRequestEntity, width: '18px', height: '18px', borderRadius: '50%', display: 'block' }"></i>
    </div>
    <!-- // 父级框 -->
    <div class="img-dlpl">
      <div class="img-car1" :style="'z-index:999;left:240px;top:' + 350 * carPosition[0] + 'px;position:absolute;'">
        <div v-for="(rect, index) in adjusta" :key="rect.id" :style="{
          width: '30px',
          height: '5px',
          backgroundColor: '#409EFF',
          marginLeft: 5 + `px`,
          top: '10px',
        }">
        </div>
      </div>
      <div class="img-car4" :style="'z-index:999;left:630px;top:' + 350 * carPosition[1] + 'px;position:absolute;'">
        <div v-for="(rect, index) in adjust" :key="rect.id" :style="{
          width: '30px',
          height: '5px',
          backgroundColor: '#409EFF',
          marginLeft: 5 + `px`,
          top: '10px',
        }">
        </div>
      </div>
      <div style="position: relative;">
        <div v-show="cell1" style="width: 170px;height: 53px;position: relative;top:63px;left: 445px;">
          <div v-for="(rect, rectIndex) in Object.values(adjustedRects)" :key="rect.id" :style="rectStyle(rect, rectIndex, 1)">
            <div v-for="(subRect, subIndex) in rect" :key="subIndex"
              :style="subRectStyle(subRect, subIndex)"></div>
          </div>
        </div>
        <div v-show="cell2" style="width: 170px;height: 53px;position: relative;top:70px;left: 445px;">
          <div v-for="(rect, rectIndex) in Object.values(adjustedRectsa)" :key="rect.id" :style="rectStyle(rect, rectIndex, 1)">
            <div v-for="(subRect, subIndex) in rect" :key="subIndex"
              :style="subRectStyle(subRect, subIndex)"></div>
          </div>
        </div>
        <div v-show="cell3" style="width: 170px;height: 53px;position: relative;top:76px;left: 445px;">
          <div v-for="(rect, rectIndex) in Object.values(adjustedRectsb)" :key="rect.id" :style="rectStyle(rect, rectIndex, 1)">
            <div v-for="(subRect, subIndex) in rect" :key="subIndex"
              :style="subRectStyle(subRect, subIndex)"></div>
          </div>
        </div>
        <div v-show="cell4" style="width: 170px;height: 53px;position: relative;top:84px;left: 445px;">
          <div v-for="(rect, rectIndex) in Object.values(adjustedRectsc)" :key="rect.id" :style="rectStyle(rect, rectIndex, 1)">
            <div v-for="(subRect, subIndex) in rect" :key="subIndex"
              :style="subRectStyle(subRect, subIndex)"></div>
          </div>
        </div>
        <div v-show="cell5" style="width: 170px;height: 53px;position: relative;top:-16px;left: 45px;">
          <div v-for="(rect, rectIndex) in Object.values(adjustedRectsd)" :key="rect.id" :style="rectStyle(rect, rectIndex, 2.12)">
            <div v-for="(subRect, subIndex) in rect" :key="subIndex"
              :style="subRectStyle(subRect, subIndex)"></div>
          </div>
        </div>
        <div v-show="cell6" style="width: 170px;height: 53px;position: relative;top:-6px;left: 45px;">
          <div v-for="(rect, rectIndex) in Object.values(adjustedRectse)" :key="rect.id" :style="rectStyle(rect, rectIndex, 2.12)">
            <div v-for="(subRect, subIndex) in rect" :key="subIndex"
              :style="subRectStyle(subRect, subIndex)"></div>
          </div>
        </div>
      </div>
    </div>
    <div class="img-car4" :style="'z-index:999;left:630px;top:' + 350*carPosition[1] + 'px;position:absolute;'">
      <div  
      v-for="(rect, index) in adjust"  
      :key="rect.id"  
      :style="{
       width: '30px',
       height: '5px',
       backgroundColor: '#409EFF',
       marginLeft: 5+ `px`,
       top: '10px',
       }"  
    >
    </div>
    </div>
    <div style="position: relative;">
    <div v-show="cell1" style="width: 170px;height: 53px;position: relative;top:63px;left: 445px;">
      <div v-for="(rect, rectIndex) in adjustedRects" :key="rect.id" :style="rectStyle(rect, rectIndex)">
    <div
      v-for="(subRect, subIndex) in getSubRects(rectIndex)"
      :key="subIndex"
      :style="subRectStyle(rectIndex, subIndex)"
    ></div>
    </div>
    </div>
 <div v-show="cell2" style="width: 170px;height: 53px;position: relative;top:70px;left: 445px;">
    <div v-for="(rect, rectIndex) in adjustedRectsa" :key="rect.id" :style="rectStylea(rect, rectIndex)">
    <div
      v-for="(subRect, subIndex) in getSubRectsa(rectIndex)"
      :key="subIndex"
      :style="subRectStylea(rectIndex, subIndex)"
    ></div>
    </div>
    </div>
  <div v-show="cell3" style="width: 170px;height: 53px;position: relative;top:76px;left: 445px;">
    <div v-for="(rect, rectIndex) in adjustedRectsb" :key="rect.id" :style="rectStyleb(rect, rectIndex)">
    <div
      v-for="(subRect, subIndex) in getSubRectsb(rectIndex)"
      :key="subIndex"
      :style="subRectStyleb(rectIndex, subIndex)"
    ></div>
    </div>
    </div>
  <div v-show="cell4" style="width: 170px;height: 53px;position: relative;top:84px;left: 445px;">
    <div v-for="(rect, rectIndex) in adjustedRectsc" :key="rect.id" :style="rectStylec(rect, rectIndex)">
    <div
      v-for="(subRect, subIndex) in getSubRectsc(rectIndex)"
      :key="subIndex"
      :style="subRectStylec(rectIndex, subIndex)"
    ></div>
    </div>
    </div>
  <div v-show="cell5" style="width: 170px;height: 53px;position: relative;top:-16px;left: 45px;">
    <div v-for="(rect, rectIndex) in adjustedRectsd" :key="rect.id" :style="rectStyled(rect, rectIndex)">
    <div
      v-for="(subRect, subIndex) in getSubRectsd(rectIndex)"
      :key="subIndex"
      :style="subRectStyled(rectIndex, subIndex)"
    ></div>
    </div>
    </div>
  <div v-show="cell6" style="width: 170px;height: 53px;position: relative;top:-6px;left: 45px;">
    <div v-for="(rect, rectIndex) in adjustedRectse" :key="rect.id" :style="rectStylee(rect, rectIndex)">
    <div
      v-for="(subRect, subIndex) in getSubRectse(rectIndex)"
      :key="subIndex"
      :style="subRectStylee(rectIndex, subIndex)"
    ></div>
    </div>
    </div>
</div>
</div>
<el-card style="flex: 1;margin-left: 1074px;margin-top: -410px;">
    <el-card style="flex: 1;margin-left: 1074px;margin-top: -410px;">
      <div style="width: 100%; height: calc(100% - 35px); overflow-y: auto;max-height: 420px;">
       <el-table height="370px" ref="table" border 
       :data="tableDatass" :header-cell-style="{background:'#F2F3F5 ',color:'#1D2129'}">
         <el-table-column fixed prop="engineerId" align="center" :label="$t('Mounting.project')" min-width="100" />
         <el-table-column prop="countTemp" align="center" :label="$t('searchOrder.totalfurnaces')" min-width="68" />
         <el-table-column prop="fullTemp" align="center" :label="$t('searchOrder.furnaces')" min-width="82" />
         <el-table-column prop="countGlass" align="center" :label="$t('searchOrder.cagesnumber')" min-width="82" />
         <el-table-column prop="area" align="center" :label="$t('large.are')" min-width="65" />
         <el-table-column prop="countSlot" align="center" :label="$t('searchOrder.slotnumber')" min-width="95" />
         <el-table-column prop="percent" align="center" :label="$t('searchOrder.progress')" min-width="75" />
       </el-table>
       </div>
        <el-table height="370px" ref="table" border :data="tableDatass"
          :header-cell-style="{ background: '#F2F3F5 ', color: '#1D2129' }">
          <el-table-column fixed prop="engineerId" align="center" :label="$t('Mounting.project')" min-width="100" />
          <el-table-column prop="countTemp" align="center" :label="$t('searchOrder.totalfurnaces')" min-width="68" />
          <el-table-column prop="fullTemp" align="center" :label="$t('searchOrder.furnaces')" min-width="82" />
          <el-table-column prop="countGlass" align="center" :label="$t('searchOrder.cagesnumber')" min-width="82" />
          <el-table-column prop="area" align="center" :label="$t('large.are')" min-width="65" />
          <el-table-column prop="countSlot" align="center" :label="$t('searchOrder.slotnumber')" min-width="95" />
          <el-table-column prop="percent" align="center" :label="$t('searchOrder.progress')" min-width="75" />
        </el-table>
      </div>
    </el-card>
<div style="padding: 10px;display: flex;height:130px;margin-top:1px">
            <div v-for="(item, index) in tableDatae" :key="index" id="occupy">  
               <el-col style="text-align:left;font-weight: bold;">#{{ item.device_id }}</el-col>  
               <el-col style="text-align:left;display:flex;justify-content: space-between;align-items: center;">  
                 <span>{{ $t('searchOrder.Usage') }}</span><span>{{ item.percentage }}%</span>  
               </el-col>  
               <hr style="width:80%;margin: 0 auto;" />  
               <el-col style="text-align:left;display:flex;justify-content: space-between;align-items: center;">  
                 <span>{{ $t('searchOrder.free') }}</span><span>{{ item.count }}</span>  
               </el-col>  
             </div>  
    <div style="padding: 10px;display: flex;height:130px;margin-top:1px">
      <div v-for="(item, index) in tableDatae" :key="index" id="occupy">
        <el-col style="text-align:left;font-weight: bold;">#{{ item.device_id }}</el-col>
        <el-col style="text-align:left;display:flex;justify-content: space-between;align-items: center;">
          <span>{{ $t('searchOrder.Usage') }}</span><span>{{ item.percentage }}%</span>
        </el-col>
        <hr style="width:80%;margin: 0 auto;" />
        <el-col style="text-align:left;display:flex;justify-content: space-between;align-items: center;">
          <span>{{ $t('searchOrder.free') }}</span><span>{{ item.count }}</span>
        </el-col>
      </div>
    </div>
    <div class="table-container">
    <el-card style="flex: 1;margin-left: 10px;margin-top: 3px;">
      <div style="width: 98%; height: calc(100% - 35px); overflow-y: auto;max-height: 200px;">
       <el-table height="200px" ref="table" 
        :row-class-name="tableRowClassName"
        :data="tableDatax" :header-cell-style="{background:'#F2F3F5 ',color:'#1D2129'}">
          <el-table-column prop="glassId" align="center" :label="$t('searchOrder.intoglassid')" min-width="140" />
      <el-card style="flex: 1;margin-left: 10px;margin-top: 3px;">
        <div style="width: 98%; height: calc(100% - 35px); overflow-y: auto;max-height: 200px;">
          <el-table height="200px" ref="table" :row-class-name="tableRowClassName" :data="tableDatax"
            :header-cell-style="{ background: '#F2F3F5 ', color: '#1D2129' }">
            <el-table-column prop="glassId" align="center" :label="$t('searchOrder.intoglassid')" min-width="140" />
            <el-table-column prop="startSlot" align="center" :label="$t('searchOrder.startposition')" min-width="120" />
            <el-table-column prop="targetSlot" align="center" :label="$t('searchOrder.targetlocation')"
              min-width="120" />
            <el-table-column prop="taskState" align="center" :label="$t('searchOrder.taskstatus')" min-width="120">
              <template #default="scope">
                <el-tag type="success">{{ scope.row.taskState == 0 ? $t('searchOrder.filmenter') : $t('searchOrder.infilm')
                  }}</el-tag>
              </template>
            </el-table-column>
            <el-table-column prop="isSame" align="center" :label="$t('searchOrder.whethersame')" min-width="120">
              <template #default="scope">
                <el-tag :type="getcasOnea(scope.row.isSame)">
                  {{ getStatuscasOnea(scope.row.isSame) }}
                </el-tag>
              </template>
            </el-table-column>
          </el-table>
        </div>
      </el-card>
      <el-card style="flex: 1;margin-left: 10px;margin-top: 3px;">
        <el-table height="200px" ref="table" :data="tableDatac"
          :header-cell-style="{ background: '#F2F3F5 ', color: '#1D2129' }">
          <el-table-column prop="glassId" align="center" :label="$t('searchOrder.outputglassID')" min-width="140" />
          <el-table-column prop="startSlot" align="center" :label="$t('searchOrder.startposition')" min-width="120" />
          <el-table-column prop="targetSlot" align="center" :label="$t('searchOrder.targetlocation')" min-width="120" />
          <el-table-column prop="taskState" align="center" :label="$t('searchOrder.taskstatus')" min-width="120">
          <template #default="scope">
            <el-tag type="success" >{{ scope.row.taskState==0? $t('searchOrder.filmenter') : $t('searchOrder.infilm') }}</el-tag>
          </template>
          </el-table-column>
          <el-table-column prop="isSame" align="center" :label="$t('searchOrder.whethersame')" min-width="120">
          <template #default="scope">
        <el-tag :type="getcasOnea(scope.row.isSame)">
          {{ getStatuscasOnea(scope.row.isSame) }}
        </el-tag>
      </template>
          <el-table-column prop="taskState" align="center" :label="$t('searchOrder.taskstatus')" min-width="157">
            <template #default="scope">
              <el-tag type="success">{{ scope.row.taskState == 0 ? $t('searchOrder.filmenter') : $t('searchOrder.infilm')
                }}</el-tag>
            </template>
          </el-table-column>
        </el-table>
       </div>
    </el-card>
    <el-card style="flex: 1;margin-left: 10px;margin-top: 3px;">
      <el-table height="200px" ref="table" 
       :data="tableDatac" :header-cell-style="{background:'#F2F3F5 ',color:'#1D2129'}">
         <el-table-column prop="glassId" align="center" :label="$t('searchOrder.outputglassID')" min-width="140" />
         <el-table-column prop="startSlot" align="center" :label="$t('searchOrder.startposition')" min-width="120" />
         <el-table-column prop="targetSlot" align="center" :label="$t('searchOrder.targetlocation')" min-width="120" />
         <el-table-column prop="taskState" align="center" :label="$t('searchOrder.taskstatus')" min-width="157">
           <template #default="scope">
             <el-tag type="success" >{{ scope.row.taskState==0? $t('searchOrder.filmenter') : $t('searchOrder.infilm') }}</el-tag>
           </template>
         </el-table-column>
       </el-table>
            </el-card>
      </el-card>
    </div>
  </div>
  </div>
    
  <el-dialog v-model="add" top="10vh" width="70%" :title="$t('searchOrder.addcage')" >

  <el-dialog v-model="add" top="10vh" width="70%" :title="$t('searchOrder.addcage')">
    <div style="margin-bottom: 20px">
      <el-form>
        <el-row style="margin-top: -15px;margin-bottom: -2px;">
          <el-col :span="4">
              <div id="dt" style="font-size: 15px;">
              <el-form-item :label="$t('searchOrder.tida')"  style="width: 14vw">
            <div id="dt" style="font-size: 15px;">
              <el-form-item :label="$t('searchOrder.tida')" style="width: 14vw">
                {{ currentRow.deviceId }}
              </el-form-item>
              </div>
            </div>
          </el-col>
          <el-col :span="5">
            <div id="dta" style="font-size: 15px;">
          <el-form-item :label="$t('searchOrder.gridnumbera')" style="width: 14vw">
              <el-form-item :label="$t('searchOrder.gridnumbera')" style="width: 14vw">
                {{ currentRow.slot }}
              </el-form-item>
              </div>
            </div>
          </el-col>
        </el-row>
      </el-form>
    </div>
      <div style="margin-top: -20px;margin-bottom: 40px;margin-left: 30px">
          <el-input v-model="glassId"   :placeholder="$t('searchOrder.inputid')" clearable style="width: 200px;">
          </el-input>
          <el-button type="primary" plain style="margin-left: 10px;" @click="searchout">{{ $t('searchOrder.search') }}</el-button>
    <div style="margin-top: -20px;margin-bottom: 40px;margin-left: 30px">
      <el-input v-model="glassId" :placeholder="$t('searchOrder.inputid')" clearable style="width: 200px;">
      </el-input>
      <el-button type="primary" plain style="margin-left: 10px;" @click="searchout">{{ $t('searchOrder.search')
        }}</el-button>
    </div>
    <div style="width: 98%; height: calc(100% - 35px); overflow-y: auto;max-height: 200px;">
        <el-table height="100%" ref="table"
        :data="tableDataf" :header-cell-style="{background:'#F2F3F5 ',color:'#1D2129'}">
          <el-table-column prop="glassId" align="center" :label="$t('searchOrder.glassID')" min-width="120" />
          <el-table-column prop="sequence" align="center" :label="$t('searchOrder.pieceingrid')" min-width="180" />
          <el-table-column prop="flowCardId" align="center" :label="$t('searchOrder.cardnumber')" min-width="150" />
          <el-table-column prop="glassType" align="center" :label="$t('searchOrder.typeglass')" min-width="150"/>
          <el-table-column prop="width" align="center" :label="$t('searchOrder.width')" min-width="150"/>
          <el-table-column prop="height" align="center" :label="$t('searchOrder.height')" min-width="150"/>
          <el-table-column prop="thickness" align="center" :label="$t('searchOrder.thickness')" min-width="150"/>
          <el-table-column prop="temperingLayoutId" align="center" :label="$t('searchOrder.layoutID')" min-width="150"/>
          <el-table-column prop="temperingFeedSequence" align="center" :label="$t('searchOrder.picturesequence')" min-width="150"/>
          <el-table-column
          align="center"
            :label="$t('searchOrder.startstatus')"
            min-width="80"
            prop="state"
          >
          <template #default="scope">  
          <el-tag  
            :type="scope.row.state === 1 ? 'success' : 'danger'"  
          >  
          {{ scope.row.state === 1 ? $t('searchOrder.enable') : $t('searchOrder.disable') }}
          </el-tag>  
        </template> 
          </el-table-column>
          <el-table-column prop="gap" align="center" :label="$t('searchOrder.glassgaps')" min-width="150"/>
          <el-table-column fixed="right" :label="$t('searchOrder.operate')" align="center" width="150">
            <template #default="scope">
              <el-button type="text" plain @click="finisha(scope.row)">{{ $t('searchOrder.sureadd') }}</el-button>
            </template>
      <el-table height="100%" ref="table" :data="tableDataf"
        :header-cell-style="{ background: '#F2F3F5 ', color: '#1D2129' }">
        <el-table-column prop="glassId" align="center" :label="$t('searchOrder.glassID')" min-width="120" />
        <el-table-column prop="sequence" align="center" :label="$t('searchOrder.pieceingrid')" min-width="180" />
        <el-table-column prop="flowCardId" align="center" :label="$t('searchOrder.cardnumber')" min-width="150" />
        <el-table-column prop="glassType" align="center" :label="$t('searchOrder.typeglass')" min-width="150" />
        <el-table-column prop="width" align="center" :label="$t('searchOrder.width')" min-width="150" />
        <el-table-column prop="height" align="center" :label="$t('searchOrder.height')" min-width="150" />
        <el-table-column prop="thickness" align="center" :label="$t('searchOrder.thickness')" min-width="150" />
        <el-table-column prop="temperingLayoutId" align="center" :label="$t('searchOrder.layoutID')" min-width="150" />
        <el-table-column prop="temperingFeedSequence" align="center" :label="$t('searchOrder.picturesequence')"
          min-width="150" />
        <el-table-column align="center" :label="$t('searchOrder.startstatus')" min-width="80" prop="state">
          <template #default="scope">
            <el-tag :type="scope.row.state === 1 ? 'success' : 'danger'">
              {{ scope.row.state === 1 ? $t('searchOrder.enable') : $t('searchOrder.disable') }}
            </el-tag>
          </template>
        </el-table-column>
        </el-table>
      </div>
        <el-table-column prop="gap" align="center" :label="$t('searchOrder.glassgaps')" min-width="150" />
        <el-table-column fixed="right" :label="$t('searchOrder.operate')" align="center" width="150">
          <template #default="scope">
            <el-button type="text" plain @click="finisha(scope.row)">{{ $t('searchOrder.sureadd') }}</el-button>
          </template>
        </el-table-column>
      </el-table>
    </div>
  </el-dialog>
  <el-dialog v-model="dialogFormVisiblea" top="2vh" width="95%" 
  :title="$t('searchOrder.cageinformation')">
  <div v-loading="isLoading" class="loading-container" :element-loading-text="$t('searchOrder.loadingText')" >
  <div style="display: flex;">
    <el-input v-model="engineerId" clearable style="margin-left: 10px;margin-bottom: 10px;width: 240px;" :placeholder="$t('processCard.projectnumber')"/>
    <el-input v-model="glassId" clearable style="margin-left: 10px;margin-bottom: 10px;width: 240px;" :placeholder="$t('searchOrder.inglassID')"/>
    <el-input v-model="flowCardId" clearable style="margin-left: 10px;margin-bottom: 10px;width: 240px;" :placeholder="$t('searchOrder.incardnumber')" />
    <el-input v-model="filmsId" clearable style="margin-left: 10px;margin-bottom: 10px;width: 240px;" :placeholder="$t('film.infilms')"/>
    <el-input v-model="thickness" clearable style="margin-left: 10px;margin-bottom: 10px;width: 240px;" :placeholder="$t('searchOrder.inthickness')"/>
    <el-button type="primary" style="margin-left: 10px;margin-bottom: 10px;" @click="fetchxianga">
      {{$t('reportmanage.inquire')}}</el-button>
  </div>
<el-table 
  ref="table" 
  style="margin-top: 20px; height: 700px; width: 1770px; overflow-y: auto;"  
  :data="tableDataa" 
  :header-cell-style="{background:'#F2F3F5 ',color:'#1D2129'}"
  virtual-scroll 
  :virtual-scroll-item-size="50" 
  :virtual-scroll-offset="100"   
  :row-height="50"  
   :border="false"  
  :lazy="true"     
  :cell-style="{padding: '8px 0'}"  
  :show-header-overflow="false"  
  :show-overflow="false"         
  :stripe="false"               
  :selectable="false"           
  :tooltip-effect="null"         
>
  <el-table-column prop="deviceId" align="center" :label="$t('searchOrder.cagenumber')" min-width="100" />
          <el-table-column prop="engineerId" align="center" :label="$t('searchOrder.projectnumber')" min-width="100" />
          <el-table-column prop="layer" align="center" :label="$t('processCard.layer')" min-width="50" />
          <el-table-column prop="slot" align="center" :label="$t('searchOrder.gridnumber')" min-width="150" />
          <el-table-column
          align="center"
            :label="$t('searchOrder.startstatus')"
            min-width="80"
            prop="enableState"
          >
          <template #default="scope">  
          <el-tag  
            :type="scope.row.enableState === 1 ? 'success' : 'danger'"  
            @click="toggleEnableState(scope.row)"  
          >  
            {{ scope.row.enableState === 1 ? $t('searchOrder.enable') : $t('searchOrder.disable')}}  
          </el-tag>  
        </template> 
          </el-table-column>
          <el-table-column prop="remainWidth" align="center" :label="$t('searchOrder.remainingwidth')" min-width="120" />
          <el-table-column prop="glassId" :label="$t('searchOrder.glassID')" align="center" min-width="120"/>
          <el-table-column prop="flowCardId" align="center" :label="$t('searchOrder.cardnumber')" min-width="130" />
          <el-table-column prop="filmsId" align="center" :label="$t('searchOrder.coatingtypes')" min-width="80" />
          <el-table-column prop="width" align="center" :label="$t('searchOrder.width')" min-width="80" />
          <el-table-column prop="height" align="center" :label="$t('searchOrder.height')" min-width="80" />
          <el-table-column prop="thickness" align="center" :label="$t('searchOrder.thickness')" min-width="80" />
          <el-table-column prop="temperingLayoutId" align="center" :label="$t('searchOrder.layoutID')" min-width="100" />
          <el-table-column prop="temperingFeedSequence" align="center" :label="$t('searchOrder.picturesequence')" min-width="120" />
          <el-table-column fixed="right" :label="$t('film.operate')" align="center" width="240">
              <template #default="scope">
              <!-- <el-button type="text" plain @click="handleBindRack(scope.row)">{{ $t('searchOrder.add') }}</el-button> -->
              <el-button type="text" plain @click="broke(scope.row)">{{ $t('searchOrder.breakage') }}</el-button>
              <el-button type="text" plain @click="brokec(scope.row)">{{ $t('searchOrder.takeout') }}</el-button>
              <el-button type="text" plain @click="opena(scope.row)">{{ $t('searchOrder.delete') }}</el-button>
              <!-- <el-button type="text" 
  <el-dialog v-model="dialogFormVisiblea" top="2vh" width="95%" :title="$t('searchOrder.cageinformation')">
    <div v-loading="isLoading" class="loading-container" :element-loading-text="$t('searchOrder.loadingText')">
      <div style="display: flex;">
        <el-input v-model="engineerId" clearable style="margin-left: 10px;margin-bottom: 10px;width: 240px;"
          :placeholder="$t('processCard.projectnumber')" />
        <el-input v-model="glassId" clearable style="margin-left: 10px;margin-bottom: 10px;width: 240px;"
          :placeholder="$t('searchOrder.inglassID')" />
        <el-input v-model="flowCardId" clearable style="margin-left: 10px;margin-bottom: 10px;width: 240px;"
          :placeholder="$t('searchOrder.incardnumber')" />
        <el-input v-model="filmsId" clearable style="margin-left: 10px;margin-bottom: 10px;width: 240px;"
          :placeholder="$t('film.infilms')" />
        <el-input v-model="thickness" clearable style="margin-left: 10px;margin-bottom: 10px;width: 240px;"
          :placeholder="$t('searchOrder.inthickness')" />
        <el-button type="primary" style="margin-left: 10px;margin-bottom: 10px;" @click="fetchxianga">
          {{ $t('reportmanage.inquire') }}</el-button>
      </div>
      <el-table ref="table" style="margin-top: 20px; height: 700px; width: 1770px; overflow-y: auto;" :data="tableDataa"
        :header-cell-style="{ background: '#F2F3F5 ', color: '#1D2129' }" virtual-scroll :virtual-scroll-item-size="50"
        :virtual-scroll-offset="100" :row-height="50" :border="false" :lazy="true" :cell-style="{ padding: '8px 0' }"
        :show-header-overflow="false" :show-overflow="false" :stripe="false" :selectable="false" :tooltip-effect="null">
        <el-table-column prop="deviceId" align="center" :label="$t('searchOrder.cagenumber')" min-width="100" />
        <el-table-column prop="engineerId" align="center" :label="$t('searchOrder.projectnumber')" min-width="100" />
        <el-table-column prop="layer" align="center" :label="$t('processCard.layer')" min-width="50" />
        <el-table-column prop="slot" align="center" :label="$t('searchOrder.gridnumber')" min-width="150" />
        <el-table-column align="center" :label="$t('searchOrder.startstatus')" min-width="80" prop="enableState">
          <template #default="scope">
            <el-tag :type="scope.row.enableState === 1 ? 'success' : 'danger'" @click="toggleEnableState(scope.row)">
              {{ scope.row.enableState === 1 ? $t('searchOrder.enable') : $t('searchOrder.disable') }}
            </el-tag>
          </template>
        </el-table-column>
        <el-table-column prop="remainWidth" align="center" :label="$t('searchOrder.remainingwidth')" min-width="120" />
        <el-table-column prop="glassId" :label="$t('searchOrder.glassID')" align="center" min-width="120" />
        <el-table-column prop="flowCardId" align="center" :label="$t('searchOrder.cardnumber')" min-width="130" />
        <el-table-column prop="filmsId" align="center" :label="$t('searchOrder.coatingtypes')" min-width="80" />
        <el-table-column prop="width" align="center" :label="$t('searchOrder.width')" min-width="80" />
        <el-table-column prop="height" align="center" :label="$t('searchOrder.height')" min-width="80" />
        <el-table-column prop="thickness" align="center" :label="$t('searchOrder.thickness')" min-width="80" />
        <el-table-column prop="temperingLayoutId" align="center" :label="$t('searchOrder.layoutID')" min-width="100" />
        <el-table-column prop="temperingFeedSequence" align="center" :label="$t('searchOrder.picturesequence')"
          min-width="120" />
        <el-table-column fixed="right" :label="$t('film.operate')" align="center" width="240">
          <template #default="scope">
            <!-- <el-button type="text" plain @click="handleBindRack(scope.row)">{{ $t('searchOrder.add') }}</el-button> -->
            <el-button type="text" plain @click="broke(scope.row)">{{ $t('searchOrder.breakage') }}</el-button>
            <el-button type="text" plain @click="brokec(scope.row)">{{ $t('searchOrder.takeout') }}</el-button>
            <el-button type="text" plain @click="opena(scope.row)">{{ $t('searchOrder.delete') }}</el-button>
            <!-- <el-button type="text"
              :disabled="!((props.row.bigStorageCageDetails[0].state !== 102 && scope.$index == 0 ) || (props.row.bigStorageCageDetails[(scope.$index - 1)<0?0:scope.$index-1].state==102)&&(scope.row.state!=102))"
               plain @click="outfil(scope.row)">
               {{ $t('searchOrder.outfilm') }}
              </el-button> -->
                </template>
              </el-table-column>
        </el-table>
        <div>
    <!-- <div style="margin-top: 20px;margin-left: 40%;">
          </template>
        </el-table-column>
      </el-table>
      <div>
        <!-- <div style="margin-top: 20px;margin-left: 40%;">
      <el-pagination
          background
          size="large"
@@ -1602,229 +1525,208 @@
          @current-change="handlePageChange2"
        />
    </div> -->
  </div>
  </div>
      </div>
    </div>
  </el-dialog>
<!-- 历史任务 -->
<el-dialog v-model="blindb" top="5vh" width="95%" @close="iframeUrl=''">
     <iframe 
     :src="iframeUrl" 
     marginwidth="2000px"
     marginheight="2000px"
     width="100%" 
     height="750px" 
     frameborder="0"
     ></iframe>
  <!-- 历史任务 -->
  <el-dialog v-model="blindb" top="5vh" width="95%" @close="iframeUrl = ''">
    <iframe :src="iframeUrl" marginwidth="2000px" marginheight="2000px" width="100%" height="750px"
      frameborder="0"></iframe>
  </el-dialog>
<!-- 钢化查询 -->
<el-dialog v-model="dialogFormVisiblec" top="5vh" width="90%" :title="$t('searchOrder.temperingqueries')">
  <div style="margin-bottom: 20px">
  <!-- 钢化查询 -->
  <el-dialog v-model="dialogFormVisiblec" top="5vh" width="90%" :title="$t('searchOrder.temperingqueries')">
    <div style="margin-bottom: 20px">
      <el-form>
        <el-row style="margin-top: -15px;margin-bottom: -2px;">
          <el-col :span="2">
              <div id="dt" style="font-size: 15px;">
              <el-form-item :label="$t('searchOrder.temperingtotal')"  style="width: 14vw">
            <div id="dt" style="font-size: 15px;">
              <el-form-item :label="$t('searchOrder.temperingtotal')" style="width: 14vw">
                {{ temperingtotal }}
              </el-form-item>
              </div>
            </div>
          </el-col>
          <el-col :span="5">
            <div id="dta" style="font-size: 15px;">
          <el-form-item :label="$t('searchOrder.glasstotal')" style="width: 14vw">
              <el-form-item :label="$t('searchOrder.glasstotal')" style="width: 14vw">
                {{ glasstotal }}
              </el-form-item>
              </div>
            </div>
          </el-col>
          <el-col :span="4">
              <div id="dt" style="font-size: 15px;">
            <div id="dt" style="font-size: 15px;">
              <el-form-item :label="$t('searchOrder.fullfurnaces')" style="width: 14vw">
                {{ fulltotals }}
              </el-form-item>
              </div>
            </div>
          </el-col>
          <el-col :span="4">
              <div id="dt" style="font-size: 15px;">
            <div id="dt" style="font-size: 15px;">
              <el-form-item :label="$t('searchOrder.specifiedproject')" style="width: 14vw">
                {{ temperingengineerId }}
              </el-form-item>
              </div>
            </div>
          </el-col>
          <el-col :span="4">
              <div id="dt" style="font-size: 15px;">
                <el-button type="text" plain @click="broked()">{{ $t('searchOrder.undesignate') }}</el-button>
              </div>
            <div id="dt" style="font-size: 15px;">
              <el-button type="text" plain @click="broked()">{{ $t('searchOrder.undesignate') }}</el-button>
            </div>
          </el-col>
        </el-row>
      </el-form>
    </div>
    <el-table  ref="table" style="margin-top: 20px;height: 600px;"
        :data="tableDatagh" :header-cell-style="{background:'#F2F3F5 ',color:'#1D2129'}">
          <el-table-column prop="engineerId" fixed align="center" :label="$t('searchOrder.projectnumber')" min-width="100"/>
          <el-table-column prop="engineerName" fixed align="center" :label="$t('large.engineername')" min-width="120"/>
          <el-table-column prop="thickness" align="center" :label="$t('basicData.thickness')" min-width="100" />
          <el-table-column prop="filmsId" align="center" :label="$t('basicData.coatingtypes')" min-width="100" />
          <el-table-column prop="temperingLayoutId" align="center" :label="$t('searchOrder.layoutnumber')" min-width="100" />
          <el-table-column prop="totalCount" align="center" :label="$t('searchOrder.allnumber')" min-width="100" />
          <el-table-column prop="realCount" align="center" :label="$t('searchOrder.numbercages')" min-width="100" />
          <el-table-column prop="lackCount" align="center" :label="$t('searchOrder.missingquantity')" min-width="100" />
          <el-table-column prop="damageCount" align="center" :label="$t('searchOrder.breakquantity')" min-width="120" />
          <el-table-column fixed="right" :label="$t('searchOrder.operate')" align="center" width="500">
            <template #default="scope">
              <el-button type="text" plain @click="brokee(scope.row,1)">{{ $t('searchOrder.specifytempering') }}</el-button>
              <el-button type="text" plain @click="brokee(scope.row,0)">{{ $t('searchOrder.specifyout') }}</el-button>
              <el-button type="text" plain @click="brokek(scope.row)">{{ $t('searchOrder.specifyengineerid') }}</el-button>
              <el-button type="text" plain @click="handlelack(scope.row)">{{ $t('searchOrder.lacknumber') }}</el-button>
              <el-button type="text" plain @click="handlecagedetails(scope.row)">{{ $t('searchOrder.cagedetails') }}</el-button>
            </template>
        </el-table-column>
        </el-table>
</el-dialog>
<el-dialog v-model="dialogFormVisibled" top="5vh" width="85%" :title="$t('hellow.missingnumber')">
    <el-table  ref="table" style="margin-top: 20px;height: 600px;"
        :data="tableDatalack" :header-cell-style="{background:'#F2F3F5 ',color:'#1D2129'}">
          <el-table-column prop="engineerId" fixed align="center" :label="$t('searchOrder.projectnumber')" min-width="150"/>
          <el-table-column prop="flowCardId" fixed align="center" :label="$t('searchOrder.cardnumber')" min-width="150" />
          <el-table-column prop="glassId" fixed align="center" :label="$t('searchOrder.glassID')" min-width="150" />
          <el-table-column prop="temperingLayoutId" fixed align="center" :label="$t('searchOrder.layoutID')" min-width="100" />
          <el-table-column prop="temperingFeedSequence" fixed align="center" :label="$t('searchOrder.picturesequence')" min-width="120" />
          <el-table-column prop="width" align="center" :label="$t('searchOrder.width')"  min-width="80" />
          <el-table-column prop="height" align="center" :label="$t('searchOrder.height')" min-width="80" />
          <el-table-column prop="thickness" align="center" :label="$t('searchOrder.thickness')" min-width="80" />
          <el-table-column prop="filmsid" align="center" :label="$t('searchOrder.coatingtypes')" min-width="80" />
          <el-table-column
            align="center"
            :label="$t('searchOrder.state')"
            min-width="80"
            prop="isDamage"
          >
            <template #default="scope">
              <div 
                @click="scope.row.isDamage === 1 ? null : broken(scope.row)"
                style="position: relative; display: inline-block;"
              >
                <el-tag
                  :type="scope.row.isDamage === 1 ? 'danger' : 'success'"
                  style="pointer-events: {{ scope.row.isDamage === 1 ? 'none' : 'auto' }};"
                >
                  {{ scope.row.isDamage === 1 ? $t('searchOrder.breakage') : $t('searchOrder.breakagn') }}
                </el-tag>
                <div 
                  v-if="scope.row.isDamage === 1"
                  style="position: absolute; top: 0; left: 0; right: 0; bottom: 0; background: transparent; z-index: 1;"
                ></div>
              </div>
            </template>
          </el-table-column>
          <el-table-column prop="layer" align="center" :label="$t('processCard.layer')" min-width="80" />
          <el-table-column prop="xcoordinate" align="center" :label="$t('searchOrder.xcoordinates')" min-width="80" />
          <el-table-column prop="ycoordinate" align="center" :label="$t('searchOrder.ycoordinates')" min-width="80" />
        </el-table>
</el-dialog>
<el-dialog v-model="dialogFormVisiblee" top="5vh" width="85%" :title="$t('searchOrder.specifyengineerid')">
    <el-table  ref="table" style="margin-top: 20px;height: 600px;"
        :data="tableDataspecify" :header-cell-style="{background:'#F2F3F5 ',color:'#1D2129'}">
          <el-table-column prop="engineerId" fixed align="center" :label="$t('searchOrder.projectnumber')" min-width="150"/>
          <el-table-column prop="flowCardId" fixed align="center" :label="$t('searchOrder.cardnumber')" min-width="150" />
          <el-table-column prop="glassId" fixed align="center" :label="$t('searchOrder.glassID')" min-width="150" />
          <el-table-column prop="temperingLayoutId" fixed align="center" :label="$t('searchOrder.layoutID')" min-width="100" />
          <el-table-column prop="temperingFeedSequence" fixed align="center" :label="$t('searchOrder.picturesequence')" min-width="120" />
          <el-table-column prop="width" align="center" :label="$t('searchOrder.width')"  min-width="80" />
          <el-table-column prop="height" align="center" :label="$t('searchOrder.height')" min-width="80" />
          <el-table-column prop="thickness" align="center" :label="$t('searchOrder.thickness')" min-width="80" />
          <el-table-column prop="filmsid" align="center" :label="$t('searchOrder.coatingtypes')" min-width="80" />
          <el-table-column
            align="center"
            :label="$t('searchOrder.state')"
            min-width="80"
            prop="isDamage"
          >
            <template #default="scope">
              <div 
                @click="scope.row.isDamage === 1 ? null : broken(scope.row)"
                style="position: relative; display: inline-block;"
              >
                <el-tag
                  :type="scope.row.isDamage === 1 ? 'danger' : 'success'"
                  style="pointer-events: {{ scope.row.isDamage === 1 ? 'none' : 'auto' }};"
                >
                  {{ scope.row.isDamage === 1 ? $t('searchOrder.breakage') : $t('searchOrder.breakagn') }}
                </el-tag>
                <div 
                  v-if="scope.row.isDamage === 1"
                  style="position: absolute; top: 0; left: 0; right: 0; bottom: 0; background: transparent; z-index: 1;"
                ></div>
              </div>
            </template>
          </el-table-column>
          <el-table-column prop="layer" align="center" :label="$t('processCard.layer')" min-width="80" />
          <el-table-column prop="xcoordinate" align="center" :label="$t('searchOrder.xcoordinates')" min-width="80" />
          <el-table-column prop="ycoordinate" align="center" :label="$t('searchOrder.ycoordinates')" min-width="80" />
        </el-table>
</el-dialog>
<el-dialog v-model="dialogFormVisiblef" top="5vh" width="85%" :title="$t('searchOrder.cagedetails')">
    <el-table  ref="table" style="margin-top: 20px;height: 600px;"
        :data="tableDatacagedetails" :header-cell-style="{background:'#F2F3F5 ',color:'#1D2129'}">
          <el-table-column prop="engineerId" fixed align="center" :label="$t('searchOrder.projectnumber')" min-width="150"/>
          <el-table-column prop="flowCardId" fixed align="center" :label="$t('searchOrder.cardnumber')" min-width="150" />
          <el-table-column prop="glassId" fixed align="center" :label="$t('searchOrder.glassID')" min-width="150" />
          <el-table-column prop="slot" fixed align="center" :label="$t('film.slot')" min-width="150" />
          <el-table-column prop="temperingLayoutId" fixed align="center" :label="$t('searchOrder.layoutID')" min-width="100" />
          <el-table-column prop="temperingFeedSequence" fixed align="center" :label="$t('searchOrder.picturesequence')" min-width="120" />
          <el-table-column prop="width" align="center" :label="$t('searchOrder.width')"  min-width="80" />
          <el-table-column prop="height" align="center" :label="$t('searchOrder.height')" min-width="80" />
          <el-table-column prop="thickness" align="center" :label="$t('searchOrder.thickness')" min-width="80" />
          <el-table-column prop="filmsId" align="center" :label="$t('searchOrder.coatingtypes')" min-width="80" />
          <el-table-column
            align="center"
            :label="$t('searchOrder.state')"
            min-width="80"
            prop="isDamage"
          >
            <template #default="scope">
              <div 
                @click="scope.row.isDamage === 1 ? null : broken(scope.row)"
                style="position: relative; display: inline-block;"
              >
                <el-tag
                  :type="scope.row.isDamage === 1 ? 'danger' : 'success'"
                  style="pointer-events: {{ scope.row.isDamage === 1 ? 'none' : 'auto' }};"
                >
                  {{ scope.row.isDamage === 1 ? $t('searchOrder.breakage') : $t('searchOrder.breakagn') }}
                </el-tag>
                <div 
                  v-if="scope.row.isDamage === 1"
                  style="position: absolute; top: 0; left: 0; right: 0; bottom: 0; background: transparent; z-index: 1;"
                ></div>
              </div>
            </template>
          </el-table-column>
          <el-table-column prop="layer" align="center" :label="$t('processCard.layer')" min-width="80" />
          <el-table-column prop="xcoordinate" align="center" :label="$t('searchOrder.xcoordinates')" min-width="80" />
          <el-table-column prop="ycoordinate" align="center" :label="$t('searchOrder.ycoordinates')" min-width="80" />
        </el-table>
</el-dialog>
<!-- 非钢化 -->
<el-dialog v-model="dialogFormVisibles" top="5vh" width="85%" :title="$t('searchOrder.searchlayout')">
  <el-table  ref="table" style="margin-top: 20px;height: 500px;"
        :data="tableDatas" :header-cell-style="{background:'#F2F3F5 ',color:'#1D2129'}">
          <el-table-column prop="engineerId" fixed align="center" :label="$t('searchOrder.projectnumber')" min-width="150"/>
          <el-table-column prop="thickness" align="center" :label="$t('basicData.thickness')" min-width="150" />
          <el-table-column prop="filmsId" align="center" :label="$t('basicData.coatingtypes')" min-width="150" />
          <el-table-column prop="temperingLayoutId" fixed align="center" :label="$t('searchOrder.layoutnumber')" min-width="120" />
          <el-table-column prop="totalCount" align="center" :label="$t('searchOrder.allnumber')" min-width="150" />
          <el-table-column prop="realCount" align="center" :label="$t('searchOrder.numbercages')" min-width="150" />
          <el-table-column prop="lackCount" align="center" :label="$t('searchOrder.missingquantity')" min-width="150" />
          <el-table-column prop="damageCount" align="center" :label="$t('searchOrder.breakquantity')" min-width="150" />
          <el-table-column fixed="right" :label="$t('searchOrder.operate')" align="center" width="500">
            <template #default="scope">
              <el-button type="text" plain @click="brokee(scope.row,1)">{{ $t('searchOrder.specifytempering') }}</el-button>
              <el-button type="text" plain @click="brokee(scope.row,0)">{{ $t('searchOrder.specifyout') }}</el-button>
              <el-button type="text" plain @click="brokek(scope.row)">{{ $t('searchOrder.specifyengineerid') }}</el-button>
              <el-button type="text" plain @click="handlelack(scope.row)">{{ $t('hellow.missingnumber') }}</el-button>
              <el-button type="text" plain @click="handlecagedetails(scope.row)">{{ $t('searchOrder.cagedetails') }}</el-button>
            </template>
        </el-table-column>
        </el-table>
    <el-table ref="table" style="margin-top: 20px;height: 600px;" :data="tableDatagh"
      :header-cell-style="{ background: '#F2F3F5 ', color: '#1D2129' }">
      <el-table-column prop="engineerId" fixed align="center" :label="$t('searchOrder.projectnumber')"
        min-width="100" />
      <el-table-column prop="engineerName" fixed align="center" :label="$t('large.engineername')" min-width="120" />
      <el-table-column prop="thickness" align="center" :label="$t('basicData.thickness')" min-width="100" />
      <el-table-column prop="filmsId" align="center" :label="$t('basicData.coatingtypes')" min-width="100" />
      <el-table-column prop="temperingLayoutId" align="center" :label="$t('searchOrder.layoutnumber')"
        min-width="100" />
      <el-table-column prop="totalCount" align="center" :label="$t('searchOrder.allnumber')" min-width="100" />
      <el-table-column prop="realCount" align="center" :label="$t('searchOrder.numbercages')" min-width="100" />
      <el-table-column prop="lackCount" align="center" :label="$t('searchOrder.missingquantity')" min-width="100" />
      <el-table-column prop="damageCount" align="center" :label="$t('searchOrder.breakquantity')" min-width="120" />
      <el-table-column fixed="right" :label="$t('searchOrder.operate')" align="center" width="500">
        <template #default="scope">
          <el-button type="text" plain @click="brokee(scope.row, 1)">{{ $t('searchOrder.specifytempering') }}</el-button>
          <el-button type="text" plain @click="brokee(scope.row, 0)">{{ $t('searchOrder.specifyout') }}</el-button>
          <el-button type="text" plain @click="brokek(scope.row)">{{ $t('searchOrder.specifyengineerid') }}</el-button>
          <el-button type="text" plain @click="handlelack(scope.row)">{{ $t('searchOrder.lacknumber') }}</el-button>
          <el-button type="text" plain @click="handlecagedetails(scope.row)">{{ $t('searchOrder.cagedetails')
            }}</el-button>
        </template>
      </el-table-column>
    </el-table>
  </el-dialog>
  <el-dialog v-model="dialogFormVisibled" top="5vh" width="85%" :title="$t('hellow.missingnumber')">
    <el-table ref="table" style="margin-top: 20px;height: 600px;" :data="tableDatalack"
      :header-cell-style="{ background: '#F2F3F5 ', color: '#1D2129' }">
      <el-table-column prop="engineerId" fixed align="center" :label="$t('searchOrder.projectnumber')"
        min-width="150" />
      <el-table-column prop="flowCardId" fixed align="center" :label="$t('searchOrder.cardnumber')" min-width="150" />
      <el-table-column prop="glassId" fixed align="center" :label="$t('searchOrder.glassID')" min-width="150" />
      <el-table-column prop="temperingLayoutId" fixed align="center" :label="$t('searchOrder.layoutID')"
        min-width="100" />
      <el-table-column prop="temperingFeedSequence" fixed align="center" :label="$t('searchOrder.picturesequence')"
        min-width="120" />
      <el-table-column prop="width" align="center" :label="$t('searchOrder.width')" min-width="80" />
      <el-table-column prop="height" align="center" :label="$t('searchOrder.height')" min-width="80" />
      <el-table-column prop="thickness" align="center" :label="$t('searchOrder.thickness')" min-width="80" />
      <el-table-column prop="filmsid" align="center" :label="$t('searchOrder.coatingtypes')" min-width="80" />
      <el-table-column align="center" :label="$t('searchOrder.state')" min-width="80" prop="isDamage">
        <template #default="scope">
          <div @click="scope.row.isDamage === 1 ? null : broken(scope.row)"
            style="position: relative; display: inline-block;">
            <el-tag :type="scope.row.isDamage === 1 ? 'danger' : 'success'"
              style="pointer-events: {{ scope.row.isDamage === 1 ? 'none' : 'auto' }};">
              {{ scope.row.isDamage === 1 ? $t('searchOrder.breakage') : $t('searchOrder.breakagn') }}
            </el-tag>
            <div v-if="scope.row.isDamage === 1"
              style="position: absolute; top: 0; left: 0; right: 0; bottom: 0; background: transparent; z-index: 1;">
            </div>
          </div>
        </template>
      </el-table-column>
      <el-table-column prop="layer" align="center" :label="$t('processCard.layer')" min-width="80" />
      <el-table-column prop="xcoordinate" align="center" :label="$t('searchOrder.xcoordinates')" min-width="80" />
      <el-table-column prop="ycoordinate" align="center" :label="$t('searchOrder.ycoordinates')" min-width="80" />
    </el-table>
  </el-dialog>
  <el-dialog v-model="dialogFormVisiblee" top="5vh" width="85%" :title="$t('searchOrder.specifyengineerid')">
    <el-table ref="table" style="margin-top: 20px;height: 600px;" :data="tableDataspecify"
      :header-cell-style="{ background: '#F2F3F5 ', color: '#1D2129' }">
      <el-table-column prop="engineerId" fixed align="center" :label="$t('searchOrder.projectnumber')"
        min-width="150" />
      <el-table-column prop="flowCardId" fixed align="center" :label="$t('searchOrder.cardnumber')" min-width="150" />
      <el-table-column prop="glassId" fixed align="center" :label="$t('searchOrder.glassID')" min-width="150" />
      <el-table-column prop="temperingLayoutId" fixed align="center" :label="$t('searchOrder.layoutID')"
        min-width="100" />
      <el-table-column prop="temperingFeedSequence" fixed align="center" :label="$t('searchOrder.picturesequence')"
        min-width="120" />
      <el-table-column prop="width" align="center" :label="$t('searchOrder.width')" min-width="80" />
      <el-table-column prop="height" align="center" :label="$t('searchOrder.height')" min-width="80" />
      <el-table-column prop="thickness" align="center" :label="$t('searchOrder.thickness')" min-width="80" />
      <el-table-column prop="filmsid" align="center" :label="$t('searchOrder.coatingtypes')" min-width="80" />
      <el-table-column align="center" :label="$t('searchOrder.state')" min-width="80" prop="isDamage">
        <template #default="scope">
          <div @click="scope.row.isDamage === 1 ? null : broken(scope.row)"
            style="position: relative; display: inline-block;">
            <el-tag :type="scope.row.isDamage === 1 ? 'danger' : 'success'"
              style="pointer-events: {{ scope.row.isDamage === 1 ? 'none' : 'auto' }};">
              {{ scope.row.isDamage === 1 ? $t('searchOrder.breakage') : $t('searchOrder.breakagn') }}
            </el-tag>
            <div v-if="scope.row.isDamage === 1"
              style="position: absolute; top: 0; left: 0; right: 0; bottom: 0; background: transparent; z-index: 1;">
            </div>
          </div>
        </template>
      </el-table-column>
      <el-table-column prop="layer" align="center" :label="$t('processCard.layer')" min-width="80" />
      <el-table-column prop="xcoordinate" align="center" :label="$t('searchOrder.xcoordinates')" min-width="80" />
      <el-table-column prop="ycoordinate" align="center" :label="$t('searchOrder.ycoordinates')" min-width="80" />
    </el-table>
  </el-dialog>
  <el-dialog v-model="dialogFormVisiblef" top="5vh" width="85%" :title="$t('searchOrder.cagedetails')">
    <el-table ref="table" style="margin-top: 20px;height: 600px;" :data="tableDatacagedetails"
      :header-cell-style="{ background: '#F2F3F5 ', color: '#1D2129' }">
      <el-table-column prop="engineerId" fixed align="center" :label="$t('searchOrder.projectnumber')"
        min-width="150" />
      <el-table-column prop="flowCardId" fixed align="center" :label="$t('searchOrder.cardnumber')" min-width="150" />
      <el-table-column prop="glassId" fixed align="center" :label="$t('searchOrder.glassID')" min-width="150" />
      <el-table-column prop="slot" fixed align="center" :label="$t('film.slot')" min-width="150" />
      <el-table-column prop="temperingLayoutId" fixed align="center" :label="$t('searchOrder.layoutID')"
        min-width="100" />
      <el-table-column prop="temperingFeedSequence" fixed align="center" :label="$t('searchOrder.picturesequence')"
        min-width="120" />
      <el-table-column prop="width" align="center" :label="$t('searchOrder.width')" min-width="80" />
      <el-table-column prop="height" align="center" :label="$t('searchOrder.height')" min-width="80" />
      <el-table-column prop="thickness" align="center" :label="$t('searchOrder.thickness')" min-width="80" />
      <el-table-column prop="filmsId" align="center" :label="$t('searchOrder.coatingtypes')" min-width="80" />
      <el-table-column align="center" :label="$t('searchOrder.state')" min-width="80" prop="isDamage">
        <template #default="scope">
          <div @click="scope.row.isDamage === 1 ? null : broken(scope.row)"
            style="position: relative; display: inline-block;">
            <el-tag :type="scope.row.isDamage === 1 ? 'danger' : 'success'"
              style="pointer-events: {{ scope.row.isDamage === 1 ? 'none' : 'auto' }};">
              {{ scope.row.isDamage === 1 ? $t('searchOrder.breakage') : $t('searchOrder.breakagn') }}
            </el-tag>
            <div v-if="scope.row.isDamage === 1"
              style="position: absolute; top: 0; left: 0; right: 0; bottom: 0; background: transparent; z-index: 1;">
            </div>
          </div>
        </template>
      </el-table-column>
      <el-table-column prop="layer" align="center" :label="$t('processCard.layer')" min-width="80" />
      <el-table-column prop="xcoordinate" align="center" :label="$t('searchOrder.xcoordinates')" min-width="80" />
      <el-table-column prop="ycoordinate" align="center" :label="$t('searchOrder.ycoordinates')" min-width="80" />
    </el-table>
  </el-dialog>
  <!-- 非钢化 -->
  <el-dialog v-model="dialogFormVisibles" top="5vh" width="85%" :title="$t('searchOrder.searchlayout')">
    <el-table ref="table" style="margin-top: 20px;height: 500px;" :data="tableDatas"
      :header-cell-style="{ background: '#F2F3F5 ', color: '#1D2129' }">
      <el-table-column prop="engineerId" fixed align="center" :label="$t('searchOrder.projectnumber')"
        min-width="150" />
      <el-table-column prop="thickness" align="center" :label="$t('basicData.thickness')" min-width="150" />
      <el-table-column prop="filmsId" align="center" :label="$t('basicData.coatingtypes')" min-width="150" />
      <el-table-column prop="temperingLayoutId" fixed align="center" :label="$t('searchOrder.layoutnumber')"
        min-width="120" />
      <el-table-column prop="totalCount" align="center" :label="$t('searchOrder.allnumber')" min-width="150" />
      <el-table-column prop="realCount" align="center" :label="$t('searchOrder.numbercages')" min-width="150" />
      <el-table-column prop="lackCount" align="center" :label="$t('searchOrder.missingquantity')" min-width="150" />
      <el-table-column prop="damageCount" align="center" :label="$t('searchOrder.breakquantity')" min-width="150" />
      <el-table-column fixed="right" :label="$t('searchOrder.operate')" align="center" width="500">
        <template #default="scope">
          <el-button type="text" plain @click="brokee(scope.row, 1)">{{ $t('searchOrder.specifytempering') }}</el-button>
          <el-button type="text" plain @click="brokee(scope.row, 0)">{{ $t('searchOrder.specifyout') }}</el-button>
          <el-button type="text" plain @click="brokek(scope.row)">{{ $t('searchOrder.specifyengineerid') }}</el-button>
          <el-button type="text" plain @click="handlelack(scope.row)">{{ $t('hellow.missingnumber') }}</el-button>
          <el-button type="text" plain @click="handlecagedetails(scope.row)">{{ $t('searchOrder.cagedetails')
            }}</el-button>
        </template>
      </el-table-column>
    </el-table>
    <!-- <el-table  ref="table" style="margin-top: 20px;height: 500px;"
        :data="tableDatas" :header-cell-style="{background:'#F2F3F5 ',color:'#1D2129'}">
          <el-table-column prop="flow_card_id" fixed align="center" :label="$t('searchOrder.processcards')"/>
@@ -1836,103 +1738,138 @@
            </template>
        </el-table-column>
        </el-table> -->
</el-dialog>
  </el-dialog>
</template>
<style>
#dt { display:block; float:left;line-height: 20px;margin-left: 150px;}
#dta { display:block; float:left;line-height: 20px;margin-left: 80%;}
#dialog-footer{
#dt {
  display: block;
  float: left;
  line-height: 20px;
  margin-left: 150px;
}

#dta {
  display: block;
  float: left;
  line-height: 20px;
  margin-left: 80%;
}

#dialog-footer {
  text-align: center;
  margin-top: -15px;
}
#message{

#message {
  text-align: center;
  align-items: center;
  color: black;
   width: 200px;
   height: 100px;
   background-color: #337ecc;
   margin-left: 28%;
  width: 200px;
  height: 100px;
  background-color: #337ecc;
  margin-left: 28%;
}
#awatch{

#awatch {
  height: 450px;
}

#occupy {
    height: 100%;
    width: 15%;
    background-color: white;
    margin: 0px 8px 0px 8px;
    border: 1px #EBEEF5 solid;
    text-align: center;
    padding: 5px;
  height: 100%;
  width: 15%;
  background-color: white;
  margin: 0px 8px 0px 8px;
  border: 1px #EBEEF5 solid;
  text-align: center;
  padding: 5px;
}

#biao {
    font-size: 12px;
  font-size: 12px;
}

#zhi {
    font-size: 18px;
    font-weight: bold;
  font-size: 18px;
  font-weight: bold;
}
#demo-pagination-block + #demo-pagination-block {

#demo-pagination-block+#demo-pagination-block {
  margin-top: 10px;
}

#demo-pagination-block #demonstration {
  margin-bottom: 16px;
}

::-webkit-scrollbar {
     width: 0 !important;
   }
   ::-webkit-scrollbar {
     width: 0 !important;height: 0;
   }
   .img-list{
  position:relative;
  width: 0 !important;
}
.data-img{
  @apply float-none ;
  width:100%;
  height:16rem;

::-webkit-scrollbar {
  width: 0 !important;
  height: 0;
}

.img-list {
  position: relative;
}

.data-img {
  @apply float-none;
  width: 100%;
  height: 16rem;
  background: rgba(0, 0, 0, 0);
  opacity: 1;
  border-radius: 0.5rem 0.5rem 0px 0px;
}
.check-img{

.check-img {
  position: absolute;
  width: 3.3125rem;
  height: 2.9375rem;
  top:20rem;
  top: 20rem;
  right: 57rem;
  z-index: 10;
}
.check-imga{

.check-imga {
  position: absolute;
  width: 3.3125rem;
  height: 2.9375rem;
  top:15rem;
  top: 15rem;
  right: 28.5rem;
  z-index: 10;
}

.vertical {
    width: 45px;
    height: 25px;
    background-color: #409EFF;
    top: 485px; /* 初始位置 */
    left: 899px; /* 水平居中 */
    transform: translateX(-50%);
    animation: move-vertical 6s infinite; /* 从上到下动画，持续6秒，无限循环 */
  width: 45px;
  height: 25px;
  background-color: #409EFF;
  top: 485px;
  /* 初始位置 */
  left: 899px;
  /* 水平居中 */
  transform: translateX(-50%);
  animation: move-vertical 6s infinite;
  /* 从上到下动画，持续6秒，无限循环 */
}

@keyframes move-vertical {
    0% {
        top: 485px; /* 起始位置 */
    }
    100% {
        top: calc(100% - 210px); /* 从上到下结束位置 */
    }
  0% {
    top: 485px;
    /* 起始位置 */
  }

  100% {
    top: calc(100% - 210px);
    /* 从上到下结束位置 */
  }
}
.img-dlpl{

.img-dlpl {
  margin-left: 20px;
  margin-top: 0px;
  background-image:url('/src/assets/ganghuaqian.png');
  background-image: url('/src/assets/ganghuaqian.png');
  background-repeat: no-repeat;
  background-attachment: local;
  min-height: 380px;
@@ -1940,11 +1877,12 @@
  max-width: 100%;
  background-size: 1050px 380px;
  overflow: hidden;
  position:relative
  position: relative
}
.img-car1{

.img-car1 {
  display: flex;
  background-image:url('/xiaoche.png');
  background-image: url('/xiaoche.png');
  position: absolute;
  background-repeat: no-repeat;
  background-attachment: local;
@@ -1953,11 +1891,12 @@
  max-width: 100%;
  background-size: 200px 70px;
  overflow: hidden;
  position:relative
  position: relative
}
.img-car4{

.img-car4 {
  display: flex;
  background-image:url('/xiaoche.png');
  background-image: url('/xiaoche.png');
  position: absolute;
  background-repeat: no-repeat;
  background-attachment: local;
@@ -1966,49 +1905,65 @@
  max-width: 100%;
  background-size: 200px 70px;
  overflow: hidden;
  position:relative
  position: relative
}

.table-container {
  display: flex;
  flex-wrap: nowrap; /* 防止换行 */
  justify-content: space-between; /* 根据需要调整子元素之间的间距 */
  flex-wrap: nowrap;
  /* 防止换行 */
  justify-content: space-between;
  /* 根据需要调整子元素之间的间距 */
}
.table-container > el-card {
  flex: 1; /* 使两个卡片平分可用空间 */
  margin-bottom: 10px; /* 可选，根据需要添加底部间距 */

.table-container>el-card {
  flex: 1;
  /* 使两个卡片平分可用空间 */
  margin-bottom: 10px;
  /* 可选，根据需要添加底部间距 */
}

#dotClass {
  display: flex;
  margin-left: 20px; 
  margin-left: 20px;
  size: 50px;
  margin-top: 20px;
  margin-bottom: 10px;
}

.row-red-background {
  background-color: #CDAF95 !important;
}

.global-alert-bar {
  position: fixed;
  top: 0;
  left: 50%; /* 水平居中关键 */
  transform: translateX(-50%); /* 水平居中关键 */
  left: 50%;
  /* 水平居中关键 */
  transform: translateX(-50%);
  /* 水平居中关键 */
  padding: 12px 20px;
  background-color: #dbdbd7;
  box-shadow: 0 2px 10px rgba(0,0,0,0.2);
  box-shadow: 0 2px 10px rgba(0, 0, 0, 0.2);
  display: flex;
  justify-content: space-between;
  align-items: center;
  z-index: 9999;
  max-width: 80%; /* 防止小屏幕溢出 */
  min-width: 400px; /* 最小宽度保证 */
  max-width: 80%;
  /* 防止小屏幕溢出 */
  min-width: 400px;
  /* 最小宽度保证 */
}

/* 提示内容居中 */
.alert-content {
  display: flex;
  align-items: center;
  justify-content: center;
  flex-grow: 1; /* 占据可用空间 */
  flex-grow: 1;
  /* 占据可用空间 */
}

/* 提示文字样式 */
.alert-text {
  margin-left: 8px;
@@ -2016,6 +1971,7 @@
  font-weight: bold;
  color: #0d0d0d;
}

/* 关闭按钮样式 */
.close-btn {
  background: none;
@@ -2024,18 +1980,23 @@
  cursor: pointer;
  margin-left: 20px;
}

/* 页面容器顶部内边距 */
#app-container {
  padding-top: 60px; /* 根据alert高度调整 */
  padding-top: 60px;
  /* 根据alert高度调整 */
}

.loading-container {
  position: relative;
  height: 100%;
}

/* 确保遮罩层在最顶层 */
.el-loading-mask {
  z-index: 2000 !important;
}

.confirm-text {
  color: rgb(242, 121, 8);
  display: block; /* 强制换行 */

 UI-Project/src/views/StockBasicData/stockBasicData.vue

@@ -256,6 +256,7 @@
    case 2: return 'primary';
    default: return 'info';
  }
  return getOriginalColor(row.state);
}

// 5. 标签类型函数（调用isNeedHighlight）

 UI-Project/src/views/StockBasicData/stockBasicData1.vue

New file
@@ -0,0 +1,259 @@
<script setup>
import {onBeforeUnmount, onMounted, onUnmounted, reactive, ref} from "vue";
import {useRouter} from "vue-router"
import request from "@/utils/request"
import {closeWebSocket, initializeWebSocket} from '@/utils/WebSocketService';
import {ElMessage, ElMessageBox} from 'element-plus'
import {useI18n} from 'vue-i18n'
const router = useRouter()
const adda = ref(false)
const {t} = useI18n()
let language = ref(localStorage.getItem('lang') || 'zh')
const tableData = ref([])
const blindb = ref(false)
const slot = ref('')
const requestData = {
  line: 2001
};
const timeRange = ref([])
const selectValuesa = reactive([]);
// 磨边任务查询
const setEdgGlassInfoRequest = async () => {
  let celllist=[]
  let stateList=[]
  if(selectValuesa[0]!=null&&selectValuesa[0]!='undefined'){
    if(selectValuesa[0]!=""){
      celllist=[selectValuesa[0]];
    }
  }
  if(selectValuesa[1]!=null&&selectValuesa[1]!='undefined'){
    if(selectValuesa[1]!=""){
      stateList=[selectValuesa[1]];
    }
  }
  const response = await request.post("/cacheGlass/edgGlassTaskInfo/setEdgGlassInfoRequest", {
    cellList: celllist,
    stateList: stateList,
    beginDate: timeRange.value[0],
    endDate: timeRange.value[1],
  })
  if (response.code === 200) {
    ElMessage.success(response.message);
  } else {
    ElMessage.error(response.message);
  }
}
// 破损
 const open = async(row) => { 
  try {
    const confirmResult = await ElMessageBox.confirm(  
      t('workOrder.messagedamaged'), 
      t('workOrder.prompt'),  
      {  
        confirmButtonText: t('workOrder.yes'), 
        cancelButtonText: t('workOrder.cancel'),
        type: 'warning',  
      } 
    );
    if (confirmResult === 'confirm') {
      const response = await request.post("/cacheGlass/edgStorageCage/edgReportStatus", {
        glassId: row.glassId,
        state: 8,
        line: row.line,
        workingProcedure: '磨边',
    })
    if (response.code === 200) {
      ElMessage.success(response.message);
      } else {
      ElMessage.error(response.msg);
      }  
    }  
  } catch (error) {
  }  
};  
// 拿走 
 const opena = async(row) => {  
  try {
    const confirmResult = await ElMessageBox.confirm(  
      t('workOrder.takemessage'), 
      t('workOrder.prompt'),  
      {  
        confirmButtonText: t('workOrder.yes'), 
        cancelButtonText: t('workOrder.cancel'),
        type: 'warning',  
      } 
    );
    if (confirmResult === 'confirm') {
      const response = await request.post("/cacheGlass/edgStorageCage/edgReportStatus", {
        glassId: row.glassId,
        state: 9,
        line: row.line,
        workingProcedure: '磨边',
    })
    if (response.code === 200) {
      ElMessage.success(response.message);
      } else {
      ElMessage.error(response.msg);
      }  
    }  
  } catch (error) {
  }  
};   
let socket = null;
const socketUrl = `ws://${window.ipConfig.serverUrl}/api/cacheGlass/api/talk/edgTasks`;
const handleMessage = (data) => {
  const formattedTasks = data.edgTasks[0].map(cageInfo => {
    if (cageInfo && cageInfo.createTime) {
      cageInfo.formattedCreateTime = formatTimestamp(cageInfo.createTime);
    }
    return cageInfo;
  });
  tableData.value = formattedTasks
};
// 历史任务
const iframeUrl = ref('');
const handlehistorical = (row) => {
  blindb.value = true;
  iframeUrl.value = `${window.location.origin}/#/StockBasicData/stockhistory`;
};
onMounted(() => {
  socket = initializeWebSocket(socketUrl, handleMessage);
});
  onUnmounted(() => {
    if (socket) {
      closeWebSocket(socket);
    }
  });
  function getStatusTypeb(state) {
  switch (state) {
    case 0:
      return 'info';
    case 1:
      return 'success';
    case 1:
      return 'danger';
  }
}
function getStatusTextb(state) {
  switch (state) {
    case 0:
      return t('workOrder.nedging');
    case 1:
      return t('workOrder.edging');
    case 2:
      return t('workOrder.finedging');
  }
}
function formatTimestamp(timestamp) {
  const date = new Date(timestamp);
  const year = date.getFullYear();
  const month = String(date.getMonth() + 1).padStart(2, '0'); // 月份从0开始，需要加1，并补零
  const day = String(date.getDate()).padStart(2, '0'); // 补零
  const hours = String(date.getHours()).padStart(2, '0'); // 补零（如果需要显示时间）
  const minutes = String(date.getMinutes()).padStart(2, '0'); // 补零（如果需要显示时间）
  const seconds = String(date.getSeconds()).padStart(2, '0'); // 补零（如果需要显示时间）
  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
}
onBeforeUnmount(() => {
  closeWebSocket();
});
</script>
<template>
  <div style="height: 500px;">
    <div>
      <el-card style="flex: 1;margin-left: 10px;margin-top: 20px;" >
        <div style="display: flex;">
        <!-- <el-button style="margin-left: 20px;" id="searchButton" type="success" @click="handlehistorical">{{
          $t('searchOrder.historicaltasks')
        }}
      </el-button> -->
        <el-select v-model="selectValuesa[0]" filterable :placeholder="$t('workOrder.cway')" clearable
                   style="margin-left: 20px;margin-bottom: 10px;">
          <el-option :label="$t('workOrder.edgingone')" value="930"></el-option>
          <el-option :label="$t('workOrder.edgingtwo')" value="931"></el-option>
        </el-select>
        <el-select v-model="selectValuesa[1]" filterable :placeholder="$t('workOrder.cstate')" clearable
                   style="margin-left: 20px;margin-bottom: 10px;">
          <el-option :label="$t('workOrder.nedging')" value="0"></el-option>
          <el-option :label="$t('workOrder.edging')" value="1"></el-option>
          <el-option :label="$t('workOrder.finedging')" value="2"></el-option>
          </el-select>
          <span class="demonstration" style="margin-left: 20px;margin-top: 3px;">{{ $t('workOrder.time') }}</span>
            <el-date-picker v-model="timeRange" type="datetimerange" range-separator="至" :start-placeholder="$t('reportmanage.starttime')"  style="margin-left: 15px;" value-format = "YYYY-MM-DD hh:mm:ss"
              :end-placeholder="$t('reportmanage.endtime')">
            </el-date-picker>
          <el-button type="primary" style="margin-left: 10px;margin-bottom: 10px;" @click="setEdgGlassInfoRequest()">{{
        $t('reportmanage.inquire')
      }}</el-button>
      </div>
      <div style="width: 98%; height: calc(100% - 35px); overflow-y: auto;">
        <el-table height="750" ref="table" 
        @selection-change="handleSelectionChange"
        :data="tableData" :header-cell-style="{background:'#F2F3F5 ',color:'#1D2129'}">
        <el-table-column prop="glassId" align="center" :label="$t('workOrder.glassID')" min-width="180" />
          <el-table-column prop="width" align="center" :label="$t('workOrder.width')" min-width="120" />
          <el-table-column prop="height" align="center" :label="$t('workOrder.height')" min-width="80" />
          <el-table-column prop="thickness" align="center" :label="$t('workOrder.thickness')" min-width="120" />
          <el-table-column prop="filmsid" align="center" :label="$t('workOrder.glasstype')" min-width="120" />
          <el-table-column prop="line" align="center" :label="$t('workOrder.line')" min-width="120" />
          <el-table-column prop="formattedCreateTime" align="center" :label="$t('workOrder.time')" min-width="120" />
          <el-table-column prop="state" :label="$t('workOrder.status')" align="center" width="200">
            <!-- <template #default="scope">
              {{ scope.row.status==0?"未磨边":scope.row.status==1?"磨边中":"已磨边" }}
            </template> -->
            <template #default="scope">  
        <el-tag :type="getStatusTypeb(scope.row.state)">  
          {{ getStatusTextb(scope.row.state) }}  
        </el-tag>  
      </template> 
        </el-table-column>
          <el-table-column fixed="right" :label="$t('workOrder.operate')" align="center" width="200">
            <template #default="scope">
              <el-button type="text" plain @click="open(scope.row)">{{
                  $t('workOrder.breakage')
                }}
              </el-button>
              <el-button type="text" plain @click="opena(scope.row)">{{
                  $t('workOrder.takeout')
                }}
              </el-button>
            </template>
          </el-table-column>
        </el-table>
      </div>
      </el-card>
    </div>
  <!-- 历史任务 -->
<el-dialog v-model="blindb" top="10vh" width="95%" @close="iframeUrl=''">
     <iframe 
     :src="iframeUrl" 
     marginwidth="2000px"
     marginheight="2000px"
     width="100%" 
     height="700px" 
     frameborder="0"
     ></iframe>
  </el-dialog>
  </div>
</template>
<style scoped>
#dt { display:block; float:left;line-height: 20px;margin-left: 100px;}
#dta { display:block; float:left;line-height: 20px;margin-left: 80%;}
#dialog-footer{
  text-align: center;
  margin-top: -15px;
}
#message{
  text-align: center;
  align-items: center;
  color: black;
   width: 200px;
   height: 100px;
   background-color: #337ecc;
   margin-left: 28%;
}
#awatch{
  height: 460px;
  /* margin-top: -60px; */
}
</style>

 UI-Project/src/views/hollow/hollowslicecage.vue

@@ -1,6 +1,6 @@
<script lang="ts" setup>
import {useI18n} from 'vue-i18n'
import {useRouter} from "vue-router"
import { useI18n } from 'vue-i18n'
import { useRouter } from "vue-router"
import request from "@/utils/request"
import {host, WebSocketHost} from '@/utils/constants'
import {onBeforeUnmount, onMounted, onUnmounted, reactive, ref} from "vue";
@@ -9,7 +9,7 @@
import LackDetailDialog from './LackDetailDialog.vue';
const dialogFormVisibleaDownGlasss = ref(false)
const scanGlass = ref([])
const {t} = useI18n()
const { t } = useI18n()
let language = ref(localStorage.getItem('lang') || 'zh')
const router = useRouter()
const dialogFormVisiblea = ref(false)
@@ -67,15 +67,15 @@
const currentPage2 = ref(1)
const add = ref(false)
const glassId = ref('');
const cell1=ref(true);
const cell2=ref(true);
const cell3=ref(true);
const cell4=ref(true);
const cell5=ref(true);
const cell6=ref(true);
const cell7=ref(true);
const cell8=ref(true);
const cell9=ref(true);
const cell1 = ref(true);
const cell2 = ref(true);
const cell3 = ref(true);
const cell4 = ref(true);
const cell5 = ref(true);
const cell6 = ref(true);
const cell7 = ref(true);
const cell8 = ref(true);
const cell9 = ref(true);
const blindb = ref(false)
const dialogFormVisibleb = ref(false)
const dialogFormVisibleLack = ref(false)
@@ -97,8 +97,8 @@
};
const handleBindRack = (row) => {
  selectedRow.value = row; // 更新选中的行数据  
  currentRow.deviceId  = row.deviceId; // 直接设置响应式属性  
  currentRow.slot = row.slot;  
  currentRow.deviceId = row.deviceId; // 直接设置响应式属性
  currentRow.slot = row.slot;
  window.localStorage.setItem('deviceId', row.deviceId)
  window.localStorage.setItem('slot', row.slot)
  add.value = true;
@@ -109,12 +109,12 @@
  handleAllMissing(row)
};
const handleAllMissing = async (row) => {
  try  {
  const response = await request.post('/hollowGlass/hollowGlassRelationInfo/queryLackGlassByFlowCard', {
    flowCardId: row.flowCardId,
    layer: row.layer,
    orderSort: row.glassType,
    //  glassId: row.glassId
  try {
    const response = await request.post('/hollowGlass/hollowGlassRelationInfo/queryLackGlassByFlowCard', {
      flowCardId: row.flowCardId,
      layer: row.layer,
      orderSort: row.glassType,
      //  glassId: row.glassId
    });
    if (response.code == 200) {
      ElMessage.success(response.message);
@@ -122,8 +122,8 @@
    } else {
      ElMessage.error(response.message);
    }
}
catch (error) {
  }
  catch (error) {
  }
}
const handlePageChange2 = (newPage) => {
@@ -172,14 +172,14 @@
      sums[index] = '';
    }
  });
 

  return sums;
};
// 搜索
const searchout = async () => {
  try {
    const response = await request.post('/cacheVerticalGlass/bigStorageCageDetails/selectBigStorageCageDetails',{
      glassId:glassId.value
    const response = await request.post('/cacheVerticalGlass/bigStorageCageDetails/selectBigStorageCageDetails', {
      glassId: glassId.value
    });
    if (response.code == 200) {
      tableDataf.value = response.data;
@@ -192,28 +192,28 @@
};
// 是否禁用
const toggleEnableState = async (row) => {
  const newState = row.enableState === 1 ? 0 : 1;  
  var url="/hollowGlass/hollowBigStorageCageDetails/updateHollowStorageCageDisabled?slot="+row.slot + "&enableState=" + newState;
      const response = await request.get(url) 
  const newState = row.enableState === 1 ? 0 : 1;
  var url = "/hollowGlass/hollowBigStorageCageDetails/updateHollowStorageCageDisabled?slot=" + row.slot + "&enableState=" + newState;
  const response = await request.get(url)
  if (response.code === 200) {
      ElMessage.success(response.message);
      } else {  
      ElMessage.error(response.message);
      }  
  row.enableState = newState;  
}; 
 // 删除 
 const opena = async(row) => {  
    ElMessage.success(response.message);
  } else {
    ElMessage.error(response.message);
  }
  row.enableState = newState;
};
// 删除
const opena = async (row) => {
  try {
    const confirmResult = await ElMessageBox.confirm(  
      t('searchOrder.deletemessage'), 
      t('searchOrder.prompt'),  
      {  
        confirmButtonText: t('searchOrder.yes'), 
    const confirmResult = await ElMessageBox.confirm(
      t('searchOrder.deletemessage'),
      t('searchOrder.prompt'),
      {
        confirmButtonText: t('searchOrder.yes'),
        cancelButtonText: t('searchOrder.cancel'),
        type: 'warning',  
      } 
    ); 
        type: 'warning',
      }
    );
    if (confirmResult === 'confirm') {
      const params = new URLSearchParams();
      params.append('state', '8');
@@ -222,21 +222,21 @@
      params.append('slot', row.slot);
      var url = `/hollowGlass/hollowBigStorageCageDetails/deleteHollowBigStorageCageDetails?${params.toString()}`;
      const response = await request.post(url)
    if (response.code === 200) {
       fetchxiang();
      //  tableDataa.value = response.data;
     ElMessage.success(response.message);
      if (response.code === 200) {
        fetchxiang();
        //  tableDataa.value = response.data;
        ElMessage.success(response.message);
      } else {
      ElMessage.error(response.message);
      }  
    }  
        ElMessage.error(response.message);
      }
    }
  } catch (error) {
  }  
}; 
  }
};
// 缺片详情-破损
const handleBroke = async (row) => {
  try {
     const confirmResult = await ElMessageBox.confirm(
    const confirmResult = await ElMessageBox.confirm(
      t('searchOrder.broke'),
      t('workOrder.prompt'),
      {
@@ -269,7 +269,7 @@
// 缺片详情-一键破损
const handleAllBroke = async (row) => {
  try {
     const confirmResult = await ElMessageBox.confirm(
    const confirmResult = await ElMessageBox.confirm(
      t('order.dilapidationWhether'),
      t('workOrder.prompt'),
      {
@@ -298,18 +298,18 @@
    console.error(error);
  }
}
 // 破损
 const broke = async(row) => {  
// 破损
const broke = async (row) => {
  try {
    const confirmResult = await ElMessageBox.confirm(  
      t('searchOrder.broke'), 
      t('searchOrder.prompt'),  
      {  
        confirmButtonText: t('searchOrder.yes'), 
    const confirmResult = await ElMessageBox.confirm(
      t('searchOrder.broke'),
      t('searchOrder.prompt'),
      {
        confirmButtonText: t('searchOrder.yes'),
        cancelButtonText: t('searchOrder.cancel'),
        type: 'warning',  
      } 
    ); 
        type: 'warning',
      }
    );
    if (confirmResult === 'confirm') {
      const params = new URLSearchParams();
      params.append('state', '8');
@@ -317,30 +317,30 @@
      params.append('glassId', row.glassId);
      params.append('slot', row.slot);
      var url = `/hollowGlass/hollowBigStorageCageDetails/damageHollowBigStorageCageDetails?${params.toString()}`;
    const response = await request.post(url)
      const response = await request.post(url)
      if (response.code === 200) {
       fetchxiang(); 
     ElMessage.success(response.message);
      } else {  
      ElMessage.error(response.message);
      }  
    }  
        fetchxiang();
        ElMessage.success(response.message);
      } else {
        ElMessage.error(response.message);
      }
    }
  } catch (error) {
  }  
}; 
 // 拿走
 const brokec = async(row) => {  
  }
};
// 拿走
const brokec = async (row) => {
  try {
    const confirmResult = await ElMessageBox.confirm(  
      t('searchOrder.brokeb'), 
      t('searchOrder.prompt'),  
      {  
        confirmButtonText: t('searchOrder.yes'), 
    const confirmResult = await ElMessageBox.confirm(
      t('searchOrder.brokeb'),
      t('searchOrder.prompt'),
      {
        confirmButtonText: t('searchOrder.yes'),
        cancelButtonText: t('searchOrder.cancel'),
        type: 'warning',  
      } 
    ); 
    if (confirmResult === 'confirm') {  
        type: 'warning',
      }
    );
    if (confirmResult === 'confirm') {
      const params = new URLSearchParams();
      params.append('state', '9');
      params.append('deviceId', row.deviceId);
@@ -349,49 +349,49 @@
      var url = `/hollowGlass/hollowBigStorageCageDetails/damageHollowBigStorageCageDetails?${params.toString()}`;
      const response = await request.post(url)
      if (response.code === 200) {
       fetchxiang();
       ElMessage.success(response.message);
      } else {  
      ElMessage.error(response.message);
      }  
    }  
        fetchxiang();
        ElMessage.success(response.message);
      } else {
        ElMessage.error(response.message);
      }
    }
  } catch (error) {
  }  
}; 
  }
};
// 确认添加
const finisha = async(row) => {  
const finisha = async (row) => {
  try {
    const confirmResult = await ElMessageBox.confirm(  
      t('searchOrder.sureadda'), 
      t('searchOrder.prompt'),  
      {  
        confirmButtonText: t('searchOrder.yes'), 
    const confirmResult = await ElMessageBox.confirm(
      t('searchOrder.sureadda'),
      t('searchOrder.prompt'),
      {
        confirmButtonText: t('searchOrder.yes'),
        cancelButtonText: t('searchOrder.cancel'),
        type: 'warning',  
      } 
    ); 
    if (confirmResult === 'confirm') {  
    let deviceId = window.localStorage.getItem('deviceId')
    let slot = window.localStorage.getItem('slot')
      const dataToSend = {  
        type: 'warning',
      }
    );
    if (confirmResult === 'confirm') {
      let deviceId = window.localStorage.getItem('deviceId')
      let slot = window.localStorage.getItem('slot')
      const dataToSend = {
        ...row,
        deviceId: deviceId,
        slot: slot
      };  
      };
      const response = await request.post("/cacheVerticalGlass/hollowBigStorageCageDetails/insertHollowBigStorageCageDetails", dataToSend)
    if (response.code === 200) {
      tableDataa.value = response.data;
      add.value = false;
      ElMessage.success(response.message);
      glassId.value = '';
      tableDataf.value = '';
      } else {  
      ElMessage.error(response.message);
      }  
    }  
      if (response.code === 200) {
        tableDataa.value = response.data;
        add.value = false;
        ElMessage.success(response.message);
        glassId.value = '';
        tableDataf.value = '';
      } else {
        ElMessage.error(response.message);
      }
    }
  } catch (error) {
  }  
}; 
  }
};
// 警报确认
const handleSure = async (row) => {
  try {
@@ -423,7 +423,7 @@
};
const handlexiang = () => {
  dialogFormVisiblea.value = true;
  fetchxiang(); 
  fetchxiang();
  currentPage2.value = 1;
  window.localStorage.setItem('pagenumber', currentPage2.value)
  filmsId.value = ''
@@ -431,47 +431,47 @@
};
// 理片笼信息
const fetchxiang = async () => {
  try {     
    const response = await request.post('/hollowGlass/hollowBigStorageCageDetails/queryVerticalSheetCageDetailsList',{
        // deviceId: page,
        engineerId: engineerId.value,
        filmsId: filmsId.value,
        flowCardId: flowCardId.value,
        glassId: glassId.value,
        thickness: -1,
  try {
    const response = await request.post('/hollowGlass/hollowBigStorageCageDetails/queryVerticalSheetCageDetailsList', {
      // deviceId: page,
      engineerId: engineerId.value,
      filmsId: filmsId.value,
      flowCardId: flowCardId.value,
      glassId: glassId.value,
      thickness: -1,
    })
    if (response.code === 200) {  
    if (response.code === 200) {
      ElMessage.success(response.message);
      tableDataa.value = response.data
    } else {  
    } else {
      ElMessage.warning(response.msg)
    }  
    }
  } catch (error) {
  } 
  }
}
const fetchxianga = async () => {
  let page = window.localStorage.getItem('pagenumber')
  try {     
    const response = await request.post('/hollowGlass/hollowBigStorageCageDetails/queryVerticalSheetCageDetailsList',{
        deviceId: page,
        engineerId: engineerId.value,
        filmsId: filmsId.value,
        flowCardId: flowCardId.value,
        glassId: glassId.value,
        thickness: thickness.value ? thickness.value : -1,
  try {
    const response = await request.post('/hollowGlass/hollowBigStorageCageDetails/queryVerticalSheetCageDetailsList', {
      deviceId: page,
      engineerId: engineerId.value,
      filmsId: filmsId.value,
      flowCardId: flowCardId.value,
      glassId: glassId.value,
      thickness: thickness.value ? thickness.value : -1,
    })
    if (response.code === 200) {  
    if (response.code === 200) {
      ElMessage.success(response.message);
      tableDataa.value = response.data
      filmsId.value = ''
      flowCardId.value = ''
    } else {  
    } else {
      ElMessage.warning(response.msg)
    }  
    }
  } catch (error) {
  } 
  }
}
function handleRowClick(row) {  
function handleRowClick(row) {
  selectedRow.value = row; // 更新选中的行数据  
}
// 任务重置
@@ -499,78 +499,78 @@
// }; 
// 调度开关
const handlediaodu = async () => {
  try  {
    const body = {  
  try {
    const body = {
      flag: diaodu.value,
    };
    var url="/hollowGlass/hollowGlassOutRelationInfo/dispatchHollowSwitch?flag="+diaodu.value;
  const response = await request.post(url)
    var url = "/hollowGlass/hollowGlassOutRelationInfo/dispatchHollowSwitch?flag=" + diaodu.value;
    const response = await request.post(url)
    if (response.code == 200) {
      ElMessage.success(response.message);
      diaodu.value = response.data
    }else {  
    } else {
      ElMessage.error(response.message);
      }  
}
catch (error) {
    }
  }
  catch (error) {
  }
}
// 中空优先级开关
const handlehollowPriority = async () => {
  try  {
    const body = {  
  try {
    const body = {
      flag: hollowPriority.value,
    };
  var url="/hollowGlass/hollowGlassOutRelationInfo/priorityHollowSwitch?flag="+hollowPriority.value;
  const response = await request.post(url)
    var url = "/hollowGlass/hollowGlassOutRelationInfo/priorityHollowSwitch?flag=" + hollowPriority.value;
    const response = await request.post(url)
    if (response.code == 200) {
      ElMessage.success(response.message);
      hollowPriority.value = response.data
    }else {  
    } else {
      ElMessage.error(response.message);
      }  
}
catch (error) {
    }
  }
  catch (error) {
  }
}
let socket = null;
const socketUrl = `ws://${window.ipConfig.serverUrl}/api/hollowGlass/api/talk/hollowGlassMessage`;
const handleMessage = (data) => {
  // 报警信息
if (data.alarmInfo[0] != null && data.alarmInfo[0].length > 0) {
  const alert = data.alarmInfo[0];
  const { id, alarmMessage, ...rest } = alert[0];
  alertMessage.value = `${alarmMessage}`;
  alertMessage.value = `${alert[0].alarmMessage}`;
  if (alert[0].alarmCode === 'sizeSame') {
    alertText.value = t('hellow.sizeSame');
  } else if (alert[0].alarmCode === 'idSame') {
    alertText.value = t('hellow.idSame');
  } else if (alert[0].alarmCode === 'slotLess') {
    alertText.value = t('hellow.slotLess');
  } else if (alert[0].alarmCode === 'overSize') {
    alertText.value = t('hellow.overSize');
  } else if (alert[0].alarmCode === 'noGlass') {
    alertText.value = t('hellow.noGlass');
  } else {
    alertText.value = t('hellow.unknownAlert');
  }
  if (data.alarmInfo[0] != null && data.alarmInfo[0].length > 0) {
    const alert = data.alarmInfo[0];
    const { id, alarmMessage, ...rest } = alert[0];
    alertMessage.value = `${alarmMessage}`;
    alertMessage.value = `${alert[0].alarmMessage}`;
    if (alert[0].alarmCode === 'sizeSame') {
      alertText.value = t('hellow.sizeSame');
    } else if (alert[0].alarmCode === 'idSame') {
      alertText.value = t('hellow.idSame');
    } else if (alert[0].alarmCode === 'slotLess') {
      alertText.value = t('hellow.slotLess');
    } else if (alert[0].alarmCode === 'overSize') {
      alertText.value = t('hellow.overSize');
    } else if (alert[0].alarmCode === 'noGlass') {
      alertText.value = t('hellow.noGlass');
    } else {
      alertText.value = t('hellow.unknownAlert');
    }
    alarmData.value = data; // 存储完整数据用于弹窗
    showAlert.value = true;
}
   const formattedData = data.alarmInfo[0].map(record => ({
     ...record,
     formattedCreateTime: formatTimestamp(record.createTime),
     alarmCode: record.alarmCode,
     alarmMessage: record.alarmMessage
   }));
    tableDataAlert.value = formattedData;
  }
  const formattedData = data.alarmInfo[0].map(record => ({
    ...record,
    formattedCreateTime: formatTimestamp(record.createTime),
    alarmCode: record.alarmCode,
    alarmMessage: record.alarmMessage
  }));
  tableDataAlert.value = formattedData;

  if(data.HollowAllFlowCard!=null){
    tableDatass.value = data.HollowAllFlowCard[0];
  }else{
    tableDatass.value = []
      }
  }
  if (data.inkageEntity != null) {
    inkageEntity.value = data.inkageEntity[0] == true ? 'green' : '#911005';
  }
@@ -595,14 +595,14 @@
  if (data.freeOneRequestEntity != null) {
    freeone.value = data.freeOneRequestEntity == 1 ? 'green' : '#911005';
  }
  if(data.bigStorageCageDetailsOutTask!=null){
  if (data.bigStorageCageDetailsOutTask != null) {
    tableDatac.value = data.bigStorageCageDetailsOutTask[0]
    adjusta.value = data.bigStorageCageDetailsOutTask[0].filter(rect => rect.slot !== null && rect.slot !== undefined);
  } else {
    tableDatac.value = [],
    adjusta.value = []
      adjusta.value = []
  }
    if (data.scanGlass != null) {
  if (data.scanGlass != null) {
    scanGlass.value = data.scanGlass[0];
    let width = scanGlass.value.width;
    let height = scanGlass.value.height;
@@ -611,83 +611,53 @@
      scanGlass.value.height = width;
    }
  }
  if(data.bigStorageCageDetailsFeedTask!=null){
  if (data.bigStorageCageDetailsFeedTask != null) {
    tableDatad.value = data.bigStorageCageDetailsFeedTask[0]
    adjust.value = data.bigStorageCageDetailsFeedTask[0].filter(rect => rect.slot !== null && rect.slot !== undefined); 
  }else{
    adjust.value = data.bigStorageCageDetailsFeedTask[0].filter(rect => rect.slot !== null && rect.slot !== undefined);
  } else {
    tableDatad.value = []
      }
if(data.temperingGlassInfoList!=null){
  tableDatab.value = data.temperingGlassInfoList[0]
}else{
  }
  if (data.temperingGlassInfoList != null) {
    tableDatab.value = data.temperingGlassInfoList[0]
  } else {
    tableDatab.value = []
      }
if(data.bigStorageCageUsage!=null){
  tableDatae.value = data.bigStorageCageUsage[0]
}else{
  }
  if (data.bigStorageCageUsage != null) {
    tableDatae.value = data.bigStorageCageUsage[0]
  } else {
    tableDatae.value = []
      }
if(data.carPostion!=null){
  carPosition.value = data.carPostion[0]
}else{
  carPosition.value = []
  }
if(data.dispatchHollowSwitch!=null){
  diaodu.value = data.dispatchHollowSwitch[0]
}else{
  diaodu.value = ''
  if (data.carPostion != null) {
    carPosition.value = data.carPostion[0]
  } else {
    carPosition.value = []
  }
if(data.priorityHollowSwitch!=null){
  hollowPriority.value = data.priorityHollowSwitch[0]
}else{
  hollowPriority.value = ''
  if (data.dispatchHollowSwitch != null) {
    diaodu.value = data.dispatchHollowSwitch[0]
  } else {
    diaodu.value = ''
  }
//   if(data.bigStorageCageInfos!=null){
//     adjustedRects.value = data.bigStorageCageInfos[0][1].map((rect, index) => ({
//     id: index + 1,
//     height: 15/55,
//     top: 64/55,
//   }));
// subRectsCounts.value = data.bigStorageCageInfos[0][1].map(rect => rect.count);
// adjustedRectsa.value = data.bigStorageCageInfos[0][2].map((rect, index) => ({
//     id: index + 1,
//     height: 15/55,
//     top: 64/55,
//   }));
// subRectsCountsa.value = data.bigStorageCageInfos[0][2].map(rect => rect.count);
// adjustedRectsb.value = data.bigStorageCageInfos[0][3].map((rect, index) => ({
//     id: index + 1,
//     height: 15/55,
//     top: 64/55,
//   }));
// subRectsCountsb.value = data.bigStorageCageInfos[0][3].map(rect => rect.count);
// adjustedRectsc.value = data.bigStorageCageInfos[0][4].map((rect, index) => ({
//     id: index + 1,
//     height: 15/55,
//     top: 64/55,
//   }));
// subRectsCountsc.value = data.bigStorageCageInfos[0][4].map(rect => rect.count);
// adjustedRectsd.value = data.bigStorageCageInfos[0][5].map((rect, index) => ({
//     id: index + 1,
//     height: 15/55,
//     top: 64/55,
//   }));
// subRectsCountsd.value = data.bigStorageCageInfos[0][5].map(rect => rect.count);
// adjustedRectse.value = data.bigStorageCageInfos[0][6].map((rect, index) => ({
//     id: index + 1,
//     height: 15/55,
//     top: 64/55,
//   }));
// subRectsCountse.value = data.bigStorageCageInfos[0][6].map(rect => rect.count);

//   }else{
//     adjustedRects.value = '',
//     adjustedRectsa.value = '',
//     adjustedRectsb.value = '',
//     adjustedRectsc.value = '',
//     adjustedRectsd.value = '',
//     adjustedRectse.value = ''
//   }
  if (data.priorityHollowSwitch != null) {
    hollowPriority.value = data.priorityHollowSwitch[0]
  } else {
    hollowPriority.value = ''
  }
  if (data.bigStorageCageInfos != null) {
    adjustedRects.value = data.bigStorageCageInfos[0][1];
    adjustedRectsa.value = data.bigStorageCageInfos[0][2];
    console.log(adjustedRectsa.value)
    adjustedRectsb.value = data.bigStorageCageInfos[0][3];
    adjustedRectsc.value = data.bigStorageCageInfos[0][4];
    adjustedRectsd.value = data.bigStorageCageInfos[0][5];
    adjustedRectse.value = data.bigStorageCageInfos[0][6];
  } else {
    adjustedRects.value = '',
      adjustedRectsa.value = '',
      adjustedRectsb.value = '',
      adjustedRectsc.value = '',
      adjustedRectsd.value = '',
      adjustedRectse.value = ''
  }
};
const getAlertText = (alarmCode) => {
  const codeMap = {
@@ -697,8 +667,8 @@
    overSize: 'hellow.overSize',
    noGlass: 'hellow.noGlass'
  };
  return alarmCode in codeMap 
    ? t(codeMap[alarmCode]) 
  return alarmCode in codeMap
    ? t(codeMap[alarmCode])
    : t('hellow.unknownAlert');
};
// 警报双击弹窗
@@ -706,11 +676,11 @@
  showModal.value = true;
};
// 计算每个大矩形的样式
const rectStyle = (rect, index) => ({
const rectStyle = (rect, index, high) => ({
  position: 'absolute',
  width: '150px',
  left: '0px',
  top: `${index*rect.top}px`,
  top: `${index * high}px`,
  height: `${rect.height}px`,
});
// 计算每个小矩形的样式和数量
@@ -723,15 +693,17 @@
  return subRects;
};
// 计算每个小矩形的样式
const proportion = ref((150 / 6200).toFixed(2));
const subRectStyle = (rectIndex, subIndex) => {
  const width = '18px';
  const width = `${rectIndex.length * proportion.value}px`;
  // const width = '18px';
  const marginLeft = '3px';
  const totalWidth = 6 * (parseInt(width) + parseInt(marginLeft));
  const left = `${(subIndex * (parseInt(width) + parseInt(marginLeft))) / totalWidth * 100}%`;
  return {
    position: 'absolute',
    width,
    height: '100%',
    height: '1px',
    marginLeft,
    top: '0px',
    backgroundColor: '#911005',
@@ -743,7 +715,7 @@
  position: 'absolute',
  width: '150px',
  left: '0px',
  top: `${index*rect.top}px`,
  top: `${index * rect.top}px`,
  height: `${rect.height}px`,
});
// 计算每个小矩形的样式和数量
@@ -776,7 +748,7 @@
  position: 'absolute',
  width: '150px',
  left: '0px',
  top: `${index*rect.top}px`,
  top: `${index * rect.top}px`,
  height: `${rect.height}px`,
});
// 计算每个小矩形的样式和数量
@@ -809,7 +781,7 @@
  position: 'absolute',
  width: '150px',
  left: '0px',
  top: `${index*rect.top}px`,
  top: `${index * rect.top}px`,
  height: `${rect.height}px`,
});
// 计算每个小矩形的样式和数量
@@ -842,7 +814,7 @@
  position: 'absolute',
  width: '150px',
  left: '0px',
  top: `${index*rect.top}px`,
  top: `${index * rect.top}px`,
  height: `${rect.height}px`,
});
// 计算每个小矩形的样式和数量
@@ -903,37 +875,37 @@
onMounted(() => {
  socket = initializeWebSocket(socketUrl, handleMessage);
});
  onUnmounted(() => {
    if (socket) {
onUnmounted(() => {
  if (socket) {
    closeWebSocket(socket);
    }
    });
  }
});
// 格式化时间戳为年月日时间字符串的函数
function formatTimestamp(timestamp) {
const date = new Date(timestamp);
const year = date.getFullYear();
const month = String(date.getMonth() + 1).padStart(2, '0'); // 月份从0开始，需要加1，并补零
const day = String(date.getDate()).padStart(2, '0'); // 补零
const hours = String(date.getHours()).padStart(2, '0'); // 补零（如果需要显示时间）
const minutes = String(date.getMinutes()).padStart(2, '0'); // 补零（如果需要显示时间）
const seconds = String(date.getSeconds()).padStart(2, '0'); // 补零（如果需要显示时间）
return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
  const date = new Date(timestamp);
  const year = date.getFullYear();
  const month = String(date.getMonth() + 1).padStart(2, '0'); // 月份从0开始，需要加1，并补零
  const day = String(date.getDate()).padStart(2, '0'); // 补零
  const hours = String(date.getHours()).padStart(2, '0'); // 补零（如果需要显示时间）
  const minutes = String(date.getMinutes()).padStart(2, '0'); // 补零（如果需要显示时间）
  const seconds = String(date.getSeconds()).padStart(2, '0'); // 补零（如果需要显示时间）
  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
}
function getcasOnea(isSame) {  
  switch (isSame) {  
function getcasOnea(isSame) {
  switch (isSame) {
    case 1:
      return 'danger';  
    case 0: 
      return 'info';  
  }  
}  
      return 'danger';
    case 0:
      return 'info';
  }
}
function getStatuscasOnea(isSame) {
  switch (isSame) {
    case 1:  
    case 1:
      return t('searchOrder.same');
    case 0:  
      return t('searchOrder.notsame'); 
  }  
    case 0:
      return t('searchOrder.notsame');
  }
}
function tableRowClassName({ row }) {
  if (row.isSame === 1) {
@@ -948,174 +920,148 @@
<template>
  <div style="height: 600px;">
    <div v-if="showAlert" class="global-alert-bar" @dblclick="handleDoubleClick">
    <div class="alert-content">
      <el-icon><WarnTriangleFilled /></el-icon>
      <span class="alert-text">
        {{ alertText }} (id:{{ alertMessage }})
        <span class="confirm-text">{{ $t('hellow.pleaseConfirm') }}</span>
      </span>
    </div>
    <button @click="showAlert = false" class="close-btn">×</button>
  </div>
  <el-dialog
    v-model="showModal"
    width="40%"
    center
  >
      <el-table 
      ref="table"
      border
      :data="tableDataAlert" 
      max-height="calc(500px - 35px)"
      style="width: 100%;"
    >
      <el-table-column prop="formattedCreateTime" align="center" :label="$t('film.createtime')" min-width="100" />
      <el-table-column 
       :label="$t('hellow.content')" 
       align="center" 
       min-width="220"
     >
       <template #default="scope">
           <span>
             {{ getAlertText(scope.row.alarmCode) }} 
             (id:{{ scope.row.alarmMessage }})
           </span>
       </template>
     </el-table-column>
      <el-table-column fixed="right" :label="$t('film.operate')" align="center" width="100">
        <template #default="scope">
          <el-button type="text" plain
            @click="handleSure(scope.row)">{{ $t('basicData.yes') }}</el-button>
        </template>
      </el-table-column>
    </el-table>
  </el-dialog>
    <div style="display: flex;">
    <el-button style="margin-top: 7px;margin-left: 10px;" id="searchButton" type="primary" @click="handlexiang">{{ $t('searchOrder.cageinformation') }}</el-button>
    <el-button style="margin-top: 7px;margin-left: 10px;" id="searchButton" type="success" @click="handlehistorical">{{ $t('searchOrder.historicaltasks') }}</el-button>
    <!-- <el-button style="margin-top: 7px;margin-left: 10px;" id="searchButton" type="danger" @click="handleptask()">{{ $t('searchOrder.partask') }}</el-button> -->
    <el-switch style="margin-top: 7px;margin-left: 10px;" v-model="diaodu" class="mb-2" :inactive-text="$t('searchOrder.Schedulingswitch')" @change="handlediaodu" />
    <div style="display: flex;">
   <div style="margin-left: 15px;margin-top: 5px;font-size: 14px;top: 5vh;margin-top: 12px;">{{ $t('searchOrder.hollowPriority') }}：</div>
   <div style="margin-left: 15px;margin-top: 5px;font-size: 14px;top: 5vh;margin-top: 12px;color: #911005;">{{ $t('searchOrder.firstLinePriority') }}</div>
    <el-switch 
       style="margin-top: 7px;margin-left: 10px;" 
       v-model="hollowPriority" 
       class="mb-2" 
       @change="handlehollowPriority" 
     />
   <div style="margin-left: 15px;margin-top: 5px;font-size: 14px;top: 5vh;margin-top: 12px;color: rgb(184, 130, 48)">{{ $t('searchOrder.secondLinePriority') }}</div>
     </div>
</div>
    <div id="dotClass">
        <div>{{ $t('searchOrder.inkageEntity') }}</div>
        <i :style="{ marginTop: '2px', backgroundColor: inkageEntity, width: '18px', height: '18px', borderRadius: '50%', display: 'block' }"></i>
        <div style="margin-left: 70px;">{{ $t('searchOrder.requestEntity') }}</div>
        <i :style="{ marginTop: '2px', backgroundColor: requestEntity, width: '18px', height: '18px', borderRadius: '50%', display: 'block' }"></i>
        <div style="margin-left: 70px;">{{ $t('searchOrder.mesReplyEntity') }}</div>
        <i :style="{ marginTop: '2px', backgroundColor: mesReplyEntity, width: '18px', height: '18px', borderRadius: '50%', display: 'block' }"></i>
        <div style="margin-left: 70px;">{{ $t('searchOrder.outInkageEntity') }}</div>
        <i :style="{ marginTop: '2px', backgroundColor: outInkageEntity, width: '18px', height: '18px', borderRadius: '50%', display: 'block' }"></i>
        <div style="margin-left: 70px;">{{ $t('searchOrder.outRequestEntity') }}</div>
        <i :style="{ marginTop: '2px', backgroundColor: outRequestEntity, width: '18px', height: '18px', borderRadius: '50%', display: 'block' }"></i>
        <div style="margin-left: 70px;">{{ $t('hellow.freeone') }}</div>
        <i :style="{ marginTop: '2px', backgroundColor: freeone, width: '18px', height: '18px', borderRadius: '50%', display: 'block' }"></i>
        <div style="margin-left: 70px;">{{ $t('hellow.freetwo') }}</div>
        <i :style="{ marginTop: '2px', backgroundColor: freetwo, width: '18px', height: '18px', borderRadius: '50%', display: 'block' }"></i>
        <div style="margin-left: 70px;">{{ $t('hellow.freethree') }}</div>
        <i :style="{ marginTop: '2px', backgroundColor: freethree, width: '18px', height: '18px', borderRadius: '50%', display: 'block' }"></i>
      <div class="alert-content">
        <el-icon>
          <WarnTriangleFilled />
        </el-icon>
        <span class="alert-text">
          {{ alertText }} (id:{{ alertMessage }})
          <span class="confirm-text">{{ $t('hellow.pleaseConfirm') }}</span>
        </span>
      </div>
      <button @click="showAlert = false" class="close-btn">×</button>
    </div>
    <el-dialog v-model="showModal" width="40%" center>
      <el-table ref="table" border :data="tableDataAlert" max-height="calc(500px - 35px)" style="width: 100%;">
        <el-table-column prop="formattedCreateTime" align="center" :label="$t('film.createtime')" min-width="100" />
        <el-table-column :label="$t('hellow.content')" align="center" min-width="220">
          <template #default="scope">
            <span>
              {{ getAlertText(scope.row.alarmCode) }}
              (id:{{ scope.row.alarmMessage }})
            </span>
          </template>
        </el-table-column>
        <el-table-column fixed="right" :label="$t('film.operate')" align="center" width="100">
          <template #default="scope">
            <el-button type="text" plain @click="handleSure(scope.row)">{{ $t('basicData.yes') }}</el-button>
          </template>
        </el-table-column>
      </el-table>
    </el-dialog>
    <div style="display: flex;">
      <el-button style="margin-top: 7px;margin-left: 10px;" id="searchButton" type="primary" @click="handlexiang">{{
        $t('searchOrder.cageinformation') }}</el-button>
      <el-button style="margin-top: 7px;margin-left: 10px;" id="searchButton" type="success"
        @click="handlehistorical">{{
          $t('searchOrder.historicaltasks') }}</el-button>
      <!-- <el-button style="margin-top: 7px;margin-left: 10px;" id="searchButton" type="danger" @click="handleptask()">{{ $t('searchOrder.partask') }}</el-button> -->
      <el-switch style="margin-top: 7px;margin-left: 10px;" v-model="diaodu" class="mb-2"
        :inactive-text="$t('searchOrder.Schedulingswitch')" @change="handlediaodu" />
      <div style="display: flex;">
        <div style="margin-left: 15px;margin-top: 5px;font-size: 14px;top: 5vh;margin-top: 12px;">{{
          $t('searchOrder.hollowPriority') }}：</div>
        <div style="margin-left: 15px;margin-top: 5px;font-size: 14px;top: 5vh;margin-top: 12px;color: #911005;">{{
          $t('searchOrder.firstLinePriority') }}</div>
        <el-switch style="margin-top: 7px;margin-left: 10px;" v-model="hollowPriority" class="mb-2"
          @change="handlehollowPriority" />
        <div
          style="margin-left: 15px;margin-top: 5px;font-size: 14px;top: 5vh;margin-top: 12px;color: rgb(184, 130, 48)">
          {{
            $t('searchOrder.secondLinePriority') }}</div>
      </div>
    </div>
    <div id="dotClass">
      <div>{{ $t('searchOrder.inkageEntity') }}</div>
      <i
        :style="{ marginTop: '2px', backgroundColor: inkageEntity, width: '18px', height: '18px', borderRadius: '50%', display: 'block' }"></i>
      <div style="margin-left: 70px;">{{ $t('searchOrder.requestEntity') }}</div>
      <i
        :style="{ marginTop: '2px', backgroundColor: requestEntity, width: '18px', height: '18px', borderRadius: '50%', display: 'block' }"></i>
      <div style="margin-left: 70px;">{{ $t('searchOrder.mesReplyEntity') }}</div>
      <i
        :style="{ marginTop: '2px', backgroundColor: mesReplyEntity, width: '18px', height: '18px', borderRadius: '50%', display: 'block' }"></i>
      <div style="margin-left: 70px;">{{ $t('searchOrder.outInkageEntity') }}</div>
      <i
        :style="{ marginTop: '2px', backgroundColor: outInkageEntity, width: '18px', height: '18px', borderRadius: '50%', display: 'block' }"></i>
      <div style="margin-left: 70px;">{{ $t('searchOrder.outRequestEntity') }}</div>
      <i
        :style="{ marginTop: '2px', backgroundColor: outRequestEntity, width: '18px', height: '18px', borderRadius: '50%', display: 'block' }"></i>
      <div style="margin-left: 70px;">{{ $t('hellow.freeone') }}</div>
      <i
        :style="{ marginTop: '2px', backgroundColor: freeone, width: '18px', height: '18px', borderRadius: '50%', display: 'block' }"></i>
      <div style="margin-left: 70px;">{{ $t('hellow.freetwo') }}</div>
      <i
        :style="{ marginTop: '2px', backgroundColor: freetwo, width: '18px', height: '18px', borderRadius: '50%', display: 'block' }"></i>
      <div style="margin-left: 70px;">{{ $t('hellow.freethree') }}</div>
      <i
        :style="{ marginTop: '2px', backgroundColor: freethree, width: '18px', height: '18px', borderRadius: '50%', display: 'block' }"></i>
    </div>
    <div style="display: flex; align-items: flex-start; gap: 20px; height: 70vh;">
<!-- // 父级框 -->
<div class="img-zkdlpl" >
    <div class="img-car1" :style="'z-index:999;left:212px;top:' + 1300*carPosition[0] + 'px;position:absolute;'">
      <div  
      v-for="(rect, index) in adjusta"  
      :key="rect.id"  
      :style="{
       width: '30px',
       height: '5px',
       backgroundColor: '#409EFF',
       marginLeft: 5+ `px`,
       top: '10px',
       }"  
    >
    </div>
    </div>
    <div class="img-car4" :style="'z-index:999;left:580px;top:' + 450*carPosition[1] + 'px;position:absolute;'">
      <div  
      v-for="(rect, index) in adjust"  
      :key="rect.id"  
      :style="{
       width: '30px',
       height: '5px',
       backgroundColor: '#409EFF',
       marginLeft: 5+ `px`,
       top: '10px',
       }"  
    >
    </div>
    </div>
    <div style="position: relative;">
    <div v-show="cell1" style="width: 150px;height: 64px;position: relative;top:82px;left: 415px;">
      <div v-for="(rect, rectIndex) in adjustedRects" :key="rect.id" :style="rectStyle(rect, rectIndex)">
    <div
      v-for="(subRect, subIndex) in getSubRects(rectIndex)"
      :key="subIndex"
      :style="subRectStyle(rectIndex, subIndex)"
    ></div>
    </div>
    </div>
 <div v-show="cell2" style="width: 150px;height: 64px;position: relative;top:88px;left: 415px;">
  <div v-for="(rect, rectIndex) in adjustedRectsa" :key="rect.id" :style="rectStylea(rect, rectIndex)">
    <div
      v-for="(subRect, subIndex) in getSubRectsa(rectIndex)"
      :key="subIndex"
      :style="subRectStylea(rectIndex, subIndex)"
    ></div>
    </div>
    </div>
  <div v-show="cell3" style="width: 150px;height: 64px;position: relative;top:93px;left: 415px;">
    <div v-for="(rect, rectIndex) in adjustedRectsb" :key="rect.id" :style="rectStyleb(rect, rectIndex)">
    <div
      v-for="(subRect, subIndex) in getSubRectsb(rectIndex)"
      :key="subIndex"
      :style="subRectStyleb(rectIndex, subIndex)"
    ></div>
    </div>
    </div>
  <div v-show="cell4" style="width: 150px;height: 64px;position: relative;top:99px;left: 415px;">
    <div v-for="(rect, rectIndex) in adjustedRectsc" :key="rect.id" :style="rectStylec(rect, rectIndex)">
    <div
      v-for="(subRect, subIndex) in getSubRectsc(rectIndex)"
      :key="subIndex"
      :style="subRectStylec(rectIndex, subIndex)"
    ></div>
    </div>
    </div>
  <div v-show="cell5" style="width: 150px;height: 64px;position: relative;top:105px;left: 415px;">
    <div v-for="(rect, rectIndex) in adjustedRectsd" :key="rect.id" :style="rectStyled(rect, rectIndex)">
    <div
      v-for="(subRect, subIndex) in getSubRectsd(rectIndex)"
      :key="subIndex"
      :style="subRectStyled(rectIndex, subIndex)"
    ></div>
    </div>
    </div>
  <div v-show="cell6" style="width: 150px;height: 64px;position: relative;top:28px;left: 40px;">
    <div v-for="(rect, rectIndex) in adjustedRectse" :key="rect.id" :style="rectStyled(rect, rectIndex)">
    <div
      v-for="(subRect, subIndex) in getSubRectse(rectIndex)"
      :key="subIndex"
      :style="subRectStylee(rectIndex, subIndex)"
    ></div>
    </div>
    </div>
</div>
</div>
<el-card style="flex: 1; height: 500px; overflow-y: auto;">
  <div style="width: 100%; height: 100%; overflow: hidden;">
     <el-table ref="table" style="margin-top: 20px; height: 700px;" :data="tableDatass"
      <!-- // 父级框 -->
      <div class="img-zkdlpl">
        <div class="img-car1" :style="'z-index:999;left:212px;top:' + 1300 * carPosition[0] + 'px;position:absolute;'">
          <div v-for="(rect, index) in adjusta" :key="rect.id" :style="{
            width: '30px',
            height: '5px',
            backgroundColor: '#409EFF',
            marginLeft: 5 + `px`,
            top: '10px',
          }">
          </div>
        </div>
        <div class="img-car4" :style="'z-index:999;left:580px;top:' + 450 * carPosition[1] + 'px;position:absolute;'">
          <div v-for="(rect, index) in adjust" :key="rect.id" :style="{
            width: '30px',
            height: '5px',
            backgroundColor: '#409EFF',
            marginLeft: 5 + `px`,
            top: '10px',
          }">
          </div>
        </div>
        <div style="position: relative;">
          <div v-show="cell1" style="width: 150px;height: 64px;position: relative;top:82px;left: 415px;">
            <div v-for="(rect, rectIndex) in Object.values(adjustedRects)" :key="rect.id" :style="rectStyle(rect, rectIndex,1.6)">
              <div v-for="(subRect, subIndex) in rect" :key="subIndex"
                :style="subRectStyle(subRect, subIndex)"></div>
            </div>
          </div>
          <div v-show="cell2" style="width: 150px;height: 64px;position: relative;top:88px;left: 415px;">
            <div v-for="(rect, rectIndex) in Object.values(adjustedRectsa)" :key="rect.id" :style="rectStyle(rect, rectIndex,1.16)">
              <div v-for="(subRect, subIndex) in rect" :key="subIndex"
                :style="subRectStyle(subRect, subIndex)"></div>
            </div>
          </div>
          <div v-show="cell3" style="width: 150px;height: 64px;position: relative;top:93px;left: 415px;">
            <div v-for="(rect, rectIndex) in Object.values(adjustedRectsb)" :key="rect.id" :style="rectStyle(rect, rectIndex,1.16)">
              <div v-for="(subRect, subIndex) in rect" :key="subIndex"
                :style="subRectStyle(subRect, subIndex)"></div>
            </div>
          </div>
          <div v-show="cell4" style="width: 150px;height: 64px;position: relative;top:99px;left: 415px;">
            <div v-for="(rect, rectIndex) in Object.values(adjustedRectsc)" :key="rect.id" :style="rectStyle(rect, rectIndex,1.16)">
              <div v-for="(subRect, subIndex) in rect" :key="subIndex"
                :style="subRectStyle(subRect, subIndex)"></div>
            </div>
          </div>
          <div v-show="cell5" style="width: 150px;height: 64px;position: relative;top:105px;left: 415px;">
            <div v-for="(rect, rectIndex) in Object.values(adjustedRectsd)" :key="rect.id" :style="rectStyle(rect, rectIndex,1.16)">
              <div v-for="(subRect, subIndex) in rect" :key="subIndex"
                :style="subRectStyle(subRect, subIndex)"></div>
            </div>
          </div>
          <div v-show="cell6" style="width: 150px;height: 64px;position: relative;top:28px;left: 40px;">
            <div v-for="(rect, rectIndex) in Object.values(adjustedRectse)" :key="rect.id" :style="rectStyle(rect, rectIndex,2.56)">
              <div v-for="(subRect, subIndex) in rect" :key="subIndex"
                :style="subRectStyle(subRect, subIndex)"></div>
            </div>
          </div>
        </div>
      </div>
      <el-card style="flex: 1; height: 500px; overflow-y: auto;">
        <div style="width: 100%; height: 100%; overflow: hidden;">
          <el-table ref="table" style="margin-top: 20px; height: 700px;" :data="tableDatass"
      :row-class-name="tableRowClassName" :header-cell-style="{ background: '#F2F3F5', color: '#1D2129' }"
      row-key="projectNumber">
      <el-table-column>
@@ -1144,174 +1090,170 @@
        </template>
      </el-table-column>
    </el-table>
  </div>
</el-card>
  </div>
        </div>
      </el-card>
    </div>
    <div style="padding: 10px;display: flex;height:110px;margin-top: -170px;">
            <div v-for="(item, index) in tableDatae" :key="index" id="occupy">  
               <el-col style="text-align:left;font-weight: bold;">#{{ item.device_id }}</el-col>  
               <el-col style="text-align:left;display:flex;justify-content: space-between;align-items: center;">  
                 <span>{{ $t('searchOrder.Usage') }}</span><span>{{ item.percentage }}%</span>  
               </el-col>  
               <hr style="width:80%;margin: 0 auto;" />  
               <el-col style="text-align:left;display:flex;justify-content: space-between;align-items: center;">  
                 <span>{{ $t('searchOrder.free') }}</span><span>{{ item.count }}</span>  
               </el-col>  
             </div>  
      <div v-for="(item, index) in tableDatae" :key="index" id="occupy">
        <el-col style="text-align:left;font-weight: bold;">#{{ item.device_id }}</el-col>
        <el-col style="text-align:left;display:flex;justify-content: space-between;align-items: center;">
          <span>{{ $t('searchOrder.Usage') }}</span><span>{{ item.percentage }}%</span>
        </el-col>
        <hr style="width:80%;margin: 0 auto;" />
        <el-col style="text-align:left;display:flex;justify-content: space-between;align-items: center;">
          <span>{{ $t('searchOrder.free') }}</span><span>{{ item.count }}</span>
        </el-col>
      </div>
    </div>
    <div class="table-container">
    <el-card style="flex: 1;margin-left: 10px;margin-top: 3px;">
      <div style="width: 98%; height: calc(100% - 35px); overflow-y: auto;max-height: 140px;">
      <el-table height="120px" ref="table"
        :row-class-name="tableRowClassName"
        :data="tableDatad" :header-cell-style="{background:'#F2F3F5 ',color:'#1D2129'}">
          <el-table-column prop="glassId" align="center" :label="$t('searchOrder.intoglassid')" min-width="140" />
      <el-card style="flex: 1;margin-left: 10px;margin-top: 3px;">
        <div style="width: 98%; height: calc(100% - 35px); overflow-y: auto;max-height: 140px;">
          <el-table height="120px" ref="table" :row-class-name="tableRowClassName" :data="tableDatad"
            :header-cell-style="{ background: '#F2F3F5 ', color: '#1D2129' }">
            <el-table-column prop="glassId" align="center" :label="$t('searchOrder.intoglassid')" min-width="140" />
            <el-table-column prop="startSlot" align="center" :label="$t('searchOrder.startposition')" min-width="120" />
            <el-table-column prop="targetSlot" align="center" :label="$t('searchOrder.targetlocation')"
              min-width="120" />
            <el-table-column prop="taskState" align="center" :label="$t('searchOrder.taskstatus')" min-width="120">
              <template #default="scope">
                <el-tag type="success">{{ scope.row.taskState == 0 ? $t('searchOrder.filmenter') : $t('searchOrder.infilm')
                  }}</el-tag>
              </template>
            </el-table-column>
            <el-table-column prop="isSame" align="center" :label="$t('searchOrder.whethersame')" min-width="120">
              <template #default="scope">
                <el-tag :type="getcasOnea(scope.row.isSame)">
                  {{ getStatuscasOnea(scope.row.isSame) }}
                </el-tag>
              </template>
            </el-table-column>
          </el-table>
        </div>
      </el-card>
      <el-card style="flex: 1;margin-left: 10px;margin-top: 3px;">
        <el-table height="120px" ref="table" :data="tableDatac"
          :header-cell-style="{ background: '#F2F3F5 ', color: '#1D2129' }">
          <el-table-column prop="glassId" align="center" :label="$t('searchOrder.outputglassID')" min-width="140" />
          <el-table-column prop="startSlot" align="center" :label="$t('searchOrder.startposition')" min-width="120" />
          <el-table-column prop="targetSlot" align="center" :label="$t('searchOrder.targetlocation')" min-width="120" />
          <el-table-column prop="taskState" align="center" :label="$t('searchOrder.taskstatus')" min-width="120">
          <template #default="scope">
            <el-tag type="success" >{{ scope.row.taskState==0? $t('searchOrder.filmenter') : $t('searchOrder.infilm') }}</el-tag>
          </template>
          </el-table-column>
          <el-table-column prop="isSame" align="center" :label="$t('searchOrder.whethersame')" min-width="120">
          <template #default="scope">
        <el-tag :type="getcasOnea(scope.row.isSame)">
          {{ getStatuscasOnea(scope.row.isSame) }}
        </el-tag>
      </template>
          <el-table-column prop="taskState" align="center" :label="$t('searchOrder.taskstatus')" min-width="157">
            <template #default="scope">
              <el-tag type="success">{{ scope.row.taskState == 0 ? $t('searchOrder.filmenter') : $t('searchOrder.infilm')
                }}</el-tag>
            </template>
          </el-table-column>
        </el-table>
       </div>
    </el-card>
    <el-card style="flex: 1;margin-left: 10px;margin-top: 3px;">
      <el-table height="120px" ref="table" 
       :data="tableDatac" :header-cell-style="{background:'#F2F3F5 ',color:'#1D2129'}">
         <el-table-column prop="glassId" align="center" :label="$t('searchOrder.outputglassID')" min-width="140" />
         <el-table-column prop="startSlot" align="center" :label="$t('searchOrder.startposition')" min-width="120" />
         <el-table-column prop="targetSlot" align="center" :label="$t('searchOrder.targetlocation')" min-width="120" />
         <el-table-column prop="taskState" align="center" :label="$t('searchOrder.taskstatus')" min-width="157">
           <template #default="scope">
             <el-tag type="success" >{{ scope.row.taskState==0? $t('searchOrder.filmenter') : $t('searchOrder.infilm') }}</el-tag>
           </template>
         </el-table-column>
       </el-table>
            </el-card>
  </div>
      </el-card>
    </div>
  </div>
  <!-- 添加理片笼信息 -->
  <el-dialog v-model="add" top="10vh" width="70%" :title="$t('searchOrder.addcage')" >
  <el-dialog v-model="add" top="10vh" width="70%" :title="$t('searchOrder.addcage')">
    <div style="margin-bottom: 20px">
      <el-form>
        <el-row style="margin-top: -15px;margin-bottom: -2px;">
          <el-col :span="4">
              <div id="dt" style="font-size: 15px;">
              <el-form-item :label="$t('searchOrder.tida')"  style="width: 14vw">
            <div id="dt" style="font-size: 15px;">
              <el-form-item :label="$t('searchOrder.tida')" style="width: 14vw">
                {{ currentRow.deviceId }}
              </el-form-item>
              </div>
            </div>
          </el-col>
          <el-col :span="5">
            <div id="dta" style="font-size: 15px;">
          <el-form-item :label="$t('searchOrder.gridnumbera')" style="width: 14vw">
              <el-form-item :label="$t('searchOrder.gridnumbera')" style="width: 14vw">
                {{ currentRow.slot }}
              </el-form-item>
              </div>
            </div>
          </el-col>
        </el-row>
      </el-form>
    </div>
      <div style="margin-top: -20px;margin-bottom: 40px;margin-left: 30px">
          <el-input v-model="glassId"   :placeholder="$t('searchOrder.inputid')" clearable style="width: 200px;">
          </el-input>
          <el-button type="primary" plain style="margin-left: 10px;" @click="searchout">{{ $t('searchOrder.search') }}</el-button>
    <div style="margin-top: -20px;margin-bottom: 40px;margin-left: 30px">
      <el-input v-model="glassId" :placeholder="$t('searchOrder.inputid')" clearable style="width: 200px;">
      </el-input>
      <el-button type="primary" plain style="margin-left: 10px;" @click="searchout">{{ $t('searchOrder.search')
        }}</el-button>
    </div>
    <div style="width: 98%; height: calc(100% - 35px); overflow-y: auto;max-height: 200px;">
        <el-table height="100%" ref="table"
        :data="tableDataf" :header-cell-style="{background:'#F2F3F5 ',color:'#1D2129'}">
          <el-table-column prop="glassId" align="center" :label="$t('searchOrder.glassID')" min-width="120" />
          <el-table-column prop="sequence" align="center" :label="$t('searchOrder.pieceingrid')" min-width="180" />
          <el-table-column prop="flowCardId" align="center" :label="$t('searchOrder.cardnumber')" min-width="150" />
          <el-table-column prop="glassType" align="center" :label="$t('searchOrder.typeglass')" min-width="150"/>
          <el-table-column prop="width" align="center" :label="$t('searchOrder.width')" min-width="150"/>
          <el-table-column prop="height" align="center" :label="$t('searchOrder.height')" min-width="150"/>
          <el-table-column prop="thickness" align="center" :label="$t('searchOrder.thickness')" min-width="150"/>
          <el-table-column prop="temperingLayoutId" align="center" :label="$t('searchOrder.layoutID')" min-width="150"/>
          <el-table-column prop="temperingFeedSequence" align="center" :label="$t('searchOrder.picturesequence')" min-width="150"/>
          <el-table-column
          align="center"
            :label="$t('searchOrder.startstatus')"
            min-width="80"
            prop="state"
          >
          <template #default="scope">  
          <el-tag  
            :type="scope.row.state === 1 ? 'success' : 'danger'"  
          >  
          {{ scope.row.state === 1 ? $t('searchOrder.enable') : $t('searchOrder.disable') }}
          </el-tag>  
        </template> 
          </el-table-column>
          <el-table-column prop="gap" align="center" :label="$t('searchOrder.glassgaps')" min-width="150"/>
          <el-table-column fixed="right" :label="$t('searchOrder.operate')" align="center" width="150">
            <template #default="scope">
              <el-button type="text" plain @click="finisha(scope.row)">{{ $t('searchOrder.sureadd') }}</el-button>
            </template>
      <el-table height="100%" ref="table" :data="tableDataf"
        :header-cell-style="{ background: '#F2F3F5 ', color: '#1D2129' }">
        <el-table-column prop="glassId" align="center" :label="$t('searchOrder.glassID')" min-width="120" />
        <el-table-column prop="sequence" align="center" :label="$t('searchOrder.pieceingrid')" min-width="180" />
        <el-table-column prop="flowCardId" align="center" :label="$t('searchOrder.cardnumber')" min-width="150" />
        <el-table-column prop="glassType" align="center" :label="$t('searchOrder.typeglass')" min-width="150" />
        <el-table-column prop="width" align="center" :label="$t('searchOrder.width')" min-width="150" />
        <el-table-column prop="height" align="center" :label="$t('searchOrder.height')" min-width="150" />
        <el-table-column prop="thickness" align="center" :label="$t('searchOrder.thickness')" min-width="150" />
        <el-table-column prop="temperingLayoutId" align="center" :label="$t('searchOrder.layoutID')" min-width="150" />
        <el-table-column prop="temperingFeedSequence" align="center" :label="$t('searchOrder.picturesequence')"
          min-width="150" />
        <el-table-column align="center" :label="$t('searchOrder.startstatus')" min-width="80" prop="state">
          <template #default="scope">
            <el-tag :type="scope.row.state === 1 ? 'success' : 'danger'">
              {{ scope.row.state === 1 ? $t('searchOrder.enable') : $t('searchOrder.disable') }}
            </el-tag>
          </template>
        </el-table-column>
        </el-table>
      </div>
        <el-table-column prop="gap" align="center" :label="$t('searchOrder.glassgaps')" min-width="150" />
        <el-table-column fixed="right" :label="$t('searchOrder.operate')" align="center" width="150">
          <template #default="scope">
            <el-button type="text" plain @click="finisha(scope.row)">{{ $t('searchOrder.sureadd') }}</el-button>
          </template>
        </el-table-column>
      </el-table>
    </div>
  </el-dialog>
  <!-- 理片笼信息 -->
<el-dialog v-model="dialogFormVisiblea" top="2vh" width="97%" :title="$t('searchOrder.cageinformation')">
  <div style="display: flex;">
    <el-input v-model="engineerId" clearable style="margin-left: 10px;margin-bottom: 10px;width: 240px;" :placeholder="$t('processCard.projectnumber')"/>
    <el-input v-model="glassId" clearable style="margin-left: 10px;margin-bottom: 10px;width: 240px;" :placeholder="$t('searchOrder.inglassID')"/>
    <el-input v-model="flowCardId" clearable style="margin-left: 10px;margin-bottom: 10px;width: 240px;" :placeholder="$t('searchOrder.incardnumber')" />
    <el-input v-model="filmsId" clearable style="margin-left: 10px;margin-bottom: 10px;width: 240px;" :placeholder="$t('film.infilms')"/>
    <el-input v-model="thickness" clearable style="margin-left: 10px;margin-bottom: 10px;width: 240px;" :placeholder="$t('searchOrder.inthickness')"/>
    <el-button type="primary" style="margin-left: 10px;margin-bottom: 10px;" @click="fetchxianga">
      {{$t('reportmanage.inquire')}}</el-button>
  </div>
  <el-table ref="table" style="margin-top: 20px;height: 700px;width: 1770px;" :data="tableDataa" :header-cell-style="{background:'#F2F3F5 ',color:'#1D2129'}">
          <el-table-column prop="deviceId" align="center" :label="$t('searchOrder.cagenumber')" min-width="150" />
          <el-table-column prop="engineerId" align="center" :label="$t('searchOrder.projectnumber')" min-width="100" />
          <el-table-column prop="layer" align="center" :label="$t('processCard.layer')" min-width="80" />
          <el-table-column prop="slot" align="center" :label="$t('searchOrder.gridnumber')" min-width="120" />
          <el-table-column
          align="center"
            :label="$t('searchOrder.startstatus')"
            min-width="80"
            prop="enableState"
          >
          <template #default="scope">  
          <el-tag  
            :type="scope.row.enableState === 1 ? 'success' : 'danger'"  
            @click="toggleEnableState(scope.row)"
          >  
            {{ scope.row.enableState === 1 ? $t('searchOrder.enable') : $t('searchOrder.disable')}}  
          </el-tag>  
        </template> 
          </el-table-column>
          <el-table-column prop="remainWidth" align="center" :label="$t('searchOrder.remainingwidth')" min-width="120" />
          <el-table-column prop="glassId" :label="$t('searchOrder.glassID')" align="center" min-width="130"/>
          <el-table-column prop="flowCardId" align="center" :label="$t('searchOrder.cardnumber')" min-width="130" />
          <el-table-column prop="filmsId" align="center" :label="$t('searchOrder.coatingtypes')" min-width="80" />
          <el-table-column prop="width" align="center" :label="$t('searchOrder.width')" min-width="80" />
          <el-table-column prop="height" align="center" :label="$t('searchOrder.height')" min-width="80" />
          <el-table-column prop="thickness" align="center" :label="$t('searchOrder.thickness')" min-width="80" />
          <el-table-column prop="temperingLayoutId" align="center" :label="$t('searchOrder.layoutID')" min-width="100" />
          <el-table-column prop="temperingFeedSequence" align="center" :label="$t('searchOrder.picturesequence')" min-width="120" />
          <el-table-column prop="gap" align="center" :label="$t('searchOrder.glassgaps')" min-width="80" />
          <el-table-column fixed="right" :label="$t('film.operate')" align="center" width="240">
              <template #default="scope">
              <!-- <el-button type="text" plain  @click="handleBindRack(scope.row)">{{ $t('searchOrder.add') }}</el-button> -->
              <el-button type="text" plain @click="broke(scope.row)">{{ $t('searchOrder.breakage') }}</el-button>
              <el-button type="text" plain @click="brokec(scope.row)">{{ $t('searchOrder.takeout') }}</el-button>
              <el-button type="text" plain @click="opena(scope.row)">{{ $t('searchOrder.delete') }}</el-button>
                </template>
              </el-table-column>
        </el-table>
        <div>
  </div>
  <el-dialog v-model="dialogFormVisiblea" top="2vh" width="97%" :title="$t('searchOrder.cageinformation')">
    <div style="display: flex;">
      <el-input v-model="engineerId" clearable style="margin-left: 10px;margin-bottom: 10px;width: 240px;"
        :placeholder="$t('processCard.projectnumber')" />
      <el-input v-model="glassId" clearable style="margin-left: 10px;margin-bottom: 10px;width: 240px;"
        :placeholder="$t('searchOrder.inglassID')" />
      <el-input v-model="flowCardId" clearable style="margin-left: 10px;margin-bottom: 10px;width: 240px;"
        :placeholder="$t('searchOrder.incardnumber')" />
      <el-input v-model="filmsId" clearable style="margin-left: 10px;margin-bottom: 10px;width: 240px;"
        :placeholder="$t('film.infilms')" />
      <el-input v-model="thickness" clearable style="margin-left: 10px;margin-bottom: 10px;width: 240px;"
        :placeholder="$t('searchOrder.inthickness')" />
      <el-button type="primary" style="margin-left: 10px;margin-bottom: 10px;" @click="fetchxianga">
        {{ $t('reportmanage.inquire') }}</el-button>
    </div>
    <el-table ref="table" style="margin-top: 20px;height: 700px;width: 1770px;" :data="tableDataa"
      :header-cell-style="{ background: '#F2F3F5 ', color: '#1D2129' }">
      <el-table-column prop="deviceId" align="center" :label="$t('searchOrder.cagenumber')" min-width="150" />
      <el-table-column prop="engineerId" align="center" :label="$t('searchOrder.projectnumber')" min-width="100" />
      <el-table-column prop="layer" align="center" :label="$t('processCard.layer')" min-width="80" />
      <el-table-column prop="slot" align="center" :label="$t('searchOrder.gridnumber')" min-width="120" />
      <el-table-column align="center" :label="$t('searchOrder.startstatus')" min-width="80" prop="enableState">
        <template #default="scope">
          <el-tag :type="scope.row.enableState === 1 ? 'success' : 'danger'" @click="toggleEnableState(scope.row)">
            {{ scope.row.enableState === 1 ? $t('searchOrder.enable') : $t('searchOrder.disable') }}
          </el-tag>
        </template>
      </el-table-column>
      <el-table-column prop="remainWidth" align="center" :label="$t('searchOrder.remainingwidth')" min-width="120" />
      <el-table-column prop="glassId" :label="$t('searchOrder.glassID')" align="center" min-width="130" />
      <el-table-column prop="flowCardId" align="center" :label="$t('searchOrder.cardnumber')" min-width="130" />
      <el-table-column prop="filmsId" align="center" :label="$t('searchOrder.coatingtypes')" min-width="80" />
      <el-table-column prop="width" align="center" :label="$t('searchOrder.width')" min-width="80" />
      <el-table-column prop="height" align="center" :label="$t('searchOrder.height')" min-width="80" />
      <el-table-column prop="thickness" align="center" :label="$t('searchOrder.thickness')" min-width="80" />
      <el-table-column prop="temperingLayoutId" align="center" :label="$t('searchOrder.layoutID')" min-width="100" />
      <el-table-column prop="temperingFeedSequence" align="center" :label="$t('searchOrder.picturesequence')"
        min-width="120" />
      <el-table-column prop="gap" align="center" :label="$t('searchOrder.glassgaps')" min-width="80" />
      <el-table-column fixed="right" :label="$t('film.operate')" align="center" width="240">
        <template #default="scope">
          <!-- <el-button type="text" plain  @click="handleBindRack(scope.row)">{{ $t('searchOrder.add') }}</el-button> -->
          <el-button type="text" plain @click="broke(scope.row)">{{ $t('searchOrder.breakage') }}</el-button>
          <el-button type="text" plain @click="brokec(scope.row)">{{ $t('searchOrder.takeout') }}</el-button>
          <el-button type="text" plain @click="opena(scope.row)">{{ $t('searchOrder.delete') }}</el-button>
        </template>
      </el-table-column>
    </el-table>
    <div>
    </div>
  </el-dialog>
  <!-- 缺片详情 -->
<LackDetailDialog
@@ -1321,7 +1263,7 @@
/>
  <!-- 多条破损数据 -->
  <el-dialog v-model="dialogFormVisibleb" top="15vh" width="70%" height="500">
    <el-button plain  @click="handleAllBroke">{{ $t('order.dilapidationAll') }}</el-button>
    <el-button plain @click="handleAllBroke">{{ $t('order.dilapidationAll') }}</el-button>
    <el-table ref="table" style="margin-top: 20px;height: 400px;" :data="tableDataMiss"
      :header-cell-style="{ background: '#F2F3F5 ', color: '#1D2129' }">
      <el-table-column prop="glassType" align="center" :label="$t('large.serialnumber')" min-width="80" />
@@ -1331,119 +1273,148 @@
      <el-table-column prop="height" align="center" :label="$t('hellow.height')" min-width="80" />
      <el-table-column prop="width" align="center" :label="$t('hellow.width')" min-width="80" />
      <el-table-column fixed="right" :label="$t('searchOrder.operate')" align="center">
            <template #default="scope">
              <el-button type="text" plain  @click="handleBroke(scope.row)">{{ $t('order.dilapidation') }}</el-button>
            </template>
        <template #default="scope">
          <el-button type="text" plain @click="handleBroke(scope.row)">{{ $t('order.dilapidation') }}</el-button>
        </template>
      </el-table-column>
    </el-table>
  </el-dialog>
  <!-- 历史任务 -->
<el-dialog v-model="blindb" top="5vh" width="95%" @close="iframeUrl=''">
     <iframe 
     :src="iframeUrl" 
     marginwidth="2000px"
     marginheight="2000px"
     width="100%" 
     height="750px" 
     frameborder="0"
     ></iframe>
  <el-dialog v-model="blindb" top="5vh" width="95%" @close="iframeUrl = ''">
    <iframe :src="iframeUrl" marginwidth="2000px" marginheight="2000px" width="100%" height="750px"
      frameborder="0"></iframe>
  </el-dialog>
</template>
<style>
#dt { display:block; float:left;line-height: 20px;margin-left: 100px;}
#dta { display:block; float:left;line-height: 20px;margin-left: 80%;}
#dialog-footer{
#dt {
  display: block;
  float: left;
  line-height: 20px;
  margin-left: 100px;
}

#dta {
  display: block;
  float: left;
  line-height: 20px;
  margin-left: 80%;
}

#dialog-footer {
  text-align: center;
  margin-top: -15px;
}
#message{

#message {
  text-align: center;
  align-items: center;
  color: black;
   width: 200px;
   height: 100px;
   background-color: #337ecc;
   margin-left: 28%;
  width: 200px;
  height: 100px;
  background-color: #337ecc;
  margin-left: 28%;
}
#awatch{

#awatch {
  height: 450px;
}

#occupy {
    height: 100%;
    width: 15%;
    background-color: white;
    margin: 0px 8px 0px 8px;
    border: 1px #EBEEF5 solid;
    text-align: center;
    padding: 5px;
  height: 100%;
  width: 15%;
  background-color: white;
  margin: 0px 8px 0px 8px;
  border: 1px #EBEEF5 solid;
  text-align: center;
  padding: 5px;
}

#biao {
    font-size: 12px;
  font-size: 12px;
}

#zhi {
    font-size: 18px;
    font-weight: bold;
  font-size: 18px;
  font-weight: bold;
}
#demo-pagination-block + #demo-pagination-block {

#demo-pagination-block+#demo-pagination-block {
  margin-top: 10px;
}

#demo-pagination-block #demonstration {
  margin-bottom: 16px;
}

::-webkit-scrollbar {
     width: 0 !important;
   }
   ::-webkit-scrollbar {
     width: 0 !important;height: 0;
   }
   .img-list{
  position:relative;
  width: 0 !important;
}
.data-img{
  @apply float-none ;
  width:100%;
  height:16rem;

::-webkit-scrollbar {
  width: 0 !important;
  height: 0;
}

.img-list {
  position: relative;
}

.data-img {
  @apply float-none;
  width: 100%;
  height: 16rem;
  background: rgba(0, 0, 0, 0);
  opacity: 1;
  border-radius: 0.5rem 0.5rem 0px 0px;
}
.check-img{

.check-img {
  position: absolute;
  width: 3.3125rem;
  height: 2.9375rem;
  top:20rem;
  top: 20rem;
  right: 57rem;
  z-index: 10;
}
.check-imga{

.check-imga {
  position: absolute;
  width: 3.3125rem;
  height: 2.9375rem;
  top:15rem;
  top: 15rem;
  right: 28.5rem;
  z-index: 10;
}

.vertical {
    width: 45px;
    height: 25px;
    background-color: #409EFF;
    top: 485px; /* 初始位置 */
    left: 899px; /* 水平居中 */
    transform: translateX(-50%);
    animation: move-vertical 6s infinite; /* 从上到下动画，持续6秒，无限循环 */
  width: 45px;
  height: 25px;
  background-color: #409EFF;
  top: 485px;
  /* 初始位置 */
  left: 899px;
  /* 水平居中 */
  transform: translateX(-50%);
  animation: move-vertical 6s infinite;
  /* 从上到下动画，持续6秒，无限循环 */
}

@keyframes move-vertical {
    0% {
        top: 485px; /* 起始位置 */
    }
    100% {
        top: calc(100% - 210px); /* 从上到下结束位置 */
    }
  0% {
    top: 485px;
    /* 起始位置 */
  }

  100% {
    top: calc(100% - 210px);
    /* 从上到下结束位置 */
  }
}
.img-zkdlpl{

.img-zkdlpl {
  margin-left: 20px;
  margin-top: 0px;
  background-image:url('/src/assets/zhongkong.png');
  background-image: url('/src/assets/zhongkong.png');
  background-repeat: no-repeat;
  background-attachment: local;
  min-height: 500px;
@@ -1451,11 +1422,12 @@
  max-width: 100%;
  background-size: 800px 500px;
  overflow: hidden;
  position:relative
  position: relative
}
.img-car1{

.img-car1 {
  display: flex;
  background-image:url('/xiaoche.png');
  background-image: url('/xiaoche.png');
  position: absolute;
  background-repeat: no-repeat;
  background-attachment: local;
@@ -1464,11 +1436,12 @@
  max-width: 100%;
  background-size: 200px 70px;
  overflow: hidden;
  position:relative
  position: relative
}
.img-car4{

.img-car4 {
  display: flex;
  background-image:url('/xiaoche.png');
  background-image: url('/xiaoche.png');
  position: absolute;
  background-repeat: no-repeat;
  background-attachment: local;
@@ -1477,49 +1450,65 @@
  max-width: 100%;
  background-size: 200px 70px;
  overflow: hidden;
  position:relative
  position: relative
}

.table-container {
  display: flex;
  flex-wrap: nowrap; /* 防止换行 */
  justify-content: space-between; /* 根据需要调整子元素之间的间距 */
  flex-wrap: nowrap;
  /* 防止换行 */
  justify-content: space-between;
  /* 根据需要调整子元素之间的间距 */
}
.table-container > el-card {
  flex: 1; /* 使两个卡片平分可用空间 */
  margin-bottom: 10px; /* 可选，根据需要添加底部间距 */

.table-container>el-card {
  flex: 1;
  /* 使两个卡片平分可用空间 */
  margin-bottom: 10px;
  /* 可选，根据需要添加底部间距 */
}

#dotClass {
  display: flex;
  margin-left: 20px; 
  margin-left: 20px;
  size: 50px;
  margin-top: 20px;
  margin-bottom: 10px;
}

.row-red-background {
  background-color: #CDAF95 !important;
}

.global-alert-bar {
  position: fixed;
  top: 0;
  left: 50%; /* 水平居中关键 */
  transform: translateX(-50%); /* 水平居中关键 */
  left: 50%;
  /* 水平居中关键 */
  transform: translateX(-50%);
  /* 水平居中关键 */
  padding: 12px 20px;
  background-color: #dbdbd7;
  box-shadow: 0 2px 10px rgba(0,0,0,0.2);
  box-shadow: 0 2px 10px rgba(0, 0, 0, 0.2);
  display: flex;
  justify-content: space-between;
  align-items: center;
  z-index: 9999;
  max-width: 80%; /* 防止小屏幕溢出 */
  min-width: 400px; /* 最小宽度保证 */
  max-width: 80%;
  /* 防止小屏幕溢出 */
  min-width: 400px;
  /* 最小宽度保证 */
}

/* 提示内容居中 */
.alert-content {
  display: flex;
  align-items: center;
  justify-content: center;
  flex-grow: 1; /* 占据可用空间 */
  flex-grow: 1;
  /* 占据可用空间 */
}

/* 提示文字样式 */
.alert-text {
  margin-left: 8px;
@@ -1527,6 +1516,7 @@
  font-weight: bold;
  color: #0d0d0d;
}

/* 关闭按钮样式 */
.close-btn {
  background: none;
@@ -1535,15 +1525,22 @@
  cursor: pointer;
  margin-left: 20px;
}

/* 页面容器顶部内边距 */
#app-container {
  padding-top: 60px; /* 根据alert高度调整 */
  padding-top: 60px;
  /* 根据alert高度调整 */
}

.confirm-text {
  color: rgb(242, 121, 8);
  display: block; /* 强制换行 */
  text-align: center; /* 水平居中 */
  margin-top: 4px; /* 与上一行保持间距 */
  font-weight: 500; /* 加粗突出 */
  display: block;
  /* 强制换行 */
  text-align: center;
  /* 水平居中 */
  margin-top: 4px;
  /* 与上一行保持间距 */
  font-weight: 500;
  /* 加粗突出 */
}
</style>

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/base/entity/vo/BigStorageVO.java

@@ -15,6 +15,8 @@
    private int deviceId;
    @ApiModelProperty(value = "格子号")
    private int slot;
    @ApiModelProperty(value = "数量")
    private int count;
    @ApiModelProperty(value = "玻璃id")
    private String glassId;
    @ApiModelProperty(value = "长边")
    private int length;
}

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/damage/controller/DamageController.java

@@ -5,11 +5,14 @@
import com.mes.damage.entity.Damage;
import com.mes.damage.entity.DamagePrint;
import com.mes.damage.entity.dto.DamageDTO;
import com.mes.damage.entity.request.DamageRequest;
import com.mes.damage.entity.vo.FlowCardDamageVO;
import com.mes.damage.entity.vo.GlassDamageVO;
import com.mes.damage.service.DamageService;
import com.mes.opctask.entity.LoadGlassDeviceTaskHistory;
import com.mes.utils.Result;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@@ -28,6 +31,7 @@
@RestController
@RequestMapping("/damage")
@ResponseBody
@Slf4j
public class DamageController {

    @Autowired(required = true)
@@ -94,5 +98,44 @@
        return Result.build(200, "查询成功", "");
    }

    @ApiOperation("自动报工测试")
    @PostMapping("/submitReport")
    public Result submitReport() {
//        for (int i = 0; i < 50; i++) {
            Damage damage = new Damage();
            damage.setProcessId("NG25110702A004");
            damage.setWorkingProcedure("磨边");
            damage.setOrderNumber(2);
            damage.setTechnologyNumber(2);
            damageService.submitReport(damage);
//            log.info("当前循环次数{}", i);
//            try {
//                // 方式1：使用Thread.sleep（推荐，直观）
//                Thread.sleep(5000); // 10000毫秒 = 10秒
//                // 方式2：使用TimeUnit（语义更清晰，可选）
//                // TimeUnit.SECONDS.sleep(10);
//            } catch (InterruptedException e) {
//                // 捕获中断异常，恢复线程中断状态（避免后续逻辑异常）
//                Thread.currentThread().interrupt();
//                // 日志记录中断信息
//                // 可选：中断后是否退出循环（根据业务需求调整）
//                // break; // 中断则退出循环
//                // continue; // 中断则跳过当前等待，继续下一次循环
//            }
//        }
        return Result.build(200, "查询成功", "");
    }

    @ApiOperation("玻璃进度查询")
    @PostMapping("/queryProgress")
    public Result<List<GlassDamageVO>> queryProgress(@RequestBody DamageRequest damageRequest) {
        return Result.build(200, "查询成功", damageService.queryProgress(damageRequest));
    }

    @ApiOperation("流程卡进度查询")
    @PostMapping("/queryFlowCardIdProgress")
    public Result<List<FlowCardDamageVO>> queryFlowCardIdProgress(@RequestBody DamageRequest damageRequest) {
        return Result.build(200, "查询成功", damageService.queryFlowCardIdProgress(damageRequest));
    }
}


 hangzhoumesParent/common/servicebase/src/main/java/com/mes/damage/entity/request/DamageRequest.java

@@ -30,7 +30,7 @@
    @NotBlank(message = "玻璃ID不能为空")
    private String glassId;

    @ApiModelProperty("状态 8 破损 9 拿走")
    @ApiModelProperty("状态 1：未报工，3已报工，7已现补，8现补信息同步给erp")
    @NotNull(message = "状态不能为空")
    private int state;

@@ -43,4 +43,26 @@

    @ApiModelProperty("备注")
    private String remark;

    @ApiModelProperty("备注")
    private Integer type;

    @ApiModelProperty("备注")
    private List<Integer> typeList;

    @NotBlank(message = "工序不能为空")
    private List<String> workingProcedureList;

    @ApiModelProperty("工程号")
    private String engineerId;

    @ApiModelProperty("流程卡")
    private List<GlassCondition> conditionList;

    @Data
    public static class GlassCondition {
        private String flowCardId;
        private Integer layer;
        private Integer glassType;
    }
}

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/damage/entity/vo/FlowCardDamageVO.java

New file
@@ -0,0 +1,97 @@
package com.mes.damage.entity.vo;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import io.swagger.models.auth.In;
import lombok.Data;
import lombok.EqualsAndHashCode;

import java.io.Serializable;
import java.sql.Timestamp;

/**
 * <p>
 *
 * </p>
 *
 * @author wu
 * @since 2024-06-25
 */
@ApiModel(description = "<p> </p>")
@Data
@EqualsAndHashCode(callSuper = false)
public class FlowCardDamageVO implements Serializable {

    /**
     * 工程
     */
    @ApiModelProperty(value = "工程", position = 1)
    private String engineerId;

    /**
     * 流程卡
     */
    @ApiModelProperty(value = "流程卡", position = 2)
    private String flowCardId;

    /**
     * 序号
     */
    @ApiModelProperty(value = "序号", position = 3)
    private Integer glassType;

    /**
     * 工艺确认序号
     */
    @ApiModelProperty(value = "层", position = 4)
    private Integer layer;

    /**
     * 膜系
     */
    @ApiModelProperty(value = "膜系", position = 5)
    private String filmsid;

    /**
     * 宽
     */
    @ApiModelProperty(value = "宽", position = 6)
    private Double width;

    /**
     * 高
     */
    @ApiModelProperty(value = "高", position = 7)
    private Double height;

    /**
     * 高
     */
    @ApiModelProperty(value = "高", position = 8)
    private Double thickness;

    /**
     * 总数量
     */
    @ApiModelProperty(value = "总数量", position = 9)
    private Integer totalQuantity;

    /**
     * 切割
     */
    @ApiModelProperty(value = "切割", position = 10)
    private Integer cutting;

    /**
     * 磨边
     */
    @ApiModelProperty(value = "磨边", position = 11)
    private Integer edging;

    /**
     * 钢化
     */
    @ApiModelProperty(value = "钢化", position = 12)
    private Integer temping;

}

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/damage/entity/vo/GlassDamageVO.java

New file
@@ -0,0 +1,105 @@
package com.mes.damage.entity.vo;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;

import java.io.Serializable;
import java.sql.Timestamp;

/**
 * <p>
 *
 * </p>
 *
 * @author wu
 * @since 2024-06-25
 */
@ApiModel(description = "<p> </p>")
@Data
@EqualsAndHashCode(callSuper = false)
public class GlassDamageVO implements Serializable {


    /**
     * 工序
     */
    @ApiModelProperty(value = "工序", position = 1)
    private String workingProcedure;

    /**
     * 玻璃id
     */
    @ApiModelProperty(value = "玻璃id", position = 2)
    private String glassId;

    /**
     * 生产时间
     */
    @ApiModelProperty(value = "生产时间", position = 3)
    private Timestamp damageTime;

    /**
     * 类型：0：报工 1：破损 2：拿走
     */
    @ApiModelProperty(value = "类型：0：报工 1：完工 8：破损", position = 4)
    private Integer type;

    /**
     * 状态：0：未报工 1：已报工
     */
    @ApiModelProperty(value = "状态：1：未报工 3：已报工", position = 5)
    private Integer status;

    /**
     * 流程卡
     */
    @ApiModelProperty(value = "流程卡", position = 6)
    private String flowCardId;

    /**
     * 序号
     */
    @ApiModelProperty(value = "序号", position = 7)
    private Integer glassType;

    /**
     * 工艺确认序号
     */
    @ApiModelProperty(value = "层", position = 8)
    private Integer layer;

    /**
     * 膜系
     */
    @ApiModelProperty(value = "膜系", position = 9)
    private String filmsid;

    /**
     * 宽
     */
    @ApiModelProperty(value = "宽", position = 10)
    private Double width;

    /**
     * 高
     */
    @ApiModelProperty(value = "高", position = 11)
    private Double height;

    /**
     * 高
     */
    @ApiModelProperty(value = "高", position = 12)
    private Double thickness;

    /**
     * 报工设备名称
     */
    @ApiModelProperty(value = "报工设备", position = 13)
    private String deviceName;

}

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/damage/mapper/DamageMapper.java

@@ -4,6 +4,9 @@
import com.github.yulichang.base.MPJBaseMapper;
import com.mes.damage.entity.Damage;
import com.mes.damage.entity.dto.DamageDTO;
import com.mes.damage.entity.request.DamageRequest;
import com.mes.damage.entity.vo.FlowCardDamageVO;
import com.mes.damage.entity.vo.GlassDamageVO;
import org.apache.ibatis.annotations.Param;

import java.util.List;
@@ -28,4 +31,8 @@
            @Param("status") int status,
            @Param("workingProcedure") String workingProcedure
    );

    List<GlassDamageVO> queryProgress(DamageRequest damageRequest);

    List<FlowCardDamageVO> queryFlowCardIdProgress(DamageRequest damageRequest);
}

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/damage/service/DamageService.java

@@ -5,10 +5,11 @@
import com.mes.damage.entity.Damage;
import com.mes.damage.entity.DamagePrint;
import com.mes.damage.entity.dto.DamageDTO;
import com.mes.opctask.entity.LoadGlassDeviceTaskHistory;
import com.mes.damage.entity.request.DamageRequest;
import com.mes.damage.entity.vo.FlowCardDamageVO;
import com.mes.damage.entity.vo.GlassDamageVO;
import com.mes.pp.entity.ReportingWork;
import com.mes.pp.entity.ReportingWorkDetail;
import com.mes.utils.Result;

import java.util.List;

@@ -71,4 +72,8 @@
    Boolean sendToERP(ReportingWork reportingWork, List<ReportingWorkDetail> reportingWorkDetails, Boolean type);

    List<Damage> queryUnTempByFlowCardId(String flowCardId);

    List<GlassDamageVO> queryProgress(DamageRequest damageRequest);

    List<FlowCardDamageVO> queryFlowCardIdProgress(DamageRequest damageRequest);
}

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/damage/service/impl/DamageServiceImpl.java

@@ -3,8 +3,6 @@
import cn.hutool.json.JSONArray;
import cn.hutool.json.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.github.yulichang.base.MPJBaseServiceImpl;
@@ -13,11 +11,13 @@
import com.mes.damage.entity.Damage;
import com.mes.damage.entity.DamagePrint;
import com.mes.damage.entity.dto.DamageDTO;
import com.mes.damage.entity.request.DamageRequest;
import com.mes.damage.entity.vo.FlowCardDamageVO;
import com.mes.damage.entity.vo.GlassDamageVO;
import com.mes.damage.mapper.DamageMapper;
import com.mes.damage.service.DamageService;
import com.mes.glassinfo.entity.GlassInfo;
import com.mes.glassinfo.mapper.GlassInfoMapper;
import com.mes.opctask.entity.LoadGlassDeviceTaskHistory;
import com.mes.pp.entity.DamageDetails;
import com.mes.pp.entity.ReportingWork;
import com.mes.pp.entity.ReportingWorkDetail;
@@ -233,6 +233,27 @@
     */
    @Override
    public void insertDamage(Damage damage) {
        LambdaQueryWrapper<GlassInfo> glassInfoSelectWrapper = new LambdaQueryWrapper<>();
        glassInfoSelectWrapper.eq(GlassInfo::getGlassId, damage.getGlassId());
        GlassInfo glassInfo = glassInfoMapper.selectOne(glassInfoSelectWrapper);
        BeanUtils.copyProperties(glassInfo, damage);

        LambdaQueryWrapper<WorkAssignment> workAssignmentSelectWrapper = new LambdaQueryWrapper<>();
        workAssignmentSelectWrapper
                .eq(WorkAssignment::getLine, damage.getLine())
                .eq(WorkAssignment::getWorkProcesses, damage.getWorkingProcedure());
        WorkAssignment workAssignment = workAssignmentMapper.selectOne(workAssignmentSelectWrapper);
        if (workAssignment != null) {
            damage.setTeamsGroupsName(workAssignment.getTeamsGroupsName());
            damage.setDeviceName(workAssignment.getDeviceName());
        }
        damage.setProcessId(glassInfo.getFlowCardId());
        damage.setOrderNumber(glassInfo.getGlassType());
        damage.setTechnologyNumber(glassInfo.getLayer());
        damage.setDamageTime(Timestamp.valueOf(LocalDateTime.now()));
        if (damage.getType() == null) {
            damage.setType(1);
        }
        List<Damage> damage1 = null;
        if (Const.GLASS_STATE_DAMAGE.equals(damage.getType()) || Const.GLASS_STATE_TAKE.equals(damage.getType())) {
            damage1 = baseMapper.selectList(
@@ -252,33 +273,18 @@
            );
        }
        if (damage1 == null || damage1.size() == 0) {
            LambdaQueryWrapper<GlassInfo> glassInfoSelectWrapper = new LambdaQueryWrapper<>();
            glassInfoSelectWrapper.eq(GlassInfo::getGlassId, damage.getGlassId());
            GlassInfo glassInfo = glassInfoMapper.selectOne(glassInfoSelectWrapper);
            BeanUtils.copyProperties(glassInfo, damage);

            LambdaQueryWrapper<WorkAssignment> workAssignmentSelectWrapper = new LambdaQueryWrapper<>();
            workAssignmentSelectWrapper
                    .eq(WorkAssignment::getLine, damage.getLine())
                    .eq(WorkAssignment::getWorkProcesses, damage.getWorkingProcedure());
            WorkAssignment workAssignment = workAssignmentMapper.selectOne(workAssignmentSelectWrapper);
            if (workAssignment != null) {
                damage.setTeamsGroupsName(workAssignment.getTeamsGroupsName());
                damage.setDeviceName(workAssignment.getDeviceName());
            }
            damage.setProcessId(glassInfo.getFlowCardId());
            damage.setOrderNumber(glassInfo.getGlassType());
            damage.setTechnologyNumber(glassInfo.getLayer());
            damage.setDamageTime(Timestamp.valueOf(LocalDateTime.now()));
            if (damage.getType() == null) {
                damage.setType(1);
            }
            if (damage.getType() == 1 && submitReport(damage)) {
                damage.setStatus(3);
            } else {
                damage.setStatus(1);
            }
            baseMapper.insert(damage);
        } else {
            if (damage.getType() == 1) {
                //重复进入
                damage.setStatus(9);
                baseMapper.insert(damage);
            }
        }
    }

@@ -358,7 +364,7 @@
            // 目标系统的API URL


            String url1 = ERP_URL + "/reportingWork/mesReportingWork";
            String url1 = ERP_URL + "/reportingWork/mesReportingWorkRedis";
            String url2 = ERP_URL + "/reportingWork/mesSaveReportingWorkWorn";
            String url;
            if (type) {
@@ -393,7 +399,8 @@
                result.put("detail", detailsJsonArray);
            }
            JSONObject reportingWorkJson = new JSONObject(objectMapper.writeValueAsString(reportingWork));
            reportingWorkJson.put("reportingWorkTime", reportingWork.getReportingWorkTime().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
            reportingWorkJson.put("reportingWorkTime", reportingWork.getReportingWorkTime().format(formatter));
            // 将 JSON 对象和数组添加到结果对象中
            result.put("title", reportingWorkJson);

@@ -435,7 +442,7 @@
                int code = jsonResponse.getInt("code");
                String message = jsonResponse.getStr("data");
                log.info("报工情况：{},{}", code, message);
                if (code == 200 && message.equals("true")) {
                if (code == 200) {
                    return true;
                } else {
                    return false;
@@ -451,4 +458,14 @@
    public List<Damage> queryUnTempByFlowCardId(String flowCardId) {
        return baseMapper.queryUnTempByFlowCardId(flowCardId);
    }

    @Override
    public List<GlassDamageVO> queryProgress(DamageRequest damageRequest) {
        return baseMapper.queryProgress(damageRequest);
    }

    @Override
    public List<FlowCardDamageVO> queryFlowCardIdProgress(DamageRequest damageRequest) {
        return baseMapper.queryFlowCardIdProgress(damageRequest);
    }
}

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/pp/entity/ReportingWork.java

@@ -142,6 +142,7 @@
    /**
     * 报工时间
     */
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    private LocalDateTime reportingWorkTime;

    /**

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/temperingglass/entity/TemperingGlassInfo.java

@@ -1,6 +1,7 @@
package com.mes.temperingglass.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.mes.base.entity.BigStorageCageBaseInfo;
@@ -8,6 +9,7 @@
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NonNull;

import java.io.Serializable;

@@ -46,6 +48,12 @@
    private Integer glassType;

    /**
     * 层
     */
    @ApiModelProperty(value = "层", position = 6)
    private Integer layer;

    /**
     * 钢化是否接受横放
     */
    @ApiModelProperty(value = "钢化是否接受横放", position = 10)
@@ -74,6 +82,12 @@
    @ApiModelProperty(value = "状态", position = 16)
    private Integer state;

    /**
     * 状态
     */
    @TableField(exist = false)
    @ApiModelProperty(value = "顺序", position = 17)
    private Integer sequence;

    @TableLogic
    private int deleted;

 hangzhoumesParent/common/servicebase/src/main/resources/mapper/DamageMapper.xml

@@ -6,12 +6,14 @@
        SELECT glass_id,
               order_number,
               technology_number,
               working_procedure
               working_procedure,
               type
        FROM (
                 SELECT glass_id,
                        order_number,
                        technology_number,
                        working_procedure,
                        type,
                        ROW_NUMBER() OVER (
      PARTITION BY glass_id
      ORDER BY damage_time DESC
@@ -45,4 +47,136 @@
            </if>
        </where>
    </select>
    <select id="queryProgress" resultType="com.mes.damage.entity.vo.GlassDamageVO">
        SELECT
        t.glass_id,
        t.glass_type,
        t.flow_card_id,
        t.layer,
        t1.damage_time,
        t.width,
        t.height,
        t.thickness,
        t.filmsid,
        t1.working_procedure,
        t1.device_name,
        t1.type
        FROM glass_info t
        LEFT JOIN damage t1 ON t.glass_id = t1.glass_id
        WHERE
        <!-- 抽离多字段IN条件：使用参数替换固定值 -->
        (t.flow_card_id, t.layer, t.glass_type) IN
        <foreach collection="conditionList" item="item" open="(" separator="," close=")">
            (#{item.flowCardId}, #{item.layer}, #{item.glassType})
        </foreach>
        <!-- 抽离t1.type条件 -->
        AND t1.type IN
        <foreach collection="typeList" item="item" open="(" separator="," close=")">
            #{item}
        </foreach>
        AND t1.working_procedure IN
        <foreach collection="workingProcedureList" item="item" open="(" separator="," close=")">
            #{item}
        </foreach>
        <if test="glassId != null and glassId != ''">
            AND t1.glass_id = #{glassId}
        </if>
    </select>
    <select id="queryFlowCardIdProgress" resultType="com.mes.damage.entity.vo.FlowCardDamageVO">
        WITH glass_info_result AS (
        SELECT
        engineer_id,
        flow_card_id,
        layer,
        glass_type,
        thickness,
        filmsid,
        width,
        height,
        count(*) AS total_quantity
        FROM
        glass_info
        WHERE
        1=1
        <if test="flowCardId != null and flowCardId != ''">
            AND flow_card_id = #{flowCardId}
        </if>
        <if test="engineerId != null and engineerId != ''">
            AND engineer_id = #{engineerId}
        </if>
        <if test="glassId != null and glassId != ''">
            and (flow_card_id, layer, glass_type) IN (select flow_card_id, layer, glass_type from glass_info where
            glass_id=#{glassId} )
        </if>
        GROUP BY
        engineer_id,
        flow_card_id,
        layer,
        glass_type,
        thickness,
        filmsid,
        width,
        height
        ),
        damage_result AS (
        SELECT
        engineer_id,
        process_id,
        technology_number,
        order_number,
        working_procedure,
        type,
        count(*) AS report_quantity
        FROM
        damage
        WHERE
        1=1
        <if test="flowCardId != null and flowCardId != ''">
            AND process_id = #{flowCardId}
        </if>
        <if test="engineerId != null and engineerId != ''">
            AND engineer_id = #{engineerId}
        </if>
        <if test="glassId != null and glassId != ''">
            AND (process_id, technology_number, order_number) IN (select flow_card_id, layer, glass_type from glass_info
            where glass_id=#{glassId} )
        </if>
        GROUP BY
        engineer_id,
        process_id,
        technology_number,
        order_number,
        working_procedure,
        type
        ),
        final_result AS (
        SELECT
        t.*,
        sum( CASE WHEN t1.working_procedure = "切割" AND t1.type = 1 THEN report_quantity ELSE 0 END ) -
        sum( CASE WHEN (t1.working_procedure = "磨边" or t1.working_procedure="钢化" or t1.working_procedure="中空") AND
        t1.type = 8 THEN report_quantity ELSE 0 END ) AS cutting,
        sum( CASE WHEN t1.working_procedure = "磨边" AND t1.type = 1 THEN report_quantity ELSE 0 END ) -
        sum( CASE WHEN (t1.working_procedure="钢化" or t1.working_procedure="中空") AND t1.type = 8 THEN report_quantity
        ELSE 0 END ) AS edging,
        sum( CASE WHEN t1.working_procedure = "钢化" AND t1.type = 1 THEN report_quantity ELSE 0 END ) -
        sum( CASE WHEN (t1.working_procedure="中空") AND t1.type = 8 THEN report_quantity ELSE 0 END ) AS temping
        FROM
        glass_info_result t
        LEFT JOIN damage_result t1 ON t.engineer_id = t1.engineer_id
        AND t.flow_card_id = t1.process_id
        AND t.layer = t1.technology_number
        AND t.glass_type = t1.order_number
        GROUP BY
        t.engineer_id,
        t.flow_card_id,
        t.layer,
        t.glass_type,
        t.thickness,
        t.filmsid,
        t.width,
        t.height,
        t.total_quantity
        )
        select * from final_result;
    </select>
</mapper>

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/bigstorage/service/BigStorageCageDetailsService.java

@@ -129,7 +129,7 @@
     */
    List<BigStorageCageDetails> queryRealGlassInfo(BigStorageQueryVO bigStorageQueryVO);

    Map<Integer, List<BigStorageVO>> querybigStorageCageDetail();
    Map<Object, Map<Integer, List<BigStorageVO>>> querybigStorageCageDetail();

    /**
     * 取消钢化任务

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/bigstorage/service/impl/BigStorageCageDetailsServiceImpl.java

@@ -466,7 +466,7 @@

        if (temperingGlassInfoList.size() == 0) {
            MPJLambdaWrapper<GlassInfo> wrapper = JoinWrappers.lambda(GlassInfo.class)
                    .select("-1 as state,t.filmsid as films_id,t.glass_id,t.flow_card_id,t.glass_type,t.width,t.height" +
                    .select("-1 as state,t.filmsid as films_id,t.glass_id,t.flow_card_id,t.layer,t.glass_type,t.width,t.height" +
                            ",t.thickness,t.ishorizontal,t.tempering_layout_id,t.tempering_feed_sequence,t.x_coordinate,t.y_coordinate," +
                            "t.angle,t1.slot,t.engineer_id")
                    .innerJoin(BigStorageCageDetails.class, BigStorageCageDetails::getGlassId, GlassInfo::getGlassId)
@@ -525,9 +525,17 @@
    }

    @Override
    public Map<Integer, List<BigStorageVO>> querybigStorageCageDetail() {
    public Map<Object, Map<Integer, List<BigStorageVO>>> querybigStorageCageDetail() {
        List<BigStorageVO> bigStorageCages = baseMapper.querybigStorageCageDetail();
        return bigStorageCages.stream().collect(Collectors.groupingBy(item -> item.getDeviceId()));
        // 嵌套分组：先按slot分组，再按deviceId分组

        return bigStorageCages.stream()
                // 第一层分组：key=slot值，value=该slot下的所有BigStorageVO
                .collect(Collectors.groupingBy(
                        BigStorageVO::getDeviceId, // 第一层分组依据：slot
                        // 第二层分组：对第一层的value继续按deviceId分组
                        Collectors.groupingBy(BigStorageVO::getSlot)
                ));
    }

    @Override

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/job/OpcPlcStorageCageNewTask.java

@@ -528,7 +528,7 @@
                List<TemperingLayoutDTO> temperingLayoutDTOS = bigStorageCageDetailsService.temperingIsAllByTemperingLayoutId(temperingEngineerId, temperingLayoutId);
                if (CollectionUtil.isNotEmpty(temperingLayoutDTOS)) {
                    List<TemperingGlassInfo> temperingGlassInfos = glassInfoService.selectJoinList(TemperingGlassInfo.class, JoinWrappers.lambda(GlassInfo.class)
                            .select("-1 as state,t.filmsid as films_id,t.glass_id,t.flow_card_id,t.glass_type,t.width,t.height" +
                            .select("-1 as state,t.filmsid as films_id,t.glass_id,t.flow_card_id,t.layer,t.glass_type,t.width,t.height" +
                                    ",t.thickness,t.ishorizontal,t.tempering_layout_id,t.tempering_feed_sequence,t.x_coordinate,t.y_coordinate," +
                                    "t.angle,t1.slot,t.engineer_id")
                            .innerJoin(BigStorageCageDetails.class, BigStorageCageDetails::getGlassId, GlassInfo::getGlassId)

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/resources/mapper/BigStorageCageDetailsMapper.xml

@@ -296,11 +296,11 @@
        FROM result
    </select>
    <select id="querybigStorageCageDetail" resultType="com.mes.base.entity.vo.BigStorageVO">
        select bsc.device_id, bsc.slot, count(bscd.glass_id) as count
        select bsc.device_id, bsc.slot,bscd.glass_id,if(bscd.width>bscd.height,bscd.width,bscd.height) as length
        from big_storage_cage bsc
            left join big_storage_cage_details bscd
        on bsc.slot = bscd.slot and bscd.state in (100, 102, 103, 104)
        group by bsc.device_id, bsc.slot
                 left join big_storage_cage_details bscd
                           on bsc.slot = bscd.slot and bscd.state in (100, 102, 103, 104)
        group by bsc.device_id, bsc.slot,bscd.glass_id
        order by bsc.device_id, bsc.slot
    </select>
    <select id="queryNeedDispatch" resultType="com.mes.bigstorage.entity.BigStorageCageDetails">

 hangzhoumesParent/moduleService/TemperingGlassModule/src/main/java/com/mes/job/PlcTemperingGlassTask.java

@@ -21,9 +21,8 @@
import javax.annotation.Resource;
import java.time.LocalDate;
import java.time.ZoneId;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
@@ -53,7 +52,7 @@
        try {
            waitingGlass = selectWaitingGlassByOpc();
            if (CollectionUtil.isNotEmpty(waitingGlass)) {
                jsonObject.append("waitingGlass", waitingGlass);
                jsonObject.append("waitingGlass", markSequence(waitingGlass));
            }
        } catch (Exception e) {
            log.info("钢化前获取异常：{}", e.getMessage());
@@ -66,9 +65,10 @@
                    if (i != 0) {
                        jsonName = jsonName + i;
                    }
                    jsonObject.append(jsonName, temperingGlassInfoService.list(new LambdaQueryWrapper<TemperingGlassInfo>()
                    List<TemperingGlassInfo> intoGlassList = temperingGlassInfoService.list(new LambdaQueryWrapper<TemperingGlassInfo>()
                            .eq(TemperingGlassInfo::getEngineerId, intoGlass.get(i).getEngineerId())
                            .eq(TemperingGlassInfo::getTemperingLayoutId, intoGlass.get(i).getTemperingLayoutId())));
                            .eq(TemperingGlassInfo::getTemperingLayoutId, intoGlass.get(i).getTemperingLayoutId()));
                    jsonObject.append(jsonName, markSequence(intoGlassList));
                }

            }
@@ -79,7 +79,7 @@
            //出炉后的玻璃
            List<TemperingGlassInfo> outGlass = temperingGlassInfoService.selectOutGlass();
            if (CollectionUtil.isNotEmpty(outGlass)) {
                jsonObject.append("outGlass", outGlass);
                jsonObject.append("outGlass", markSequence(outGlass));
            }
        } catch (Exception e) {
            log.info("钢化前获取异常：{}", e.getMessage());
@@ -181,4 +181,33 @@
            return tempList;
        }
    }


    public List<TemperingGlassInfo> markSequence(List<TemperingGlassInfo> tempGlass) {

        // 1. 步骤1：定义分组键提取规则（明确类型，避免泛型推导混乱）
        // 组合键：flowCardId + "_" + layer（保证flowCardId+layer唯一）
        Function<TemperingGlassInfo, String> keyExtractor = info ->
                info.getFlowCardId() + "_" + (info.getLayer() == null ? "" : info.getLayer());

        // 2. 步骤2：按组合键分组（完全依赖编译器自动推导泛型，无显式指定）
        // 使用LinkedHashMap保证分组顺序与原始数据一致
        Map<String, List<TemperingGlassInfo>> groupMap = tempGlass.stream()
                .collect(Collectors.groupingBy(
                        keyExtractor,          // 分组键
                        LinkedHashMap::new,    // 外层Map实现（有序）
                        Collectors.toList()    // 内层List收集器
                ));

        // 3. 步骤3：为每个分组内的元素标记sequence（从1开始）
        groupMap.forEach((key, glassList) -> {
            // 遍历分组内的列表，按顺序赋值sequence
            for (int i = 0; i < glassList.size(); i++) {
                glassList.get(i).setSequence(i + 1); // sequence从1开始
            }
        });

        // 5. 返回标记后的完整列表（原列表已通过引用修改）
        return tempGlass;
    }
}

 hangzhoumesParent/moduleService/hollowGlassModule/src/main/java/com/mes/hollow/entity/HollowGlassOutRelationInfo.java

@@ -53,6 +53,12 @@
     * 是否强制
     */
    private Long formulaId;

    /**
     * 除膜膜系
     */
    private String filmRemove;

    /**
     * /*创建时间
     */

 hangzhoumesParent/moduleService/hollowGlassModule/src/main/java/com/mes/hollow/entity/request/HollowTaskRequest.java

@@ -21,6 +21,8 @@
    private int totalPairQuantity;
    @ApiModelProperty(value = "配方id")
    private Long formulaId;
    @ApiModelProperty(value = "除膜膜系")
    private String filmRemove;


}

 hangzhoumesParent/moduleService/hollowGlassModule/src/main/java/com/mes/hollow/service/HollowBigStorageCageDetailsService.java

@@ -30,7 +30,7 @@

    List<HollowBigStorageCageDetails> queryOutGlassList(String flowCardId, int cell, List<Integer> layerList);

    Map<Integer, List<BigStorageVO>> queryHollowbigStorageCageDetail();
    Map<Object, Map<Integer, List<BigStorageVO>>> queryHollowbigStorageCageDetail();

    /**
     * 取出每组玻璃占用笼子的格子并计算格子内的最大组序号

 hangzhoumesParent/moduleService/hollowGlassModule/src/main/java/com/mes/hollow/service/impl/HollowBigStorageCageDetailsServiceImpl.java

@@ -75,9 +75,16 @@
    }

    @Override
    public Map<Integer, List<BigStorageVO>> queryHollowbigStorageCageDetail() {
    public Map<Object, Map<Integer, List<BigStorageVO>>> queryHollowbigStorageCageDetail() {
        List<BigStorageVO> bigStorageCages = baseMapper.queryHollowbigStorageCageDetail();
        return bigStorageCages.stream().collect(Collectors.groupingBy(item -> item.getDeviceId()));
        return bigStorageCages.stream()
                // 第一层分组：key=slot值，value=该slot下的所有BigStorageVO
                .collect(Collectors.groupingBy(
                        BigStorageVO::getDeviceId, // 第一层分组依据：slot
                        // 第二层分组：对第一层的value继续按deviceId分组
                        Collectors.groupingBy(BigStorageVO::getSlot)
                ));
//        return bigStorageCages.stream().collect(Collectors.groupingBy(item -> item.getDeviceId()));
    }

    @Override

 hangzhoumesParent/moduleService/hollowGlassModule/src/main/java/com/mes/hollow/service/impl/HollowGlassOutRelationInfoServiceImpl.java

@@ -389,6 +389,7 @@
            info.setState(Const.HOLLOW_FLOW_CARD_NEW);
            info.setTotalPairQuantity(request.getTotalPairQuantity());
            info.setFormulaId(request.getFormulaId());
            info.setFilmRemove(request.getFilmRemove());
            this.save(info);
            // 查询出需要出玻璃的队列
            List<Integer> layerList = new ArrayList<>();
@@ -403,7 +404,7 @@
                    }
                    layerList = tempList.stream().distinct().collect(Collectors.toList());
                    isPairCount = layerList.size() * request.getTotalPairQuantity();
                }else{
                } else {
                    isPairCount = glassInfo.getTotalLayer() * request.getTotalPairQuantity();
                }
            } else {

 hangzhoumesParent/moduleService/hollowGlassModule/src/main/java/com/mes/hollow/service/impl/HollowGlassRelationInfoServiceImpl.java

@@ -464,6 +464,9 @@
        });
        List<LackDetailsDTO> detailsDTOS = baseMapper.queryLackByFlowCardByERP(processCardReports);
        List<Damage> damages = damageService.queryUnTempByFlowCardId(flowCardId);
        damages = damages.stream()
                .filter(damage -> damage.getType() != 8) // 核心：排除type=8的元素
                .collect(Collectors.toList());
// 1. 按(orderNumber+layer)分组，同时缓存DTO的其他字段作为模板
        Map<String, List<Damage>> damageMap = new HashMap<>();
        Map<String, LackDetailsDTO> dtoTemplateMap = new HashMap<>(); // 存储分组对应的DTO模板

 hangzhoumesParent/moduleService/hollowGlassModule/src/main/java/com/mes/job/PushMessageToIndex.java

@@ -154,160 +154,160 @@


    public void queryDataSource1(JSONObject jsonObject) throws Exception {
        S7DataZKDLPOne s7DataZKDLPOne = s7SerializerZKDLPOne.read(S7DataZKDLPOne.class);
        S7DataZKDLPTwo s7DataZKDLPTwo = s7SerializerZKDLPTwo.read(S7DataZKDLPTwo.class);
        S7DataZKExtra s7DataZKExtra = s7SerializerZKQ2.read(S7DataZKExtra.class);
//        S7DataZKDLPOne s7DataZKDLPOne = s7SerializerZKDLPOne.read(S7DataZKDLPOne.class);
//        S7DataZKDLPTwo s7DataZKDLPTwo = s7SerializerZKDLPTwo.read(S7DataZKDLPTwo.class);
//        S7DataZKExtra s7DataZKExtra = s7SerializerZKQ2.read(S7DataZKExtra.class);
        List<Double> carPostion = new ArrayList<>();
        carPostion.add(0.25);
        carPostion.add(0.5);
        jsonObject.append("carPostion", carPostion);
        //界面展示笼子信息
        jsonObject.append("bigStorageCageInfos", hollowBigStorageCageDetailsService.queryHollowbigStorageCageDetail());

        try {
            //进片任务数据
            List<BigStorageTaskVO> inTaskList = new ArrayList();
            String fromOpcUa = s7DataZKDLPOne.getFrom1().toString();
            for (int i = 0; i < 6; i++) {
                String requestWord = "";
                String stateWord = "";
                String targetSlotWord = "";
                switch (i) {
                    case 0:
                        requestWord = s7DataZKDLPOne.getId1();
                        stateWord = s7DataZKDLPOne.getState1().toString();
                        targetSlotWord = s7DataZKDLPOne.getTo1().toString();
                        break;
                    case 1:
                        requestWord = s7DataZKDLPOne.getId2();
                        stateWord = s7DataZKDLPOne.getState2().toString();
                        targetSlotWord = s7DataZKDLPOne.getTo2().toString();
                        break;
                    case 2:
                        requestWord = s7DataZKDLPOne.getId3();
                        stateWord = s7DataZKDLPOne.getState3().toString();
                        targetSlotWord = s7DataZKDLPOne.getTo3().toString();
                        break;
                    case 3:
                        requestWord = s7DataZKDLPOne.getId4();
                        stateWord = s7DataZKDLPOne.getState4().toString();
                        targetSlotWord = s7DataZKDLPOne.getTo4().toString();
                        break;
                    case 4:
                        requestWord = s7DataZKDLPOne.getId5();
                        stateWord = s7DataZKDLPOne.getState5().toString();
                        targetSlotWord = s7DataZKDLPOne.getTo5().toString();
                        break;
                    case 5:
                        requestWord = s7DataZKDLPOne.getId6();
                        stateWord = s7DataZKDLPOne.getState6().toString();
                        targetSlotWord = s7DataZKDLPOne.getTo6().toString();
                        break;
                }
                if (StringUtils.isNotEmpty(requestWord)) {
                    BigStorageTaskVO task = new BigStorageTaskVO();
                    task.setGlassId(requestWord);
                    int isExistCount = hollowBigStorageCageDetailsService.count(new LambdaQueryWrapper<HollowBigStorageCageDetails>().in(HollowBigStorageCageDetails::getGlassId, task.getGlassId())
                            .in(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL));
                    if (isExistCount > 0) {
                        task.setIsSame(1);
                    } else {
                        task.setIsSame(0);
                    }
                    task.setStartSlot(Integer.parseInt(fromOpcUa));
                    task.setTargetSlot(Integer.parseInt(targetSlotWord));
                    task.setTaskState(Integer.parseInt(stateWord));
                    inTaskList.add(task);
                    continue;
                }
            }
            jsonObject.append("bigStorageCageDetailsFeedTask", inTaskList);
        } catch (Exception e) {
            //todo:不做任务处理
        }
        try {
            //进片联机
            Boolean inkageEntity = s7DataZKDLPOne.getMesControl();
            jsonObject.append("inkageEntity", inkageEntity);
            //进片请求
            Integer requestEntity = s7DataZKDLPOne.getRequestMes();
            jsonObject.append("requestEntity", requestEntity);
            //启动命令
            Integer mesReplyEntity = s7DataZKDLPOne.getMesReply();
            jsonObject.append("mesReplyEntity", mesReplyEntity);
            //出片联机
            Boolean outInkageEntity = s7DataZKDLPTwo.getMesControl();
            jsonObject.append("outInkageEntity", outInkageEntity);
            //出片请求
            Integer outRequestEntity = s7DataZKDLPTwo.getRequestMes();
            jsonObject.append("outRequestEntity", outRequestEntity);
            //930空闲信号
            jsonObject.append("freeOneRequestEntity", CMJ1ModbusTcp.readUInt16(42027 - offset));
            //931空闲信号
            jsonObject.append("freeTwoRequestEntity", s7DataZKExtra.getIsFree());
            //932空闲信号
            jsonObject.append("freeThreeRequestEntity", s7DataZKExtra.getIsFree());
        } catch (Exception e) {
            //todo:不做任务处理
        }

        //出片任务数据
        List<BigStorageCageTask> outTaskList = new ArrayList<>();
        for (int i = 0; i < 6; i++) {

            BigStorageCageTask bigStorageCageTask = new BigStorageCageTask();
            String glassId = "";
            Integer startSlot = 0;
            Integer targetSlot = 0;
            Integer taskState = 0;
            switch (i) {
                case 0:
                    glassId = s7DataZKDLPTwo.getId1();
                    startSlot = s7DataZKDLPTwo.getFrom1();
                    targetSlot = s7DataZKDLPTwo.getTo1();
                    taskState = s7DataZKDLPTwo.getState1();
                    ;
                    break;
                case 1:
                    glassId = s7DataZKDLPTwo.getId2();
                    startSlot = s7DataZKDLPTwo.getFrom2();
                    targetSlot = s7DataZKDLPTwo.getTo2();
                    taskState = s7DataZKDLPTwo.getState2();
                    break;
                case 2:
                    glassId = s7DataZKDLPTwo.getId3();
                    startSlot = s7DataZKDLPTwo.getFrom3();
                    targetSlot = s7DataZKDLPTwo.getTo3();
                    taskState = s7DataZKDLPTwo.getState3();
                    break;
                case 3:
                    glassId = s7DataZKDLPTwo.getId4();
                    startSlot = s7DataZKDLPTwo.getFrom4();
                    targetSlot = s7DataZKDLPTwo.getTo4();
                    taskState = s7DataZKDLPTwo.getState4();
                    break;
                case 4:
                    glassId = s7DataZKDLPTwo.getId5();
                    startSlot = s7DataZKDLPTwo.getFrom5();
                    targetSlot = s7DataZKDLPTwo.getTo5();
                    taskState = s7DataZKDLPTwo.getState5();
                    break;
                case 5:
                    glassId = s7DataZKDLPTwo.getId6();
                    startSlot = s7DataZKDLPTwo.getFrom6();
                    targetSlot = s7DataZKDLPTwo.getTo6();
                    taskState = s7DataZKDLPTwo.getState6();
                    break;
            }
            if (StringUtils.isNotEmpty(glassId)) {
                bigStorageCageTask.setGlassId(glassId);
                bigStorageCageTask.setStartSlot(startSlot);
                bigStorageCageTask.setTargetSlot(targetSlot);
                bigStorageCageTask.setTaskState(taskState);
                outTaskList.add(bigStorageCageTask);
            }
        }
        jsonObject.append("bigStorageCageDetailsOutTask", outTaskList);
        jsonObject.append("HollowAllFlowCard", hollowGlassRelationInfoService.queryHollowAllFlowCard(new HollowBigStorageDetailsQueryVO()));
//        try {
//            //进片任务数据
//            List<BigStorageTaskVO> inTaskList = new ArrayList();
//            String fromOpcUa = s7DataZKDLPOne.getFrom1().toString();
//            for (int i = 0; i < 6; i++) {
//                String requestWord = "";
//                String stateWord = "";
//                String targetSlotWord = "";
//                switch (i) {
//                    case 0:
//                        requestWord = s7DataZKDLPOne.getId1();
//                        stateWord = s7DataZKDLPOne.getState1().toString();
//                        targetSlotWord = s7DataZKDLPOne.getTo1().toString();
//                        break;
//                    case 1:
//                        requestWord = s7DataZKDLPOne.getId2();
//                        stateWord = s7DataZKDLPOne.getState2().toString();
//                        targetSlotWord = s7DataZKDLPOne.getTo2().toString();
//                        break;
//                    case 2:
//                        requestWord = s7DataZKDLPOne.getId3();
//                        stateWord = s7DataZKDLPOne.getState3().toString();
//                        targetSlotWord = s7DataZKDLPOne.getTo3().toString();
//                        break;
//                    case 3:
//                        requestWord = s7DataZKDLPOne.getId4();
//                        stateWord = s7DataZKDLPOne.getState4().toString();
//                        targetSlotWord = s7DataZKDLPOne.getTo4().toString();
//                        break;
//                    case 4:
//                        requestWord = s7DataZKDLPOne.getId5();
//                        stateWord = s7DataZKDLPOne.getState5().toString();
//                        targetSlotWord = s7DataZKDLPOne.getTo5().toString();
//                        break;
//                    case 5:
//                        requestWord = s7DataZKDLPOne.getId6();
//                        stateWord = s7DataZKDLPOne.getState6().toString();
//                        targetSlotWord = s7DataZKDLPOne.getTo6().toString();
//                        break;
//                }
//                if (StringUtils.isNotEmpty(requestWord)) {
//                    BigStorageTaskVO task = new BigStorageTaskVO();
//                    task.setGlassId(requestWord);
//                    int isExistCount = hollowBigStorageCageDetailsService.count(new LambdaQueryWrapper<HollowBigStorageCageDetails>().in(HollowBigStorageCageDetails::getGlassId, task.getGlassId())
//                            .in(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL));
//                    if (isExistCount > 0) {
//                        task.setIsSame(1);
//                    } else {
//                        task.setIsSame(0);
//                    }
//                    task.setStartSlot(Integer.parseInt(fromOpcUa));
//                    task.setTargetSlot(Integer.parseInt(targetSlotWord));
//                    task.setTaskState(Integer.parseInt(stateWord));
//                    inTaskList.add(task);
//                    continue;
//                }
//            }
//            jsonObject.append("bigStorageCageDetailsFeedTask", inTaskList);
//        } catch (Exception e) {
//            //todo:不做任务处理
//        }
//        try {
//            //进片联机
//            Boolean inkageEntity = s7DataZKDLPOne.getMesControl();
//            jsonObject.append("inkageEntity", inkageEntity);
//            //进片请求
//            Integer requestEntity = s7DataZKDLPOne.getRequestMes();
//            jsonObject.append("requestEntity", requestEntity);
//            //启动命令
//            Integer mesReplyEntity = s7DataZKDLPOne.getMesReply();
//            jsonObject.append("mesReplyEntity", mesReplyEntity);
//            //出片联机
//            Boolean outInkageEntity = s7DataZKDLPTwo.getMesControl();
//            jsonObject.append("outInkageEntity", outInkageEntity);
//            //出片请求
//            Integer outRequestEntity = s7DataZKDLPTwo.getRequestMes();
//            jsonObject.append("outRequestEntity", outRequestEntity);
//            //930空闲信号
//            jsonObject.append("freeOneRequestEntity", CMJ1ModbusTcp.readUInt16(42027 - offset));
//            //931空闲信号
//            jsonObject.append("freeTwoRequestEntity", s7DataZKExtra.getIsFree());
//            //932空闲信号
//            jsonObject.append("freeThreeRequestEntity", s7DataZKExtra.getIsFree());
//        } catch (Exception e) {
//            //todo:不做任务处理
//        }
//
//        //出片任务数据
//        List<BigStorageCageTask> outTaskList = new ArrayList<>();
//        for (int i = 0; i < 6; i++) {
//
//            BigStorageCageTask bigStorageCageTask = new BigStorageCageTask();
//            String glassId = "";
//            Integer startSlot = 0;
//            Integer targetSlot = 0;
//            Integer taskState = 0;
//            switch (i) {
//                case 0:
//                    glassId = s7DataZKDLPTwo.getId1();
//                    startSlot = s7DataZKDLPTwo.getFrom1();
//                    targetSlot = s7DataZKDLPTwo.getTo1();
//                    taskState = s7DataZKDLPTwo.getState1();
//                    ;
//                    break;
//                case 1:
//                    glassId = s7DataZKDLPTwo.getId2();
//                    startSlot = s7DataZKDLPTwo.getFrom2();
//                    targetSlot = s7DataZKDLPTwo.getTo2();
//                    taskState = s7DataZKDLPTwo.getState2();
//                    break;
//                case 2:
//                    glassId = s7DataZKDLPTwo.getId3();
//                    startSlot = s7DataZKDLPTwo.getFrom3();
//                    targetSlot = s7DataZKDLPTwo.getTo3();
//                    taskState = s7DataZKDLPTwo.getState3();
//                    break;
//                case 3:
//                    glassId = s7DataZKDLPTwo.getId4();
//                    startSlot = s7DataZKDLPTwo.getFrom4();
//                    targetSlot = s7DataZKDLPTwo.getTo4();
//                    taskState = s7DataZKDLPTwo.getState4();
//                    break;
//                case 4:
//                    glassId = s7DataZKDLPTwo.getId5();
//                    startSlot = s7DataZKDLPTwo.getFrom5();
//                    targetSlot = s7DataZKDLPTwo.getTo5();
//                    taskState = s7DataZKDLPTwo.getState5();
//                    break;
//                case 5:
//                    glassId = s7DataZKDLPTwo.getId6();
//                    startSlot = s7DataZKDLPTwo.getFrom6();
//                    targetSlot = s7DataZKDLPTwo.getTo6();
//                    taskState = s7DataZKDLPTwo.getState6();
//                    break;
//            }
//            if (StringUtils.isNotEmpty(glassId)) {
//                bigStorageCageTask.setGlassId(glassId);
//                bigStorageCageTask.setStartSlot(startSlot);
//                bigStorageCageTask.setTargetSlot(targetSlot);
//                bigStorageCageTask.setTaskState(taskState);
//                outTaskList.add(bigStorageCageTask);
//            }
//        }
//        jsonObject.append("bigStorageCageDetailsOutTask", outTaskList);

        //调度开关
        boolean dispatchHollowSwitch = false;

 hangzhoumesParent/moduleService/hollowGlassModule/src/main/resources/mapper/HollowBigStorageCageDetailsMapper.xml

@@ -212,11 +212,14 @@
        </if>
    </select>
    <select id="queryHollowbigStorageCageDetail" resultType="com.mes.base.entity.vo.BigStorageVO">
        select hbsc.device_id, hbsc.slot, count(hbscd.glass_id) as count
        select hbsc.device_id,
               hbsc.slot,
               hbscd.glass_id,
               if(hbscd.width > hbscd.height, hbscd.width, hbscd.height) as length
        from hollow_big_storage_cage hbsc
                 left join hollow_big_storage_cage_details hbscd
                           on hbsc.slot = hbscd.slot and hbscd.state in (100, 102, 103, 104)
        group by hbsc.device_id, hbsc.slot
        group by hbsc.device_id, hbsc.slot, hbscd.glass_id
        order by hbsc.device_id, hbsc.slot
    </select>
    <select id="querySlotMaxSequence" resultType="com.mes.hollow.entity.HollowBigStorageCageDetails">