@operato/dataset 1.0.0-alpha.36 → 1.0.0-alpha.39

package/src/index.ts

@@ -1,3 +1,6 @@
 export * from './ox-data-entry-form.js'
+export * from './ox-data-sample-view.js'
+export * from './ox-data-ooc-view.js'
 export * from './ox-data-item-spec.js'
+export * from './ox-data-use-case'
 export * from './types.js'

package/src/ox-data-entry-form.ts

@@ -1,6 +1,6 @@
 import '@operato/input/ox-input-file.js'
 
-import { LitElement, css, html } from 'lit'
+import { css, html, LitElement } from 'lit'
 import { customElement, property } from 'lit/decorators.js'
 
 import { DataSet } from './types.js'
@@ -95,7 +95,7 @@ export class OxDataEntryForm extends LitElement {
       const value = this.value && this.value[tag]
 
       const elements = samples.map((_, idx) => {
-        const v = quota <= 1 ? value : value instanceof Array ? value[idx] : undefined
+        const v = value instanceof Array ? value[idx] : idx === 0 ? value : undefined
 
         switch (type) {
           case 'select':
@@ -141,19 +141,14 @@ export class OxDataEntryForm extends LitElement {
     const dataItems = this.dataSet!.dataItems
 
     return (dataItems || []).reduce((sum, dataItem) => {
-      const { tag, quota, type } = dataItem
+      const { tag, type } = dataItem
 
       const editors = Array.prototype.slice.call(
         this.renderRoot.querySelectorAll(`[name=${tag}]`) as NodeListOf<HTMLInputElement>
       ) as HTMLInputElement[]
 
       if (editors.length > 0) {
-        sum[tag] =
-          editors.length > 1
-            ? editors.map(editor => (type === 'boolean' ? editor.checked : editor.value))
-            : type === 'boolean'
-            ? editors[0].checked
-            : editors[0].value
+        sum[tag] = editors.map(editor => (type === 'boolean' ? editor.checked : editor.value))
       }
 
       return sum

package/src/ox-data-item-spec.ts

@@ -1,25 +1,13 @@
 import '@operato/property-editor/ox-properties-dynamic-view.js'
 
-import { DataItem, DataItemSpecSet, DataItemSpecSetProvider } from './types.js'
-import { LitElement, PropertyValues, css, html } from 'lit'
+import { css, html, LitElement, PropertyValues } from 'lit'
 import { customElement, property, queryAll, state } from 'lit/decorators.js'
 
+import { OxDataUseCase } from './ox-data-use-case.js'
+import { DataItem, DataItemSpecSet } from './types.js'
+
 @customElement('ox-data-item-spec')
 export class OxDataItemSpec extends LitElement {
-  static registry: { [name: string]: DataItemSpecSetProvider } = {}
-
-  public static registerProvider(name: string, provider: DataItemSpecSetProvider) {
-    OxDataItemSpec.registry[name] = provider
-  }
-
-  public static getProviderNames() {
-    return Object.keys(OxDataItemSpec.registry)
-  }
-
-  public static getProvider(name: string): DataItemSpecSetProvider | undefined {
-    return OxDataItemSpec.registry[name]
-  }
-
   static styles = css`
     :host {
       display: flex;
@@ -61,7 +49,7 @@ export class OxDataItemSpec extends LitElement {
 
   updated(changes: PropertyValues<this>) {
     if (changes.has('dataItem')) {
-      this.dataItemSpecSets = Object.values(OxDataItemSpec.registry).map(provider => provider(this.dataItem!))
+      this.dataItemSpecSets = OxDataUseCase.getUseCases().map(useCase => useCase.getSpecification(this.dataItem!))
     }
   }
 

package/src/ox-data-ooc-view.ts

@@ -0,0 +1,56 @@
+import '@operato/input/ox-input-file.js'
+import './ox-data-sample-view'
+
+import { DataOoc, DataSet } from './types.js'
+import { LitElement, css, html } from 'lit'
+import { customElement, property } from 'lit/decorators.js'
+
+@customElement('ox-data-ooc-view')
+export class OxDataOocView extends LitElement {
+  static styles = css`
+    :host {
+      display: flex;
+      flex-direction: column;
+      background-color: var(--main-section-background-color);
+      padding: var(--padding-wide);
+    }
+
+    h3 {
+      margin: var(--title-margin);
+      padding-top: 12px;
+      font: var(--title-font);
+      color: var(--title-text-color);
+    }
+
+    [page-description] {
+      margin: var(--page-description-margin);
+      font: var(--page-description-font);
+      color: var(--page-description-color);
+    }
+  `
+
+  @property({ type: Object }) dataSet?: DataSet
+  @property({ type: Object }) dataOoc?: DataOoc
+
+  render() {
+    const history = this.dataOoc?.history || []
+    const formatter = new Intl.DateTimeFormat(navigator.language, { dateStyle: 'full', timeStyle: 'short' })
+
+    return html`
+      <ox-data-sample-view .dataSample=${this.dataOoc} .dataSet=${this.dataSet}></ox-data-sample-view>
+
+      <h3>history</h3>
+      ${history.map(
+        ({ user, state, comment, timestamp }) => html`
+          <p page-description>
+            ${formatter.format(new Date(timestamp))}
+            <br />
+            ${state} by ${user.name}
+            <br />
+            ${comment}
+          </p>
+        `
+      )}
+    `
+  }
+}

package/src/ox-data-sample-view.ts

@@ -0,0 +1,171 @@
+import '@operato/input/ox-input-file.js'
+
+import { DataItem, DataSample, DataSet } from './types.js'
+import { LitElement, css, html } from 'lit'
+import { customElement, property } from 'lit/decorators.js'
+
+import { OxDataUseCase } from './ox-data-use-case.js'
+
+@customElement('ox-data-sample-view')
+export class OxDataSampleView extends LitElement {
+  static styles = css`
+    :host {
+      display: flex;
+      flex-direction: column;
+      background-color: var(--main-section-background-color);
+    }
+
+    form {
+      flex: 1;
+
+      display: flex;
+      flex-direction: column;
+    }
+
+    h2 {
+      margin: var(--title-margin);
+      padding-top: 25px;
+      font: var(--title-font);
+      color: var(--title-text-color);
+    }
+    [page-description] {
+      margin: var(--page-description-margin);
+      font: var(--page-description-font);
+      color: var(--page-description-color);
+    }
+
+    table {
+      border-collapse: collapse;
+      margin-bottom: var(--margin-default);
+    }
+    th {
+      padding: var(--th-padding);
+      border-top: var(--th-border-top);
+      border-bottom: var(--td-border-bottom);
+      text-transform: var(--th-text-transform);
+      font: var(--th-font);
+      color: var(--th-color);
+      text-align: left;
+    }
+    th[item] {
+      min-width: 100px;
+    }
+    th[value] {
+      min-width: 100px;
+    }
+    tr {
+      background-color: var(--tr-background-color);
+    }
+    tr:nth-child(odd) {
+      background-color: var(--tr-background-odd-color);
+    }
+    tr:hover {
+      background-color: var(--tr-background-hover-color);
+    }
+    tr[ooc],
+    tr[oos] {
+      background-color: #fefbdf;
+    }
+    td {
+      border-bottom: var(--td-border-bottom);
+      padding: var(--td-padding);
+      font: var(--td-font);
+      color: var(--td-color);
+    }
+    td[name] {
+      font-weight: bold;
+    }
+    td mwc-icon {
+      color: var(--status-danger-color);
+    }
+
+    pre {
+      tab-size: 2;
+    }
+  `
+
+  @property({ type: Object }) dataSet?: DataSet
+  @property({ type: Object }) dataSample?: DataSample
+
+  render() {
+    const dataItems = this.dataSet?.dataItems.filter(item => item.active) || []
+    const data = this.dataSample?.data || {}
+    const formatter = new Intl.DateTimeFormat(navigator.language, { dateStyle: 'full', timeStyle: 'short' })
+
+    return html` <h2>${this.dataSample?.name}</h2>
+      <p page-description>
+        ${this.dataSample?.description}<br /><br />
+        collected at: ${this.dataSample && formatter.format(new Date(this.dataSample?.collectedAt!))}
+      </p>
+
+      <form @change=${(e: Event) => this.onChange(e)}>
+        <table>
+          <tr>
+            <th item>item</th>
+            <th>description</th>
+            <th>unit</th>
+            <th value>value</th>
+            <th>specification</th>
+            <th>OOC</th>
+            <th>OOS</th>
+          </tr>
+          ${dataItems.map(dataItem => {
+            const { ooc, oos } = this.evaluateOOC(dataItem, data?.[dataItem.tag]) || {}
+            return html`
+              <tr ?ooc=${ooc} ?oos=${oos}>
+                <td name>${dataItem.name}</td>
+                <td>${dataItem.description}</td>
+                <td>${dataItem.unit}</td>
+                <td>${this.buildValue(dataItem)}</td>
+                <td><pre>${this.buildSpec(dataItem)}</pre></td>
+                <td>${ooc ? html`<mwc-icon>done</mwc-icon>` : ''}</td>
+                <td>${oos ? html`<mwc-icon>done</mwc-icon>` : ''}</td>
+              </tr>
+            `
+          })}
+        </table>
+      </form>`
+  }
+
+  private onChange(e: Event) {}
+
+  private buildSpec(dataItem: DataItem) {
+    return OxDataUseCase.elaborateDataItemSpec(this.dataSet!, dataItem)
+  }
+
+  private buildValue(dataItem: DataItem) {
+    const { tag, type } = dataItem
+
+    if (!this.dataSample) {
+      return ''
+    }
+
+    const value = this.dataSample?.data[dataItem.tag]
+    if (value === undefined) {
+      return ''
+    }
+    const values = value instanceof Array ? value : [value]
+
+    const elements = values.map((_: any, idx) => {
+      const v = value[idx]
+
+      switch (type) {
+        case 'boolean':
+          return html` <input type="checkbox" name=${tag} .checked=${v} disabled />`
+          break
+
+        case 'select':
+        case 'number':
+        case 'string':
+        default:
+          return String(v === undefined ? '' : v)
+      }
+    })
+
+    return type === 'boolean' ? elements : elements.join(', ')
+  }
+
+  private evaluateOOC(dataItem: DataItem, value: any) {
+    return OxDataUseCase.evaluateItem(this.dataSet!, dataItem, value)
+  }
+}

package/src/ox-data-use-case.ts

@@ -0,0 +1,147 @@
+import { DataItem, DataItemSpecSet, DataSet, EvaluationResult } from './types'
+
+export abstract class OxDataUseCase {
+  static registry: { [name: string]: OxDataUseCase } = {}
+
+  public static registerUseCase(name: string, useCase: OxDataUseCase) {
+    OxDataUseCase.registry[name] = useCase
+  }
+
+  public static getUseCaseNames() {
+    return Object.keys(OxDataUseCase.registry)
+  }
+
+  public static getUseCases(): OxDataUseCase[] {
+    return Object.values(OxDataUseCase.registry)
+  }
+
+  public static getUseCase(name: string): OxDataUseCase | undefined {
+    return OxDataUseCase.registry[name]
+  }
+
+  public static elaborateDataItemSpec(dataSet: DataSet, dataItem: DataItem): string {
+    if (!dataSet.useCase) {
+      return ''
+    }
+
+    const useCaseNames = dataSet.useCase.split(',').map(useCaseName => useCaseName.trim())
+    const useCases = useCaseNames.map(useCaseName => OxDataUseCase.getUseCase(useCaseName)).filter(useCase => !!useCase)
+
+    var texts = []
+
+    for (let j = 0; j < useCases.length; j++) {
+      const useCase = useCases[j]
+      if (!useCase) {
+        continue
+      }
+
+      const specs = dataItem.spec?.[dataSet.useCase]
+      if (!specs) {
+        continue
+      }
+
+      const result = useCase.elaborateUseCaseSpec(dataItem.spec)
+      if (!result) {
+        continue
+      }
+
+      texts.push(result)
+    }
+
+    return texts.join('\n')
+  }
+
+  public static evaluate(dataSet: DataSet, dataItems: DataItem[], data: any): EvaluationResult | undefined {
+    var ooc = false
+    var oos = false
+
+    if (!dataSet.useCase) {
+      return { ooc, oos }
+    }
+
+    const useCaseNames = dataSet.useCase.split(',').map(useCaseName => useCaseName.trim())
+    const useCases = useCaseNames.map(useCaseName => OxDataUseCase.getUseCase(useCaseName)).filter(useCase => !!useCase)
+
+    for (let i = 0; i < dataItems.length; i++) {
+      const dataItem = dataItems[i]
+      const { active, tag } = dataItem
+      if (!active || !tag) {
+        continue
+      }
+
+      let values: any | any[] = data[tag]
+      if (typeof values === 'undefined') {
+        continue // TODO what if in case no value ?
+      }
+
+      if (!(values instanceof Array)) {
+        values = [values]
+      }
+
+      for (let j = 0; j < useCases.length; j++) {
+        const useCase = useCases[j]
+
+        const specs = dataItem.spec?.[dataSet.useCase]
+        if (!specs) {
+          continue
+        }
+
+        const result = useCase?.evaluate(specs, values)
+
+        if (result) {
+          ooc ||= result.ooc
+          oos ||= result.oos
+        }
+      }
+    }
+
+    return { ooc, oos }
+  }
+
+  public static evaluateItem(dataSet: DataSet, dataItem: DataItem, values: any | any[]): EvaluationResult | undefined {
+    var ooc = false
+    var oos = false
+
+    if (!dataSet.useCase) {
+      return { ooc, oos }
+    }
+
+    const useCaseNames = dataSet.useCase.split(',').map(useCaseName => useCaseName.trim())
+    const useCases = useCaseNames.map(useCaseName => OxDataUseCase.getUseCase(useCaseName)).filter(useCase => !!useCase)
+
+    const { active, tag } = dataItem
+    if (!active || !tag) {
+      return
+    }
+
+    if (typeof values === 'undefined') {
+      return // TODO what if in case no value ?
+    }
+
+    if (!(values instanceof Array)) {
+      values = [values]
+    }
+
+    for (let j = 0; j < useCases.length; j++) {
+      const useCase = useCases[j]
+
+      const specs = dataItem.spec?.[dataSet.useCase]
+      if (!specs) {
+        return
+      }
+
+      const result = useCase?.evaluate(specs, values)
+
+      if (result) {
+        ooc ||= result.ooc
+        oos ||= result.oos
+      }
+    }
+
+    return { ooc, oos }
+  }
+
+  public abstract evaluate(specs: any, values: any[]): EvaluationResult | undefined
+  public abstract elaborateUseCaseSpec(spec: any): string | undefined
+  public abstract getSpecification(dataItem: DataItem): DataItemSpecSet
+}

package/src/types.ts

@@ -15,6 +15,7 @@ export type DataItem = {
   options: TypeOptions
   unit: string
   quota: number
+  spec: { [useCase: string]: any }
 }
 
 export type DataSet = {
@@ -24,19 +25,46 @@ export type DataSet = {
   useCase: string
   active: boolean
   dataItems: DataItem[]
+  spec: { [dataItem: string]: { [useCase: string]: any } }
 }
 
 export type DataItemSpec = {
   type: string
   label: string
   name: string
-  property: { [option: string]: any }
+  property?: { [option: string]: any }
 }
 
 export type DataItemSpecSet = {
   name: string
   description: string
+  help: string
   specs: DataItemSpec[]
 }
 
-export type DataItemSpecSetProvider = (dataItem: DataItem) => DataItemSpecSet
+export type DataSample = {
+  name: string
+  description: string
+  data: any
+  spec: any
+  quota: number
+  collectedAt: Date
+}
+
+export type DataOocState = 'CREATED' | 'REVIEWED' | 'CORRECTED'
+
+export type DataOoc = DataSample & {
+  state: DataOocState
+  correctiveAction: string
+  history: {
+    user: {
+      id: string
+      name: string
+    }
+    state: DataOocState
+    comment: string
+    timestamp: number
+  }[]
+}
+
+export type EvaluationResult = { oos: boolean; ooc: boolean }