Return the path to the entity collection endpoint

@param entity
name
@param customer
group id
@return collection endpoint
422228
public String getCollectionEndpoint(String entityName, String groupId) {
		return connec.getBasePath() + "/" + groupId + "/" + entityName;
	}
534322
@Override
  public <T> T findById(Object id, Class<T> entityClass) {
    return findById(id, Util.determineCollectionName(entityClass));
  }
872536
public OvhInstanceGroup project_serviceName_instance_group_groupId_GET(String serviceName, String groupId, String region) throws IOException {
		String qPath = "/cloud/project/{serviceName}/instance/group/{groupId}";
		StringBuilder sb = path(qPath, serviceName, groupId);
		query(sb, "region", region);
		String resp = exec(qPath, "GET", sb.toString(), null);
		return convertTo(resp, OvhInstanceGroup.class);
	}
1189102
@SuppressWarnings("unchecked")
    @Override
    public Set<JsonEntityBean> search(String entityType, String searchTerm) {

        Set<JsonEntityBean> results = new HashSet<>();

        EntityEnum entityEnum = EntityEnum.getEntityEnum(entityType);
        if (entityEnum == null) {
            throw new IllegalArgumentException(
                    String.format("Parameter entityType has an unknown value of [%s]", entityType));
        }

        EntityIdentifier[] identifiers;

        Class identifierType;

        // if the entity type is a group, use the group service's findGroup method
        // to locate it
        if (entityEnum.isGroup()) {
            identifiers =
                    GroupService.searchForGroups(
                            searchTerm,
                            GroupService.SearchMethod.CONTAINS_CI,
                            entityEnum.getClazz());
            identifierType = IEntityGroup.class;
        }

        // otherwise use the getGroupMember method
        else {
            identifiers =
                    GroupService.searchForEntities(
                            searchTerm,
                            GroupService.SearchMethod.CONTAINS_CI,
                            entityEnum.getClazz());
            identifierType = entityEnum.getClazz();
        }

        for (int i = 0; i < identifiers.length; i++) {
            if (identifiers[i].getType().equals(identifierType)) {
                IGroupMember entity = GroupService.getGroupMember(identifiers[i]);
                if (entity != null) {
                    JsonEntityBean jsonBean = getEntity(entity);
                    results.add(jsonBean);
                } else {
                    log.warn("Grouper member entity of " + identifiers[i].getKey() + " is null.");
                }
            }
        }

        return results;
    }
331139
@Override
	public List<CommerceShipment> findByGroupId(long groupId) {
		return findByGroupId(groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
	}
563741
public static Endpoint selectNode(ClientRequestContext ctx, String groupName) {
        groupName = normalizeGroupName(groupName);
        final EndpointSelector endpointSelector = getNodeSelector(groupName);
        if (endpointSelector == null) {
            throw new EndpointGroupException("non-existent EndpointGroup: " + groupName);
        }

        return endpointSelector.select(ctx);
    }
993346
public Map<String, Object> retrieve(String entityName, String groupId, String entityId) throws MnoException {
		return retrieve(entityName, groupId, entityId, getAuthenticatedClient());
	}
34069
@Override
    public IEntityGroup findGroup(String key) throws GroupsException {
        CompositeEntityIdentifier ent = newCompositeEntityIdentifier(key);
        IIndividualGroupService service = getComponentService(ent);
        return (service == null) ? null : service.findGroup(ent);
    }
777968
def environment_session_entity_type_path(cls, project, environment, user,
                                             session, entity_type):
        """"""
        return google.api_core.path_template.expand(
            'projects/{project}/agent/environments/{environment}/users/{user}/sessions/{session}/entityTypes/{entity_type}',
            project=project,
            environment=environment,
            user=user,
            session=session,
            entity_type=entity_type,
        )
362246
@Override
	public CommerceRegion getCommerceRegionByUuidAndGroupId(String uuid,
		long groupId) throws PortalException {
		return commerceRegionPersistence.findByUUID_G(uuid, groupId);
	}
186856
function findCollectionName(entityName) {
    var xrmInternal = Utility.getXrmInternal();
    if (!Utility.isNull(xrmInternal)) {
        return xrmInternal.getEntitySetName(entityName) || entityName;
    }

    var collectionName = null;

    if (!Utility.isNull(_entityNames)) {
        collectionName = _entityNames[entityName];
        if (Utility.isNull(collectionName)) {
            for (var key in _entityNames) {
                if (_entityNames[key] == entityName) {
                    return entityName;
                }
            }
        }
    }

    return collectionName;
}
1313892
public String getInstanceUrl(String entityName, String groupId, String id) {
		return connec.getHost() + getInstanceEndpoint(entityName, groupId, id);
	}
441210
Node getGroupNode(Session session, Group group) throws PathNotFoundException, RepositoryException
   {
      return getGroupNode(session, group == null ? "" : group.getId());
   }
1179002
public GroupEntity findGroupById(String groupId) {
    checkAuthorization(Permissions.READ, Resources.GROUP, groupId);
    return getDbEntityManager().selectById(GroupEntity.class, groupId);
  }
914292
@Override
    public IGroupMember getGroupMember(EntityIdentifier underlyingEntityIdentifier)
            throws GroupsException {
        return getGroupMember(
                underlyingEntityIdentifier.getKey(), underlyingEntityIdentifier.getType());
    }
864532
@Override
	public com.liferay.commerce.model.CommerceRegion fetchCommerceRegionByUuidAndGroupId(
		String uuid, long groupId) {
		return _commerceRegionLocalService.fetchCommerceRegionByUuidAndGroupId(uuid,
			groupId);
	}
588026
@RequestMapping(value = "/{id}", method = RequestMethod.GET)
    public ResponseEntity<E> findById(@PathVariable Integer id) {

        try {
            E entity = this.service.findById(id);
            LOG.trace("Found " + entity.getClass().getSimpleName()
                + " with ID " + entity.getId());
            return new ResponseEntity<E>(entity, HttpStatus.OK);
        } catch (Exception e) {
            LOG.error("Error finding entity with id " + id + ": "
                + e.getMessage());
            return new ResponseEntity<E>(HttpStatus.NOT_FOUND);
        }
    }