6945749690

Committed 21 Nov 2023 03:09PM UTC coverage: 73.016% (+0.08%) from 72.933%

Build # 6945749690

Build Type

push

github

Committed by

Arun-KumarH

Commit Message

fix: Add support for multiple operations

Run Details

761 of 1127 branches covered (0.0%)

Branch coverage included in aggregate %.

8 of 11 new or added lines in 1 file covered. (72.73%)

1 existing line in 1 file now uncovered.

1328 of 1734 relevant lines covered (76.59%)

63.04 hits per line

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

79.28

/src/core/hierarchicalScope.ts

import * as _ from 'lodash';
import traverse from 'traverse';
import { Logger } from 'winston';
import { AccessController } from '.';
import { Request } from '@restorecommerce/rc-grpc-clients/dist/generated-server/io/restorecommerce/access_control';
import { Target } from '@restorecommerce/rc-grpc-clients/dist/generated-server/io/restorecommerce/rule';
import { Attribute } from '@restorecommerce/rc-grpc-clients/dist/generated-server/io/restorecommerce/attribute';
import { Resource, ContextWithSubResolved } from './interfaces';
import { getAllValues, updateScopedRoles } from './utils';

export const checkHierarchicalScope = async (ruleTarget: Target,
  request: Request, urns: Map<string, string>, accessController: AccessController, logger?: Logger): Promise<boolean> => {
  let scopedRoles = new Map<string, Map<string, string[]>>(); // <role, <scopingEntity, scopingInstances[]>>
  let role: string;
  const totalScopingEntities: string[] = [];
  const ruleSubject = ruleTarget.subjects || [];
  let hierarchicalRoleScopeCheck = 'true';
  // retrieving all role scoping entities from the rule's subject
  for (let attribute of ruleSubject) {
    if (attribute.id == urns.get('role')) {
      role = attribute.value;
      if (!scopedRoles.has(role)) {
        scopedRoles.set(role, new Map<string, string[]>());
      }
    }
    if (attribute.id == urns.get('roleScopingEntity') && !!role) {
      const scopingEntity = attribute.value;

      totalScopingEntities.push(scopingEntity);
      const scopingEntities = scopedRoles.get(role);
      scopingEntities.set(scopingEntity, []);
      scopedRoles.set(role, scopingEntities);
      role = null;
    }
    if (attribute.id === urns.get('hierarchicalRoleScoping')) {
      hierarchicalRoleScopeCheck = attribute.value;
    }
  }

  if (_.isEmpty(totalScopingEntities)) {
    logger.debug('Scoping entity not found in rule subject hence hierarchical scope check not needed');
    return true; // no scoping entities specified in rule, request ignored
  }

  let context = (request as any).context as ContextWithSubResolved;
  if (_.isEmpty(context)) {
    return false; // no context was provided, evaluation fails
  }

  const ctxResources = context.resources || [];
  const reqTarget = request.target;
  let entityOrOperation: string;
  // iterating through all targeted resources and retrieve relevant owners instances
  for (let attribute of ruleTarget.resources || []) {
    if (attribute?.id == urns.get('entity')) { // resource type found
      logger.debug('Evaluating resource entity match');
      entityOrOperation = attribute?.value;

      let entitiesMatch = false;
      // iterating request resources to filter all resources of a given type
      for (let requestAttribute of reqTarget.resources || []) {
        if (requestAttribute?.id == attribute?.id && requestAttribute?.value == entityOrOperation) {
          entitiesMatch = true; // a resource entity that matches the request and the rule's target
        } else if (requestAttribute?.id == attribute?.id) {
          // rule entity, get ruleNS and entityRegexValue for rule
          const value = entityOrOperation;
          let pattern = value?.substring(value?.lastIndexOf(':') + 1);
          let nsEntityArray = pattern?.split('.');
          // firstElement could be either entity or namespace
          let nsOrEntity = nsEntityArray[0];
          let entityRegexValue = nsEntityArray[nsEntityArray.length - 1];
          let reqNS, ruleNS;
          if (nsOrEntity?.toUpperCase() != entityRegexValue?.toUpperCase()) {
            // rule name space is present
            ruleNS = nsOrEntity?.toUpperCase();
          }

          // request entity, get reqNS and requestEntityValue for request
          let reqValue = requestAttribute?.value;
          const reqAttributeNS = reqValue?.substring(0, reqValue?.lastIndexOf(':'));
          const ruleAttributeNS = value?.substring(0, value?.lastIndexOf(':'));
          // verify namespace before entity name
          if (reqAttributeNS != ruleAttributeNS) {
            entitiesMatch = false;
          }
          let reqPattern = reqValue?.substring(reqValue?.lastIndexOf(':') + 1);
          let reqNSEntityArray = reqPattern?.split('.');
          // firstElement could be either entity or namespace
          let reqNSOrEntity = reqNSEntityArray[0];
          let requestEntityValue = reqNSEntityArray[reqNSEntityArray.length - 1];
          if (reqNSOrEntity?.toUpperCase() != requestEntityValue?.toUpperCase()) {
            // request name space is present
            reqNS = reqNSOrEntity?.toUpperCase();
          }

          if ((reqNS && ruleNS && (reqNS === ruleNS)) || (!reqNS && !ruleNS)) {
            const reExp = new RegExp(entityRegexValue);
            if (requestEntityValue?.match(reExp)) {
              entitiesMatch = true;
            }
          }
        }
        else if (requestAttribute?.id == urns?.get('resourceID') && entitiesMatch) { // resource instance ID of a matching entity
          const instanceID = requestAttribute?.value;
          // found resource instance ID, iterating through the context to check if owners entities match the scoping entities
          let ctxResource: Resource = _.find(ctxResources, ['instance.id', instanceID]);
          if (ctxResource) {
            ctxResource = ctxResource?.instance;
          } else {
            // look up by ID
            ctxResource = _.find(ctxResources, ['id', instanceID]);
          }
          if (ctxResource) {
            const meta = ctxResource.meta;
            if (_.isEmpty(meta) || _.isEmpty(meta.owners)) {
              logger.debug(`Owners information missing for hierarchical scope matching of entity ${attribute.value}, evaluation fails`);
              return false; // no ownership was passed, evaluation fails
            }
            scopedRoles = updateScopedRoles(meta, scopedRoles, urns, totalScopingEntities);
          } else {
            logger.debug('Resource of targeted entity was not provided in context');
            return false; // resource of targeted entity was not provided in context
          }
        }
      }
    } else if (attribute?.id === urns.get('operation')) {
      logger.debug('Evaluating resource operation match');
      entityOrOperation = attribute?.value;
      for (let reqAttribute of reqTarget.resources || []) {
        // match Rule resource operation URN and operation name with request resource operation URN and operation name
        if (reqAttribute?.id === attribute?.id && reqAttribute?.value === attribute?.value) {
          // find context resource based
          let ctxResource: Resource = _.find(ctxResources, ['id', entityOrOperation]);
          if (ctxResource) {
            const meta = ctxResource.meta;
            if (_.isEmpty(meta) || _.isEmpty(meta.owners)) {
              logger.debug(`Owners information missing for hierarchical scope matching of entity ${attribute.value}, evaluation fails`);
              return false; // no ownership was passed, evaluation fails
            }
            scopedRoles = updateScopedRoles(meta, scopedRoles, urns, totalScopingEntities);
          } else {
            logger.debug('Operation name was not provided in context');
            return false; // Operation name was not provided in context
          }
        }
      }
    }
  }

  if (_.isNil(entityOrOperation) || _.isEmpty(entityOrOperation)) {
    logger.debug('No Entity or operation name found');
    return false; // no entity found
  }

  // check if context subject_id contains HR scope if not make request 'createHierarchicalScopes'
  if (context?.subject?.token && _.isEmpty(context.subject.hierarchical_scopes)) {
    context = await accessController.createHRScope(context);
  }

  const roleAssociations = context?.subject?.role_associations;
  if (_.isEmpty(roleAssociations)) {
    logger.debug('Role Associations not found');
    return false; // impossible to evaluate context
  }
  const treeNodes = new Map<string, Map<string, string[]>>(); // <role, <entity, hierarchicalTreeNodes>>

  for (let i = 0; i < roleAssociations.length; i += 1) {
    const role: string = roleAssociations[i].role;
    const attributes: Attribute[] = roleAssociations[i].attributes || [];

    if (scopedRoles.has(role)) {
      const entities = scopedRoles.get(role);
      let scopingEntity: string;
      // let roleSubNodes = []; // sub nodes to be queried in case hierarchical resource is not found
      for (let attribute of attributes) {
        if (attribute.id == urns.get('roleScopingEntity') && entities.has(attribute.value)) {
          scopingEntity = attribute.value;
          if (attribute?.attributes?.length > 0) {
            for (let roleScopeInstObj of attribute.attributes) { // role-attributes-attributes -> roleScopingInstance
              if (roleScopeInstObj.id == urns.get('roleScopingInstance') && !!scopingEntity) {  // if scoping instance is found within the attributes
                const instances = entities.get(scopingEntity);
                if (!_.isEmpty(_.remove(instances, i => i == roleScopeInstObj.value))) { // if any element was removed
                  if (_.isEmpty(instances)) {
                    entities.delete(scopingEntity);
                    if (entities.size == 0) {
                      scopedRoles.delete(role);
                    }
                  }
                } else {
                  if (!treeNodes.has(role)) {
                    treeNodes.set(role, new Map<string, string[]>());
                  }
                  const nodesByEntity = treeNodes.get(role);
                  if (!nodesByEntity.has(scopingEntity)) {
                    nodesByEntity.set(scopingEntity, []);
                  }
                  const nodes = nodesByEntity.get(scopingEntity);
                  nodes.push(roleScopeInstObj.value);
                  nodesByEntity.set(scopingEntity, nodes);
                  treeNodes.set(role, nodesByEntity);
                }
              }
            }
          }
        }
      }
    }
    else {
      if (i == roleAssociations.length - 1 && scopedRoles.size > 0 && treeNodes.size === 0) {
        logger.debug('Subject does not have one of the required roles in its context');
        return false; // user does not have one of the required roles in its context
      }
    }
  }

  let check = scopedRoles.size == 0;
  if (!check && hierarchicalRoleScopeCheck && hierarchicalRoleScopeCheck === 'true') {
    const hierarchicalScopes = context.subject.hierarchical_scopes;
    for (let hierarchicalScope of hierarchicalScopes) {
      let subTreeRole = null;
      let level = -1;
      traverse(hierarchicalScope).forEach(function (node: any): void { // depth-first search
        let subtreeFound = false;
        if (!!node.id) {
          if (level > -1 && this.level >= level) {
            subTreeRole = null;
            level = -1;
          } else {
            if (!subTreeRole) {
              for (let [role, nodes] of treeNodes) {
                for (let [, instances] of nodes) {
                  if (_.includes(instances, node.id)) {
                    subTreeRole = role;
                    subtreeFound = true;
                    break;
                  }
                }
              }
            }
            if (subtreeFound) {
              const entities = scopedRoles.get(subTreeRole);
              let eligibleOrgScopes = [];
              getAllValues(node, eligibleOrgScopes);
              if (entities) {
                for (let [entity, instances] of entities) {
                  for (let instance of instances) {
                    if (eligibleOrgScopes.indexOf(instance) > -1) {
                      instances = instances.filter(e => e != instance);
                    }
                  }
                  if (instances.length === 0) {
                    entities.delete(entity);
                    break;
                  }
                }
              }
              if (entities && entities.size == 0) {
                scopedRoles.delete(subTreeRole);
                if (scopedRoles.size == 0) {
                  check = true;
                  this.stop(); // stopping traversal, no more scoped roles need to be checked
                }
              }
              // inside hierarchical sub
            }
          }
        }
      });
    }
  }

  return check;
};

1	import * as _ from 'lodash';	2✔
2	import traverse from 'traverse';	2✔
3	import { Logger } from 'winston';
4	import { AccessController } from '.';
5	import { Request } from '@restorecommerce/rc-grpc-clients/dist/generated-server/io/restorecommerce/access_control';
6	import { Target } from '@restorecommerce/rc-grpc-clients/dist/generated-server/io/restorecommerce/rule';
7	import { Attribute } from '@restorecommerce/rc-grpc-clients/dist/generated-server/io/restorecommerce/attribute';
8	import { Resource, ContextWithSubResolved } from './interfaces';
9	import { getAllValues, updateScopedRoles } from './utils';	2✔
10
11	export const checkHierarchicalScope = async (ruleTarget: Target,	2✔
12	request: Request, urns: Map<string, string>, accessController: AccessController, logger?: Logger): Promise<boolean> => {
13	let scopedRoles = new Map<string, Map<string, string[]>>(); // <role, <scopingEntity, scopingInstances[]>>	103✔
14	let role: string;
15	const totalScopingEntities: string[] = [];	103✔
16	const ruleSubject = ruleTarget.subjects \|\| [];	103!
17	let hierarchicalRoleScopeCheck = 'true';	103✔
18	// retrieving all role scoping entities from the rule's subject
19	for (let attribute of ruleSubject) {	103✔
20	if (attribute.id == urns.get('role')) {	164✔
21	role = attribute.value;	84✔
22	if (!scopedRoles.has(role)) {	84!
23	scopedRoles.set(role, new Map<string, string[]>());	84✔
24	}
25	}
26	if (attribute.id == urns.get('roleScopingEntity') && !!role) {	164✔
27	const scopingEntity = attribute.value;	69✔
28
29	totalScopingEntities.push(scopingEntity);	69✔
30	const scopingEntities = scopedRoles.get(role);	69✔
31	scopingEntities.set(scopingEntity, []);	69✔
32	scopedRoles.set(role, scopingEntities);	69✔
33	role = null;	69✔
34	}
35	if (attribute.id === urns.get('hierarchicalRoleScoping')) {	164✔
36	hierarchicalRoleScopeCheck = attribute.value;	1✔
37	}
38	}
39
40	if (_.isEmpty(totalScopingEntities)) {	103✔
41	logger.debug('Scoping entity not found in rule subject hence hierarchical scope check not needed');	34✔
42	return true; // no scoping entities specified in rule, request ignored	34✔
43	}
44
45	let context = (request as any).context as ContextWithSubResolved;	69✔
46	if (_.isEmpty(context)) {	69!
47	return false; // no context was provided, evaluation fails	×
48	}
49
50	const ctxResources = context.resources \|\| [];	69!
51	const reqTarget = request.target;	69✔
52	let entityOrOperation: string;
53	// iterating through all targeted resources and retrieve relevant owners instances
54	for (let attribute of ruleTarget.resources \|\| []) {	69!
55	if (attribute?.id == urns.get('entity')) { // resource type found	103✔
56	logger.debug('Evaluating resource entity match');	64✔
57	entityOrOperation = attribute?.value;	64✔
58
59	let entitiesMatch = false;	64✔
60	// iterating request resources to filter all resources of a given type
61	for (let requestAttribute of reqTarget.resources \|\| []) {	64!
62	if (requestAttribute?.id == attribute?.id && requestAttribute?.value == entityOrOperation) {	258✔
63	entitiesMatch = true; // a resource entity that matches the request and the rule's target	64✔
64	} else if (requestAttribute?.id == attribute?.id) {	194✔
65	// rule entity, get ruleNS and entityRegexValue for rule
66	const value = entityOrOperation;	23✔
67	let pattern = value?.substring(value?.lastIndexOf(':') + 1);	23✔
68	let nsEntityArray = pattern?.split('.');	23✔
69	// firstElement could be either entity or namespace
70	let nsOrEntity = nsEntityArray[0];	23✔
71	let entityRegexValue = nsEntityArray[nsEntityArray.length - 1];	23✔
72	let reqNS, ruleNS;
73	if (nsOrEntity?.toUpperCase() != entityRegexValue?.toUpperCase()) {	23!
74	// rule name space is present
75	ruleNS = nsOrEntity?.toUpperCase();	×
76	}
77
78	// request entity, get reqNS and requestEntityValue for request
79	let reqValue = requestAttribute?.value;	23✔
80	const reqAttributeNS = reqValue?.substring(0, reqValue?.lastIndexOf(':'));	23✔
81	const ruleAttributeNS = value?.substring(0, value?.lastIndexOf(':'));	23✔
82	// verify namespace before entity name
83	if (reqAttributeNS != ruleAttributeNS) {	23!
84	entitiesMatch = false;	×
85	}
86	let reqPattern = reqValue?.substring(reqValue?.lastIndexOf(':') + 1);	23✔
87	let reqNSEntityArray = reqPattern?.split('.');	23✔
88	// firstElement could be either entity or namespace
89	let reqNSOrEntity = reqNSEntityArray[0];	23✔
90	let requestEntityValue = reqNSEntityArray[reqNSEntityArray.length - 1];	23✔
91	if (reqNSOrEntity?.toUpperCase() != requestEntityValue?.toUpperCase()) {	23!
92	// request name space is present
93	reqNS = reqNSOrEntity?.toUpperCase();	×
94	}
95
96	if ((reqNS && ruleNS && (reqNS === ruleNS)) \|\| (!reqNS && !ruleNS)) {	23!
97	const reExp = new RegExp(entityRegexValue);	23✔
98	if (requestEntityValue?.match(reExp)) {	23!
99	entitiesMatch = true;	×
100	}
101	}
102	}
103	else if (requestAttribute?.id == urns?.get('resourceID') && entitiesMatch) { // resource instance ID of a matching entity	171✔
104	const instanceID = requestAttribute?.value;	79✔
105	// found resource instance ID, iterating through the context to check if owners entities match the scoping entities
106	let ctxResource: Resource = _.find(ctxResources, ['instance.id', instanceID]);	79✔
107	if (ctxResource) {	79!
UNCOV 108	ctxResource = ctxResource?.instance;	×
109	} else {
110	// look up by ID
111	ctxResource = _.find(ctxResources, ['id', instanceID]);	79✔
112	}
113	if (ctxResource) {	79!
114	const meta = ctxResource.meta;	79✔
115	if (_.isEmpty(meta) \|\| _.isEmpty(meta.owners)) {	79!
116	logger.debug(`Owners information missing for hierarchical scope matching of entity ${attribute.value}, evaluation fails`);	×
117	return false; // no ownership was passed, evaluation fails	×
118	}
119	scopedRoles = updateScopedRoles(meta, scopedRoles, urns, totalScopingEntities);	79✔
120	} else {
121	logger.debug('Resource of targeted entity was not provided in context');	×
122	return false; // resource of targeted entity was not provided in context	×
123	}
124	}
125	}
126	} else if (attribute?.id === urns.get('operation')) {	39✔
127	logger.debug('Evaluating resource operation match');	5✔
128	entityOrOperation = attribute?.value;	5✔
129	for (let reqAttribute of reqTarget.resources \|\| []) {	5!
130	// match Rule resource operation URN and operation name with request resource operation URN and operation name
131	if (reqAttribute?.id === attribute?.id && reqAttribute?.value === attribute?.value) {	9✔
132	// find context resource based
133	let ctxResource: Resource = _.find(ctxResources, ['id', entityOrOperation]);	5✔
134	if (ctxResource) {	5!
135	const meta = ctxResource.meta;	5✔
136	if (_.isEmpty(meta) \|\| _.isEmpty(meta.owners)) {	5!
NEW 137	logger.debug(`Owners information missing for hierarchical scope matching of entity ${attribute.value}, evaluation fails`);	×
138	return false; // no ownership was passed, evaluation fails	×
139	}
140	scopedRoles = updateScopedRoles(meta, scopedRoles, urns, totalScopingEntities);	5✔
141	} else {
NEW 142	logger.debug('Operation name was not provided in context');	×
NEW 143	return false; // Operation name was not provided in context	×
144	}
145	}
146	}
147	}
148	}
149
150	if (_.isNil(entityOrOperation) \|\| _.isEmpty(entityOrOperation)) {	69!
151	logger.debug('No Entity or operation name found');	×
152	return false; // no entity found	×
153	}
154
155	// check if context subject_id contains HR scope if not make request 'createHierarchicalScopes'
156	if (context?.subject?.token && _.isEmpty(context.subject.hierarchical_scopes)) {	69!
157	context = await accessController.createHRScope(context);	×
158	}
159
160	const roleAssociations = context?.subject?.role_associations;	69✔
161	if (_.isEmpty(roleAssociations)) {	69!
162	logger.debug('Role Associations not found');	×
163	return false; // impossible to evaluate context	×
164	}
165	const treeNodes = new Map<string, Map<string, string[]>>(); // <role, <entity, hierarchicalTreeNodes>>	69✔
166
167	for (let i = 0; i < roleAssociations.length; i += 1) {	69✔
168	const role: string = roleAssociations[i].role;	69✔
169	const attributes: Attribute[] = roleAssociations[i].attributes \|\| [];	69!
170
171	if (scopedRoles.has(role)) {	69!
172	const entities = scopedRoles.get(role);	69✔
173	let scopingEntity: string;
174	// let roleSubNodes = []; // sub nodes to be queried in case hierarchical resource is not found
175	for (let attribute of attributes) {	69✔
176	if (attribute.id == urns.get('roleScopingEntity') && entities.has(attribute.value)) {	69!
177	scopingEntity = attribute.value;	69✔
178	if (attribute?.attributes?.length > 0) {	69!
179	for (let roleScopeInstObj of attribute.attributes) { // role-attributes-attributes -> roleScopingInstance	69✔
180	if (roleScopeInstObj.id == urns.get('roleScopingInstance') && !!scopingEntity) { // if scoping instance is found within the attributes	71!
181	const instances = entities.get(scopingEntity);	71✔
182	if (!_.isEmpty(_.remove(instances, i => i == roleScopeInstObj.value))) { // if any element was removed	85✔
183	if (_.isEmpty(instances)) {	46✔
184	entities.delete(scopingEntity);	45✔
185	if (entities.size == 0) {	45!
186	scopedRoles.delete(role);	45✔
187	}
188	}
189	} else {
190	if (!treeNodes.has(role)) {	25!
191	treeNodes.set(role, new Map<string, string[]>());	25✔
192	}
193	const nodesByEntity = treeNodes.get(role);	25✔
194	if (!nodesByEntity.has(scopingEntity)) {	25!
195	nodesByEntity.set(scopingEntity, []);	25✔
196	}
197	const nodes = nodesByEntity.get(scopingEntity);	25✔
198	nodes.push(roleScopeInstObj.value);	25✔
199	nodesByEntity.set(scopingEntity, nodes);	25✔
200	treeNodes.set(role, nodesByEntity);	25✔
201	}
202	}
203	}
204	}
205	}
206	}
207	}
208	else {
209	if (i == roleAssociations.length - 1 && scopedRoles.size > 0 && treeNodes.size === 0) {	×
210	logger.debug('Subject does not have one of the required roles in its context');	×
211	return false; // user does not have one of the required roles in its context	×
212	}
213	}
214	}
215
216	let check = scopedRoles.size == 0;	69✔
217	if (!check && hierarchicalRoleScopeCheck && hierarchicalRoleScopeCheck === 'true') {	69✔
218	const hierarchicalScopes = context.subject.hierarchical_scopes;	24✔
219	for (let hierarchicalScope of hierarchicalScopes) {	24✔
220	let subTreeRole = null;	24✔
221	let level = -1;	24✔
222	traverse(hierarchicalScope).forEach(function (node: any): void { // depth-first search	24✔
223	let subtreeFound = false;	90✔
224	if (!!node.id) {	90✔
225	if (level > -1 && this.level >= level) {	42!
226	subTreeRole = null;	×
227	level = -1;	×
228	} else {
229	if (!subTreeRole) {	42✔
230	for (let [role, nodes] of treeNodes) {	34✔
231	for (let [, instances] of nodes) {	30✔
232	if (_.includes(instances, node.id)) {	30✔
233	subTreeRole = role;	23✔
234	subtreeFound = true;	23✔
235	break;	23✔
236	}
237	}
238	}
239	}
240	if (subtreeFound) {	42✔
241	const entities = scopedRoles.get(subTreeRole);	23✔
242	let eligibleOrgScopes = [];	23✔
243	getAllValues(node, eligibleOrgScopes);	23✔
244	if (entities) {	23!
245	for (let [entity, instances] of entities) {	23✔
246	for (let instance of instances) {	23✔
247	if (eligibleOrgScopes.indexOf(instance) > -1) {	26✔
248	instances = instances.filter(e => e != instance);	24✔
249	}
250	}
251	if (instances.length === 0) {	23✔
252	entities.delete(entity);	18✔
253	break;	18✔
254	}
255	}
256	}
257	if (entities && entities.size == 0) {	23✔
258	scopedRoles.delete(subTreeRole);	18✔
259	if (scopedRoles.size == 0) {	18!
260	check = true;	18✔
261	this.stop(); // stopping traversal, no more scoped roles need to be checked	18✔
262	}
263	}
264	// inside hierarchical sub
265	}
266	}
267	}
268	});
269	}
270	}
271
272	return check;	69✔
273	};

restorecommerce / access-control-srv / 6945749690

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