@things-factory/organization 10.1.226 → 10.1.228

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/organization",
-  "version": "10.1.226",
+  "version": "10.1.228",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -36,11 +36,12 @@
     "@operato/p13n": "^10.0.0",
     "@operato/popup": "^10.15.0",
     "@operato/shell": "^10.0.0",
-    "@things-factory/auth-base": "^10.1.226",
-    "@things-factory/code-ui": "^10.1.226",
-    "@things-factory/contact": "^10.1.226",
-    "@things-factory/shell": "^10.1.208",
-    "xlsx": "^0.18.5"
+    "@things-factory/auth-base": "^10.1.228",
+    "@things-factory/code-ui": "^10.1.228",
+    "@things-factory/contact": "^10.1.228",
+    "@things-factory/pdf": "^10.1.228",
+    "@things-factory/shell": "^10.1.228",
+    "exceljs": "4.2.0"
   },
-  "gitHead": "abc5cf99effa2de579a1cbfda74ddc5eb41dba50"
+  "gitHead": "fc4ede44617418df8701e83b83d177db4142a8f3"
 }

package/tests/employee-profile-db.test.ts

@@ -123,6 +123,20 @@ describe("an employee's own profile", () => {
     expect(await dataSource.getRepository(organization.EmployeeProfile).count()).toBe(1)
   })
 
+  it('★ adding from a résumé takes nothing away, and reaches only one\'s own', async () => {
+    const kim = await person('kim')
+    const park = await person('park')
+    await ask(park, SAVE, { profile: { summary: 'park' } })
+    await ask(kim, SAVE, { profile: { summary: '옛 요약', skills: ['TypeScript'], projects: [{ name: 'A' }] } })
+    const ADD = `mutation ($profile: EmployeeProfileInput!) { addToMyEmployeeProfile(profile: $profile) { ${ROWS} } }`
+    const added = await ask(kim, ADD, { profile: { skills: ['typescript', 'PLC'], projects: [{ name: 'A' }, { name: 'B', role: 'PM' }] } })
+    expect(added.errors).toBeUndefined()
+    expect(added.data.addToMyEmployeeProfile).toMatchObject({ summary: '옛 요약', skills: ['TypeScript', 'PLC'], projects: [{ name: 'A' }, { name: 'B', role: 'PM' }] })
+    expect((await ask(park, MINE)).data.myEmployeeProfile.summary).toBe('park')
+    const stranger = await person('stranger', null)
+    expect((await ask(stranger, ADD, { profile: { summary: 'x' } })).errors?.[0]?.extensions?.requires).toBe('no-employee')
+  })
+
   it("★ one employee's save never touches another's profile", async () => {
     const kim = await person('kim')
     const park = await person('park')
@@ -151,6 +165,48 @@ describe('the profiles of every active employee', () => {
     expect(list.data.employeeProfiles[0]).toMatchObject({ jobPosition: '과장', jobResponsibility: '팀장', hiredOn: '2020-03-02', profile: { skills: ['A'] } })
   })
 
+  it('★ the document of the chosen: active ones only, in the order chosen, as an Excel workbook', async () => {
+    const kim = await person('kim')
+    await person('lee')
+    await person('gone', { retiredOn: '2020-01-01' })
+    const ids = (await ask(kim, LIST)).data.employeeProfiles.map((one: any) => one.employeeId)
+    const goneId = (await dataSource.getRepository(organization.Employee).findOneBy({ name: 'gone' })).id
+    const answer = await ask(kim, `query ($ids: [String!]!) { employeeProfileDocument(employeeIds: $ids, format: XLSX) { fileName mimeType content } }`, { ids: [ids[1], goneId, ids[0]] })
+    expect(answer.errors).toBeUndefined()
+    const file = answer.data.employeeProfileDocument
+    expect(file.fileName).toMatch(/^text\.employee-profile-file-\d{8}\.xlsx$/)
+    expect(file.mimeType).toBe('application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
+    const { Workbook } = require('exceljs')
+    const book = new Workbook()
+    await book.xlsx.load(Buffer.from(file.content, 'base64'))
+    expect(book.worksheets.map((sheet: any) => sheet.name)).toEqual(['Text.employee-profile-doc-roste', 'lee', 'kim'])
+  })
+
+  it('the preview is an HTML page of the same people', async () => {
+    const kim = await person('kim')
+    const ids = (await ask(kim, LIST)).data.employeeProfiles.map((one: any) => one.employeeId)
+    const answer = await ask(kim, `query ($ids: [String!]!) { employeeProfileDocument(employeeIds: $ids, format: HTML) { fileName mimeType content } }`, { ids })
+    expect(answer.errors).toBeUndefined()
+    const file = answer.data.employeeProfileDocument
+    expect(file.mimeType).toBe('text/html')
+    expect(file.fileName).toMatch(/\.html$/)
+    expect(Buffer.from(file.content, 'base64').toString('utf8')).toContain('<td class="name" colspan="6">kim</td>')
+  })
+
+  it("★ the document's own words follow the language asked for - one the application runs - or the reader's", () => {
+    const { documentTranslator } = loadCompiled('service/employee-profile/employee-profile-query')
+    const env = require('@things-factory/env')
+    const runs = jest.spyOn(env.config, 'get').mockImplementation((key: string, fallback: any) => (key === 'i18n/languages' ? [{ code: 'ko-KR' }, { code: 'en-US' }] : fallback))
+    try {
+      const context = { t: (key: string) => `reader:${key}`, i18next: { getFixedT: (lng: string) => (key: string) => `${lng}:${key}` } }
+      expect(documentTranslator(context, null)('text.employee-profile-doc-title')).toBe('reader:text.employee-profile-doc-title')
+      expect(documentTranslator(context, 'en-US')('text.employee-profile-doc-title')).toBe('en-US:text.employee-profile-doc-title')
+      expect(() => documentTranslator(context, 'fr-FR')).toThrow('does not run the language "fr-FR"')
+    } finally {
+      runs.mockRestore()
+    }
+  })
+
   it('★ reaching a profile does not reach the employee record behind it', () => {
     const type = schema.getType('EmployeeProfile').getFields()
     expect(Object.keys(type)).not.toContain('employee')
@@ -172,10 +228,15 @@ describe('what each door asks', () => {
     expect(asks(source('employee-profile-query.ts'), 'myEmployeeProfile')).toEqual(['employee-self', 'query', 'true'])
     expect(asks(source('employee-profile-query.ts'), 'employeeProfiles')).toEqual(['employee-profile', 'query', 'true'])
     const mutation = source('employee-profile-mutation.ts')
-    expect(asks(mutation, 'saveMyEmployeeProfile')).toEqual(['employee-self', 'mutation', 'true'])
-    expect(mutation).toMatch(/@Directive\('@transaction'\)\n  @Directive\('@privilege\(category: "employee-self", privilege: "mutation"/)
-    expect([...mutation.matchAll(/@Mutation\(/g)]).toHaveLength(1)
-    expect(mutation).toMatch(/requireMyEmployee\(context\)/)
+    /* Two doors write - saving the whole and adding from a résumé - and each finds the profile from the caller alone. */
+    expect([...mutation.matchAll(/@Mutation\(/g)]).toHaveLength(2)
+    for (const door of ['saveMyEmployeeProfile', 'addToMyEmployeeProfile']) {
+      expect(asks(mutation, door)).toEqual(['employee-self', 'mutation', 'true'])
+      const body = mutation.slice(mutation.indexOf(`async ${door}(`)).split('\n  }')[0]
+      expect(body).toMatch(/requireMyEmployee\(context\)/)
+      expect(body).not.toMatch(/@Arg\('(employee|employeeId|user|userId)'/)
+    }
+    expect([...mutation.matchAll(/@Directive\('@transaction'\)\n  @Directive\('@privilege\(category: "employee-self", privilege: "mutation"/g)]).toHaveLength(2)
   })
 
   it('★ the tasks grant them: own-profile to write one\'s own, profiles-reading to read everyone\'s', () => {

package/tests/employee-profile-document.test.ts

@@ -0,0 +1,219 @@
+import { Workbook } from 'exceljs'
+
+import {
+  careerLengthOf,
+  careerMonths,
+  heightOf,
+  rosterTaglineOf,
+  taglineOf,
+  dotted,
+  layoutHtml,
+  periodOf,
+  profileFileName,
+  profileFooterHtml,
+  profileHtml,
+  profilePreviewHtml,
+  profileSheetLayout,
+  profileWorkbook,
+  profileWordsOf,
+  lead,
+  rosterLayout,
+  sheetNamesOf,
+  type ProfileSheetWords
+} from '../server/service/employee-profile/employee-profile-document'
+
+/** The profiles a quotation attaches - one layout, painted as Excel and as HTML for PDF (ADR-0169 decision 5). */
+const COUNTS: Record<string, (...args: number[]) => string> = {
+  years: (years, months) => `${years}y${months}m`,
+  projectCount: n => `${n}p`,
+  certificateCount: n => `${n}c`,
+  peopleCount: n => `${n}people`
+}
+const WORDS = new Proxy({} as any, { get: (_target, key) => COUNTS[String(key)] ?? `<${String(key)}>` }) as ProfileSheetWords
+
+const TODAY = new Date('2026-10-28T00:00:00Z')
+
+const KIM = {
+  name: '김하늘',
+  departmentName: '개발팀',
+  jobPosition: '과장',
+  jobResponsibility: '팀장',
+  hiredOn: '2020-03-02',
+  profile: {
+    summary: 'MES 10년',
+    skills: ['TypeScript', 'PostgreSQL'],
+    educations: [{ school: '서울대', major: '컴퓨터공학', degree: '학사', startedOn: '2005-03', endedOn: '2009-02' }],
+    certificates: [{ name: '정보처리기사', issuer: '한국산업인력공단', acquiredOn: '2010-05-01' }],
+    careers: [{ company: 'A사', department: '연구소', position: '대리', startedOn: '2009-03', endedOn: '2019-12', duties: 'ERP' }],
+    projects: [{ name: '미라텍 MES', client: '미라텍', startedOn: '2024-01', role: 'PM', duties: '설계', technologies: 'Node' }]
+  }
+}
+
+const valuesOf = (line: { cells: { value: string }[] }) => line.cells.map(cell => cell.value)
+
+describe('one layout of a staffing profile', () => {
+  const cellsOf = (lines: ReturnType<typeof profileSheetLayout>, role: string) => lines.flatMap(line => line.cells.filter(cell => cell.role === role).map(cell => cell.value))
+
+  it('★ the name large with where the person stands, then the figures a buyer weighs', () => {
+    const lines = profileSheetLayout(KIM, WORDS, '(주)하티오랩', TODAY)
+    expect(valuesOf(lines[0])).toEqual(['(주)하티오랩', '<title>'])
+    expect(lines[1].cells).toEqual([{ col: 1, span: 6, value: '김하늘', role: 'name' }])
+    expect(valuesOf(lines[2])).toEqual(['개발팀  ·  과장 / 팀장  ·  <hiredOn> 2020.03.02'])
+    expect(lines[3].cells[0].role).toBe('rule')
+    expect(cellsOf(lines, 'statLabel')).toEqual(['<careerLength>', '<projectsDone>', '<certificatesHeld>'])
+    expect(cellsOf(lines, 'statValue')).toEqual([careerLengthOf(KIM, WORDS, TODAY), '1p', '1c'])
+  })
+
+  it('★ the expertise, then the projects first - careers, certificates and education after; no line to sign', () => {
+    const lines = profileSheetLayout(KIM, WORDS, '(주)하티오랩', TODAY)
+    expect(cellsOf(lines, 'section')).toEqual(['<expertise>', '<projects>', '<careers>', '<certificates>', '<educations>'])
+    expect(cellsOf(lines, 'summary')).toEqual(['MES 10년'])
+    expect(cellsOf(lines, 'skills')).toEqual(['TypeScript, PostgreSQL'])
+    const rowAfter = (section: string) => valuesOf(lines[lines.findIndex(line => line.cells[0]?.value === section && line.cells[0].role === 'section') + 3])
+    expect(rowAfter('<projects>')).toEqual(['2024.01 ~ <ongoing>', '미라텍 MES', '미라텍', 'PM', '설계', 'Node'])
+    expect(rowAfter('<careers>')).toEqual(['2009.03 ~ 2019.12', 'A사', '연구소', '대리', 'ERP'])
+    expect(rowAfter('<certificates>')).toEqual(['2010.05.01', '정보처리기사', '한국산업인력공단'])
+    expect(rowAfter('<educations>')).toEqual(['2005.03 ~ 2009.02', '서울대', '컴퓨터공학', '학사'])
+    expect(JSON.stringify(lines)).not.toMatch(/affirmation|signature/)
+  })
+
+  it('every other row of a table is shaded', () => {
+    const two = { ...KIM, profile: { ...KIM.profile, projects: [KIM.profile.projects[0], KIM.profile.projects[0], KIM.profile.projects[0]] } }
+    const lines = profileSheetLayout(two, WORDS, '', TODAY)
+    const rows = lines.filter(line => line.cells[0]?.role === 'value' && line.cells.length === 6)
+    expect(rows.map(line => !!line.zebra)).toEqual([false, true, false])
+  })
+
+  it('a person with nothing written: dashes for the figures, no summary box, every table says so', () => {
+    const lines = profileSheetLayout({ name: '박지민', profile: null }, WORDS, '', TODAY)
+    expect(cellsOf(lines, 'statValue')).toEqual(['—', '—', '—'])
+    expect(cellsOf(lines, 'summary')).toEqual([])
+    expect(cellsOf(lines, 'none')).toEqual(['<none>', '<none>', '<none>', '<none>'])
+    expect(taglineOf({ name: '박지민' }, WORDS)).toBe('')
+  })
+
+  it('★ the career counts the months worked once - earlier jobs and the time here, overlaps not twice', () => {
+    expect(careerMonths({ hiredOn: '2026-01-15' }, TODAY)).toBe(10)
+    expect(careerMonths({ hiredOn: '2025-10-01', profile: { careers: [{ startedOn: '2025-01', endedOn: '2025-12' }] } }, TODAY)).toBe(22)
+    expect(careerMonths({ profile: { careers: [{ startedOn: '2024-01' }] } }, TODAY)).toBe(34)
+    expect(careerMonths({ profile: { careers: [{ endedOn: '2020-01' }] } }, TODAY)).toBe(0)
+    expect(careerLengthOf(KIM, WORDS, TODAY)).toBe(`${Math.floor(careerMonths(KIM, TODAY) / 12)}y${careerMonths(KIM, TODAY) % 12}m`)
+    expect(careerLengthOf({}, WORDS, TODAY)).toBe('')
+  })
+
+  it('periods and days in the dotted form, an open end still going on', () => {
+    expect(dotted('2023-03')).toBe('2023.03')
+    expect(periodOf('2024-01', '', 'now')).toBe('2024.01 ~ now')
+    expect(periodOf('', '2024-01', 'now')).toBe('~ 2024.01')
+    expect(periodOf(undefined, undefined, 'now')).toBe('')
+  })
+
+  it('a roster: how many and their experience on average, then one line a person in the order picked', () => {
+    const lines = rosterLayout([KIM, { name: '박지민', hiredOn: '2025-10-01' }], WORDS, 'C', TODAY)
+    expect(valuesOf(lines[0])).toEqual(['C', '<writtenOn> 2026.10.28'])
+    expect(valuesOf(lines[1])).toEqual(['<rosterTitle>'])
+    const average = Math.round((careerMonths(KIM, TODAY) + 13) / 2)
+    expect(valuesOf(lines[2])).toEqual([`2people  ·  <averageCareer> ${Math.floor(average / 12)}y${average % 12}m`])
+    expect(valuesOf(lines[5])).toEqual(['<number>', '<name>', '<department>', '<jobPosition>', '<careerLength>', '<skills>'])
+    expect(lines.slice(6).map(line => valuesOf(line).slice(0, 2))).toEqual([['1', '김하늘'], ['2', '박지민']])
+    expect(rosterTaglineOf([], WORDS, TODAY)).toBe('0people')
+  })
+})
+
+describe('painted as Excel', () => {
+  it('★ a ruled line is as tall as its longest cell wraps - Excel does not grow it for written text', () => {
+    const one = heightOf({ cells: [{ col: 1, value: '2012.03 ~ 2019.02', role: 'value' }, { col: 2, span: 5, value: '짧음', role: 'value' }] })!
+    const wrapped = heightOf({ cells: [{ col: 5, value: '요구 분석, 설계, 일정·인력 관리와 고객 보고', role: 'value' }] })!
+    expect(one).toBe(22)
+    expect(wrapped).toBeGreaterThan(one)
+    expect(heightOf({ cells: [{ col: 1, span: 6, value: 'x', role: 'name' }] })).toBeUndefined()
+    expect(heightOf({ cells: [{ col: 1, value: 'a\nb\nc', role: 'value' }] })).toBe(52)
+    expect(heightOf({ cells: [{ col: 1, span: 6, value: '짧은 소개', role: 'summary' }] })).toBe(30)
+  })
+
+  async function readBack(people: any[]) {
+    const buffer = await profileWorkbook(people, WORDS, '(주)하티오랩', TODAY).xlsx.writeBuffer()
+    const book = new Workbook()
+    await book.xlsx.load(buffer as any)
+    return book
+  }
+
+  it('★ several people open with the roster, then a sheet a person in the order picked - read back from the file', async () => {
+    const book = await readBack([KIM, { name: '박지민' }])
+    expect(book.worksheets.map(sheet => sheet.name)).toEqual(['<rosterTitle>', '김하늘', '박지민'])
+    expect((await readBack([KIM])).worksheets.map(sheet => sheet.name)).toEqual(['김하늘'])
+  })
+
+  it('★ the title spans the page, labels and heads are shaded and ruled, values ruled and wrapped, A4 to one page wide', async () => {
+    const sheet = (await readBack([KIM])).getWorksheet('김하늘')!
+    expect(sheet.getCell('A2').value).toBe('김하늘')
+    expect(sheet.getCell('A2').font).toMatchObject({ bold: true, size: 22, color: { argb: 'FF1F3A5F' } })
+    expect(sheet.getCell('F2').isMerged).toBe(true)
+    expect(sheet.getCell('A4').border?.bottom?.style).toBe('thick')
+    const rows = sheet.getRows(1, sheet.rowCount)!
+    const head = rows.find(row => row.getCell(1).value === '<period>')!
+    expect((head.getCell(1).fill as any)?.fgColor?.argb).toBe('FF1F3A5F')
+    expect(head.getCell(1).font?.color?.argb).toBe('FFFFFFFF')
+    const value = sheet.getRow(head.number + 1).getCell(2)
+    expect(value.value).toBe('미라텍 MES')
+    expect(value.border?.right?.style).toBe('thin')
+    expect(value.alignment).toMatchObject({ wrapText: true, indent: 1 })
+    expect(sheet.headerFooter.oddFooter).toBe('&L&8(주)하티오랩  ·  <title>&R&8&P / &N')
+    expect(sheet.pageSetup).toMatchObject({ paperSize: 9, orientation: 'portrait', fitToWidth: 1, fitToHeight: 0 })
+    expect(sheet.views[0]).toMatchObject({ showGridLines: false })
+    expect(sheet.getColumn(1).width).toBe(18)
+  })
+
+  it('★ sheet names Excel takes: at most 31 characters, none of \\ / ? * [ ] :, no two alike, none the roster has', () => {
+    const names = sheetNamesOf(['홍길동', '홍길동', 'HONG', 'hong', 'a/b:c*d?[e]', '', null, 'x'.repeat(40), 'x'.repeat(40), '인력 현황'], ['인력 현황'])
+    expect(names.slice(0, 7)).toEqual(['홍길동', '홍길동 (2)', 'HONG', 'hong (2)', 'a b c d  e', '#6', '#7'])
+    expect(names[7]).toBe('x'.repeat(31))
+    expect(names[8]).toBe('x'.repeat(27) + ' (2)')
+    expect(names[9]).toBe('인력 현황 (2)')
+  })
+})
+
+describe('painted as HTML for the PDF', () => {
+  it('★ a page a person after the roster, the same cells, spans as colspan, text escaped', () => {
+    const html = profileHtml([KIM, { name: '<b>박</b>' }], WORDS, 'C', TODAY)
+    expect(html.match(/<section class="sheet">/g)).toHaveLength(3)
+    expect(html).toContain('<td class="name" colspan="6">김하늘</td>')
+    expect(html).toContain('<span class="tag">TypeScript</span><span class="tag">PostgreSQL</span>')
+    expect(html).toMatch(/<tr class="zebra"|<tr style/)
+    expect(html).toContain('&lt;b&gt;박&lt;/b&gt;')
+    expect(html).not.toContain('<b>박</b>')
+  })
+
+  it('a line keeps its line breaks, an empty line is a gap, a cell left of the first one is filled', () => {
+    expect(layoutHtml([{ cells: [{ col: 2, value: 'a\nb', role: 'value' }] }])).toContain('<td colspan="1"></td><td class="value">a<br>b</td><td colspan="4"></td>')
+    expect(layoutHtml([{ cells: [] }])).toContain('<tr class="gap">')
+  })
+
+  it('the foot of every PDF page: the employer and the page of how many, a brace in the name opening no template', () => {
+    const footer = profileFooterHtml('{{evil}} & Co', WORDS)
+    expect(footer).toContain('&#123;&#123;evil&#125;&#125; &amp; Co  ·  &lt;title&gt;')
+    expect(footer).toContain('<span class="pageNumber"></span> / <span class="totalPages"></span>')
+  })
+
+  it('★ the preview is the same pages as one document, shown as sheets of A4 on a screen', () => {
+    const page = profilePreviewHtml([KIM], WORDS, 'C', TODAY)
+    expect(page.startsWith('<!doctype html>')).toBe(true)
+    expect(page).toContain(profileHtml([KIM], WORDS, 'C', TODAY))
+    expect(page).toMatch(/@media screen \{[\s\S]*\.sheet \{[^}]*width: 210mm/)
+  })
+
+  it('the words head as a document heads - a capital first where the language has one', () => {
+    expect(lead('proyectos')).toBe('Proyectos')
+    expect(lead('프로젝트 이력')).toBe('프로젝트 이력')
+    expect(lead('')).toBe('')
+    const words = profileWordsOf(key => (key === 'text.employee-profile-doc-years' ? '{years} años' : 'habilidades'))
+    expect(words.skills).toBe('Habilidades')
+    expect(words.years(2, 0)).toBe('{years} años')
+  })
+
+  it('the file is named by the word and the day', () => {
+    expect(profileFileName('인력프로필', 'xlsx', new Date(2026, 9, 7))).toBe('인력프로필-20261007.xlsx')
+    expect(profileFileName('인력프로필', 'pdf', new Date(2026, 9, 7))).toBe('인력프로필-20261007.pdf')
+    expect(profileFileName('인력프로필', 'html', new Date(2026, 9, 7))).toBe('인력프로필-20261007.html')
+  })
+})

package/tests/employee-profile-entry.test.ts

@@ -0,0 +1,72 @@
+/*
+ * The person's own profile as the assistant's 입력안 (ADR-0169 decision 10): a résumé read into rows of sections, each
+ * section added to one's own profile by one call of addToMyEmployeeProfile, nothing kept taken away.
+ */
+import { clearEntryTargets, declareEntryTarget } from '../../ai-assistant/server/service/data-entry/entry-target'
+import { profileAdditionOf, profileEntryIssues, PROFILE_ENTRY_FIELDS } from '../server/ai-entry/employee-profile-entry'
+import { employeeProfileEntryTarget, ORGANIZATION_EMPLOYEE_PROFILE } from '../server/ai-entry/organization-entry-targets'
+import { addedProfileOf } from '../server/service/employee-profile/employee-profile-rules'
+
+import en from '../translations/en.json'
+import es from '../translations/es.json'
+import ko from '../translations/ko.json'
+
+const row = (values: Record<string, unknown>, index = 0) => ({ index, values, sources: [], issues: [] })
+
+describe("the assistant's 입력안 of one's own profile", () => {
+  afterEach(() => clearEntryTargets())
+
+  it('★ is accepted by the assistant as declared - one call of addToMyEmployeeProfile a section', () => {
+    const target = employeeProfileEntryTarget()
+    expect(() => declareEntryTarget(target as any)).not.toThrow()
+    expect(target.key).toBe(ORGANIZATION_EMPLOYEE_PROFILE)
+    expect(target.mutation).toMatch(/addToMyEmployeeProfile\(profile: \$profile\)/)
+    expect(target.group?.by).toBe('section')
+    expect(target.description).toMatch(/OWN/)
+  })
+
+  it('★ the rows of a section become what the door adds - only the section fields', () => {
+    expect(profileAdditionOf([row({ section: 'summary', text: ' MES 12년 ' })])).toEqual({ summary: 'MES 12년' })
+    expect(profileAdditionOf([row({ section: 'skill', text: 'TypeScript' }), row({ section: 'skill', text: 'PLC' }, 1)])).toEqual({ skills: ['TypeScript', 'PLC'] })
+    expect(profileAdditionOf([row({ section: 'project', name: '미라텍 MES', client: '미라텍', startedOn: '2024-01', role: 'PM', school: '섞임' })])).toEqual({
+      projects: [{ name: '미라텍 MES', client: '미라텍', startedOn: '2024-01', endedOn: '', role: 'PM', duties: '', technologies: '' }]
+    })
+    expect(profileAdditionOf([row({ section: 'education', school: '한양대', degree: '학사' })])).toEqual({
+      educations: [{ school: '한양대', major: '', degree: '학사', startedOn: '', endedOn: '' }]
+    })
+  })
+
+  it('a row without what its section needs is kept out, and so is a second summary', () => {
+    const issues = profileEntryIssues([
+      row({ section: 'project', client: '미라텍' }),
+      row({ section: 'certificate', name: 'PMP' }, 1),
+      row({ section: 'summary', text: 'a' }, 2),
+      row({ section: 'summary', text: 'b' }, 3)
+    ])
+    expect(issues[0]).toEqual([{ field: 'name', code: 'required', blocking: true }])
+    expect(issues[1]).toEqual([])
+    expect(issues[2]).toEqual([])
+    expect(issues[3].map(issue => issue.code)).toEqual(['one-summary'])
+  })
+
+  it('★ adding takes nothing away: a summary given replaces, skills and rows are added unless already there', () => {
+    const held = { summary: '옛 요약', skills: ['TypeScript'], projects: [{ name: 'A', client: 'X' }], educations: [], certificates: [], careers: [] }
+    const added = addedProfileOf(held, { summary: '새 요약', skills: ['typescript', 'PLC'], projects: [{ name: ' a ', client: 'x' }, { name: 'B' }] })
+    expect(added).toEqual({ summary: '새 요약', skills: ['TypeScript', 'PLC'], educations: [], certificates: [], careers: [], projects: [{ name: 'A', client: 'X' }, { name: 'B' }] })
+    expect(addedProfileOf(held, { skills: ['Go'] }).summary).toBe('옛 요약')
+    expect(addedProfileOf(null, { certificates: [{ name: 'PMP' }] }).certificates).toEqual([{ name: 'PMP' }])
+  })
+
+  it('every word the card shows is in the languages the application runs', () => {
+    const keys = [
+      employeeProfileEntryTarget().labelKey,
+      ...PROFILE_ENTRY_FIELDS.map(field => field.labelKey!),
+      ...PROFILE_ENTRY_FIELDS.find(field => field.name === 'section')!.values!.map(value => `text.organization-entry-profile-section-${value}`),
+      'text.organization-entry-profile-one-summary'
+    ]
+    for (const [language, words] of Object.entries({ ko, en, es } as Record<string, Record<string, string>>)) {
+      const missing = keys.filter(key => !(key in words) && !['label.department'].includes(key))
+      expect([language, missing]).toEqual([language, []])
+    }
+  })
+})

package/tests/employee-profile-rules.test.ts

@@ -1,5 +1,5 @@
 import { employeesWithProfiles, isActiveEmployee, profileDocumentOf, PROFILE_ROW_FIELDS } from '../server/service/employee-profile/employee-profile-rules'
-import { PROFILE_SECTIONS, profileFormOf, profileInputOf, skillsOf } from '../client/pages/employee-profile/employee-profile-form'
+import { addSkills, blankRow, completenessOf, headlineOf, periodLabelOf, PROFILE_SECTIONS, profileFormOf, profileInputOf } from '../client/pages/employee-profile/employee-profile-form'
 
 /** The employee's profile is saved whole, as the screen holds it (ADR-0169 decision 2). */
 describe("an employee's profile as it is saved", () => {
@@ -34,13 +34,40 @@ describe("an employee's profile as it is saved", () => {
     expect(PROFILE_SECTIONS.map(section => section.key).sort()).toEqual(Object.keys(PROFILE_ROW_FIELDS).sort())
   })
 
-  it('the skills are written in one line and sent as a list', () => {
-    expect(skillsOf(' Java, Spring ,,\nKotlin ')).toEqual(['Java', 'Spring', 'Kotlin'])
+  it('skills are added as typed - split at commas and line ends, no repeat whatever the case', () => {
+    expect(addSkills(['Java'], ' java, Spring ,,\nKotlin, spring ')).toEqual(['Java', 'Spring', 'Kotlin'])
     const form = profileFormOf({ summary: 'S', skills: ['A', 'B'], projects: [{ name: 'P', other: 'x' }] })
-    expect(form.skills).toBe('A, B')
-    expect(form.projects).toEqual([{ name: 'P', client: '', role: '', startedOn: '', endedOn: '', technologies: '', duties: '' }])
+    expect(form.skills).toEqual(['A', 'B'])
     expect(profileInputOf(form).skills).toEqual(['A', 'B'])
-    expect(profileFormOf(null)).toEqual({ summary: '', skills: '', educations: [], certificates: [], careers: [], projects: [] })
+    expect(profileFormOf(null)).toEqual({ summary: '', skills: [], educations: [], certificates: [], careers: [], projects: [] })
+  })
+
+  it('★ a job or project begun and not ended is going on; going on is never sent, and sends no end', () => {
+    const form = profileFormOf({ projects: [{ name: 'P', startedOn: '2024-01', endedOn: null, other: 'x' }], careers: [{ company: 'A', startedOn: '2020-01', endedOn: '2023-12' }] })
+    expect(form.projects).toEqual([{ name: 'P', client: '', role: '', startedOn: '2024-01', endedOn: '', technologies: '', duties: '', ongoing: 'true' }])
+    expect(form.careers[0].ongoing).toBe('')
+    const sent = profileInputOf({ ...form, careers: [{ ...form.careers[0], ongoing: 'true' }] })
+    expect(sent.careers).toEqual([{ company: 'A', department: '', position: '', startedOn: '2020-01', endedOn: '', duties: '' }])
+    expect(sent.projects[0]).not.toHaveProperty('ongoing')
+    const projects = PROFILE_SECTIONS.find(section => section.key === 'projects')!
+    expect(blankRow(projects)).toHaveProperty('ongoing', '')
+    expect(blankRow(PROFILE_SECTIONS.find(section => section.key === 'certificates')!)).toEqual({ name: '', issuer: '', acquiredOn: '' })
+  })
+
+  it("a row's headline and period in one line each", () => {
+    const projects = PROFILE_SECTIONS.find(section => section.key === 'projects')!
+    expect(headlineOf(projects, { name: '미라텍 MES', client: '', role: 'PM' })).toBe('미라텍 MES · PM')
+    expect(periodLabelOf({ startedOn: '2024-01', endedOn: '', ongoing: 'true' }, '현재')).toBe('2024.01 ~ 현재')
+    expect(periodLabelOf({ startedOn: '2020-01', endedOn: '2023-12' }, '현재')).toBe('2020.01 ~ 2023.12')
+    expect(periodLabelOf({ name: 'x', acquiredOn: '2010-05-01' }, '현재')).toBe('2010.05.01')
+    expect(periodLabelOf({ startedOn: '', endedOn: '' }, '현재')).toBe('')
+  })
+
+  it('★ complete when the summary, skills, education and projects are written - jobs and certificates are not asked', () => {
+    const empty = profileFormOf(null)
+    expect(completenessOf(empty)).toEqual({ percent: 0, missing: ['summary', 'skills', 'educations', 'projects'] })
+    expect(completenessOf({ ...empty, summary: '  ', skills: ['A'] })).toEqual({ percent: 25, missing: ['summary', 'educations', 'projects'] })
+    expect(completenessOf({ ...empty, summary: 'S', skills: ['A'], educations: [{}], projects: [{}] }).percent).toBe(100)
   })
 })
 

package/translations/en.json

@@ -132,15 +132,55 @@
   "label.employee-profile-role": "role",
   "label.employee-profile-technologies": "technologies",
   "label.employee-profile-updated-at": "profile updated",
-  "text.employee-profile-skills-hint": "separate them with commas",
   "text.employee-profile-not-linked-title": "this account is not linked to an employee record",
   "text.employee-profile-not-linked-description": "each employee writes their own profile. A $t(term.domain) administrator can link this account to an employee in the employee list.",
   "text.employee-profile-select-rows-first": "select the employees to download first",
   "text.employee-profile-file": "employee-profiles",
   "text.employee-profile-empty": "no active employees",
-  "text.employee-profile-no-rows": "nothing written yet",
   "task.organization.own-profile.name": "My profile",
   "task.organization.own-profile.description": "Reads and writes one's own profile - summary, skills, education, certificates, career and projects.",
   "task.organization.profiles-reading.name": "Reading employee profiles",
-  "task.organization.profiles-reading.description": "Reads every active employee's profile and downloads them as Excel. Contact, address, accounts and pay are not among them."
+  "task.organization.profiles-reading.description": "Reads every active employee's profile and downloads them as Excel. Contact, address, accounts and pay are not among them.",
+  "text.employee-profile-doc-title": "Staff Profile",
+  "text.employee-profile-doc-roster": "Staff Roster",
+  "text.employee-profile-doc-ongoing": "present",
+  "text.employee-profile-doc-none": "None",
+  "text.employee-profile-doc-written-on": "Written on",
+  "text.employee-profile-doc-number": "No.",
+  "text.employee-profile-doc-years": "{years} yr {months} mo",
+  "label.employee-profile-career-length": "total experience",
+  "button.employee-profile-download-pdf": "download as PDF",
+  "text.employee-profile-completeness": "Profile completeness",
+  "text.employee-profile-to-fill": "To fill",
+  "text.employee-profile-ready": "Ready to attach to a quotation",
+  "text.employee-profile-unsaved": "There are unsaved changes",
+  "text.employee-profile-summary-example": "e.g. Ten years designing and building manufacturing MES - process modelling and equipment integration, PM for the last three.",
+  "text.employee-profile-skill-placeholder": "Type a skill and press Enter",
+  "text.employee-profile-why-educations": "Start from the latest degree.",
+  "text.employee-profile-why-certificates": "Certificates a bid looks at.",
+  "text.employee-profile-why-careers": "Jobs before this company - they add to the total experience.",
+  "text.employee-profile-why-projects": "The first thing read on a profile attached to a quotation - the role and what was done.",
+  "label.employee-profile-ongoing": "ongoing",
+  "text.employee-profile-new-entry": "New entry",
+  "text.employee-profile-doc-expertise": "Core Expertise",
+  "text.employee-profile-doc-projects-done": "Projects delivered",
+  "text.employee-profile-doc-certificates-held": "Certifications",
+  "text.employee-profile-doc-project-count": "{n}",
+  "text.employee-profile-doc-certificate-count": "{n}",
+  "text.employee-profile-doc-people": "{n} people",
+  "text.employee-profile-doc-average-career": "Average experience",
+  "label.employee-profile-document-language": "document language",
+  "button.employee-profile-preview": "preview",
+  "title.employee-profile-preview": "staff profile preview",
+  "label.organization-entry-employee-profile": "my profile",
+  "label.organization-entry-profile-section": "part",
+  "label.organization-entry-profile-text": "text",
+  "label.organization-entry-profile-name": "name",
+  "text.organization-entry-profile-section-summary": "summary",
+  "text.organization-entry-profile-section-skill": "skill",
+  "text.organization-entry-profile-section-education": "education",
+  "text.organization-entry-profile-section-certificate": "certificate",
+  "text.organization-entry-profile-section-career": "career",
+  "text.organization-entry-profile-section-project": "project",
+  "text.organization-entry-profile-one-summary": "A profile has one summary"
 }

package/translations/es.json

@@ -132,15 +132,55 @@
   "label.employee-profile-role": "rol",
   "label.employee-profile-technologies": "tecnologías",
   "label.employee-profile-updated-at": "perfil actualizado",
-  "text.employee-profile-skills-hint": "sepárelas con comas",
   "text.employee-profile-not-linked-title": "esta cuenta no está vinculada a un registro de empleado",
   "text.employee-profile-not-linked-description": "cada empleado escribe su propio perfil. Un administrador de $t(term.domain) puede vincular esta cuenta a un empleado en la lista de empleados.",
   "text.employee-profile-select-rows-first": "seleccione primero los empleados que desea descargar",
   "text.employee-profile-file": "perfiles-empleados",
   "text.employee-profile-empty": "no hay empleados en activo",
-  "text.employee-profile-no-rows": "todavía no hay nada escrito",
   "task.organization.own-profile.name": "Mi perfil",
   "task.organization.own-profile.description": "Lee y escribe el propio perfil: resumen, habilidades, formación, certificaciones, experiencia y proyectos.",
   "task.organization.profiles-reading.name": "Lectura de perfiles de empleados",
-  "task.organization.profiles-reading.description": "Lee el perfil de cada empleado en activo y los descarga en Excel. No incluye contacto, dirección, cuentas ni nómina."
+  "task.organization.profiles-reading.description": "Lee el perfil de cada empleado en activo y los descarga en Excel. No incluye contacto, dirección, cuentas ni nómina.",
+  "text.employee-profile-doc-title": "Perfil profesional",
+  "text.employee-profile-doc-roster": "Relación de personal",
+  "text.employee-profile-doc-ongoing": "actualidad",
+  "text.employee-profile-doc-none": "Ninguno",
+  "text.employee-profile-doc-written-on": "Fecha",
+  "text.employee-profile-doc-number": "N.º",
+  "text.employee-profile-doc-years": "{years} años {months} meses",
+  "label.employee-profile-career-length": "experiencia total",
+  "button.employee-profile-download-pdf": "descargar PDF",
+  "text.employee-profile-completeness": "Perfil completado",
+  "text.employee-profile-to-fill": "Por completar",
+  "text.employee-profile-ready": "Listo para adjuntar a una oferta",
+  "text.employee-profile-unsaved": "Hay cambios sin guardar",
+  "text.employee-profile-summary-example": "p. ej. Diez años diseñando e implantando MES de fabricación; modelado de procesos e integración de equipos, PM los últimos tres.",
+  "text.employee-profile-skill-placeholder": "Escriba una habilidad y pulse Intro",
+  "text.employee-profile-why-educations": "Empiece por la titulación más reciente.",
+  "text.employee-profile-why-certificates": "Las certificaciones que mira una licitación.",
+  "text.employee-profile-why-careers": "Empleos anteriores a esta empresa; suman a la experiencia total.",
+  "text.employee-profile-why-projects": "Lo primero que se lee en un perfil adjunto a una oferta: el rol y lo que se hizo.",
+  "label.employee-profile-ongoing": "en curso",
+  "text.employee-profile-new-entry": "Nueva entrada",
+  "text.employee-profile-doc-expertise": "Competencias clave",
+  "text.employee-profile-doc-projects-done": "Proyectos realizados",
+  "text.employee-profile-doc-certificates-held": "Certificaciones",
+  "text.employee-profile-doc-project-count": "{n}",
+  "text.employee-profile-doc-certificate-count": "{n}",
+  "text.employee-profile-doc-people": "{n} personas",
+  "text.employee-profile-doc-average-career": "Experiencia media",
+  "label.employee-profile-document-language": "idioma del documento",
+  "button.employee-profile-preview": "vista previa",
+  "title.employee-profile-preview": "vista previa del perfil",
+  "label.organization-entry-employee-profile": "mi perfil",
+  "label.organization-entry-profile-section": "parte",
+  "label.organization-entry-profile-text": "texto",
+  "label.organization-entry-profile-name": "nombre",
+  "text.organization-entry-profile-section-summary": "resumen",
+  "text.organization-entry-profile-section-skill": "habilidad",
+  "text.organization-entry-profile-section-education": "formación",
+  "text.organization-entry-profile-section-certificate": "certificación",
+  "text.organization-entry-profile-section-career": "experiencia",
+  "text.organization-entry-profile-section-project": "proyecto",
+  "text.organization-entry-profile-one-summary": "Un perfil tiene un solo resumen"
 }