private List<MetricsBulletChartNVD3> getMetricsBulletChart(
      List<Integer> variableIds, Long timestampFrom, Long timestampTo) {
    ArrayList<MetricsBulletChartNVD3> bulletCharts = new ArrayList<MetricsBulletChartNVD3>();
    List<SensorVariable> sensorVariables = DaoUtils.getSensorVariableDao().getAll(variableIds);
    // Update from/to time
    MetricsDoubleTypeDevice queryInput =
        MetricsDoubleTypeDevice.builder()
            .timestampFrom(timestampFrom)
            .timestampTo(timestampTo)
            .build();
    for (SensorVariable sensorVariable : sensorVariables) {
      // Update sensor variable
      queryInput.setSensorVariable(sensorVariable);
      MetricsDoubleTypeDevice metric =
          DaoUtils.getMetricsDoubleTypeDeviceDao().getMinMaxAvg(queryInput);

      String unit = sensorVariable.getUnit() != "" ? " (" + sensorVariable.getUnit() + ")" : "";

      // If current value not available, do not allow any value
      if (sensorVariable.getValue() == null || metric.getMin() == null) {
        bulletCharts.add(
            MetricsBulletChartNVD3.builder()
                .id(sensorVariable.getId())
                .resourceName(
                    new ResourceModel(RESOURCE_TYPE.SENSOR_VARIABLE, sensorVariable)
                            .getResourceLessDetails()
                        + unit)
                .displayName(
                    sensorVariable.getSensor().getName()
                        + " >> "
                        + sensorVariable.getVariableType().getText()
                        + unit)
                .build());
      } else {
        bulletCharts.add(
            MetricsBulletChartNVD3.builder()
                .id(sensorVariable.getId())
                // .title(sensorVariable.getVariableType().getText())
                // .subtitle(sensorVariable.getUnit())
                .ranges(new Object[] {metric.getMin(), metric.getAvg(), metric.getMax()})
                .measures(new Object[] {sensorVariable.getValue()})
                .markers(new Object[] {sensorVariable.getPreviousValue()})
                .resourceName(
                    new ResourceModel(RESOURCE_TYPE.SENSOR_VARIABLE, sensorVariable)
                            .getResourceLessDetails()
                        + unit)
                .displayName(
                    sensorVariable.getSensor().getName()
                        + " >> "
                        + sensorVariable.getVariableType().getText()
                        + unit)
                .build());
      }
    }
    return bulletCharts;
  }
 private void checkHearbeat() {
   List<Node> nodes = DaoUtils.getNodeDao().getAll();
   long aliveCheckInterval =
       ObjectFactory.getAppProperties().getControllerSettings().getAliveCheckInterval();
   if (aliveCheckInterval < MycUtils.MINUTE) {
     aliveCheckInterval = MycUtils.MINUTE;
   }
   for (Node node : nodes) {
     if (node.getLastSeen() == null
         || node.getLastSeen() <= (System.currentTimeMillis() - aliveCheckInterval)) {
       node.setState(STATE.DOWN);
       DaoUtils.getNodeDao().update(node);
       _logger.debug("Node is in not reachable state, Node:[{}]", node);
     }
   }
 }
Ejemplo n.º 3
0
  private ArrayList<MetricsChartDataKeyValuesJson> getAllAfter(
      AGGREGATION_TYPE aggregationType, int sensorId) {
    MetricsAggregationBase metricsAggregationBase = new MetricsAggregationBase();
    Sensor sensor =
        DaoUtils.getSensorDao()
            .get(sensorId); // Here sensorId means 'id'(db reference) not actual sensorId

    ArrayList<MetricsChartDataKeyValuesJson> finalData =
        new ArrayList<MetricsChartDataKeyValuesJson>();

    if (sensor.getMetricType() == null) {
      // Sensor pay load type not up to date
      _logger.debug("Payload type not updated in sensor.");
      return null;
    } else if (sensor.getMetricType() == MyMessages.PAYLOAD_TYPE.PL_DOUBLE.ordinal()) {
      _logger.debug("Payload type: {}", MyMessages.PAYLOAD_TYPE.PL_DOUBLE.toString());
      List<MetricsDoubleTypeDevice> metrics =
          metricsAggregationBase.getMetricsDoubleTypeAllAfter(aggregationType, sensor);
      if (metrics == null) {
        // throw new ApiError("No data available");
        return null;
      }

      MetricsChartDataKeyValuesJson minChartData = new MetricsChartDataKeyValuesJson("Minimum");
      MetricsChartDataKeyValuesJson avgChartData = new MetricsChartDataKeyValuesJson("Average");
      MetricsChartDataKeyValuesJson maxChartData = new MetricsChartDataKeyValuesJson("Maximum");

      for (MetricsDoubleTypeDevice metric : metrics) {
        minChartData.add(new Object[] {metric.getTimestamp(), metric.getMin()});
        avgChartData.add(new Object[] {metric.getTimestamp(), metric.getAvg()});
        maxChartData.add(new Object[] {metric.getTimestamp(), metric.getMax()});
      }

      finalData.add(minChartData);
      finalData.add(avgChartData);
      finalData.add(maxChartData);
    } else if (sensor.getMetricType() == MyMessages.PAYLOAD_TYPE.PL_BOOLEAN.ordinal()) {
      _logger.debug("Payload type: {}", MyMessages.PAYLOAD_TYPE.PL_BOOLEAN.toString());
      List<MetricsOnOffTypeDevice> metrics =
          metricsAggregationBase.getMetricsBooleanTypeAllAfter(aggregationType, sensor);
      if (metrics == null) {
        // throw new ApiError("No data available");
        return null;
      }

      String name = sensor.getName() != null ? sensor.getName() : "State";
      MetricsChartDataKeyValuesJson minChartData = new MetricsChartDataKeyValuesJson(name);

      for (MetricsOnOffTypeDevice metric : metrics) {
        minChartData.add(new Object[] {metric.getTimestamp(), metric.getState() ? 1 : 0});
      }

      finalData.add(minChartData);
    }

    return finalData;
  }
 @Override
 public Principal authenticate(String aUsername, String aPassword) throws SecurityException {
   _logger.debug("User:{},Password:{}", aUsername, aPassword);
   User user = DaoUtils.getUserDao().get(aUsername);
   if (user != null) {
     _logger.debug("User Found...User:{}", user);
     if (user.getPassword().equals(aPassword)) {
       user.setPassword(null);
       return user;
     }
   }
   throw new SecurityException("Access denied to user " + aUsername);
 }
 private void sendHearbeat() {
   List<Node> nodes = DaoUtils.getNodeDao().getAll();
   for (Node node : nodes) {
     switch (node.getGateway().getNetworkType()) {
       case MY_SENSORS:
         ObjectFactory.getIActionEngine(NETWORK_TYPE.MY_SENSORS).sendAliveStatusRequest(node);
         break;
       default:
         // TODO: not supported
         return;
     }
   }
 }
 public static boolean login(String aUsername, String aPassword) {
   if (aUsername == null || aPassword == null) {
     return false;
   }
   _logger.debug("User:{},Password:{}", aUsername, aPassword);
   User user = DaoUtils.getUserDao().get(aUsername);
   if (user != null) {
     _logger.debug("User Found...User:{}", user);
     if (user.getPassword().equals(aPassword)) {
       return true;
     }
   }
   return false;
 }
Ejemplo n.º 7
0
 @GET
 @Path("/sensorVariableTypesBySenRef/{sensorRefId}")
 public Response getSensorVariableTypesBySensorRefId(@PathParam("sensorRefId") int sensorRefId) {
   Sensor sensor = DaoUtils.getSensorDao().get(sensorRefId);
   if (sensor != null && sensor.getType() != null) {
     return RestUtils.getResponse(
         Status.OK,
         TypesUtils.getSensorVariableTypes(sensor.getType(), sensor.getVariableTypes()));
   }
   return RestUtils.getResponse(
       Status.BAD_REQUEST,
       new ApiError(
           "Requested Sensor["
               + sensor.getName()
               + "] type not available or Sensor not available"));
 }
 private void unloadLoadSunRiseSetJobs() {
   List<Timer> timers = DaoUtils.getTimerDao().getAllEnabled();
   // reload all jobs
   for (Timer timer : timers) {
     switch (TYPE.get(timer.getType())) {
       case BEFORE_SUNRISE:
       case AFTER_SUNRISE:
       case BEFORE_SUNSET:
       case AFTER_SUNSET:
         SchedulerUtils.reloadTimerJob(timer);
         break;
       default:
         break;
     }
   }
 }
Ejemplo n.º 9
0
  @GET
  @Path("/")
  public Response getAll(
      @QueryParam(Timer.KEY_NAME) List<String> name,
      @QueryParam(Timer.KEY_RESOURCE_TYPE) String resourceType,
      @QueryParam(Timer.KEY_RESOURCE_ID) Integer resourceId,
      @QueryParam(Timer.KEY_TIMER_TYPE) String timerType,
      @QueryParam(Timer.KEY_FREQUENCY) String frequency,
      @QueryParam(Timer.KEY_ENABLED) Boolean enabled,
      @QueryParam(Query.PAGE_LIMIT) Long pageLimit,
      @QueryParam(Query.PAGE) Long page,
      @QueryParam(Query.ORDER_BY) String orderBy,
      @QueryParam(Query.ORDER) String order) {
    HashMap<String, Object> filters = new HashMap<String, Object>();

    filters.put(Timer.KEY_NAME, name);
    filters.put(Timer.KEY_RESOURCE_TYPE, RESOURCE_TYPE.fromString(resourceType));
    filters.put(Timer.KEY_RESOURCE_ID, resourceId);
    filters.put(Timer.KEY_TIMER_TYPE, TIMER_TYPE.fromString(timerType));
    filters.put(Timer.KEY_FREQUENCY, FREQUENCY_TYPE.fromString(frequency));
    filters.put(Timer.KEY_ENABLED, enabled);

    // Add allowed resources filter if he is non-admin
    if (!AuthUtils.isSuperAdmin(securityContext)) {
      filters.put(
          AllowedResources.KEY_ALLOWED_RESOURCES,
          AuthUtils.getUser(securityContext).getAllowedResources());
    }

    QueryResponse queryResponse =
        DaoUtils.getTimerDao()
            .getAll(
                Query.builder()
                    .order(order != null ? order : Query.ORDER_ASC)
                    .orderBy(orderBy != null ? orderBy : Timer.KEY_ID)
                    .filters(filters)
                    .pageLimit(pageLimit != null ? pageLimit : Query.MAX_ITEMS_PER_PAGE)
                    .page(page != null ? page : 1l)
                    .build());
    return RestUtils.getResponse(Status.OK, queryResponse);
  }
 private String getFileName(SensorVariable sensorVariable, AGGREGATION_TYPE aggrType) {
   Sensor sensor = DaoUtils.getSensorDao().getById(sensorVariable.getSensor().getId());
   StringBuilder builder = new StringBuilder();
   builder
       .append(sensor.getNode().getName())
       .append("_")
       .append(sensor.getName())
       .append("_Nid-")
       .append(sensor.getNode().getEui())
       .append("_Sid-")
       .append(sensor.getSensorId())
       .append("_")
       .append(sensorVariable.getVariableType().getText());
   if (sensorVariable.getMetricType() == METRIC_TYPE.DOUBLE) {
     builder.append("_").append("SampleType_").append(aggrType);
   }
   builder
       .append("_")
       .append(new SimpleDateFormat("yyyy-MMM-dd_hh-mm-ss").format(new Date()))
       .append(".csv");
   return builder.toString().replaceAll(" ", "_");
 }
Ejemplo n.º 11
0
 @GET
 @Path("/{id}")
 public Response get(@PathParam("id") int id) {
   hasAccessTimer(id);
   return RestUtils.getResponse(Status.OK, DaoUtils.getTimerDao().getById(id));
 }
  private ArrayList<MetricsChartDataGroupNVD3> getMetricsDataJsonNVD3(
      List<Integer> variableIds,
      Integer sensorId,
      Long timestampFrom,
      Long timestampTo,
      Boolean withMinMax,
      String chartType) {

    // if chartType not null, call this
    if (chartType != null) {
      return getMetricsDataJsonNVD3WithChartType(
          variableIds, timestampFrom, timestampTo, chartType);
    }

    // Get sensor variables
    List<SensorVariable> sensorVariables = null;
    if (!variableIds.isEmpty()) {
      sensorVariables = DaoUtils.getSensorVariableDao().getAll(variableIds);
    } else {
      sensorVariables = DaoUtils.getSensorVariableDao().getAllBySensorId(sensorId);
    }
    // Return if no data available
    if (sensorVariables == null) {
      return new ArrayList<MetricsChartDataGroupNVD3>();
    }

    MetricsGraphSettings metricsGraphSettings =
        ObjectFactory.getAppProperties().getMetricsGraphSettings();
    ArrayList<MetricsChartDataGroupNVD3> finalData = new ArrayList<MetricsChartDataGroupNVD3>();

    for (SensorVariable sensorVariable : sensorVariables) {
      MetricsGraph metrics =
          metricsGraphSettings.getMetric(sensorVariable.getVariableType().getText());
      switch (sensorVariable.getMetricType()) {
        case DOUBLE:
          ArrayList<MetricsChartDataNVD3> preDoubleData = new ArrayList<MetricsChartDataNVD3>();

          MetricsDoubleTypeDevice metricQueryDouble =
              MetricsDoubleTypeDevice.builder()
                  .timestampFrom(timestampFrom)
                  .timestampTo(timestampTo)
                  .sensorVariable(sensorVariable)
                  .build();
          List<MetricsDoubleTypeDevice> doubleMetrics =
              DaoUtils.getMetricsDoubleTypeDeviceDao().getAll(metricQueryDouble);
          ArrayList<Object> avgMetricDoubleValues = new ArrayList<Object>();
          ArrayList<Object> minMetricDoubleValues = new ArrayList<Object>();
          ArrayList<Object> maxMetricDoubleValues = new ArrayList<Object>();
          for (MetricsDoubleTypeDevice metric : doubleMetrics) {
            avgMetricDoubleValues.add(new Object[] {metric.getTimestamp(), metric.getAvg()});
            if (withMinMax) {
              minMetricDoubleValues.add(new Object[] {metric.getTimestamp(), metric.getMin()});
              maxMetricDoubleValues.add(new Object[] {metric.getTimestamp(), metric.getMax()});
            }
          }
          preDoubleData.add(
              MetricsChartDataNVD3.builder()
                  .key(ObjectFactory.getMcLocale().getString(MC_LOCALE.AVERAGE))
                  .values(avgMetricDoubleValues)
                  .color(metrics.getColor())
                  .type(metrics.getSubType())
                  .build()
                  .updateSubType(metrics.getType()));
          if (withMinMax) {
            preDoubleData.add(
                MetricsChartDataNVD3.builder()
                    .key(ObjectFactory.getMcLocale().getString(MC_LOCALE.MINUMUM))
                    .values(minMetricDoubleValues)
                    .color(COLOR_MINIMUM)
                    .type(metrics.getSubType())
                    .build()
                    .updateSubType(metrics.getType()));
            preDoubleData.add(
                MetricsChartDataNVD3.builder()
                    .key(ObjectFactory.getMcLocale().getString(MC_LOCALE.MAXIMUM))
                    .values(maxMetricDoubleValues)
                    .color(COLOR_MAXIMUM)
                    .type(metrics.getSubType())
                    .build()
                    .updateSubType(metrics.getType()));
          }
          finalData.add(
              MetricsChartDataGroupNVD3.builder()
                  .metricsChartDataNVD3(preDoubleData)
                  .id(sensorVariable.getId())
                  .unit(sensorVariable.getUnit())
                  .timeFormat(getTimeFormat(timestampFrom))
                  .variableType(
                      ObjectFactory.getMcLocale()
                          .getString(sensorVariable.getVariableType().name()))
                  .dataType(sensorVariable.getMetricType().getText())
                  .resourceName(
                      new ResourceModel(RESOURCE_TYPE.SENSOR_VARIABLE, sensorVariable)
                          .getResourceLessDetails())
                  .chartType(metrics.getType())
                  .chartInterpolate(metrics.getInterpolate())
                  .build());

          break;
        case BINARY:
          ArrayList<MetricsChartDataNVD3> preBinaryData = new ArrayList<MetricsChartDataNVD3>();
          MetricsBinaryTypeDevice metricQueryBinary =
              MetricsBinaryTypeDevice.builder()
                  .timestampFrom(timestampFrom)
                  .timestampTo(timestampTo)
                  .sensorVariable(sensorVariable)
                  .build();
          List<MetricsBinaryTypeDevice> binaryMetrics =
              DaoUtils.getMetricsBinaryTypeDeviceDao().getAll(metricQueryBinary);
          ArrayList<Object> metricBinaryValues = new ArrayList<Object>();
          for (MetricsBinaryTypeDevice metric : binaryMetrics) {
            metricBinaryValues.add(new Object[] {metric.getTimestamp(), metric.getState() ? 1 : 0});
          }
          preBinaryData.add(
              MetricsChartDataNVD3.builder()
                  .key(sensorVariable.getVariableType().getText())
                  .values(metricBinaryValues)
                  .color(metrics.getColor())
                  .type(metrics.getSubType())
                  .build()
                  .updateSubType(metrics.getType()));
          finalData.add(
              MetricsChartDataGroupNVD3.builder()
                  .metricsChartDataNVD3(preBinaryData)
                  .id(sensorVariable.getId())
                  .unit(sensorVariable.getUnit())
                  .timeFormat(getTimeFormat(timestampFrom))
                  .variableType(
                      ObjectFactory.getMcLocale()
                          .getString(sensorVariable.getVariableType().name()))
                  .dataType(sensorVariable.getMetricType().getText())
                  .resourceName(
                      new ResourceModel(RESOURCE_TYPE.SENSOR_VARIABLE, sensorVariable)
                          .getResourceLessDetails())
                  .chartType(metrics.getType())
                  .chartInterpolate(metrics.getInterpolate())
                  .build());
          break;
        default:
          // no need to do anything here
          break;
      }
    }

    return finalData;
  }
  private ArrayList<MetricsChartDataGroupNVD3> getMetricsDataJsonNVD3WithChartType(
      List<Integer> variableIds, Long timestampFrom, Long timestampTo, String chartType) {

    // Get sensor variables
    List<SensorVariable> sensorVariables = null;
    if (!variableIds.isEmpty()) {
      sensorVariables = DaoUtils.getSensorVariableDao().getAll(variableIds);
    }

    // Return if no data available
    if (sensorVariables == null) {
      return new ArrayList<MetricsChartDataGroupNVD3>();
    }

    MetricsGraphSettings metricsGraphSettings =
        ObjectFactory.getAppProperties().getMetricsGraphSettings();
    ArrayList<MetricsChartDataGroupNVD3> finalData = new ArrayList<MetricsChartDataGroupNVD3>();

    SensorVariable yaxis1Variable = null;
    boolean initialLoadDone = false;
    String chartTypeInternal = null;

    ArrayList<MetricsChartDataNVD3> metricDataValues = new ArrayList<MetricsChartDataNVD3>();

    String unit = null;
    String unit2 = null;
    String chartInterpolate = null;
    boolean isMultiChart = false;

    for (SensorVariable sensorVariable : sensorVariables) {
      MetricsGraph metrics =
          metricsGraphSettings.getMetric(sensorVariable.getVariableType().getText());
      // Load initial settings
      if (!initialLoadDone) {
        if (CHART_TYPE.MULTI_CHART == CHART_TYPE.fromString(chartType)) {
          isMultiChart = true;
          yaxis1Variable = sensorVariable;
          chartTypeInternal = chartType;
        } else if (CHART_TYPE.LINE_CHART == CHART_TYPE.fromString(chartType)) {
          chartTypeInternal = chartType;
          chartInterpolate = metrics.getInterpolate();
        }
        initialLoadDone = true;
      }

      Integer yAxis = null;
      if (yaxis1Variable != null) {
        if (yaxis1Variable.getVariableType() == sensorVariable.getVariableType()) {
          yAxis = 1;
          unit = sensorVariable.getUnit();
        } else {
          yAxis = 2;
          unit2 = sensorVariable.getUnit();
        }
      } else {
        unit = sensorVariable.getUnit();
      }

      if (chartTypeInternal == null) {
        chartTypeInternal = metrics.getType();
      }

      String seriesName = null;
      if (isMultiChart) {
        seriesName =
            sensorVariable.getSensor().getName() + "-" + sensorVariable.getVariableType().getText();
      } else {
        seriesName = sensorVariable.getSensor().getName();
      }
      switch (sensorVariable.getMetricType()) {
        case DOUBLE:
          MetricsDoubleTypeDevice metricQueryDouble =
              MetricsDoubleTypeDevice.builder()
                  .timestampFrom(timestampFrom)
                  .timestampTo(timestampTo)
                  .sensorVariable(sensorVariable)
                  .build();
          List<MetricsDoubleTypeDevice> doubleMetrics =
              DaoUtils.getMetricsDoubleTypeDeviceDao().getAll(metricQueryDouble);
          ArrayList<Object> avgMetricDoubleValues = new ArrayList<Object>();
          for (MetricsDoubleTypeDevice metric : doubleMetrics) {
            if (isMultiChart) {
              avgMetricDoubleValues.add(
                  MetricsChartDataXY.builder().x(metric.getTimestamp()).y(metric.getAvg()).build());
            } else {
              avgMetricDoubleValues.add(new Object[] {metric.getTimestamp(), metric.getAvg()});
            }
          }
          if (!doubleMetrics.isEmpty()) {
            metricDataValues.add(
                MetricsChartDataNVD3.builder()
                    .key(seriesName)
                    .values(avgMetricDoubleValues)
                    .type(metrics.getSubType())
                    // .interpolate(metrics.getInterpolate())
                    .yAxis(yAxis)
                    .build()
                    .updateSubType(chartTypeInternal));
          }

          break;
        case BINARY:
          MetricsBinaryTypeDevice metricQueryBinary =
              MetricsBinaryTypeDevice.builder()
                  .timestampFrom(timestampFrom)
                  .timestampTo(timestampTo)
                  .sensorVariable(sensorVariable)
                  .build();
          List<MetricsBinaryTypeDevice> binaryMetrics =
              DaoUtils.getMetricsBinaryTypeDeviceDao().getAll(metricQueryBinary);
          ArrayList<Object> metricBinaryValues = new ArrayList<Object>();
          for (MetricsBinaryTypeDevice metric : binaryMetrics) {
            if (isMultiChart) {
              metricBinaryValues.add(
                  MetricsChartDataXY.builder()
                      .x(metric.getTimestamp())
                      .y(metric.getState() ? 1 : 0)
                      .build());
            } else {
              metricBinaryValues.add(
                  new Object[] {metric.getTimestamp(), metric.getState() ? 1 : 0});
            }
          }
          if (!binaryMetrics.isEmpty()) {
            metricDataValues.add(
                MetricsChartDataNVD3.builder()
                    .key(seriesName)
                    .values(metricBinaryValues)
                    .type(metrics.getSubType())
                    // .interpolate(metrics.getInterpolate())
                    .yAxis(yAxis)
                    .id(sensorVariable.getId())
                    .resourceName(
                        new ResourceModel(RESOURCE_TYPE.SENSOR_VARIABLE, sensorVariable)
                            .getResourceLessDetails())
                    .build()
                    .updateSubType(chartTypeInternal));
          }

          break;
        default:
          // no need to do anything here
          break;
      }
    }

    finalData.add(
        MetricsChartDataGroupNVD3.builder()
            .metricsChartDataNVD3(metricDataValues)
            .unit(unit)
            .unit2(unit2)
            .timeFormat(getTimeFormat(timestampFrom))
            .chartType(chartType)
            .chartInterpolate(chartInterpolate)
            .build());

    return finalData;
  }
  private MetricsChartDataGroupNVD3 getMetricsBatteryJsonNVD3(
      Integer nodeId, Long timestampFrom, Long timestampTo, Boolean withMinMax) {
    ArrayList<MetricsChartDataNVD3> preDoubleData = new ArrayList<MetricsChartDataNVD3>();

    MetricsBatteryUsage metricQueryBattery =
        MetricsBatteryUsage.builder()
            .timestampFrom(timestampFrom)
            .timestampTo(timestampTo)
            .node(Node.builder().id(nodeId).build())
            .build();
    List<MetricsBatteryUsage> batteryMetrics =
        DaoUtils.getMetricsBatteryUsageDao().getAll(metricQueryBattery);
    ArrayList<Object> avgMetricValues = new ArrayList<Object>();
    ArrayList<Object> minMetricValues = new ArrayList<Object>();
    ArrayList<Object> maxMetricValues = new ArrayList<Object>();
    for (MetricsBatteryUsage metric : batteryMetrics) {
      avgMetricValues.add(new Object[] {metric.getTimestamp(), metric.getAvg()});
      if (withMinMax) {
        minMetricValues.add(new Object[] {metric.getTimestamp(), metric.getMin()});
        maxMetricValues.add(new Object[] {metric.getTimestamp(), metric.getMax()});
      }
    }
    MetricsGraph metricBattery =
        ObjectFactory.getAppProperties().getMetricsGraphSettings().getBattery();
    preDoubleData.add(
        MetricsChartDataNVD3.builder()
            .key(ObjectFactory.getMcLocale().getString(MC_LOCALE.AVERAGE))
            .values(avgMetricValues)
            .color(metricBattery.getColor())
            .type(metricBattery.getSubType())
            .build()
            .updateSubType(metricBattery.getType()));
    if (withMinMax) {
      preDoubleData.add(
          MetricsChartDataNVD3.builder()
              .key(ObjectFactory.getMcLocale().getString(MC_LOCALE.MINUMUM))
              .values(minMetricValues)
              .color(COLOR_MINIMUM)
              .type(metricBattery.getSubType())
              .build()
              .updateSubType(metricBattery.getType()));
      preDoubleData.add(
          MetricsChartDataNVD3.builder()
              .key(ObjectFactory.getMcLocale().getString(MC_LOCALE.MAXIMUM))
              .values(maxMetricValues)
              .color(COLOR_MAXIMUM)
              .type(metricBattery.getSubType())
              .build()
              .updateSubType(metricBattery.getType()));
    }

    return MetricsChartDataGroupNVD3.builder()
        .metricsChartDataNVD3(preDoubleData)
        .unit("%")
        .timeFormat(getTimeFormat(timestampFrom))
        .id(nodeId)
        .resourceName(new ResourceModel(RESOURCE_TYPE.NODE, nodeId).getResourceLessDetails())
        .chartType(metricBattery.getType())
        .chartInterpolate(metricBattery.getInterpolate())
        .build();
  }
Ejemplo n.º 15
0
 @GET
 @Path("/sensorData/{id}")
 public Response getSensorDetails(@PathParam("id") int id) {
   Sensor sensor = DaoUtils.getSensorDao().get(id);
   return RestUtils.getResponse(Status.OK, sensor);
 }
 public MetricsCsvDownload getMetricsCSV(int sensorValueId, int aggregationTypeId) {
   SensorVariable sensorVariable = DaoUtils.getSensorVariableDao().get(sensorValueId);
   AGGREGATION_TYPE aggrType = AGGREGATION_TYPE.get(aggregationTypeId);
   return new MetricsCsvDownload(
       getFileName(sensorVariable, aggrType), getData(sensorVariable, aggrType));
 }