logwork-cli 1.1.1 → 1.3.0

package/lib/ro-api-projects.mjs

@@ -0,0 +1,137 @@
+// Project memberships and per-project day logs from the legacy member-logtime API.
+import { CONFIG } from './config.mjs';
+import { mapLimit, toApiLogDate } from './util.mjs';
+import { ApiError, apiFetch } from './ro-api-http.mjs';
+import {
+  addDroppedRow,
+  attachNormalizationDiagnostics,
+  createNormalizationDiagnostics,
+  diagnosticProjectFields,
+  getNormalizationDiagnostics
+} from './ro-api-diagnostics.mjs';
+import {
+  hasProjectName,
+  normalizeDateOnly,
+  projectFallbackName,
+  readExplicitProjectMemberId,
+  readNumber,
+  readProjectId,
+  readProjectName,
+  unwrapRecords
+} from './ro-api-fields.mjs';
+
+export async function getProjects(token, userId) {
+  const qs = new URLSearchParams({
+    f_user_id: String(userId),
+    'f_project.stage_id': '!6'
+  });
+
+  const data = await apiFetch(token, `${CONFIG.projectMembersPath}?${qs}`);
+  return unwrapRecords(data).map(normalizeProject).filter((project) => project.projectMemberId);
+}
+
+export async function getDayLogs(token, projectId, userId, localDateISO) {
+  const qs = new URLSearchParams({
+    f_project_id: String(projectId),
+    f_user_id: String(userId),
+    f_logdate: toApiLogDate(localDateISO)
+  });
+
+  try {
+    const data = await apiFetch(token, `${CONFIG.memberLogtimePath}?${qs}`);
+    const logs = unwrapRecords(data);
+    const entries = normalizeLogtimeEntries(logs, {
+      date: localDateISO,
+      projectId
+    });
+    const normalization = getNormalizationDiagnostics(entries);
+
+    return {
+      projectId,
+      totalHours: entries.reduce((sum, log) => sum + Number(log.hours || 0), 0),
+      entries,
+      logs,
+      normalization,
+      ok: true
+    };
+  } catch (error) {
+    if (error instanceof ApiError && error.status === 401) {
+      throw error;
+    }
+
+    return {
+      projectId,
+      totalHours: null,
+      logs: [],
+      ok: false,
+      error: error.message
+    };
+  }
+}
+
+export function normalizeLogtimeEntries(logs, defaults = {}) {
+  const rows = unwrapRecords(logs);
+  const diagnostics = createNormalizationDiagnostics('logtime_entries');
+  diagnostics.rowsRead = rows.length;
+  const entries = [];
+
+  rows.forEach((log, index) => {
+    if (!log || typeof log !== 'object') {
+      addDroppedRow(diagnostics, 'invalid_log_entry', { index });
+      return;
+    }
+
+    const context = { index, kind: 'logtime_entry' };
+    const date = normalizeDateOnly(log.logdate ?? log.log_date ?? log.date) || defaults.date;
+    const projectMemberId = readExplicitProjectMemberId(log) ?? defaults.projectMemberId;
+    const projectId = readProjectId(log) ?? defaults.projectId;
+    const hours = readNumber(log, ['logtimes', 'hours', 'time'], diagnostics, context);
+
+    if (!date) {
+      addDroppedRow(diagnostics, 'missing_date', { ...context, ...diagnosticProjectFields({ projectMemberId, projectId }) });
+      return;
+    }
+
+    if (projectMemberId === undefined && projectId === undefined) {
+      addDroppedRow(diagnostics, 'missing_project_identity', { ...context, date });
+      return;
+    }
+
+    if (hours <= 0) {
+      addDroppedRow(diagnostics, 'non_positive_hours', { ...context, date, ...diagnosticProjectFields({ projectMemberId, projectId }) });
+      return;
+    }
+
+    diagnostics.rowsAccepted += 1;
+    entries.push({
+      id: log.id ?? log.logtime_id ?? log.logtimeId,
+      date,
+      projectMemberId,
+      projectId,
+      projectName: hasProjectName(log) ? readProjectName(log, readProjectId(log), diagnostics, context) : defaults.projectName,
+      hours,
+      taskName: log.task_name ?? log.taskName ?? log.name ?? log.title ?? ''
+    });
+  });
+
+  return attachNormalizationDiagnostics(entries, diagnostics);
+}
+
+export async function getAllDayLogSummaries(token, projects, userId, localDateISO) {
+  return mapLimit(projects, CONFIG.dayLogConcurrency, (project) => (
+    getDayLogs(token, project.projectId, userId, localDateISO)
+  ));
+}
+
+function normalizeProject(rec) {
+  const projectId = rec.project_id ?? rec.project?.id ?? rec.project?.project_id;
+  const projectMemberId = rec.id ?? rec.project_member_id;
+
+  return {
+    projectMemberId,
+    projectId,
+    projectName: rec.project?.name ?? rec.project_name ?? rec.name ?? projectFallbackName(projectId ?? projectMemberId),
+    workloadPercent: rec.workload ?? rec.workload_percent ?? rec.assigned_percent ?? 0,
+    raw: rec
+  };
+}

package/lib/ro-api-tasks.mjs

@@ -0,0 +1,50 @@
+// Worklog task catalog: project tasks plus shared default tasks.
+import { CONFIG } from './config.mjs';
+import { apiFetch } from './ro-api-http.mjs';
+import { unwrapRecords } from './ro-api-fields.mjs';
+import {
+  mergeWorklogTaskLists,
+  normalizeWorklogTask
+} from './worklog-task-resolver.mjs';
+
+export async function getWorklogTasks(token, { projectId, search } = {}, options = {}) {
+  const path = `${CONFIG.logworkTasksPath}${buildLogworkTasksQuery({ projectId, search })}`;
+  const data = await apiFetch(token, path, options);
+  return unwrapRecords(data).map(normalizeWorklogTask);
+}
+
+export async function getDefaultWorklogTasks(token, { projectId, search } = {}, options = {}) {
+  const path = `${CONFIG.logworkDefaultTasksPath}${buildLogworkTasksQuery({ projectId, search })}`;
+  const data = await apiFetch(token, path, options);
+  return unwrapRecords(data).map(normalizeWorklogTask);
+}
+
+export async function fetchWorklogTasksForProject(token, projectId, options = {}) {
+  const cacheKey = Number(projectId);
+  const { cache, ...apiOptions } = options;
+  if (cache instanceof Map && cache.has(cacheKey)) {
+    return cache.get(cacheKey);
+  }
+
+  const [projectTasks, defaultTasks] = await Promise.all([
+    getWorklogTasks(token, { projectId: cacheKey }, apiOptions),
+    getDefaultWorklogTasks(token, { projectId: cacheKey }, apiOptions)
+  ]);
+  const merged = mergeWorklogTaskLists(projectTasks, defaultTasks);
+  if (cache instanceof Map) {
+    cache.set(cacheKey, merged);
+  }
+  return merged;
+}
+
+function buildLogworkTasksQuery({ projectId, search }) {
+  const qs = new URLSearchParams();
+  if (projectId !== undefined && projectId !== null && projectId !== '') {
+    qs.set('project_id', String(projectId));
+  }
+  if (search) {
+    qs.set('search', String(search));
+  }
+  const query = qs.toString();
+  return query ? `?${query}` : '';
+}

package/lib/ro-api-timesheet.mjs

@@ -0,0 +1,413 @@
+// Timesheet range reads: booked and logged hours per day and project.
+import { CONFIG } from './config.mjs';
+import { addLocalDays, toApiLogDate } from './util.mjs';
+import { apiFetch } from './ro-api-http.mjs';
+import {
+  addDroppedRow,
+  addWarning,
+  attachNormalizationDiagnostics,
+  createNormalizationDiagnostics,
+  diagnosticProjectFields,
+  getNormalizationDiagnostics
+} from './ro-api-diagnostics.mjs';
+import {
+  coerceHours,
+  hasProjectName,
+  isDateInRange,
+  normalizeDateOnly,
+  pickFirst,
+  readAssignedHours,
+  readDateLike,
+  readLoggedHours,
+  readNumber,
+  readProjectId,
+  readProjectMemberId,
+  readProjectName
+} from './ro-api-fields.mjs';
+
+export async function getTimesheetRange(token, userId, { from, to }) {
+  const { records } = await getTimesheetRangeResult(token, userId, { from, to });
+  return records;
+}
+
+export async function getTimesheetRangeResult(token, userId, { from, to }) {
+  const qs = new URLSearchParams({
+    f_user_id: String(userId),
+    f_from: toApiLogDate(from),
+    f_to: toApiLogDate(to),
+    f_timesheet_by_week: '0',
+    f_time_off: '1'
+  });
+
+  const data = await apiFetch(token, `${CONFIG.timesheetPath}?${qs}`);
+  return normalizeTimesheetRangeResult(data, { from, to });
+}
+
+export function normalizeTimesheetRange(data, { from, to } = {}) {
+  return normalizeTimesheetRangeResult(data, { from, to }).records;
+}
+
+export function normalizeTimesheetRangeResult(data, { from, to } = {}) {
+  const diagnostics = createNormalizationDiagnostics('unknown');
+  const explicitRows = expandProjectTimesheetRows(data, { from, to }, diagnostics);
+  const rows = explicitRows.length ? explicitRows : findTimesheetRowsInRange(data, { from, to });
+  diagnostics.sourceShape = explicitRows.length ? 'project_timesheet' : 'range_scan';
+  if (!rows.length && hasObjectPayload(data)) {
+    addWarning(diagnostics, 'unknown_timesheet_shape');
+  }
+  const records = normalizeTimesheetRecords(rows, diagnostics);
+  return {
+    records,
+    normalization: getNormalizationDiagnostics(records)
+  };
+}
+
+export async function getBookedProjectsForDate(token, userId, localDateISO) {
+  const { records } = await getTimesheetRangeResult(token, userId, {
+    from: localDateISO,
+    to: addLocalDays(localDateISO, 1)
+  });
+  return normalizeTimesheetProjects(records, localDateISO);
+}
+
+export async function getTodayTimesheetProjects(token, userId, localDateISO) {
+  return getBookedProjectsForDate(token, userId, localDateISO);
+}
+
+function normalizeTimesheetProjects(rows, localDateISO) {
+  const byMember = new Map();
+
+  for (const row of rows) {
+    const projectMemberId = readProjectMemberId(row);
+    const projectId = readProjectId(row);
+
+    if (!projectMemberId && !projectId) {
+      continue;
+    }
+
+    const key = String(projectMemberId ?? projectId);
+    const projectName = readProjectName(row, projectId ?? projectMemberId);
+    const assignedHours = Number(row.bookedHours ?? readAssignedHours(row));
+    const loggedHours = Number(row.loggedHours ?? readLoggedHours(row));
+    const existing = byMember.get(key);
+
+    if (existing) {
+      existing.assignedHours += assignedHours;
+      existing.loggedHours += loggedHours;
+      existing.workloadPercent = hoursToAssignPercent(existing.assignedHours);
+      existing.raw.push(row);
+      continue;
+    }
+
+    byMember.set(key, {
+      projectMemberId: projectMemberId ?? row.project_member_id ?? row.id,
+      projectId,
+      projectName,
+      assignedHours,
+      loggedHours,
+      workloadPercent: hoursToAssignPercent(assignedHours),
+      localDateISO,
+      raw: [row]
+    });
+  }
+
+  return [...byMember.values()].filter((project) => project.assignedHours > 0);
+}
+
+function normalizeTimesheetRecords(rows, diagnostics = createNormalizationDiagnostics('range_scan')) {
+  const byDayProject = new Map();
+  diagnostics.rowsRead = rows.length;
+
+  rows.forEach((row, index) => {
+    const date = readDateLike(row);
+    const projectMemberId = readProjectMemberId(row);
+    const projectId = readProjectId(row);
+    const context = {
+      index,
+      kind: 'timesheet_row',
+      ...diagnosticProjectFields({ projectMemberId, projectId, projectName: hasProjectName(row) ? readProjectName(row, projectId ?? projectMemberId) : undefined })
+    };
+
+    if (!date) {
+      addDroppedRow(diagnostics, 'missing_date', context);
+      return;
+    }
+
+    if (projectMemberId === undefined && projectId === undefined) {
+      addDroppedRow(diagnostics, 'missing_project_identity', { ...context, date });
+      return;
+    }
+
+    const key = `${date}:${projectMemberId ?? projectId}`;
+    const existing = byDayProject.get(key);
+    const bookedHours = readTimesheetHours(row, ['bookedHours'], readAssignedHours, diagnostics, { ...context, date, metric: 'bookedHours' });
+    const loggedHours = readTimesheetHours(row, ['loggedHours'], readLoggedHours, diagnostics, { ...context, date, metric: 'loggedHours' });
+    const entries = readLogEntries(row, diagnostics, { ...context, date });
+    diagnostics.rowsAccepted += 1;
+
+    if (existing) {
+      existing.bookedHours += bookedHours;
+      existing.loggedHours += loggedHours;
+      existing.entries.push(...entries);
+      existing.raw.push(row);
+      return;
+    }
+
+    byDayProject.set(key, {
+      date,
+      projectMemberId,
+      projectId,
+      projectName: readProjectName(row, projectId ?? projectMemberId, diagnostics, { ...context, date }),
+      bookedHours,
+      loggedHours,
+      entries,
+      raw: [row]
+    });
+  });
+
+  return attachNormalizationDiagnostics([...byDayProject.values()].map((record) => ({
+    ...record,
+    bookedHours: Number(record.bookedHours.toFixed(2)),
+    loggedHours: Number(record.loggedHours.toFixed(2))
+  })), diagnostics);
+}
+
+function expandProjectTimesheetRows(data, range, diagnostics = null) {
+  const assignments = [];
+  collectProjectAssignments(data, assignments, new Set());
+  const rows = [];
+
+  assignments.forEach((assignment, assignmentIndex) => {
+    assignment.timesheet.forEach((day, dayIndex) => {
+      const date = normalizeDateOnly(day.logdate ?? day.log_date ?? day.date);
+      if (!isDateInRange(date, range)) {
+        return;
+      }
+
+      const context = {
+        index: rows.length,
+        assignmentIndex,
+        dayIndex,
+        kind: 'project_timesheet_row',
+        date,
+        ...diagnosticProjectFields({
+          projectMemberId: assignment.id,
+          projectId: assignment.project?.id,
+          projectName: assignment.project?.name
+        })
+      };
+
+      rows.push({
+        date,
+        projectMemberId: assignment.id,
+        project_member_id: assignment.id,
+        projectId: assignment.project?.id,
+        project_id: assignment.project?.id,
+        projectName: assignment.project?.name,
+        project_name: assignment.project?.name,
+        bookedHours: readAssignedHours(day, diagnostics, { ...context, metric: 'bookedHours' }),
+        loggedHours: readNumber(day, ['logtimes'], diagnostics, { ...context, metric: 'loggedHours' }),
+        overtime: readNumber(day, ['overtime'], diagnostics, { ...context, metric: 'overtime' }),
+        source: 'timesheet'
+      });
+    });
+  });
+
+  return rows;
+}
+
+function collectProjectAssignments(value, assignments, seen) {
+  if (!value || typeof value !== 'object') {
+    return;
+  }
+
+  if (seen.has(value)) {
+    return;
+  }
+  seen.add(value);
+
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      collectProjectAssignments(item, assignments, seen);
+    }
+    return;
+  }
+
+  if (
+    value.project &&
+    typeof value.project === 'object' &&
+    Array.isArray(value.timesheet)
+  ) {
+    assignments.push(value);
+    return;
+  }
+
+  for (const [key, child] of Object.entries(value)) {
+    if (key === 'overall') {
+      continue;
+    }
+    collectProjectAssignments(child, assignments, seen);
+  }
+}
+
+function findTimesheetRowsInRange(data, { from, to } = {}) {
+  const rows = [];
+  collectTimesheetRowsInRange(data, { from, to }, rows, new Set());
+  return rows;
+}
+
+function collectTimesheetRowsInRange(value, range, rows, seen) {
+  if (!value || typeof value !== 'object') {
+    return;
+  }
+
+  if (seen.has(value)) {
+    return;
+  }
+  seen.add(value);
+
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      collectTimesheetRowsInRange(item, range, rows, seen);
+    }
+    return;
+  }
+
+  const directDate = readDateLike(value);
+  if (isDateInRange(directDate, range) && looksLikeTimesheetRow(value)) {
+    rows.push(value);
+  } else if (!directDate && looksLikeTimesheetRow(value)) {
+    rows.push(value);
+  }
+
+  for (const [key, child] of Object.entries(value)) {
+    if (Array.isArray(child)) {
+      const keyDate = normalizeDateOnly(key);
+      if (isDateInRange(keyDate, range)) {
+        for (const item of child) {
+          if (item && typeof item === 'object') {
+            rows.push({ ...item, date: readDateLike(item) || keyDate });
+          }
+        }
+        continue;
+      }
+
+      for (const item of child) {
+        if (item && typeof item === 'object') {
+          const itemDate = readDateLike(item);
+          if (isDateInRange(itemDate, range) && looksLikeTimesheetRow(item)) {
+            rows.push(item);
+            continue;
+          }
+        }
+
+        collectTimesheetRowsInRange(item, range, rows, seen);
+      }
+      continue;
+    }
+
+    if (child && typeof child === 'object') {
+      const keyDate = normalizeDateOnly(key);
+      if (isDateInRange(keyDate, range)) {
+        rows.push({ ...child, date: readDateLike(child) || keyDate });
+        continue;
+      }
+
+      collectTimesheetRowsInRange(child, range, rows, seen);
+    }
+  }
+}
+
+function looksLikeTimesheetRow(row) {
+  return readAssignedHours(row) > 0 || readLoggedHours(row) > 0 || Boolean(pickFirst(row, [
+    'project_member_id',
+    'projectMemberId',
+    'project_id',
+    'projectId'
+  ]));
+}
+
+function readLogEntries(row, diagnostics = null, context = {}) {
+  const rawEntries = pickFirst(row, [
+    'logs',
+    'logtimes_data',
+    'logtimesData',
+    'log_times',
+    'logTimes',
+    'items',
+    'children'
+  ]);
+
+  if (!Array.isArray(rawEntries)) {
+    return [];
+  }
+
+  const entries = [];
+  rawEntries.forEach((entry, entryIndex) => {
+    if (!entry || typeof entry !== 'object') {
+      addDroppedRow(diagnostics, 'invalid_log_entry', {
+        ...context,
+        entryIndex
+      });
+      return;
+    }
+
+    const entryContext = {
+      ...context,
+      entryIndex,
+      kind: 'embedded_log_entry'
+    };
+    const date = normalizeDateOnly(entry.logdate ?? entry.log_date ?? entry.date ?? row.logdate ?? row.date);
+    const projectMemberId = readProjectMemberId(entry) ?? readProjectMemberId(row);
+    const projectId = readProjectId(entry) ?? readProjectId(row);
+    const hours = readNumber(entry, ['logtimes', 'hours', 'time'], diagnostics, { ...entryContext, metric: 'hours' });
+
+    if (!date) {
+      addDroppedRow(diagnostics, 'missing_date', { ...entryContext, ...diagnosticProjectFields({ projectMemberId, projectId }) });
+      return;
+    }
+
+    if (projectMemberId === undefined && projectId === undefined) {
+      addDroppedRow(diagnostics, 'missing_project_identity', { ...entryContext, date });
+      return;
+    }
+
+    if (hours <= 0) {
+      addDroppedRow(diagnostics, 'non_positive_hours', { ...entryContext, date, ...diagnosticProjectFields({ projectMemberId, projectId }) });
+      return;
+    }
+
+    entries.push({
+      id: entry.id ?? entry.logtime_id ?? entry.logtimeId,
+      date,
+      projectMemberId,
+      projectId,
+      projectName: hasProjectName(entry) ? readProjectName(entry, readProjectId(entry), diagnostics, entryContext) : readProjectName(row, readProjectId(row) ?? readProjectMemberId(row), diagnostics, entryContext),
+      hours,
+      taskName: entry.task_name ?? entry.taskName ?? entry.name ?? entry.title ?? '',
+      raw: entry
+    });
+  });
+
+  return entries;
+}
+
+function readTimesheetHours(row, directPaths, fallbackReader, diagnostics, context) {
+  const directValue = pickFirst(row, directPaths);
+  if (directValue !== undefined) {
+    return coerceHours(directValue, diagnostics, {
+      ...context,
+      field: directPaths[0]
+    });
+  }
+
+  return fallbackReader(row, diagnostics, context);
+}
+
+function hoursToAssignPercent(hours) {
+  return Math.round((Number(hours || 0) / CONFIG.standardDayHours) * 100);
+}
+
+function hasObjectPayload(data) {
+  return Boolean(data && typeof data === 'object' && Object.keys(data).length > 0);
+}

package/lib/ro-delete-workflow.mjs

@@ -1,4 +1,5 @@
-import { ApiError, deleteLogworkEntry } from './api.mjs';
+import { ApiError } from './ro-api-http.mjs';
+import { deleteLogworkEntry } from './ro-api-entries.mjs';
 import { createResourceOptimiserSession } from './query-workflow.mjs';
 import { assertOwnUnlockedRoEntry, createF03LogworkReader, createRoEntryRevisionFingerprint } from './ro-entry-reader.mjs';
 

package/lib/ro-entry-reader.mjs

@@ -1,26 +1,31 @@
 import { ApiError, getLogtimeById, getLogworkDay, getProjects } from './api.mjs';
 import { createResourceOptimiserSession } from './query-workflow.mjs';
 
+const DEFAULT_READS = { getLogtimeById, getLogworkDay, getProjects };
+
 // Reads one existing RO entry with the fields edit, resubmit and delete need. The legacy
 // GET /member-logtime/:id gives the date, owner and Jira link; /logwork/day
 // gives the F03 fields (status, worklog task, type of work, description); the
-// project-member list maps project_member_id to project_id.
-export function createF03LogworkReader() {
-  const session = createResourceOptimiserSession();
+// project-member list maps project_member_id to project_id. Tests inject the
+// session and the RO reads; callers use the defaults.
+export function createF03LogworkReader({
+  session = createResourceOptimiserSession(),
+  reads = DEFAULT_READS
+} = {}) {
   let projectsPromise = null;
   return async (logworkId) => withRoSessionRetry(session, async ({ token, userId }) => {
-    const legacy = await getLogtimeById(token, logworkId);
+    const legacy = await reads.getLogtimeById(token, logworkId);
     if (!legacy.date) {
       throw new Error(`Resource Optimiser did not return a date for logwork ${logworkId}.`);
     }
-    const day = await getLogworkDay(token, { date: legacy.date });
+    const day = await reads.getLogworkDay(token, { date: legacy.date });
     const f03 = (day.entries || []).find((entry) => String(entry.id) === String(legacy.id));
     if (!f03) {
       throw new Error(`RO logwork ${logworkId} was not found on ${legacy.date}; it may have been deleted.`);
     }
     // Cache only a successful load: a cached rejection (say a 401) would make
     // the retry after a forced login fail the same way.
-    projectsPromise ||= getProjects(token, userId).catch((error) => {
+    projectsPromise ||= reads.getProjects(token, userId).catch((error) => {
       projectsPromise = null;
       throw error;
     });

package/lib/ro-resubmit-workflow.mjs

@@ -1,4 +1,5 @@
-import { ApiError, resubmitLogworkEntry } from './api.mjs';
+import { ApiError } from './ro-api-http.mjs';
+import { resubmitLogworkEntry } from './ro-api-entries.mjs';
 import { createResourceOptimiserSession } from './query-workflow.mjs';
 import { assertOwnUnlockedRoEntry, createF03LogworkReader, createRoEntryRevisionFingerprint } from './ro-entry-reader.mjs';
 

package/lib/terminal-auth-prompts.mjs

@@ -1,12 +1,15 @@
-import { isCancel, password, select, text } from '@clack/prompts';
+import * as clackPrompts from '@clack/prompts';
 import { createAuthRequiredError } from './auth-errors.mjs';
 import { createCredentialEmailStorage } from './credential-store.mjs';
 
 export function createTerminalCredentialProvider({
   emailStorage = createCredentialEmailStorage(),
   stdin = process.stdin,
-  stdout = process.stdout
+  stdout = process.stdout,
+  prompts = clackPrompts
 } = {}) {
+  const { password, select, text } = prompts;
+  const handleCancel = (value) => handleCancelWith(prompts, value);
   return {
     async requestCredentials() {
       ensureInteractive(stdin, stdout);
@@ -111,8 +114,8 @@ function ensureInteractive(stdin, stdout) {
   }
 }
 
-function handleCancel(value) {
-  if (isCancel(value)) {
+function handleCancelWith(prompts, value) {
+  if (prompts.isCancel(value)) {
     throw new Error('User cancelled Resource Optimiser authentication.');
   }