6879554296

Committed 15 Nov 2023 03:42PM UTC coverage: 73.02% (-0.009%) from 73.029%

Build # 6879554296

Build Type

push

github

Committed by

Arun-KumarH

Commit Message

fix: up deps for changes in expires_in, last_login and last_access to timestamp fields

Run Details

778 of 1157 branches covered (0.0%)

Branch coverage included in aggregate %.

2 of 3 new or added lines in 1 file covered. (66.67%)

1 existing line in 1 file now uncovered.

1352 of 1760 relevant lines covered (76.82%)

60.68 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

68.42

/src/accessControlService.ts

import * as _ from 'lodash';
import { Server } from '@restorecommerce/chassis-srv';
import { Events } from '@restorecommerce/kafka-client';

import { CommandInterface } from '@restorecommerce/chassis-srv';
import { ResourceManager } from './resourceManager';
import { RedisClientType } from 'redis';

import * as core from './core';
import { Logger } from 'winston';
import {
  AccessControlServiceImplementation, ReverseQuery,
  Request, Response, DeepPartial, Response_Decision
} from '@restorecommerce/rc-grpc-clients/dist/generated-server/io/restorecommerce/access_control';
import {
  CommandInterfaceServiceImplementation
} from '@restorecommerce/rc-grpc-clients/dist/generated-server/io/restorecommerce/commandinterface';
import { PolicySetWithCombinables } from './core/interfaces';

export class AccessControlService implements AccessControlServiceImplementation {
  cfg: any;
  logger: Logger;
  resourceManager: ResourceManager;
  accessController: core.AccessController;
  constructor(cfg: any, logger: Logger, resourceManager: ResourceManager, accessController: core.AccessController) {
    this.cfg = cfg;
    this.logger = logger;
    this.resourceManager = resourceManager;
    this.accessController = accessController;

    // create a resource adapter if any is defined in the config
    const adapterCfg = this.cfg.get('adapter') || {};
    if (!_.isEmpty(adapterCfg)) {
      this.accessController.createResourceAdapter(adapterCfg);
    }
  }
  async loadPolicies(): Promise<void> {
    this.logger.info('Loading policies');

    const policiesCfg = this.cfg.get('policies');
    const loadType = policiesCfg?.type;
    switch (loadType) {
      case 'local':
        const path: string = policiesCfg?.path;
        this.accessController = await core?.utils?.loadPoliciesFromDoc(this.accessController, path);
        this.logger.silly('Policies from local files loaded');
        break;
      case 'database':
        const policySetService = this.resourceManager.getResourceService('policy_set');
        const policySets: Map<string, PolicySetWithCombinables> = await policySetService.load() || new Map();
        this.accessController.policySets = policySets;
        this.logger.silly('Policies from database loaded');
        break;
    }
  }

  clearPolicies(): void {
    this.accessController.clearPolicies();
  }
  /**
   * gRPC interface
   */
  async isAllowed(request: Request, context: any): Promise<DeepPartial<Response>> {
    const acsRequest: Request = {
      target: request.target,
      context: request.context ? this.unmarshallContext(request.context) : {}
    };

    try {
      return this.accessController.isAllowed(acsRequest);
    } catch (err) { // deny if any error occurs
      this.logger.error('Error evaluating isAllowed request', { code: err.code, message: err.message, stack: err.stack });
      return {
        decision: Response_Decision.DENY,
        obligations: [],
        operation_status: {
          code: err.code,
          message: err.message
        }
      };
    }
  }

  async whatIsAllowed(request: Request, context: any): Promise<DeepPartial<ReverseQuery>> {
    const acsRequest: Request = {
      target: request.target,
      context: request.context ? this.unmarshallContext(request.context) : {}
    };
    let whatisAllowedResponse: ReverseQuery;
    try {
      whatisAllowedResponse = await this.accessController.whatIsAllowed(acsRequest);
    } catch (err) {
      this.logger.error('Error evaluating whatIsAllowed request', { code: err.code, message: err.message, stack: err.stack });
      return {
        operation_status: {
          code: err.code,
          message: err.message
        }
      };
    }
    return whatisAllowedResponse;
  }

  unmarshallContext(context: any): any {
    for (let prop in context) {
      if (_.isArray(context[prop])) {
        context[prop] = _.map(context.resources, this.unmarshallProtobufAny.bind(this));
      } else {
        context[prop] = this.unmarshallProtobufAny(context[prop]);
      }
    }
    return context;
  }

  unmarshallProtobufAny(object: any): any {
    if (!object || _.isEmpty(object.value)) {
      return null;
    }

    try {
      return JSON.parse(object.value.toString());
    } catch (err) {
      this.logger.error('Error unmarshalling object', { code: err.code, message: err.message, stack: err.stack });
      throw err;
    }
  }

}

export class AccessControlCommandInterface extends CommandInterface implements CommandInterfaceServiceImplementation {
  accessControlService: AccessControlService;
  constructor(server: Server, cfg: any, logger: Logger, events: Events,
    accessControlService: AccessControlService, redisClient: RedisClientType<any, any>) {
    super(server, cfg, logger, events, redisClient);
    this.accessControlService = accessControlService;
  }

  async restore(payload: any): Promise<any> {
    const result = await super.restore(payload);

    this.accessControlService.clearPolicies();
    await this.accessControlService.loadPolicies();
    return result;
  }

  async reset(): Promise<any> {
    const result = await super.reset();
    this.accessControlService.clearPolicies();
    return result;
  }
}

1	import * as _ from 'lodash';	2✔
2	import { Server } from '@restorecommerce/chassis-srv';
3	import { Events } from '@restorecommerce/kafka-client';
4
5	import { CommandInterface } from '@restorecommerce/chassis-srv';	2✔
6	import { ResourceManager } from './resourceManager';
7	import { RedisClientType } from 'redis';
8
9	import * as core from './core';	2✔
10	import { Logger } from 'winston';
11	import {	2✔
12	AccessControlServiceImplementation, ReverseQuery,
13	Request, Response, DeepPartial, Response_Decision
14	} from '@restorecommerce/rc-grpc-clients/dist/generated-server/io/restorecommerce/access_control';
15	import {
16	CommandInterfaceServiceImplementation
17	} from '@restorecommerce/rc-grpc-clients/dist/generated-server/io/restorecommerce/commandinterface';
18	import { PolicySetWithCombinables } from './core/interfaces';
19
20	export class AccessControlService implements AccessControlServiceImplementation {	2✔
21	cfg: any;
22	logger: Logger;
23	resourceManager: ResourceManager;
24	accessController: core.AccessController;
25	constructor(cfg: any, logger: Logger, resourceManager: ResourceManager, accessController: core.AccessController) {
26	this.cfg = cfg;	5✔
27	this.logger = logger;	5✔
28	this.resourceManager = resourceManager;	5✔
29	this.accessController = accessController;	5✔
30
31	// create a resource adapter if any is defined in the config
32	const adapterCfg = this.cfg.get('adapter') \|\| {};	5!
33	if (!_.isEmpty(adapterCfg)) {	5!
34	this.accessController.createResourceAdapter(adapterCfg);	5✔
35	}
36	}
37	async loadPolicies(): Promise<void> {
38	this.logger.info('Loading policies');	5✔
39
40	const policiesCfg = this.cfg.get('policies');	5✔
41	const loadType = policiesCfg?.type;	5✔
42	switch (loadType) {	5✔
43	case 'local':	5!
44	const path: string = policiesCfg?.path;	×
45	this.accessController = await core?.utils?.loadPoliciesFromDoc(this.accessController, path);	×
NEW 46	this.logger.silly('Policies from local files loaded');	×
UNCOV 47	break;	×
48	case 'database':
49	const policySetService = this.resourceManager.getResourceService('policy_set');	5✔
50	const policySets: Map<string, PolicySetWithCombinables> = await policySetService.load() \|\| new Map();	5✔
51	this.accessController.policySets = policySets;	5✔
52	this.logger.silly('Policies from database loaded');	5✔
53	break;	5✔
54	}
55	}
56
57	clearPolicies(): void {
58	this.accessController.clearPolicies();	×
59	}
60	/**
61	* gRPC interface
62	*/
63	async isAllowed(request: Request, context: any): Promise<DeepPartial<Response>> {
64	const acsRequest: Request = {	60✔
65	target: request.target,
66	context: request.context ? this.unmarshallContext(request.context) : {}	60✔
67	};
68
69	try {	60✔
70	return this.accessController.isAllowed(acsRequest);	60✔
71	} catch (err) { // deny if any error occurs
72	this.logger.error('Error evaluating isAllowed request', { code: err.code, message: err.message, stack: err.stack });	×
73	return {	×
74	decision: Response_Decision.DENY,
75	obligations: [],
76	operation_status: {
77	code: err.code,
78	message: err.message
79	}
80	};
81	}
82	}
83
84	async whatIsAllowed(request: Request, context: any): Promise<DeepPartial<ReverseQuery>> {
85	const acsRequest: Request = {	24✔
86	target: request.target,
87	context: request.context ? this.unmarshallContext(request.context) : {}	24!
88	};
89	let whatisAllowedResponse: ReverseQuery;
90	try {	24✔
91	whatisAllowedResponse = await this.accessController.whatIsAllowed(acsRequest);	24✔
92	} catch (err) {
93	this.logger.error('Error evaluating whatIsAllowed request', { code: err.code, message: err.message, stack: err.stack });	×
94	return {	×
95	operation_status: {
96	code: err.code,
97	message: err.message
98	}
99	};
100	}
101	return whatisAllowedResponse;	24✔
102	}
103
104	unmarshallContext(context: any): any {
105	for (let prop in context) {	83✔
106	if (_.isArray(context[prop])) {	179✔
107	context[prop] = _.map(context.resources, this.unmarshallProtobufAny.bind(this));	83✔
108	} else {
109	context[prop] = this.unmarshallProtobufAny(context[prop]);	96✔
110	}
111	}
112	return context;	83✔
113	}
114
115	unmarshallProtobufAny(object: any): any {
116	if (!object \|\| _.isEmpty(object.value)) {	203!
117	return null;	×
118	}
119
120	try {	203✔
121	return JSON.parse(object.value.toString());	203✔
122	} catch (err) {
123	this.logger.error('Error unmarshalling object', { code: err.code, message: err.message, stack: err.stack });	×
124	throw err;	×
125	}
126	}
127
128	}
129
130	export class AccessControlCommandInterface extends CommandInterface implements CommandInterfaceServiceImplementation {	2✔
131	accessControlService: AccessControlService;
132	constructor(server: Server, cfg: any, logger: Logger, events: Events,
133	accessControlService: AccessControlService, redisClient: RedisClientType<any, any>) {
134	super(server, cfg, logger, events, redisClient);	5✔
135	this.accessControlService = accessControlService;	5✔
136	}
137
138	async restore(payload: any): Promise<any> {
139	const result = await super.restore(payload);	×
140
141	this.accessControlService.clearPolicies();	×
142	await this.accessControlService.loadPolicies();	×
143	return result;	×
144	}
145
146	async reset(): Promise<any> {
147	const result = await super.reset();	×
148	this.accessControlService.clearPolicies();	×
149	return result;	×
150	}
151	}

restorecommerce / access-control-srv / 6879554296

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous