Skip to content
[Jenkins]Jenkins
log in

Package: DeviceConnectionOptionServiceImpl

DeviceConnectionOptionServiceImpl

nameinstructionbranchcomplexitylinemethod
DeviceConnectionOptionServiceImpl()
M: 4 C: 0
0%
M: 0 C: 0
100%
M: 1 C: 0
0%
M: 2 C: 0
0%
M: 1 C: 0
0%
count(KapuaQuery)
M: 31 C: 0
0%
M: 0 C: 0
100%
M: 1 C: 0
0%
M: 6 C: 0
0%
M: 1 C: 0
0%
create(DeviceConnectionOptionCreator)
M: 5 C: 0
0%
M: 0 C: 0
100%
M: 1 C: 0
0%
M: 1 C: 0
0%
M: 1 C: 0
0%
delete(KapuaId, KapuaId)
M: 5 C: 0
0%
M: 0 C: 0
100%
M: 1 C: 0
0%
M: 1 C: 0
0%
M: 1 C: 0
0%
find(KapuaId, KapuaId)
M: 33 C: 0
0%
M: 0 C: 0
100%
M: 1 C: 0
0%
M: 7 C: 0
0%
M: 1 C: 0
0%
lambda$count$3(KapuaQuery, EntityManager)
M: 5 C: 0
0%
M: 0 C: 0
100%
M: 1 C: 0
0%
M: 1 C: 0
0%
M: 1 C: 0
0%
lambda$find$1(KapuaId, KapuaId, EntityManager)
M: 5 C: 0
0%
M: 0 C: 0
100%
M: 1 C: 0
0%
M: 1 C: 0
0%
M: 1 C: 0
0%
lambda$query$2(KapuaQuery, EntityManager)
M: 4 C: 0
0%
M: 0 C: 0
100%
M: 1 C: 0
0%
M: 1 C: 0
0%
M: 1 C: 0
0%
lambda$update$0(DeviceConnectionOption, EntityManager)
M: 18 C: 0
0%
M: 2 C: 0
0%
M: 2 C: 0
0%
M: 3 C: 0
0%
M: 1 C: 0
0%
query(KapuaQuery)
M: 30 C: 0
0%
M: 0 C: 0
100%
M: 1 C: 0
0%
M: 6 C: 0
0%
M: 1 C: 0
0%
update(DeviceConnectionOption)
M: 93 C: 0
0%
M: 4 C: 0
0%
M: 3 C: 0
0%
M: 17 C: 0
0%
M: 1 C: 0
0%

Coverage

1: /*******************************************************************************
2: * Copyright (c) 2016, 2022 Eurotech and/or its affiliates and others
3: *
4: * This program and the accompanying materials are made
5: * available under the terms of the Eclipse Public License 2.0
6: * which is available at https://www.eclipse.org/legal/epl-2.0/
7: *
8: * SPDX-License-Identifier: EPL-2.0
9: *
10: * Contributors:
11: * Eurotech - initial API and implementation
12: *******************************************************************************/
13: package org.eclipse.kapua.service.device.registry.connection.option.internal;
14:
15: import org.eclipse.kapua.KapuaEntityNotFoundException;
16: import org.eclipse.kapua.KapuaException;
17: import org.eclipse.kapua.KapuaRuntimeErrorCodes;
18: import org.eclipse.kapua.KapuaRuntimeException;
19: import org.eclipse.kapua.commons.service.internal.AbstractKapuaService;
20: import org.eclipse.kapua.commons.util.ArgumentValidator;
21: import org.eclipse.kapua.locator.KapuaLocator;
22: import org.eclipse.kapua.locator.KapuaProvider;
23: import org.eclipse.kapua.model.domain.Actions;
24: import org.eclipse.kapua.model.id.KapuaId;
25: import org.eclipse.kapua.model.query.KapuaQuery;
26: import org.eclipse.kapua.model.query.predicate.AndPredicate;
27: import org.eclipse.kapua.model.query.predicate.AttributePredicate.Operator;
28: import org.eclipse.kapua.service.authorization.AuthorizationService;
29: import org.eclipse.kapua.service.authorization.permission.PermissionFactory;
30: import org.eclipse.kapua.service.device.registry.DeviceDomains;
31: import org.eclipse.kapua.service.device.registry.connection.DeviceConnectionAttributes;
32: import org.eclipse.kapua.service.device.registry.connection.DeviceConnectionQuery;
33: import org.eclipse.kapua.service.device.registry.connection.DeviceConnectionService;
34: import org.eclipse.kapua.service.device.registry.connection.internal.DeviceConnectionQueryImpl;
35: import org.eclipse.kapua.service.device.registry.connection.option.DeviceConnectionOption;
36: import org.eclipse.kapua.service.device.registry.connection.option.DeviceConnectionOptionCreator;
37: import org.eclipse.kapua.service.device.registry.connection.option.DeviceConnectionOptionListResult;
38: import org.eclipse.kapua.service.device.registry.connection.option.DeviceConnectionOptionService;
39: import org.eclipse.kapua.service.device.registry.connection.option.UserAlreadyReservedException;
40: import org.eclipse.kapua.service.device.registry.internal.DeviceEntityManagerFactory;
41:
42: /**
43: * DeviceConnectionService exposes APIs to retrieve Device connections under a scope.
44: * It includes APIs to find, list, and update devices connections associated with a scope.
45: *
46: * @since 1.0
47: */
48: @KapuaProvider
49: public class DeviceConnectionOptionServiceImpl extends AbstractKapuaService implements DeviceConnectionOptionService {
50:
51: public DeviceConnectionOptionServiceImpl() {
52: super(DeviceEntityManagerFactory.instance());
53: }
54:
55: @Override
56: public DeviceConnectionOption create(DeviceConnectionOptionCreator deviceConnectionCreator)
57: throws KapuaException {
58: throw new KapuaRuntimeException(KapuaRuntimeErrorCodes.SERVICE_OPERATION_NOT_SUPPORTED);
59: }
60:
61: @Override
62: public DeviceConnectionOption update(DeviceConnectionOption deviceConnectionOptions)
63: throws KapuaException {
64: //
65: // Argument Validation
66: ArgumentValidator.notNull(deviceConnectionOptions, "deviceConnection");
67: ArgumentValidator.notNull(deviceConnectionOptions.getId(), "deviceConnection.id");
68: ArgumentValidator.notNull(deviceConnectionOptions.getScopeId(), "deviceConnection.scopeId");
69:
70: //
71: // Check Access
72: KapuaLocator locator = KapuaLocator.getInstance();
73: DeviceConnectionService deviceConnectionService = locator.getService(DeviceConnectionService.class);
74: AuthorizationService authorizationService = locator.getService(AuthorizationService.class);
75: PermissionFactory permissionFactory = locator.getFactory(PermissionFactory.class);
76: authorizationService.checkPermission(permissionFactory.newPermission(DeviceDomains.DEVICE_CONNECTION_DOMAIN, Actions.write, deviceConnectionOptions.getScopeId()));
77:
78:• if (deviceConnectionOptions.getReservedUserId() != null) {
79: DeviceConnectionQuery query = new DeviceConnectionQueryImpl(deviceConnectionOptions.getScopeId());
80:
81: AndPredicate deviceAndPredicate = query.andPredicate(
82: query.attributePredicate(DeviceConnectionAttributes.RESERVED_USER_ID, deviceConnectionOptions.getReservedUserId()),
83: query.attributePredicate(DeviceConnectionAttributes.ENTITY_ID, deviceConnectionOptions.getId(), Operator.NOT_EQUAL)
84: );
85:
86: query.setPredicate(deviceAndPredicate);
87:• if (deviceConnectionService.count(query) > 0) {
88: throw new UserAlreadyReservedException(deviceConnectionOptions.getScopeId(), deviceConnectionOptions.getId(), deviceConnectionOptions.getReservedUserId());
89: }
90: }
91:
92: return entityManagerSession.doTransactedAction(em -> {
93:• if (DeviceConnectionOptionDAO.find(em, deviceConnectionOptions.getScopeId(), deviceConnectionOptions.getId()) == null) {
94: throw new KapuaEntityNotFoundException(DeviceConnectionOption.TYPE, deviceConnectionOptions.getId());
95: }
96:
97: return DeviceConnectionOptionDAO.update(em, deviceConnectionOptions);
98: });
99: }
100:
101: @Override
102: public DeviceConnectionOption find(KapuaId scopeId, KapuaId entityId)
103: throws KapuaException {
104: //
105: // Argument Validation
106: ArgumentValidator.notNull(scopeId, "scopeId");
107: ArgumentValidator.notNull(entityId, "entityId");
108:
109: //
110: // Check Access
111: KapuaLocator locator = KapuaLocator.getInstance();
112: AuthorizationService authorizationService = locator.getService(AuthorizationService.class);
113: PermissionFactory permissionFactory = locator.getFactory(PermissionFactory.class);
114: authorizationService.checkPermission(permissionFactory.newPermission(DeviceDomains.DEVICE_CONNECTION_DOMAIN, Actions.read, scopeId));
115:
116: return entityManagerSession.doAction(em -> DeviceConnectionOptionDAO.find(em, scopeId, entityId));
117: }
118:
119: @Override
120: public DeviceConnectionOptionListResult query(KapuaQuery query)
121: throws KapuaException {
122: //
123: // Argument Validation
124: ArgumentValidator.notNull(query, "query");
125:
126: //
127: // Check Access
128: KapuaLocator locator = KapuaLocator.getInstance();
129: AuthorizationService authorizationService = locator.getService(AuthorizationService.class);
130: PermissionFactory permissionFactory = locator.getFactory(PermissionFactory.class);
131: authorizationService.checkPermission(permissionFactory.newPermission(DeviceDomains.DEVICE_CONNECTION_DOMAIN, Actions.read, query.getScopeId()));
132:
133: return entityManagerSession.doAction(em -> DeviceConnectionOptionDAO.query(em, query));
134: }
135:
136: @Override
137: public long count(KapuaQuery query)
138: throws KapuaException {
139: //
140: // Argument Validation
141: ArgumentValidator.notNull(query, "query");
142:
143: //
144: // Check Access
145: KapuaLocator locator = KapuaLocator.getInstance();
146: AuthorizationService authorizationService = locator.getService(AuthorizationService.class);
147: PermissionFactory permissionFactory = locator.getFactory(PermissionFactory.class);
148: authorizationService.checkPermission(permissionFactory.newPermission(DeviceDomains.DEVICE_CONNECTION_DOMAIN, Actions.read, query.getScopeId()));
149:
150: return entityManagerSession.doAction(em -> DeviceConnectionOptionDAO.count(em, query));
151: }
152:
153: @Override
154: public void delete(KapuaId scopeId, KapuaId deviceConnectionOptionsId)
155: throws KapuaException {
156: throw new KapuaRuntimeException(KapuaRuntimeErrorCodes.SERVICE_OPERATION_NOT_SUPPORTED);
157: }
158: }