Merge pull request #75 from ayyoob/configConnectedCup

few changes in connected cup to remove the dependent with the configu…

modules/samples/connectedcup/component/plugin/src/main/java/org/coffeeking/connectedcup/plugin/constants/ConnectedCupConstants.java

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

modules/samples/connectedcup/component/plugin/src/main/java/org/coffeeking/connectedcup/plugin/exception/ConnectedCupDeviceMgtPluginException.java

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

modules/samples/connectedcup/component/plugin/src/main/java/org/coffeeking/connectedcup/plugin/impl/ConnectedCupManager.java

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

modules/samples/connectedcup/component/plugin/src/main/java/org/coffeeking/connectedcup/plugin/impl/ConnectedCupManagerService.java

@@ -18,6 +18,7 @@
 
 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.DeviceManagementException;
 import org.wso2.carbon.device.mgt.common.DeviceManager;
@@ -34,8 +35,7 @@ public class ConnectedCupManagerService implements DeviceManagementService{
 
 	@Override
 	public String getType() {
-		return "connectedcup";
+		return ConnectedCupConstants.DEVICE_TYPE;
-        //TODO: Constant
 	}
 
 

modules/samples/connectedcup/component/plugin/src/main/java/org/coffeeking/connectedcup/plugin/impl/dao/ConnectedCupDAO.java

@@ -21,102 +21,112 @@ package org.coffeeking.connectedcup.plugin.impl.dao;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 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.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 java.sql.Connection;
 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();
-    }
+		}
+	}
 }

modules/samples/connectedcup/component/plugin/src/main/java/org/coffeeking/connectedcup/plugin/impl/dao/impl/ConnectedCupDAOImpl.java

@@ -21,222 +21,223 @@ package org.coffeeking.connectedcup.plugin.impl.dao.impl;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.coffeeking.connectedcup.plugin.constants.ConnectedCupConstants;
+import org.coffeeking.connectedcup.plugin.exception.ConnectedCupDeviceMgtPluginException;
 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.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.ArrayList;
-import java.util.HashMap;
 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();
+		}
+
+	}
+
+}

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

@@ -20,7 +20,13 @@ package org.coffeeking.connectedcup.plugin.impl.dao.util;
 
 import org.apache.commons.logging.Log;
 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;
 
 /**
@@ -30,15 +36,52 @@ public class ConnectedCupUtils {
 
     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);
     }
 
 

modules/samples/connectedcup/component/plugin/src/main/java/org/coffeeking/connectedcup/plugin/internal/ConnectedCupServiceComponent.java

@@ -25,18 +25,11 @@ import org.osgi.framework.BundleContext;
 import org.osgi.framework.ServiceRegistration;
 import org.osgi.service.component.ComponentContext;
 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
  * .ConnectedCupServiceComponent"
  * 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 {
@@ -77,15 +70,4 @@ public class ConnectedCupServiceComponent {
             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) {
-    }
 }