form 91/98 report, min max value update in AML rule and whihc rule apply day, week, month and some more updates

src/app/rbi-circulars/aml-rules/aml-rules.component.html

@@ -21,6 +21,22 @@
     </mat-card-header>
 
     <mat-card-content class="aml-card-content">
+      <!-- Separate the rules by the window they are measured over -->
+      <div class="period-filters">
+        <span class="period-filters-label">Applies over</span>
+        <button
+          *ngFor="let p of periodFilters"
+          type="button"
+          class="period-chip"
+          [class.active]="activePeriod === p.key"
+          [disabled]="periodCount(p.key) === 0"
+          (click)="setPeriod(p.key)"
+        >
+          {{ p.label }}
+          <span class="period-chip-n">{{ periodCount(p.key) }}</span>
+        </button>
+      </div>
+
       <table mat-table [dataSource]="rules" class="aml-table mat-elevation-z1">
         <!-- Order Position Column -->
         <ng-container matColumnDef="orderPosition">
@@ -45,10 +61,37 @@
           </td>
         </ng-container>
 
-        <!-- Income / Occupation Limit Column -->
-        <ng-container matColumnDef="incomeLimit">
-          <th mat-header-cell *matHeaderCellDef>Income / Occupation Limit</th>
-          <td mat-cell *matCellDef="let element" class="income-limit-cell">{{ getIncomeLimitLabel(element) }}</td>
+        <!-- What the min/max figures are measured against -->
+        <ng-container matColumnDef="limitBasis">
+          <th mat-header-cell *matHeaderCellDef>Limit Basis</th>
+          <td mat-cell *matCellDef="let element" class="basis-cell">
+            {{ getLimitBasis(element) }}
+            <span *ngIf="getNonNumericCriterion(element)" class="basis-sub">
+              {{ getNonNumericCriterion(element) }}
+            </span>
+          </td>
+        </ng-container>
+
+        <!-- Minimum Limit Column -->
+        <ng-container matColumnDef="minLimit">
+          <th mat-header-cell *matHeaderCellDef class="col-right">Minimum Limit</th>
+          <td mat-cell *matCellDef="let element" class="col-right amount-cell">{{ getMinLimit(element) }}</td>
+        </ng-container>
+
+        <!-- Maximum Limit Column -->
+        <ng-container matColumnDef="maxLimit">
+          <th mat-header-cell *matHeaderCellDef class="col-right">Maximum Limit</th>
+          <td mat-cell *matCellDef="let element" class="col-right amount-cell">
+            <span [class.no-ceiling]="getMaxLimit(element) === 'No upper limit'">{{ getMaxLimit(element) }}</span>
+          </td>
+        </ng-container>
+
+        <!-- Observation window the rule is measured over -->
+        <ng-container matColumnDef="appliesOver">
+          <th mat-header-cell *matHeaderCellDef class="col-center">Applies Over</th>
+          <td mat-cell *matCellDef="let element" class="col-center">
+            <span [ngClass]="periodClass(element)">{{ periodLabel(element) }}</span>
+          </td>
         </ng-container>
 
         <!-- Reason Column -->

src/app/rbi-circulars/aml-rules/aml-rules.component.scss

@@ -114,13 +114,141 @@
   max-width: 400px;
 }
 
-.income-limit-cell {
+.col-right {
+  text-align: right;
+  justify-content: flex-end;
+}
+
+/* What the min/max amounts are measured against. */
+.basis-cell {
   color: #334155;
-  font-size: 13px;
-  font-weight: 500;
+  font-size: 12px;
+  font-weight: 600;
   white-space: normal;
-  max-width: 200px;
-  line-height: 1.35;
+  max-width: 150px;
+  line-height: 1.3;
+}
+
+.basis-sub {
+  display: block;
+  font-size: 11px;
+  font-weight: 400;
+  color: #64748b;
+}
+
+.amount-cell {
+  font-family: 'DM Mono', monospace;
+  font-size: 12.5px;
+  color: #0f172a;
+  white-space: nowrap;
+}
+
+/* An open-ended threshold rule has a floor but no ceiling. */
+.no-ceiling {
+  font-family: inherit;
+  font-size: 11px;
+  font-style: italic;
+  color: #94a3b8;
+}
+
+/* ── Observation-window badges ─────────────────────────────────────────── */
+.period-badge {
+  display: inline-block;
+  padding: 3px 10px;
+  border-radius: 999px;
+  font-size: 11px;
+  font-weight: 700;
+  white-space: nowrap;
+  letter-spacing: 0.02em;
+
+  &.period-txn {
+    background: #e2e8f0;
+    color: #334155;
+  }
+
+  &.period-day {
+    background: #dbeafe;
+    color: #1d4ed8;
+  }
+
+  &.period-week {
+    background: #fef3c7;
+    color: #b45309;
+  }
+
+  &.period-month {
+    background: #ede9fe;
+    color: #6d28d9;
+  }
+
+  &.period-other {
+    background: #fee2e2;
+    color: #b91c1c;
+  }
+}
+
+/* Chips that separate the rule list by window. */
+.period-filters {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  flex-wrap: wrap;
+  padding: 0 0 14px;
+}
+
+.period-filters-label {
+  font-size: 11px;
+  font-weight: 700;
+  color: #64748b;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+  margin-right: 2px;
+}
+
+.period-chip {
+  display: inline-flex;
+  align-items: center;
+  gap: 7px;
+  padding: 6px 13px;
+  border: 1px solid #cbd5e1;
+  background: #fff;
+  border-radius: 999px;
+  font-size: 12.5px;
+  font-weight: 600;
+  color: #334155;
+  cursor: pointer;
+  font-family: inherit;
+  transition: all 0.15s;
+
+  &:hover:not(:disabled) {
+    border-color: #1a237e;
+    color: #1a237e;
+  }
+
+  &.active {
+    background: #1a237e;
+    border-color: #1a237e;
+    color: #fff;
+  }
+
+  &:disabled {
+    opacity: 0.4;
+    cursor: not-allowed;
+  }
+}
+
+.period-chip-n {
+  font-size: 11px;
+  font-weight: 700;
+  padding: 1px 7px;
+  border-radius: 999px;
+  background: #f1f5f9;
+  color: #475569;
+
+  .period-chip.active & {
+    background: rgb(255 255 255 / 22%);
+    color: #fff;
+  }
 }
 
 /* Badges for Risk Category */

src/app/rbi-circulars/aml-rules/aml-rules.component.ts

@@ -42,24 +42,185 @@ export class AmlRulesComponent implements OnInit {
     'orderPosition',
     'ruleName',
     'riskCategory',
-    'incomeLimit',
+    'limitBasis',
+    'minLimit',
+    'maxLimit',
+    'appliesOver',
     'reason',
     'amlCheckStatus',
     'bannedEntityMatch'
   ];
 
+  /** Every rule as returned by the API, before the period filter is applied. */
+  private allRules: any[] = [];
+
+  /** Period buckets the rules can be separated into. */
+  readonly periodFilters: { key: string; label: string }[] = [
+    { key: '', label: 'All rules' },
+    { key: 'TXN', label: 'Per transaction' },
+    { key: 'DAY', label: 'Daily' },
+    { key: 'WEEK', label: 'Weekly' },
+    { key: 'MONTH', label: 'Monthly' },
+    { key: 'OTHER', label: 'Other window' }
+  ];
+  activePeriod = '';
+
   @ViewChild(MatPaginator) paginator!: MatPaginator;
 
   ngOnInit(): void {
     this.clientsService.getClientRiskRules().subscribe({
       next: (data) => {
-        this.rules.data = data || [];
+        this.allRules = data || [];
+        this.applyPeriodFilter();
         this.rules.paginator = this.paginator;
       },
       error: () => {}
     });
   }
 
+  setPeriod(key: string): void {
+    this.activePeriod = key;
+    this.applyPeriodFilter();
+  }
+
+  private applyPeriodFilter(): void {
+    this.rules.data = this.activePeriod
+      ? this.allRules.filter((r) => this.periodKey(r) === this.activePeriod)
+      : this.allRules;
+    if (this.rules.paginator) {
+      this.rules.paginator.firstPage();
+    }
+  }
+
+  /** How many rules fall in each period bucket — shown on the filter chips. */
+  periodCount(key: string): number {
+    return key ? this.allRules.filter((r) => this.periodKey(r) === key).length : this.allRules.length;
+  }
+
+  /**
+   * Buckets a rule by the observation window it is measured over.
+   * A rule with no window is evaluated on the single transaction itself, so it is
+   * in force every day rather than accumulating over a period.
+   */
+  periodKey(rule: any): string {
+    const days = rule.txnWindowDays;
+    if (days == null || days === 0) {
+      return 'TXN';
+    }
+    if (days === 1) {
+      return 'DAY';
+    }
+    if (days === 7) {
+      return 'WEEK';
+    }
+    if (days >= 28 && days <= 31) {
+      return 'MONTH';
+    }
+    return 'OTHER';
+  }
+
+  periodLabel(rule: any): string {
+    const days = rule.txnWindowDays;
+    switch (this.periodKey(rule)) {
+      case 'TXN':
+        return 'Per transaction';
+      case 'DAY':
+        return 'Daily';
+      case 'WEEK':
+        return 'Weekly';
+      case 'MONTH':
+        return 'Monthly';
+      default:
+        return `${days} days`;
+    }
+  }
+
+  periodClass(rule: any): string {
+    return 'period-badge period-' + this.periodKey(rule).toLowerCase();
+  }
+
+  /** Sub-caption telling the reader what the min/max figures actually measure. */
+  getLimitBasis(rule: any): string {
+    if (rule.minMonthlyIncome > 0 || rule.maxMonthlyIncome > 0) {
+      return 'Monthly Income';
+    }
+    if (rule.minAnnualIncome > 0 || rule.maxAnnualIncome > 0) {
+      return 'Annual Income';
+    }
+    if (rule.minAnnualTurnover > 0 || rule.maxAnnualTurnover > 0) {
+      return 'Annual Turnover';
+    }
+    if (rule.txnThresholdAmountMediumRisk != null || rule.txnThresholdAmountHighRisk != null) {
+      return 'Txn Amount (tiered)';
+    }
+    if (rule.txnThresholdAmount != null) {
+      return 'Txn Amount';
+    }
+    if (rule.occupationName) {
+      return 'Occupation';
+    }
+    if (rule.occupationCategoryName) {
+      return 'Occupation Category';
+    }
+    return 'Behavioural pattern';
+  }
+
+  private inr(n: number): string {
+    return '₹' + Number(n).toLocaleString('en-IN');
+  }
+
+  /** Lower bound of the rule, or an em dash where the criterion is not numeric. */
+  getMinLimit(rule: any): string {
+    if (rule.minMonthlyIncome > 0) {
+      return this.inr(rule.minMonthlyIncome);
+    }
+    if (rule.minAnnualIncome > 0) {
+      return this.inr(rule.minAnnualIncome);
+    }
+    if (rule.minAnnualTurnover > 0) {
+      return this.inr(rule.minAnnualTurnover);
+    }
+    // Declarative band from m_aml_transaction_rule takes precedence over the raw threshold.
+    if (rule.txnMinLimitAmount != null) {
+      return this.inr(rule.txnMinLimitAmount);
+    }
+    if (rule.txnThresholdAmount != null) {
+      return this.inr(rule.txnThresholdAmount);
+    }
+    return '—';
+  }
+
+  /** Upper bound, or "No upper limit" where the rule is genuinely open-ended. */
+  getMaxLimit(rule: any): string {
+    if (rule.maxMonthlyIncome > 0) {
+      return this.inr(rule.maxMonthlyIncome);
+    }
+    if (rule.maxAnnualIncome > 0) {
+      return this.inr(rule.maxAnnualIncome);
+    }
+    if (rule.maxAnnualTurnover > 0) {
+      return this.inr(rule.maxAnnualTurnover);
+    }
+    if (rule.txnMaxLimitAmount != null) {
+      return this.inr(rule.txnMaxLimitAmount);
+    }
+    // A floor with no configured ceiling means the rule has no upper bound.
+    if (
+      rule.minMonthlyIncome > 0 ||
+      rule.minAnnualIncome > 0 ||
+      rule.minAnnualTurnover > 0 ||
+      rule.txnThresholdAmount != null
+    ) {
+      return 'No upper limit';
+    }
+    return '—';
+  }
+
+  /** Occupation-driven rules carry no amount; show the criterion instead. */
+  getNonNumericCriterion(rule: any): string {
+    return rule.occupationName || rule.occupationCategoryName || '';
+  }
+
   getRiskCategoryLabel(category: number): string {
     switch (category) {
       case 1:
@@ -85,39 +246,4 @@ export class AmlRulesComponent implements OnInit {
         return '';
     }
   }
-
-  /** Formats whichever income/turnover/occupation criterion drives this rule's risk mark. */
-  getIncomeLimitLabel(rule: any): string {
-    const inr = (n: number) => '₹' + Number(n).toLocaleString('en-IN');
-    if (rule.minMonthlyIncome != null && rule.minMonthlyIncome > 0) {
-      return rule.maxMonthlyIncome != null && rule.maxMonthlyIncome > 0
-        ? `Monthly Income ${inr(rule.minMonthlyIncome)} - ${inr(rule.maxMonthlyIncome)}`
-        : `Monthly Income > ${inr(rule.minMonthlyIncome)}`;
-    }
-    if (rule.minAnnualIncome != null && rule.minAnnualIncome > 0) {
-      return rule.maxAnnualIncome != null && rule.maxAnnualIncome > 0
-        ? `Annual Income ${inr(rule.minAnnualIncome)} - ${inr(rule.maxAnnualIncome)}`
-        : `Annual Income > ${inr(rule.minAnnualIncome)}`;
-    }
-    if (rule.minAnnualTurnover != null && rule.minAnnualTurnover > 0) {
-      return rule.maxAnnualTurnover != null && rule.maxAnnualTurnover > 0
-        ? `Annual Turnover ${inr(rule.minAnnualTurnover)} - ${inr(rule.maxAnnualTurnover)}`
-        : `Annual Turnover > ${inr(rule.minAnnualTurnover)}`;
-    }
-    if (rule.occupationName) return `Occupation: ${rule.occupationName}`;
-    if (rule.occupationCategoryName) return `Occupation Category: ${rule.occupationCategoryName}`;
-    if (rule.txnThresholdAmountMediumRisk != null || rule.txnThresholdAmountHighRisk != null) {
-      const parts: string[] = [];
-      if (rule.txnThresholdAmountMediumRisk != null) parts.push(`${inr(rule.txnThresholdAmountMediumRisk)} (Medium Risk)`);
-      if (rule.txnThresholdAmountHighRisk != null) parts.push(`${inr(rule.txnThresholdAmountHighRisk)} (High Risk)`);
-      return `Txn Amount ≥ ${parts.join(' / ')}`;
-    }
-    if (rule.txnThresholdAmount != null) {
-      const amt = inr(rule.txnThresholdAmount);
-      if (rule.txnRuleType === 'THRESHOLD') return `Txn Amount ≥ ${amt}`;
-      if (rule.txnWindowDays != null) return `${amt} within ${rule.txnWindowDays} days`;
-      return `Txn Amount ≥ ${amt}`;
-    }
-    return 'Behavioral / Transaction Pattern';
-  }
 }