wanzb_v3_api/src/manage/controls.py

#coding=utf-8
'''
'''
import os,re,random
import json,time,datetime
import shutil
import tempfile
import zipfile
from docxtpl import DocxTemplate,InlineImage
from docx.shared import Mm
from django.db import transaction
from django.conf import settings
import common.models as cm
import common.error_info as ce
import common.common_functions as ccf
import common.common_control as ccc
import account.password_handle as ph
from utils.exceltool import ExcelTool
from utils.jgpush import send_notification_by_registration_ids
import wzhifuSDK as wxpay
from utils.exceltool import ExcelTool
from utils.qrcodetool import gen_general_qrcode
from django.db.models import Q,Sum,Count
from PIL import Image
from PIL import Image,ImageDraw,ImageFont
from threading import Thread
#from django.core.cache import cache
from django.db import connection

import xlrd
import xlwt
from xlutils.copy import copy
from xltpl.writer import BookWriter

def async(f):
    def wrapper(*args, **kwargs):
        thr = Thread(target=f, args=args, kwargs=kwargs)
        thr.start()
    return wrapper

def update_group_rank_day(match_id,match_group,stock_date):
    #return
    #ccc.cache.delete("*_"+stock_date)
    prset = cm.PlayerRecord.objects.filter(match_id=match_id,match_group=match_group,stock_date=stock_date).order_by("-total_income")
    records = prset.values()
    case_id = " case id "
    cases = []
    where = []
    #
    delkey = "*_%s_%s_%s" % (match_id,match_group,stock_date)
    del_keys = ccc.cache.keys(delkey)
    #ccc.cache.delete(*del_keys)
    for index,pr in enumerate(prset):
        case = "WHEN %s THEN %s" % (pr.id,index+1)
        cases.append(case)
        where.append(str(pr.id))
        #
        record = records[index]
        record.update({"group_rank":index+1})
        key = "%s_%s_%s_%s" % (pr.player_id,match_id,match_group,stock_date)
        ccc.pl.set(key,json.dumps(record,cls=ccc.CusJSONEncoder))
    ccc.pl.execute()

    case = case_id + " ".join(cases)
    where = ",".join(where)
    sql = "update player_record set group_rank = %s ELSE 0 END where id in (%s)" % (case,where)
    cursor = connection.cursor()
    cursor.execute(sql)
    cursor.close()

def add_model(cls,**kwargs):
    """
    """
    model_name = re.search(r'.*\.(\w+)View',str(cls.__class__)).groups()[0]
    model = getattr(cm,model_name)
    if model_name == "UserInfo":
        username = kwargs.get("username")
        usercode = kwargs.get("usercode")
        if cm.UserInfo.objects.filter(username=username).exists():
            raise ce.TipException(u"用户名重复!")
        if cm.UserInfo.objects.filter(usercode=usercode).exists():
            raise ce.TipException(u"用户代码重复!")
    if model_name == "Match":
        name = kwargs.get("name")
        if cm.Match.objects.filter(name=name).exists():
            raise ce.TipException(u"比赛名称重复!")
    if model_name == "MatchGoup":
        name = kwargs.get("name")
        match_id = kwargs.get("match_id")
        if cm.MatchGroup.objects.filter(name=name,match_id=match_id).exists():
            raise ce.TipException(u"分组名称重复!")

    if model_name == "Player":
        user_id = kwargs.get("user_id")
        match_id = kwargs.get("match_id")
        if cm.Player.objects.filter(user_id=user_id,match_id=match_id).exists():
            raise ce.TipException(u"重复添加选手!")
        user =cm.UserInfo.objects.filter(id=user_id).first()
        username = user.username if user else ""
        usercode = user.usercode if user else ""
        kwargs["username"] = username
        kwargs["usercode"] = usercode

    if model_name == "PlayerRecord":
        match_id = kwargs.get("match_id")
        stock_date = kwargs.get("stock_date")
        today_stock = json.dumps(kwargs.get("today_stock"))
        today_stock_img = json.dumps(kwargs.get("today_stock_img"))
        player_id = kwargs.get("player_id")
        today_fund = float(kwargs.get("today_fund"))
        is_markt = int(kwargs.get("is_markt",0))

        player = cm.Player.objects.filter(id=player_id).first()
        user_id = player.user_id
        init_fund = player.fund
        user = cm.UserInfo.objects.filter(id=user_id).first()
        username = user.username
        usercode = user.usercode
        match_group = player.match_group
        match = cm.Match.objects.filter(id=match_id).first()
        if player.match_status < 1:
            raise ce.TipException(u"该账号已暂停/退出比赛,如有疑问请联系管理员获取详情信息!")
        now_date = datetime.datetime.now().strftime("%Y-%m-%d")
        if match.end_time < now_date:
            raise ce.TipException(u"该比赛已结束!")

        #yesterday_date = (datetime.datetime.now()-datetime.timedelta(days=1)).strftime("%Y-%m-%d")
        yesterday = cm.PlayerRecord.objects.filter(
                        match_id=match_id,player_id=player_id).order_by("-stock_date").first()
        if yesterday:
            yesterday_fund = yesterday.today_fund
            yesterday_stock = yesterday.today_stock
            yesterday_stock_img = yesterday.today_stock_img
            yesterday_is_markt = yesterday.is_markt
        else:
            yesterday_fund = init_fund 
            yesterday_stock = ""
            yesterday_stock_img = "" 
            yesterday_is_markt = 0
        obj,flag = cm.PlayerRecord.objects.get_or_create(
                        player_id=player_id,
                        match_id=match_id,
                        stock_date=stock_date)
        obj.init_fund = init_fund
        obj.yesterday_fund = yesterday_fund
        obj.yesterday_stock = yesterday_stock
        obj.yesterday_stock_img = yesterday_stock_img
        obj.today_fund = today_fund
        obj.today_stock = today_stock
        obj.today_stock_img = today_stock_img
        obj.user_id = user_id
        obj.username = username
        obj.usercode = usercode
        obj.match_group = match_group
        obj.is_markt = is_markt
        obj.yesterday_is_markt = yesterday_is_markt
        #计算今日和昨日盈亏
        today_income = (today_fund - yesterday_fund)/float(yesterday_fund)
        total_income = (today_fund - init_fund)/float(init_fund)
        obj.today_income = round(today_income,4)
        obj.total_income = round(total_income,4)
        if not flag:
            obj.ctime = datetime.datetime.now()
        obj.save()

        #更新group_rank
        update_group_rank_day(match_id,match_group,obj.stock_date)

        return obj.id

    obj = model.objects.create(**kwargs)
    #
    if model_name == "Match":
        cm.MatchGroup.objects.create(
            match_id = obj.id, 
            name = obj.name+u"游客组", 
            is_active = 0,
            charge = 0
        )

    return obj.id

def update_model(cls,**kwargs):
    """
    """
    model_name = re.search(r'.*\.(\w+)View',str(cls.__class__)).groups()[0]
    model = getattr(cm,model_name)
    id = kwargs.pop("id")

    if model_name == "UserInfo":
        username = kwargs.get("username")
        usercode = kwargs.get("usercode")
        if cm.UserInfo.objects.exclude(id=id).filter(username=username).exists():
            raise ce.TipException(u"用户名重复!")
        if cm.UserInfo.objects.exclude(id=id).filter(usercode=usercode).exists():
            raise ce.TipException(u"用户代码重复!")
    if model_name == "Player":
        user_id = kwargs.get("user_id")
        match_id = kwargs.get("match_id")
        if cm.Player.objects.exclude(id=id).filter(user_id=user_id,match_id=match_id).exists():
            raise ce.TipException(u"重复添加选手!")
        user =cm.UserInfo.objects.filter(id=user_id).first()
        username = user.username if user else ""
        usercode = user.usercode if user else ""
        kwargs["username"] = username
        kwargs["usercode"] = usercode

    if model_name == "PlayerRecord":
        is_markt = int(kwargs.get("is_markt",0))
        kwargs["today_stock"] = json.dumps(kwargs.get("today_stock"))
        kwargs["today_stock_img"] = json.dumps(kwargs.get("today_stock_img"))

    rst = model.objects.filter(id=id).update(**kwargs)

    if model_name == "PlayerRecord":
        obj = cm.PlayerRecord.objects.filter(id=id).first()
        today_fund = obj.today_fund
        yesterday_fund = obj.yesterday_fund
        init_fund = obj.init_fund
        today_income = (today_fund - yesterday_fund)/float(yesterday_fund)
        total_income = (today_fund - init_fund)/float(init_fund)
        obj.today_income = round(today_income,4)
        obj.total_income = round(total_income,4)
        #
        player = cm.Player.objects.filter(id=obj.player_id).first()
        if player:
            obj.match_group = player.match_group
            obj.username = player.username
            obj.usercode = player.usercode
        obj.save()

        #更新player的init_fund
        player_id = obj.player_id
        cm.Player.objects.filter(id=player_id).update(fund=init_fund)

        ##更新group_rank
        #update_group_rank_day(obj.match_id,obj.match_group,obj.stock_date)
    if model_name == "UserInfo":
        ccc.del_cache("cdata_get_user_info_(%s,)"%id)

    return rst


def delete_model(cls,**kwargs):
    """
    """
    model_name = re.search(r'.*\.(\w+)View',str(cls.__class__)).groups()[0]
    model = getattr(cm,model_name)
    ids = str(kwargs.get("id")).split(",")
    rst = model.objects.filter(id__in=ids).delete()
    if model_name == "UserInfo":
        cm.Player.objects.filter(user_id__in=ids).delete()
        cm.PlayerRecord.objects.filter(user_id__in=ids).delete()
    if model_name == "Player":
        cm.PlayerRecord.objects.filter(player_id__in=ids).delete()
    if model_name == "Match":
        cm.PlayerRecord.objects.filter(match_id__in=ids).delete()
        cm.Player.objects.filter(match_id__in=ids).delete()
        cm.MatchGroup.objects.filter(match_id__in=ids).delete()
    if model_name == "MatchGroup":
        cm.PlayerRecord.objects.filter(match_group__in=ids).delete()
        cm.Player.objects.filter(match_group__in=ids).delete()
    #更新group_rank
    update_group_rank()
    return ids


def get_search_list(cls,**kwargs):
    """
    """
    model_name = re.search(r'.*\.(\w+)SearchView',str(cls.__class__)).groups()[0]
    model = getattr(cm,model_name)
    qset = model.objects.all().order_by("-id")
    if model_name == "Player":
        data = list(qset.values("id","user_id","username"))
        for item in data:
            user = cm.UserInfo.objects.filter(id=item["user_id"]).first()
            item["username"] = user.username
            item["usercode"] = user.usercode
            item["label"] = "%s(%s)" % (item["username"],item["usercode"])
    elif model_name == "Stock":
        data = list(qset.values("id","name","code"))
        for item in data:
            item["label"] = "%s(%s)" % (item["name"],item["code"])
    elif model_name == "UserInfo":
        data = list(qset.values("id","username","usercode"))
        for item in data:
            item["label"] = "%s(%s)" % (item["username"],item["usercode"])
    else:
        if kwargs.get("name"):
            qset = qset.filter(name__icontains=kwargs.get("name"))
        data = list(qset.values("id","name"))
    return data

def get_detail_info(cls,**kwargs):
    """
    """
    model_name = re.search(r'.*\.(\w+)View',str(cls.__class__)).groups()[0]
    model = getattr(cm,model_name)
    id = kwargs.get("id")
    rst = list(model.objects.filter(id=id).values())
    rst = rst[0] if rst else {}
    if model_name == "Player":
        user = cm.UserInfo.objects.filter(id=rst["user_id"]).first()
        match = cm.Match.objects.filter(id=rst["match_id"]).first()
        rst["username"] = user.username
        rst["usercode"] = user.usercode
        rst["match_name"] = match.name if match else ""
        rst["match_group"] = int(rst["match_group"])
    if model_name == "PlayerRecord":
        rst["today_stock"] = json.loads(rst["today_stock"]) if rst["today_stock"] else []
        rst["today_stock_img"] = json.loads(rst["today_stock_img"]) if rst["today_stock_img"] else []
        rst["yesterday_stock"] = json.loads(rst["yesterday_stock"]) if rst["yesterday_stock"] else []
        rst["yesterday_stock_img"] = json.loads(rst["yesterday_stock_img"]) if rst["yesterday_stock_img"] else []
        rst["is_markt"] = bool(rst["is_markt"]) 
    return rst


def get_group_income(match_id,match_group,stock_date=None):
    """
    """
    data = []
    if stock_date:
        today = stock_date
    else:
        today = datetime.datetime.now().strftime("%Y-%m-%d")
    player_ids = list(cm.Player.objects.filter(match_id=match_id,match_group=match_group).values_list("id",flat=True))
    for player_id in player_ids:
        today_record = cm.PlayerRecord.objects.filter(match_id=match_id,match_group=match_group,player_id=player_id,stock_date=today).order_by("-stock_date").first()
        if today_record:
            data.append(today_record.total_income)
    data = list(set(data))
    data = sorted(data,key=lambda x:x,reverse=True)
    return data

def get_list_info(cls,**kwargs):
    """
    """
    model_name = re.search(r'.*\.(\w+)ListView',str(cls.__class__)).groups()[0]
    model = getattr(cm,model_name)
    qset = model.objects.all()
    if kwargs.get("name"):
        qset = qset.filter(name__icontains=kwargs.get("name"))
    if model_name == "UserInfo":
        if kwargs.get("username"):
            qset = qset.filter(Q(username__icontains=kwargs.get("username"))|Q(usercode__icontains=kwargs.get("username")))
    if model_name == "Player":
        if kwargs.get("username"):
            qset = qset.filter(Q(username__icontains=kwargs.get("username"))|Q(usercode__icontains=kwargs.get("username")))
        if kwargs.get("match_id"):
            qset = qset.filter(match_id=kwargs.get("match_id"))
        if kwargs.get("groupId"):
            qset = qset.filter(match_group=kwargs.get("groupId"))
    if model_name == "MatchGroup":
        if kwargs.get("match_id"):
            qset = qset.filter(match_id=kwargs.get("match_id"))
    if model_name == "PlayerRecord":
        if kwargs.get("match_id"):
            qset = qset.filter(match_id=kwargs.get("match_id"))
        if kwargs.get("groupId"):
            qset = qset.filter(match_group=kwargs.get("groupId"))
        if kwargs.get("username"):
            qset = qset.filter(Q(username__icontains=kwargs.get("username"))|Q(usercode__icontains=kwargs.get("username")))
        if kwargs.get("stock_date"):
            qset = qset.filter(stock_date=kwargs.get("stock_date"))
        if kwargs.get("auto_complete"):
            if int(kwargs.get("auto_complete"))==1:
                qset = qset.filter(auto_complete__gte=kwargs.get("auto_complete"))
            else:
                qset = qset.filter(auto_complete=kwargs.get("auto_complete"))
    if model_name == "SignupOrder":
        if kwargs.get("match_id"):
            qset = qset.filter(match_id=kwargs.get("match_id"))
        if kwargs.get("username"):
            qset = qset.filter(user_name__icontains=kwargs.get("username"))
        if kwargs.get("signup_type"):
            qset = qset.filter(signup_type=kwargs.get("signup_type"))
        if kwargs.get("order_status") or kwargs.get("order_status")==0:
            qset = qset.filter(order_status=kwargs.get("order_status"))

    if model_name == "Article":
        if kwargs.get("type"):
            qset = qset.filter(type=kwargs.get("type"))
    if model_name == "Stock":
        if kwargs.get("username"):
            qset = qset.filter(name__icontains=kwargs.get("username"))

    if model_name == "PlayerRecord":
        data = list(qset.order_by("-total_income").values())
    else:
        data = list(qset.order_by("-id").values())
    page = int(kwargs.get("page",1))
    page_size = int(kwargs.get("page_size",20))
    if page and page_size:
        total,data = ccf.get_page_list(data,page,page_size)
        if model_name == "Player":
            for item in data:
                user = cm.UserInfo.objects.filter(id=item["user_id"]).first()
                if user:
                    match = cm.Match.objects.filter(id=item["match_id"]).first()
                    item["username"] = user.username
                    item["usercode"] = user.usercode
                    item["nickname"] = user.nickname
                    item["match_name"] = match.name if match else ""
                    item["match_group"] = int(item["match_group"])
                    item["match_group_name"] = cm.MatchGroup.objects.filter(id=int(item["match_group"])).first().name
                    item["openid"] = user.openid
                    item["player_type"] = user.player_type
                    item["phone"] = user.phone
                #cm.Player.objects.filter(id=item["id"]).update(username=user.username,usercode=user.usercode)
        if model_name == "PlayerRecord":
            for item in data:
                user = cm.UserInfo.objects.filter(id=item["user_id"]).first()

                item["username"] = user.username
                item["usercode"] = user.usercode

                today_stock = json.loads(item["today_stock"]) if item["today_stock"] else []
                today_stock = filter(lambda x:x["name"],today_stock if today_stock else [])
                today_stock_img = json.loads(item["today_stock_img"]) if item["today_stock_img"] else []
                item["today_stock"] = today_stock
                item["today_stock_img"] = today_stock_img


                yesterday_stock = json.loads(item["yesterday_stock"]) if item["yesterday_stock"] else []
                yesterday_stock = filter(lambda x:x["name"],yesterday_stock if yesterday_stock else [])

                item["yesterday_stock"] = yesterday_stock
                item["yesterday_stock_img"] = json.loads(item["yesterday_stock_img"]) if item["yesterday_stock_img"] else []

                item["today_income"] = "{}%".format(item["today_income"]*100)
                item["total_income"] = "{}%".format(item["total_income"]*100)
                item["is_markt"] = bool(item["is_markt"]) 
            if kwargs.get("groupId"):
                data = sorted(data,key=lambda x:x["group_rank"])
        if model_name == "Match":
            for item in data:
                groups = ",".join(list(cm.MatchGroup.objects.filter(match_id=item["id"]).values_list("name",flat=True)))
                item["join_count"] = cm.Player.objects.filter(match_id=item["id"]).count()
                item["out_count"] = cm.Player.objects.filter(match_id=item["id"],match_status=-1).count()
                item["groups"] = groups
        if model_name == "MatchGroup":
            for item in data:
                match = cm.Match.objects.filter(id=item["match_id"]).first()
                match_name = match.name if match else ""
                item["join_count"] = cm.Player.objects.filter(match_group=item["id"]).count()
                item["out_count"] = cm.Player.objects.filter(match_group=item["id"],match_status=-1).count()
                item["match_name"] = match_name
        if model_name == "SignupOrder":
            for item in data:
                item["match_group_name"] = cm.MatchGroup.objects.filter(id=item["match_group"]).first().name
        return (total,data)
    else:
        return len(data),data

    return rst


def download_records(request):
    """
    """
    kwargs = request.json
    header = [u"排名",u"选手",u"初始资产(万)",u"昨日资产(万)",u"今日资产",u"今日盈亏",u"总盈亏",u"昨日持股",u"今日持股"]
    
    qset = cm.PlayerRecord.objects.all()

    if kwargs.get("match_id"):
        qset = qset.filter(match_id=kwargs.get("match_id"))
    if kwargs.get("groupId"):
        qset = qset.filter(match_group=kwargs.get("groupId"))
    if kwargs.get("username"):
        qset = qset.filter(Q(username__icontains=kwargs.get("username"))|Q(usercode__icontains=kwargs.get("username")))
    if kwargs.get("stock_date"):
        qset = qset.filter(stock_date=kwargs.get("stock_date"))

    qdata = list(qset.order_by("-total_income").values())

    if kwargs.get("groupId"):
        qdata = sorted(qdata,key=lambda x:x["group_rank"])

    data = []
    for item in qdata:
        user = cm.UserInfo.objects.filter(id=item["user_id"]).first()
        item["username"] = user.username
        item["usercode"] = user.usercode
        item["today_income"] = "{}%".format(item["today_income"]*100)
        item["total_income"] = "{}%".format(item["total_income"]*100)

        today_stock = json.loads(item["today_stock"]) if item["today_stock"] else []
        today_stock = list(filter(lambda x:x["name"],today_stock if today_stock else []))
        today_stock = ",".join([x["name"]+str(x["fund"]) for x in today_stock]) if today_stock else ""

        yesterday_stock = json.loads(item["yesterday_stock"]) if item["yesterday_stock"] else []
        yesterday_stock = list(filter(lambda x:x["name"],yesterday_stock if yesterday_stock else []))
        yesterday_stock = ",".join([x["name"]+str(x["fund"]) for x in yesterday_stock]) if yesterday_stock else ""

        #空仓、开超市、请假判断
        if item["auto_complete"] > 0:
            today_stock = u"请假"
        else:
            if item["is_markt"] == 1:
                today_stock = u"开超市"
            else:
                if today_stock == "":
                    today_stock = u"空仓"
        #昨日
        if item["yesterday_auto_complete"] > 0:
            yesterday_stock = u"请假"
        else:
            if item["yesterday_is_markt"] == 1:
                yesterday_stock = u"开超市"
            else:
                if yesterday_stock == "":
                    yesterday_stock = u"空仓"

        data.append(
                [
                    item["group_rank"],
                    item["username"],
                    item["init_fund"],
                    item["yesterday_fund"],
                    item["today_fund"],
                    item["today_income"],
                    item["total_income"],
                    yesterday_stock,
                    today_stock
                ])
    xlsfile = os.path.join(settings.BASE_DIR,"demo.xls")
    exceltool = ExcelTool(xlsfile)
    xlsdata = exceltool.save_data(u"学员报名数据表",header,data)

    return xlsdata


def fast_save_player(**kwargs):
    """
    """
    username = kwargs.get("username")
    usercode = kwargs.get("usercode")
    if cm.UserInfo.objects.filter(username=username).exists():
        raise ce.TipException(u"用户名重复!")
    if cm.UserInfo.objects.filter(usercode=usercode).exists():
        raise ce.TipException(u"用户代码重复!")
    user = cm.UserInfo.objects.create(username=username,usercode=usercode)
    #新建选手
    user_id = user.id
    kwargs["user_id"] = user_id
    cm.Player.objects.create(**kwargs)


def update_player_latest(record):
    """更新选手最后一次数据
    """
    player_id=record["player_id"]
    match_id = record["match_id"]

    latest = cm.PlayerRecord.objects.filter(player_id=player_id,match_id=match_id).order_by("-stock_date").first()
    if latest:
        key = "PLAYER_LATEST_{}".format(player_id)
        ccc.cache.hset(key,"stock_date",latest.stock_date)
        ccc.cache.hset(key,"match_id",latest.match_id)
        ccc.cache.hset(key,"match_group",latest.match_group)
        #更新胜率
        qset = cm.PlayerRecord.objects.filter(match_id=latest.match_id,player_id=latest.player_id)
        win_rate = qset.filter(today_income__gte=0).count()/float(qset.count()) if qset else 0.0
        win_rate = round(win_rate,3)
        ccc.cache.hset(key,"win_rate",win_rate)
    badest = cm.PlayerRecord.objects.filter(player_id=player_id,match_id=match_id).order_by("-today_income").first()
    if badest:
        key = "PLAYER_LATEST_{}".format(player_id)
        ccc.cache.hset(key,"badest_income",latest.today_income)


def update_group_rank(stock_date=None,match_id=None,group_id=None):
    """
    """
    #ccc.cache.delete("cdata_*")
    if stock_date:
        stock_date = stock_date
    else:
        stock_date = datetime.datetime.now().strftime("%Y-%m-%d")
    #ccc.cache.delete("*_"+stock_date)
    #groups = cm.MatchGroup.objects.filter(match_id=match_id)
    groups = cm.MatchGroup.objects.filter(id=group_id)
    for gp in groups:
        match_id = gp.match_id
        match_group = gp.id
        delkey = "*_%s_%s_%s" % (match_id,match_group,stock_date)
        del_keys = ccc.cache.keys(delkey)
        #if del_keys:
        #    ccc.cache.delete(*del_keys)
        prset = cm.PlayerRecord.objects.filter(match_id=match_id,match_group=match_group,stock_date=stock_date).order_by("-total_income")
        if prset:
            records = prset.values()
            case_id = " case id "
            cases = []
            where = []
            for index,pr in enumerate(prset):
                case = "WHEN %s THEN %s" % (pr.id,index+1)
                cases.append(case)
                where.append(str(pr.id))
                #
                key = "%s_%s_%s_%s" % (pr.player_id,match_id,match_group,stock_date)
                record = records[index]
                record.update({"group_rank":index+1})
                ccc.pl.set(key,json.dumps(record,cls=ccc.CusJSONEncoder))
                #更新最后一次数据
                #update_player_latest(record)
            ccc.pl.execute()
            if cases and where:
                case = case_id + " ".join(cases)
                where = ",".join(where)
                sql = "update player_record set group_rank = %s ELSE 0 END where id in (%s)" % (case,where)
                cursor = connection.cursor()
                cursor.execute(sql)
                cursor.close()


def update_comment(**kwargs):
    """
    """
    id = kwargs.get("id")
    wanzhu_comment = kwargs.get("wanzhu_comment")
    cm.PlayerRecord.objects.filter(id=id).update(wanzhu_comment=wanzhu_comment)


def reset_initfund(**kwargs):
    """
    """
    match_id = kwargs.get("match_id")
    cm.Player.objects.filter(match_id=match_id).update(fund=1)
    #cm.Player.objects.filter(match_id=match_id,id=3011).update(fund=None)

def get_stock_comments_list(**kwargs):
    """
    """
    qset = cm.Comments.objects.filter(stock_id__isnull=False)
    if kwargs.get("name"):
        qset = qset.filter(stock_name__icontains=kwargs.get("name"))
    data = list(qset.values())
    for item in data:
        item["stock_name"] = cm.Stock.objects.filter(id=item["stock_id"]).first().name
    #分页
    page = int(kwargs.get("page",1))
    page_size = int(kwargs.get("page_size",20))
    if page and page_size:
        total,data = ccf.get_page_list(data,page,page_size)
    else:
        total = len(data)
    return total,data


def get_record_comments_list(**kwargs):
    """
    """
    qset = cm.Comments.objects.filter(record_id__isnull=False)
    if kwargs.get("user_name"):
        qset = qset.filter(user_name__icontains=kwargs.get("name"))
    data = list(qset.values())
    for item in data:
        item["record_info"] = cm.PlayerRecord.objects.filter(id=item["record_id"]).values().first()
    #分页
    page = int(kwargs.get("page",1))
    page_size = int(kwargs.get("page_size",20))
    if page and page_size:
        total,data = ccf.get_page_list(data,page,page_size)
    else:
        total = len(data)
    return total,data


def get_wanzhu_consult_list(**kwargs):
    """
    """
    qset = cm.WanzhuConsult.objects.filter(user_id__gt=0).order_by("-id")
    if kwargs.get("user_name"):
        qset = qset.filter(user_name__icontains=kwargs.get("name"))
    data = list(qset.values())
    for item in data:
        reply_list = list(cm.WanzhuConsult.objects.filter(pid=item["id"]).values())
        item["reply_list"] = reply_list
    #分页
    page = int(kwargs.get("page",1))
    page_size = int(kwargs.get("page_size",20))
    if page and page_size:
        total,data = ccf.get_page_list(data,page,page_size)
    else:
        total = len(data)
    return total,data

def reply_wanzhu_consult(**kwargs):
    """
    """
    pid = kwargs.get("pid")
    content = kwargs.get("reply_content")
    cm.WanzhuConsult.objects.create(
        pid = pid, 
        reply_content = content,
        user_id = 0,
        player_id = 0
    )
    cm.WanzhuConsult.objects.filter(id=pid).update(reply_status=1)

def update_player_type(**kwargs):
    """
    """
    player_id = kwargs.get("player_id")
    user_id = kwargs.get("user_id")
    player_type = kwargs.get("player_type")
    phone = kwargs.get("phone")

    cm.UserInfo.objects.filter(id=user_id).update(player_type=player_type,phone=phone)