service-activities2-node/src/services/ActivitiesCommandSet.ts

Party activities tracking microservice in Node.js / ES2017 V2

import { DateTimeConverter } from 'pip-services4-commons-node';
import { IContext } from 'pip-services4-components-node';
import { Parameters } from 'pip-services4-components-node';
import { ArraySchema } from 'pip-services4-data-node';
import { FilterParams } from 'pip-services4-data-node';
import { ObjectSchema } from 'pip-services4-data-node';
import { PagingParams } from 'pip-services4-data-node';
import { FilterParamsSchema } from 'pip-services4-data-node';
import { PagingParamsSchema } from 'pip-services4-data-node';
import { Command } from 'pip-services4-rpc-node';
import { CommandSet } from 'pip-services4-rpc-node';
import { ICommand } from 'pip-services4-rpc-node';

import { PartyActivityV1Schema } from '../data/version1/PartyActivityV1Schema';
import { IActivitiesService } from './IActivitiesService';

export class ActivitiesCommandSet extends CommandSet {
    private _service: IActivitiesService;

    constructor(service: IActivitiesService) {
        super();

        this._service = service;

        // Register commands to the database
		this.addCommand(this.makeGetPartyActivitiesCommand());
		this.addCommand(this.makeLogPartyActivityCommand());
		this.addCommand(this.makeBatchPartyActivitiesCommand());
		this.addCommand(this.makeDeletePartyActivitiesCommand());
    }

	private makeGetPartyActivitiesCommand(): ICommand {
		return new Command(
			"get_party_activities",
			new ObjectSchema(true)
				.withOptionalProperty('filter', new FilterParamsSchema())
				.withOptionalProperty('paging', new PagingParamsSchema()),
            async (ctx: IContext, args: Parameters) => {
                let filter = FilterParams.fromValue(args.get("filter"));
                let paging = PagingParams.fromValue(args.get("paging"));
				return await this._service.getPartyActivities(ctx, filter, paging);
            }
		);
	}

	private makeLogPartyActivityCommand(): ICommand {
		return new Command(
			"log_party_activity",
			new ObjectSchema(true)
				.withRequiredProperty('activity', new PartyActivityV1Schema()),
			async (ctx: IContext, args: Parameters) => {
                let activity = args.get("activity");
				activity.time = DateTimeConverter.toNullableDateTime(activity.time);
				return await this._service.logPartyActivity(ctx, activity);
            }
		);
	}

	private makeBatchPartyActivitiesCommand(): ICommand {
		return new Command(
			"batch_party_activities",
			new ObjectSchema(true)
				.withRequiredProperty('activities', new ArraySchema(new PartyActivityV1Schema())),
			async (ctx: IContext, args: Parameters) => {
                let activities = args.getAsArray("activities");
				activities.forEach((a) => {
					a.time = DateTimeConverter.toNullableDateTime(a.time);
				});
				return await this._service.batchPartyActivities(ctx, activities);
            }
		);
	}

	private makeDeletePartyActivitiesCommand(): ICommand {
		return new Command(
			"delete_party_activities",
			new ObjectSchema(true)
				.withOptionalProperty('filter', new FilterParamsSchema()),
			async (ctx: IContext, args: Parameters) => {
                let filter = FilterParams.fromValue(args.get("filter"));
				return await this._service.deletePartyActivities(ctx, filter);
            }
		);
	}

}