Product Ordering Management API

This API provides Product Order Management capabilities through a REST API interface.

Installation

npm install @dnext-angular/product-ordering

Setup

Import the required modules and services:

import { NgModule } from '@angular/core';
import { HttpClientModule } from '@angular/common/http';
import { 
  ProductOrderService,
  CancelProductOrderService,
  ProductOrderItemService,
  ProductOrderJourneyService 
} from '@dnext-angular/product-ordering';

@NgModule({
  imports: [
    HttpClientModule
  ],
  providers: [
    ProductOrderService,
    CancelProductOrderService,
    ProductOrderItemService,
    ProductOrderJourneyService
  ]
})
export class AppModule { }

Services

ProductOrderService

Handles product order management operations.

// Create a product order
createProductOrder(
  order: ProductOrderCreate,
  observe?: 'body' | 'response' | 'events'
): Observable<ProductOrder>

// Retrieve a product order
retrieveProductOrder(
  id: string,
  fields?: string,
  observe?: 'body' | 'response' | 'events'
): Observable<ProductOrder>

// Update a product order
patchProductOrder(
  id: string,
  order: ProductOrderUpdate
): Observable<ProductOrder>

// Delete a product order
deleteProductOrder(
  id: string
): Observable<any>

CancelProductOrderService

Handles cancellation of product orders.

// Create a cancellation request
createCancelOrder(
  cancelOrder: CancelProductOrderCreate
): Observable<CancelProductOrder>

// List cancellation requests
listCancelOrder(
  fields?: string,
  offset?: number,
  limit?: number,
  sort?: string
): Observable<Array<CancelProductOrder>>

// Retrieve a cancellation request
retrieveCancelOrder(
  id: string,
  fields?: string
): Observable<CancelProductOrder>

ProductOrderItemService

Handles product order item operations.

// List order items
listProductOrderItems(
  orderId: string,
  fields?: string,
  offset?: number,
  limit?: number,
  sort?: string
): Observable<Array<DetachedProductOrderItem>>

// Update an order item
patchProductOrderItem(
  orderId: string,
  itemId: string,
  item: DetachedProductOrderItemUpdate
): Observable<DetachedProductOrderItem>

// Retrieve an order item
retrieveProductOrderItem(
  orderId: string,
  itemId: string,
  fields?: string
): Observable<DetachedProductOrderItem>

Usage Examples

Creating a Product Order

import { ProductOrderService } from '@dnext-angular/product-ordering';

@Component({...})
export class OrderComponent {
  constructor(private productOrderService: ProductOrderService) {}

  createOrder() {
    const order: ProductOrderCreate = {
      orderItem: [{
        action: 'add',
        product: {
          name: 'Internet Package'
        }
      }],
      relatedParty: [{
        id: 'customer-123',
        role: 'customer'
      }]
    };

    this.productOrderService.createProductOrder(order)
      .subscribe({
        next: (response) => {
          console.log('Order created:', response);
        },
        error: (error) => {
          console.error('Error creating order:', error);
        }
      });
  }
}

Cancelling a Product Order

import { CancelProductOrderService } from '@dnext-angular/product-ordering';

@Component({...})
export class CancelOrderComponent {
  constructor(private cancelOrderService: CancelProductOrderService) {}

  cancelOrder(orderId: string) {
    const cancelRequest: CancelProductOrderCreate = {
      cancellationReason: 'Customer request',
      productOrder: {
        id: orderId
      }
    };

    this.cancelOrderService.createCancelOrder(cancelRequest)
      .subscribe({
        next: (response) => {
          console.log('Cancellation requested:', response);
        },
        error: (error) => {
          console.error('Error requesting cancellation:', error);
        }
      });
  }
}

Managing Order Items

import { ProductOrderItemService } from '@dnext-angular/product-ordering';

@Component({...})
export class OrderItemsComponent {
  constructor(private orderItemService: ProductOrderItemService) {}

  updateOrderItem(orderId: string, itemId: string) {
    const update: DetachedProductOrderItemUpdate = {
      quantity: {
        amount: 2,
        units: 'pieces'
      }
    };

    this.orderItemService.patchProductOrderItem(orderId, itemId, update)
      .subscribe({
        next: (response) => {
          console.log('Item updated:', response);
        },
        error: (error) => {
          console.error('Error updating item:', error);
        }
      });
  }

  listOrderItems(orderId: string) {
    this.orderItemService.listProductOrderItems(orderId)
      .subscribe({
        next: (items) => {
          console.log('Order items:', items);
        },
        error: (error) => {
          console.error('Error retrieving items:', error);
        }
      });
  }
}

Dependencies

• @angular/core: >=18.0.1
• @angular/common: >=18.0.1
• @dnext-angular/http: 1.2.2
• @dnext-angular/common: 1.1.1
• rxjs: ^7.0.0

License

DNext PiAGroup