Merge branch 'dev' into WEB-1247-remove-orphaned-e2e-server-and-update-playwright-readme

Author: IOhacker

src/app/home/activities.ts

@@ -52,6 +52,11 @@ const activities: any[] = [
     path: '/organization/base-teller/savings-account-openings',
     permission: 'READ_TELLER'
   },
+  {
+    activity: 'labels.heading.Savings Account Deposit',
+    path: '/organization/base-teller/savings-account-deposits',
+    permission: 'DEPOSIT_SAVINGSACCOUNT'
+  },
   { activity: 'manage funds', path: '/organization/manage-funds' },
   { activity: 'chart of accounts', path: '/accounting/chart-of-accounts' },
   { activity: 'frequent postings', path: '/accounting/journal-entries/frequent-postings' },

src/app/organization/base-teller/base-teller.service.spec.ts

@@ -0,0 +1,127 @@
+/**
+ * Copyright since 2025 Mifos Initiative
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+import { provideHttpClient } from '@angular/common/http';
+import { HttpTestingController, provideHttpClientTesting } from '@angular/common/http/testing';
+import { TestBed } from '@angular/core/testing';
+import { firstValueFrom } from 'rxjs';
+import { describe, expect, it, beforeEach, afterEach } from '@jest/globals';
+
+import { BaseTellerService } from './base-teller.service';
+
+describe('BaseTellerService deposit workflow', () => {
+  let service: BaseTellerService;
+  let httpMock: HttpTestingController;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [
+        BaseTellerService,
+        provideHttpClient(),
+        provideHttpClientTesting()
+      ]
+    });
+
+    service = TestBed.inject(BaseTellerService);
+    httpMock = TestBed.inject(HttpTestingController);
+  });
+
+  afterEach(() => {
+    httpMock.verify();
+  });
+
+  it('searches customers and savings accounts through the platform search endpoint', async () => {
+    const resultPromise = firstValueFrom(service.searchDepositCustomersAndAccounts('amina'));
+
+    const req = httpMock.expectOne((request) => request.url === '/search' && request.method === 'GET');
+    expect(req.request.params.get('query')).toBe('amina');
+    expect(req.request.params.get('resource')).toBe('clients,savings');
+    expect(req.request.params.get('exactMatch')).toBe('false');
+    req.flush([{ entityId: 9 }]);
+
+    expect(await resultPromise).toEqual([{ entityId: 9 }]);
+  });
+
+  it('loads customer savings accounts', async () => {
+    const resultPromise = firstValueFrom(service.getDepositClientAccounts(22));
+
+    const req = httpMock.expectOne((request) => request.url === '/clients/22/accounts' && request.method === 'GET');
+    req.flush({ savingsAccounts: [{ id: 7 }] });
+
+    expect(await resultPromise).toEqual({ savingsAccounts: [{ id: 7 }] });
+  });
+
+  it('loads the savings transaction template payment types', async () => {
+    const resultPromise = firstValueFrom(service.getSavingsDepositTemplate(7));
+
+    const req = httpMock.expectOne(
+      (request) => request.url === '/savingsaccounts/7/transactions/template' && request.method === 'GET'
+    );
+    req.flush({ paymentTypeOptions: [{ id: 3, isCashPayment: true }] });
+
+    expect(await resultPromise).toEqual({ paymentTypeOptions: [{ id: 3, isCashPayment: true }] });
+  });
+
+  it('posts a cash deposit payload to the savings transaction deposit command', async () => {
+    const payload = {
+      transactionDate: '16 September 2026',
+      transactionAmount: 100,
+      paymentTypeId: 3,
+      dateFormat: 'dd MMMM yyyy',
+      locale: 'en'
+    };
+    const resultPromise = firstValueFrom(service.depositToSavingsAccount(7, payload));
+
+    const req = httpMock.expectOne((request) => request.url === '/savingsaccounts/7/transactions');
+    expect(req.request.method).toBe('POST');
+    expect(req.request.params.get('command')).toBe('deposit');
+    expect(req.request.body).toEqual(payload);
+    req.flush({ resourceId: 55 });
+
+    expect(await resultPromise).toEqual({ resourceId: 55 });
+  });
+
+  it('posts a check deposit payload using backend payment detail fields', async () => {
+    const payload = {
+      transactionDate: '16 September 2026',
+      transactionAmount: 250,
+      paymentTypeId: 4,
+      accountNumber: 'CHK-ACCOUNT',
+      checkNumber: 'CHK-009',
+      routingCode: 'RT-1',
+      receiptNumber: 'RC-1',
+      bankNumber: 'BANK-1',
+      dateFormat: 'dd MMMM yyyy',
+      locale: 'en'
+    };
+    const resultPromise = firstValueFrom(service.depositToSavingsAccount(7, payload));
+
+    const req = httpMock.expectOne((request) => request.url === '/savingsaccounts/7/transactions');
+    expect(req.request.params.get('command')).toBe('deposit');
+    expect(req.request.body).toEqual(payload);
+    req.flush({ resourceId: 56 });
+
+    expect(await resultPromise).toEqual({ resourceId: 56 });
+  });
+
+  it('propagates backend errors from deposit submission', async () => {
+    const payload = {
+      transactionDate: '16 September 2026',
+      transactionAmount: 100,
+      paymentTypeId: 3,
+      dateFormat: 'dd MMMM yyyy',
+      locale: 'en'
+    };
+    const resultPromise = firstValueFrom(service.depositToSavingsAccount(7, payload)).catch((error) => error);
+
+    const req = httpMock.expectOne((request) => request.url === '/savingsaccounts/7/transactions');
+    req.flush({ defaultUserMessage: 'paymentTypeId is required' }, { status: 400, statusText: 'Bad Request' });
+
+    expect((await resultPromise).status).toBe(400);
+  });
+});

src/app/organization/base-teller/base-teller.service.ts

@@ -13,6 +13,120 @@ import { HttpClient, HttpParams } from '@angular/common/http';
 /** rxjs Imports */
 import { Observable } from 'rxjs';
 
+export type FineractId = string | number;
+
+export interface DepositSearchResult {
+  id?: FineractId;
+  entityId?: FineractId;
+  accountId?: FineractId;
+  clientId?: FineractId;
+  accountNo?: string;
+  entityAccountNo?: string;
+  displayName?: string;
+  entityName?: string;
+  name?: string;
+  entityType?: string;
+  subEntityType?: string;
+  accountType?: string;
+}
+
+export interface DepositClient {
+  id?: FineractId;
+  accountNo?: string;
+  displayName?: string;
+  fullname?: string;
+  name?: string;
+  externalId?: string;
+}
+
+export interface DepositSavingsAccount {
+  id?: FineractId;
+  accountId?: FineractId;
+  savingsId?: FineractId;
+  accountNo?: string;
+  accountNumber?: string;
+  productName?: string;
+  savingsProductName?: string;
+  clientId?: FineractId;
+  clientName?: string;
+  clientDisplayName?: string;
+  currency?: { code?: string };
+  currencyCode?: string;
+  status?:
+    | {
+        active?: boolean;
+        value?: string;
+        code?: string;
+      }
+    | string;
+  summary?: {
+    accountBalance?: number | null;
+    availableBalance?: number | null;
+  };
+  accountBalance?: number | null;
+}
+
+export interface DepositClientAccounts {
+  savingsAccounts?: DepositSavingsAccount[];
+  savingAccounts?: DepositSavingsAccount[];
+}
+
+export interface DepositPaymentType {
+  id: FineractId;
+  name?: string;
+  value?: string;
+  description?: string;
+  isCashPayment?: boolean;
+  position?: number;
+  codeName?: string;
+  isSystemDefined?: boolean;
+}
+
+export interface SavingsDepositTemplate {
+  paymentTypeOptions?: DepositPaymentType[];
+}
+
+export interface SavingsDepositCommandPayload {
+  transactionDate: string;
+  transactionAmount: number;
+  paymentTypeId: FineractId;
+  dateFormat: string;
+  locale: string;
+  accountNumber?: string;
+  checkNumber?: string;
+  routingCode?: string;
+  receiptNumber?: string;
+  bankNumber?: string;
+  note?: string;
+}
+
+export interface SavingsDepositCommandResult {
+  resourceId?: FineractId;
+  entityId?: FineractId;
+  transactionId?: FineractId;
+  savingsId?: FineractId;
+  changes?: Record<string, unknown>;
+}
+
+export interface SavingsDepositReceipt extends SavingsDepositCommandResult {
+  id?: FineractId;
+  accountNo?: string;
+  accountNumber?: string;
+  amount?: number | null;
+  transactionAmount?: number | null;
+  runningBalance?: number | null;
+  cumulativeBalance?: number | null;
+  paymentDetailData?: {
+    receiptNumber?: string;
+    paymentType?: {
+      name?: string;
+    };
+  };
+  transactionType?: {
+    value?: string;
+  };
+}
+
 /**
  * Base Teller service.
  */
@@ -63,4 +177,66 @@ export class BaseTellerService {
   getSavingsOpeningReceipt(receiptNumber: string | number): Observable<any> {
     return this.http.get(`${this.savingsAccountOpeningsPath}/${receiptNumber}`);
   }
+
+  /**
+   * Searches clients and savings accounts using the authoritative platform search endpoint.
+   */
+  searchDepositCustomersAndAccounts(
+    searchTerm: string
+  ): Observable<DepositSearchResult[] | { pageItems?: DepositSearchResult[] }> {
+    const params = new HttpParams()
+      .set('exactMatch', 'false')
+      .set('query', searchTerm)
+      .set('resource', 'clients,savings');
+    return this.http.get<DepositSearchResult[] | { pageItems?: DepositSearchResult[] }>('/search', { params });
+  }
+
+  /**
+   * Retrieves a client profile.
+   */
+  getDepositClient(clientId: FineractId): Observable<DepositClient> {
+    return this.http.get<DepositClient>(`/clients/${clientId}`);
+  }
+
+  /**
+   * Retrieves the customer's accounts so an existing active savings account can be selected.
+   */
+  getDepositClientAccounts(clientId: FineractId): Observable<DepositClientAccounts> {
+    return this.http.get<DepositClientAccounts>(`/clients/${clientId}/accounts`);
+  }
+
+  /**
+   * Retrieves the selected savings account with server-provided balances and status.
+   */
+  getDepositSavingsAccount(savingsId: FineractId): Observable<DepositSavingsAccount> {
+    const params = new HttpParams().set('associations', 'all');
+    return this.http.get<DepositSavingsAccount>(`/savingsaccounts/${savingsId}`, { params });
+  }
+
+  /**
+   * Retrieves payment type options for the savings transaction command.
+   */
+  getSavingsDepositTemplate(savingsId: FineractId): Observable<SavingsDepositTemplate> {
+    return this.http.get<SavingsDepositTemplate>(`/savingsaccounts/${savingsId}/transactions/template`);
+  }
+
+  /**
+   * Deposits funds into an existing savings account.
+   */
+  depositToSavingsAccount(
+    savingsId: FineractId,
+    payload: SavingsDepositCommandPayload
+  ): Observable<SavingsDepositCommandResult> {
+    const params = new HttpParams().set('command', 'deposit');
+    return this.http.post<SavingsDepositCommandResult>(`/savingsaccounts/${savingsId}/transactions`, payload, {
+      params
+    });
+  }
+
+  /**
+   * Retrieves the saved transaction as the authoritative receipt/details response.
+   */
+  getSavingsDepositReceipt(savingsId: FineractId, transactionId: FineractId): Observable<SavingsDepositReceipt> {
+    return this.http.get<SavingsDepositReceipt>(`/savingsaccounts/${savingsId}/transactions/${transactionId}`);
+  }
 }