pahansith
/
product-iots
forked from community/product-iots
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Connected cup issues with url generation fixed

Browse Source
application-manager-new
Menaka Madushanka 9 years ago
parent 5770ecab2f 3f9e279188
commit 41bfb96fe2
9 changed files with 428 additions and 357 deletions
Show Stats Download Patch File Download Diff File

1
modules/samples/connectedcup/component/plugin/src/main/java/org/coffeeking/connectedcup/plugin/constants/ConnectedCupConstants.java
Unescape View File

@ -18,5 +18,6 @@ public class ConnectedCupConstants {
public static final String SENSOR_TEMPERATURE = "temperature"; public static final String SENSOR_TEMPERATURE = "temperature";
public static final String SENSOR_LEVEL = "level"; public static final String SENSOR_LEVEL = "level";
public static final String DATA_SOURCE_NAME = "jdbc/ConnectedCupDM_DB";
} }

56
modules/samples/connectedcup/component/plugin/src/main/java/org/coffeeking/connectedcup/plugin/exception/ConnectedCupDeviceMgtPluginException.java
Unescape View File

@ -0,0 +1,56 @@
/*
* Copyright (c) 2015, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.coffeeking.connectedcup.plugin.exception;
public class ConnectedCupDeviceMgtPluginException extends Exception{
private String errorMessage;
public String getErrorMessage() {
return errorMessage;
}
public void setErrorMessage(String errorMessage) {
this.errorMessage = errorMessage;
}
public ConnectedCupDeviceMgtPluginException(String msg, Exception nestedEx) {
super(msg, nestedEx);
setErrorMessage(msg);
}
public ConnectedCupDeviceMgtPluginException(String message, Throwable cause) {
super(message, cause);
setErrorMessage(message);
}
public ConnectedCupDeviceMgtPluginException(String msg) {
super(msg);
setErrorMessage(msg);
}
public ConnectedCupDeviceMgtPluginException() {
super();
}
public ConnectedCupDeviceMgtPluginException(Throwable cause) {
super(cause);
}
}

64
modules/samples/connectedcup/component/plugin/src/main/java/org/coffeeking/connectedcup/plugin/impl/ConnectedCupManager.java
Unescape View File

@ -21,6 +21,7 @@ package org.coffeeking.connectedcup.plugin.impl;
import org.apache.commons.logging.Log; import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory; import org.apache.commons.logging.LogFactory;
import org.coffeeking.connectedcup.plugin.exception.ConnectedCupDeviceMgtPluginException;
import org.coffeeking.connectedcup.plugin.impl.dao.ConnectedCupDAO; import org.coffeeking.connectedcup.plugin.impl.dao.ConnectedCupDAO;
import org.wso2.carbon.device.mgt.common.Device; import org.wso2.carbon.device.mgt.common.Device;
import org.wso2.carbon.device.mgt.common.DeviceIdentifier; import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
@ -31,12 +32,6 @@ import org.wso2.carbon.device.mgt.common.FeatureManager;
import org.wso2.carbon.device.mgt.common.configuration.mgt.TenantConfiguration; import org.wso2.carbon.device.mgt.common.configuration.mgt.TenantConfiguration;
import org.wso2.carbon.device.mgt.common.license.mgt.License; import org.wso2.carbon.device.mgt.common.license.mgt.License;
import org.wso2.carbon.device.mgt.common.license.mgt.LicenseManagementException; import org.wso2.carbon.device.mgt.common.license.mgt.LicenseManagementException;
import org.wso2.carbon.device.mgt.iot.util.iotdevice.dao.IotDeviceManagementDAOException;
import org.wso2.carbon.device.mgt.iot.util.iotdevice.dao.IotDeviceManagementDAOFactory;
import org.wso2.carbon.device.mgt.iot.util.iotdevice.dto.IotDevice;
import org.wso2.carbon.device.mgt.iot.util.iotdevice.util.IotDeviceManagementUtil;
import java.util.ArrayList;
import java.util.List; import java.util.List;
@ -47,7 +42,7 @@ public class ConnectedCupManager implements DeviceManager {
private static final Log log = LogFactory.getLog(ConnectedCupManager.class); private static final Log log = LogFactory.getLog(ConnectedCupManager.class);
private static final IotDeviceManagementDAOFactory iotDeviceManagementDAOFactory = new ConnectedCupDAO(); private static final ConnectedCupDAO connectedCupDAO = new ConnectedCupDAO();
@Override @Override
public FeatureManager getFeatureManager() { public FeatureManager getFeatureManager() {
@ -70,19 +65,17 @@ public class ConnectedCupManager implements DeviceManager {
@Override @Override
public boolean enrollDevice(Device device) throws DeviceManagementException { public boolean enrollDevice(Device device) throws DeviceManagementException {
boolean status; boolean status;
IotDevice iotDevice = IotDeviceManagementUtil.convertToIotDevice(device);
try { try {
if (log.isDebugEnabled()) { if (log.isDebugEnabled()) {
log.debug("Enrolling a new Connected Cup device : " + device.getDeviceIdentifier()); log.debug("Enrolling a new Connected Cup device : " + device.getDeviceIdentifier());
} }
ConnectedCupDAO.beginTransaction(); ConnectedCupDAO.beginTransaction();
status = iotDeviceManagementDAOFactory.getIotDeviceDAO().addIotDevice( status = connectedCupDAO.getConnectedCupDeviceDAO().addDevice(device);
iotDevice);
ConnectedCupDAO.commitTransaction(); ConnectedCupDAO.commitTransaction();
} catch (IotDeviceManagementDAOException e) { } catch (ConnectedCupDeviceMgtPluginException e) {
try { try {
ConnectedCupDAO.rollbackTransaction(); ConnectedCupDAO.rollbackTransaction();
} catch (IotDeviceManagementDAOException iotDAOEx) { } catch (ConnectedCupDeviceMgtPluginException iotDAOEx) {
String msg = "Error occurred while roll back the device enrol transaction :" + device.toString(); String msg = "Error occurred while roll back the device enrol transaction :" + device.toString();
log.warn(msg, iotDAOEx); log.warn(msg, iotDAOEx);
} }
@ -96,19 +89,17 @@ public class ConnectedCupManager implements DeviceManager {
@Override @Override
public boolean modifyEnrollment(Device device) throws DeviceManagementException { public boolean modifyEnrollment(Device device) throws DeviceManagementException {
boolean status; boolean status;
IotDevice iotDevice = IotDeviceManagementUtil.convertToIotDevice(device);
try { try {
if (log.isDebugEnabled()) { if (log.isDebugEnabled()) {
log.debug("Modifying the Connected Cup device enrollment data"); log.debug("Modifying the Connected Cup device enrollment data");
} }
ConnectedCupDAO.beginTransaction(); ConnectedCupDAO.beginTransaction();
status = iotDeviceManagementDAOFactory.getIotDeviceDAO() status = connectedCupDAO.getConnectedCupDeviceDAO().updateDevice(device);
.updateIotDevice(iotDevice);
ConnectedCupDAO.commitTransaction(); ConnectedCupDAO.commitTransaction();
} catch (IotDeviceManagementDAOException e) { } catch (ConnectedCupDeviceMgtPluginException e) {
try { try {
ConnectedCupDAO.rollbackTransaction(); ConnectedCupDAO.rollbackTransaction();
} catch (IotDeviceManagementDAOException iotDAOEx) { } catch (ConnectedCupDeviceMgtPluginException iotDAOEx) {
String msg = "Error occurred while roll back the update device transaction :" + device.toString(); String msg = "Error occurred while roll back the update device transaction :" + device.toString();
log.warn(msg, iotDAOEx); log.warn(msg, iotDAOEx);
} }
@ -128,13 +119,12 @@ public class ConnectedCupManager implements DeviceManager {
log.debug("Dis-enrolling Connected Cup device : " + deviceId); log.debug("Dis-enrolling Connected Cup device : " + deviceId);
} }
ConnectedCupDAO.beginTransaction(); ConnectedCupDAO.beginTransaction();
status = iotDeviceManagementDAOFactory.getIotDeviceDAO() status = connectedCupDAO.getConnectedCupDeviceDAO().deleteDevice(deviceId.getId());
.deleteIotDevice(deviceId.getId());
ConnectedCupDAO.commitTransaction(); ConnectedCupDAO.commitTransaction();
} catch (IotDeviceManagementDAOException e) { } catch (ConnectedCupDeviceMgtPluginException e) {
try { try {
ConnectedCupDAO.rollbackTransaction(); ConnectedCupDAO.rollbackTransaction();
} catch (IotDeviceManagementDAOException iotDAOEx) { } catch (ConnectedCupDeviceMgtPluginException iotDAOEx) {
String msg = "Error occurred while roll back the device dis enrol transaction :" + deviceId.toString(); String msg = "Error occurred while roll back the device dis enrol transaction :" + deviceId.toString();
log.warn(msg, iotDAOEx); log.warn(msg, iotDAOEx);
} }
@ -152,13 +142,11 @@ public class ConnectedCupManager implements DeviceManager {
if (log.isDebugEnabled()) { if (log.isDebugEnabled()) {
log.debug("Checking the enrollment of Connected Cup device : " + deviceId.getId()); log.debug("Checking the enrollment of Connected Cup device : " + deviceId.getId());
} }
IotDevice iotDevice = Device iotDevice = connectedCupDAO.getConnectedCupDeviceDAO().getDevice(deviceId.getId());
iotDeviceManagementDAOFactory.getIotDeviceDAO().getIotDevice(
deviceId.getId());
if (iotDevice != null) { if (iotDevice != null) {
isEnrolled = true; isEnrolled = true;
} }
} catch (IotDeviceManagementDAOException e) { } catch (ConnectedCupDeviceMgtPluginException e) {
String msg = "Error while checking the enrollment status of Connected Cup device : " + String msg = "Error while checking the enrollment status of Connected Cup device : " +
deviceId.getId(); deviceId.getId();
log.error(msg, e); log.error(msg, e);
@ -184,10 +172,9 @@ public class ConnectedCupManager implements DeviceManager {
try {if (log.isDebugEnabled()) { try {if (log.isDebugEnabled()) {
log.debug("Getting the details of Connected Cup device : " + deviceId.getId()); log.debug("Getting the details of Connected Cup device : " + deviceId.getId());
} }
IotDevice iotDevice = iotDeviceManagementDAOFactory.getIotDeviceDAO(). device = connectedCupDAO.getConnectedCupDeviceDAO().getDevice(deviceId.getId());
getIotDevice(deviceId.getId());
device = IotDeviceManagementUtil.convertToDevice(iotDevice); } catch (ConnectedCupDeviceMgtPluginException e) {
} catch (IotDeviceManagementDAOException e) {
String msg = "Error while fetching the Connected Cup device : " + deviceId.getId(); String msg = "Error while fetching the Connected Cup device : " + deviceId.getId();
log.error(msg, e); log.error(msg, e);
throw new DeviceManagementException(msg, e); throw new DeviceManagementException(msg, e);
@ -229,20 +216,18 @@ public class ConnectedCupManager implements DeviceManager {
@Override @Override
public boolean updateDeviceInfo(DeviceIdentifier deviceIdentifier, Device device) throws DeviceManagementException { public boolean updateDeviceInfo(DeviceIdentifier deviceIdentifier, Device device) throws DeviceManagementException {
boolean status; boolean status;
IotDevice iotDevice = IotDeviceManagementUtil.convertToIotDevice(device);
try { try {
if (log.isDebugEnabled()) { if (log.isDebugEnabled()) {
log.debug( log.debug(
"updating the details of Connected Cup device : " + deviceIdentifier); "updating the details of Connected Cup device : " + deviceIdentifier);
} }
ConnectedCupDAO.beginTransaction(); ConnectedCupDAO.beginTransaction();
status = iotDeviceManagementDAOFactory.getIotDeviceDAO() status = connectedCupDAO.getConnectedCupDeviceDAO().updateDevice(device);
.updateIotDevice(iotDevice);
ConnectedCupDAO.commitTransaction(); ConnectedCupDAO.commitTransaction();
} catch (IotDeviceManagementDAOException e) { } catch (ConnectedCupDeviceMgtPluginException e) {
try { try {
ConnectedCupDAO.rollbackTransaction(); ConnectedCupDAO.rollbackTransaction();
} catch (IotDeviceManagementDAOException iotDAOEx) { } catch (ConnectedCupDeviceMgtPluginException iotDAOEx) {
String msg = "Error occurred while roll back the update device info transaction :" + device.toString(); String msg = "Error occurred while roll back the update device info transaction :" + device.toString();
log.warn(msg, iotDAOEx); log.warn(msg, iotDAOEx);
} }
@ -261,15 +246,8 @@ public class ConnectedCupManager implements DeviceManager {
if (log.isDebugEnabled()) { if (log.isDebugEnabled()) {
log.debug("Fetching the details of all Connected Cup devices"); log.debug("Fetching the details of all Connected Cup devices");
} }
List<IotDevice> iotDevices = devices = connectedCupDAO.getConnectedCupDeviceDAO().getAllDevices();
iotDeviceManagementDAOFactory.getIotDeviceDAO().getAllIotDevices(); } catch (ConnectedCupDeviceMgtPluginException e) {
if (iotDevices != null) {
devices = new ArrayList<Device>();
for (IotDevice iotDevice : iotDevices) {
devices.add(IotDeviceManagementUtil.convertToDevice(iotDevice));
}
}
} catch (IotDeviceManagementDAOException e) {
String msg = "Error while fetching all Connected Cup devices."; String msg = "Error while fetching all Connected Cup devices.";
log.error(msg, e); log.error(msg, e);
throw new DeviceManagementException(msg, e); throw new DeviceManagementException(msg, e);

4
modules/samples/connectedcup/component/plugin/src/main/java/org/coffeeking/connectedcup/plugin/impl/ConnectedCupManagerService.java
Unescape View File

@ -18,6 +18,7 @@
package org.coffeeking.connectedcup.plugin.impl; package org.coffeeking.connectedcup.plugin.impl;
import org.coffeeking.connectedcup.plugin.constants.ConnectedCupConstants;
import org.wso2.carbon.device.mgt.common.DeviceIdentifier; import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
import org.wso2.carbon.device.mgt.common.DeviceManagementException; import org.wso2.carbon.device.mgt.common.DeviceManagementException;
import org.wso2.carbon.device.mgt.common.DeviceManager; import org.wso2.carbon.device.mgt.common.DeviceManager;
@ -34,8 +35,7 @@ public class ConnectedCupManagerService implements DeviceManagementService{
@Override @Override
public String getType() { public String getType() {
return "connectedcup"; return ConnectedCupConstants.DEVICE_TYPE;
//TODO: Constant
} }

176
modules/samples/connectedcup/component/plugin/src/main/java/org/coffeeking/connectedcup/plugin/impl/dao/ConnectedCupDAO.java
Unescape View File

@ -21,102 +21,112 @@ package org.coffeeking.connectedcup.plugin.impl.dao;
import org.apache.commons.logging.Log; import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory; import org.apache.commons.logging.LogFactory;
import org.coffeeking.connectedcup.plugin.constants.ConnectedCupConstants; import org.coffeeking.connectedcup.plugin.constants.ConnectedCupConstants;
import org.coffeeking.connectedcup.plugin.exception.ConnectedCupDeviceMgtPluginException;
import org.coffeeking.connectedcup.plugin.impl.dao.impl.ConnectedCupDAOImpl; import org.coffeeking.connectedcup.plugin.impl.dao.impl.ConnectedCupDAOImpl;
import org.wso2.carbon.device.mgt.iot.util.iotdevice.dao.IotDeviceDAO; import javax.naming.Context;
import org.wso2.carbon.device.mgt.iot.util.iotdevice.dao.IotDeviceManagementDAOException; import javax.naming.InitialContext;
import org.wso2.carbon.device.mgt.iot.util.iotdevice.dao.IotDeviceManagementDAOFactory; import javax.naming.NamingException;
import org.wso2.carbon.device.mgt.iot.util.iotdevice.dao.IotDeviceManagementDAOFactoryInterface;
import javax.sql.DataSource; import javax.sql.DataSource;
import java.sql.Connection; import java.sql.Connection;
import java.sql.SQLException; import java.sql.SQLException;
public class ConnectedCupDAO extends IotDeviceManagementDAOFactory public class ConnectedCupDAO {
implements IotDeviceManagementDAOFactoryInterface {
private static final Log log = LogFactory.getLog(ConnectedCupDAO.class);
static DataSource dataSource;
private static ThreadLocal<Connection> currentConnection = new ThreadLocal<Connection>();
public ConnectedCupDAO() {
initConnectedCupDAO();
}
private static final Log log = LogFactory.getLog(ConnectedCupDAO.class); public static void initConnectedCupDAO() {
static DataSource dataSource; try {
private static ThreadLocal<Connection> currentConnection = new ThreadLocal<Connection>(); Context ctx = new InitialContext();
dataSource = (DataSource) ctx.lookup(ConnectedCupConstants.DATA_SOURCE_NAME);
} catch (NamingException e) {
log.error("Error while looking up the data source: " +
ConnectedCupConstants.DATA_SOURCE_NAME);
}
public ConnectedCupDAO() { }
initFireAlarmDAO();
}
public static void initFireAlarmDAO() {
dataSource = getDataSourceMap().get(ConnectedCupConstants.DEVICE_TYPE);
}
@Override public IotDeviceDAO getIotDeviceDAO() { public ConnectedCupDAOImpl getConnectedCupDeviceDAO() {
return new ConnectedCupDAOImpl(); return new ConnectedCupDAOImpl();
} }
public static void beginTransaction() throws IotDeviceManagementDAOException { public static void beginTransaction() throws ConnectedCupDeviceMgtPluginException {
try { try {
Connection conn = dataSource.getConnection(); Connection conn = dataSource.getConnection();
conn.setAutoCommit(false); conn.setAutoCommit(false);
currentConnection.set(conn); currentConnection.set(conn);
} catch (SQLException e) { } catch (SQLException e) {
throw new IotDeviceManagementDAOException("Error occurred while retrieving datasource connection", e); throw new ConnectedCupDeviceMgtPluginException(
} "Error occurred while retrieving datasource connection", e);
} }
}
public static Connection getConnection() throws IotDeviceManagementDAOException { public static Connection getConnection() throws ConnectedCupDeviceMgtPluginException {
if (currentConnection.get() == null) { if (currentConnection.get() == null) {
try { try {
currentConnection.set(dataSource.getConnection()); currentConnection.set(dataSource.getConnection());
} catch (SQLException e) { } catch (SQLException e) {
throw new IotDeviceManagementDAOException("Error occurred while retrieving data source connection", e); throw new ConnectedCupDeviceMgtPluginException(
} "Error occurred while retrieving data source connection", e);
} }
return currentConnection.get(); }
} return currentConnection.get();
}
public static void commitTransaction() throws IotDeviceManagementDAOException { public static void commitTransaction() throws ConnectedCupDeviceMgtPluginException {
try { try {
Connection conn = currentConnection.get(); Connection conn = currentConnection.get();
if (conn != null) { if (conn != null) {
conn.commit(); conn.commit();
} else { } else {
if (log.isDebugEnabled()) { if (log.isDebugEnabled()) {
log.debug("Datasource connection associated with the current thread is null, hence commit " log.debug("Datasource connection associated with the current thread is null, " +
+ "has not been attempted"); "hence commit has not been attempted");
} }
} }
} catch (SQLException e) { } catch (SQLException e) {
throw new IotDeviceManagementDAOException("Error occurred while committing the transaction", e); throw new ConnectedCupDeviceMgtPluginException(
} finally { "Error occurred while committing the transaction", e);
closeConnection(); } finally {
} closeConnection();
} }
}
public static void closeConnection() throws IotDeviceManagementDAOException { public static void closeConnection() throws ConnectedCupDeviceMgtPluginException {
Connection con = currentConnection.get(); Connection con = currentConnection.get();
if (con != null) { if (con != null) {
try { try {
con.close(); con.close();
} catch (SQLException e) { } catch (SQLException e) {
log.error("Error occurred while close the connection"); log.error("Error occurred while close the connection");
} }
} }
currentConnection.remove(); currentConnection.remove();
} }
public static void rollbackTransaction() throws IotDeviceManagementDAOException { public static void rollbackTransaction() throws ConnectedCupDeviceMgtPluginException {
try { try {
Connection conn = currentConnection.get(); Connection conn = currentConnection.get();
if (conn != null) { if (conn != null) {
conn.rollback(); conn.rollback();
} else { } else {
if (log.isDebugEnabled()) { if (log.isDebugEnabled()) {
log.debug("Datasource connection associated with the current thread is null, hence rollback " log.debug(
+ "has not been attempted"); "Datasource connection associated with the current thread is null, " +
} "hence rollback has not been attempted");
} }
} catch (SQLException e) { }
throw new IotDeviceManagementDAOException("Error occurred while rollback the transaction", e); } catch (SQLException e) {
} finally { throw new ConnectedCupDeviceMgtPluginException("Error occurred while rollback the transaction", e);
closeConnection(); } finally {
} closeConnection();
} }
}
} }

411
modules/samples/connectedcup/component/plugin/src/main/java/org/coffeeking/connectedcup/plugin/impl/dao/impl/ConnectedCupDAOImpl.java
Unescape View File

@ -21,222 +21,223 @@ package org.coffeeking.connectedcup.plugin.impl.dao.impl;
import org.apache.commons.logging.Log; import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory; import org.apache.commons.logging.LogFactory;
import org.coffeeking.connectedcup.plugin.constants.ConnectedCupConstants; import org.coffeeking.connectedcup.plugin.constants.ConnectedCupConstants;
import org.coffeeking.connectedcup.plugin.exception.ConnectedCupDeviceMgtPluginException;
import org.coffeeking.connectedcup.plugin.impl.dao.ConnectedCupDAO; import org.coffeeking.connectedcup.plugin.impl.dao.ConnectedCupDAO;
import org.wso2.carbon.device.mgt.iot.util.iotdevice.dao.IotDeviceDAO; import org.coffeeking.connectedcup.plugin.impl.dao.util.ConnectedCupUtils;
import org.wso2.carbon.device.mgt.iot.util.iotdevice.dao.IotDeviceManagementDAOException; import org.wso2.carbon.device.mgt.common.Device;
import org.wso2.carbon.device.mgt.iot.util.iotdevice.dao.util.IotDeviceManagementDAOUtil;
import org.wso2.carbon.device.mgt.iot.util.iotdevice.dto.IotDevice;
import java.sql.Connection; import java.sql.Connection;
import java.sql.PreparedStatement; import java.sql.PreparedStatement;
import java.sql.ResultSet; import java.sql.ResultSet;
import java.sql.SQLException; import java.sql.SQLException;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map;
/** /**
* Implements IotDeviceDAO for virtual firealarm Devices. * Device Dao for connected cup Devices.
*/ */
public class ConnectedCupDAOImpl implements IotDeviceDAO { public class ConnectedCupDAOImpl {
private static final Log log = LogFactory.getLog(ConnectedCupDAOImpl.class); private static final Log log = LogFactory.getLog(ConnectedCupDAOImpl.class);
@Override public Device getDevice(String deviceId) throws ConnectedCupDeviceMgtPluginException {
public IotDevice getIotDevice(String iotDeviceId) Connection conn = null;
throws IotDeviceManagementDAOException { PreparedStatement stmt = null;
Connection conn = null; Device connectedCupDevice = null;
PreparedStatement stmt = null; ResultSet resultSet = null;
IotDevice iotDevice = null; try {
ResultSet resultSet = null; conn = ConnectedCupDAO.getConnection();
try { String selectDBQuery =
conn = ConnectedCupDAO.getConnection(); "SELECT CONNECTED_CUP_DEVICE_ID, DEVICE_NAME, ACCESS_TOKEN, REFRESH_TOKEN" +
String selectDBQuery = " FROM CONNECTED_CUP_DEVICE WHERE CONNECTED_CUP_DEVICE_ID = ?";
"SELECT CONNECTED_CUP_DEVICE_ID, DEVICE_NAME, ACCESS_TOKEN, REFRESH_TOKEN" + stmt = conn.prepareStatement(selectDBQuery);
" FROM CONNECTED_CUP_DEVICE WHERE CONNECTED_CUP_DEVICE_ID = ?"; stmt.setString(1, deviceId);
stmt = conn.prepareStatement(selectDBQuery); resultSet = stmt.executeQuery();
stmt.setString(1, iotDeviceId);
resultSet = stmt.executeQuery(); if (resultSet.next()) {
connectedCupDevice = new Device();
if (resultSet.next()) { connectedCupDevice.setName(resultSet.getString(
iotDevice = new IotDevice(); ConnectedCupConstants.DEVICE_PLUGIN_DEVICE_NAME));
iotDevice.setIotDeviceName(resultSet.getString( List<Device.Property> propertyList = new ArrayList<Device.Property>();
ConnectedCupConstants.DEVICE_PLUGIN_DEVICE_NAME)); propertyList.add(ConnectedCupUtils.getProperty(
Map<String, String> propertyMap = new HashMap<String, String>(); ConnectedCupConstants.DEVICE_PLUGIN_PROPERTY_ACCESS_TOKEN,
propertyMap.put(ConnectedCupConstants.DEVICE_PLUGIN_PROPERTY_ACCESS_TOKEN, resultSet.getString("ACCESS_TOKEN")); resultSet.getString("ACCESS_TOKEN")));
propertyMap.put(ConnectedCupConstants.DEVICE_PLUGIN_PROPERTY_REFRESH_TOKEN, resultSet.getString("REFRESH_TOKEN")); propertyList.add(ConnectedCupUtils.getProperty(
iotDevice.setDeviceProperties(propertyMap); ConnectedCupConstants.DEVICE_PLUGIN_PROPERTY_REFRESH_TOKEN,
resultSet.getString("REFRESH_TOKEN")));
if (log.isDebugEnabled()) { connectedCupDevice.setProperties(propertyList);
log.debug("Connected Cup service " + iotDeviceId + " data has been fetched from " +
"Connected Cup database."); if (log.isDebugEnabled()) {
} log.debug("Connected Cup service " + deviceId + " data has been fetched from" +
} "Connected Cup database.");
} catch (SQLException e) {
String msg = "Error occurred while fetching Connected Cup device : '" + iotDeviceId + "'";
log.error(msg, e);
throw new IotDeviceManagementDAOException(msg, e);
} finally {
IotDeviceManagementDAOUtil.cleanupResources(stmt, resultSet);
ConnectedCupDAO.closeConnection();
}
return iotDevice;
}
@Override
public boolean addIotDevice(IotDevice iotDevice)
throws IotDeviceManagementDAOException {
boolean status = false;
Connection conn = null;
PreparedStatement stmt = null;
try {
conn = ConnectedCupDAO.getConnection();
String createDBQuery =
"INSERT INTO CONNECTED_CUP_DEVICE(CONNECTED_CUP_DEVICE_ID, DEVICE_NAME, ACCESS_TOKEN, REFRESH_TOKEN) VALUES (?, ?, ?, ?)";
stmt = conn.prepareStatement(createDBQuery);
stmt.setString(1, iotDevice.getIotDeviceId());
stmt.setString(2, iotDevice.getIotDeviceName());
stmt.setString(3, iotDevice.getDeviceProperties().get(ConnectedCupConstants.DEVICE_PLUGIN_PROPERTY_ACCESS_TOKEN));
stmt.setString(4, iotDevice.getDeviceProperties().get(ConnectedCupConstants.DEVICE_PLUGIN_PROPERTY_REFRESH_TOKEN));
int rows = stmt.executeUpdate();
if (rows > 0) {
status = true;
if (log.isDebugEnabled()) {
log.debug("Connected Cup device " + iotDevice.getIotDeviceId() + " data has been" +
" added to the Connected Cup database.");
}
}
} catch (SQLException e) {
String msg = "Error occurred while adding the Connected Cup device '" +
iotDevice.getIotDeviceId() + "' to the Connected Cup db.";
log.error(msg, e);
throw new IotDeviceManagementDAOException(msg, e);
} finally {
IotDeviceManagementDAOUtil.cleanupResources(stmt, null);
}
return status;
}
@Override
public boolean updateIotDevice(IotDevice iotDevice)
throws IotDeviceManagementDAOException {
boolean status = false;
Connection conn = null;
PreparedStatement stmt = null;
try {
conn = ConnectedCupDAO.getConnection();
String updateDBQuery =
"UPDATE CONNECTED_CUP_DEVICE SET DEVICE_NAME = ?, ACCESS_TOKEN=?, REFRESH_TOKEN=? WHERE CONNECTED_CUP_DEVICE_ID = ?";
stmt = conn.prepareStatement(updateDBQuery);
if (iotDevice.getDeviceProperties() == null) {
iotDevice.setDeviceProperties(new HashMap<String, String>());
} }
stmt.setString(1, iotDevice.getIotDeviceName()); }
stmt.setString(2, iotDevice.getDeviceProperties().get( } catch (SQLException e) {
ConnectedCupConstants.DEVICE_PLUGIN_PROPERTY_ACCESS_TOKEN)); String msg = "Error occurred while fetching Connected Cup device : '" + deviceId + "'";
stmt.setString(3, iotDevice.getDeviceProperties().get( log.error(msg, e);
ConnectedCupConstants.DEVICE_PLUGIN_PROPERTY_ACCESS_TOKEN)); throw new ConnectedCupDeviceMgtPluginException(msg, e);
stmt.setString(4, iotDevice.getIotDeviceId()); } finally {
int rows = stmt.executeUpdate(); ConnectedCupUtils.cleanupResources(stmt, resultSet);
if (rows > 0) { ConnectedCupDAO.closeConnection();
status = true; }
if (log.isDebugEnabled()) { return connectedCupDevice;
log.debug("Connected Cup device " + iotDevice.getIotDeviceId() + " data has been" + }
" modified.");
}
public boolean addDevice(Device connectedCupDevice) throws ConnectedCupDeviceMgtPluginException {
boolean status = false;
Connection conn = null;
PreparedStatement stmt = null;
try {
conn = ConnectedCupDAO.getConnection();
String createDBQuery =
"INSERT INTO CONNECTED_CUP_DEVICE(CONNECTED_CUP_DEVICE_ID, DEVICE_NAME, " +
"ACCESS_TOKEN, REFRESH_TOKEN) VALUES (?, ?, ?, ?)";
stmt = conn.prepareStatement(createDBQuery);
stmt.setString(1, connectedCupDevice.getDeviceIdentifier());
stmt.setString(2, connectedCupDevice.getName());
stmt.setString(3, ConnectedCupUtils.getDeviceProperty(
connectedCupDevice.getProperties(),
ConnectedCupConstants.DEVICE_PLUGIN_PROPERTY_ACCESS_TOKEN));
stmt.setString(4, ConnectedCupUtils.getDeviceProperty(
connectedCupDevice.getProperties(),
ConnectedCupConstants.DEVICE_PLUGIN_PROPERTY_REFRESH_TOKEN));
int rows = stmt.executeUpdate();
if (rows > 0) {
status = true;
if (log.isDebugEnabled()) {
log.debug("Connected Cup device " + connectedCupDevice.getDeviceIdentifier() +
" data has been added to the Connected Cup database.");
} }
} catch (SQLException e) { }
String msg = "Error occurred while modifying the Connected Cup device '" + } catch (SQLException e) {
iotDevice.getIotDeviceId() + "' data."; String msg = "Error occurred while adding the Connected Cup device '" +
log.error(msg, e); connectedCupDevice.getDeviceIdentifier() + "' to the Connected Cup db.";
throw new IotDeviceManagementDAOException(msg, e); log.error(msg, e);
} finally { throw new ConnectedCupDeviceMgtPluginException(msg, e);
IotDeviceManagementDAOUtil.cleanupResources(stmt, null); } finally {
} ConnectedCupUtils.cleanupResources(stmt, null);
return status; }
} return status;
}
@Override
public boolean deleteIotDevice(String iotDeviceId) public boolean updateDevice(Device connectedCupDevice) throws ConnectedCupDeviceMgtPluginException {
throws IotDeviceManagementDAOException { boolean status = false;
boolean status = false; Connection conn = null;
Connection conn = null; PreparedStatement stmt = null;
PreparedStatement stmt = null; try {
try { conn = ConnectedCupDAO.getConnection();
conn = ConnectedCupDAO.getConnection(); String updateDBQuery =
String deleteDBQuery = "UPDATE CONNECTED_CUP_DEVICE SET DEVICE_NAME = ?, ACCESS_TOKEN=?, " +
"DELETE FROM CONNECTED_CUP_DEVICE WHERE CONNECTED_CUP_DEVICE_ID = ?"; "REFRESH_TOKEN=? WHERE CONNECTED_CUP_DEVICE_ID = ?";
stmt = conn.prepareStatement(deleteDBQuery);
stmt.setString(1, iotDeviceId); stmt = conn.prepareStatement(updateDBQuery);
int rows = stmt.executeUpdate();
if (rows > 0) { if (connectedCupDevice.getProperties() == null) {
status = true; connectedCupDevice.setProperties(new ArrayList<Device.Property>());
if (log.isDebugEnabled()) { }
log.debug("Connected Cup device " + iotDeviceId + " data has deleted" + stmt.setString(1, connectedCupDevice.getName());
" from the Connected Cup database."); stmt.setString(2, ConnectedCupUtils.getDeviceProperty(
} connectedCupDevice.getProperties(),
ConnectedCupConstants.DEVICE_PLUGIN_PROPERTY_ACCESS_TOKEN));
stmt.setString(3, ConnectedCupUtils.getDeviceProperty(
connectedCupDevice.getProperties(),
ConnectedCupConstants.DEVICE_PLUGIN_PROPERTY_REFRESH_TOKEN));
stmt.setString(4, connectedCupDevice.getDeviceIdentifier());
int rows = stmt.executeUpdate();
if (rows > 0) {
status = true;
if (log.isDebugEnabled()) {
log.debug("Connected Cup device " + connectedCupDevice.getDeviceIdentifier() +
" data has been modified.");
} }
} catch (SQLException e) { }
String msg = "Error occurred while deleting Connected Cup device " + iotDeviceId; } catch (SQLException e) {
log.error(msg, e); String msg = "Error occurred while modifying the Connected Cup device '" +
throw new IotDeviceManagementDAOException(msg, e); connectedCupDevice.getDeviceIdentifier() + "' data.";
} finally { log.error(msg, e);
IotDeviceManagementDAOUtil.cleanupResources(stmt, null); throw new ConnectedCupDeviceMgtPluginException(msg, e);
} } finally {
return status; ConnectedCupUtils.cleanupResources(stmt, null);
} }
return status;
@Override }
public List<IotDevice> getAllIotDevices()
throws IotDeviceManagementDAOException { public boolean deleteDevice(String deviceId) throws ConnectedCupDeviceMgtPluginException {
boolean status = false;
Connection conn = null; Connection conn = null;
PreparedStatement stmt = null; PreparedStatement stmt = null;
ResultSet resultSet = null; try {
IotDevice iotDevice; conn = ConnectedCupDAO.getConnection();
List<IotDevice> iotDevices = new ArrayList<>(); String deleteDBQuery =
"DELETE FROM CONNECTED_CUP_DEVICE WHERE CONNECTED_CUP_DEVICE_ID = ?";
try { stmt = conn.prepareStatement(deleteDBQuery);
conn = ConnectedCupDAO.getConnection(); stmt.setString(1, deviceId);
String selectDBQuery = int rows = stmt.executeUpdate();
"SELECT CONNECTED_CUP_DEVICE_ID, DEVICE_NAME, ACCESS_TOKEN, REFRESH_TOKEN" + if (rows > 0) {
"FROM CONNECTED_CUP_DEVICE"; status = true;
stmt = conn.prepareStatement(selectDBQuery); if (log.isDebugEnabled()) {
resultSet = stmt.executeQuery(); log.debug("Connected Cup device " + deviceId + " data has deleted" +
while (resultSet.next()) { " from the Connected Cup database.");
iotDevice = new IotDevice();
iotDevice.setIotDeviceId(resultSet.getString(ConnectedCupConstants.DEVICE_PLUGIN_DEVICE_ID));
iotDevice.setIotDeviceName(resultSet.getString(ConnectedCupConstants.DEVICE_PLUGIN_DEVICE_NAME));
Map<String, String> propertyMap = new HashMap<>();
propertyMap.put(ConnectedCupConstants.DEVICE_PLUGIN_PROPERTY_ACCESS_TOKEN,
resultSet.getString("ACCESS_TOKEN"));
propertyMap.put(ConnectedCupConstants.DEVICE_PLUGIN_PROPERTY_REFRESH_TOKEN,
resultSet.getString("REFRESH_TOKEN"));
iotDevice.setDeviceProperties(propertyMap);
iotDevices.add(iotDevice);
} }
if (log.isDebugEnabled()) { }
log.debug("All Connected Cup device details have fetched from Connected Cup database."); } catch (SQLException e) {
} String msg = "Error occurred while deleting Connected Cup device " + deviceId;
return iotDevices; log.error(msg, e);
} catch (SQLException e) { throw new ConnectedCupDeviceMgtPluginException(msg, e);
String msg = "Error occurred while fetching all Connected Cup device data'"; } finally {
log.error(msg, e); ConnectedCupUtils.cleanupResources(stmt, null);
throw new IotDeviceManagementDAOException(msg, e); }
} finally { return status;
IotDeviceManagementDAOUtil.cleanupResources(stmt, resultSet); }
ConnectedCupDAO.closeConnection();
} public List<Device> getAllDevices() throws ConnectedCupDeviceMgtPluginException {
} Connection conn = null;
PreparedStatement stmt = null;
} ResultSet resultSet = null;
Device connectedCupDevice;
List<Device> iotDevices = new ArrayList<>();
try {
conn = ConnectedCupDAO.getConnection();
String selectDBQuery =
"SELECT CONNECTED_CUP_DEVICE_ID, DEVICE_NAME, ACCESS_TOKEN, REFRESH_TOKEN" +
"FROM CONNECTED_CUP_DEVICE";
stmt = conn.prepareStatement(selectDBQuery);
resultSet = stmt.executeQuery();
while (resultSet.next()) {
connectedCupDevice = new Device();
connectedCupDevice.setDeviceIdentifier(resultSet.getString(
ConnectedCupConstants.DEVICE_PLUGIN_DEVICE_ID));
connectedCupDevice.setName(resultSet.getString(
ConnectedCupConstants.DEVICE_PLUGIN_DEVICE_NAME));
List<Device.Property> propertyList = new ArrayList<Device.Property>();
propertyList.add(ConnectedCupUtils.getProperty(
ConnectedCupConstants.DEVICE_PLUGIN_PROPERTY_ACCESS_TOKEN,
resultSet.getString("ACCESS_TOKEN")));
propertyList.add(ConnectedCupUtils.getProperty(
ConnectedCupConstants.DEVICE_PLUGIN_PROPERTY_REFRESH_TOKEN,
resultSet.getString("REFRESH_TOKEN")));
connectedCupDevice.setProperties(propertyList);
}
if (log.isDebugEnabled()) {
log.debug("All Connected Cup device details have fetched from Connected Cup database" +
".");
}
return iotDevices;
} catch (SQLException e) {
String msg = "Error occurred while fetching all Connected Cup device data'";
log.error(msg, e);
throw new ConnectedCupDeviceMgtPluginException(msg, e);
} finally {
ConnectedCupUtils.cleanupResources(stmt, resultSet);
ConnectedCupDAO.closeConnection();
}
}
}

53
modules/samples/connectedcup/component/plugin/src/main/java/org/coffeeking/connectedcup/plugin/impl/dao/util/ConnectedCupUtils.java
Unescape View File

@ -20,7 +20,13 @@ package org.coffeeking.connectedcup.plugin.impl.dao.util;
import org.apache.commons.logging.Log; import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory; import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.device.mgt.common.Device;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map; import java.util.Map;
/** /**
@ -30,15 +36,52 @@ public class ConnectedCupUtils {
private static Log log = LogFactory.getLog(ConnectedCupUtils.class); private static Log log = LogFactory.getLog(ConnectedCupUtils.class);
public static String getDeviceProperty(Map<String, String> deviceProperties, String property) { public static String getDeviceProperty(List<Device.Property> deviceProperties, String propertyKey) {
String deviceProperty = "";
for(Device.Property property :deviceProperties){
if(propertyKey.equals(property.getName())){
deviceProperty = property.getValue();
}
}
return deviceProperty;
}
String deviceProperty = deviceProperties.get(property); public static Device.Property getProperty(String property, String value) {
if (property != null) {
Device.Property prop = new Device.Property();
prop.setName(property);
prop.setValue(value);
return prop;
}
return null;
}
if (deviceProperty == null) { public static void cleanupResources(Connection conn, PreparedStatement stmt, ResultSet rs) {
return ""; if (rs != null) {
try {
rs.close();
} catch (SQLException e) {
log.warn("Error occurred while closing result set", e);
}
} }
if (stmt != null) {
try {
stmt.close();
} catch (SQLException e) {
log.warn("Error occurred while closing prepared statement", e);
}
}
if (conn != null) {
try {
conn.close();
} catch (SQLException e) {
log.warn("Error occurred while closing database connection", e);
}
}
}
return deviceProperty; public static void cleanupResources(PreparedStatement stmt, ResultSet rs) {
cleanupResources(null, stmt, rs);
} }

18
modules/samples/connectedcup/component/plugin/src/main/java/org/coffeeking/connectedcup/plugin/internal/ConnectedCupServiceComponent.java
Unescape View File

@ -25,18 +25,11 @@ import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceRegistration; import org.osgi.framework.ServiceRegistration;
import org.osgi.service.component.ComponentContext; import org.osgi.service.component.ComponentContext;
import org.wso2.carbon.device.mgt.common.spi.DeviceManagementService; import org.wso2.carbon.device.mgt.common.spi.DeviceManagementService;
import org.wso2.carbon.device.mgt.iot.service.DeviceTypeService;
/** /**
* @scr.component name="org.coffeeking.connectedcup.plugin.internal * @scr.component name="org.coffeeking.connectedcup.plugin.internal
* .ConnectedCupServiceComponent" * .ConnectedCupServiceComponent"
* immediate="true" * immediate="true"
* @scr.reference name="org.wso2.carbon.device.mgt.iot.service.DeviceTypeServiceImpl"
* interface="org.wso2.carbon.device.mgt.iot.service.DeviceTypeService"
* cardinality="1..1"
* policy="dynamic"
* bind="setDeviceTypeService"
* unbind="unsetDeviceTypeService"
*/ */
public class ConnectedCupServiceComponent { public class ConnectedCupServiceComponent {
@ -77,15 +70,4 @@ public class ConnectedCupServiceComponent {
log.error("Error occurred while de-activating Connected Cup Service Component", e); log.error("Error occurred while de-activating Connected Cup Service Component", e);
} }
} }
protected void setDeviceTypeService(DeviceTypeService deviceTypeService) {
/* This is to avoid this component getting initialized before the
common registered */
if (log.isDebugEnabled()) {
log.debug("Data source service set to mobile service component");
}
}
protected void unsetDeviceTypeService(DeviceTypeService deviceTypeService) {
}
} }

2
modules/samples/connectedcup/feature/connectedcup-feature/src/main/resources/jaggeryapps/devicemgt/app/units/cdmf.unit.device.type.connectedcup.type-view/public/js/download.js
Unescape View File

@ -146,7 +146,7 @@ function downloadAgent() {
payload.owner = $inputs[1].value; payload.owner = $inputs[1].value;
var connectedCupRegisterURL = "/connectedcup_mgt/connectedcup/cup/register?" + var connectedCupRegisterURL = "/connectedcup_mgt/connectedcup/cup/register?" +
"name=" + payload.name + "&owner=" + payload.owner; "name=" + encodeURI(payload.name) + "&owner=" + payload.owner;
invokerUtil.post( invokerUtil.post(
connectedCupRegisterURL, connectedCupRegisterURL,

Write Preview
Loading…
Cancel
Save