Merge pull request #75 from ayyoob/configConnectedCup

few changes in connected cup to remove the dependent with the configu…
application-manager-new
ayyoob 9 years ago
commit 3f9e279188

@ -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";
} }

@ -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);
}
}

@ -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);

@ -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
} }

@ -21,75 +21,84 @@ 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); private static final Log log = LogFactory.getLog(ConnectedCupDAO.class);
static DataSource dataSource; static DataSource dataSource;
private static ThreadLocal<Connection> currentConnection = new ThreadLocal<Connection>(); private static ThreadLocal<Connection> currentConnection = new ThreadLocal<Connection>();
public ConnectedCupDAO() { public ConnectedCupDAO() {
initFireAlarmDAO(); initConnectedCupDAO();
} }
public static void initFireAlarmDAO() { public static void initConnectedCupDAO() {
dataSource = getDataSourceMap().get(ConnectedCupConstants.DEVICE_TYPE); try {
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);
} }
@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(
"Error occurred while committing the transaction", e);
} finally { } finally {
closeConnection(); 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) {
@ -102,19 +111,20 @@ public class ConnectedCupDAO extends IotDeviceManagementDAOFactory
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) { } catch (SQLException e) {
throw new IotDeviceManagementDAOException("Error occurred while rollback the transaction", e); throw new ConnectedCupDeviceMgtPluginException("Error occurred while rollback the transaction", e);
} finally { } finally {
closeConnection(); closeConnection();
} }

@ -21,35 +21,29 @@ 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)
throws IotDeviceManagementDAOException {
Connection conn = null; Connection conn = null;
PreparedStatement stmt = null; PreparedStatement stmt = null;
IotDevice iotDevice = null; Device connectedCupDevice = null;
ResultSet resultSet = null; ResultSet resultSet = null;
try { try {
conn = ConnectedCupDAO.getConnection(); conn = ConnectedCupDAO.getConnection();
@ -57,116 +51,121 @@ public class ConnectedCupDAOImpl implements IotDeviceDAO {
"SELECT CONNECTED_CUP_DEVICE_ID, DEVICE_NAME, ACCESS_TOKEN, REFRESH_TOKEN" + "SELECT CONNECTED_CUP_DEVICE_ID, DEVICE_NAME, ACCESS_TOKEN, REFRESH_TOKEN" +
" FROM CONNECTED_CUP_DEVICE WHERE CONNECTED_CUP_DEVICE_ID = ?"; " FROM CONNECTED_CUP_DEVICE WHERE CONNECTED_CUP_DEVICE_ID = ?";
stmt = conn.prepareStatement(selectDBQuery); stmt = conn.prepareStatement(selectDBQuery);
stmt.setString(1, iotDeviceId); stmt.setString(1, deviceId);
resultSet = stmt.executeQuery(); resultSet = stmt.executeQuery();
if (resultSet.next()) { if (resultSet.next()) {
iotDevice = new IotDevice(); connectedCupDevice = new Device();
iotDevice.setIotDeviceName(resultSet.getString( connectedCupDevice.setName(resultSet.getString(
ConnectedCupConstants.DEVICE_PLUGIN_DEVICE_NAME)); ConnectedCupConstants.DEVICE_PLUGIN_DEVICE_NAME));
Map<String, String> propertyMap = new HashMap<String, String>(); List<Device.Property> propertyList = new ArrayList<Device.Property>();
propertyMap.put(ConnectedCupConstants.DEVICE_PLUGIN_PROPERTY_ACCESS_TOKEN, resultSet.getString("ACCESS_TOKEN")); propertyList.add(ConnectedCupUtils.getProperty(
propertyMap.put(ConnectedCupConstants.DEVICE_PLUGIN_PROPERTY_REFRESH_TOKEN, resultSet.getString("REFRESH_TOKEN")); ConnectedCupConstants.DEVICE_PLUGIN_PROPERTY_ACCESS_TOKEN,
iotDevice.setDeviceProperties(propertyMap); resultSet.getString("ACCESS_TOKEN")));
propertyList.add(ConnectedCupUtils.getProperty(
ConnectedCupConstants.DEVICE_PLUGIN_PROPERTY_REFRESH_TOKEN,
resultSet.getString("REFRESH_TOKEN")));
connectedCupDevice.setProperties(propertyList);
if (log.isDebugEnabled()) { if (log.isDebugEnabled()) {
log.debug("Connected Cup service " + iotDeviceId + " data has been fetched from " + log.debug("Connected Cup service " + deviceId + " data has been fetched from" +
"Connected Cup database."); "Connected Cup database.");
} }
} }
} catch (SQLException e) { } catch (SQLException e) {
String msg = "Error occurred while fetching Connected Cup device : '" + iotDeviceId + "'"; String msg = "Error occurred while fetching Connected Cup device : '" + deviceId + "'";
log.error(msg, e); log.error(msg, e);
throw new IotDeviceManagementDAOException(msg, e); throw new ConnectedCupDeviceMgtPluginException(msg, e);
} finally { } finally {
IotDeviceManagementDAOUtil.cleanupResources(stmt, resultSet); ConnectedCupUtils.cleanupResources(stmt, resultSet);
ConnectedCupDAO.closeConnection(); ConnectedCupDAO.closeConnection();
} }
return connectedCupDevice;
return iotDevice;
} }
@Override
public boolean addIotDevice(IotDevice iotDevice) public boolean addDevice(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 createDBQuery = String createDBQuery =
"INSERT INTO CONNECTED_CUP_DEVICE(CONNECTED_CUP_DEVICE_ID, DEVICE_NAME, ACCESS_TOKEN, REFRESH_TOKEN) VALUES (?, ?, ?, ?)"; "INSERT INTO CONNECTED_CUP_DEVICE(CONNECTED_CUP_DEVICE_ID, DEVICE_NAME, " +
"ACCESS_TOKEN, REFRESH_TOKEN) VALUES (?, ?, ?, ?)";
stmt = conn.prepareStatement(createDBQuery); stmt = conn.prepareStatement(createDBQuery);
stmt.setString(1, iotDevice.getIotDeviceId()); stmt.setString(1, connectedCupDevice.getDeviceIdentifier());
stmt.setString(2, iotDevice.getIotDeviceName()); stmt.setString(2, connectedCupDevice.getName());
stmt.setString(3, iotDevice.getDeviceProperties().get(ConnectedCupConstants.DEVICE_PLUGIN_PROPERTY_ACCESS_TOKEN)); stmt.setString(3, ConnectedCupUtils.getDeviceProperty(
stmt.setString(4, iotDevice.getDeviceProperties().get(ConnectedCupConstants.DEVICE_PLUGIN_PROPERTY_REFRESH_TOKEN)); 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(); int rows = stmt.executeUpdate();
if (rows > 0) { if (rows > 0) {
status = true; status = true;
if (log.isDebugEnabled()) { if (log.isDebugEnabled()) {
log.debug("Connected Cup device " + iotDevice.getIotDeviceId() + " data has been" + log.debug("Connected Cup device " + connectedCupDevice.getDeviceIdentifier() +
" added to the Connected Cup database."); " data has been added to the Connected Cup database.");
} }
} }
} catch (SQLException e) { } catch (SQLException e) {
String msg = "Error occurred while adding the Connected Cup device '" + String msg = "Error occurred while adding the Connected Cup device '" +
iotDevice.getIotDeviceId() + "' to the Connected Cup db."; connectedCupDevice.getDeviceIdentifier() + "' to the Connected Cup db.";
log.error(msg, e); log.error(msg, e);
throw new IotDeviceManagementDAOException(msg, e); throw new ConnectedCupDeviceMgtPluginException(msg, e);
} finally { } finally {
IotDeviceManagementDAOUtil.cleanupResources(stmt, null); ConnectedCupUtils.cleanupResources(stmt, null);
} }
return status; return status;
} }
@Override public boolean updateDevice(Device connectedCupDevice) throws ConnectedCupDeviceMgtPluginException {
public boolean updateIotDevice(IotDevice iotDevice)
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 updateDBQuery =
"UPDATE CONNECTED_CUP_DEVICE SET DEVICE_NAME = ?, ACCESS_TOKEN=?, REFRESH_TOKEN=? WHERE CONNECTED_CUP_DEVICE_ID = ?"; "UPDATE CONNECTED_CUP_DEVICE SET DEVICE_NAME = ?, ACCESS_TOKEN=?, " +
"REFRESH_TOKEN=? WHERE CONNECTED_CUP_DEVICE_ID = ?";
stmt = conn.prepareStatement(updateDBQuery); stmt = conn.prepareStatement(updateDBQuery);
if (iotDevice.getDeviceProperties() == null) { if (connectedCupDevice.getProperties() == null) {
iotDevice.setDeviceProperties(new HashMap<String, String>()); connectedCupDevice.setProperties(new ArrayList<Device.Property>());
} }
stmt.setString(1, iotDevice.getIotDeviceName()); stmt.setString(1, connectedCupDevice.getName());
stmt.setString(2, iotDevice.getDeviceProperties().get( stmt.setString(2, ConnectedCupUtils.getDeviceProperty(
ConnectedCupConstants.DEVICE_PLUGIN_PROPERTY_ACCESS_TOKEN)); connectedCupDevice.getProperties(),
stmt.setString(3, iotDevice.getDeviceProperties().get(
ConnectedCupConstants.DEVICE_PLUGIN_PROPERTY_ACCESS_TOKEN)); ConnectedCupConstants.DEVICE_PLUGIN_PROPERTY_ACCESS_TOKEN));
stmt.setString(4, iotDevice.getIotDeviceId()); stmt.setString(3, ConnectedCupUtils.getDeviceProperty(
connectedCupDevice.getProperties(),
ConnectedCupConstants.DEVICE_PLUGIN_PROPERTY_REFRESH_TOKEN));
stmt.setString(4, connectedCupDevice.getDeviceIdentifier());
int rows = stmt.executeUpdate(); int rows = stmt.executeUpdate();
if (rows > 0) { if (rows > 0) {
status = true; status = true;
if (log.isDebugEnabled()) { if (log.isDebugEnabled()) {
log.debug("Connected Cup device " + iotDevice.getIotDeviceId() + " data has been" + log.debug("Connected Cup device " + connectedCupDevice.getDeviceIdentifier() +
" modified."); " data has been modified.");
} }
} }
} catch (SQLException e) { } catch (SQLException e) {
String msg = "Error occurred while modifying the Connected Cup device '" + String msg = "Error occurred while modifying the Connected Cup device '" +
iotDevice.getIotDeviceId() + "' data."; connectedCupDevice.getDeviceIdentifier() + "' data.";
log.error(msg, e); log.error(msg, e);
throw new IotDeviceManagementDAOException(msg, e); throw new ConnectedCupDeviceMgtPluginException(msg, e);
} finally { } finally {
IotDeviceManagementDAOUtil.cleanupResources(stmt, null); ConnectedCupUtils.cleanupResources(stmt, null);
} }
return status; return status;
} }
@Override public boolean deleteDevice(String deviceId) throws ConnectedCupDeviceMgtPluginException {
public boolean deleteIotDevice(String iotDeviceId)
throws IotDeviceManagementDAOException {
boolean status = false; boolean status = false;
Connection conn = null; Connection conn = null;
PreparedStatement stmt = null; PreparedStatement stmt = null;
@ -175,34 +174,32 @@ public class ConnectedCupDAOImpl implements IotDeviceDAO {
String deleteDBQuery = String deleteDBQuery =
"DELETE FROM CONNECTED_CUP_DEVICE WHERE CONNECTED_CUP_DEVICE_ID = ?"; "DELETE FROM CONNECTED_CUP_DEVICE WHERE CONNECTED_CUP_DEVICE_ID = ?";
stmt = conn.prepareStatement(deleteDBQuery); stmt = conn.prepareStatement(deleteDBQuery);
stmt.setString(1, iotDeviceId); stmt.setString(1, deviceId);
int rows = stmt.executeUpdate(); int rows = stmt.executeUpdate();
if (rows > 0) { if (rows > 0) {
status = true; status = true;
if (log.isDebugEnabled()) { if (log.isDebugEnabled()) {
log.debug("Connected Cup device " + iotDeviceId + " data has deleted" + log.debug("Connected Cup device " + deviceId + " data has deleted" +
" from the Connected Cup database."); " from the Connected Cup database.");
} }
} }
} catch (SQLException e) { } catch (SQLException e) {
String msg = "Error occurred while deleting Connected Cup device " + iotDeviceId; String msg = "Error occurred while deleting Connected Cup device " + deviceId;
log.error(msg, e); log.error(msg, e);
throw new IotDeviceManagementDAOException(msg, e); throw new ConnectedCupDeviceMgtPluginException(msg, e);
} finally { } finally {
IotDeviceManagementDAOUtil.cleanupResources(stmt, null); ConnectedCupUtils.cleanupResources(stmt, null);
} }
return status; return status;
} }
@Override public List<Device> getAllDevices() throws ConnectedCupDeviceMgtPluginException {
public List<IotDevice> getAllIotDevices()
throws IotDeviceManagementDAOException {
Connection conn = null; Connection conn = null;
PreparedStatement stmt = null; PreparedStatement stmt = null;
ResultSet resultSet = null; ResultSet resultSet = null;
IotDevice iotDevice; Device connectedCupDevice;
List<IotDevice> iotDevices = new ArrayList<>(); List<Device> iotDevices = new ArrayList<>();
try { try {
conn = ConnectedCupDAO.getConnection(); conn = ConnectedCupDAO.getConnection();
@ -212,28 +209,32 @@ public class ConnectedCupDAOImpl implements IotDeviceDAO {
stmt = conn.prepareStatement(selectDBQuery); stmt = conn.prepareStatement(selectDBQuery);
resultSet = stmt.executeQuery(); resultSet = stmt.executeQuery();
while (resultSet.next()) { while (resultSet.next()) {
iotDevice = new IotDevice(); connectedCupDevice = new Device();
iotDevice.setIotDeviceId(resultSet.getString(ConnectedCupConstants.DEVICE_PLUGIN_DEVICE_ID)); connectedCupDevice.setDeviceIdentifier(resultSet.getString(
iotDevice.setIotDeviceName(resultSet.getString(ConnectedCupConstants.DEVICE_PLUGIN_DEVICE_NAME)); ConnectedCupConstants.DEVICE_PLUGIN_DEVICE_ID));
connectedCupDevice.setName(resultSet.getString(
Map<String, String> propertyMap = new HashMap<>(); ConnectedCupConstants.DEVICE_PLUGIN_DEVICE_NAME));
propertyMap.put(ConnectedCupConstants.DEVICE_PLUGIN_PROPERTY_ACCESS_TOKEN,
resultSet.getString("ACCESS_TOKEN")); List<Device.Property> propertyList = new ArrayList<Device.Property>();
propertyMap.put(ConnectedCupConstants.DEVICE_PLUGIN_PROPERTY_REFRESH_TOKEN, propertyList.add(ConnectedCupUtils.getProperty(
resultSet.getString("REFRESH_TOKEN")); ConnectedCupConstants.DEVICE_PLUGIN_PROPERTY_ACCESS_TOKEN,
iotDevice.setDeviceProperties(propertyMap); resultSet.getString("ACCESS_TOKEN")));
iotDevices.add(iotDevice); propertyList.add(ConnectedCupUtils.getProperty(
ConnectedCupConstants.DEVICE_PLUGIN_PROPERTY_REFRESH_TOKEN,
resultSet.getString("REFRESH_TOKEN")));
connectedCupDevice.setProperties(propertyList);
} }
if (log.isDebugEnabled()) { if (log.isDebugEnabled()) {
log.debug("All Connected Cup device details have fetched from Connected Cup database."); log.debug("All Connected Cup device details have fetched from Connected Cup database" +
".");
} }
return iotDevices; return iotDevices;
} catch (SQLException e) { } catch (SQLException e) {
String msg = "Error occurred while fetching all Connected Cup device data'"; String msg = "Error occurred while fetching all Connected Cup device data'";
log.error(msg, e); log.error(msg, e);
throw new IotDeviceManagementDAOException(msg, e); throw new ConnectedCupDeviceMgtPluginException(msg, e);
} finally { } finally {
IotDeviceManagementDAOUtil.cleanupResources(stmt, resultSet); ConnectedCupUtils.cleanupResources(stmt, resultSet);
ConnectedCupDAO.closeConnection(); ConnectedCupDAO.closeConnection();
} }

@ -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);
} }

@ -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) {
}
} }

Loading…
Cancel
Save