The Factory Method Design Pattern

export abstract class User {
    constructor(public name: string, public userType: string) {}
}

export class Admin extends User {
    constructor(name: string) {
        super(name, 'Admin');
    }
}

export class Customer extends User {
    constructor(name: string) {
        super(name, 'Customer');
    }
}

export class Vendor extends User {
    constructor(name: string) {
        super(name, 'Vendor');
    }
}

export class UserFactory {
    createUser(name: string, type: string): User {
        switch(type) {
            case 'Admin':
                return new Admin(name);
            case 'Customer':
                return new Customer(name);
            case 'Vendor':
                return new Vendor(name);
            default:
                throw new Error('User type is not recognized!');
        }
    }
}

import { Injectable } from '@angular/core';
import { User, Admin, Customer, Vendor, UserFactory } from './user.model';

@Injectable({
    providedIn: 'root'
})
export class UserService {
    private userFactory = new UserFactory();

    createUser(name: string, type: string): User {
        return this.userFactory.createUser(name, type);
    }
}

import { Component, OnInit } from '@angular/core';
import { User } from './user.model';
import { UserService } from './user.service';

@Component({
    selector: 'app-user',
    template: `<h1>Welcome {{ user.name }}! You are logged in as a(n) {{ user.userType }}.</h1>`
})
export class UserComponent implements OnInit {
    user: User;

    constructor(private userService: UserService) {}

    ngOnInit(): void {
        // Example: Create a user of type 'Admin'
        this.user = this.userService.createUser('Alice', 'Admin');
    }
}

export interface PaymentGateway {
    processPayment(amount: number): string;
}

export class CreditCardGateway implements PaymentGateway {
    processPayment(amount: number): string {
        return `Processing credit card payment of $${amount}.`;
    }
}

export class PayPalGateway implements PaymentGateway {
    processPayment(amount: number): string {
        return `Processing PayPal payment of $${amount}.`;
    }
}

export class AliPayGateway implements PaymentGateway {
    processPayment(amount: number): string {
        return `Processing AliPay payment of ¥${amount}.`;
    }
}

export class PaymentGatewayFactory {
    createGateway(type: string): PaymentGateway {
        switch(type) {
            case 'CreditCard':
                return new CreditCardGateway();
            case 'PayPal':
                return new PayPalGateway();
            case 'AliPay':
                return new AliPayGateway();
            default:
                throw new Error('Payment gateway type is not recognized!');
        }
    }
}

import { Injectable } from '@angular/core';
import { PaymentGateway, CreditCardGateway, PayPalGateway, 
    AliPayGateway, PaymentGatewayFactory } from './payment-gateway.model';

@Injectable({
    providedIn: 'root'
})
export class PaymentService {
    private gatewayFactory = new PaymentGatewayFactory();

    processPayment(type: string, amount: number): string {
        const gateway = this.gatewayFactory.createGateway(type);
        return gateway.processPayment(amount);
    }
}

import { Component } from '@angular/core';
import { PaymentService } from './payment.service';

@Component({
    selector: 'app-payment',
    template: `<h1>{{ paymentConfirmation }}</h1>`
})
export class PaymentComponent {
    paymentConfirmation: string;

    constructor(private paymentService: PaymentService) {
        this.paymentConfirmation = this.processPayment('AliPay', 100);
    }

    processPayment(type: string, amount: number): string {
        return this.paymentService.processPayment(type, amount);
    }
}