코드 스니펫

클릭해서 복사하고, 바로 다운로드하세요.

구글 시트로 만드는 나만의 스티커 메모 보드 웹앱

javascript

구글 시트를 데이터베이스 삼아 실시간으로 메모를 저장하고 관리하는 웹 기반 스티커 메모 보드를 직접 만들어 보세요.

11 0 11

[file: Code.gs]
const SHEET_NAME = 'Notes'; // 메모 저장용 시트 이름

function getSheet_() {
  const ss = SpreadsheetApp.getActiveSpreadsheet();
  let sheet = ss.getSheetByName(SHEET_NAME);
  if (!sheet) sheet = ss.insertSheet(SHEET_NAME);

// 헤더: id, x, y, w, h, text(HTML), color, z
  const header = ['id', 'x', 'y', 'w', 'h', 'text', 'color', 'z'];
  const firstRow = sheet.getRange(1, 1, 1, header.length).getValues()[0];
  const isHeaderSet = firstRow.some(v => v);

if (!isHeaderSet) {
    sheet.getRange(1, 1, 1, header.length).setValues([header]);
  }
  return sheet;
}

/** 웹앱 화면 */
function doGet(e) {
  return HtmlService.createHtmlOutputFromFile('index')
    .setTitle('스티커 메모 보드');
}

/** 시트에서 메모 목록 불러오기 */
function getNotes() {
  const sheet = getSheet_();
  const values = sheet.getDataRange().getValues();
  if (values.length < 2) return [];

const notes = [];
  for (let i = 1; i < values.length; i++) {
    const row = values[i];
    if (!row[0]) continue; // id 없으면 스킵

const note = {
      id: Number(row[0]),
      x: Number(row[1] || 80),
      y: Number(row[2] || 80),
      w: Number(row[3] || 260),
      h: Number(row[4] || 160),
      // text에는 HTML 그대로 저장
      text: String(row[5] || ''),
      color: String(row[6] || 'yellow'),
      z: Number(row[7] || 1),
    };
    notes.push(note);
  }
  return notes;
}

/** 메모 전체를 시트에 저장 (덮어쓰기) */
function saveNotes(notes) {
  const sheet = getSheet_();
  if (!Array.isArray(notes)) notes = [];

// 기존 내용 삭제
  sheet.clearContents();

// 헤더 다시 쓰기
  const header = ['id', 'x', 'y', 'w', 'h', 'text', 'color', 'z'];
  sheet.getRange(1, 1, 1, header.length).setValues([header]);

if (!notes.length) return 'OK';

const rows = notes.map(n => [
    n.id || new Date().getTime(),
    n.x || 80,
    n.y || 80,
    n.w || 260,
    n.h || 160,
    n.text || '',
    n.color || 'yellow',
    n.z || 1,
  ]);

sheet.getRange(2, 1, rows.length, header.length).setValues(rows);
  return 'OK';
}

[file:HTML]
<!DOCTYPE html>
<html lang="ko">
<head>
  <meta charset="UTF-8">
  <base target="_top">
  <title>스티커 메모 보드</title>

body {
      margin: 0;
      height: 100vh;
      overflow: hidden;
      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
      background: #f3f5fb;
    }

#toolbar {
      position: fixed;
      top: 10px;
      left: 10px;
      z-index: 1000;
      display: flex;
      align-items: center;
      gap: 8px;
      padding: 8px 12px;
      background: rgba(255, 255, 255, 0.9);
      border-radius: 8px;
      box-shadow: 0 2px 6px rgba(0,0,0,0.15);
      font-size: 13px;
    }

#toolbar button {
      border: none;
      padding: 6px 10px;
      border-radius: 4px;
      cursor: pointer;
      background: #3b82f6;
      color: #fff;
      font-size: 12px;
    }

#toolbar button:hover {
      opacity: 0.9;
    }

#status {
      font-size: 11px;
      color: #555;
    }

/* 메모 카드 */
    .note {
      position: absolute;
      width: 260px;
      min-width: 160px;
      min-height: 160px;
      border-radius: 8px;                /* ↔ 크기조절 핸들과 동일 라운딩 */
      box-shadow: 0 10px 25px rgba(0,0,0,0.2);
      overflow: hidden;
    }

.note-header {
      position: absolute;
      top: 0;
      left: 0;
      right: 0;
      height: 26px;
      display: flex;
      align-items: center;
      justify-content: space-between;
      padding: 0 6px;
      font-size: 11px;
      cursor: move;
      user-select: none;
      opacity: 0.9;
    }

.note-header .title {
      flex: 1;
      white-space: nowrap;
      overflow: hidden;
      text-overflow: ellipsis;
    }

.note-header .actions {
      display: flex;
      align-items: center;
      gap: 4px;
    }

.note-header select {
      font-size: 10px;
    }

.note-header button {
      border: none;
      background: transparent;
      cursor: pointer;
      font-size: 14px;
      line-height: 1;
    }

/* 상단 서식 툴바 */
    .note-toolbar {
      position: absolute;
      top: 26px;
      left: 0;
      right: 0;
      height: 26px;
      display: flex;
      align-items: center;
      gap: 4px;
      padding: 0 6px;
      font-size: 11px;
      background: rgba(255,255,255,0.4);
      user-select: none;
    }

.note-toolbar button {
      border: none;
      background: transparent;
      cursor: pointer;
      padding: 2px 4px;
      border-radius: 4px;
      font-size: 12px;
    }
    .note-toolbar button:hover {
      background: rgba(0,0,0,0.08);
    }

/* 내용 영역: 헤더(26) + 툴바(26) 위,
       아래쪽은 크기조절 핸들(14px) + 여유 4px = 18px 만큼 비워둠 */
    .note-content {
      position: absolute;
      top: 52px;           /* 26 + 26 */
      left: 0;
      right: 0;
      bottom: 18px;        /* ↔ 핸들 바로 위까지만 편집 영역 */
      padding: 8px 10px 4px 10px;
      font-size: 13px;
      line-height: 1.4;
      outline: none;
      white-space: pre-wrap;
      overflow: auto;
    }

/* 리스트 행간/여백 */
    .note-content ul {
      margin: 2px 0 4px 1.1em;
      padding-left: 0.9em;
    }
    .note-content li {
      margin: 0;
      line-height: 1.35;
    }

/* 링크 스타일 */
    .note-content a {
      color: #1d4ed8;
      text-decoration: underline;
      word-break: break-all;
    }

/* 파스텔톤 색상 */
    .note.yellow { background: #fff7c2; }
    .note.yellow .note-header { background: #ffe28a; }

.note.pink { background: #ffdce7; }
    .note.pink .note-header { background: #ffb6cf; }

.note.blue { background: #dcecff; }
    .note.blue .note-header { background: #afc8ff; }

.note.green { background: #e2f7e9; }
    .note.green .note-header { background: #bfe8cd; }

/* 크기 조절 핸들 */
    .note-resize {
      position: absolute;
      right: 4px;
      bottom: 4px;
      width: 14px;
      height: 14px;
      cursor: se-resize;
      background: rgba(0,0,0,0.18);
      border-radius: 8px;        /* ↔ note 라운딩과 맞춤 */
    }

@media (max-width: 768px) {
      body { overflow: auto; }
    }
  </style>
</head>
<body>
  <div id="toolbar">
    <button id="addNoteBtn">+ 새 메모</button>
    <span id="status">불러오는 중...</span>
  </div>

const statusEl = () => document.getElementById('status');

function setStatus(msg) {
      if (!statusEl()) return;
      statusEl().textContent = msg || '';
    }

function getNote(id) {
      return notes.find(n => n.id === id);
    }

function bringToFront(note) {
      maxZ += 1;
      note.z = maxZ;
      const el = document.querySelector(`.note[data-id="${note.id}"]`);
      if (el) el.style.zIndex = note.z;
      scheduleSave();
    }

// 첫 줄을 제목으로
    function updateTitleFromContent(note, contentEl, titleEl) {
      if (!contentEl || !titleEl) return;
      const text = contentEl.innerText || '';
      const firstLine =
        (text.split(/r?n/).find(line => line.trim() !== '') || '메모')
          .trim();
      titleEl.textContent = firstLine.length > 30
        ? firstLine.slice(0, 30) + '...'
        : firstLine;
    }

// URL 자동 링크
    function autoLink(root) {
      const urlRegex = /(https?://[^s]+)/g;
      const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT, null);
      const targets = [];
      let node;

while ((node = walker.nextNode())) {
        if (!node.nodeValue || !urlRegex.test(node.nodeValue)) continue;
        if (node.parentNode && node.parentNode.closest('a')) continue; // 이미 링크이면 패스
        targets.push(node);
        urlRegex.lastIndex = 0;
      }

targets.forEach(textNode => {
        const text = textNode.nodeValue;
        let lastIndex = 0;
        let match;
        const frag = document.createDocumentFragment();

while ((match = urlRegex.exec(text))) {
          const url = match[0];
          if (match.index > lastIndex) {
            frag.appendChild(document.createTextNode(text.slice(lastIndex, match.index)));
          }
          const a = document.createElement('a');
          a.href = url;
          a.textContent = url;
          a.target = '_blank';
          a.rel = 'noopener noreferrer';
          a.contentEditable = 'false';      // 링크는 클릭 가능하게, 편집은 불가
          frag.appendChild(a);
          lastIndex = match.index + url.length;
        }

if (lastIndex < text.length) {
          frag.appendChild(document.createTextNode(text.slice(lastIndex)));
        }

textNode.parentNode.replaceChild(frag, textNode);
      });
    }

function createToolbar(content, note, titleEl) {
      const toolbar = document.createElement('div');
      toolbar.className = 'note-toolbar';

const buttons = [
        { cmd: 'bold', label: 'B' },
        { cmd: 'italic', label: 'I' },
        { cmd: 'underline', label: 'U' },
        { cmd: 'insertUnorderedList', label: '•' },
      ];

buttons.forEach(b => {
        const btn = document.createElement('button');
        btn.textContent = b.label;
        btn.title = b.cmd;
        btn.addEventListener('click', (e) => {
          e.preventDefault();
          content.focus();
          document.execCommand(b.cmd, false, null);
          const n = getNote(note.id);
          if (!n) return;
          autoLink(content);
          n.text = content.innerHTML;
          updateTitleFromContent(n, content, titleEl);
          scheduleSave();
        });
        toolbar.appendChild(btn);
      });

return toolbar;
    }

function createNoteElement(note) {
      const el = document.createElement('div');
      el.className = 'note ' + (note.color || 'yellow');
      el.style.left = (note.x || 80) + 'px';
      el.style.top = (note.y || 80) + 'px';
      el.style.width = (note.w || 260) + 'px';
      el.style.height = (note.h || 160) + 'px';
      el.style.zIndex = note.z || 1;
      el.dataset.id = note.id;

const header = document.createElement('div');
      header.className = 'note-header';

const title = document.createElement('div');
      title.className = 'title';
      title.textContent = '메모';

const actions = document.createElement('div');
      actions.className = 'actions';

const colorSelect = document.createElement('select');
      ['yellow','pink','blue','green'].forEach(c => {
        const opt = document.createElement('option');
        opt.value = c;
        opt.textContent = c;
        if (c === note.color) opt.selected = true;
        colorSelect.appendChild(opt);
      });

const closeBtn = document.createElement('button');
      closeBtn.innerHTML = '✕';
      closeBtn.title = '삭제';

actions.appendChild(colorSelect);
      actions.appendChild(closeBtn);

header.appendChild(title);
      header.appendChild(actions);

const content = document.createElement('div');
      content.className = 'note-content';
      content.contentEditable = 'true';
      content.spellcheck = false;   // 빨간 물결 끄기
      content.innerHTML = note.text || '';
      autoLink(content);            // 기존 내용도 링크 변환

const toolbar = createToolbar(content, note, title);

const resizeHandle = document.createElement('div');
      resizeHandle.className = 'note-resize';

el.appendChild(header);
      el.appendChild(toolbar);
      el.appendChild(content);
      el.appendChild(resizeHandle);
      document.body.appendChild(el);

// 제목 초기화
      updateTitleFromContent(note, content, title);

// 내용 입력 시 저장 + 링크 처리 + 제목 갱신
      content.addEventListener('input', () => {
        const n = getNote(note.id);
        if (!n) return;
        autoLink(content);
        n.text = content.innerHTML;
        updateTitleFromContent(n, content, title);
        scheduleSave();
      });

// 색상 변경
      colorSelect.addEventListener('change', () => {
        const n = getNote(note.id);
        if (!n) return;
        n.color = colorSelect.value;

el.classList.remove('yellow','pink','blue','green');
        el.classList.add(n.color);
        scheduleSave();
      });

// 삭제
      closeBtn.addEventListener('click', () => {
        notes = notes.filter(n => n.id !== note.id);
        el.remove();
        scheduleSave();
      });

// 드래그 시작
      header.addEventListener('mousedown', (e) => {
        const n = getNote(note.id);
        if (!n) return;
        dragState.id = note.id;
        dragState.offsetX = e.clientX - (n.x || 0);
        dragState.offsetY = e.clientY - (n.y || 0);
        bringToFront(n);
      });

// 클릭 시 맨 앞으로
      el.addEventListener('mousedown', () => {
        const n = getNote(note.id);
        if (n) bringToFront(n);
      });

// 크기 조절 시작
      resizeHandle.addEventListener('mousedown', (e) => {
        e.stopPropagation();
        const n = getNote(note.id);
        if (!n) return;
        resizeState.id = note.id;
        resizeState.startX = e.clientX;
        resizeState.startY = e.clientY;
        resizeState.startW = el.offsetWidth;
        resizeState.startH = el.offsetHeight;
        bringToFront(n);
      });
    }

function renderAll() {
      document.querySelectorAll('.note').forEach(el => el.remove());
      notes.forEach(n => createNoteElement(n));
    }

document.addEventListener('mousemove', (e) => {
      // 이동
      if (dragState.id) {
        const note = getNote(dragState.id);
        if (!note) return;
        note.x = e.clientX - dragState.offsetX;
        note.y = e.clientY - dragState.offsetY;

const el = document.querySelector(`.note[data-id="${note.id}"]`);
        if (el) {
          el.style.left = note.x + 'px';
          el.style.top = note.y + 'px';
        }
        scheduleSave();
      }

// 크기 조절
      if (resizeState.id) {
        const note = getNote(resizeState.id);
        if (!note) return;
        const el = document.querySelector(`.note[data-id="${note.id}"]`);
        if (!el) return;

const newW = Math.max(160, resizeState.startW + (e.clientX - resizeState.startX));
        const newH = Math.max(140, resizeState.startH + (e.clientY - resizeState.startY));

note.w = newW;
        note.h = newH;

el.style.width = newW + 'px';
        el.style.height = newH + 'px';
        scheduleSave();
      }
    });

document.addEventListener('mouseup', () => {
      if (dragState.id || resizeState.id) {
        scheduleSave();
      }
      dragState.id = null;
      resizeState.id = null;
    });

document.getElementById('addNoteBtn').addEventListener('click', () => {
        const id = Date.now();
        const newNote = {
          id,
          x: 100 + Math.random() * 80,
          y: 100 + Math.random() * 80,
          w: 260,
          h: 160,
          text: '',
          color: 'yellow',
          z: ++maxZ,
        };
        notes.push(newNote);
        createNoteElement(newNote);
        scheduleSave();
      });
    }

window.addEventListener('load', init);
  </script>
</body>
</html>

구글 시트 데이터로 구글 슬라이드(PPT) 자동 생성하기

Code.gs

구글 시트에 입력된 데이터를 바탕으로 구글 슬라이드 프레젠테이션을 자동으로 만들고, 원하는 내용으로 채워주는 스크립트입니다.

다운로드

16 0 6

/******************************************************
 * Google Sheets -> Google Slides (Template Copy 방식)
 * - 템플릿 Slides 파일을 복사해서 출력본을 만들고,
 *   복사본 내부에서 템플릿 슬라이드를 데이터 행 수만큼 복제(duplicate)한 뒤
 *   {{A}}, {{B}}, {{C}} ... 토큰을 각 열 값으로 치환합니다.
 *
 * 장점: 프레젠테이션 간 슬라이드 이동 문제 없이 안정적으로 동작
 ******************************************************/

const CONFIG = {
  SHEET_NAME: 'data',        // 데이터 시트 이름
  HEADER_ROW: 1,             // 헤더 행(권장)
  DATA_START_ROW: 2,         // 데이터 시작 행
  TEMPLATE_SLIDE_INDEX: 0,   // 템플릿 슬라이드 위치(0=첫 슬라이드)
  OUTPUT_TITLE_PREFIX: '[AUTO] ',
  KEEP_TEMPLATE_SLIDE: false, // true면 템플릿 슬라이드를 표지로 남김, false면 삭제
  SKIP_EMPTY_ROW: true,      // A열이 비면 해당 행은 슬라이드 생성 제외

// 스크립트 속성 키(템플릿 Slides ID 저장)
  PROP_TEMPLATE_ID: 'TEMPLATE_PRESENTATION_ID',
};

function onOpen() {
  SpreadsheetApp.getUi()
    .createMenu('Slides 자동화')
    .addItem('슬라이드 생성(템플릿 복사)', 'runCreateByCopy')
    .addSeparator()
    .addItem('템플릿 ID 다시 설정', 'resetTemplateId')
    .addToUi();
}

/**
 * 메인 실행: 템플릿 복사 → 데이터 기반 슬라이드 생성
 */
function runCreateByCopy() {
  const ss = SpreadsheetApp.getActiveSpreadsheet();
  const sh = ss.getSheetByName(CONFIG.SHEET_NAME);
  if (!sh) throw new Error(`시트를 찾을 수 없습니다: ${CONFIG.SHEET_NAME}`);

const values = sh.getDataRange().getValues();
  if (values.length < CONFIG.DATA_START_ROW) {
    SpreadsheetApp.getUi().alert('데이터가 없습니다. (DATA_START_ROW 이후 행이 필요)');
    return;
  }

// 데이터행
  let rows = values.slice(CONFIG.DATA_START_ROW - 1);

// 빈 행 제외(기본: A열 기준)
  if (CONFIG.SKIP_EMPTY_ROW) {
    rows = rows.filter(r => String(r[0] ?? '').trim() !== '');
  }

if (rows.length === 0) {
    SpreadsheetApp.getUi().alert('생성할 데이터 행이 없습니다. (A열이 비어있지 않은 행 필요)');
    return;
  }

const templateId = getTemplateId_();
  const outUrl = createSlidesFromTemplate_(templateId, rows, ss.getName());

SpreadsheetApp.getUi().alert('완료!n생성된 Slides:n' + outUrl);
}

/**
 * 템플릿 Slides를 Drive에서 복사해 새 프레젠테이션을 만들고,
 * 그 안에서 템플릿 슬라이드를 duplicate하여 데이터 슬라이드를 생성합니다.
 */
function createSlidesFromTemplate_(templateId, rows, baseName) {
  const outTitle =
    CONFIG.OUTPUT_TITLE_PREFIX +
    baseName +
    ' - ' +
    Utilities.formatDate(new Date(), Session.getScriptTimeZone(), 'yyyy-MM-dd HHmm');

// 1) 템플릿 파일 복사(출력본)
  const copiedFile = DriveApp.getFileById(templateId).makeCopy(outTitle);
  const outPres = SlidesApp.openById(copiedFile.getId());

// 2) 템플릿 슬라이드 확보(복사본 내부)
  const slides = outPres.getSlides();
  const templateSlide = slides[CONFIG.TEMPLATE_SLIDE_INDEX];
  if (!templateSlide) throw new Error('템플릿 슬라이드를 찾지 못했습니다. TEMPLATE_SLIDE_INDEX 확인 필요.');

// 3) 데이터 행마다 슬라이드 생성 + 치환
  rows.forEach((row) => {
    const newSlide = templateSlide.duplicate();
    replaceTokensByColumns_(newSlide, row);  // {{A}}~{{Z}} 치환
  });

// 4) 템플릿 슬라이드 처리
  // - KEEP_TEMPLATE_SLIDE=false면 템플릿 슬라이드를 제거
  // - true면 표지로 남겨두는 구조(표지에 토큰이 있으면 그대로 남음)
  if (!CONFIG.KEEP_TEMPLATE_SLIDE) {
    templateSlide.remove(); // ✅ removeSlide 아님! Slide.remove()가 정답
  }

return outPres.getUrl();
}

/**
 * {{A}}, {{B}}, {{C}} ... 형태의 토큰을 시트 열 값으로 치환
 * - A열: row[0], B열: row[1] ...
 * - 기본은 A~Z(26열)까지만 지원
 */
function replaceTokensByColumns_(slide, row) {
  const max = Math.min(row.length, 26);
  for (let i = 0; i < max; i++) {
    const colLetter = String.fromCharCode('A'.charCodeAt(0) + i);
    const token = `{{${colLetter}}}`;
    const value = row[i] == null ? '' : String(row[i]);
    slide.replaceAllText(token, value);
  }
}

/**
 * 템플릿 Slides ID 가져오기(없으면 1회 입력받아 저장)
 * - 템플릿 Slides URL에서 /d/ 와 /edit 사이 값
 */
function getTemplateId_() {
  const props = PropertiesService.getDocumentProperties();
  let id = props.getProperty(CONFIG.PROP_TEMPLATE_ID);

if (!id) {
    const ui = SpreadsheetApp.getUi();
    const res = ui.prompt(
      '템플릿 Slides ID 입력',
      '템플릿 Google Slides URL에서 /d/ 와 /edit 사이 값을 붙여넣으세요.n예) https://docs.google.com/presentation/d/여기/edit',
      ui.ButtonSet.OK_CANCEL
    );
    if (res.getSelectedButton() !== ui.Button.OK) throw new Error('취소됨');
    id = (res.getResponseText() || '').trim();
    if (!id) throw new Error('템플릿 Slides ID가 비어있습니다.');
    props.setProperty(CONFIG.PROP_TEMPLATE_ID, id);
  }

return id;
}

/**
 * 템플릿 ID 재설정(잘못 넣었을 때)
 */
function resetTemplateId() {
  const props = PropertiesService.getDocumentProperties();
  props.deleteProperty(CONFIG.PROP_TEMPLATE_ID);
  SpreadsheetApp.getUi().alert('템플릿 ID 저장값을 삭제했습니다. 다음 실행 시 다시 입력받습니다.');
}

구글 앱스 스크립트로 문서 스타일 변환기 만들기 (Gemini API 활용)

Code.gs

단 10분 만에 구글 앱스 스크립트와 Gemini AI를 활용하여, 어떤 글이든 원하는 문서 스타일에 맞춰 자동으로 변환해주는 나만의 AI 글쓰기 도우미를 만들어…

다운로드

33 0 17

[file: code.gs]

const CFG = {
  MODEL: 'gemini-2.5-flash',
  FILTERS: ['논문', '보고서', '요약', '공문', '발표문'],
};

function doGet() {
  return HtmlService.createHtmlOutputFromFile('Index')
    .setTitle('AI 변환 웹앱')
    .setXFrameOptionsMode(HtmlService.XFrameOptionsMode.ALLOWALL);
}

// (선택) 최초 1회 키 저장용
function setApiKey(key) {
  key = (key || '').trim();
  if (!key) throw new Error('API Key가 비어 있습니다.');
  PropertiesService.getScriptProperties().setProperty('GEMINI_API_KEY', key);
  return true;
}

function getFilters() {
  return CFG.FILTERS.slice();
}

function transformText(source, filter) {
  source = String(source || '').trim();
  filter = String(filter || '').trim();

if (!source) throw new Error('원문이 비어 있습니다.');
  if (!CFG.FILTERS.includes(filter)) throw new Error('유효하지 않은 필터입니다.');

const apiKey = PropertiesService.getScriptProperties().getProperty('GEMINI_API_KEY');
  if (!apiKey) throw new Error('API Key가 없습니다. (스크립트 속성 GEMINI_API_KEY)');

const prompt = buildPrompt_(source, filter);

const out = callGemini_(apiKey, prompt, 2048);
  let finalOut = out;

// 끊김 감지 → 이어쓰기 (논문/보고서/발표문)
  const trimmed = finalOut.trim();
  const looksCut = trimmed.length >= 1200 && !/[.?!…]|[。？！]|ns*$/.test(trimmed);
  if (looksCut && (filter === '발표문' || filter === '보고서' || filter === '논문')) {
    const cont = continueGeneration_(apiKey, finalOut);
    if (cont) finalOut = (finalOut + 'n' + cont).trim();
  }

// 요약 후처리(명사형 종결 보정)
  if (filter === '요약') finalOut = postprocessSummaryToNounEnding_(finalOut);

return finalOut;
}

function decideSummaryBullets_(source) {
  const n = (source || '').replace(/s+/g, ' ').trim().length;
  if (n <= 80) return 2;
  if (n <= 200) return 3;
  if (n <= 450) return 5;
  if (n <= 900) return 7;
  return 9;
}

function buildPrompt_(source, filter) {
  const commonRules = [
    '출력은 한국어로만 작성.',
    '원문에 없는 사실/수치/근거를 임의로 추가하지 말 것.',
    '고유명사/수치/전문용어는 가능한 한 원문을 유지.',
    '불필요한 사족(서론, 자기소개, 메타 발언) 금지.',
    '요청된 형식/문체만 출력.'
  ].join('n');

const summaryBullets = decideSummaryBullets_(source);

const styleMap = {
    '논문': [
      '문체: 학술 논문체(객관적, 서술은 "~다/~이다" 계열).',
      '표현: 구어체/감탄/주관적 평가 최소화.',
      '구성: 필요 시 (정의)-(특징)-(함의) 순으로 간결 재구성.',
      '제한: 원문에 없는 참고문헌/저자/연도/주장 추가 금지.'
    ].join('n'),
    '보고서': [
      '문체: 실무 보고서체(명료, 단락/불릿 허용).',
      '구성: (요약)-(핵심 내용)-(시사점/권고) 순서 권장.',
      '표현: 실행 가능 문장 중심.'
    ].join('n'),
    '요약': [
      `형식: 불릿 ${summaryBullets}개 내외.`,
      '✅ 각 불릿은 명사형/체언형으로 종결(예: "~탐구", "~경계", "~가능성", "~미래상").',
      '✅ "이다/입니다/합니다/된다/되다" 등 서술어 종결 금지.',
      '중복 제거, 과장 금지, 원문 범위 내 핵심만.'
    ].join('n'),
    '공문': [
      '문체: 공문/행정 문체(격식, 간결).',
      '형식: 목적-내용-요청(또는 협조) 순.',
      '필요 시 날짜/수신/참조는 [대괄호] placeholder 처리.'
    ].join('n'),
    '발표문': [
      '문체: 발표 스크립트(과도한 구어체 금지, 흐름 중심).',
      '구성: 도입-핵심 3포인트-정리.',
      '마무리: 끝맺음 문장으로 자연스럽게 종료.'
    ].join('n')
  };

const style = styleMap[filter] || `문체: "${filter}"에 맞춰 자연스럽게 변환.`;

return [
    '너는 한국어 글쓰기 편집자다.',
    commonRules,
    '',
    '요청 스타일:',
    style,
    '',
    '원문:',
    source
  ].join('n');
}

function callGemini_(apiKey, prompt, maxOutputTokens) {
  const url = `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(CFG.MODEL)}:generateContent`;
  const payload = {
    contents: [{ role: 'user', parts: [{ text: prompt }] }],
    generationConfig: { temperature: 0.3, maxOutputTokens: maxOutputTokens || 1024 }
  };

const res = UrlFetchApp.fetch(url, {
    method: 'post',
    contentType: 'application/json; charset=utf-8',
    headers: { 'x-goog-api-key': apiKey },
    payload: JSON.stringify(payload),
    muteHttpExceptions: true
  });

const code = res.getResponseCode();
  const text = res.getContentText();
  if (code < 200 || code >= 300) throw new Error(`Gemini API HTTP ${code}: ${text}`);

const json = JSON.parse(text);
  const out = (json.candidates?.[0]?.content?.parts || []).map(p => p.text || '').join('').trim();
  if (!out) throw new Error('빈 응답이 반환되었습니다.');
  return out;
}

function continueGeneration_(apiKey, partialText) {
  const prompt =
`아래 글이 중간에서 끊겼다. 직전 문장 흐름을 이어서 자연스럽게 끝까지 완성하라.
- 기존 문장 반복 최소화
- 출력은 이어지는 부분만
- 마지막은 마무리 문장으로 종결

[이미 작성된 내용]
${partialText}

[이어서 작성]`;

try {
    return callGemini_(apiKey, prompt, 1024);
  } catch (e) {
    return '';
  }
}

function postprocessSummaryToNounEnding_(text) {
  const lines = String(text || '').split('n');
  const fixed = lines.map(line => {
    let s = line;
    const isBullet = /^s*([*-•]|d+[.)])s+/.test(s);
    if (!isBullet) return s;

s = s
      .replace(/s*(입니다|이다|합니다|된다|되다).?s*$/u, '')
      .replace(/.s*$/u, '');

return s;
  });
  return fixed.join('n').trim();
}

[file: Index.html]
<!doctype html>
<html lang="ko">
<head>
  <meta charset="utf-8" />
  <meta name="viewport" content="width=device-width, initial-scale=1" />
  <title>AI 변환</title>

<style>
    :root{
      --bg:#f6f8fc;
      --card:#ffffff;
      --text:#1f1f1f;
      --sub:#5f6368;
      --border:#e0e3e7;
      --shadow: 0 1px 2px rgba(60,64,67,.10), 0 1px 3px rgba(60,64,67,.08);
      --radius:16px;
      --focus: 0 0 0 3px rgba(26,115,232,.20);
      --blue:#1a73e8;
      --blue2:#1557b0;
      --chip:#eef3fd;
    }

*{box-sizing:border-box}
    html,body{height:100%}
    body{
      margin:0;
      font-family: system-ui, -apple-system, "Segoe UI", Roboto, "Noto Sans KR", Arial, sans-serif;
      color:var(--text);
      background:var(--bg);
      line-height:1.5;
    }

/* Top app bar */
    .appbar{
      position:sticky; top:0; z-index:10;
      background:rgba(246,248,252,.85);
      backdrop-filter:saturate(1.2) blur(10px);
      border-bottom:1px solid var(--border);
    }
    .appbar-inner{
      max-width:1080px;
      margin:0 auto;
      padding:14px 16px;
      display:flex;
      align-items:center;
      justify-content:space-between;
      gap:12px;
    }
    .brand{
      display:flex; align-items:center; gap:10px;
      min-width:0;
    }
    .logo{
      width:34px; height:34px;
      border-radius:10px;
      background:linear-gradient(135deg,#e8f0fe,#ffffff);
      border:1px solid var(--border);
      display:grid; place-items:center;
      box-shadow: var(--shadow);
      flex:0 0 auto;
    }
    .logo svg{width:18px;height:18px;fill:var(--blue)}
    .title{
      display:flex; flex-direction:column; min-width:0;
    }
    .title strong{font-size:14px; letter-spacing:.2px}
    .title span{font-size:12px; color:var(--sub); white-space:nowrap; overflow:hidden; text-overflow:ellipsis}

.bar-actions{display:flex; gap:8px; flex-wrap:wrap; justify-content:flex-end}

/* Layout */
    .wrap{
      max-width:1080px;
      margin:18px auto 60px;
      padding:0 16px;
      display:grid;
      grid-template-columns: 1.15fr .85fr;
      gap:14px;
    }
    @media (max-width: 980px){
      .wrap{grid-template-columns:1fr}
    }

.card{
      background:var(--card);
      border:1px solid var(--border);
      border-radius:var(--radius);
      box-shadow: var(--shadow);
      overflow:hidden;
    }
    .card-hd{
      padding:14px 16px;
      border-bottom:1px solid var(--border);
      display:flex;
      align-items:center;
      justify-content:space-between;
      gap:10px;
    }
    .card-hd .hd-left{
      display:flex; flex-direction:column; gap:2px;
      min-width:0;
    }
    .card-hd .hd-left b{font-size:13px}
    .card-hd .hd-left small{font-size:12px; color:var(--sub)}

.card-bd{padding:14px 16px; display:grid; gap:10px}

/* Controls */
    label{font-size:12px; color:var(--sub)}
    .row{display:flex; gap:10px; flex-wrap:wrap; align-items:center}
    .row > * {flex:0 0 auto}

.select, .input, .textarea{
      width:100%;
      border:1px solid var(--border);
      border-radius:12px;
      padding:10px 12px;
      background:#fff;
      color:var(--text);
      outline:none;
      transition: box-shadow .12s ease, border-color .12s ease;
      font-size:14px;
    }
    .select:focus, .input:focus, .textarea:focus{
      border-color: rgba(26,115,232,.55);
      box-shadow: var(--focus);
    }

.textarea{min-height:240px; resize:vertical}

.btn{
      border:1px solid var(--border);
      background:#fff;
      color:var(--text);
      padding:10px 12px;
      border-radius:12px;
      font-size:14px;
      cursor:pointer;
      transition: transform .04s ease, background .12s ease, border-color .12s ease;
      display:inline-flex; align-items:center; gap:8px;
      user-select:none;
    }
    .btn:hover{background:#f8f9fa}
    .btn:active{transform: translateY(1px)}
    .btn:focus{outline:none; box-shadow: var(--focus)}

.btn-primary{
      background: var(--blue);
      color:#fff;
      border-color: transparent;
    }
    .btn-primary:hover{background: var(--blue2)}
    .btn-primary:disabled{
      opacity:.6;
      cursor:not-allowed;
      transform:none;
    }

.btn-ghost{
      background:transparent;
      border-color:transparent;
      color:var(--sub);
    }
    .btn-ghost:hover{background:#f1f3f4; color:var(--text)}
    .btn-ghost:focus{box-shadow: var(--focus); border-color: rgba(26,115,232,.25)}

.pill{
      display:inline-flex;
      align-items:center;
      gap:8px;
      padding:8px 10px;
      border-radius:999px;
      background:var(--chip);
      border:1px solid rgba(26,115,232,.12);
      color:#174ea6;
      font-size:12px;
      max-width:100%;
      white-space:nowrap; overflow:hidden; text-overflow:ellipsis;
    }

/* Output box */
    .output{
      border:1px dashed var(--border);
      border-radius:12px;
      padding:12px;
      min-height:240px;
      white-space:pre-wrap;
      background: #fcfdff;
    }

.muted{color:var(--sub); font-size:12px}
    .sep{height:1px; background:var(--border); margin:4px 0}

/* Toast */
    .toast{
      position: fixed;
      left: 50%;
      bottom: 18px;
      transform: translateX(-50%);
      background: rgba(32,33,36,.92);
      color:#fff;
      padding:10px 12px;
      border-radius:999px;
      font-size:13px;
      box-shadow: 0 6px 18px rgba(0,0,0,.18);
      opacity:0;
      pointer-events:none;
      transition: opacity .18s ease, transform .18s ease;
    }
    .toast.show{
      opacity:1;
      transform: translateX(-50%) translateY(-4px);
    }

/* Small icon */
    .icon{width:16px;height:16px;display:inline-block}
    .spin{animation: spin 1s linear infinite}
    @keyframes spin{to{transform: rotate(360deg)}}
  </style>
</head>
<body>
  
  <header class="appbar">
    <div class="appbar-inner">
      <div class="brand">
        <div class="logo" aria-hidden="true">
          <svg viewBox="0 0 24 24"><path d="M12 2a7 7 0 0 0-7 7v3a5 5 0 0 0 5 5h1v3H8a1 1 0 1 0 0 2h8a1 1 0 1 0 0-2h-3v-3h1a5 5 0 0 0 5-5V9a7 7 0 0 0-7-7Zm5 10a3 3 0 0 1-3 3h-4a3 3 0 0 1-3-3V9a5 5 0 0 1 10 0v3Z"/></svg>
        </div>
        <div class="title">
          <strong>AI 변환</strong>
          <span>원문 + 필터 선택 → 결과 생성 (Gemini)</span>
        </div>
      </div>
      <div class="bar-actions">
        <button class="btn btn-ghost" id="clearTop" title="비우기">비우기</button>
        <button class="btn btn-primary" id="runTop">
          <svg class="icon" viewBox="0 0 24 24" fill="currentColor"><path d="M8 5v14l11-7z"/></svg>
          변환
        </button>
      </div>
    </div>
  </header>

<main class="wrap">
    
    <section class="card">
      <div class="card-hd">
        <div class="hd-left">
          <b>입력</b>
          <small>필터는 고정 목록에서만 선택</small>
        </div>
        <div class="pill" id="statusPill">대기</div>
      </div>

<aside class="card">
      <div class="card-hd">
        <div class="hd-left">
          <b>결과</b>
          <small>생성된 텍스트가 여기에 표시</small>
        </div>
        <div class="muted" id="latency"></div>
      </div>
      <div class="card-bd">
        <div class="output" id="out"></div>

<details>
          <summary class="muted">API Key 저장(최초 1회)</summary>
          <div style="margin-top:10px; display:grid; gap:10px">
            <input class="input" id="key" type="password" placeholder="Gemini API Key" autocomplete="off">
            <div class="row">
              <button class="btn" id="saveKey">
                <svg class="icon" viewBox="0 0 24 24" fill="currentColor"><path d="M17 3H5a2 2 0 0 0-2 2v14h18V7l-4-4zm-2 16H9v-6h6v6zm3-10H5V5h11.17L18 6.83V9z"/></svg>
                저장
              </button>
              <span class="muted">키는 서버 ScriptProperties에 저장</span>
            </div>
          </div>
        </details>
      </div>
    </aside>
  </main>

function toast(msg){
      const t = $("toast");
      t.textContent = msg;
      t.classList.add("show");
      setTimeout(()=>t.classList.remove("show"), 1800);
    }

function setStatus(text, loading=false){
      const pill = $("statusPill");
      pill.textContent = text;
      pill.style.background = loading ? "#e8f0fe" : "var(--chip)";
      pill.style.borderColor = loading ? "rgba(26,115,232,.25)" : "rgba(26,115,232,.12)";
      pill.style.color = loading ? "#174ea6" : "#174ea6";
    }

function runTransform(){
      const src = $("src").value.trim();
      const filter = $("filter").value;

if(!src){ $("out").textContent = "⚠️ 원문을 입력하세요."; toast("원문이 비어 있습니다"); return; }

const t0 = performance.now();
      setLoading(true);

google.script.run
        .withSuccessHandler(res => {
          $("out").textContent = res || "";
          const dt = Math.round(performance.now() - t0);
          $("latency").textContent = dt ? `${dt}ms` : "";
          setLoading(false);
          toast("완료");
        })
        .withFailureHandler(err => {
          $("out").textContent = "⚠️ " + (err?.message || err);
          setLoading(false);
          toast("오류");
        })
        .transformText(src, filter);
    }

function clearAll(){
      $("src").value = "";
      $("out").textContent = "";
      $("counter").textContent = "0자";
      setStatus("대기");
      toast("초기화");
    }

$("run").addEventListener("click", runTransform);
    $("runTop").addEventListener("click", runTransform);
    $("clear").addEventListener("click", clearAll);
    $("clearTop").addEventListener("click", clearAll);

$("copy").addEventListener("click", async () => {
      const text = $("out").textContent || "";
      if(!text.trim()){ toast("복사할 내용이 없습니다"); return; }
      try{
        await navigator.clipboard.writeText(text);
        toast("복사됨");
      }catch(e){
        toast("복사 실패(브라우저 권한)");
      }
    });

$("saveKey").addEventListener("click", () => {
      const key = $("key").value.trim();
      if(!key){ toast("API Key를 입력하세요"); return; }
      google.script.run
        .withSuccessHandler(() => {
          $("key").value = "";
          toast("API Key 저장 완료");
        })
        .withFailureHandler(err => {
          $("out").textContent = "⚠️ " + (err?.message || err);
          toast("저장 실패");
        })
        .setApiKey(key);
    });

$("src").addEventListener("input", () => {
      const n = $("src").value.length;
      $("counter").textContent = `${n.toLocaleString()}자`;
    });

// init
    loadFilters();
    setStatus("대기");
  </script>
</body>
</html>

AI 자동 번역 시스템

Code.gs

구글 시트에 한국어 단어를 입력하면, AI가 자동으로 중국어와 병음을 찾아 채워주는 편리한 기능을 만들어 보세요.

다운로드

21 0 6

/***** 설정 *****/
const GEMINI_API_KEY = "YOUR_API_KEY";   // gemini-2.5-flash 키
const MODEL = "gemini-2.5-flash";

const SHEET_NAME = "시트1";
const COL = { WORD:1, ZH:2, PINYIN:3 };  // A:단어, B:중국어, C:병음

/***** 설치형 onEdit 트리거에서 호출되는 함수 (이름 중요: onEdit 아님!) *****/
function handleEdit(e) {
  const range = e.range;
  const sheet = range.getSheet();
  if (sheet.getName() !== SHEET_NAME) return;

const col = range.getColumn();
  const row = range.getRow();

// A열만 처리, 1행은 제외
  if (col !== COL.WORD || row === 1) return;

const values = range.getValues(); // 복붙 대비
  const numRows = values.length;

for (let i = 0; i < numRows; i++) {
    const word = values[i][0];
    const targetRow = row + i;

if (!word) {
      sheet.getRange(targetRow, COL.ZH).setValue("");
      sheet.getRange(targetRow, COL.PINYIN).setValue("");
      continue;
    }

// ★ 먼저 '생성중...' 표시
    sheet.getRange(targetRow, COL.ZH).setValue("생성중...");
    sheet.getRange(targetRow, COL.PINYIN).setValue("...");

Utilities.sleep(80); // 복붙 시 과도한 호출 방지용(선택)

try {
      const result = translateToChineseAndPinyin(word);
      if (!result) continue;

sheet.getRange(targetRow, COL.ZH).setValue(result.zh);
      sheet.getRange(targetRow, COL.PINYIN).setValue(result.pinyin);

} catch (err) {
      // ★ 에러가 나도 셀에는 계속 '생성중...'만 유지
      Logger.log("변환 오류: " + err);
      sheet.getRange(targetRow, COL.ZH).setValue("생성중...");
      sheet.getRange(targetRow, COL.PINYIN).setValue("...");
    }
  }
}

/***** Gemini API 호출 함수 *****/
function translateToChineseAndPinyin(koreanWord) {
  const url =
    `https://generativelanguage.googleapis.com/v1beta/models/${MODEL}:generateContent?key=${GEMINI_API_KEY}`;

const prompt = `
다음 한국어 단어를 중국어와 병음으로 변환해줘.

규칙:
1. 출력 형식은 "중국어|병음" 한 줄만 작성.
2. 병음은 성조 포함(ā á ǎ à).
3. 예: "책" → "书|shū"
4. 다른 문장, 설명, 예문 금지.

한국어 단어: "${koreanWord}"
  `.trim();

const payload = {
    contents: [
      {
        parts: [{ text: prompt }]
      }
    ]
  };

const options = {
    method: "post",
    contentType: "application/json",
    payload: JSON.stringify(payload),
    muteHttpExceptions: true
  };

const response = UrlFetchApp.fetch(url, options);
  const code = response.getResponseCode();

if (code !== 200) {
    throw new Error("API Error: " + code + " - " + response.getContentText());
  }

const data = JSON.parse(response.getContentText());
  const text =
    data.candidates?.[0]?.content?.parts?.[0]?.text?.trim() || "";

if (!text) throw new Error("응답 없음");

const parts = text.split("|").map(s => s.trim());
  if (parts.length < 2) throw new Error("형식 오류: " + text);

return {
    zh: parts[0],
    pinyin: parts[1]
  };
}

/***** 설치형 onEdit 트리거 생성 함수 *****/
function installOnEditTrigger() {
  // 기존 트리거 정리
  ScriptApp.getProjectTriggers().forEach(t => {
    if (t.getHandlerFunction() === "handleEdit") {
      ScriptApp.deleteTrigger(t);
    }
  });

ScriptApp.newTrigger("handleEdit")
    .forSpreadsheet(SpreadsheetApp.getActive())
    .onEdit()
    .create();
}

구글 시트에 AI 이미지가 자동으로 생성되고 문서로 저장됨

Code.gs

구글 시트와 스테이블 디퓨전 AI를 연결하여, 프롬프트 입력만으로 이미지를 생성하고 구글 문서에 자동으로 정리해주는 스크립트입니다.

다운로드

33 0 6

/**
 * 구글 시트와 스테이블 디퓨전 API를 연동하여 문서를 생성하는 스크립트
 * * 기능:
 * 1. 시트의 B열(프롬프트)에 내용이 입력되면 자동으로 실행됩니다 (onEdit 트리거).
 * 2. 한글 프롬프트는 자동으로 영어로 번역되어 API에 전달됩니다.
 * 3. A열의 제목이 연속되면 같은 문서에, 다르면 새 문서에 이미지를 추가합니다.
 * 4. 생성된 문서 링크를 C열에 기록합니다.
 */

// ==========================================
// [설정 영역] 사용자의 API 정보를 입력하세요
// ==========================================
// 예시: Stability AI (DreamStudio) API 키
const API_KEY = 'Stability AI API 키 넣는 곳';

// 최신 SDXL 1.0 정식 버전 엔드포인트 (1024x1024 지원)
const API_URL = 'https://api.stability.ai/v1/generation/stable-diffusion-xl-1024-v1-0/text-to-image';

// 작업할 시트 이름 (없으면 첫 번째 시트를 자동으로 사용합니다)
const SHEET_NAME = '시트1';

// [요청 반영] 문서에 삽입할 이미지 너비 (높이는 비율에 맞게 자동 조절)
const IMAGE_WIDTH = 800;

// ==========================================
// [트리거 함수] B열 수정 시 자동 실행되도록 설정
// ==========================================

/**
 * 시트가 수정될 때 자동으로 실행되는 함수입니다.
 * B열에 내용이 입력되면 generateImageForSingleRow 함수를 호출합니다.
 * 이 함수를 사용하려면 Apps Script 에디터에서 트리거를 설정해야 합니다.
 * 설정 방법은 아래 설명을 참고해주세요.
 */
function onEdit(e) {
  // 이벤트 객체에서 수정된 셀 정보 추출
  const range = e.range;
  const sheet = range.getSheet();
  const sheetName = sheet.getName();
  
  // 1. 설정된 시트 이름과 일치하는지 확인
  // 2. 수정된 열이 B열(2번째 열)인지 확인
  // 3. 행이 데이터 영역(2행 이상)인지 확인
  if (sheetName === SHEET_NAME && range.getColumn() === 2 && range.getRow() > 1) {
    // B열이 수정되면 해당 행만 처리하는 함수를 호출
    generateImageForSingleRow(sheet, range.getRow());
  }
}

// ==========================================
// [메인 함수] 단일 행을 처리하는 함수
// ==========================================
function generateImageForSingleRow(sheet, rowIndex) {
  const rowData = sheet.getRange(rowIndex, 1, 1, 3).getValues()[0];
  
  const bookTitle = rowData[0]; // A열: 책 제목
  const prompt = rowData[1];    // B열: 이미지 설명
  const existingLink = rowData[2]; // C열: 기존 링크
  
  // 제목이나 프롬프트가 없으면 중단
  if (!bookTitle || !prompt) return;

// 이미 링크가 생성되어 있고(성공 케이스), 프롬프트가 변경되지 않은 경우 중복 방지
  if (existingLink && !existingLink.toString().startsWith("실패") && !existingLink.toString().startsWith("에러")) {
    // 이미 처리가 완료된 경우 스킵할 수 있으나, onEdit은 프롬프트 변경 시 항상 실행됨.
    // 여기서는 프롬프트 변경 시 재작업을 허용함.
  }
    
  Logger.log(`처리 중(행 ${rowIndex}): ${bookTitle}`);
  sheet.getRange(rowIndex, 3).setValue("처리 중..."); 
  SpreadsheetApp.flush(); 
  
  // 1. 번역 로직
  let translatedPrompt = prompt;
  try {
    if (/[가-힣]/.test(prompt)) { 
      translatedPrompt = LanguageApp.translate(prompt, 'ko', 'en');
      Logger.log(`번역됨: "${prompt}" -> "${translatedPrompt}"`);
    }
  } catch (e) {
    Logger.log(`번역 실패, 원본 사용: ${e.toString()}`);
    translatedPrompt = prompt;
  }

try {
    // 2. 이미지 생성 API 호출 (번역된 프롬프트 사용)
    const apiResult = callStableDiffusionAPI(translatedPrompt);
    
    if (!apiResult.success) {
      const errorMsg = `실패: ${apiResult.error}`;
      Logger.log(errorMsg);
      sheet.getRange(rowIndex, 3).setValue(errorMsg);
      return;
    }

const imageBlob = apiResult.blob;

// 3. 문서 ID 및 URL 결정 (이전 행의 데이터 가져오기)
    let doc;
    let body;
    let currentDocUrl;
    let currentDocId;
    
    // 이전 행의 제목과 비교 (i는 1부터 시작하므로 rowIndex - 1)
    const prevRowIndex = rowIndex - 1;
    const prevRowData = prevRowIndex > 1 ? sheet.getRange(prevRowIndex, 1, 1, 3).getValues()[0] : null;
    const previousTitle = prevRowData ? prevRowData[0] : "";
    const prevDocLink = prevRowData ? prevRowData[2] : "";

// 이전 행의 제목과 같고, 이전 행에 유효한 문서 링크가 있는 경우
    if (bookTitle === previousTitle && prevDocLink && !prevDocLink.toString().startsWith("실패")) {
      try {
        currentDocId = DocumentApp.openByUrl(prevDocLink).getId();
        currentDocUrl = prevDocLink;
        doc = DocumentApp.openById(currentDocId);
        body = doc.getBody();
      } catch(e) {
         // 문서 열기 실패 시 새 문서 생성
         doc = DocumentApp.create(bookTitle + " - 이미지 모음");
         Utilities.sleep(500); // 안전장치
         currentDocId = doc.getId();
         currentDocUrl = doc.getUrl();
         body = doc.getBody();
         
         try {
           const titlePara = body.insertParagraph(0, bookTitle);
           titlePara.setHeading(DocumentApp.ParagraphHeading.HEADING_1);
         } catch (styleError) {
           Logger.log(`제목 스타일 적용 실패(내용은 유지): ${styleError}`);
         }
      }
    } else {
      // 제목이 다르거나 첫 시작이면 새 문서 생성
      doc = DocumentApp.create(bookTitle + " - 이미지 모음");
      Utilities.sleep(500); // 안전장치
      currentDocId = doc.getId();
      currentDocUrl = doc.getUrl();
      body = doc.getBody();
      
      try {
        const titlePara = body.insertParagraph(0, bookTitle);
        titlePara.setHeading(DocumentApp.ParagraphHeading.HEADING_1);
      } catch (styleError) {
        Logger.log(`제목 스타일 적용 실패(내용은 유지): ${styleError}`);
      }
    }
    
    // 4. 문서에 이미지 및 설명 추가
    // [요청 반영] 프롬프트 텍스트 제거하고 이미지와 구분선만 추가
    try {
      // 이미지 삽입
      body.appendImage(imageBlob)
          .setWidth(IMAGE_WIDTH); 
    } catch (imgError) {
      sheet.getRange(rowIndex, 3).setValue("실패: 이미지 포맷 오류");
      return;
    }
    
    // 문서 구분을 위한 내용 추가 (선택 사항)
    body.appendParagraph("--------------------------------------------------");
    
    doc.saveAndClose(); 
    
    // 5. 시트 C열에 링크 기록
    sheet.getRange(rowIndex, 3).setValue(currentDocUrl);
    
  } catch (e) {
    Logger.log(`에러 발생 (행 ${rowIndex}): ${e.toString()}`);
    sheet.getRange(rowIndex, 3).setValue(`에러: ${e.toString()}`);
  }
}

// ==========================================
// [API 호출 함수] 스테이블 디퓨전 API 통신
// ==========================================
function callStableDiffusionAPI(prompt) {
  const payload = {
    "text_prompts": [
      {
        "text": prompt,
        "weight": 1
      }
    ],
    "cfg_scale": 7,
    "height": 1024,
    "width": 1024,
    "samples": 1,
    "steps": 30
  };

const options = {
    "method": "post",
    "headers": {
      "Content-Type": "application/json",
      "Accept": "image/png",
      "Authorization": `Bearer ${API_KEY}`
    },
    "payload": JSON.stringify(payload),
    "muteHttpExceptions": true
  };

try {
    const response = UrlFetchApp.fetch(API_URL, options);
    const responseCode = response.getResponseCode();
    
    if (responseCode === 200) {
      return { success: true, blob: response.getBlob() };
    } else {
      const errorText = response.getContentText();
      Logger.log(`API 오류(${responseCode}): ${errorText}`);
      try {
        const errorJson = JSON.parse(errorText);
        return { success: false, error: errorJson.message || `API 오류(${responseCode})` };
      } catch (e) {
        return { success: false, error: `API 오류(${responseCode})` };
      }
    }
  } catch (e) {
    Logger.log(`API 통신 실패: ${e}`);
    return { success: false, error: "통신 실패(인터넷/URL 확인)" };
  }
}

대량 QR코드 무료로 자동 생성하기

Code.gs

버튼 한 번으로 스프레드시트의 여러 링크를 QR코드로 만들고 구글 드라이브에 자동으로 저장하는 방법입니다.

다운로드

47 1 8

```javascript
    /***** 설정 *****/
    const SHEET_NAME = "시트 이름"; // 시트 이름
    const FOLDER_ID  = "구글 폴더 ID"; // 드라이브 QR 저장 폴더 ID

// 컬럼 위치 (1 = A열)
    const COL = {
      URL:    1, // A: link
      NAME:   2, // B: filename
      STATUS: 3, // C: status
      FILEID: 4  // D: fileId
    };

// 사용할 QR 생성 API (무료)
    const QR_BASE_URL = "https://api.qrserver.com/v1/create-qr-code/?size=500x500&data=";

/***** 메인 함수: 시트 → QR 생성 → 드라이브 저장 *****/
    function generateQrToDrive() {
      const ss    = SpreadsheetApp.getActive();
      const sheet = ss.getSheetByName(SHEET_NAME);
      const folder = DriveApp.getFolderById(FOLDER_ID);

const lastRow = sheet.getLastRow();
      if (lastRow < 2) return; // 데이터 없음

// 2행부터 마지막 행까지 읽기
      const range = sheet.getRange(2, 1, lastRow - 1, 4);
      const values = range.getValues();

for (let i = 0; i < values.length; i++) {
        let row = values[i];
        let url      = row[COL.URL - 1];    // A
        let filename = row[COL.NAME - 1];   // B
        let status   = row[COL.STATUS - 1]; // C

// URL이 없거나 이미 완료된 경우 건너뛰기
        if (!url) {
          row[COL.STATUS - 1] = "URL없음";
          continue;
        }
        if (status === "완료") continue;

try {
          // QR 생성 API 호출
          const qrUrl = QR_BASE_URL + encodeURIComponent(url);
          const response = UrlFetchApp.fetch(qrUrl);
          let blob = response.getBlob();

// 파일 이름 지정 (비어 있으면 기본 이름 사용)
          const safeName = filename && String(filename).trim() !== ""
            ? String(filename).trim()
            : "qr_" + (i + 2); // 행 번호 기반

blob = blob.setName(safeName + ".png");

// 드라이브에 파일 생성
          const file = folder.createFile(blob);

// 상태 및 fileId 기록
          row[COL.STATUS - 1] = "완료";
          row[COL.FILEID - 1] = file.getId();

} catch (e) {
          row[COL.STATUS - 1] = "에러: " + e.message;
        }
      }

// 수정된 값 다시 시트에 반영
      range.setValues(values);
    }
    ```