Resource Ordering Management API¶

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

Installation¶

npm install @dnext-angular/resource-ordering

Setup¶

Import the required modules and services:

import { NgModule } from '@angular/core';
import { HttpClientModule } from '@angular/common/http';
import { ResourceOrderService, CancelResourceOrderService } from '@dnext-angular/resource-ordering';

@NgModule({
  imports: [
    HttpClientModule
  ],
  providers: [
    ResourceOrderService,
    CancelResourceOrderService
  ]
})
export class AppModule { }

Services¶

ResourceOrderService¶

Handles resource order management operations.

// Create a resource order
createResourceOrder(
  order: ResourceOrderCreate,
  observe?: 'body' | 'response' | 'events'
): Observable<ResourceOrder>

// Retrieve a resource order by ID
retrieveResourceOrder(
  id: string,
  fields?: string,
  observe?: 'body' | 'response' | 'events'
): Observable<ResourceOrder>

// List resource orders
listResourceOrder(
  fields?: string,
  offset?: number,
  limit?: number
): Observable<Array<ResourceOrder>>

// Update a resource order
patchResourceOrder(
  id: string,
  order: ResourceOrderUpdate
): Observable<ResourceOrder>

// Delete a resource order
deleteResourceOrder(
  id: string
): Observable<any>

CancelResourceOrderService¶

Handles cancellation of resource orders.

// Create a cancellation request
createCancelOrder(
  cancelOrder: CancelResourceOrderCreate
): Observable<CancelResourceOrder>

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

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

Models¶

Core Models¶

ResourceOrder¶

Describes a resource order:

interface ResourceOrder {
    id?: string;                  // Unique identifier
    href?: string;                // Reference URL
    externalId?: ExternalId[];    // External system references
    priority?: string;            // Order priority
    description?: string;        // Order description
    state?: string;              // Order state
    orderDate?: Date;            // Order creation date
    completionDate?: Date;       // Order completion date
    requestedStartDate?: Date;   // Requested start date
    requestedCompletionDate?: Date; // Requested completion date
    orderItems?: ResourceOrderItem[]; // Order items
}

ResourceOrderItem¶

Represents an item within a resource order:

interface ResourceOrderItem {
    id?: string;              // Item identifier
    action: string;           // Action to perform
    state?: string;           // Item state
    resource?: Resource;      // Associated resource
    quantity?: Quantity;      // Quantity details
}

CancelResourceOrder¶

Describes a cancellation request:

interface CancelResourceOrder {
    id?: string;                          // Request identifier
    cancellationReason?: string;          // Reason for cancellation
    state?: TaskStateType;                // Request state
    effectiveCancellationDate?: Date;     // Actual cancellation date
    requestedCancellationDate?: Date;     // Requested cancellation date
    resourceOrder: ResourceOrderRef;       // Reference to the order
}

Usage Examples¶

Creating a Resource Order¶

import { ResourceOrderService } from '@dnext-angular/resource-ordering';

@Component({...})
export class OrderComponent {
  constructor(private resourceOrderService: ResourceOrderService) {}

  createOrder() {
    const order: ResourceOrderCreate = {
      externalId: [{
        id: 'ORD-001',
        entityType: 'Order',
        owner: 'ExternalSystem'
      }],
      orderItems: [{
        action: 'add',
        resource: {
          name: 'Resource1'
        }
      }]
    };

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

Cancelling a Resource Order¶

import { CancelResourceOrderService } from '@dnext-angular/resource-ordering';

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

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

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

Dependencies¶

@angular/core: ^18.0.0
@angular/common: ^18.0.0
@dnext-angular/http: 1.2.2
@dnext-angular/common: 1.1.1
rxjs: ^7.0.0

License¶

DNext PiAGroup