flask售后评分系统

做软件行业的公司，一般都有专业的售前售后团队，还有客服团队，客服处理用户反馈的问题，会形成工单，然后工单会有一大堆工单流程，涉及工单的内部人员，可能会有赔付啥的，当然，这是有专业的售前、售后、客服团队。

但，我相信，有好大一部分是没有售后团队的，或者研发就是售后，有测试团队的，那测试肯定是首当其冲的售后团队，用户有啥问题，产品直接把测试拖到群里就ok~~~~~相信很多公司和我们一样。

既然没有专业的售后团队，所有人都肯定不想去搞这售后，所以，要想让售后维护下去，那就得有奖励，比如把项目奖金部分拿来奖励处理售后的人员。

问题来了，怎么去分配这部分奖励呢？？

要做好售后奖励分配，需要关注哪些要素？我这模拟了半个月，总结了一些，希望有需要的可以参考参考。

以下是我们实施售后评分系统的基础调研理论：

************************************************************************************************************

项目售后奖惩制度

一、售后主要打分参数

售后主要有几个参数：

1. 响应速度

从用户通过QQ、微信、电话等反馈问题开始到售后人员回复问题，这段时间称为响应时间，响应时间越短，客户满意度会越好。

1. 问题复杂程度

用户反馈的问题，有简单的，比如使用问题，也有比较复杂的，比如环境问题，或者是很难复现的BUG。按照问题的复杂情况分为：简单、一般、复杂、疑难4种等级。

1. 问题解决时长

售后接受到问题到解决上线了这个问题，这段时间称为解决时间，不同复杂程度解决时间消耗不一样。按照解决时长分为：当日解决、24小时内解决、72小时内解决、164小时内解决（7日）。

1. 问题解决程度

根据问题的复杂程度或其他原因，问题是存在解决程度的，比如先临时解决用户先能正常使用起来，再抽时间彻底解决。所以分了几个标准：彻底解决（该问题不会再出现）、通用解决（该问题同样的操作步骤不会再出现，但其他情况或其他人可能还会出现）、临时解决（该问题下次还会出现，只能采用同样办法避免）

1. 客户满意度

问题解决后，用户对该问题解决情况综合评价

二、 售后分数计算规则

按照售后的参数，赋予不同的分数，各项参数标准分数为100分，大于100分为奖励分，低于100分为惩罚分数：

以上参数表格说明一下：

比如复杂程度为“简单”，严重程度为“致命”，解决时间为“当日”的情况下，得分为110分，但如果解决时间大于24小时小于72小时，则得分为-40分。我们认为这个售后问题是很简单的，但又是致命的，对客户来说很重要，对我们解决耗时很短，但若问题解决时间还大于24小时，我们认为解决速度是存在问题的，所以要扣除分数作为惩罚。当然，若问题很复杂，则解决时间肯定会变长，所以，随着问题的复杂性提高，扣除分数基本不会存在，这样也算比较合理的规则。再比如，如果这个问题被客户投诉了，则客户满意度这一项会直接得分-100分，如果用户主动表扬，则得分150分。

有了这样的基础表格，我们就可以计算这个问题的总得分了，我们按照各项参数占比来计算：解决时长占比40%，解决程度占比30%，客户满意度占比30%，响应时长主要用于扣除惩罚计算。

计算公式：

三、  售后奖励分配规则

一个问题的提出到解决，是有很多人一起参与的，一个项目又是有多人参与的，我们按照项目来区分，同一项目内部独立计算，比如黑龙江的售后，则只计算参与了黑龙江售后的人员。同一个问题有响应人员（发起人员或接受人员）、解决人员、参与人员。该问题的分数也按照比例分配这些人员。我们人为一个问题的发起人会全程参与这个问题直到问题解决，所以响应人员占比要多一点，同样，参与人员可能是零星参与，所以参与人员比例要少一点。当然，不可能做到绝对公平：

问题响应人员（一人）：55%

问题解决人员（一人）：35%

问题参与人员（多人）：10%

四、 售后奖励扣除规则

有奖励就有惩罚，根据参数我们做了扣分规则，但还不够，响应速度需要主观来判断，所以做了单独的规则：

响应时间在工作日非工作日期间是有区别的，工作日期间应该要响应快一点，非工作日期间，可能会看到问题慢一点，当然直接电话除外：

1. 工作日期间：
   1. 响应时间<0.5h：不扣除
   2. 0.5h<响应时间<2h: 扣除2%
   3. 响应时间>2h：扣除5%
2. 非工作日期间：
   1. 响应时间<1h：不扣除
   2. 1h<响应时间<2h: 扣除2%
   3. 响应时间>2h：扣除5%

以上特殊情况除外，如果他人二次通知在这时间内响应了，也算自己主动响应。这里的扣除是直接针对奖励金额，不是针对分数。这里的扣除比例针对的是参与该项目售后获得当月奖励的所有人员。扣除最高为100%，比如当月有20个问题响应时长都是扣除5%，那么该月的所有人可能就没有了奖励。

************************************************************************************************************

现在开始实施：

1.数据库设计

（1）创建project_manage数据库

（2）创建pro_collect_problems表，用于问题收集。

CREATE TABLE `pro_collect_problems` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT 'id',
  `product_id` int(11) DEFAULT NULL COMMENT '关联的产品线产品id',
  `problem_detail` varchar(1000) DEFAULT NULL COMMENT '问题描述',
  `problem_date` varchar(50) DEFAULT NULL COMMENT '问题发现时间',
  `problem_type` varchar(255) DEFAULT NULL COMMENT '问题类型：使用问题、环境问题、需求问题、代码问题',
  `problem_complexity` varchar(20) DEFAULT NULL COMMENT '问题复杂程度：简单、一般、复杂、疑难',
  `system_type` varchar(50) DEFAULT NULL COMMENT '问题系统类型',
  `problem_degree` varchar(255) DEFAULT NULL COMMENT '问题严重程度：致命、严重、一般、轻微、建议',
  `problem_solution` varchar(1000) DEFAULT NULL COMMENT '问题解决方法',
  `problem_remark` varchar(1000) DEFAULT NULL COMMENT '解决方案备注信息',
  `solve_degree` varchar(255) DEFAULT NULL COMMENT '解决程度：临时解决（下次还会出现）、通用解决（某种情况不会出现）、彻底解决（不会出现）',
  `problem_solver` varchar(50) DEFAULT NULL COMMENT '解决人',
  `other_person` varchar(255) DEFAULT NULL COMMENT '其他参与人',
  `problem_solve_time` varchar(255) DEFAULT NULL COMMENT '解决时间',
  `problem_burning_time` varchar(10) DEFAULT NULL COMMENT '解决耗时(解决时间-发现时间)-单位小时，精确一位小数点',
  `is_holiday` int(2) unsigned DEFAULT '0' COMMENT '是否在节假日发现或解决(1：是;0：否）',
  `is_general_problem` int(10) DEFAULT '0' COMMENT '是否融媒体共性问题',
  `customer_evaluation` varchar(255) DEFAULT NULL COMMENT '客户评价：非常满意（用户主动表扬）、满意、不满意（用户有抱怨）、及其不满意（用户主动投诉）',
  `score` varchar(10) DEFAULT '0' COMMENT '售后得分(算法服务自动计算存入)',
  `weight_score` varchar(10) DEFAULT '0' COMMENT '加权售后得分',
  `is_grant_money` int(2) DEFAULT '0' COMMENT '是否发放奖励',
  `grant_money_person` varchar(50) DEFAULT '' COMMENT '发放奖励人员',
  `grant_money_time` varchar(20) DEFAULT NULL COMMENT '发放奖励时间',
  `resolve_str` varchar(1000) DEFAULT NULL COMMENT '已解决融媒体产品id串',
  `creator` varchar(100) DEFAULT NULL COMMENT '创建人',
  `creator_department` varchar(255) DEFAULT NULL COMMENT '创建人部门',
  `creator_phone` varchar(255) DEFAULT NULL COMMENT '创建者手机号',
  `date_create` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `date_update` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  `updater` varchar(20) DEFAULT NULL COMMENT '更新人员',
  `is_disabled` int(11) unsigned zerofill DEFAULT '00000000000' COMMENT '是否删除',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4 COMMENT='问题收集表';

（3）创建problem_solving_time，用于初始化解决时长对应的分数

CREATE TABLE `problem_solving_time` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `complexity` varchar(10) NOT NULL COMMENT '问题复杂程度',
  `severity` varchar(10) NOT NULL COMMENT '问题严重程度',
  `duration` varchar(10) DEFAULT NULL COMMENT '解决时长',
  `score` varchar(10) DEFAULT NULL COMMENT '分数',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4 COMMENT='问题解决时长分数';

（4）创建problem_solving_degree，用于初始化问题解决程度分数

CREATE TABLE `problem_solving_degree` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `complexity` varchar(10) NOT NULL COMMENT '问题复杂程度',
  `severity` varchar(10) NOT NULL COMMENT '问题严重程度',
  `solve_degree` varchar(10) DEFAULT NULL COMMENT '问题解决程度',
  `score` varchar(10) DEFAULT NULL COMMENT '分数',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4 COMMENT='问题解决程度分数';

（5）创建problem_customer_satisfaction，用于初始化用户满意度分数

CREATE TABLE `problem_customer_satisfaction` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `complexity` varchar(10) NOT NULL COMMENT '问题复杂程度',
  `severity` varchar(10) NOT NULL COMMENT '问题严重程度',
  `satisfaction` varchar(10) DEFAULT NULL COMMENT '问题解决满意度',
  `score` varchar(10) DEFAULT NULL COMMENT '分数',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4 COMMENT='客户满意度分数';

（6）创建problem_person_score，用于存储个人得分表

CREATE TABLE `problem_person_score` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `problem_id` int(11) NOT NULL COMMENT '问题id',
  `product_id` int(11) NOT NULL COMMENT '产品id',
  `name` varchar(10) NOT NULL COMMENT '姓名',
  `score` varchar(10) NOT NULL COMMENT '分数',
  `total_score` varchar(10) NOT NULL,
  `is_issue_money` varchar(5) NOT NULL COMMENT '是否发放奖金',
  `problem_time` datetime NOT NULL COMMENT '问题生成时间',
  `update_time` datetime NOT NULL COMMENT '更新时间',
  PRIMARY KEY (`id`),
  UNIQUE KEY `pn` (`problem_id`,`name`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4 COMMENT='用户分数表';

以上创建好表后，我们开始搭建问题收集网站

2.用flask搭建一个网站，这个网站用于记录售后问题。

搭建这个网站很简单，可以参考我们常用的测试管理工具，如禅道~

（1）售后列表页面：

（2）售后填写页面：

类似页面flask搭建很简单，提交存库就行，这里不做代码介绍。

3.把我们得计算规则（售后分数计算规则）初始化到数据库里，也就是上面我们定义好的规则。

4.计算该问题的总得分

（1）获取没有计算的数据

SELECT
    id,
    problem_complexity,
    problem_degree,
    CASE
WHEN problem_burning_time <= 8 THEN
    '当日'
WHEN problem_burning_time <= 24 THEN
    '24小时'
WHEN problem_burning_time <= 72 THEN
    '72小时'
WHEN problem_burning_time > 72 THEN
    '164小时'
END problem_burning_time,
 CASE
WHEN solve_degree LIKE '%彻底解决%' THEN
    '彻底'
WHEN solve_degree LIKE '%通用解决%' THEN
    '通用'
WHEN solve_degree LIKE '%临时解决%' THEN
    '临时'
END solve_degree,
 customer_evaluation
FROM
    `pro_collect_problems`
WHERE
    problem_burning_time IS NOT NULL
AND score = '0';

（2）获取单个id需要计算的数据

SELECT
    id,
    problem_complexity,
    problem_degree,
    CASE
WHEN problem_burning_time <= 8 THEN
    '当日'
WHEN problem_burning_time <= 24 THEN
    '24小时'
WHEN problem_burning_time <= 72 THEN
    '72小时'
WHEN problem_burning_time > 72 THEN
    '164小时'
END problem_burning_time,
 CASE
WHEN solve_degree LIKE '%彻底解决%' THEN
    '彻底'
WHEN solve_degree LIKE '%通用解决%' THEN
    '通用'
WHEN solve_degree LIKE '%临时解决%' THEN
    '临时'
END solve_degree,
 customer_evaluation
FROM
    `pro_collect_problems`
WHERE
    id = '@@@@';

（3）计算问题分数接口

@pas.route('/deal_score', methods=['POST'])
def calculation_score_task():
    if request.json:
        try:
            req_data = request.json
            user_name = req_data['user_name']
            time_stamp = str(req_data['time_stamp'])
            get_sign = req_data['sign']
            sign_str = "#￥………@#@t_21@#%Aa"
            problem_id = [{'id': req_data['id']}]
        except Exception as e:
            print(e)
            return jsonify({"error": 400, "msg": "参数错误！"}), 400
        need_to_md5 = user_name + time_stamp + sign_str
        sign = hashlib.md5(need_to_md5.encode(encoding="UTF-8")).hexdigest()
        if get_sign == sign:
            if req_data['id']:
                sql_result = sql.deal_more_mysql("get_project_manage_id.sql", problem_id)
            else:
                sql_result = sql.deal_mysql("get_project_manage.sql")
            if sql_result:
                for i in sql_result:
                    p_solve_time = [{'complexity': i[1], 'severity': i[2], 'duration': i[3]}]
                    p_solve_degree = [{'complexity': i[1], 'severity': i[2], 'solve_degree': i[4]}]
                    p_solve_satisfaction = [{'complexity': i[1], 'severity': i[2], 'satisfaction': i[5]}]
                    pst_result = sql.deal_more_mysql("get_problem_solving_time.sql", p_solve_time)
                    psd_result = sql.deal_more_mysql("get_problem_solving_degree.sql", p_solve_degree)
                    pss_result = sql.deal_more_mysql("get_problem_solving_satisfaction.sql", p_solve_satisfaction)
                    score = 0.4 * int(pst_result[0][0]) + 0.3 * int(psd_result[0][0]) + 0.3 * int(pss_result[0][0])
                    # print('id',id,'--pst-',pst_result[0][0], '--psd-', psd_result[0][0], '--pss-',pss_result[0][0], '--score-',score)
                    update_sql = """UPDATE pro_collect_problems set score = '%s' WHERE id = '%s' LIMIT 1;""" % (score, i[0])
                    d = pro_sql.Database()
                    d.exec_no_query(update_sql)
                return jsonify({"success": 200, "msg": "计算完成"})
            else:
                return jsonify({"success": 200, "msg": "暂无数据待计算！"})
        else:
            return jsonify({"error": 400, "msg": "参数错误！"}), 400

这里对接口做了一个验签，客服端和后端计算的sign值一样才能验签通过，另外这里对传入的问题id做了校验，如果有id，这计算这个id的分数，如果没有id，就计算所有需要计算的数据。

这个地方：score = 0.4 * int(pst_result[0][0]) + 0.3 * int(psd_result[0][0]) + 0.3 * int(pss_result[0][0])计算的是占比：解决时长占比40%，解决程度占比30%，客户满意度占比30%。

这个是处理数据的插件，我用flask一般都用这个---PooledDB ：

import pymysql
from DBUtils.PooledDB import PooledDB
from app.dao import db_config as config

class Database:
    def __init__(self, *db):
        # mysql数据库
        self.host = config.project_manage['host']
        self.port = config.project_manage['port']
        self.user = config.project_manage['user']
        self.pwd = config.project_manage['passwd']
        self.db = config.project_manage['db']
        self.charset = config.project_manage['charset']
        self.create_pool()

    def create_pool(self):
        self.Pool = PooledDB(creator=pymysql, mincached=0, maxcached=10, maxshared=0, maxconnections=0, blocking=True, host=self.host, port=self.port,
                             user=self.user, password=self.pwd, database=self.db, charset=self.charset)

    def get_connect(self):
        self.conn = self.Pool.connection()
        cur = self.conn.cursor()
        if not cur:
            raise NameError("数据库连接不上")
        else:
            return cur

    # 查询sql
    def exec_query(self, sql):
        cur = self.get_connect()
        cur.execute(sql)
        re_list = cur.fetchall()
        cur.close()
        self.conn.close()
        return re_list

    # 非查询的sql,增删改
    def exec_no_query(self, sql):
        cur = self.get_connect()
        re = cur.execute(sql)
        self.conn.commit()
        cur.close()
        self.conn.close()
        return re

    # 显示查询中的第一条记录
    def show_first(self, sql):
        cur = self.get_connect()
        cur.execute(sql)
        result_first = cur.fetchone()
        cur.close()
        self.conn.close()
        return result_first

    # 显示查询出的所有结果
    def show_all(self, sql):
        cur = self.get_connect()
        cur.execute(sql)
        result_all = cur.fetchall()
        cur.close()
        self.conn.close()
        return result_all

# if __name__ == "__main__":
#     # d = Database()

然后自己封装了一个处理sql脚本的py文件：

# coding = utf-8
# 禅道项目度量--读取sql脚本

import os
from app.dao import project_manage_mysql as mysql

pl = os.getcwd().split('cover_app_platform')
path_pl = pl[0] + "cover_app_platform\\app\\dao\\project_manage\\"

# 读取sql脚本
def read_sql(f):
    """
    :param f: 需要读取sql脚本的文件
    :return: 返回读取后的sql语句
    """
    f_path = path_pl + f

    try:
        fi = open(f_path, "r", encoding='UTF-8')
        fp = fi.readlines()
        fi.close()
        sql_script = ''
        for i in fp:
            sql_script += i
        return sql_script
    except FileNotFoundError as ep:
        return ep

def deal_mysql(f, pa='', u=0):
    """
    :param f:
    :param pa: list
    :param u: list
    :return:
    """
    d = mysql.Database()
    sql = read_sql(f)
    if len(pa) != 0:
        for i in pa:
            sql = sql.replace('@@@@', str(i))
    if u == 0:
        results = d.show_all(sql)
        tl = list(results)
        return tl
    else:
        results = d.exec_no_query(sql)
        return results

def deal_more_mysql(f, pa=None):
    """
    :param f:
    :param pa: list
    :return:
    """
    if pa is None:
        pa = []
    d = mysql.Database()
    sql = read_sql(f)
    sql_new = ''
    if pa:
        for i in pa:
            s = sql.split('\n')
            for sq in s:
                sqn = ""
                for key in i:
                    if key in sq:
                        sq = sq.replace('@@@@', i[key])
                        sqn = sq + '\n'
                    else:
                        sqn = sq + '\n'
                sql_new += sqn
    results = d.show_all(sql_new)
    tl = list(results)
    return tl

if __name__ == '__main__':
    par_har = [{'upload_id': '2', 'har_name': '直播流程.har'}]
    f = "get_locust_debug.sql"
    r = deal_more_mysql(f, par_har)
    print(r)

5.计算该问题发起人、解决人、参与人的分数

@pas.route('/deal_personal_score', methods=['POST'])
def calculation_score_personal():
    if request.json:
        try:
            req_data = request.json
            user_name = req_data['user_name']
            time_stamp = req_data['time_stamp']
            get_sign = req_data['sign']
            sign_str = "co#2332@#@ct_21@#%Aa"
            problem_id = [{'id': req_data['id']}]
        except Exception as e:
            print(e)
            return jsonify({"error": 400, "msg": "参数错误！"}), 400
        need_to_md5 = user_name + time_stamp + sign_str
        sign = hashlib.md5(need_to_md5.encode(encoding="UTF-8")).hexdigest()
        if get_sign == sign:
            if req_data['id']:
                sql_result = sql.deal_more_mysql("get_score_personal_id.sql", problem_id)
            else:
                sql_result = sql.deal_mysql("get_score_personal.sql")
            # sql_result = [(119, 3, '王*红', '王*红', None, '100.0', 0, datetime.datetime(2021, 7, 16, 17, 7, 49))]
            if sql_result:
                all_personal_data = []
                for i in sql_result:
                    personal_data = {}
                    p_score = i[5]
                    p_creator = i[2].split('、')  # 55%
                    p_solver = i[3].split('、')  # 35%
                    if len(p_solver) >= 2:
                        for ps in p_solver:
                            if ps == p_creator[0]:
                                p_solver.remove(ps)
                    if i[4] is None:
                        p_participants = ''.split('、')
                    else:
                        p_participants = i[4].split('、')  # 10%
                    if len(p_participants) >= 1:
                        for pcs in (p_creator + p_solver):
                            for pp in p_participants:
                                if pcs == pp:
                                    p_participants.remove(pcs)
                    # 如果创建人和解决人是同一人
                    if len(p_creator) == len(p_solver) == 1 and p_creator[0] == p_solver[0]:
                        # 如果没有参与人,当创建人等于解决人等于参与人时，参与人会被移除，此时len(p_participants)等于0
                        if (len(p_participants) == 1 and p_participants[0] == '') or len(p_participants) == 0:
                            # 计算创建人 占比100%
                            personal_data[p_creator[0]] = float(p_score) * 1
                        # 有参与人
                        else:
                            # 计算创建人 占比90%
                            personal_data[p_creator[0]] = round(float(p_score) * 0.9, 2)
                            # 计算参与人 占比10%
                            for spp in p_participants:
                                personal_data[spp] = round(float(p_score) * 0.1 / len(p_participants), 2)
                    # 如果没有参与人
                    elif len(p_participants) == 1 and p_participants[0] == '':
                        # 计算创建人 占比60%
                        personal_data[p_creator[0]] = round(float(p_score) * 0.6, 2)
                        # 计算解决人 占比40， 多人则均分40%
                        for sp in p_solver:
                            personal_data[sp] = round(float(p_score) * 0.4 / len(p_solver), 2)
                    # 创建人、解决人、参与人都有的情况
                    else:
                        # 计算创建人 占比 55%
                        personal_data[p_creator[0]] = round(float(p_score) * 0.55, 2)
                        # 计算解决人 占比 35% 多人则均分35%
                        for sp in p_solver:
                            personal_data[sp] = round(float(p_score) * 0.35 / len(p_solver), 2)
                        # 计算参与人 占比10% 多人则均分10%
                        for spp in p_participants:
                            personal_data[spp] = round(float(p_score) * 0.1 / len(p_participants), 2)
                    for pd in personal_data:
                        personal_data_l = {'problem_id': i[0],
                                           'product_id': i[1],
                                           'is_issue_money': i[6],
                                           'problem_time': i[7],
                                           'name': pd,
                                           'total_score': p_score,
                                           'score': personal_data[pd],
                                           }
                        all_personal_data.append(personal_data_l)
                print('执行数据更新开始时间： ', datetime.datetime.now())
                d = pro_sql.Database()
                if req_data['id']:
                    del_sql = "DELETE FROM problem_person_score where problem_id = '%s';" % req_data['id']
                    d.exec_no_query(del_sql)
                for s_data in all_personal_data:
                    in_sql = """
                        INSERT INTO `problem_person_score` (
                            `problem_id`,
                            `product_id`,
                            `name`,
                            `score`,
                            `total_score`,
                            `is_issue_money`,
                            `problem_time`,
                            `update_time`
                        )
                        VALUES('%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s');
                    """ % (s_data['problem_id'],
                           s_data['product_id'],
                           s_data['name'],
                           s_data['score'],
                           s_data['total_score'],
                           s_data['is_issue_money'],
                           s_data['problem_time'],
                           datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),)
                    try:
                        # 插入sql
                        d.exec_no_query(in_sql)
                    except IntegrityError:
                        update_sql = "UPDATE problem_person_score set score = '%s', problem_time = '%s', total_score = '%s', update_time = '%s' " \
                                     "where problem_id = '%s' and name = '%s' LIMIT 1;" % (
                                         s_data['score'],
                                         s_data['problem_time'],
                                         s_data['total_score'],
                                         datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
                                         s_data['problem_id'],
                                         s_data['name']
                                     )
                        # 插入sql出错则更新sql
                        d.exec_no_query(update_sql)
                print('执行数据更新结束时间： ', datetime.datetime.now())
                return jsonify({"success": 200, "msg": "计算完成"})
            else:
                return jsonify({"success": 200, "msg": "暂无数据待计算！"})
    else:
        return jsonify({"error": 400, "msg": "参数错误！"}), 400

这里主要是算法判断有点复杂：

简单规则理解：

1.一个售后问题，我们定义了三个角色：发起人（填写人），解决人，参与人

（1）发起人：问题的第一介入人员，也是填写售后问题的人员，这个角色主要是第一个响应客户的人员，比较重要，也是推动这个问题解决的人员，所以，发起人只有一个，分数占比55%。

（2）解决人：解决问题的人员，可以有多个，比如用户反映的一个问题，可能前段，后端，app段都需要修改，或者android和ios都要修改，所以有多个人，但考虑到解决人员没有与用户直接响应，也没有花时间如推动，分数占比为35%。

（3）参与人：参与问题解决的人员，可以有多个，可以是参与排查问题的人员，也可以是其他部门协助解决的人员，分数占比10%。

定义好这些角色后，我们就有几种情况了：

（1）如果用户反映的问题被发起人解决了，那么发起人则分数占比100%

（2）如果用户反映的问题有发起人，有解决人，没有参与人，则发起人占比60%，解决人占比40%

（3）如果用户反映的问题有发起人，解决人，参与人，则发起人占比55%，解决人35%，参与人10%。

我们也定义了其他情况：

（1）解决人或参与人若有发起人，则发起人只计算发起人的比例

（2）参与人里若有解决人或发起人，也要过滤

（3）当解决人里有且只有发起人，则发起人算发起人和解决人分数

如：

（1）发起人（张三），解决人（李四，张三），参与人（李四，张三、王五），则有效的为：发起人（张三），解决人（李四），参与人（王五）

（2）发起人（张三），解决人（张三），参与人（张三），则有效的为：发起人（张三），解决人（张三）

当然，还有其他规则，这些可以自己定义。

然后，这里我们也判断了id，如果有id，则只计算这个id的数据，但处理这个id数据前，会先去删除这个id的数据，重新插入。

数据表定义了判重，一个问题一个用户只能有一条数据，如果插入时候报错，则执行update语句。

计算后的数据：

售后问题得分页面：

最后，可以根据这些个人得分数据，可以再做一个排行榜，可以按照项目、个人、月度、年度来排~~

有不懂得或有建议的，欢迎留言。