dev

plot/plot_control.py

@@ -20,16 +20,11 @@ logging.basicConfig(filename='/var/www/html/data/log/flask.log',
 logger = logging.getLogger('plot')
 
 def parse_parmeter():
-    cur_time = int(time.time())
-
-    start_time = request.args.get('start_time')
-    start_time = cur_time - 7200 if start_time is None else int(start_time.strip())
-
     end_time = request.args.get('end_time')
-    end_time = cur_time if end_time is None else int(end_time.strip())
+    end_time = None if end_time is None else int(end_time.strip())
 
-    stime = lambda t: time.strftime('%d-%H:%M:%S', time.localtime(t))
-    logger.debug("start_time=%s end_time=%s",stime(start_time) ,stime(end_time))
+    start_time = request.args.get('start_time')
+    start_time = None if start_time is None else int(start_time.strip())
 
     card_types = request.args.get('card_types')
     card_types = filter_cardtype(card_types)
@@ -83,6 +78,22 @@ def mch_ratio():
     except Exception as ex:
         return onError(ex)
 
+@app.route('/plot/mch_order_send')
+def mch_order_send():
+    try:
+        logger.debug('start mch_order_send')
+        start_time, end_time, card_types, spec, filter_wave = parse_parmeter()
+        mchids = request.args.get('mchids')
+        mchids = filter_mchids(mchids)
+
+        painter = MerchantPainter(start_time=start_time, end_time=end_time, mchids=mchids, card_types=card_types, spec=spec, filter_wave=filter_wave)
+        buf = painter.paint_refilling()
+        data = base64.b64encode(buf.getbuffer()).decode("ascii")
+
+        return f"<img src='data:image/png;base64,{data}'/>"
+    except Exception as ex:
+        return onError(ex)
+
 
 if __name__ == "__main__":
     debug_mode = True

plot/refill/ChannelPainter.py

@@ -55,8 +55,18 @@ class ChannelPainter(object):
         self._reader = ChannelReader()
         _start_time, _end_time, self._chnames, self._card_types, self._spec, self._filter_wave = start_time, end_time, chnames, card_types, spec, filter_wave
 
-        start_time = self._reader.near_stamp(_start_time,True)
-        end_time = self._reader.near_stamp(_end_time,False)
+        if _end_time is None:
+            _end_time = int(time.time())
+        end_time = self._reader.near_stamp(_end_time, False)
+        if end_time is None:
+            raise Exception('data is empty')
+
+        if _start_time is None or start_time > end_time:
+            _start_time = end_time - 7200
+
+        start_time = self._reader.near_stamp(_start_time, True)
+        if start_time is None:
+            raise Exception('data is empty')
 
         stime = lambda t: time.strftime('%d-%H:%M:%S', time.localtime(t))
         logger.debug("start_time=%s end_time=%s",stime(start_time) ,stime(end_time))

plot/refill/DataStream.py

@@ -6,7 +6,8 @@ import h5py
 from enum import IntEnum
 import threading
 
-__all__ = ['DataWriteStream', 'DataReadStream', 'day_stamp', 'EMchPosmap', 'EChPosmap', 'ENetPosmap', 'open_hdf5', 'time_border']
+__all__ = ['DataWriteStream', 'DataReadStream', 'day_stamp', 'EMchPosmap', 'EChPosmap', 'ENetPosmap', 'open_hdf5', 'time_border',
+           'calc_interval']
 
 import logging
 

plot/refill/MerchantPainter.py

@@ -1,15 +1,17 @@
-from .DataStream import EMchPosmap as pos_map, day_stamp, span_days, time_border, calc_interval
+from .DataStream import EMchPosmap as pos_map, span_days, time_border, calc_interval
 from .MerchantReader import MerchantReader
 from matplotlib.figure import Figure
 from matplotlib import ticker
 from io import BytesIO
 import numpy as np
-from .algorithm import calc_mchratios
+from .algorithm import calc_mchratios, calc_morder_send
 import time as time
 
 import logging
+
 logger = logging.getLogger('painter')
 
+
 def allpathes(reader: MerchantReader, tuple_pathes: dict, days: list, spec=None):
     count = len(days)
     show_detail = True if len(list(tuple_pathes.keys())) == 1 else False
@@ -54,11 +56,21 @@ class MerchantPainter(object):
         self._reader = MerchantReader()
         _start_time, _end_time, self._mchids, self._card_types, self._spec, self._filter_wave = start_time, end_time, mchids, card_types, spec, filter_wave
 
-        start_time = self._reader.near_stamp(_start_time,True)
-        end_time = self._reader.near_stamp(_end_time,False)
+        if _end_time is None:
+            _end_time = int(time.time())
+        end_time = self._reader.near_stamp(_end_time, False)
+        if end_time is None:
+            raise Exception('data is empty')
+
+        if _start_time is None or start_time > end_time:
+            _start_time = end_time - 7200
+
+        start_time = self._reader.near_stamp(_start_time, True)
+        if start_time is None:
+            raise Exception('data is empty')
 
         stime = lambda t: time.strftime('%d-%H:%M:%S', time.localtime(t))
-        logger.debug("start_time=%s end_time=%s",stime(start_time) ,stime(end_time))
+        logger.debug("start_time %d , %s end_time=%s", start_time, stime(start_time), stime(end_time))
 
         interval = calc_interval(start_time, end_time)
         start_time = time_border(interval, start_time, True)
@@ -77,10 +89,18 @@ class MerchantPainter(object):
             ax.set(xlabel='time', ylabel='ratio')
             return ax, fig
 
-        def flush(ax, fig, ticks, lables):
+        def flush(ax, fig, xticks=None, xlables=None, yticks=None, ylables=None):
             ax.yaxis.set_major_formatter(ticker.PercentFormatter(xmax=1, decimals=4))
-            ax.set_xticks(ticks=ticks)
-            ax.set_xticklabels(lables)
+            if xticks is not None:
+                ax.set_xticks(ticks=xticks)
+            if xlables is not None:
+                ax.set_xticklabels(xlables)
+
+            if yticks is not None:
+                ax.set_yticks(ticks=yticks)
+            if ylables is not None:
+                ax.set_yticklabels(ylables)
+
             fig.autofmt_xdate()
             ax.grid()
             fig.subplots_adjust(left=0.1, right=0.8, top=0.95, bottom=0.1)
@@ -113,10 +133,10 @@ class MerchantPainter(object):
             y = np.convolve(y, window, 'same') if window is not None else y
             ax.plot(x, y, ls='-', label=self._label(chname=_mchid, succ=succ, count=count, card_type=_card_type, spec=_spec))
 
-        ticks = [d - self._start_time for d in range(self._start_time, self._end_time + 1, self._interval)]
-        xlables = [time.strftime('%d-%H:%M:%S', time.localtime(d + self._start_time)) for d in ticks]
+        xticks = [d - self._start_time for d in range(self._start_time, self._end_time + 1, self._interval)]
+        xlables = [time.strftime('%d-%H:%M:%S', time.localtime(d + self._start_time)) for d in xticks]
 
-        return fig_flush(ax, fig, ticks, xlables)
+        return fig_flush(ax, fig, xticks=xticks, xlables=xlables)
 
     def _label(self, chname, succ, count, card_type=None, spec=None):
         _card_type = None
@@ -148,4 +168,66 @@ class MerchantPainter(object):
 
         return lable
 
+    def _fig_bar_funs(self):
+        def create():
+            fig = Figure(figsize=(19, 8))
+            ax = fig.subplots()
+            ax.set_title('success ratio')
+            ax.set(xlabel='time', ylabel='ratio')
+            return ax, fig
+
+        def flush(ax, fig, xticks=None, xlables=None, yticks=None, ylables=None):
+            if xticks is not None:
+                ax.set_xticks(ticks=xticks)
+            if xlables is not None:
+                ax.set_xticklabels(xlables)
+
+            if yticks is not None:
+                ax.set_yticks(ticks=yticks)
+            if ylables is not None:
+                ax.set_yticklabels(ylables)
+
+            ax.grid()
+            fig.autofmt_xdate()
+
+            buf = BytesIO()
+            fig.savefig(buf, format="png")
+            return buf
+
+        return create, flush
+
+    def paint_refilling(self):
+        tuple_pathes = self._reader.many_tuple_path(self._days, self._mchids, self._card_types, self._spec)
+        gen = allpathes(self._reader, tuple_pathes, self._days, self._spec)
+        if len(self._days) == 0:
+            return BytesIO()
+
+        day_stamp = self._days[0]
+        fig_create, fig_flush = self._fig_bar_funs()
+        ax, fig = fig_create()
+
+        lables = list()
+        datas = list()
+        for _mchid, _card_type, _spec, _data in gen:
+            if _mchid == 'all':
+                continue
+
+            lables.append(f"{_mchid}")
+            ret = calc_morder_send(_data, pos_map, self._start_time - day_stamp, self._end_time - day_stamp)
+            datas.append(ret)
+
+        send_count, submit_count, succ_count, fail_count, amounts, lack = zip(*datas)
+        width = 0.20
+        x_asix = np.arange(len(lables))
+
+        rect_send = ax.bar(x_asix - width * 0.5, list(send_count), width, label='send', align='center')
+        rect_submit = ax.bar(x_asix - width * 1.5, list(submit_count), width, label='summit',align='center')
+        rect_succ = ax.bar(x_asix + width * 0.5, list(succ_count), width, label='succ',align='center')
+        rect_fail = ax.bar(x_asix + width * 1.5, list(fail_count), width, label='fail', align='center')
+
+        ax.bar_label(rect_send, padding=3)
+        # ax.bar_label(rect_submit, padding=3)
+        # ax.bar_label(rect_succ, padding=3)
+        # ax.bar_label(rect_fail, padding=3)
 
+        return fig_flush(ax, fig, xticks=x_asix, xlables=lables)

plot/refill/algorithm.py

@@ -1,4 +1,5 @@
 
+from .DataStream import EMchPosmap
 import numpy as np
 
 def calc_chratios(data,pos_map,start,end):
@@ -24,4 +25,17 @@ def calc_mchratios(data,pos_map,start,end):
     commit += 0.0000001
     y = succ / commit
     y = y.ravel()
-    return int(all[0, -1]), int(all[0, -1] + all[1, -1]), y
+    return int(all[0, -1]), int(all[0, -1] + all[1, -1]), y
+
+
+def calc_morder_send(data, pos_map: type(EMchPosmap), start: int, end: int):
+    view = data[:, start:end]
+    sums = np.sum(view, axis=1)
+
+    all_return = sums[pos_map.succ_count] + sums[pos_map.fail_count] + 0.0000001
+    ratio = sums[pos_map.succ_count] / all_return
+    send_count = sums[pos_map.submit_count] - sums[pos_map.succ_count] - sums[pos_map.fail_count]
+    send_amounts = sums[pos_map.submit_amounts] - sums[pos_map.succ_mch_amounts] - sums[pos_map.fail_mch_amounts]
+    lack_amounts = send_amounts * ratio
+
+    return send_count, sums[pos_map.submit_count], sums[pos_map.succ_count], sums[pos_map.fail_count], send_amounts, lack_amounts