구글시트 체크인 사진 드라이브 저장 방법: Apps Script로 날짜별 정리

const CHK_DRIVE_CONFIG = {                             // → 체크인 사진 저장 설정
  ROOT_FOLDER_NAME: '입고체크인사진',                   // → 최상위 폴더 이름
  DATE_FOLDER_FORMAT: 'YYYY-MM-DD',                    // → 날짜 폴더 형식
  MAX_IMAGE_MB: 10,                                    // → 허용 파일 최대 용량(MB)
  ALLOWED_MIME_TYPES: ['image/jpeg', 'image/png'],     // → 허용 이미지 유형
  TIMEZONE: 'America/New_York'                         // → 시간대 고정
};                                                     // 
// → 이 상수는 다른 편 상수와 이름이 겹치지 않게 CHK_ 접두어를 씁니다.

function CHK_getOrCreateRootFolder_() {                            // → 최상위 폴더 찾기/생성
  const folders = DriveApp.getFoldersByName(                        // → 같은 이름 폴더 검색
    CHK_DRIVE_CONFIG.ROOT_FOLDER_NAME                               // → 설정에서 이름 사용
  );                                                                
  if (folders.hasNext()) {                                          // → 이미 있으면
    return folders.next();                                          // → 첫 번째 폴더 사용
  }                                                                 
  return DriveApp.createFolder(                                     // → 없으면 새로 생성
    CHK_DRIVE_CONFIG.ROOT_FOLDER_NAME                               // → 같은 이름으로 생성
  );                                                                
}                                                                   

function CHK_getOrCreateDateFolder_(dateObj) {                      // → 날짜별 폴더 찾기/생성
  if (!(dateObj instanceof Date) || isNaN(dateObj)) {               // → 유효한 날짜인지 확인
    throw new Error('CHK_getOrCreateDateFolder_: 잘못된 날짜입니다.');  // → 잘못된 입력 차단
  }                                                                 
  const tz = CHK_DRIVE_CONFIG.TIMEZONE;                             // → 고정 시간대 사용
  const y = Utilities.formatDate(dateObj, tz, 'yyyy');              // → 연도 추출
  const m = Utilities.formatDate(dateObj, tz, 'MM');                // → 월 추출
  const d = Utilities.formatDate(dateObj, tz, 'dd');                // → 일 추출
  const folderName = [y, m, d].join('-');                           // → YYYY-MM-DD 조합
  const root = CHK_getOrCreateRootFolder_();                        // → 최상위 폴더 확보
  const subFolders = root.getFoldersByName(folderName);             // → 날짜 폴더 검색
  if (subFolders.hasNext()) {                                       // → 있으면
    return subFolders.next();                                       // → 그 폴더 사용
  }                                                                 
  return root.createFolder(folderName);                             // → 없으면 새로 생성
}

function CHK_saveImageToDriveCore_(base64Data, fileNameHint) {        // → 이미지 저장 핵심 함수
  if (typeof base64Data !== 'string' || base64Data.indexOf(',') < 0) { // → 문자열·형식 확인
    throw new Error('CHK_saveImageToDriveCore_: 잘못된 이미지 데이터입니다.'); // → 잘못된 입력 차단
  }                                                                    
  const parts = base64Data.split(',');                                 // → 헤더·본문 분리
  const header = parts[0];                                             // → data:...;base64 부분
  const dataPart = parts[1];                                           // → 실제 base64 본문
  const mimeMatch = header.match(/data:(.*);base64/);                  // → MIME 추출
  if (!mimeMatch) {                                                    // → 형식이 다르면
    throw new Error('CHK_saveImageToDriveCore_: MIME 형식을 읽을 수 없습니다.'); // → 예외 발생
  }                                                                    
  const mimeType = mimeMatch[1];                                       // → 이미지 MIME 유형
  if (CHK_DRIVE_CONFIG.ALLOWED_MIME_TYPES.indexOf(mimeType) === -1) {  // → 허용 목록 확인
    throw new Error('허용되지 않은 이미지 형식입니다.');                // → jpg/png 외 거부
  }                                                                    
  const blobBytes = Utilities.base64Decode(dataPart);                  // → base64 디코드
  const sizeMb = blobBytes.length / (1024 * 1024);                     // → 바이트 → MB 계산
  if (sizeMb > CHK_DRIVE_CONFIG.MAX_IMAGE_MB) {                        // → 용량 제한 검사
    throw new Error('이미지 용량이 너무 큽니다. 최대 '                   // → 사용자 메시지
      + CHK_DRIVE_CONFIG.MAX_IMAGE_MB + 'MB 입니다.');                 
  }                                                                    
  const now = new Date();                                              // → 현재 시각
  const tz = CHK_DRIVE_CONFIG.TIMEZONE;                                // → 고정 시간대
  const timeLabel = Utilities.formatDate(now, tz, 'HHmmss');           // → 시각 문자열
  const safeNameHint = fileNameHint                                   // → 파일명 힌트 정리
    ? String(fileNameHint).replace(/[^0-9A-Za-z_-]+/g, '_')            // → 특수문자 치환
    : 'NO_CONTAINER';                                                  // → 힌트 없을 때 대체
  const ext = (mimeType === 'image/png') ? '.png' : '.jpg';            // → MIME에 맞는 확장자
  const finalFileName = safeNameHint + '_' + timeLabel + ext;          // → 최종 파일명
  const folder = CHK_getOrCreateDateFolder_(now);                      // → 날짜 폴더 확보
  const blob = Utilities.newBlob(blobBytes, mimeType, finalFileName);  // → Blob 생성
  const file = folder.createFile(blob);                                // → Drive 파일 생성
  return {                                                             // → 결과 객체 반환
    id: file.getId(),                                                 // → 파일 ID
    url: file.getUrl(),                                               // → 웹 URL
    name: file.getName(),                                             // → 실제 저장 이름
    folderName: folder.getName()                                      // → 날짜 폴더 이름
  };                                                                  
}

const CHK_APPT_SHEET_NAME = 'APPT_MAIN';                        // → 예약 메인 시트 이름
const CHK_PHOTO_SHEET_NAME = 'CHECKIN_PHOTOS';                  // → 사진 로그 시트(이 편에서 새로 만든다)
// 예약 시트 열 번호는 시리즈 확정 배치 그대로다. A 날짜 B 시작시간 C 장비유형 D 도어
// E 컨테이너 F 운송사 G 고객사 H 비고 I 종료시간 J 생성일시 K 수량 L 팔레트 M 예약ID.
// **사진 열은 없다.** 그래서 아래에서 별도 시트에 쌓는다.
const CHK_APPT_COL_DATE = 1;                                    // → A: 예약일자
const CHK_APPT_COL_CONTAINER = 5;                               // → E: 컨테이너 번호
const CHK_APPT_COL_BOOKING_ID = 13;                             // → M: 예약ID
const CHK_APPT_COL_LAST = 13;                                   // → 한 번에 읽을 열 수(A~M)

// 사진 로그 시트 머리글 — 사진 한 장이 한 줄이다.
const CHK_PHOTO_HEADERS = ['기록일시', '예약일자', '컨테이너', '예약행',
                           '예약ID', '종류', '파일이름', '사진URL'];

/**
 * 사진 로그 시트를 준비한다(없으면 만들고, 비어 있으면 머리글을 넣는다).
 * 기본 1편 getOrCreateSheet_() 는 시트만 만들고 머리글은 넣지 않는다.
 */
function CHK_getPhotoSheet_() {                                 // → 사진 로그 시트 준비
  const ss = SpreadsheetApp.getActiveSpreadsheet();             // → 현재 스프레드시트
  let sheet = ss.getSheetByName(CHK_PHOTO_SHEET_NAME);          // → 있으면 가져오고
  if (!sheet) {                                                 // → 없으면
    sheet = ss.insertSheet(CHK_PHOTO_SHEET_NAME);               // → 새로 만든다
  }                                                             //
  if (sheet.getLastRow() === 0) {                               // → 아직 비어 있으면
    sheet.getRange(1, 1, 1, CHK_PHOTO_HEADERS.length)           // → 1행에
      .setValues([CHK_PHOTO_HEADERS]);                          // → 머리글을 넣는다
    sheet.setFrozenRows(1);                                     // → 머리글 고정
  }                                                             //
  return sheet;                                                 // → 시트 반환
}

/**
 * 체크인 사진 저장 — **행 번호는 1편 조회 결과(data.rowIndex)를 그대로 받는다.**
 * @param {number} apptRow 1편 getApptInfoByCntr() 가 알려 준 예약 행 번호
 * @param {string} containerNo 컨테이너 번호(대조용)
 * @param {string} base64Data data:image/... 형식 문자열
 * @param {string} photoType 'BOL' | 'POD' | '기타' 등 사진 종류
 */
function CHK_saveImageToDrive(apptRow, containerNo, base64Data, photoType) {
  const lock = LockService.getScriptLock();                     // → 스크립트 잠금 객체
  lock.waitLock(30000);                                         // → 최대 30초까지 대기
  try {
    const rowNo = Number(apptRow);                              // → 행 번호 숫자로
    if (!Number.isInteger(rowNo) || rowNo < 2) {                // → 머리글(1행) 아래여야 한다
      throw new Error('예약 행 번호가 올바르지 않습니다. 조회를 먼저 실행해 주세요.');
    }
    const cntr = String(containerNo || '').trim().toUpperCase();  // → 대문자로 통일
    if (!cntr) {                                                // → 컨테이너 번호 없음
      throw new Error('컨테이너 번호가 없습니다.');              // → 필수값 누락 차단
    }

    const ss = SpreadsheetApp.getActiveSpreadsheet();           // → 현재 스프레드시트
    const sheet = ss.getSheetByName(CHK_APPT_SHEET_NAME);       // → 예약 시트 가져오기
    if (!sheet) {                                               // → 시트 없을 때
      throw new Error('예약 메인 시트를 찾을 수 없습니다.');      // → 즉시 중단
    }
    if (rowNo > sheet.getLastRow()) {                           // → 시트 밖 행
      throw new Error('예약 행을 찾을 수 없습니다. 다시 조회해 주세요.');
    }

    // 화면이 열려 있는 동안 행이 밀렸을 수 있다. **그 행이 정말 그 컨테이너의 오늘
    // 예약인지** 저장 직전에 한 번 더 본다. 아니면 엉뚱한 예약에 사진이 붙는다.
    const row = sheet.getRange(rowNo, 1, 1, CHK_APPT_COL_LAST).getValues()[0];
    const rowCntr = String(row[CHK_APPT_COL_CONTAINER - 1] || '').trim().toUpperCase();
    if (rowCntr !== cntr) {                                     // → 다른 예약
      throw new Error('예약 정보가 바뀌었습니다. 컨테이너 번호를 다시 조회해 주세요.');
    }
    let rowYmd;                                                 // → 그 행의 예약일자
    try {                                                       // → 날짜 통일
      rowYmd = APPT_ymd_(row[CHK_APPT_COL_DATE - 1]);           // → 'YYYY-MM-DD'
    } catch (e) {                                               // → 날짜를 못 읽음
      throw new Error('예약 행의 날짜를 읽을 수 없습니다(행 ' + rowNo + '). 사무실에 문의해 주세요.');
    }
    if (rowYmd !== APPT_ymd_(new Date())) {                     // → 오늘 예약이 아님
      throw new Error('오늘 예약이 아닙니다. 컨테이너 번호를 다시 조회해 주세요.');
    }

    const result = CHK_saveImageToDriveCore_(                   // → Drive에 저장 호출
      base64Data,                                               // → 이미지 데이터
      cntr                                                      // → 파일명 힌트
    );

    // **덮어쓰지 않고 쌓는다.** 한 예약에 BOL·POD·파손 사진이 여러 장 온다.
    const photoSheet = CHK_getPhotoSheet_();                    // → 사진 로그 시트
    photoSheet.appendRow([                                      // → 한 장 = 한 줄
      new Date(),                                               // → A: 기록일시
      rowYmd,                                                   // → B: 예약일자
      cntr,                                                     // → C: 컨테이너
      rowNo,                                                    // → D: 예약행
      String(row[CHK_APPT_COL_BOOKING_ID - 1] || ''),           // → E: 예약ID
      String(photoType || '기타').trim(),                       // → F: 종류
      result.name,                                              // → G: 파일이름
      result.url                                                // → H: 사진URL
    ]);

    return {                                                    // → 웹앱으로 반환
      success: true,                                            // → 성공 여부
      fileUrl: result.url,                                      // → 파일 URL
      fileId: result.id,                                        // → 파일 ID
      fileName: result.name,                                    // → 파일 이름
      row: rowNo                                                // → 예약 행 번호
    };
  } catch (e) {
    return {                                                    // → 오류도 객체로 반환
      success: false,                                           // → 실패 표시
      message: e.message || String(e)                           // → 에러 메시지
    };
  } finally {
    lock.releaseLock();                                         // → 잠금 해제
  }
}

function CHK_testSaveImageToDrive() {                         // → 저장 함수 테스트
  // 1편 조회를 먼저 돌려 **오늘 실제로 있는 예약의 행 번호**를 얻는다.
  // 행 번호를 손으로 찍으면 그 행이 오늘 예약인지 알 수 없어 테스트가 의미를 잃는다.
  const TEST_CONTAINER = 'TEST123456';                        // → 오늘 예약이 있는 번호로 교체
  const TEST_BASE64 = 'data:image/jpeg;base64,AAAA';          // → 실제 base64로 교체 필요

  const found = getApptInfoByCntr(TEST_CONTAINER);            // → 1편 조회 함수
  if (!found.found) {                                         // → 오늘 예약이 없으면
    Logger.log('오늘 예약을 찾지 못했습니다: ' + found.reason + ' / ' + found.message);
    return;                                                   // → 여기서 멈춘다
  }

  const result = CHK_saveImageToDrive(found.data.rowIndex,    // → 조회가 알려 준 행 번호
    TEST_CONTAINER, TEST_BASE64, 'BOL');                      // → 번호·이미지·종류
  Logger.log(JSON.stringify(result));                         // → 결과를 로그에 출력
}