@things-factory/kpi 9.0.16 → 9.0.17

package/client/pages/kpi/kpi-grade-editor.ts

@@ -1,20 +1,20 @@
 import '@material/web/button/elevated-button.js'
 import '@material/web/button/filled-button.js'
 import '@material/web/button/text-button.js'
-import '@material/web/textfield/outlined-text-field.js'
-import '@material/web/select/outlined-select.js'
-import '@material/web/select/select-option.js'
 import '@material/web/icon/icon.js'
+import '@operato/data-grist/ox-grist.js'
+import deepEquals from 'lodash-es/isEqual'
 
+import gql from 'graphql-tag'
 import { LitElement, css, html } from 'lit'
-import { customElement, property, state } from 'lit/decorators.js'
-import { ScopedElementsMixin } from '@open-wc/scoped-elements'
+import { customElement, property, state, query } from 'lit/decorators.js'
+import { DataGrist } from '@operato/data-grist/ox-grist.js'
+import { i18next, localize } from '@operato/i18n'
 import { client } from '@operato/graphql'
 import { notify } from '@operato/layout'
-import gql from 'graphql-tag'
-import { CommonButtonStyles, CommonHeaderStyles, CommonGristStyles, ScrollbarStyles } from '@operato/styles'
+import { FetchOption } from '@operato/data-grist'
+import { CommonHeaderStyles } from '@operato/styles'
 
-// KPI 등급 타입 정의 (서버와 동일한 구조)
 interface KpiGrade {
   name: string
   minValue: number
@@ -27,268 +27,141 @@ interface KpiGrade {
 type KpiGrades = KpiGrade[]
 
 @customElement('kpi-grade-editor')
-export class KpiGradeEditor extends ScopedElementsMixin(LitElement) {
+export class KpiGradeEditor extends localize(i18next)(LitElement) {
   static styles = [
     CommonHeaderStyles,
-    ScrollbarStyles,
     css`
       :host {
         display: flex;
         flex-direction: column;
-        background-color: var(--md-sys-color-surface, #f4f6fa);
-      }
 
-      .grade-list {
-        flex: 1;
-        margin-bottom: 20px;
-        overflow-y: auto;
-      }
-
-      .grade-item {
-        display: flex;
-        align-items: center;
-        gap: 10px;
-        padding: 10px;
-        border: 1px solid #ddd;
-        border-radius: 4px;
-        margin-bottom: 10px;
-        background: #f9f9f9;
-      }
-
-      .grade-item:hover {
-        background: #f0f0f0;
-      }
-
-      .grade-inputs {
-        display: flex;
-        gap: 10px;
-        flex: 1;
+        background-color: var(--md-sys-color-surface);
       }
 
-      .grade-inputs md-outlined-text-field {
+      ox-grist {
         flex: 1;
       }
-
-      .grade-actions {
-        display: flex;
-        gap: 5px;
-      }
-
-      .footer span {
-        font-size: 0.8em;
-        color: var(--md-sys-color-on-surface);
-        line-height: 1.5;
-        padding: 10px;
-      }
     `
   ]
 
-  @property({ type: Object }) kpi: any
-  @state() grades: KpiGrades = []
-  @state() isDirty = false
+  @property({ type: Object }) kpi: any = { grades: [] }
+
+  @state() grades: KpiGrades = this.kpi?.grades || []
+  @state() gristConfig: any = null
+  @query('ox-grist') grist!: DataGrist
 
-  connectedCallback() {
-    super.connectedCallback()
+  async firstUpdated() {
     if (this.kpi?.grades) {
       this.grades = [...this.kpi.grades]
     }
+
+    this.gristConfig = {
+      list: { fields: ['name', 'minValue', 'maxValue', 'score', 'color', 'description'] },
+      columns: [
+        { type: 'gutter', gutterName: 'row-selector', multiple: true, fixed: true },
+        { type: 'gutter', gutterName: 'sequence', fixed: true },
+        { type: 'gutter', gutterName: 'button', fixed: true, icon: 'add', handlers: { click: 'record-copy' } },
+        { type: 'gutter', gutterName: 'button', fixed: true, icon: 'arrow_upward', handlers: { click: 'move-up' } },
+        { type: 'gutter', gutterName: 'button', fixed: true, icon: 'arrow_downward', handlers: { click: 'move-down' } },
+        { type: 'string', name: 'name', header: '등급명', record: { editable: true }, width: 100 },
+        { type: 'number', name: 'minValue', header: '최소값', record: { editable: true }, width: 100 },
+        { type: 'number', name: 'maxValue', header: '최대값', record: { editable: true }, width: 100 },
+        { type: 'number', name: 'score', header: '점수', record: { editable: true }, width: 80 },
+        { type: 'color', name: 'color', header: '색상', record: { editable: true }, width: 100 },
+        { type: 'string', name: 'description', header: '설명', record: { editable: true }, width: 200 }
+      ],
+      rows: { selectable: { multiple: true } },
+      pagination: { infinite: true }
+    }
   }
 
   render() {
     return html`
-      <div class="grade-list">${this.grades.map((grade, index) => this._renderGradeItem(grade, index))}</div>
-
+      <ox-grist .mode=${'GRID'} .config=${this.gristConfig} .fetchHandler=${this.fetchHandler.bind(this)}></ox-grist>
       <div class="footer">
-        <button type="button" @click=${this._addGrade}><md-icon>add</md-icon>등급 추가</button>
         <div filler></div>
-        <button type="button" @click=${this._cancel}><md-icon>cancel</md-icon>취소</button>
-        <button type="button" @click=${this._save} ?disabled=${!this.isDirty} done><md-icon>save</md-icon>저장</button>
-      </div>
-    `
-  }
-
-  _renderGradeItem(grade: KpiGrade, index: number) {
-    return html`
-      <div class="grade-item">
-        <div class="grade-inputs">
-          <md-outlined-text-field
-            label="등급명"
-            value=${grade.name}
-            @input=${(e: any) => this._updateGrade(index, 'name', e.target.value)}
-          ></md-outlined-text-field>
-
-          <md-outlined-text-field
-            label="최소값"
-            type="number"
-            value=${grade.minValue}
-            @input=${(e: any) => this._updateGrade(index, 'minValue', parseFloat(e.target.value))}
-          ></md-outlined-text-field>
-
-          <md-outlined-text-field
-            label="최대값"
-            type="number"
-            value=${grade.maxValue}
-            @input=${(e: any) => this._updateGrade(index, 'maxValue', parseFloat(e.target.value))}
-          ></md-outlined-text-field>
-
-          <md-outlined-text-field
-            label="점수"
-            type="number"
-            value=${grade.score || ''}
-            @input=${(e: any) => this._updateGrade(index, 'score', parseFloat(e.target.value))}
-          ></md-outlined-text-field>
-
-          <md-outlined-text-field
-            label="색상"
-            value=${grade.color || ''}
-            @input=${(e: any) => this._updateGrade(index, 'color', e.target.value)}
-          ></md-outlined-text-field>
-        </div>
-
-        <div class="grade-actions">
-          <md-icon-button @click=${() => this._removeGrade(index)}>
-            <md-icon>delete</md-icon>
-          </md-icon-button>
-        </div>
+        <button danger @click=${this._deleteGrades.bind(this)}>
+          <md-icon>delete</md-icon>${i18next.t('button.delete')}
+        </button>
+        <button done type="button" @click=${this._updateGrades}><md-icon>save</md-icon>저장</button>
       </div>
     `
   }
 
-  _updateGrade(index: number, field: keyof KpiGrade, value: any) {
-    this.grades[index] = { ...this.grades[index], [field]: value }
-    this.isDirty = true
-    this.requestUpdate()
-  }
-
-  _addGrade() {
-    const newGrade: KpiGrade = {
-      name: '',
-      minValue: 0,
-      maxValue: 0,
-      score: 0,
-      color: '#4caf50',
-      description: ''
+  async fetchHandler({ page, limit, sorters = [] }: FetchOption) {
+    return {
+      total: this.grades.length,
+      records: this.grades
     }
-    this.grades.push(newGrade)
-    this.isDirty = true
-    this.requestUpdate()
   }
 
-  _removeGrade(index: number) {
-    this.grades.splice(index, 1)
-    this.isDirty = true
-    this.requestUpdate()
-  }
+  async _updateGrades() {
+    this.grades = this.grist.dirtyData.records
+      .map(patch => {
+        const { name, minValue, maxValue, score, color, description } = patch
+        return { name, minValue, maxValue, score, color, description }
+      })
+      .sort((a, b) => a.minValue - b.minValue) as any
 
-  _loadTemplate(template: string) {
-    switch (template) {
-      case '5grade':
-        this.grades = [
-          { name: 'A', minValue: 0, maxValue: 1.5, score: 95, color: '#4caf50', description: '우수' },
-          { name: 'B', minValue: 1.5, maxValue: 2.5, score: 85, color: '#ff9800', description: '양호' },
-          { name: 'C', minValue: 2.5, maxValue: 3.5, score: 75, color: '#ffc107', description: '보통' },
-          { name: 'D', minValue: 3.5, maxValue: 4.5, score: 65, color: '#ff9800', description: '미흡' },
-          { name: 'E', minValue: 4.5, maxValue: 999, score: 55, color: '#f44336', description: '불량' }
-        ]
-        break
-      case '3grade':
-        this.grades = [
-          { name: '우수', minValue: 0, maxValue: 1.5, score: 95, color: '#4caf50', description: '목표 달성' },
-          { name: '양호', minValue: 1.5, maxValue: 2.5, score: 85, color: '#ff9800', description: '기준 달성' },
-          { name: '미흡', minValue: 2.5, maxValue: 999, score: 75, color: '#f44336', description: '개선 필요' }
-        ]
-        break
-      case 'continuous':
-        this.grades = [
-          { name: '0.999999', minValue: 0, maxValue: 0.025, score: 0.999999, color: '#4caf50' },
-          { name: '0.944189368', minValue: 0.025, maxValue: 0.05, score: 0.944189368, color: '#4caf50' },
-          { name: '0.888379735', minValue: 0.05, maxValue: 0.075, score: 0.888379735, color: '#4caf50' }
-        ]
-        break
-      case 'clear':
-        this.grades = []
-        break
+    if (!this._validateGrades()) {
+      return
     }
-    this.isDirty = true
-    this.requestUpdate()
-  }
 
-  async _save() {
-    try {
-      // 등급 유효성 검사
-      if (!this._validateGrades()) {
-        return
-      }
-
-      // 정렬 (minValue 기준)
-      this.grades.sort((a, b) => a.minValue - b.minValue)
-
-      this.dispatchEvent(
-        new CustomEvent('grades-updated', {
-          detail: {
-            kpiId: this.kpi.id,
-            grades: this.grades
+    if (!deepEquals(this.kpi?.grades, this.grades)) {
+      try {
+        const response = await client.mutate({
+          mutation: gql`
+            mutation ($id: String!, $patch: KpiPatch!) {
+              updateKpi(id: $id, patch: $patch) {
+                id
+                name
+                grades
+              }
+            }
+          `,
+          variables: {
+            id: this.kpi.id,
+            patch: { grades: this.grades }
           }
         })
-      )
 
-      this.isDirty = false
-    } catch (error) {
-      notify({
-        message: '등급 저장 중 오류가 발생했습니다.'
-      })
+        this.grades = response.data.updateKpi.grades
+        this.grist.fetch()
+      } catch (error) {
+        notify({ message: '등급 저장 중 오류가 발생했습니다.' })
+      }
     }
   }
 
   _validateGrades(): boolean {
-    // 최소 1개 등급 필요
     if (this.grades.length === 0) {
-      notify({
-        message: '최소 1개 이상의 등급을 설정해야 합니다.'
-      })
+      notify({ message: '최소 1개 이상의 등급을 설정해야 합니다.' })
       return false
     }
-
-    // 등급명 중복 체크
     const names = this.grades.map(g => g.name)
     const uniqueNames = new Set(names)
     if (names.length !== uniqueNames.size) {
-      notify({
-        message: '등급명이 중복되었습니다.'
-      })
+      notify({ message: '등급명이 중복되었습니다.' })
       return false
     }
-
-    // 값 범위 체크
     for (let i = 0; i < this.grades.length; i++) {
       const grade = this.grades[i]
       if (grade.minValue >= grade.maxValue) {
-        notify({
-          message: `등급 "${grade.name}"의 최소값이 최대값보다 크거나 같습니다.`
-        })
+        notify({ message: `등급 "${grade.name}"의 최소값이 최대값보다 크거나 같습니다.` })
         return false
       }
-
-      // 연속성 체크
       if (i > 0) {
         const prevGrade = this.grades[i - 1]
         if (prevGrade.maxValue !== grade.minValue) {
-          notify({
-            message: `등급 "${prevGrade.name}"과 "${grade.name}" 사이에 간격이 있습니다.`
-          })
+          notify({ message: `등급 "${prevGrade.name}"과 "${grade.name}" 사이에 간격이 있습니다.` })
           return false
         }
       }
     }
-
     return true
   }
 
-  _cancel() {
-    // 팝업 닫기
-    const popup = this.closest('ox-popup') as any
-    if (popup && popup.close) {
-      popup.close()
-    }
+  async _deleteGrades() {
+    this.grist.deleteSelectedRecords(true)
   }
 }

package/client/pages/kpi/kpi-list-page.ts

@@ -503,47 +503,13 @@ export class KpiListPage extends connect(store)(localize(i18next)(ScopedElements
   }
 
   async _editGrades(kpi: any) {
-    const popup = await openPopup(
-      html`
-        <kpi-grade-editor .kpi=${kpi} @grades-updated=${(e: any) => this._onGradesUpdated(e.detail)}></kpi-grade-editor>
-      `,
-      {
-        title: `${kpi.name} - 등급 설정`,
-        size: 'large'
-      }
-    )
-  }
-
-  async _onGradesUpdated(detail: any) {
-    const { kpiId, grades } = detail
-
-    try {
-      const response = await client.mutate({
-        mutation: gql`
-          mutation ($id: String!, $patch: KpiPatch!) {
-            updateKpi(id: $id, patch: $patch) {
-              id
-              name
-              grades
-            }
-          }
-        `,
-        variables: {
-          id: kpiId,
-          patch: { grades }
-        }
-      })
+    const popup = await openPopup(html` <kpi-grade-editor .kpi=${kpi}></kpi-grade-editor> `, {
+      title: `${kpi.name} - 등급 설정`,
+      size: 'large'
+    })
 
-      if (!response.errors) {
-        this.grist.fetch()
-        notify({
-          message: '등급 설정이 성공적으로 업데이트되었습니다.'
-        })
-      }
-    } catch (error) {
-      notify({
-        message: '등급 설정 업데이트 중 오류가 발생했습니다.'
-      })
+    popup.onclosed = () => {
+      this.grist.fetch()
     }
   }
 

package/dist-client/pages/kpi/kpi-grade-editor.d.ts

@@ -1,11 +1,11 @@
 import '@material/web/button/elevated-button.js';
 import '@material/web/button/filled-button.js';
 import '@material/web/button/text-button.js';
-import '@material/web/textfield/outlined-text-field.js';
-import '@material/web/select/outlined-select.js';
-import '@material/web/select/select-option.js';
 import '@material/web/icon/icon.js';
+import '@operato/data-grist/ox-grist.js';
 import { LitElement } from 'lit';
+import { DataGrist } from '@operato/data-grist/ox-grist.js';
+import { FetchOption } from '@operato/data-grist';
 interface KpiGrade {
     name: string;
     minValue: number;
@@ -15,21 +15,21 @@ interface KpiGrade {
     description?: string;
 }
 type KpiGrades = KpiGrade[];
-declare const KpiGradeEditor_base: typeof LitElement & import("@open-wc/dedupe-mixin").Constructor<import("@open-wc/scoped-elements/types/src/types").ScopedElementsHost>;
+declare const KpiGradeEditor_base: (new (...args: any[]) => LitElement) & typeof LitElement;
 export declare class KpiGradeEditor extends KpiGradeEditor_base {
     static styles: import("lit").CSSResult[];
     kpi: any;
     grades: KpiGrades;
-    isDirty: boolean;
-    connectedCallback(): void;
+    gristConfig: any;
+    grist: DataGrist;
+    firstUpdated(): Promise<void>;
     render(): import("lit-html").TemplateResult<1>;
-    _renderGradeItem(grade: KpiGrade, index: number): import("lit-html").TemplateResult<1>;
-    _updateGrade(index: number, field: keyof KpiGrade, value: any): void;
-    _addGrade(): void;
-    _removeGrade(index: number): void;
-    _loadTemplate(template: string): void;
-    _save(): Promise<void>;
+    fetchHandler({ page, limit, sorters }: FetchOption): Promise<{
+        total: number;
+        records: KpiGrades;
+    }>;
+    _updateGrades(): Promise<void>;
     _validateGrades(): boolean;
-    _cancel(): void;
+    _deleteGrades(): Promise<void>;
 }
 export {};