def search_task(task_name, submit_date, state, status):
    results = []
    query = []
    condition_num = 0
    if task_name:
        task_name_list = task_name.split(' ')
        for item in task_name_list:
            #print 'item:', item
            query.append({'wildcard':{'task_name': '*' + item + '*'}})
            condition_num += 1
    if submit_date:
        query.append({'match':{'submit_date': submit_date}})
        condition_num += 1
    if state:
        state_list = state.split(' ')
        for item in state_list:
            query.append({'wildcard':{'state': '*' + item + '*'}})
            condition_num += 1
    if status:
        query.append({'match':{'status': status}})
        condition_num += 1
    if condition_num > 0:
        try:
            source = es.search(
                    index = 'group_result',
                    doc_type = 'group',
                    body = {
                        'query':{
                            'bool':{
                                'must':query
                                }
                            },
                        'sort': [{'count':{'order': 'desc'}}],
                        'size': 10000
                        }
                    )
        except Exception as e:
            raise e
    else:
        source = es.search(
                index = 'group_result',
                doc_type = 'group',
                body = {
                    'query':{'match_all':{}
                        },
                    'sort': [{'count': {'order': 'desc'}}],
                    'size': 10000
                    }
                )

    try:
        task_dict_list = source['hits']['hits']
    except:
        return None
    result = []
    print 'len task_dict_list:', len(task_dict_list)
    for task_dict in task_dict_list:
        result.append([task_dict['_source']['task_name'], task_dict['_source']['submit_date'], task_dict['_source']['count'], task_dict['_source']['state'], task_dict['_source']['status']])
    
    return result

def conclusion_on_influence(uid):
    # test
    index_name = copy_portrait_index_name
    index_type = copy_portrait_index_type
    total_number = es.count(index=copy_portrait_index_name, doc_type=copy_portrait_index_type)["count"]

    try:
        influ_result = es.get(index=index_name, doc_type=index_type, id=uid)["_source"]
    except:
        influ_result = {}
        result = [0, 0, 0, 0, 0, 0, total_number]  # aver_activeness, sorted, aver_influence, sorted
        return result

    aver_activeness = influ_result.get("aver_activeness", 0)
    aver_influence = influ_result.get("aver_influence", 0)
    aver_importance = influ_result.get("aver_importance", 0)
    influence_query_body = {"query": {"match_all": {}}, "sort": {"aver_influence": {"order": "desc"}}, "size": 1}
    top_influence = es.search(
        index=copy_portrait_index_name, doc_type=copy_portrait_index_type, body=influence_query_body
    )["hits"]["hits"][0]["sort"][0]

    importance_query_body = {"query": {"match_all": {}}, "sort": {"aver_importance": {"order": "desc"}}, "size": 1}
    top_importance = es.search(
        index=copy_portrait_index_name, doc_type=copy_portrait_index_type, body=importance_query_body
    )["hits"]["hits"][0]["sort"][0]

    activeness_query_body = {"query": {"match_all": {}}, "sort": {"aver_activeness": {"order": "desc"}}, "size": 1}
    top_activeness = es.search(
        index=copy_portrait_index_name, doc_type=copy_portrait_index_type, body=activeness_query_body
    )["hits"]["hits"][0]["sort"][0]

    influence_query_body = {"query": {"filtered": {"filter": {"range": {"aver_influence": {"gt": aver_influence}}}}}}

    activeness_query_body = {"query": {"filtered": {"filter": {"range": {"aver_activeness": {"gt": aver_activeness}}}}}}

    importance_query_body = {"query": {"filtered": {"filter": {"range": {"aver_importance": {"gt": aver_importance}}}}}}

    influence_count = es.count(
        index=copy_portrait_index_name, doc_type=copy_portrait_index_type, body=influence_query_body
    )["count"]
    activeness_count = es.count(
        index=copy_portrait_index_name, doc_type=copy_portrait_index_type, body=activeness_query_body
    )["count"]
    importance_count = es.count(
        index=copy_portrait_index_name, doc_type=copy_portrait_index_type, body=importance_query_body
    )["count"]

    result = [
        int(aver_activeness * 100.0 / top_activeness),
        activeness_count,
        int(aver_influence * 100.0 / top_influence),
        influence_count,
        int(aver_importance * 100.0 / top_importance),
        importance_count,
        total_number,
    ]
    return result

def show_social_sensing_task(user):
    query_body = {
        "query":{
            "filtered":{
                "filter":{
                    "bool":{
                        "must":[
                            {"term": {"finish": "1"}},
                            {"term": {"create_by": user}}
                        ]
                    }
                }
            }
        },
        "sort": {"create_at": {"order": "desc"}},
        "size": 10000
    }

    results = []
    search_results = es.search(index=index_manage_social_task, doc_type=task_doc_type, body=query_body)['hits']['hits']
    if search_results:
        for item in search_results:
            results.append(item['_source']['task_name'])

    return results

def delete_attribute(attribute_name):
    status = False
    try:
        result = es.get(index=attribute_index_name, doc_type=attribute_index_type, id=attribute_name)['_source']
    except:
        return status
    attribute_value = json.loads(result['value'])
    es.delete(index=attribute_index_name, doc_type=attribute_index_type, id=attribute_name)
    # delete attribute in user_portrait
    query = []
    for value in attribute_value:
        query.append({'match':{attribute_name: value}})
    try:
        attribute_user_result = es.search(index=user_index_name, doc_type=user_index_type, \
                                         body={'query':{'bool':{'must':query}}})['hits']['hits']
    except:
        attribute_user_result = []
    if attribute_user_result==[]:
        status = True
        return status
    bulk_action = []
    for user_dict in attribute_user_result:
        try:
            user_item = user_dict['_source']
        except:
            next
        user_item.pop(attribute)
        user = user_item['uid']
        action = {'index':{'_id':str(user)}}
        bulk_action.extend([action, user_item])
    es.bulk(bulk_action, index=user_index_name, doc_type=index_type)
    status = True
    return status

def get_social_domain(uid_set):
    results = {}
    query_body = {
        'query':{
            'filtered':{
                'filter':{
                    'terms':{
                        'uid': list(uid_set)
                        }
                    }
                }
            },
        'aggs':{
            'all_domain':{
                'terms':{'field': 'domain'}
                }
            }
        }
    search_result = es_user_portrait.search(index=portrait_index_name, doc_type=portrait_index_type, \
            body=query_body)['aggregations']['all_domain']['buckets']
    print 'search_result:', search_result
    for item in search_result:
        results[item['key']] = item['doc_count']

    return results

def get_attribute_name():
    attribute_name_list = []
    try:
        attribute_result = es.search(index=attribute_index_name, doc_type=attribute_index_type, \
                                     body={'query':{'match_all':{}}})['hits']['hits']
    except Exception, e:
        raise e

def get_top_influence(key):
    query_body = {"query": {"match_all": {}}, "sort": {key: {"order": "desc"}}, "size": 1}

    search_result = es.search(index=portrait_index_name, doc_type=portrait_index_type, body=query_body)["hits"]["hits"]
    if search_result:
        result = search_result[0]["_source"][key]

    return result

def search_attribute(query_body, condition_num):
    result = []
    if condition_num==0:
        try:
            result = es.search(index=attribute_index_name, doc_type=attribute_index_type, \
                               body={'query':{'match_all':{}}})['hits']['hits']
        except Exception, e:
            raise e

def search_attribute(query_body, condition_num):
    item_list = []
    default_size = 100000
    if condition_num==0:
        try:
            result = es.search(index=attribute_index_name, doc_type=attribute_index_type, \
                    body={'query':{'match_all':{}}, 'size':default_size})['hits']['hits']
        except Exception, e:
            raise e

def get_evaluate_max():
    max_result = {}
    evaluate_index = ["influence", "activeness", "importance"]
    for evaluate in evaluate_index:
        query_body = {"query": {"match_all": {}}, "size": 1, "sort": [{evaluate: {"order": "desc"}}]}
        try:
            result = es.search(index=portrait_index_name, doc_type=portrait_index_type, body=query_body)["hits"]["hits"]
        except Exception, e:
            raise e
        max_evaluate = result[0]["_source"][evaluate]
        max_result[evaluate] = max_evaluate

def search_portrait(condition_num, query, sort, size):
    user_result = []
    index_name = 'user_portrait'
    index_type = 'user'
    if condition_num > 0:
        try:
            #print query
            result = es_user_portrait.search(index=index_name, doc_type=index_type, \
                    body={'query':{'bool':{'must':query}}, 'sort':sort, 'size':size})['hits']['hits']
            #print 'result:', result
        except Exception,e:
            raise e

def ajax_show_task():
    # show all working task
    # "0": unfinish working task
    # "1": finish working task
    status = request.args.get("finish", "01")
    user = request.args.get('user', 'admin')
    length = len(status)
    query_body = {
        "query":{
            "filtered":{
                "filter":{
                    "bool":{
                        "must":[
                            {"term":{"create_by": user}}
                        ]
                    }
                }
            }
        },
        "sort": {"create_at": {"order": "desc"}},
        "size": 10000
    }
    #if length == 2:
    #    category_list = [status[0], status[1]]
    #    query_body['query']['filtered']['filter']["bool"]["must"].append({"term":{"finish": category_list}})
    if length == 1:
        query_body['query']['filtered']['filter']['bool']['must'].append({"term":{"finish": status}})
    #else:
    #    print "error"

    try:
        search_results = es.search(index=index_manage_sensing_task, doc_type=task_doc_type, body=query_body)['hits']['hits']
    except:
        search_results = []
    results = []
    if search_results:
        for item in search_results:
            item = item['_source']
            history_status = json.loads(item['history_status'])
            if history_status:
                temp_list = []
                temp_list.append(history_status[-1])
                for iter_item in history_status[:-1]:
                    if int(iter_item[-1]) != 0:
                        temp_list.append(iter_item)
                sorted_list = sorted(temp_list, key=lambda x:x[0], reverse=True)
                item['history_status'] = sorted_list
            else:
                item['history_status'] = history_status
            results.append(item)
    print results
    return json.dumps(results)

def save_detect_single_task(input_dict):
    results = {}
    #step1: identify the seed user is in user_portrait
    seed_user = input_dict['query_condition']['seed_user']
    query = []
    query_list = []
    for user_item in seed_user:
        query_list.append({'term':{user_item: seed_user[user_item]}})
    query.append({'bool':{'should': query_list}})
    try:
        seed_user_result = es_user_portrait.search(index=portrait_index_name, doc_type=portrait_index_type, \
                            body={'query':{'bool':{'must':query}}, 'size':1})['hits']['hits']
    except Exception, e:
        raise e

def get_top_influence(key="influence"):
    query_body = {
        "query":{
            "match_all": {}
        },
        "sort":{key:{"order":"desc"}},
        "size": 1
    }

    search_result = es.search(index=portrait_index_name, doc_type=portrait_index_type, body=query_body)['hits']['hits']
    if search_result:
        result = search_result[0]['_source']['influence']
    else:
        result = 2000

    return result

def ajax_get_group_list():
    user = request.args.get('user', '')
    # get all group list from group manage
    results = [] #
    query_body = {
        "query":{
            "filtered":{
                "filter":{
                    "bool":{
                        "should":[
                            {"term": {"task_type": "analysis"}},
                            {"bool":{
                                "must":[
                                    {"term": {"task_type": "detect"}},
                                    {"term": {"detect_process":100}}
                                ]
                            }}
                        ],
                        "must":{"term": {"submit_user": user}}
                    }
                }
            }
        },
        "sort": {"submit_date": {"order": "desc"}},
        "size": 10000
    }

    search_results = es.search(index=index_group_manage, doc_type=doc_type_group, body=query_body, timeout=600)['hits']['hits']
    if search_results:
        for item in search_results:
            item = item['_source']
            temp = []
            temp.append(item['task_name'])
            temp.append(item['submit_user'])
            temp.append(item['submit_date'])
            temp.append(0)
            temp.append(item.get('state', ""))
            try:
                temp.append(json.loads(item['uid_list']))
                count = len(json.loads(item['uid_list']))
                temp[3] = count
            except:
                temp.append(item['uid_list'])
                temp[3] = len(item['uid_list'])
            results.append(temp)

    return json.dumps(results)

def get_evaluate_max():
    max_result = {}
    evaluate_index = ['influence', 'activeness', 'importance']
    for evaluate in evaluate_index:
        query_body = {
            'query':{
                'match_all':{}
                    },
                'size':1,
                'sort':[{evaluate: {'order': 'desc'}}]
                }
        try:
            result = es.search(index=portrait_index_name, doc_type=portrait_index_type, body=query_body)['hits']['hits']
        except Exception, e:
            raise e
        max_evaluate = result[0]['_source'][evaluate]
        max_result[evaluate] = max_evaluate

def ajax_show_task():
    # show all working task
    # "0": unfinish working task
    # "1": finish working task
    status = request.args.get("finish", "01")
    length = len(status)
    query_body = {
        "query":{
            "filtered":{
                "filter":{
                }
            }
        },
        "sort": {"create_at": {"order": "desc"}},
        "size": 10000
    }
    if length == 2:
        category_list = [status[0], status[1]]
        query_body['query']['filtered']['filter']['terms'] = {"finish": category_list}
    elif length == 1:
        query_body['query']['filtered']['filter']['term'] = {"finish": status}
    else:
        print "error"

    search_results = es.search(index=index_manage_sensing_task, doc_type=task_doc_type, body=query_body)['hits']['hits']

    results = []
    if search_results:
        for item in search_results:
            item = item['_source']
            history_status = json.loads(item['history_status'])
            keywords = json.loads(item['keywords'])
            item['keywords'] = keywords
            if history_status:
                temp_list = []
                temp_list.append(history_status[-1])
                for iter_item in history_status[:-1]:
                    if int(iter_item[-1]) != 0:
                        temp_list.append(iter_item)
                sorted_list = sorted(temp_list, key=lambda x:x[0], reverse=True)
                item['history_status'] = sorted_list
            else:
                item['history_status'] = history_status
            results.append(item)

    return json.dumps(results)

def filter_in_uname(input_dict):
    input_uname = input_dict.keys()
    all_count = len(input_uname)
    iter_count = 0
    in_portrait_result = []
    while iter_count < all_count:
        iter_user_list = input_uname[iter_count: iter_count+FILTER_ITER_COUNT]
        try:
            portrait_result = es_user_portrait.search(index=portrait_index_name, doc_type=portrait_index_type,\
                    body={'query':{'terms': {'uname': iter_user_list}}}, _source=False, fields=['photo_url', 'uname'])['hits']['hits']
        except:
            portrait_result = []
        if portrait_result:
            iter_in_portrait = [[item['_id'], item['uname'][0], item['photo_url'][0], input_uname[item['uname']]] for item in portrait_result]
        in_portrait_result.extend(iter_in_portrait)
        iter_count += FILTER_ITER_COUNT
    return in_portrait_result

def get_top_all_influence(key, ts):
    query_body = {
        "query":{
            "match_all": {}
        },
        "sort":{key:{"order":"desc"}},
        "size": 1
    }

    index_name = "bci_" + ts2datetime(ts-DAY).replace('-','')
    exist_es = es.indices.exists(index=index_name)
    if exist_es:
         search_result = es.search(index=index_name, doc_type="bci", body=query_body)['hits']['hits']
    else:
         search_result = {}
    if search_result:
        result = search_result[0]['_source'][key]
    else:
        result = 2000
    return result

def get_evaluate_max():
    max_result = {}
    evaluate_index = ['influence', 'activeness', 'importance', 'sensitive']
    for evaluate in evaluate_index:
        query_body = {
            'query':{
                'match_all':{}
                },
            'size': 1,
            'sort':[{evaluate: {'order': 'desc'}}]
            }
        try:
            result = es_user_portrait.search(index=portrait_index_name, doc_type=portrait_index_type,\
                    body=query_body)['hits']['hits']
        except:
            result = {}
        try:
            max_evaluate = result[0]['_source'][evaluate]
        except:
            max_evaluate = MAX_VALUE
        max_result[evaluate] = max_evaluate
    
    return max_result