非去哪儿白条

白条/数据准备/同步线上白条红包减免.py

+# encoding: utf8
+"""
+    根据线上xyqb库的baitiao_bill_repayment_plan表中的红包值，更新new_transaction库user_bt_repayment_plan表中的红包金额
+"""
+
+import pandas as pd
+from sqlalchemy import create_engine
+
+pd.options.mode.chained_assignment = None
+
+engine_xyqb = create_engine('mysql+mysqldb://syzhu_data_r:ulk0989742097y43@192.168.4.6:8066/xyqb?charset=utf8',
+                            echo=True)
+engine_new_transaction = create_engine(
+    'mysql+mysqldb://yulong:ohVU1nPITynSZwR2@172.16.3.201:3306/new_transaction?charset=utf8', echo=True)
+xyqb_sql = """ 
+ SELECT DISTINCT order_no,term_no,red_packet_amount 
+ FROM baitiao_bill_repayment_plan 
+ WHERE red_packet_amount > 0 AND repaid_at>='%s' AND  repaid_at<'%s'"""
+
+update_sql = """ 
+  UPDATE user_bt_repayment_plan 
+  SET red_package=%s 
+  WHERE order_no=%s AND term_no=%s  AND sys_tag='XYQB_BILL_BT' """
+
+start_time = '2017-09-01'
+end_time = '2017-10-01'
+
+
+def update_red_package():
+    df = pd.read_sql(xyqb_sql % (start_time, end_time), engine_xyqb)
+    if len(df) > 0:
+        df['order_no'] = df['order_no'].astype(str)
+        df['term_no'] = df['term_no'].astype(int)
+        df['red_packet_amount'] = df['red_packet_amount'].astype(float)
+        conditions = df[['red_packet_amount', 'order_no', 'term_no']].values.tolist()
+        engine_new_transaction.execute(update_sql, conditions)
+        df.to_excel(u'E:/baitiao/红包减免/需要更新的plan2017-09.xlsx')
+
+
+update_red_package()

白条/数据准备/同步线上白条红包减免更新ref表.py

+# encoding: utf8
+"""
+    根据线上xyqb库的baitiao_bill_repayment_plan表中的红包值，更新new_transaction库user_bt_repayment_plan表中的红包金额
+"""
+
+import sys
+
+import pandas as pd
+
+reload(sys)
+sys.setdefaultencoding("utf-8")
+from sqlalchemy import create_engine
+
+pd.options.mode.chained_assignment = None
+
+engine_xyqb = create_engine('mysql+mysqldb://syzhu_data_r:ulk0989742097y43@192.168.4.6:8066/xyqb?charset=utf8',
+                            echo=True)
+engine_offline = create_engine('mysql+mysqldb://syzhu_data_r:ulk0989742097y43@192.168.4.6:8066/offline?charset=utf8',
+                               echo=True)
+engine_new_transaction = create_engine(
+    'mysql+mysqldb://yulong:ohVU1nPITynSZwR2@172.16.3.201:3306/new_transaction?charset=utf8', echo=True)
+engine_audit = create_engine('mysql+mysqldb://yulong:ohVU1nPITynSZwR2@172.16.3.201:3306/audit?charset=utf8', echo=True)
+engine_xyqb_offline = create_engine('mysql+mysqldb://zhling_ofl_r:jiyng987ujki8@192.168.4.253:3306/xyqb?charset=utf8',
+                                    echo=True)
+
+user_bt_sql = """ 
+  SELECT id plan_id,order_no,term_no,red_package 
+  FROM user_bt_repayment_plan 
+  WHERE sys_tag='XYQB_BILL_BT' AND red_package>0 
+  AND biz_repaid_at>='%s' AND  biz_repaid_at<'%s'"""
+ref_sql = """select plan_id ,collection_relief from baitiao_repay_plan_repay_record_ref WHERE  plan_id in %s """
+
+update_ref_sql = """
+update baitiao_repay_plan_repay_record_ref 
+set mitigate_all=%s ,red_package_fee=%s 
+WHERE  plan_id = %s """
+
+start_time = '2017-09-01'
+end_time = '2017-10-01'
+
+
+# 主要用于更新baitiao_repay_plan_repay_record_ref关联
+def udpate_ref():
+    df = pd.read_sql(user_bt_sql % (start_time, end_time), engine_new_transaction)
+    df['plan_id'] = df['plan_id'].astype(int)
+    df['red_package'] = df['red_package'].astype(float)
+    plan_ids = df['plan_id'].tolist()
+    df_2 = pd.read_sql(ref_sql % (str(tuple(plan_ids)),), engine_new_transaction)
+    df_2['plan_id'] = df_2['plan_id'].astype(int)
+    df_2['collection_relief'] = df_2['collection_relief'].astype(float)
+    df = pd.merge(df, df_2, on='plan_id')
+    df['diff'] = df['collection_relief'] - df['red_package']
+    df_not = df[df['diff'] < 0]
+    df_good = df[df['diff'] >= 0]
+    if len(df_not) > 0:
+        df_not.to_excel(u"E:/baitiao/红包减免/不符合减免条件2017-08.xlsx", index=None)
+        df_not['plan_id'] = df_not['plan_id'].astype(int)
+        update_plan = """update new_transaction.user_bt_repayment_plan set red_package=0 WHERE  id = %s"""
+        plan_ids = df_not[['plan_id']].values.tolist()
+        engine_new_transaction.execute(update_plan, plan_ids)
+
+    if len(df_good) > 0:
+        df_good.to_excel(u"E:/baitiao/红包减免/符合减免条件2017-08.xlsx", index=None)
+        values_list = df_good[['diff', 'red_package', 'plan_id']].values.tolist()
+        engine_new_transaction.execute(update_ref_sql, values_list)
+
+
+udpate_ref()
\ No newline at end of file

白条/数据准备/更新白条还款计划实还.py

+# -*- encoding: utf8 -*-
+
+import logging
+import pandas as pd
+from sqlalchemy import create_engine
+
+logging.basicConfig(level=logging.INFO,
+                    format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
+                    datefmt='%a, %d %b %Y %H:%M:%S',
+                    filename='log_repay_ment.log',
+                    filemode='a+')
+logging.getLogger('sqlalchemy.engine').setLevel(logging.INFO)
+formatter = logging.Formatter('%(name)-12s: %(levelname)-8s %(message)s')
+console = logging.StreamHandler()
+console.setFormatter(formatter)
+logging.getLogger('sqlalchemy.engine').addHandler(console)
+
+engine_audit = create_engine('mysql+mysqldb://yulong:ohVU1nPITynSZwR2@172.16.3.201:3306/new_transaction?charset=utf8',
+                             echo=True)
+
+sql_1_1 = """
+select plan_id from baitiao_repay_plan_repay_record_ref 
+where ref_amount > 0 AND  created_at>='%s' 
+AND repay_channel in(3,5,7,13,22,23,24)
+"""
+sql_1 = """
+select sum(ref_amount) repay_amount, plan_id 
+from baitiao_repay_plan_repay_record_ref 
+where plan_id in %s group by plan_id """
+
+sql_2 = """
+select id plan_id, principle, interest, service_fee, should_punish,red_package,repay_status 
+from user_bt_repayment_plan where id in %s"""
+
+sql_update = """update user_bt_repayment_plan set real_principle = %s, real_interest = %s, real_service_fee = %s, \
+ real_punish = %s, current_repayment = %s, collection_relief = %s, remain = %s,mitigate_all=%s,red_package=%s where id = %s;"""
+
+start_time = '2017-10-01'
+
+
+def cal_msg(x):
+    repay_amount = x['repay_amount']
+    principle = x['principle']
+    interest = x['interest']
+    service_fee = x['service_fee']
+    should_punish = x['should_punish']
+    res_msg = ''
+    remain = repay_amount - principle
+    remain = round(remain, 2)
+    if remain < 0:
+        res_msg += '减免本金%s元' % (-remain,)
+        if interest > 0:
+            res_msg += '，减免利息%s元' % (interest,)
+        if service_fee > 0:
+            res_msg += '，减免服务费%s元' % (service_fee,)
+        if should_punish > 0:
+            res_msg += '，减免罚息%s元' % (should_punish,)
+        return res_msg + '。'
+    remain -= interest
+    remain = round(remain, 2)
+    if remain < 0:
+        res_msg += '减免利息%s元' % (-remain,)
+        if service_fee > 0:
+            res_msg += '，减免服务费%s元' % (service_fee,)
+        if should_punish > 0:
+            res_msg += '，减免罚息%s元' % (should_punish,)
+        return res_msg + '。'
+    remain -= service_fee
+    remain = round(remain, 2)
+    if remain < 0:
+        res_msg += '减免服务费%s元' % (-remain,)
+        if should_punish > 0:
+            res_msg += '，减免罚息%s元' % (should_punish,)
+        return res_msg + '。'
+    remain -= should_punish
+    remain = round(remain, 2)
+    if remain < 0:
+        return '减免罚息%s元。' % -remain
+    return ''
+
+
+step = 10000
+df1_gen = pd.read_sql(sql=sql_1_1 % start_time, con=engine_audit, chunksize=step)
+i = 0
+for df1 in df1_gen:
+    logging.info('-----------------------------> i: %s <--------------------------' % i)
+    i += 1
+    logging.info('----------------------------> len(df1): %s  <------------------------------' % len(df1))
+    if len(df1) > 0:
+        ids = df1['plan_id'].astype(str).tolist()
+        df1 = pd.read_sql(sql=sql_1 % str(tuple(ids)).replace(',)', ')'), con=engine_audit)
+        df2 = pd.read_sql(sql=sql_2 % str(tuple(ids)).replace(',)', ')'), con=engine_audit)
+
+        df = pd.merge(df1, df2, on='plan_id')
+        df.fillna(0, inplace=True)
+        df['repay_amount'] = df['repay_amount'].apply(lambda x: round(x, 2))
+        df['principle'] = df['principle'].apply(lambda x: round(x, 2))
+        df['interest'] = df['interest'].apply(lambda x: round(x, 2))
+        df['service_fee'] = df['service_fee'].apply(lambda x: round(x, 2))
+        df['should_punish'] = df['should_punish'].apply(lambda x: round(x, 2))
+        df['red_package'] = df['red_package'].apply(lambda x: round(x, 2))
+        df.repay_status = df.repay_status.astype(int)
+        # 如果是其他的状态，则使用实际的还款金额
+        df.ix[df.repay_status != 3, 'principle'] = df.ix[df.repay_status != 3].apply(
+            lambda x: min(x.principle, x.repay_amount), axis=1)
+        df.ix[df.repay_status != 3, 'interest'] = df.ix[df.repay_status != 3].apply(
+            lambda x: round(min(x.repay_amount - x.principle, x.interest), 2), axis=1)
+        df.ix[df.repay_status != 3, 'service_fee'] = df.ix[df.repay_status != 3].apply(
+            lambda x: round(min(x.service_fee, x.repay_amount - x.principle - x.interest), 2), axis=1)
+        df.ix[df.repay_status != 3, 'should_punish'] = df.ix[df.repay_status != 3].apply(
+            lambda x: round(min(x.should_punish, x.repay_amount - x.principle - x.interest - x.service_fee), 2), axis=1)
+        df.ix[df.repay_status != 3, 'red_package'] = 0
+        df['remain'] = df['repay_amount'] - df['principle'] - df['interest'] - df['service_fee'] - df['should_punish']
+        df['remain'] = df['remain'].apply(lambda x: round(x, 2))
+
+        # df['msg'] = df.apply(lambda x: cal_msg(x), axis=1)
+        df['collection_relife'] = 0
+        df.loc[df['remain'] < 0, 'collection_relife'] = -df.loc[df['remain'] < 0, 'remain']
+        df.loc[df['remain'] <= 0, 'remain'] = 0
+        # 其他减免
+        df['mitigate_all'] = df['collection_relife'] - df['red_package']
+        df['mitigate_all'] = df['mitigate_all'].apply(lambda x: round(x, 2))
+        df_list = df[
+            ['principle', 'interest', 'service_fee', 'should_punish', 'repay_amount', 'collection_relife', 'remain',
+             'mitigate_all', 'red_package', 'plan_id']].values.tolist()
+        logging.info('----------------------------> len(df_list): %s  <------------------------------' % len(df_list))
+        print str(df_list)
+        print sql_update
+        engine_audit.execute(sql_update, df_list)
+
+logging.info('-------------------------------------------done-----------------------------------')

白条/数据准备/白条支付宝退款关联.py

+# -*- coding:utf-8 -*-
+# Author: Perry_Zhu
+import pandas as pd
+import numpy as np
+import sys
+from sqlalchemy import create_engine
+
+reload(sys)
+sys.setdefaultencoding("utf-8")
+pd.options.mode.chained_assignment = None
+
+engine_new_transaction = create_engine(
+    'mysql+mysqldb://yulong:ohVU1nPITynSZwR2@172.16.3.201:3306/new_transaction?charset=utf8', echo=True)
+file_path = u'E:/baitiao/repay_online/2017-09/'
+query_plan = """
+SELECT id plan_id,order_no,term_no,(0-real_principle) principle,(0-real_interest) interest,
+(0-ifnull(real_service_fee,0)) service_fee,(0-ifnull(real_punish,0)) punish
+FROM user_bt_repayment_plan 
+WHERE repayment_plan_id is not NULL AND order_no in %s
+"""
+query_record = """
+SELECT business_flow,id record_id 
+FROM offline_alipay_record WHERE business_flow in %s
+"""
+query_ex = """
+select record_id,plan_id
+from new_transaction.baitiao_repay_plan_repay_record_ref 
+where  repay_channel=13;
+"""
+
+df = pd.read_excel(file_path + u'alipay_refund.xlsx',sheetname='Sheet2')
+df = df.dropna(axis=0)
+df.business_flow = df.business_flow.astype(str)
+df.order_no = df.order_no.astype(str)
+df.term_no = df.term_no.astype(int)
+df['ref_amount'] = df['ref_amount'].apply(lambda x: np.round(x, 2))
+order_nos = df['order_no'].tolist()
+flow_ids = df['business_flow'].tolist()
+df_r = pd.read_sql(query_record % (str(tuple(flow_ids)).replace(',)', ')')), engine_new_transaction)
+df_f = pd.read_sql(query_plan % (str(tuple(order_nos)).replace(',)', ')')), engine_new_transaction)
+df_r.business_flow = df_r.business_flow.astype(str)
+df_f.order_no = df_f.order_no.astype(str)
+df_f.term_no = df_f.term_no.astype(int)
+df_out = pd.merge(df, df_r, on='business_flow')
+df_out['order_no'] = df_out['order_no'].astype(str)
+df_out['term_no'] = df_out['term_no'].astype(int)
+df_f['order_no'] = df_f['order_no'].astype(str)
+df_f['term_no'] = df_f['term_no'].astype(int)
+df_out = pd.merge(df_out, df_f, on=['order_no', 'term_no'])
+df_out = df_out[['plan_id', 'record_id', 'ref_amount', 'principle', 'interest', 'service_fee', 'punish']]
+df_out['repay_channel'] = 13
+df_out['repay_type'] = 'ALIPAY'
+df_out.to_excel(file_path + u'alipay退款.xlsx', index=None)
+df_out.to_sql(name='baitiao_repay_plan_repay_record_ref', con=engine_new_transaction, if_exists='append', index=None)

白条/数据准备/白条数据录入步骤

+# 说白条数据录入说明文档
+### 录入线上还款数据
+- 执行account\内控\数据准备\白条\白条线上还款录入repay_record_online.py脚本，
+注意更改白条还款明细的文件位置；
+- 校验数据的准确性。
+- 确保还款白条还款计划已经录入成功，然后执行account\内控\数据准备\白条\同步线上白条红包减免.py,添加白条还款计划的红包信息
+- 执行account\内控\数据准备\白条\同步线上白条红包减免更新ref表.py，录入红包信息；
+- 执行account\内控\数据准备\白条\白条ref表插入数据.py，插入到baitiao_repay_plan_repay_record_ref表中；
+- 执行account\内控\数据准备\白条\白条还款状态时间更新.py脚本，更新白条还款计划的实际还款时间；
+- 执行account\内控\数据准备\白条\白条罚息更新.py脚本，更新白条还款计划的应还罚息；
+- 执行account\内控\数据准备\白条\白条ref表本息服罚拆分.py，将baitiao_repay_plan_repay_record_ref表的ref_amount拆分为本利服罚；
+- 执行account\内控\数据准备\白条\更新白条还款计划实还.py，设置白条还款计划的实还信息。
\ No newline at end of file

白条/数据准备/白条现金支付勾稽.py

+# -*- coding:utf-8 -*-
+# Author: Perry_Zhu
+import numpy as np
+import pandas as pd
+import sys
+from sqlalchemy import create_engine
+
+pd.options.mode.chained_assignment = None
+
+reload(sys)
+sys.setdefaultencoding('utf8')
+engine_new_transaction = create_engine(
+    'mysql+mysqldb://yulong:ohVU1nPITynSZwR2@172.16.3.201:3306/new_transaction?charset=utf8',
+    echo=True)
+engine_pay_center = create_engine(
+    'mysql+mysqldb://syzhu_data_r:ulk0989742097y43@192.168.4.6:8066/payment_center?charset=utf8', echo=True)
+
+bill_start_time = '2017-08-01'
+bill_end_time = '2017-09-01'
+path = "E:/baitiao/baitiao_cash/2017-08/"
+
+sql_record = """
+  select DISTINCT order_id 
+  from repay_record_online 
+  where pay_approach = 18
+    and enable = 1 and is_ref = 0 
+    AND  bill_time>='%s' 
+    AND bill_time<'%s'
+    AND id in (
+    19360735,19360737,19360813,19360815,19360843,19360851,19360853,19360855,19360885,19360889,19360891,19360893,19360895,19360897,19360903,19360905,19360907,19360909,19360911,19360913,19360915,19360917,19360921,19360943,19360945,19360947,19360955,19360957,19360959,19360961,19360963,19360965,19360967,19360977
+    )
+    GROUP BY order_id
+    HAVING sum(amount)!=0
+"""
+select_repay = """
+ select id record_id,amount ref_amount,order_id ,bill_time
+  from repay_record_online 
+  where pay_approach = 18
+    and enable = 1 and is_ref = 0 
+    AND  bill_time>='%s' 
+    AND bill_time<'%s'
+    AND order_id in %s
+"""
+
+sql_pay_center = """
+  select order_id, merchant_order_no order_no, merchant_id 
+  from repay_order t 
+  where t.repay_status = 3
+  -- and merchant_id=10
+   AND pay_approach = 6
+   and t.order_id in %s
+"""
+sql_order = """
+SELECT t1.id repay_id, t1.order_no,t2.real_loan_amount ref_amount
+FROM baitiao_cash_repay t1 
+JOIN baitiao_audit.baitiao_order t2 ON t1.ref_id =t2.ref_id
+WHERE t2.is_active in(1,-2)
+AND t2.order_no in %s
+"""
+
+update_is_ref = """update repay_record_online set is_ref =1 WHERE id in %s """
+
+
+def refund_online():
+    df_record = pd.read_sql(sql=sql_record % (bill_start_time, bill_end_time), con=engine_new_transaction)
+
+    # for df_record in df_all:
+    if len(df_record) > 0:
+        df_record.order_id = df_record.order_id.astype(str)
+        order_id_list = df_record.order_id.unique().tolist()
+        df_real = pd.read_sql(
+            select_repay % (bill_start_time, bill_end_time, str(tuple(order_id_list)).replace(',)', ')')),
+            con=engine_new_transaction)
+        df_pay_center = pd.read_sql(sql=sql_pay_center % str(tuple(order_id_list)).replace(',)', ')'),
+                                    con=engine_pay_center)
+        df_pay_center.order_id = df_pay_center.order_id.astype(str)
+        df_record = pd.merge(df_real, df_pay_center, on='order_id')
+        df_record_not = df_real.ix[~df_real['order_id'].isin(df_record['order_id'])]
+        df_record.order_no = df_record.order_no.astype(str)
+        if len(df_record_not) > 0:
+            with open(path + 'record_not_in_pay_center.csv', 'a') as f:
+                df_record_not.to_csv(f, index=None)
+        if len(df_record) > 0:
+            with open(path + 'record_is_in_pay_center.csv', 'a') as f:
+                df_record.to_csv(f, index=None)
+            df_record['ref_amount'] = df_record['ref_amount'].apply(lambda x: np.round(x, 2))
+            df_record = df_record[['bill_time', 'record_id', 'ref_amount', 'order_no']]
+            order_no_list = df_record.order_no.astype(str).unique().tolist()
+            df_plan = pd.read_sql(sql=sql_order % str(tuple(order_no_list)).replace(',)', ')'),
+                                  con=engine_new_transaction)
+            if len(df_plan) > 0:
+                df_plan.order_no = df_plan.order_no.astype(str)
+                df_plan.repay_id = df_plan.repay_id.astype(int)
+                df_plan['ref_amount'] = df_plan['ref_amount'].apply(lambda x: np.round(x, 2))
+                df_1 = pd.merge(df_plan, df_record, on=['order_no', 'ref_amount'])
+                df_n = df_record.ix[~df_record['record_id'].isin(df_1['record_id'])]
+                if len(df_n) > 0:
+                    # df_n.drop(['ref_amount_str', 'uniqueness_no'], axis=1, inplace=True)
+                    with open(path + u'not_in_repay.csv', 'a') as f:
+                        df_n.to_csv(f, index=None)
+                if len(df_1) > 0:
+                    df_i = df_1[['repay_id', 'record_id', 'ref_amount']]
+                    df_i['repay_channel'] = 7
+                    df_i.to_sql('baitiao_cash_record_ref', con=engine_new_transaction, if_exists='append', index=None)
+                    record_ids = df_i['record_id'].astype(int).tolist()
+                    # pd.read_sql(update_is_ref % (str(tuple(record_ids)).replace(',)', ')'),), con=engine_new_transaction)
+                    engine_new_transaction.execute(update_is_ref % (str(tuple(record_ids)).replace(',)', ')'),))
+            else:
+                with open(path + u'no_baitiao_cash_record.csv', 'a') as f:
+                    df_record.to_csv(f, index=None)
+
+
+select_alipay = """
+select id record_id,outcome ref_amount,business_flow  
+FROM offline_alipay_record WHERE outcome<0 AND business_flow in %s 
+"""
+select_cash_repay = """
+select id repay_id,order_no financial_flow from baitiao_cash_repay WHERE  order_no in %s AND real_order_amount<0
+"""
+update_off_ali_ref = """update offline_alipay_record set is_ref =1 WHERE id in %s """
+
+
+def refund_offline():
+    df = pd.read_excel(u'E:/baitiao/易联易宝退款/退款数据-7月份.xlsx',
+                       converters={u'电话': str, u'订单号': str, u'流水号/银行订单号': str, u'退款金额': float})
+    df.rename(columns={u'姓名': 'user_name',
+                       u'支付宝账号/银行账户': 'alipay_account',
+                       u'电话': 'phone_no_remark',
+                       u'实际退款日期（流水日期）': 'transfer_time',
+                       u'退款金额': 'outcome',
+                       u'还款计划ID/期数': 'remark',
+                       u'业务类型': 'repay_type',
+                       u'流水号/银行订单号': 'business_flow',
+                       u'订单号': 'financial_flow'
+                       }, inplace=True)
+    df = df.ix[df['repay_type'] == '现金支付']
+    df = df[['business_flow', 'financial_flow']]
+    if len(df) > 0:
+        flow_ids = df.business_flow.astype(str).unique().tolist()
+        order_nos = df.financial_flow.astype(str).unique().tolist()
+        df_record = pd.read_sql(select_alipay % str(tuple(flow_ids)).replace(',)', ')'), engine_new_transaction)
+        df_plan = pd.read_sql(select_cash_repay % str(tuple(order_nos)).replace(',)', ')'), engine_new_transaction)
+        df_1 = pd.merge(df, df_record, on='business_flow')
+        df_2 = pd.merge(df_1, df_plan, on='financial_flow')
+        df_2['ref_amount'] = df_2['ref_amount'].apply(lambda x: np.round(x, 2))
+        df_3 = df_2[['repay_id', 'record_id', 'ref_amount']]
+        with open(path + u'refund.csv', 'a') as f:
+            df_3.to_csv(f, index=None)
+        df_3.to_sql('baitiao_cash_record_ref', con=engine_new_transaction, if_exists='append', index=None)
+        record_ids = df_3['record_id'].astype(int).unique().tolist()
+        print record_ids
+        engine_new_transaction.execute(update_off_ali_ref % (str(tuple(record_ids)).replace(',)', ')'),))
+
+
+# refund_offline()
+refund_online()

白条/数据准备/白条直投/白条直投还款计划.py

+# -*- coding:utf-8 -*-
+# Author: Perry_Zhu
+import pandas as pd
+import numpy as np
+import sys
+from sqlalchemy import create_engine
+
+reload(sys)
+sys.setdefaultencoding("utf-8")
+pd.options.mode.chained_assignment = None
+
+engine_new_transaction = create_engine(
+    'mysql+mysqldb://yulong:ohVU1nPITynSZwR2@172.16.3.201:3306/new_transaction?charset=utf8', echo=True)
+
+engine_xyqb = create_engine('mysql+mysqldb://syzhu_data_r:ulk0989742097y43@192.168.4.6:8066/xyqb?charset=utf8',
+                            echo=True)
+query_fk = """
+SELECT DISTINCT order_no 
+FROM baitiao_audit.baitiao_order t1
+JOIN baitiao_audit.baitiao_finance_record t2 ON t1.batch_no_id=t2.batch_no
+WHERE 
+t1.is_active=1
+AND t2.trans_date>='%s'
+AND t2.trans_date<'%s'
+"""
+query_xl = """
+SELECT
+    bill.id repay_plan_id,
+	bill.order_no,
+	5 funding_code,
+	bill.term_no,
+	t1.`status`,
+	plan.deadline,
+	plan.principal,
+	plan.interest,
+    t1.refund_status,
+    CASE t1.refund_status
+    WHEN 1
+    THEN t1.updated_at
+    ELSE NULL 
+    END as refund_time,
+	t1.rate AIR
+FROM
+    baitiao_fund_repayment_plan plan
+JOIN baitiao_bill_repayment_plan bill ON plan.plan_id=bill.id
+JOIN baitiao_fund_order t1 ON t1.order_id = bill.order_id
+WHERE 
+t1.status=3
+AND bill.order_no in %s
+"""
+
+select_exist = """
+select DISTINCT repay_plan_id 
+from bt_funding_repayment_plan
+WHERE order_no in %s 
+"""
+select_exist_refund = """
+select DISTINCT order_no,term_no 
+from bt_funding_repayment_plan
+WHERE order_no in %s 
+-- AND principal<0
+"""
+select_insert_refund = """
+select order_no,funding_code,term_no,`status`,deadline,principal,interest,
+current_repayment,refund_status,refund_time,AIR,remark 
+from bt_funding_repayment_plan
+WHERE order_no in %s 
+AND principal>0
+"""
+
+
+# 录入跨月的退款数据(与deadline_end相同)
+# refund_start = '2017-09-01'
+
+
+def transt_float(df):
+    df['principal'].fillna(0, inplace=True)
+    df['interest'].fillna(0, inplace=True)
+    df['principal'] = df['principal'].apply(lambda x: np.round(x, 2))
+    df['interest'] = df['interest'].apply(lambda x: np.round(x, 2))
+    return df
+
+
+update_sql = """
+    update bt_funding_repayment_plan 
+    set `status`=%s ,deadline=%s,principal=%s,interest=%s,current_repayment=%s,refund_time=%s,refund_status=%s,AIR=%s
+    WHERE  repay_plan_id=%s AND order_no=%s AND term_no=%s
+"""
+
+loan_start = '2017-09-01'
+loan_end = '2017-10-01'
+step = 10000
+
+
+def zt_xiaolian():
+    df_order = pd.read_sql(query_fk % (loan_start, loan_end), engine_new_transaction)
+    order_nos = df_order['order_no'].astype(str).tolist()
+    df_xl = pd.read_sql(query_xl % (str(tuple(order_nos)).replace(',)', ')')), engine_xyqb)
+    if len(df_xl) > 0:
+        df_xl = transt_float(df_xl)
+        df_xl['current_repayment'] = df_xl['principal'] + df_xl['interest']
+        order_nos = df_xl['order_no'].astype(str).unique().tolist()
+        df_e = pd.read_sql(select_exist % (str(tuple(order_nos)).replace(',)', ')')), engine_new_transaction)
+        df_e.repay_plan_id = df_e.repay_plan_id.astype(int)
+        df_xl.repay_plan_id = df_xl.repay_plan_id.astype(int)
+        df_updte = pd.merge(df_xl, df_e, on=['repay_plan_id'])
+        if len(df_updte) > 0:
+            val_list = df_updte[['status', 'deadline', 'principal', 'interest', 'current_repayment', 'refund_time'
+                , 'refund_status', 'AIR', 'repay_plan_id', 'order_no', 'term_no']].values.tolist()
+            engine_new_transaction.execute(update_sql, val_list, chunksize=step)
+            df_xl = df_xl.ix[~df_xl['repay_plan_id'].isin(df_updte['repay_plan_id'])]
+        if len(df_xl) > 0:
+            df_xl.to_sql('bt_funding_repayment_plan', con=engine_new_transaction, chunksize=step, if_exists='append',
+                         index=None)
+
+
+zt_xiaolian()

白条/数据准备/白条直投/白条直投还资金方实还录入.py

+# -*- coding:utf-8 -*-
+# Author: Perry_Zhu
+import numpy as np
+import pandas as pd
+import sys
+from sqlalchemy import create_engine
+
+engine_new_transaction = create_engine(
+    'mysql+mysqldb://yulong:ohVU1nPITynSZwR2@172.16.3.201:3306/new_transaction?charset=utf8', echo=True)
+
+engine_xyqb = create_engine('mysql+mysqldb://syzhu_data_r:ulk0989742097y43@192.168.4.6:8066/xyqb?charset=utf8',
+                            echo=True)
+
+query_zc = """
+SELECT plan.plan_id repay_plan_id,plan.term_no,plan.deadline,plan.principal,plan.interest,
+  plan.discount,date(r.created_at)repaid_at,plan.finance_record_id
+FROM baitiao_fund_repayment_plan plan 
+JOIN baitiao_finance_record r ON plan.finance_record_id=r.id AND r.type=1 AND locate('正常',r.remark) > 0
+"""
+
+
+def update_zc():
+    df = pd.read_sql(query_zc, engine_xyqb)
+    df['funding_code'] = 5
+    df['refund_status'] = 0
+    df['principal_account'] = 1
+    df['interest_account'] = 1
+    df['discount_acount'] = 2
+    df['behalf_repay'] = 0
+    df.to_sql('bt_funding_repayment_record', con=engine_new_transaction, chunksize=10000, if_exists='append',
+              index=None)
+
+
+# update_zc()
+
+
+
+query_yq = """
+SELECT plan.plan_id repay_plan_id,plan.term_no,plan.deadline,plan.principal,plan.interest,
+  IF(ISNULL(plan.free_interest_record_id),3,2) interest_account,
+  plan.discount,date(r.created_at)repaid_at,plan.finance_record_id
+FROM baitiao_fund_repayment_plan plan 
+JOIN baitiao_finance_record r ON plan.finance_record_id=r.id AND r.type=1 AND locate('逾期',r.remark) > 0
+"""
+
+
+def update_yq():
+    df = pd.read_sql(query_yq, engine_xyqb)
+    df['funding_code'] = 5
+    df['refund_status'] = 0
+    df['principal_account'] = 3
+    df['discount_acount'] = 2
+    df['behalf_repay'] = 0
+    df.to_sql('bt_funding_repayment_record', con=engine_new_transaction, chunksize=10000, if_exists='append',
+              index=None)
+
+
+# update_yq()
+
+
+
+
+query_refund = """
+SELECT plan.fund_order_id,date(r.created_at)repaid_at,plan.finance_record_id
+FROM baitiao_fund_repayment_plan plan 
+JOIN baitiao_finance_record r ON plan.finance_record_id=r.id AND r.type=1 AND locate('退款',r.remark) > 0
+"""
+query_tk = """
+SELECT plan.fund_order_id,plan.plan_id repay_plan_id,plan.term_no,plan.deadline,plan.principal,
+  case plan.term_no
+  WHEN 1
+  THEN plan.interest
+  ELSE 0.0
+  END AS interest,
+  case plan.term_no
+  WHEN 1
+  THEN 2
+  ELSE 3
+  END AS interest_account,
+  plan.discount
+FROM baitiao_fund_repayment_plan plan 
+WHERE plan.fund_order_id in %s
+"""
+
+
+def update_tk():
+    df_t = pd.read_sql(query_refund, engine_xyqb)
+    df_t['fund_order_id'] = df_t['fund_order_id'].astype(int)
+    plan_ids = df_t['fund_order_id'].tolist()
+    df = pd.read_sql(query_tk % (str(tuple(plan_ids)).replace(',)', ')')), engine_xyqb)
+    df['fund_order_id'] = df['fund_order_id'].astype(int)
+    df = pd.merge(df_t, df, on='fund_order_id')
+    df.drop(['fund_order_id'], axis=1, inplace=True)
+    df['funding_code'] = 5
+    df['refund_status'] = 3
+    df['principal_account'] = 3
+    # df['interest_account'] = 3
+    df['discount_acount'] = 2
+    df['behalf_repay'] = 0
+    df.to_sql('bt_funding_repayment_record', con=engine_new_transaction, chunksize=10000, if_exists='append',
+              index=None)
+
+
+# update_tk()

白条/数据准备/白条线下还款勾稽.py

+# -*- coding:utf-8 -*-
+# Author: Perry_Zhu
+
+import numpy as np
+import pandas as pd
+import sys
+from sqlalchemy import create_engine
+
+pd.options.mode.chained_assignment = None
+
+reload(sys)
+sys.setdefaultencoding('utf8')
+engine_new_transaction = create_engine(
+    'mysql+mysqldb://yulong:ohVU1nPITynSZwR2@172.16.3.201:3306/new_transaction?charset=utf8',
+    echo=True)
+
+select_alipay = """
+select id record_id,outcome ref_amount,business_flow  
+FROM offline_alipay_record WHERE 
+outcome<0 
+AND createTime>='2017-08-01'
+AND business_flow in %s 
+"""
+select_plan = """
+select id plan_id,order_no financial_flow,required_repayment ref_amount 
+from user_bt_repayment_plan WHERE  order_no in %s AND principle<0
+"""
+update_off_ali_ref = """update offline_alipay_record set is_ref =1 WHERE id in %s """
+path = u"E:/baitiao/线上白条还款/2017-07/"
+
+
+def baitiao_offline():
+    df = pd.read_excel(u'E:/baitiao/易联易宝退款/退款数据-7月份.xlsx',
+                       converters={u'电话': str, u'订单号': str, u'流水号/银行订单号': str, u'退款金额': float})
+    df.rename(columns={u'姓名': 'user_name',
+                       u'支付宝账号/银行账户': 'alipay_account',
+                       u'电话': 'phone_no_remark',
+                       u'实际退款日期（流水日期）': 'transfer_time',
+                       u'退款金额': 'outcome',
+                       u'还款计划ID/期数': 'term_no',
+                       u'业务类型': 'repay_type',
+                       u'流水号/银行订单号': 'business_flow',
+                       u'订单号': 'financial_flow'
+                       }, inplace=True)
+    df = df.ix[df['repay_type'] == '白条']
+    df = df[['business_flow', 'financial_flow', 'term_no']]
+    if len(df) > 0:
+        # df['outcome'] = df['outcome'].apply(lambda x: np.round(x, 2))
+        flow_ids = df.business_flow.astype(str).unique().tolist()
+        order_nos = df.financial_flow.astype(str).unique().tolist()
+        df_record = pd.read_sql(select_alipay % str(tuple(flow_ids)).replace(',)', ')'), engine_new_transaction)
+        df_record['ref_amount'] = df_record['ref_amount'].apply(lambda x: np.round(x, 2))
+        df_plan = pd.read_sql(select_plan % str(tuple(order_nos)).replace(',)', ')'), engine_new_transaction)
+        df_plan['ref_amount'] = df_plan['ref_amount'].apply(lambda x: np.round(x, 2))
+        df_1 = pd.merge(df, df_record, on='business_flow')
+        df_2 = pd.merge(df_1, df_plan, on=['financial_flow', 'ref_amount'])
+        df_3 = df_2[['plan_id', 'record_id', 'ref_amount']]
+        df_3['repay_channel'] = 13
+        df_3['repay_type'] = 'ALIPAY'
+        with open(path + u'白条线下还款关联.csv', 'a') as f:
+            df_3.to_csv(f, index=None)
+        df_3.to_sql('baitiao_repay_plan_repay_record_ref', con=engine_new_transaction, if_exists='append', index=None)
+        record_ids = df_3['record_id'].astype(int).unique().tolist()
+        print record_ids
+        engine_new_transaction.execute(update_off_ali_ref % (str(tuple(record_ids)).replace(',)', ')'),))
+
+
+baitiao_offline()

白条/数据准备/白条罚息更新.py

+# -*- coding: utf-8 -*-
+import sys
+import datetime
+import pandas as pd
+import numpy as np
+
+from sqlalchemy import create_engine
+
+reload(sys)
+sys.setdefaultencoding('utf8')
+
+
+# 获取小数点后两位，小数点后3位开始逢数进一
+def get_2_ceil(num):
+    start = str(num).find('.')
+    if start == -1:
+        return np.round(start, 2)
+    else:
+        if str(num).__len__() - start > 3:
+            return np.round(np.ceil(float(str(num)[:start + 4]) * 100) / 100, 2)
+        else:
+            return np.round(float(str(num)[:start + 3]), 2)
+
+
+# 线上线下罚息
+def cal_deplay_fee(contract_amount, contract_term, deadline, repaid_at, principle, interest, merchantId, is_online):
+    result = {'lkb_deplay_fee': 0}
+    lkb_deplay_days = (repaid_at.date() - deadline.date()).days
+    if lkb_deplay_days <= 0:
+        return result
+    if is_online == 0:  # 小数向上取
+        # 线下白条
+        result['lkb_deplay_fee'] = get_2_ceil((principle + interest) * 0.005 * lkb_deplay_days + contract_amount * 0.01)
+        # np.round((principle + interest) * 0.005 * lkb_deplay_days + contract_amount * 0.01,2)
+        return result
+    if merchantId == 1:
+        # 八天白条
+        result['lkb_deplay_fee'] = get_2_ceil(contract_amount * 0.01 + contract_amount * 0.005 * lkb_deplay_days)
+        # np.round(contract_amount * 0.01 + contract_amount * 0.005 * lkb_deplay_days,2)
+        return result
+    if repaid_at < datetime.datetime(2016, 8, 29, 14, 26, 0):
+        # 第一版 ? origin_amount
+        origin_amount = principle + interest
+        result['lkb_deplay_fee'] = get_2_ceil(origin_amount * 0.01 + origin_amount * 0.005 * lkb_deplay_days)
+        # np.round(origin_amount*0.01+origin_amount*0.005*lkb_deplay_days,2)
+    elif repaid_at >= datetime.datetime(2016, 8, 29, 14, 26, 0) and repaid_at < datetime.datetime(2017, 3, 16, 15, 2,
+                                                                                                  0):
+        # 第二版--不分期
+        if contract_term <= 1:
+            result['lkb_deplay_fee'] = get_2_ceil(contract_amount * 0.01 + contract_amount * 0.005 * lkb_deplay_days)
+            # np.round(contract_amount*0.01+contract_amount*0.005*lkb_deplay_days,2)
+        else:
+            # 分期
+            result['lkb_deplay_fee'] = get_2_ceil(principle * 0.005 * lkb_deplay_days + contract_amount * 0.01)
+            # np.round(principle*0.005*lkb_deplay_days+contract_amount*0.01,2)
+    elif repaid_at >= datetime.datetime(2017, 3, 16, 15, 2, 0):
+        # 第三版
+        if contract_term <= 1:
+            result['lkb_deplay_fee'] = get_2_ceil(contract_amount * 0.01 + contract_amount * 0.005 * lkb_deplay_days)
+            # np.round(contract_amount*0.01+contract_amount*0.005*lkb_deplay_days,2)
+        else:
+            # 分期
+            result['lkb_deplay_fee'] = get_2_ceil(
+                (principle + interest) * 0.005 * lkb_deplay_days + contract_amount * 0.01)
+            # np.round((principle+interest)*0.005*lkb_deplay_days+contract_amount*0.01,2)
+    else:
+        print 'not support'
+    return result
+
+
+# 查询白条罚息
+read_punish_sql = '''
+SELECT t1.id,t1.order_no,t2.is_online,t2.merchantId ,t2.real_loan_amount,
+  t2.contract_term,t1.principle,t1.interest,t1.deadline,t1.biz_repaid_at
+FROM new_transaction.`user_bt_repayment_plan` t1
+ JOIN baitiao_audit.`baitiao_order` t2 ON t1.order_no = t2.order_no
+ WHERE t1.repay_status in (3,6) and t1.biz_repaid_at >= '%s' and t1.biz_repaid_at < '%s' 
+ AND DATE(t1.biz_repaid_at) > DATE(t1.deadline) 
+'''
+
+update_sql = '''
+update user_bt_repayment_plan set should_punish=%s where id = %s
+'''
+
+engine_audit = create_engine('mysql+mysqldb://yulong:ohVU1nPITynSZwR2@172.16.3.201:3306/new_transaction?charset=utf8',
+                             echo=True)
+
+step = 10000
+start_time = '2017-09-01'
+end_time = '2017-10-01'
+df_gen = pd.read_sql(sql=read_punish_sql % (start_time, end_time), con=engine_audit, chunksize=10000)
+df_out = pd.DataFrame()
+i = 0
+for df in df_gen:
+    print '-----------------------i: %s -------------------------' % i
+    i += 1
+    df.fillna(0, inplace=True)
+    df['should_punish'] = df.apply(lambda x: cal_deplay_fee(x['real_loan_amount'], x['contract_term'], x['deadline'],
+                                                            x['biz_repaid_at'], x['principle'], x['interest'],
+                                                            x['merchantId'], x['is_online'])['lkb_deplay_fee'], axis=1)
+    df['id'] = df['id'].map('{:.0f}'.format)
+    up_val = df[['should_punish', 'id']].values.tolist()
+    engine_audit.execute(update_sql, up_val)
+    print '-----------------------i: %s done-------------------------' % i
+
+print '---------------------------------done !-------------------------------'

白条/数据准备/白条还款状态时间更新.py

+# -*- coding: utf-8 -*-
+import sys
+import datetime
+import pandas as pd
+import numpy as np
+
+from sqlalchemy import create_engine
+
+reload(sys)
+sys.setdefaultencoding('utf8')
+
+'''
+1、基于白条线上还款，更新还款状态时间
+2、注意更新完后，执行下罚息
+3、代码待测试
+'''
+
+engine_audit = create_engine('mysql+mysqldb://yulong:ohVU1nPITynSZwR2@172.16.3.201:3306/new_transaction?charset=utf8',
+                             echo=True)
+
+engine_xyqb = create_engine('mysql+mysqldb://syzhu_data_r:ulk0989742097y43@192.168.4.6:8066/xyqb?charset=utf8',
+                            echo=True)
+
+engine_offline = create_engine('mysql+mysqldb://syzhu_data_r:ulk0989742097y43@192.168.4.6:8066/offline?charset=utf8',
+                               echo=True)
+
+update_sql = '''
+update user_bt_repayment_plan set biz_repaid_at=%s,repay_status=%s where id=%s
+'''
+path = u"E:/baitiao/线上白条还款/2017-09/"
+
+
+def offline_update(df_plan):
+    if len(df_plan) <= 0:
+        return
+    sql_1 = '''
+    SELECT id xyqb_plan_id, order_id,term_no,`actual_repaid_at`,`repaid_status` FROM `order_repaid_record`
+    WHERE id in %s
+    '''
+    step = 5000
+    for i in xrange(0, len(df_plan), step):
+        df_plan_sub = df_plan[i:i + step]
+        if len(df_plan_sub) > 0:
+            repayment_plan_ids = df_plan_sub.repayment_plan_id.astype(int).tolist()
+            df_gen = pd.read_sql(sql_1 % str(tuple(repayment_plan_ids)).replace(',)', ')'), engine_offline)
+            if len(df_gen) > 0:
+                df_gen['order_id'] = df_gen['order_id'].astype(str)
+                df_gen['term_no'] = df_gen['term_no'].astype(int)
+                df_plan_sub['order_no'] = df_plan_sub['order_no'].astype(str)
+                df_plan_sub['term_no'] = df_plan_sub['term_no'].astype(int)
+                df_2 = pd.merge(df_plan_sub, df_gen, left_on=['order_no', 'term_no'], right_on=['order_id', 'term_no'],
+                                how='outer')
+                df_2 = df_2.ix[~df_2.xyqb_plan_id.isnull()]
+                df_2.fillna(0, inplace=True)
+                # 线下还款的状态 1 表示以还款
+                df_2.ix[df_2.repaid_status == 1, 'repaid_status'] = 3
+                df_2['repayment_plan_id'] = df_2['repayment_plan_id'].astype(int)
+                df_2['xyqb_plan_id'] = df_2['xyqb_plan_id'].astype(int)
+                df_2['diff'] = df_2['xyqb_plan_id'] - df_2['repayment_plan_id']
+                if len(df_2) > 0:
+                    df_bad = df_2.ix[df_2['diff'] != 0]
+                    if len(df_bad) > 0:
+                        df_bad.to_csv(path + 'bad_offline_csv.csv', mode='a', encoding="utf-8")
+                    df_good = df_2.ix[df_2['diff'] == 0]
+                    if len(df_good) > 0:
+                        df_good = df_good[['actual_repaid_at', 'repaid_status', 'plan_id']]
+                        df_good['actual_repaid_at'] = pd.to_datetime(df_good['actual_repaid_at'])
+                        df_good['repaid_status'] = df_good['repaid_status'].astype(int)
+                        df_good['plan_id'] = df_good['plan_id'].astype(int)
+                        up_val = df_good.values.tolist()
+                        engine_audit.execute(update_sql, up_val)
+
+
+def bill_update(df_plan):
+    if len(df_plan) <= 0:
+        return
+    sql_1 = '''
+
+    SELECT `id` xyqb_plan_id,`order_no`,term_no,`repaid_at`,`repayment_status`
+    FROM `baitiao_bill_repayment_plan` 
+    WHERE ENABLE = 1 AND repayment_status=3 and id in %s
+    '''
+    step = 5000
+    for i in xrange(0, len(df_plan), step):
+        df_plan_sub = df_plan[i:i + step]
+        repayment_plan_ids = df_plan_sub.repayment_plan_id.astype(int).tolist()
+        df_gen = pd.read_sql(sql_1 % str(tuple(repayment_plan_ids)).replace(',)', ')'), engine_xyqb)
+        df_gen['order_no'] = df_gen['order_no'].astype(str)
+        df_gen['term_no'] = df_gen['term_no'].astype(int)
+        df_plan_sub['order_no'] = df_plan_sub['order_no'].astype(str)
+        df_plan_sub['term_no'] = df_plan_sub['term_no'].astype(int)
+        df_2 = pd.merge(df_plan_sub, df_gen, on=['order_no', 'term_no'], how='outer')
+        print '======================df_2.ix[df_2.repaid_at.isnull()].length %s ===============' % len(
+            df_2.ix[df_2.repaid_at.isnull()])
+        df_2 = df_2.ix[~df_2.repaid_at.isnull()]
+        df_2.fillna(0, inplace=True)
+        df_2['repayment_plan_id'] = df_2['repayment_plan_id'].astype(int)
+        df_2['xyqb_plan_id'] = df_2['xyqb_plan_id'].astype(int)
+        df_2['diff'] = df_2['xyqb_plan_id'] - df_2['repayment_plan_id']
+        df_bad = df_2.ix[df_2['diff'] != 0]
+        if len(df_bad) > 0:
+            df_bad.to_csv(path + 'bad_bill_csv.csv', mode='a', encoding="utf-8")
+        df_good = df_2.ix[df_2['diff'] == 0]
+        df_good = df_good[['repaid_at', 'repayment_status', 'plan_id']]
+        df_good['repaid_at'] = pd.to_datetime(df_good['repaid_at'])
+        df_good['repayment_status'] = df_good['repayment_status'].astype(int)
+        df_good['plan_id'] = df_good['plan_id'].astype(int)
+        if len(df_good) > 0:
+            up_val = df_good[['repaid_at', 'repayment_status', 'plan_id']].values.tolist()
+            engine_audit.execute(update_sql, up_val)
+
+
+def online_update(df_plan):
+    if len(df_plan) <= 0:
+        return
+    sql_1 = '''
+        SELECT t1.`id` xyqb_plan_id ,t2.`order_no`,t1.term_no,t1.`repaid_at`,t1.`repayment_status`
+        FROM `baitiao_repayment_plan` t1
+        JOIN `baitiao_order` t2 ON t1.order_id = t2.id
+        WHERE t1.id in %s
+    '''
+    step = 5000
+    for i in xrange(0, len(df_plan), step):
+        print '=====第i====', i, i + step
+        df_plan_sub = df_plan[i:i + step]
+        repayment_plan_ids = df_plan_sub.repayment_plan_id.astype(int).tolist()
+        df_gen = pd.read_sql(sql_1 % str(tuple(repayment_plan_ids)).replace(',)', ')'), engine_xyqb)
+        df_gen['order_no'] = df_gen['order_no'].astype(str)
+        df_gen['term_no'] = df_gen['term_no'].astype(int)
+        df_plan_sub['order_no'] = df_plan_sub['order_no'].astype(str)
+        df_plan_sub['term_no'] = df_plan_sub['term_no'].astype(int)
+        df_2 = pd.merge(df_plan_sub, df_gen, on=['order_no', 'term_no'], how='outer')
+        print '======================df_2.ix[df_2.repaid_at.isnull()].length %s ===============' % len(
+            df_2.ix[df_2.repaid_at.isnull()])
+        df_2 = df_2.ix[~df_2.repaid_at.isnull()]
+        df_2.fillna(0, inplace=True)
+        df_2['repayment_plan_id'] = df_2['repayment_plan_id'].astype(int)
+        df_2['xyqb_plan_id'] = df_2['xyqb_plan_id'].astype(int)
+        df_2['diff'] = df_2['xyqb_plan_id'] - df_2['repayment_plan_id']
+        df_bad = df_2.ix[df_2['diff'] != 0]
+        if len(df_bad) > 0:
+            df_bad.to_csv(path + 'bad_online_csv.csv', mode='a', encoding="utf-8")
+        df_good = df_2.ix[df_2['diff'] == 0]
+        if len(df_good) > 0:
+            df_good = df_good[['repaid_at', 'repayment_status', 'plan_id']]
+            df_good['repaid_at'] = pd.to_datetime(df_good['repaid_at'])
+            df_good['repayment_status'] = df_good['repayment_status'].astype(int)
+            df_good['plan_id'] = df_good['plan_id'].astype(int)
+            up_val = df_good[['repaid_at', 'repayment_status', 'plan_id']].values.tolist()
+            engine_audit.execute(update_sql, up_val)
+
+
+'需要更新的plan'
+# sql_plan='''
+# select t1.id plan_id,t1.sys_tag,t1.repayment_plan_id,t1.order_no,t1.term_no,t1.ref_id
+# from user_bt_repayment_plan t1
+# join baitiao_audit.baitiao_order t2 on t1.ref_id = t2.ref_id and t2.is_active = 1
+# where t1.repay_status !=3
+# AND t1.repayment_plan_id is not NULL
+# '''
+
+sql_plan = '''
+select t1.id plan_id,t1.sys_tag,t1.repayment_plan_id,t1.order_no,t1.term_no,t1.ref_id
+from user_bt_repayment_plan t1
+join baitiao_audit.baitiao_order t2 on t1.ref_id = t2.ref_id and t2.is_active = 1
+JOIN baitiao_repay_plan_repay_record_ref rf on rf.plan_id=t1.id
+where rf.created_at>='2017-10-04'
+AND rf.repay_channel =13 
+-- in (3,5,7,22,23,24)
+'''
+
+df = pd.read_sql(sql_plan, engine_audit)
+df_plan_online = df.ix[df.sys_tag == 'XYQB_BT']
+df_plan_bill = df.ix[df.sys_tag == 'XYQB_BILL_BT']
+df_plan_offline = df.ix[df.sys_tag == 'OFFLINE_BT']
+# 线上白条
+online_update(df_plan=df_plan_online)
+# 账单白条
+bill_update(df_plan=df_plan_bill)
+# 线下白条
+offline_update(df_plan=df_plan_offline)