@openmrs/esm-report-builder 0.1.1-pre.87

package/src/components/legacy-reports/tabs/legacy-report-parameters-tab.component.tsx

@@ -0,0 +1,279 @@
+import React from 'react';
+import {
+  Button,
+  Tile,
+  Table,
+  TableHead,
+  TableRow,
+  TableHeader,
+  TableBody,
+  TableCell,
+  TableContainer,
+  TextInput,
+  Select,
+  SelectItem,
+  FormGroup,
+  Stack,
+  Modal,
+  ModalBody,
+  ModalFooter,
+  InlineNotification,
+} from '@carbon/react';
+import { Add, TrashCan, Edit } from '@carbon/icons-react';
+import type { LegacyReportConfig } from '../legacy-report-editor-page.component';
+
+type Parameter = {
+  name: string;
+  label: string;
+  type: string;
+};
+
+type Props = {
+  report: LegacyReportConfig;
+  onChange: (report: LegacyReportConfig) => void;
+};
+
+const parameterTypes = [
+  { value: 'DATE', label: 'Date' },
+  { value: 'LOCATION', label: 'Location' },
+  { value: 'STRING', label: 'Text String' },
+  { value: 'NUMBER', label: 'Number' },
+  { value: 'BOOLEAN', label: 'Yes/No' },
+];
+
+const LegacyReportParametersTab: React.FC<Props> = ({ report, onChange }) => {
+  const [editingIndex, setEditingIndex] = React.useState<number | null>(null);
+  const [showModal, setShowModal] = React.useState(false);
+  const [currentParam, setCurrentParam] = React.useState<Parameter>({ name: '', label: '', type: 'STRING' });
+  const [error, setError] = React.useState<string | null>(null);
+
+  const parameters = report.parameters || [];
+
+  const handleAdd = () => {
+    setCurrentParam({ name: '', label: '', type: 'STRING' });
+    setEditingIndex(null);
+    setShowModal(true);
+    setError(null);
+  };
+
+  const handleEdit = (index: number) => {
+    setCurrentParam({ ...parameters[index] });
+    setEditingIndex(index);
+    setShowModal(true);
+    setError(null);
+  };
+
+  const handleDelete = (index: number) => {
+    if (confirm('Are you sure you want to delete this parameter?')) {
+      const updatedParams = parameters.filter((_, i) => i !== index);
+      onChange({
+        ...report,
+        parameters: updatedParams,
+      });
+    }
+  };
+
+  const handleSave = () => {
+    if (!currentParam.name.trim()) {
+      setError('Parameter name is required');
+      return;
+    }
+    if (!currentParam.label.trim()) {
+      setError('Parameter label is required');
+      return;
+    }
+
+    // Check for duplicate parameter names
+    const isDuplicate = parameters.some((param, index) =>
+      param.name === currentParam.name && index !== editingIndex
+    );
+
+    if (isDuplicate) {
+      setError('A parameter with this name already exists');
+      return;
+    }
+
+    let updatedParams;
+    if (editingIndex !== null) {
+      updatedParams = parameters.map((param, index) =>
+        index === editingIndex ? currentParam : param
+      );
+    } else {
+      updatedParams = [...parameters, currentParam];
+    }
+
+    onChange({
+      ...report,
+      parameters: updatedParams,
+    });
+
+    setShowModal(false);
+    setCurrentParam({ name: '', label: '', type: 'STRING' });
+    setEditingIndex(null);
+    setError(null);
+  };
+
+  return (
+    <Stack gap={6}>
+      <Tile>
+        <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>
+          <div>
+            <h4 style={{ marginTop: 0 }}>Report Parameters</h4>
+            <p style={{ opacity: 0.7, margin: 0 }}>
+              Define input parameters that users will provide when running this report
+            </p>
+          </div>
+          <Button size="sm" kind="primary" renderIcon={Add} onClick={handleAdd}>
+            Add Parameter
+          </Button>
+        </div>
+      </Tile>
+
+      {parameters.length === 0 ? (
+        <Tile style={{ textAlign: 'center', padding: '3rem' }}>
+          <p style={{ opacity: 0.7 }}>No parameters defined yet. Click "Add Parameter" to create one.</p>
+        </Tile>
+      ) : (
+        <TableContainer>
+          <Table>
+            <TableHead>
+              <TableRow>
+                <TableHeader>Parameter Name</TableHeader>
+                <TableHeader>Display Label</TableHeader>
+                <TableHeader>Data Type</TableHeader>
+                <TableHeader>Usage in Queries</TableHeader>
+                <TableHeader>Actions</TableHeader>
+              </TableRow>
+            </TableHead>
+            <TableBody>
+              {parameters.map((param, index) => (
+                <TableRow key={index}>
+                  <TableCell>
+                    <code>{param.name}</code>
+                  </TableCell>
+                  <TableCell>{param.label}</TableCell>
+                  <TableCell>
+                    <span style={{
+                      padding: '2px 8px',
+                      borderRadius: '4px',
+                      background: 'var(--cds-tag-blue)',
+                      fontSize: '0.85em',
+                      fontWeight: 500
+                    }}>
+                      {param.type}
+                    </span>
+                  </TableCell>
+                  <TableCell>
+                    <code style={{ fontSize: '0.85em', opacity: 0.7 }}>
+                      :{param.name}
+                    </code>
+                  </TableCell>
+                  <TableCell>
+                    <div style={{ display: 'flex', gap: '0.5rem' }}>
+                      <Button
+                        size="sm"
+                        kind="ghost"
+                        renderIcon={Edit}
+                        hasIconOnly
+                        iconDescription="Edit"
+                        onClick={() => handleEdit(index)}
+                      />
+                      <Button
+                        size="sm"
+                        kind="ghost"
+                        renderIcon={TrashCan}
+                        hasIconOnly
+                        iconDescription="Delete"
+                        onClick={() => handleDelete(index)}
+                      />
+                    </div>
+                  </TableCell>
+                </TableRow>
+              ))}
+            </TableBody>
+          </Table>
+        </TableContainer>
+      )}
+
+      <Tile style={{ background: 'var(--cds-background-information)' }}>
+        <h5 style={{ marginTop: 0 }}>Parameter Usage in Reports</h5>
+        <p style={{ opacity: 0.85, margin: 0 }}>
+          Parameters defined here can be used in SQL queries using the <code>:parameterName</code> syntax.
+          For example, a parameter named <code>startDate</code> can be referenced in SQL as <code>:startDate</code>.
+        </p>
+        <ul style={{ marginTop: '0.5rem', marginBottom: 0, paddingLeft: '1.5rem', opacity: 0.85 }}>
+          <li><strong>DATE parameters:</strong> Use <code>:startDate</code> and <code>:endDate</code> for date ranges</li>
+          <li><strong>LOCATION parameters:</strong> Use <code>:location</code> to filter by facility/location</li>
+          <li><strong>STRING/NUMBER parameters:</strong> Use for any additional filters or configuration values</li>
+        </ul>
+      </Tile>
+
+      {/* Add/Edit Modal */}
+      <Modal
+        open={showModal}
+        onRequestClose={() => setShowModal(false)}
+        modalHeading={editingIndex !== null ? 'Edit Parameter' : 'Add Parameter'}
+        size="sm"
+      >
+        <ModalBody>
+          {error && (
+            <InlineNotification
+              kind="error"
+              title="Error"
+              subtitle={error}
+              style={{ marginBottom: '1rem' }}
+              onCloseButtonClick={() => setError(null)}
+            />
+          )}
+
+          <FormGroup legendText="">
+            <TextInput
+              id="param-name"
+              labelText="Parameter Name"
+              placeholder="e.g., startDate"
+              value={currentParam.name}
+              onChange={(e) => setCurrentParam({ ...currentParam, name: e.target.value })}
+              style={{ marginBottom: '1rem' }}
+              disabled={editingIndex !== null} // Don't allow changing name once set
+            />
+          </FormGroup>
+
+          <FormGroup legendText="">
+            <TextInput
+              id="param-label"
+              labelText="Display Label"
+              placeholder="e.g., Start Date"
+              value={currentParam.label}
+              onChange={(e) => setCurrentParam({ ...currentParam, label: e.target.value })}
+              style={{ marginBottom: '1rem' }}
+            />
+          </FormGroup>
+
+          <FormGroup legendText="">
+            <Select
+              id="param-type"
+              labelText="Data Type"
+              value={currentParam.type}
+              onChange={(e) => setCurrentParam({ ...currentParam, type: e.target.value })}
+            >
+              {parameterTypes.map((type) => (
+                <SelectItem key={type.value} value={type.value} text={type.label} />
+              ))}
+            </Select>
+          </FormGroup>
+        </ModalBody>
+
+        <ModalFooter>
+          <Button kind="secondary" onClick={() => setShowModal(false)}>
+            Cancel
+          </Button>
+          <Button kind="primary" onClick={handleSave}>
+            {editingIndex !== null ? 'Update' : 'Add'} Parameter
+          </Button>
+        </ModalFooter>
+      </Modal>
+    </Stack>
+  );
+};
+
+export default LegacyReportParametersTab;

package/src/components/linelist/definition/indicator-to-sql.utils.ts

@@ -0,0 +1,281 @@
+/**
+ * Convert Indicator Population Config to Linelist Cohort SQL
+ *
+ * This utility converts indicator-based population configurations
+ * into SQL suitable for linelist cohort definitions.
+ */
+
+import type { IndicatorPopulationConfig, PopulationConfiguration } from './linelist-definition.types';
+import type { DataThemeConfig } from '../../indicators/types/data-theme-config.types';
+import { applyConditionClauses } from '../../indicators/utils/indicator-sql.utils';
+
+/**
+ * Convert a single indicator rule to SQL WHERE clause
+ * Returns the SQL for finding patients matching the indicator conditions
+ */
+function convertIndicatorRuleToWhere(
+  rule: IndicatorPopulationConfig,
+  themeConfig: DataThemeConfig
+): string {
+  // Start with base SQL for the indicator
+  const baseSql = buildSqlBaseQuery(themeConfig);
+
+  // Apply indicator conditions
+  const sqlWithConditions = applyConditionClauses(
+    baseSql,
+    themeConfig.conditions || [],
+    rule.conditions
+  );
+
+  // Extract just the WHERE clause for combining
+  const whereStart = sqlWithConditions.indexOf('WHERE');
+  if (whereStart === -1) {
+    return '1=1'; // No conditions
+  }
+
+  let whereClause = sqlWithConditions.substring(whereStart + 5).trim();
+
+  // Remove trailing semicolon and other clauses
+  const semicolonIdx = whereClause.indexOf(';');
+  if (semicolonIdx !== -1) {
+    whereClause = whereClause.substring(0, semicolonIdx).trim();
+  }
+
+  // Remove ORDER BY, GROUP BY, LIMIT if present (they come after WHERE)
+  const orderByIdx = whereClause.indexOf('ORDER BY');
+  if (orderByIdx !== -1) {
+    whereClause = whereClause.substring(0, orderByIdx).trim();
+  }
+
+  const groupByIdx = whereClause.indexOf('GROUP BY');
+  if (groupByIdx !== -1) {
+    whereClause = whereClause.substring(0, groupByIdx).trim();
+  }
+
+  return whereClause;
+}
+
+/**
+ * Build base SQL query for linelist from theme config
+ * This selects distinct patient_ids
+ */
+function buildSqlBaseQuery(themeConfig: DataThemeConfig): string {
+  const { sourceTable, patientIdColumn, dateColumn, joins } = themeConfig;
+
+  const lines: string[] = [];
+
+  lines.push('SELECT');
+  lines.push(`  DISTINCT ${sourceTable}.${patientIdColumn}`);
+
+  // Add joins if defined
+  // const joinTables = joins?.map((j) => {
+  //   const match = j.joinSql.match(/JOIN\s+(\S+)/i);
+  //   return match ? match[1] : j.alias;
+  // });
+
+  lines.push(`FROM ${sourceTable}`);
+
+  // Add joins
+  if (joins && joins.length > 0) {
+    joins.forEach((join) => {
+      lines.push(join.joinSql);
+    });
+  }
+
+  lines.push('WHERE');
+
+  // Date filtering
+  if (dateColumn) {
+    lines.push(`  ${sourceTable}.${dateColumn} >= :startDate`);
+    lines.push(`  AND ${sourceTable}.${dateColumn} < :endDate`);
+  } else {
+    lines.push(`  1=1`); // Placeholder for date filtering
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Convert a single indicator rule to full linelist cohort SQL
+ */
+export function convertIndicatorRule(rule: IndicatorPopulationConfig, themeConfig: DataThemeConfig): string {
+  const baseSql = buildSqlBaseQuery(themeConfig);
+  const whereClause = convertIndicatorRuleToWhere(rule, themeConfig);
+
+  // Replace the WHERE clause in base SQL with our conditions
+  const whereIdx = baseSql.indexOf('WHERE');
+  if (whereIdx === -1) {
+    return baseSql + '\nAND ' + whereClause;
+  }
+
+  const beforeWhere = baseSql.substring(0, whereIdx + 5); // Include "WHERE"
+  const afterWhereStart = baseSql.indexOf('\n', whereIdx);
+  const afterWhere = afterWhereStart !== -1
+    ? baseSql.substring(afterWhereStart)
+    : '';
+
+  // Build final SQL
+  let finalSql = beforeWhere + '\n';
+
+  // Add custom SQL if present
+  if (rule.customSql) {
+    finalSql += '  ' + rule.customSql + '\n';
+  }
+
+  // Add conditions
+  const conditionLines = whereClause.split('\n').map((line) => {
+    const trimmed = line.trim();
+    // Skip empty lines and fix indentation
+    if (!trimmed) return '';
+    if (trimmed.startsWith('AND')) return '  ' + trimmed;
+    return '  AND ' + trimmed;
+  }).filter(Boolean);
+
+  finalSql += conditionLines.join('\n') + '\n';
+
+  // Add back any trailing clauses
+  if (afterWhere.trim()) {
+    finalSql += afterWhere.trim() + '\n';
+  }
+
+  // Handle negation (NOT)
+  if (rule.negate) {
+    // Wrap in NOT EXISTS subquery
+    finalSql = `SELECT ${themeConfig.patientIdColumn}\nFROM (\n${finalSql}) AS matches\nWHERE 1=0`;
+  }
+
+  return finalSql;
+}
+
+/**
+ * Combine multiple indicator rules into a single SQL query
+ * Rules are combined using their logicalOperator (AND/OR)
+ */
+export function combineIndicatorRules(
+  rules: IndicatorPopulationConfig[],
+  themeConfig: DataThemeConfig
+): string {
+  if (!rules || rules.length === 0) {
+    return buildSqlBaseQuery(themeConfig);
+  }
+
+  if (rules.length === 1) {
+    return convertIndicatorRule(rules[0], themeConfig);
+  }
+
+  // Build subqueries for each rule
+  const subqueries: string[] = [];
+  const negateQueries: string[] = [];
+
+  for (const rule of rules) {
+    const sql = convertIndicatorRule(rule, themeConfig);
+
+    if (rule.negate) {
+      negateQueries.push(sql);
+    } else {
+      subqueries.push(sql);
+    }
+  }
+
+  // Build the combined query
+  const lines: string[] = [];
+  const { sourceTable, patientIdColumn } = themeConfig;
+
+  lines.push(`SELECT DISTINCT base.${patientIdColumn}`);
+  lines.push(`FROM ${sourceTable} base`);
+
+  // Positive matches with UNION/INTERSECT
+  if (subqueries.length > 0) {
+    if (rules[0]?.logicalOperator === 'OR') {
+      // OR means UNION
+      lines.push(`WHERE base.${patientIdColumn} IN (`);
+      lines.push(subqueries.map((q) => `  (${q})`).join('\n  UNION\n'));
+      lines.push(')');
+    } else {
+      // AND means INTERSECT (all conditions must match)
+      // For simplicity, use nested EXISTS
+      subqueries.forEach((q, idx) => {
+        const alias = `match${idx}`;
+        lines.push(`  AND EXISTS (${q.replace(/SELECT/g, `SELECT 1 FROM ${sourceTable} ${alias} WHERE ${alias}.${patientIdColumn} = base.${patientIdColumn} AND`)})`);
+      });
+    }
+  }
+
+  // Negative matches (NOT EXISTS)
+  negateQueries.forEach((q) => {
+    lines.push(`  AND NOT EXISTS (${q})`);
+  });
+
+  // Add date filter if defined
+  if (themeConfig.dateColumn) {
+    lines.push(`  AND base.${themeConfig.dateColumn} >= :startDate`);
+    lines.push(`  AND base.${themeConfig.dateColumn} < :endDate`);
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Convert full population configuration to linelist cohort SQL
+ */
+export function convertPopulationConfig(config: PopulationConfiguration, themeConfig: DataThemeConfig): string {
+  switch (config.mode) {
+    case 'SQL':
+      return config.sql || buildSqlBaseQuery(themeConfig);
+
+    case 'INDICATOR':
+      if (!config.indicatorRules || config.indicatorRules.length === 0) {
+        return buildSqlBaseQuery(themeConfig);
+      }
+      return combineIndicatorRules(config.indicatorRules, themeConfig);
+
+    case 'HYBRID': {
+      // Start with indicator rules and append custom SQL
+      let sql = buildSqlBaseQuery(themeConfig);
+      if (config.indicatorRules && config.indicatorRules.length > 0) {
+        sql = combineIndicatorRules(config.indicatorRules, themeConfig);
+      }
+      if (config.sql) {
+        // Append custom SQL with AND
+        const whereIdx = sql.indexOf('WHERE');
+        if (whereIdx !== -1) {
+          const beforeSemicolon = sql.indexOf(';');
+          const insertAt = beforeSemicolon !== -1 ? beforeSemicolon : sql.length;
+          sql = sql.substring(0, insertAt) + `  AND (${config.sql})\n` + sql.substring(insertAt);
+        }
+      }
+      return sql;
+    }
+
+    default:
+      return buildSqlBaseQuery(themeConfig);
+  }
+}
+
+/**
+ * Validate indicator population configuration
+ */
+export function validateIndicatorConfig(config: PopulationConfiguration): string[] {
+  const errors: string[] = [];
+
+  if (config.mode === 'INDICATOR' || config.mode === 'HYBRID') {
+    if (!config.indicatorRules || config.indicatorRules.length === 0) {
+      errors.push('At least one indicator rule is required');
+    }
+
+    config.indicatorRules?.forEach((rule, idx) => {
+      if (!rule.indicatorUuid) {
+        errors.push(`Indicator rule ${idx + 1} is missing indicator UUID`);
+      }
+      if (!rule.name) {
+        errors.push(`Indicator rule ${idx + 1} is missing a name`);
+      }
+    });
+  }
+
+  if (config.mode === 'SQL' && !config.sql) {
+    errors.push('SQL is required when in SQL mode');
+  }
+
+  return errors;
+}