add batch_recommend_user

libs/es.py

@@ -167,7 +167,7 @@ class ESPerform(object):
 
     @classmethod
     def get_search_results(cls, es_cli,sub_index_name,query_body,offset=0,size=10,
-                           auto_create_index=False,doc_type="_doc",aggregations_query=False,is_suggest_request=False):
+                           auto_create_index=False,doc_type="_doc",aggregations_query=False,is_suggest_request=False,batch_search=False):
         try:
             assert (es_cli is not None)
 
@@ -182,6 +182,8 @@ class ESPerform(object):
                     cls.put_index_mapping(es_cli,sub_index_name)
 
             logging.info("duan add,query_body:%s" % str(query_body).encode("utf-8"))
+
+            if not batch_search:
                 res = es_cli.search(index=official_index_name,doc_type=doc_type,body=query_body,from_=offset,size=size)
 
                 if is_suggest_request:
@@ -194,6 +196,11 @@ class ESPerform(object):
                     if aggregations_query:
                         result_dict["aggregations"] = res["aggregations"]
                     return result_dict
+            else:
+                res = es_cli.msearch(body='\n'.join(query_item for query_item in query_body), index=official_index_name, doc_type=doc_type)
+
+                logging.info("duan add,msearch res:%s" % str(res))
+                return res
         except:
             logging.error("catch exception,err_msg:%s" % traceback.format_exc())
             return {"total_count":0,"hits":[]}
\ No newline at end of file

search/utils/user.py

@@ -9,6 +9,42 @@ from libs.es import ESPerform
 
 
 class UserUtils(object):
+    @classmethod
+    def get_batch_attention_user_dict(cls,user_id_list,self_user_id):
+        """
+        :remark 批量用户 关注的 用户列表
+        :param user_id_list:
+        :param self_user_id:
+        :return:
+        """
+        try:
+            user_id_list.append(self_user_id)
+
+            q = dict()
+            q["query"] = {
+                "terms":{
+                    "user_id":user_id_list
+                }
+            }
+            q["_source"] = {
+                "include":["attention_user_id_list","user_id"]
+            }
+
+            result_dict = ESPerform.get_search_results(ESPerform.get_cli(), "user", q, offset=0, size=len(user_id_list))
+
+            attention_user_dict = dict()
+            for hit_item in result_dict["hits"]:
+                user_id = hit_item["_source"]["user_id"]
+                attention_user_id_list = [item["user_id"] for item in hit_item["_source"]["attention_user_id_list"]]
+
+                attention_user_dict[user_id] = attention_user_id_list
+
+            return attention_user_dict
+        except:
+            logging.error("catch exception,err_msg:%s" % traceback.format_exc())
+            return dict()
+
+
     @classmethod
     def get_attention_user_list(cls,user_id_list,self_user_id):
         """
@@ -131,3 +167,86 @@ class UserUtils(object):
         except:
             logging.error("catch exception,err_msg:%s" % traceback.format_exc())
             return []
+
+
+    @classmethod
+    def get_batch_recommend_user_dict(cls,need_filter_attention_user_id_list,attention_user_dict,self_user_id,offset,size):
+        """
+        :remark 获取批量推荐用户
+        :param need_filter_attention_user_id_list:
+        :param attention_user_dict:
+        :param self_user_id:
+        :param offset:
+        :param size:
+        :return:
+        """
+        try:
+            batch_query_list = list()
+            for interesting_user_id in attention_user_dict:
+                if interesting_user_id != self_user_id:
+                    filter_user_id_list = need_filter_attention_user_id_list
+                    filter_user_id_list.append(interesting_user_id)
+
+                    q = dict()
+                    q["from"] = offset
+                    q["size"] = size
+                    q["query"] = dict()
+
+                    functions_list = [
+                        {
+                            "gauss": {
+                                "latest_topic_time_val": {
+                                    "origin": int(time.time()),
+                                    "scale": "600",
+                                    "decay": 0.1
+                                }
+                            }
+                        }
+                    ]
+
+                    if len(attention_user_dict[interesting_user_id]) > 0:
+                        functions_list.append(
+                            {
+                                "filter":{
+                                    "bool":{
+                                        "should":{"terms":{"user_id":attention_user_dict[interesting_user_id]}}
+                                    }
+                                },
+                                "weight":10
+                            }
+                        )
+
+                    query_function_score = {
+                        "query": {
+                            "bool": {
+                                "must": [
+                                    {"term": {"is_recommend": True}},
+                                    {"term": {"is_online": True}},
+                                    {"term": {"is_deleted": False}},
+                                    {"term": {"is_shadow": False}}
+                                ],
+                                "must_not":{
+                                    "terms":{
+                                        "user_id":filter_user_id_list
+                                    }
+                                }
+                            }
+                        },
+                        "score_mode": "sum",
+                        "boost_mode": "sum",
+                        "functions": functions_list
+                    }
+                    q["query"]["function_score"] = query_function_score
+                    q["_source"] = {
+                        "include":["user_id"]
+                    }
+
+                    batch_query_list.append(q)
+
+
+            result_dict = ESPerform.get_search_results(ESPerform.get_cli(), sub_index_name="user", query_body=batch_query_list,
+                                                       batch_search=False)
+            return result_dict
+        except:
+            logging.error("catch exception,err_msg:%s" % traceback.format_exc())
+            return dict()

search/views/user.py

@@ -35,6 +35,39 @@ def recommend_user(self_user_id,interesting_user_id,offset=0,size=10):
 
         recommend_user_list = UserUtils.get_recommend_user_list(self_attention_user_id_list,recursion_attention_user_id_list,offset,size)
 
+        return recommend_user_list
+    except:
+        logging.error("catch exception,err_msg:%s" % traceback.format_exc())
+        return {"recommend_user_ids":[]}
+
+@bind("physical/search/batch_recommend_user")
+def batch_recommend_user(self_user_id,interesting_user_id_list,offset=0,size=10):
+    """
+    :remark 点关注推荐用户 - 批量接口
+    :param self_user_id:
+    :param interesting_user_id:
+    :param offset:
+    :param size:
+    :return:
+    """
+    try:
+        if not isinstance(self_user_id,int):
+            self_user_id = -1
+
+        #获取关注用户列表
+        attention_user_dict = UserUtils.get_batch_attention_user_dict(interesting_user_id_list,self_user_id)
+
+
+        #去除自身及感兴趣的用户ID
+        need_filter_attention_user_id_list = attention_user_dict[self_user_id] if self_user_id in attention_user_dict else list()
+        need_filter_attention_user_id_list.append(self_user_id)
+
+
+        recommend_user_list = UserUtils.get_batch_recommend_user_dict(need_filter_attention_user_id_list=need_filter_attention_user_id_list,attention_user_dict=attention_user_dict,
+                                                                      self_user_id=self_user_id,offset=offset,size=size)
+
+
+
         return recommend_user_list
     except:
         logging.error("catch exception,err_msg:%s" % traceback.format_exc())