def jenkins_info(request):
    """
    :author: yechengzhou
    :param request:
    :return:
    """
    if request.method != "GET":
        return  public.fail_result_http(u'该接口只支持GET')
    if 'name' in request.REQUEST:
        if 'job' in request.REQUEST:
            logging.debug('')
            job = utils.JenkinsInfo(name=request.REQUEST['name'], job=request.REQUEST['job'])
            if job.get_status():
                return public.success_result_http(json.dumps(job.get_ret()))
            else:
                return public.fail_result_http(u'get jenkins info failed')
        else:
            view = utils.JenkinsInfo(name=request.REQUEST['name'])
            if view.get_status():
                return public.success_result_http(json.dumps(view.get_ret()))
            else:
                return public.fail_result_http(u'get jenkins info failed')

    else:
        return public.fail_result_http(u"wrong argument")

def get_seal_version(request):
    module = request.GET.get('module')
    if module == 'biz':
        return public.success_result_http(data_utils.get_seal_or_newlab_version('biz'))
    elif module == "shanghaife":
        return public.success_result_http(data_utils.get_seal_or_newlab_version('shanghaife'))
    else:
        return public.success_result_http({'biz': data_utils.get_seal_or_newlab_version('biz'), "shanghaife": data_utils.get_seal_or_newlab_version('biz')})

def set_algo_view(request):
    if request.method != "POST":
        return public.fail_result_http(u"POST only")

    data = json.loads(request.body)
    x = data.get("x")
    y = data.get("y")
    module = data.get("module_id")
    scene = data.get("scene_id")
    resource_name = data.get("resource")
    if len(utils.get_resource_by_name(resource_name)):
        resource_id = utils.get_resource_by_name(resource_name).get('id')
    else:
        print 'get resource id failed'

    record_id = data.get("id")
    if not (x and y and module and scene):
        return public.fail_result_http(u"module, scence, X, Y should not be NONE")

    ret = algo.set_algo_info(module, scene , resource_name, x, y)

    # save formula info
    tmp = {}
    tmp['a'] = ret.get('a')
    tmp['b'] = ret.get('b')

    this_formula = {}
    this_formula['resource_id'] = resource_id if resource_id else 0
    this_formula['record_id'] = record_id
    this_formula['formula'] = json.dumps(tmp)
    utils.save_formula(this_formula)

    if type(ret) == type(""):
        return public.fail_result_http(ret)
    return public.success_result_http(ret)

def get_branch_svn_log(request):
    """
    :author: yechengzhou
    :param request: request should contains branch name and module name
    :return: json format branch svn log
    """
    if request.method != "GET":
        return public.fail_result_http(u"该接口只支持GET")
    else:

        module = request.GET.get('module')
        branch = request.GET.get('branch')
        type = request.GET.get('type') # 0 -- one day  1 -- last 10

        if not (module and branch):
            return public.fail_result_http(u"参数错误")

        else:
            if type == '0' or type == None:
                if branch != "trunk":
                    start = branch.split('_')[-2]
                    start_time = public.str2datetime(start, "%Y%m%d")
                    end_time = start_time + datetime.timedelta(days=1)
                    end = public.datetime2str(end_time, "%Y%m%d")
                    ret = utils.get_branch_svn_log(module,branch, start, end)
                else:
                    ret = utils.get_branch_svn_log(module,branch)


            elif type == '1':
                ret = utils.get_branch_svn_log(module,branch )


            return public.success_result_http(ret)

def static_dashboard_view(request):
    env = request.GET.get("env")
    if env.upper() == public.ENV_MOB:
        ret = utils.static_mob()
    else:
        ret = utils.static_newlab()
    return public.success_result_http(ret)

def filter_api_view(request):
    q = request.GET.get("q")
    data = utils.filter_api(q)
    if data:
        return public.success_result_http(data)
    else:
        return public.fail_result_http(data)

def update_api_mob_version_view(request):
    if request.method == "POST":
        data = json.loads(request.body)
        ret = utils.update_api_mob_version(data)
        return public.success_result_http(ret)
    else:
        return public.fail_result_http("Only Post!")

def copy_api_view(request):
    data = {}
    pk = request.GET.get("id")
    user = request.session.get("django_mail")
    flag = request.GET.get("flag")
    ret = utils.copy_api(pk, user, flag)
    return public.success_result_http(ret)

def get_sealed_or_newlab_version(request):
    # 获取封板号 封板号没有就返回newlab版本
    if request.method != "GET":
        return public.fail_result_http(u"Only support GET")
    else:
        ret = utils.get_seal_or_newlab_version(request.REQUEST.get("module"))
        return public.success_result_http(ret)

def get_build_status(request):
    if request.method != "GET":
        return public.fail_result_http(u"do not accept get method")
    else:
        job_name = request.REQUEST.get('name')
        view = request.REQUEST.get('view')


        # build = request.REQUEST.get('build')

        # 目前只有newlab
        if job_name and job_name != 'undefined' and not job_name.startswith("newlabs"):
            job_name = "newlabs_" + job_name
        else:
            return public.fail_result_http('get job name failed')

        view = "agile"
        JB = utils.JenkinsInfo(view, job_name)
        build = JB.get_ret()['builds'][0]['number']

        JI = utils.JenkinsInfo(view, job_name, str(build))
        if JI.get_status():
            if_building = JI.get_ret()['building']
            if JI.get_ret()['result']:
                job_status = JI.get_ret()['result'].lower()
            else:
                job_status = 'fail'
            return public.success_result_http({"status":job_status, 'building': if_building})
        else:
            logging.error("Get Job Info Failed:" + str(request))
            return public.fail_result_http('get job info failed')

def save_single_api_record(request):
    id = utils.save_api_record(json.loads(request.body))
    public_info = utils.get_public(request)
    if public_info.get('auth').get('write') != 1:
        return public.fail_result_http('have no write right')
    else:
        return public.success_result_http({'id': id})

def bind_job_view(request):
    if request.method != "POST":
        return public.fail_result_http(u"Only support POST!")
    else:
        data = json.loads(request.body)
        ret = utils.bind_job(data)
        return public.success_result_http(ret)

def interface_show_api_view(request):
    data = data_utils.get_api(request.GET.get("id"))
    urlHost = data_utils.get_url_host_list()
    url_id = data.get("url")
    for url in urlHost:
        if url_id == url.get("id"):
            data["url"] = url.get("host")
    return public.success_result_http(data)

def bind_api_tag_view(request):
    if request.method == "POST":
        data = json.loads(request.body)
        data["user"] = public.get_user_mail(request)
        utils.bind_api_tag(data)
        return public.success_result_http()
    else:
        return public.fail_result_http("Only Post!")

def set_auth_view(request):
    if request.method != "POST":
        return public.fail_result_http(u"Only support POST!")
    else:
        ret = utils.set_auth(request)
        if ret:
            return public.fail_result_http(ret)
        return public.success_result_http(ret)

def save_svn_history_view(request):
    logger.debug(request)

    if request.method == "POST":
        data = json.loads(request.body)
        utils.save_svn_history(data)
    else:
        return public.fail_result_http(u"该接口只支持POST数据")
    return public.success_result_http()

def rm_group_view(request):
    if request.method != "POST":
        return public.fail_result_http(u"Only support POST!")
    else:
        body = json.loads(request.body)
        ret = utils.rm_group(body.get("id"))
        if ret != True:
            return public.fail_result_http(ret)
        return public.success_result_http(ret)

def edit_url_host_view(request):
    if request.method == "POST":
        ret = data_utils.edit_host(request)
        return public.success_result_http(ret)
    else:
        data = {}
        id = request.GET.get("id")
        data["host"] = data_utils.get_url_host_dict(id)
        return render(request, 'edit_host.html', {"data": data})

def save_data_structure_view(request):
    if request.method == "POST":
        ret = data_utils.save_data_structure(request)
        return public.success_result_http(ret)
    else:
        data = {}
        data["structure"] = data_utils.get_data_structure()
        data["current"] = data_utils.get_structure_dict(request.GET.get("id"))
        return render(request, 'edit_structure.html', {"data": data})

def set_next_job_view(request):
    if request.method == "POST":
        data = json.loads(request.body)
        ret = utils.set_next_job(data)
        if ret:
            return public.fail_result_http(ret)
        return public.success_result_http()
    else:
        return public.fail_result_http("POST Only!")