import java.util.List;
/**
- * Default implementation of basic Create, Read, Delete operations
+ * Default implementation of basic CRUD operations
*
* @param <T> type of Entity
* @param <ID> type of ID of Entity
* @see Device
* @since 2017-06-26
*/
-public interface DeviceService {
+public interface DeviceService extends CommonService<Device> {
+ /**
+ * Service method provides getting List of all devices in DB.
+ *
+ * @return List<{@link Device}> containing all devices in DB.
+ */
+ List<Device> getAll();
+
/**
* Service method returns Device by UUID in DB.
*
Device init(String uuid, String name, String type, String model, int status, User user, String route);
/**
+ * Remove all devices
+ */
+ void removeAll();
+
+ /**
* Remove all specified devices
*
* @param devices devices
* @see Report
* @since 2016-09-01
*/
-public interface ReportService {
+public interface ReportService extends CommonService<Report> {
/**
* Service method saves report.
*
List<Report> findReportsByDeviceUuid(String deviceUuid);
/**
+ * Find all reports
+ */
+ List<Report> findAll();
+
+
+ /**
* Service method provides getting Smart Security report by Device id.
*
* @param deviceId id of Device
* @param report report
*/
Report saveReport(long deviceId, String type, String date, int result, String report);
+
+ /**
+ * Remove all
+ */
+ void removeAll();
}
import com.samsung.commons.domain.Device;
import com.samsung.commons.domain.User;
import com.samsung.commons.repository.DeviceRepository;
-import com.samsung.commons.service.CommonCrudService;
import com.samsung.commons.service.DeviceService;
import com.samsung.commons.service.PolicyService;
import org.springframework.beans.factory.annotation.Autowired;
* @since 2017-06-26
*/
@Service("deviceService")
-public class DeviceServiceImpl extends CommonCrudService<Device, Long> implements DeviceService {
+public class DeviceServiceImpl implements DeviceService {
+ @Autowired
private DeviceRepository deviceRepository;
@Autowired
private PolicyService policyService;
- /**
- * Provide CRUD repository
- *
- * @param repository CRUD repo
- */
- public DeviceServiceImpl(DeviceRepository repository) {
- super(repository);
+ @Override
+ public Device findById(Long id) {
+ return deviceRepository.findOne(id);
+ }
- this.deviceRepository = repository;
+ @Override
+ public List<Device> getAll() {
+ return (List<Device>) deviceRepository.findAll();
}
@Override
- public Device findByUUID(String uuid) {
- return deviceRepository.findByUuid(uuid);
+ public long count() {
+ return deviceRepository.count();
}
@Override
- public List<Device> findByUser(User user) {
- return deviceRepository.findByUserAndRemovedOrderByIdAsc(user, false);
+ public Device save(Device device) {
+ device = deviceRepository.save(device);
+
+ return device;
}
@Override
- public List<Device> findUserDevicesByType(long userId, String type) {
- return deviceRepository.findByUserIdAndType(userId, type);
+ public void remove(Device device) {
+ deviceRepository.delete(device);
}
@Override
- public List<Device> findUserDevicesByStatus(long userId, int status) {
- return deviceRepository.findByUserIdAndStatus(userId, status);
+ public Device findByUUID(String uuid) {
+ return deviceRepository.findByUuid(uuid);
+ }
+
+ @Override
+ public List<Device> findByUser(User user) {
+ return deviceRepository.findByUserAndRemovedOrderByIdAsc(user, false);
}
@Override
agent.setDevice(device);
device.getAgents().add(agent);
- return save(device);
+ return deviceRepository.save(device);
+ }
+
+ @Override
+ public void removeAll() {
+ deviceRepository.deleteAll();
}
@Override
public void remove(Set<Device> devices) {
for (Device device : devices) {
- delete(device);
+ remove(device);
}
}
return save(new Device(uuid, name, type, model, status, policyService.initPolicy(route), user));
}
+
+ @Override
+ public List<Device> findUserDevicesByStatus(long userId, int status) {
+ return deviceRepository.findByUserIdAndStatus(userId, status);
+ }
+
+ @Override
+ public List<Device> findUserDevicesByType(long userId, String type) {
+ return deviceRepository.findByUserIdAndType(userId, type);
+ }
}
import com.samsung.commons.repository.DeviceRepository;
import com.samsung.commons.repository.ReportRepository;
import com.samsung.commons.repository.ReportTypeRepository;
-import com.samsung.commons.service.CommonCrudService;
import com.samsung.commons.service.ReportService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
* @since 2016-09-01
*/
@Service("reportService")
-public class ReportServiceImpl extends CommonCrudService<Report, Long> implements ReportService {
+public class ReportServiceImpl implements ReportService {
+ @Autowired
private ReportRepository reportRepository;
@Autowired
@Autowired
private DeviceRepository deviceRepository;
- /**
- * Provide CRUD repository
- *
- * @param repository CRUD repo
- */
- public ReportServiceImpl(ReportRepository repository) {
- super(repository);
-
- this.reportRepository = repository;
+ @Override
+ public Report save(Report t) {
+ t.setReport(strip(t.getReport()));
+ return reportRepository.save(t);
}
- @Override
- public Report save(Report report) {
- report.setReport(strip(report.getReport()));
- return reportRepository.save(report);
+ private String strip(String str){
+ return str.replace("\n", "").replace("\b", "").replace("\t", "").replace("\r", "");
}
@Override
}
@Override
- public Report saveReport(long deviceId, String type, String date, int result, String report) {
- Report deviceReport = findReport(deviceId, ReportType.Type.getType(type));
+ public void remove(Report report) {
+ reportRepository.delete(report);
+ }
- if (deviceReport == null) {
- return save(deviceId, type, date, result, report);
- } else {
- deviceReport.setReport(report);
- return save(deviceReport);
- }
+ @Override
+ public Report findById(Long id) {
+ return reportRepository.findOne(id);
+ }
+
+ @Override
+ public long count() {
+ return reportRepository.count();
}
@Override
return reportRepository.findByDeviceUuid(deviceUuid);
}
- private String strip(String str){
- return str.replace("\n", "").replace("\b", "").replace("\t", "").replace("\r", "");
+ @Override
+ public List<Report> findAll() {
+ return (List<Report>) reportRepository.findAll();
+ }
+
+ @Override
+ public Report saveReport(long deviceId, String type, String date, int result, String report) {
+ Report deviceReport = findReport(deviceId, ReportType.Type.getType(type));
+
+ if (deviceReport == null) {
+ return save(deviceId, type, date, result, report);
+ } else {
+ deviceReport.setReport(report);
+ return save(deviceReport);
+ }
+ }
+
+ @Override
+ public void removeAll() {
+ reportRepository.deleteAll();
}
}
\ No newline at end of file
import com.samsung.commons.domain.Policy;
import com.samsung.commons.domain.User;
import com.samsung.commons.service.impl.AgentServiceImpl;
-import com.samsung.commons.service.impl.DeviceServiceImpl;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
private UserService userService;
@Autowired
- private DeviceServiceImpl deviceService;
+ private DeviceService deviceService;
private Agent agent;
@After
public void after() {
- deviceService.deleteAll();
+ deviceService.removeAll();
agentService.deleteAll();
}
import com.samsung.commons.domain.*;
import com.samsung.commons.repository.ReportTypeRepository;
import com.samsung.commons.service.impl.AgentServiceImpl;
-import com.samsung.commons.service.impl.DeviceServiceImpl;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
private UserService userService;
@Autowired
- private DeviceServiceImpl deviceService;
+ private DeviceService deviceService;
@Autowired
private PolicyService policyService;
@After
public void after() {
- deviceService.deleteAll();
+ deviceService.removeAll();
// Some agents aren't bound to device (so need to delete'em separately)
agentService.deleteAll();
}
@Test
+ public void testGetAll() {
+ assertEquals(deviceService.getAll().size(), 2);
+ }
+
+ @Test
public void testSave() {
String route = "route";
Policy policy = policyService.initPolicy(route);
}
@Test
+ public void testRemove() {
+ Policy policy = policyService.initPolicy("route");
+ Device newDevice = deviceService.save(new Device("newuuid", "newname", "newtype", "newmodel", 0, policy, user));
+ deviceService.remove(deviceService.findById(newDevice.getId()));
+ assertNull(deviceService.findById(newDevice.getId()));
+ }
+
+ // Just to increase coverage
+ // Must remove all without exceptions
+ @Test
+ public void testRemoveAll() {
+ Device saved = deviceService.save(new Device("some_uuid", "name", "type", "model", 1, policyService.initPolicy("route"), user));
+
+ HashSet<Device> devices = new HashSet<>();
+ devices.add(saved);
+
+ deviceService.remove(devices);
+ }
+
+ @Test
public void testFindByUUID() {
assertEquals(DEVICE_UUID, deviceService.findByUUID(DEVICE_UUID).getUuid());
}
+ @Test
+ public void testCount() {
+ assertEquals(deviceService.count(), 2);
+ }
+
@Test(expected = IllegalArgumentException.class)
public void testAddAgentToNotFoundDevice() {
deviceService.setDeviceAgents(UNEXISTENT_UUID, new Agent());
@Test
public void testAgentsAndReportsMustBeRemovedWithDevice() {
- deviceService.delete(deviceService.findByUUID(DEVICE_UUID));
+ deviceService.remove(deviceService.findByUUID(DEVICE_UUID));
// Device removed
assertNull(deviceService.findByUUID(DEVICE_UUID));
try {
deviceService.init(initUuid, "duplikatename", "duplikatetype", "duplikatemodel", 0, user, "route");
+ } catch (Exception e) {
+ throw e;
} finally {
- deviceService.delete(initedDevice);
+ deviceService.remove(initedDevice);
}
}
import com.samsung.commons.domain.Policy;
import com.samsung.commons.domain.User;
import com.samsung.commons.service.impl.AgentServiceImpl;
-import com.samsung.commons.service.impl.DeviceServiceImpl;
import com.samsung.commons.service.impl.PolicyServiceImpl;
import org.junit.After;
import org.junit.Before;
private PolicyServiceImpl policyService;
@Autowired
- private DeviceServiceImpl deviceService;
+ private DeviceService deviceService;
@Autowired
private AgentServiceImpl agentService;
@After
public void after() {
- deviceService.delete(device);
+ deviceService.remove(device);
agentService.delete(agent);
}
assertNotNull(policyService.findByDeviceId(newDevice.getId()));
policyService.delete(policyService.findByDeviceId(newDevice.getId()));
assertEquals("", policyService.findByDeviceId(newDevice.getId()).getPolicy());
- deviceService.delete(newDevice);
+ deviceService.remove(newDevice);
assertNull(policyService.findOne(policy.getId()));
}
import com.samsung.commons.domain.Report;
import com.samsung.commons.domain.ReportType;
import com.samsung.commons.repository.ReportTypeRepository;
-import com.samsung.commons.service.impl.DeviceServiceImpl;
-import com.samsung.commons.service.impl.ReportServiceImpl;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
public class ReportServiceTest {
@Autowired
- private ReportServiceImpl reportService;
+ private ReportService reportService;
@Autowired
- private DeviceServiceImpl deviceService;
+ private DeviceService deviceService;
@Autowired
private UserService userService;
private ReportType reportType;
+ private Report report;
private static final long NON_EXISTENT_ID = 42L;
@Before
public void before() {
- device = deviceService.save(new Device("uuid", "name", "type", "model", 1,
- policyService.initPolicy("policy"), userService.findUserByEmail("admin@samsung.com")));
-
- reportType = reportTypeRepository.findByType(SIM.type);
-
- reportService.save(new Report(reportType, "report", "date", 0, device));
+ device = new Device("uuid", "name", "type", "model", 1,
+ policyService.initPolicy("policy"), userService.findUserByEmail("admin@samsung.com"));
+ deviceService.save(device);
+ reportType = reportTypeRepository.findByType(ReportType.Type.SIM.type);
+ report = reportService.save(new Report(reportType, "report", "date", 0, device));
}
@After
public void after() {
- deviceService.deleteAll();
+ deviceService.removeAll();
+ }
+
+ @Test
+ public void test_Save() {
+ assertThat(reportService.save(device.getId(), SMART_SECURITY.type, "date", 1, "report"), is(notNullValue()));
}
@Test
- public void saveNewOrSaveForFound() {
+ public void test_Save_Report() {
// Report was found
assertThat(reportService.saveReport(device.getId(), SIM.type, "date", 1, "report"), is(notNullValue()));
}
@Test(expected = IllegalArgumentException.class)
- public void saveReportWrongDeviceId() {
+ public void test_Save_Report_Wrong_Device_Id() {
reportService.saveReport(NON_EXISTENT_ID, SMART_SECURITY.type, null, 0, null);
}
@Test
- public void findReportsByDeviceId() {
+ public void test_Find_Report_By_Id() {
+ assertThat(reportService.findById(report.getId()), is(notNullValue()));
+ assertThat(reportService.findById(NON_EXISTENT_ID), is(nullValue()));
+ }
+
+ @Test
+ public void test_Find_Reports_By_Device_Id() {
assertThat(reportService.findReportsByDeviceId(device.getId()), is(not(empty())));
assertThat(reportService.findReportsByDeviceId(NON_EXISTENT_ID), is(empty()));
}
@Test
- public void findByDidAndType() {
- assertThat(reportService.findReport(device.getId(), SIM), is(notNullValue()));
+ public void test_Find_Report_By_Did_And_Type() {
+ assertThat(reportService.findReport(device.getId(), ReportType.Type.SIM), is(notNullValue()));
+ }
+
+ @Test
+ public void test_Find_Report_By_Did_And_Type_Negative() {
+ assertThat(reportService.findReport(device.getId(), ReportType.Type.SMACK), is(nullValue()));
+ assertThat(reportService.findReport(NON_EXISTENT_ID, ReportType.Type.SIM), is(nullValue()));
+ }
+
+ @Test
+ public void test_FindAll() {
+ assertThat(reportService.findAll().size(), is(1));
+ }
+
+ @Test
+ public void test_Remove() {
+ reportService.remove(report);
+ assertThat(reportService.findAll(), is(empty()));
+ }
+
+ @Test
+ public void test_RemoveAll() {
+ reportService.removeAll();
+ assertThat(reportService.findAll(), is(empty()));
}
@Test
- public void findByDidAndTypeNegative() {
- assertThat(reportService.findReport(device.getId(), SMACK), is(nullValue()));
- assertThat(reportService.findReport(NON_EXISTENT_ID, SIM), is(nullValue()));
+ public void test_Count() {
+ assertThat(reportService.count(), is(1L));
}
}
import javax.servlet.http.HttpServletRequest;
import javax.validation.Valid;
-import com.samsung.commons.service.impl.DeviceServiceImpl;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import com.samsung.commons.domain.User;
import com.samsung.commons.model.MQPolicy;
import com.samsung.commons.service.AgentService;
+import com.samsung.commons.service.DeviceService;
import com.samsung.commons.service.PolicyService;
import com.samsung.commons.service.ReportService;
import com.samsung.commons.service.UserService;
import com.samsung.dsm.policy.parser.PolicyParserFactory;
import com.samsung.dsm.rest.mq.MQSenderImpl;
-import static com.samsung.dsm.policy.parser.PolicyParserFactory.Type.JSON;
-
/**
* <h1> Dashboard Devices controller</h1>
* Provides IoT Devices management methods.
private UserService userService;
@Autowired
- private DeviceServiceImpl deviceService;
+ private DeviceService deviceService;
@Autowired
private AgentService agentService;
@RequestMapping(value = "/overview/{id}", method = RequestMethod.GET)
public String iotDeviceOverview(Model model, @PathVariable Long id) {
ViewDevice viewDevice;
- Device device = deviceService.findOne(id);
+ Device device = deviceService.findById(id);
try {
viewDevice = new ViewDevice(device);
- viewDevice.setOverview(new DeviceOverview(device.getPolicy().getPolicy(), JSON,
+ viewDevice.setOverview(new DeviceOverview(device.getPolicy().getPolicy(),
+ PolicyParserFactory.Type.JSON,
reportService.findReportsByDeviceId(id),
agentService.findDeviceAgents(device.getUuid())));
} catch (NullPointerException e) {
@RequestMapping(value = "/reports/{id}", method = RequestMethod.GET)
public String iotDeviceReports(Model model, @PathVariable Long id) {
ViewDevice viewDevice;
- Device device = deviceService.findOne(id);
+ Device device = deviceService.findById(id);
try {
viewDevice = new ViewDevice(device);
@RequestMapping(value = "/agents/{id}", method = RequestMethod.GET)
public String iotDeviceAgents(Model model, @PathVariable Long id) {
ViewDevice viewDevice;
- Device device = deviceService.findOne(id);
+ Device device = deviceService.findById(id);
try {
viewDevice = new ViewDevice(device);
return "redirect:/dashboard/devices";
}
- viewDevice.setAgents(agentService.findDeviceAgents(device.getUuid()), JSON);
+ viewDevice.setAgents(agentService.findDeviceAgents(device.getUuid()), PolicyParserFactory.Type.JSON);
model.addAttribute("device", viewDevice);
return "device-agents";
@RequestMapping(value = "/policies/{id}", method = RequestMethod.GET)
public String iotDevicePolicies(Model model, @PathVariable Long id) {
try {
- ViewDevice device = new ViewDevice(deviceService.findOne(id), JSON);
+ ViewDevice device = new ViewDevice(deviceService.findById(id), PolicyParserFactory.Type.JSON);
model.addAttribute("device", device);
} catch (NullPointerException e) {
log.error("There is no user with such id", e);
return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
}
try {
- PolicyConfigParser parser = new PolicyParserFactory().getParser(JSON);
+ PolicyConfigParser parser = new PolicyParserFactory().getParser(PolicyParserFactory.Type.JSON);
parser.toPolicyObject(policy.getPolicies());
Device device = deviceService.findByUUID(policy.getUuid());
Policy fullPolicy = policyService.findByDeviceId(device.getId());
*/
package com.samsung.dsm.rest.report;
+import static java.lang.String.format;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.StringJoiner;
+
+import org.apache.log4j.Logger;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.samsung.commons.domain.Report;
import com.samsung.commons.model.Notification;
import com.samsung.commons.service.IotCloudService;
-import com.samsung.commons.service.impl.ReportServiceImpl;
+import com.samsung.commons.service.ReportService;
import com.samsung.dsm.report.analyzer.impl.MACReportAnalyzer;
import com.samsung.dsm.rest.mq.MQSenderImpl;
import com.samsung.dsm.service.GrantedApplicationService;
-import org.apache.log4j.Logger;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.web.bind.annotation.PathVariable;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.ResponseBody;
-import org.springframework.web.bind.annotation.RestController;
-
-import java.util.*;
-
-import static java.lang.String.format;
/**
* <h1>Report API</h1> Report REST operations
public static final String FOR_STUB = "smack_test";
@Autowired
- private ReportServiceImpl reportService;
+ private ReportService reportService;
@Autowired
private IotCloudService iotCloudService;
@RequestMapping(value = "/newreport/{reportId}")
public void newReportNotification(@PathVariable Long reportId) {
log.info("Get new report" + reportId);
- Report report = reportService.findOne(reportId);
+ Report report = reportService.findById(reportId);
log.info("============================REPORT=====================================");
log.info(report);
log.info("=======================================================================");
package com.samsung.dsm.controller;
-import com.samsung.commons.service.impl.DeviceServiceImpl;
+import com.samsung.commons.service.DeviceService;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;
-import java.security.Principal;
-
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
+import java.security.Principal;
+
/**
* @author Mail to: <A HREF="mailto:a.motchanyi@samsung.com">Artem Motchanyi, a.motchanyi@samsung.com</A>
* @version 1.0
@WebAppConfiguration
@DirtiesContext(classMode = DirtiesContext.ClassMode.BEFORE_CLASS)
public class DashboardDevicesControllerTest {
- /**
- * The mock mvc.
- */
+ /** The mock mvc. */
private MockMvc mockMvc;
- /**
- * The web application context.
- */
+ /** The web application context. */
@Autowired
private WebApplicationContext webApplicationContext;
@Autowired
- private DeviceServiceImpl deviceService;
+ private DeviceService deviceService;
@Mock
private Principal principalMock;
@After
public void after() {
- deviceService.deleteAll();
+ deviceService.removeAll();
}
/**
@Test
public void dashboardNegativeTest() throws Exception {
mockMvc.perform(get("/dashboard/devices/").principal(principalMock))
- .andExpect(status().isOk())
- .andExpect(view().name("devices"))
- .andExpect(forwardedUrl("devices"));
+ .andExpect(status().isOk())
+ .andExpect(view().name("devices"))
+ .andExpect(forwardedUrl("devices"));
}
}
package com.samsung.dsm.rest;
-import com.samsung.commons.domain.Agent;
-import com.samsung.commons.domain.Device;
-import com.samsung.commons.domain.User;
-import com.samsung.commons.service.IotCloudService;
-import com.samsung.commons.service.PolicyService;
-import com.samsung.commons.service.impl.DeviceServiceImpl;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
import com.samsung.commons.service.impl.RoleServiceImpl;
import com.samsung.commons.service.impl.UserServiceImpl;
-import com.samsung.dsm.utils.JsonUtils;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;
-import java.util.*;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+import com.samsung.commons.domain.Agent;
+import com.samsung.commons.domain.Device;
+import com.samsung.commons.domain.User;
+import com.samsung.commons.service.DeviceService;
+import com.samsung.commons.service.IotCloudService;
+import com.samsung.commons.service.PolicyService;
+import com.samsung.commons.service.RoleService;
+import com.samsung.commons.service.UserService;
+import com.samsung.dsm.utils.JsonUtils;
@RunWith(SpringJUnit4ClassRunner.class)
private IotCloudService iotCloudService;
@Autowired
- private DeviceServiceImpl deviceService;
+ private DeviceService deviceService;
@Autowired
private PolicyService policyService;
import com.samsung.commons.domain.Device;
import com.samsung.commons.domain.Policy;
import com.samsung.commons.domain.User;
+import com.samsung.commons.service.DeviceService;
import com.samsung.commons.service.PolicyService;
import com.samsung.commons.service.UserService;
-import com.samsung.commons.service.impl.DeviceServiceImpl;
import com.samsung.commons.utils.UrlBuilder;
import com.samsung.dsm.utils.JsonUtils;
import org.junit.After;
private UserService userService;
@Autowired
- private DeviceServiceImpl deviceService;
+ private DeviceService deviceService;
@Autowired
private PolicyService policyService;
@After
public void after() {
- deviceService.deleteAll();
+ for (Device device : devices) {
+ deviceService.remove(device);
+ }
}
@Test
import com.samsung.commons.domain.User;
import com.samsung.commons.repository.ReportTypeRepository;
import com.samsung.commons.service.*;
-import com.samsung.commons.service.impl.DeviceServiceImpl;
-import com.samsung.commons.service.impl.IotCloudServiceImpl;
-import com.samsung.commons.service.impl.PolicyServiceImpl;
-import com.samsung.commons.service.impl.ReportServiceImpl;
import com.samsung.dsm.utils.CloudUserBuilder;
import com.samsung.dsm.utils.UserBuilder;
import org.junit.After;
private ReportTypeRepository reportTypeRepository;
@Autowired
- private ReportServiceImpl reportService;
+ private ReportService reportService;
@Autowired
private UserService userService;
@Autowired
- private DeviceServiceImpl deviceService;
+ private DeviceService deviceService;
@Autowired
- private PolicyServiceImpl policyService;
+ private PolicyService policyService;
@Autowired
- private IotCloudServiceImpl iotCloudService;
+ private IotCloudService iotCloudService;
@Autowired
private UserBuilder userBuilder;
@After
public void after() {
- reportService.deleteAll();
- deviceService.deleteAll();
+ reportService.removeAll();
+ deviceService.removeAll();
+
+ // userService.removeAll();
iotCloudService.deleteAllUsers();
}
package com.samsung.servermq.iotivity;
-import com.samsung.servermq.iotivity.extractor.PostDataExtractor;
+import java.util.List;
+
import org.apache.log4j.Logger;
import org.iotivity.cloud.mqserver.topic.Topic;
import org.iotivity.cloud.mqserver.topic.TopicManager;
-import java.util.Arrays;
-import java.util.List;
-
-import static java.lang.String.format;
+import com.samsung.servermq.iotivity.extractor.PostDataExtractor;
public class MessageQueueListener {
private PostDataExtractor extractor;
private String listenerName;
- public MessageQueueListener(String topicName,
+ public MessageQueueListener(String topicName,
PostDataExtractor extractor,
String listenerName, String zookeperHost, String kafkaHost) {
log.debug("Created " + listenerName);
}
- public List<byte[]> getMessages() {
- List<byte[]> messages = kafkaConsumer.getMessages();
- for (byte[] message : messages) {
- log.debug(format("%s get message: %s", getListenerName(), Arrays.toString(message)));
- extractor.extract(message);
- }
- return messages;
- }
+ public List<byte[]> getMessages() {
+ List<byte[]> messages = kafkaConsumer.getMessages();
+ for (byte[] message : messages) {
+ log.debug(getListenerName() + " get message: " + (new String(message)));
+ extractor.extract(message);
+ }
+ return messages;
+ }
public KafkaConsumerWrapper getKafkaConsumer() {
return kafkaConsumer;
public void setExtractor(PostDataExtractor extractor) {
this.extractor = extractor;
}
-
-
+
+
}
projects / platform / core / security / suspicious-activity-monitor.git / commitdiff