Пример #1
0
    def post_valid(self, api_request):
        api_reply = self.reply_class()
        channel = api_request.cleaned_data['channel']
        result = api_request.cleaned_data['result']
        start = api_request.cleaned_data['start']
        end = api_request.cleaned_data['end']
        days = api_request.cleaned_data['days']

        ret_data = {'channel':{}, 'feeds':{}}
        try:
            channel = models.Channel.objects.using("slave").get(channel_id=channel)

            # process channel data
            sensor_setting = {}
            sensor_setting['name'] = channel.name
            sensor_setting['category'] = channel.category
            for sensor_data in models.AlertSetting.objects.using("slave").filter(channel=channel):
                sensor_setting[sensor_data.sensor.name] = str((sensor_data.value)) if sensor_data.value is not None else None
                sensor_setting['alert'] = sensor_data.abnormal >= settings.ALERT_LIMIT
                if sensor_data.sensor.id == 1:
                    sensor_setting['valid_from'] = logic.format_time(sensor_data.valid_from)
                    sensor_setting['valid_to'] = logic.format_time(sensor_data.valid_to)
                    sensor_setting['min_value'] = int(sensor_data.min_value)
                    sensor_setting['max_value'] = int(sensor_data.max_value)
                sensor_setting['updated_at'] = logic.format_date(sensor_data.update_time)
            ret_data['channel'].update(sensor_setting)

            # process feeds
            getcontext().prec = 3
            data_feeds = collections.defaultdict(lambda:0)
            datetime_filter = localtime(now()) - datetime.timedelta(days=1)
            for data in models.HistoryFeeds.objects.using("slave").filter(channel=channel, sensor_id=1, create_time__gt=datetime_filter):
                key = localtime(data.create_time).strftime("%Y%m%d%H")
                if data_feeds[key] == 0:
                    data_feeds[key] = data.value
                else:
                    data_feeds[key] = (data_feeds[key] + data.value) / 2

            ordered = OrderedDict(sorted(data_feeds.items(), key=lambda x:int(x[0]), reverse=True))

            horizen = []
            dataset = []
            for key, value in ordered.iteritems():
                horizen.insert(0, key[-2:]+":00")
                dataset.insert(0, str(value))
                if len(horizen) == 10:
                    break
            ret_data['feeds']['labels'] = horizen
            ret_data['feeds']['data'] = [dataset]

            api_reply.set_field("data", ret_data)
            return api_reply

        except models.Channel.DoesNotExist:
            raise exceptions.ApiChannelNotFound()
Пример #2
0
    def post_valid(self, api_request):
        api_reply = self.reply_class()

        channels = []

        channel_setting_dict = collections.defaultdict(list)
        for alert in models.AlertSetting.objects.using("slave").all():
            setting_dict = collections.defaultdict(dict)
            setting_dict[alert.sensor.name]["max"] = str(alert.max_value)
            setting_dict[alert.sensor.name]["min"] = str((alert.min_value))
            setting_dict[alert.sensor.name]["from"] = logic.format_time(alert.valid_from)
            setting_dict[alert.sensor.name]["to"] = logic.format_time(alert.valid_to)
            setting_dict[alert.sensor.name]["value"] = str((alert.value))
            setting_dict[alert.sensor.name]["update_time"] = logic.format_date(alert.update_time)
            setting_dict[alert.sensor.name]["alert"] = alert.abnormal >= settings.ALERT_LIMIT
            # if setting_dict[alert.sensor.name]["alert"] and  alert.sensor_id == 1:
                # sms.send_sms_alert(settings.ALERT_NUMBER,
                                   # alert.sensor.name,
                                   # alert.channel.name,
                                   # alert.min_value,
                                   # alert.max_value,
                                   # alert.value)
            channel_setting_dict[alert.channel.id].append(setting_dict)

        for channel in models.Channel.objects.using("slave").all().order_by("-id"):
            channel_dict = {}
            channel_dict['name'] = channel.name
            channel_dict['api_key'] = channel.api_write_key
            channel_dict['category'] = channel.get_category_display()
            channel_dict['id'] = channel.channel_id
            channel_dict['status'] = channel_setting_dict[channel.id]

            channels.append(channel_dict)

        api_reply.set_field("data", channels)
        return api_reply
Пример #3
0
    def post_valid(self, api_request):
        api_reply = self.reply_class()
        cleaned_data = api_request.cleaned_data

        name = cleaned_data['name']
        max_temp = cleaned_data['max_temp']
        min_temp = cleaned_data['min_temp']
        valid_from = cleaned_data['valid_from']
        valid_to = cleaned_data['valid_to']
        category = cleaned_data['category']
        channel = cleaned_data['channel']

        print api_request.cleaned_data
        try:
            cha = models.Channel.objects.get(channel_id=channel)
            try:
                with transaction.atomic():
                    models.Channel.objects.filter(channel_id=channel).update(
                        name = name,
                        category = category
                    )
                    models.AlertSetting.objects.filter(channel=cha, sensor_id=1).update(
                        min_value = min_temp,
                        max_value = max_temp,
                        valid_from = valid_from,
                        valid_to = valid_to
                    )
            except Exception as e:
                logger.error("update channel failed, Exception %s", e)
                raise exceptions.ApiUpdateChannelError("Database Error")

        except models.Channel.DoesNotExist:
            api_read_key = logic.generate_key()
            sensors = [sensor.id for sensor in models.Sensor.objects.all()]
            try:
                with transaction.atomic():
                    cha = models.Channel.objects.create(
                        name = name,
                        description = '',
                        category = category,
                        channel_id = channel,
                        api_write_key = '',
                        api_read_key = api_read_key
                    )

                    obj_list = []
                    for sensor in sensors[::-1]:
                        if sensor == 1:
                            max_value = max_temp
                            min_value = min_temp
                            value = 25
                        elif sensor == 2:
                            max_value = 80
                            min_value = 30
                            value = 50
                        elif sensor == 3:
                            max_value = 100
                            min_value = 0
                            value = 76
                        obj = models.AlertSetting(
                            channel = cha,
                            sensor_id = sensor,
                            min_value = min_value,
                            max_value = max_value,
                            valid_from = valid_from,
                            valid_to = valid_to,
                            value = value,
                            update_time = localtime(now())
                        )
                        obj_list.append(obj)
                    print obj_list
                    models.AlertSetting.objects.bulk_create(obj_list)
            except IntegrityError:
                logger.error("duplicate channel name, %s", name)
                raise exceptions.ApiCreateChannelError("Duplicated Name")
            except Exception as e:
                logger.error("create channel failed, exception: %s", e)
                raise exceptions.ApiCreateChannelError("Database Error")

        ret_data = {
            'name': name,
            'min_temp': str(min_temp),
            'max_temp': str(max_temp),
            'valid_from': logic.format_time(valid_from),
            'valid_to': logic.format_time(valid_to),
            'category': category
        }

        api_reply.set_field("data", ret_data)
        return api_reply