提交改动

all_backend_api/answer_request.yaml

@@ -10,24 +10,24 @@ detail:
   # isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
 
 #回答详情页——点赞
-vote:
-  method: post
-  url: /api/answer/vote
-  params:
-    current_city_id: ${current_city_id}
-  data:
-    answer_id: ${answer_id}
-  json: {}
-  isLogin: 1
+#vote:
+#  method: post
+#  url: /api/answer/vote
+#  params:
+#    current_city_id: ${current_city_id}
+#  data:
+#    answer_id: ${answer_id}
+#  json: {}
+#  isLogin: 1
 
 #回答详情页——取消点赞
-cancel_vote:
-  method: post
-  url: /api/answer/cancel_vote
-  params:
-    current_city_id: ${current_city_id}
-  data:
-    answer_id: ${answer_id}
-  json: {}
-  isLogin: 1
+#cancel_vote:
+#  method: post
+#  url: /api/answer/cancel_vote
+#  params:
+#    current_city_id: ${current_city_id}
+#  data:
+#    answer_id: ${answer_id}
+#  json: {}
+#  isLogin: 1
 

all_backend_api/common_request.py

@@ -5,23 +5,31 @@ from in_common.base_request import BaseRequest
 class common_request(BaseRequest):
     def __init__(self):
         self.data = self.api_load(path_setting.DIARY_COMMON_CONFIG)
+        print("00000000000000",self.data)
 
     # 日记贴评论列表--一级评论列表
-    def diary_common_reply(self, id, type):
+    def diary_common_reply(self, id, type, data_type, offset ,start_num):
         self.params["id"] = id
         self.params["type"] = type
+        self.params["data_type"] = data_type
+        self.params["offset"] = offset
+        self.params["start_num"] = start_num
+
         return self.api_send(self.data["reply_detail"])
 
     # 日记贴评论列表--二级评论
-    def topic_sub_common(self, id, type, reply_id):
+    def topic_sub_common(self, id, type, reply_id,offset,start_num):
         self.params["id"] = id
         self.params["type"] = type
         self.params["reply_id"] = reply_id
+        self.params["offset"] = offset
+        self.params["start_num"] = start_num
         return self.api_send(self.data["sub_common"])
 
 
 
-
+if __name__ == '__main__':
+    common_request().diary_common_reply(21250007,2)
 
 
 

all_backend_api/common_request.yaml

@@ -5,6 +5,9 @@ reply_detail:
   params:
     id: ${id}
     type: ${type}
+    offset: ${offset}
+    start_num: ${start_num}
+    data_type: ${data_type}
   data: {}
   json: {}
   isLogin: 0  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
@@ -18,6 +21,8 @@ sub_common:
     id: ${id}
     type: ${type}
     reply_id: ${reply_id}
+    start_num: ${start_num}
+    offset: ${offset}
   data: {}
   json: {}
   isLogin: 0  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段

all_backend_api/conversation_request.py

@@ -6,12 +6,12 @@ class conversation_request(BaseRequest):
     def __init__(self):
         self.messageread = self.api_load(path_setting.MESSAGE_READ_CONFIG)
 
-    def message_read(self,current_city_id,release,message_ids):
-        self.params["current_city_id"] = current_city_id
-        self.params["release"] = release
-        #self.params["uqid"] = uqid
-        self.params["message_ids"] = message_ids
-        return self.api_send(self.messageread["message_read"])
+    # def message_read(self,current_city_id,release,message_ids):
+    #     self.params["current_city_id"] = current_city_id
+    #     self.params["release"] = release
+    #     #self.params["uqid"] = uqid
+    #     self.params["message_ids"] = message_ids
+    #     return self.api_send(self.messageread["message_read"])
 
     def detail_messageid(self, os_version, last_msg_id, offset_msg_id):
         self.params["os_version"] = os_version

all_backend_api/conversation_request.yaml

-message_read:
-  method: post
-  url: /api/conversation/message/read
-  params:
-    current_city_id: ${current_city_id}
-    release: ${release}
-    #uqid: ${uqid}
-  data:
-    message_ids: ${message_ids}
-
-  json: {}
-  isLogin: 1 #需要登录的接口
+#message_read:
+#  method: post
+#  url: /api/conversation/message/read
+#  params:
+#    current_city_id: ${current_city_id}
+#    release: ${release}
+#    #uqid: ${uqid}
+#  data:
+#    message_ids: ${message_ids}
+#
+#  json: {}
+#  isLogin: 1 #需要登录的接口
 
 detail_messageid:
   method: get

all_backend_api/diary_request.py

@@ -15,13 +15,10 @@ class diary_request(BaseRequest):
         return self.api_send(self.data["cancelfavor"])
 
     # 更新日记本
-    def diary_operation(self, diary_id, title, operation_timestamp, doctor_name, hospital_name):
-        self.params["diary_id"] = diary_id
-        self.params["title"] = title
-        self.params["operation_timestamp"] = operation_timestamp
-        self.params["doctor_name"] = doctor_name
-        self.params["hospital_name"] = hospital_name
-        return self.api_send(self.data["operation"])
+    def diary_operation(self, start_num, count):
+        self.params["start_num"] = start_num
+        self.params["count"] = count
+        return self.api_send(self.data["diary_operation"])
 
     # 添加信息--待争议
     def diary_additional_info(self):
@@ -48,3 +45,6 @@ class diary_request(BaseRequest):
         return self.api_send(self.data["update"])
 
 
+    def diary_pre_create_topic(self,diary_id):
+        self.params["diary_id"] = diary_id
+        return self.api_send(self.data["diary_pre_create_topic"])

all_backend_api/diary_request.yaml

 #日记本收藏
-isfavor:
-  method: post
-  url: /api/diary/favor/17586195
-  params:
-  data: {}
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+#isfavor:
+#  method: post
+#  url: /api/diary/favor/17586195
+#  params:
+#  data: {}
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
 
 #日记本取消收藏
-cancelfavor:
-  method: delete
-  url: /api/diary/favor/17586195
-  params:
-  data: {}
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+#cancelfavor:
+#  method: delete
+#  url: /api/diary/favor/17586195
+#  params:
+#  data: {}
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
 #
 
 #日记本修改信息
-operation:
-  method: post
-  url: /api/diary/additional_info/v2
-  params:
-  data:
-    diary_id: ${diary_id}
-    title: ${title}
-    operation_timestamp: ${operation_timestamp}
-    doctor_name: ${doctor_name}
-    hospital_name: ${hospital_name}
-
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
-
-
-#查看日记修改信息页面
-additional_info:
-  method: get
-  url: /api/diary/operation/17586198/
-  params:
-  data: {}
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+#operation:
+#  method: post
+#  url: /api/diary/additional_info/v2
+#  params:
+#  data:
+#    diary_id: ${diary_id}
+#    title: ${title}
+#    operation_timestamp: ${operation_timestamp}
+#    doctor_name: ${doctor_name}
+#    hospital_name: ${hospital_name}
+#
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
 
 
 #详情页内容
@@ -69,11 +59,31 @@ diary_service:
 
 
 #更新日记本的修改信息
-update:
-  method: post
-  url: /api/diary/update_v2/17586198
+#update:
+#  method: post
+#  url: /api/diary/update_v2/17586198
+#  params:
+#  data:
+#    topic_list: ${topic_list}
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+diary_operation:
+  method: get
+  url: /api/diary/operation/17878325
   params:
-  data:
-    topic_list: ${topic_list}
+    count: ${count}
+    start_num: ${start_num}
+    current_city_id: beijing
+  data: {}
+  json: {}
+  isLogin: 1
+
+diary_pre_create_topic:
+  method: get
+  url: /api/diary/pre_create_topic/v2
+  params:
+    current_city_id: beijing
+    diary_id: ${diary_id}
+  data: {}
   json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+  isLogin: 1
\ No newline at end of file

all_backend_api/doctor_request.yaml

@@ -8,14 +8,16 @@ article:
     page: 1
     own_page: 0
     doctor_type: 0
+    current_city_id: beijing
   data: {}
   json: {}
 
 #医生主页详情
 detail:
   method: get
-  url: /api/doctor/5bd9f05cad51403d853ba8c881989e23/detail
-  params: {}
+  url: /api/doctor/a1ee69fad0794022b8f2b1517bf46eba/detail
+  params:
+    current_city_id: beijing
   data: {}
   json: {}
 

all_backend_api/gmai_request.yaml

-skin_newReport:
-  method: post
-  url: /gm_ai/skin/new_report
-  params:
-    version: ${version}
-  data:
-    image_url: ${image_url}
-
-
-eyelids_plastic:
-  method: post
-  url: /gm_ai/eyelids/plastic
-  params:
-    version: ${version}
-  data:
-    image_url: ${image_url}
-    style_id: ${style_id}
-
-
-analysis_v3:
-  method: post
-  url: /gm_ai/plastic/analysis_v3
-  params:
-    device_id: ${device_id}
-  data:
-    image_url: ${image_url}
-    landmark: ${landmark}
-    cheek_style_classify_id: ${cheek_style_classify_id}
-
-
-
-simulate_analyze:
-  method: post
-  url: /gm_ai/simulate/analyze
-  params:
-    device_id: ${device_id}
-  data:
-    image_url: ${image_url}
-    style_id: ${style_id}
-    type_id: ${type_id}
+#skin_newReport:
+#  method: post
+#  url: /gm_ai/skin/new_report
+#  params:
+#    version: ${version}
+#  data:
+#    image_url: ${image_url}
+#
+#
+#eyelids_plastic:
+#  method: post
+#  url: /gm_ai/eyelids/plastic
+#  params:
+#    version: ${version}
+#  data:
+#    image_url: ${image_url}
+#    style_id: ${style_id}
+#
+
+#analysis_v3:
+#  method: post
+#  url: /gm_ai/plastic/analysis_v3
+#  params:
+#    device_id: ${device_id}
+#  data:
+#    image_url: ${image_url}
+#    landmark: ${landmark}
+#    cheek_style_classify_id: ${cheek_style_classify_id}
+
+
+
+#simulate_analyze:
+#  method: post
+#  url: /gm_ai/simulate/analyze
+#  params:
+#    device_id: ${device_id}
+#  data:
+#    image_url: ${image_url}
+#    style_id: ${style_id}
+#    type_id: ${type_id}
 
 
 simulate_conf:
@@ -48,15 +48,15 @@ simulate_conf:
 
 
 
-plastic_analystic_v2:
-  method: post
-  url: /gm_ai/plastic/analysis_v2
-  params:
-    device_id: ${device_id}
-  data:
-    image_url: ${image_url}
-    landmark: ${landmark}
-    cheek_style_classify_id: ${cheek_style_classify_id}
+#plastic_analystic_v2:
+#  method: post
+#  url: /gm_ai/plastic/analysis_v2
+#  params:
+#    device_id: ${device_id}
+#  data:
+#    image_url: ${image_url}
+#    landmark: ${landmark}
+#    cheek_style_classify_id: ${cheek_style_classify_id}
 
 
 plastic_cheek_style_classify:

all_backend_api/hybrid_api_topic_request.yaml

 #日记本列表--日记贴点赞
-vote:
-  method: post
-  url: /hybrid/api/topic/vote/_data
-  params:
-  data:
-    id: ${id}
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+#vote:
+#  method: post
+#  url: /hybrid/api/topic/vote/_data
+#  params:
+#  data:
+#    id: ${id}
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
 
 #取消点赞
-canclevote:
-  method: post
-  url: /hybrid/api/topic/cancel_vote/_data
-  params:
-  data:
-    id: ${id}
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+#canclevote:
+#  method: post
+#  url: /hybrid/api/topic/cancel_vote/_data
+#  params:
+#  data:
+#    id: ${id}
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
 #
 detail:
   method: get

all_backend_api/hybrid_get_gift_request.yaml

 #商祥页-优惠券列表-领取
-get_gift_data:
-  method: post
-  url: /hybrid/get_gift/_data
-  params: {}
-  data:
-    gift_id: ${gift_id}
-  json: {}
-  isLogin: 1
\ No newline at end of file
+#get_gift_data:
+#  method: post
+#  url: /hybrid/get_gift/_data
+#  params: {}
+#  data:
+#    gift_id: ${gift_id}
+#  json: {}
+#  isLogin: 1
\ No newline at end of file

all_backend_api/im_request.yaml

@@ -12,31 +12,31 @@ conversation_detail:
   json: {}
   isLogin: 1 #需要登录的接口
 
-auto_msg:
-  method: post
-  url: /api/im/auto_msg
-  params:
-    trace_id: ${trace_id}
-
-  data:
-    conversation_id: ${conversation_id}
-
-  json: {}
-  isLogin: 1 #需要登录的接口
+#auto_msg:
+#  method: post
+#  url: /api/im/auto_msg
+#  params:
+#    trace_id: ${trace_id}
+#
+#  data:
+#    conversation_id: ${conversation_id}
+#
+#  json: {}
+#  isLogin: 1 #需要登录的接口
 
-send_msg:
-  method: post
-  url: /api/im/send_msg
-  params: {}
-
-  data:
-    conversation_id: ${conversation_id}
-    is_system: ${is_system}
-    referrer: ${referrer}
-    referrer_id: ${referrer_id}
-    msg_type: ${msg_type}
-    content: ${content}
-    extra: ${extra}
-
-  json: {}
-  isLogin: 1 #需要登录的接口
\ No newline at end of file
+#send_msg:
+#  method: post
+#  url: /api/im/send_msg
+#  params: {}
+#
+#  data:
+#    conversation_id: ${conversation_id}
+#    is_system: ${is_system}
+#    referrer: ${referrer}
+#    referrer_id: ${referrer_id}
+#    msg_type: ${msg_type}
+#    content: ${content}
+#    extra: ${extra}
+#
+#  json: {}
+#  isLogin: 1 #需要登录的接口
\ No newline at end of file

all_backend_api/janus_request.py

@@ -7,24 +7,6 @@ class janus_request(BaseRequest):
         #捜索结果页-综合/百科tab
         self.data = self.api_load(path_setting.CONTENTV7_CONFIG)
 
-        #医院主页捜索
-        self.data = self.api_load(path_setting.HOSPITALSEARCH_CONFIG)
-
-        #品类聚合页面商品列表
-        self.data = self.api_load(path_setting.TAG_SERVICE_CONFIG)
-
-        #品类聚合页面标签和专场
-        self.data = self.api_load(path_setting.POLYMER_CONFIG)
-
-        #医生医院sug列表
-        self.data = self.api_load(path_setting.KEYWORDTIP_CONFIG)
-
-        #次卡商详页
-        self.data = self.api_load(path_setting.BEAUTY_CARD_DETAIL_CONFIG)
-
-        #直播-点击【设置封面】
-        self.data = self.api_load(path_setting.PAGE_RULES_CONFIG)
-
     #搜索结果页-综合/百科tab
     def content_v7(self, query, device_id, current_city_id, version, is_first, tab_type, offset):
         #搜索词

all_backend_api/janus_request.yaml

@@ -108,30 +108,30 @@ keyword_tip:
   json: {}
 
 #次卡-确认订单
-beauty_card_order_confirm:
-  method: post
-  url: /api/janus/beauty_card/order/confirm
-  params: {}
-  data:
-    sku_id: ${sku_id}
-    number: ${number}
-    bctraceid: ""
-    use_bc_coupon: ${use_bc_coupon}
-    bc_coupon_id: ${bc_coupon_id}
-  json: {}
-  isLogin: 1
+#beauty_card_order_confirm:
+#  method: post
+#  url: /api/janus/beauty_card/order/confirm
+#  params: {}
+#  data:
+#    sku_id: ${sku_id}
+#    number: ${number}
+#    bctraceid: ""
+#    use_bc_coupon: ${use_bc_coupon}
+#    bc_coupon_id: ${bc_coupon_id}
+#  json: {}
+#  isLogin: 1
 
 #次卡-确认订单页面-修改手机号
-beauty_card_update_phone:
-  method: post
-  url: /api/janus/beauty_card/update_phone
-  params: {}
-  data:
-    authorize_phone: ${authorize_phone}
-    authorize_phone_type: ${authorize_phone_type}
-    vfc_code: ${vfc_code}
-  json: {}
-  isLogin: 1
+#beauty_card_update_phone:
+#  method: post
+#  url: /api/janus/beauty_card/update_phone
+#  params: {}
+#  data:
+#    authorize_phone: ${authorize_phone}
+#    authorize_phone_type: ${authorize_phone_type}
+#    vfc_code: ${vfc_code}
+#  json: {}
+#  isLogin: 1
 #次卡商详页
 beauty_card_detail:
   method: GET
@@ -165,19 +165,19 @@ service_hospital:
 
 
 #次卡-提交订单
-beauty_card_order_submit:
-  method: post
-  url: /api/janus/beauty_card/order/submit
-  params: {}
-  data:
-    phone: ${phone}
-    sku_id: ${sku_id}
-    number: ${number}
-    is_doctor_see: ${is_doctor_see}
-    gain_coupon_id: ${gain_coupon_id}
-    deduction_price: ${deduction_price}
-  json: {}
-  isLogin: 1
+#beauty_card_order_submit:
+#  method: post
+#  url: /api/janus/beauty_card/order/submit
+#  params: {}
+#  data:
+#    phone: ${phone}
+#    sku_id: ${sku_id}
+#    number: ${number}
+#    is_doctor_see: ${is_doctor_see}
+#    gain_coupon_id: ${gain_coupon_id}
+#    deduction_price: ${deduction_price}
+#  json: {}
+#  isLogin: 1
 
 #次卡-支付平台
 beauty_card_payment_method:
@@ -190,25 +190,25 @@ beauty_card_payment_method:
   isLogin: 1
 
 #次卡-微信支付
-beauty_card_prepay_wechat:
-  method: post
-  url: /api/janus/beauty_card/prepay/wechat
-  params: {}
-  data:
-    payment_id: ${payment_id}
-  json: {}
-  isLogin: 1
+#beauty_card_prepay_wechat:
+#  method: post
+#  url: /api/janus/beauty_card/prepay/wechat
+#  params: {}
+#  data:
+#    payment_id: ${payment_id}
+#  json: {}
+#  isLogin: 1
 
 #次卡-支付宝支付
-beauty_card_prepay_alipay:
-  method: post
-  url: /api/janus/beauty_card/prepay/alipay
-  params: {}
-  data:
-    is_huabei: ${is_huabei}
-    payment_id: ${payment_id}
-  json: {}
-  isLogin: 1
+#beauty_card_prepay_alipay:
+#  method: post
+#  url: /api/janus/beauty_card/prepay/alipay
+#  params: {}
+#  data:
+#    is_huabei: ${is_huabei}
+#    payment_id: ${payment_id}
+#  json: {}
+#  isLogin: 1
 
 ##次卡-支付宝支付-花呗分期
 #beauty_card_prepay_alipay_huabei:
@@ -233,14 +233,14 @@ beauty_card_payment_detail:
   isLogin: 1
 
 #次卡-取消订单
-beauty_card_payment_delete:
-  method: post
-  url: /api/janus/beauty_card/payment/delete
-  params: {}
-  data:
-    payment_id: ${payment_id}
-  json: {}
-  isLogin: 1
+#beauty_card_payment_delete:
+#  method: post
+#  url: /api/janus/beauty_card/payment/delete
+#  params: {}
+#  data:
+#    payment_id: ${payment_id}
+#  json: {}
+#  isLogin: 1
 
 #次卡-申请退款
 beauty_card_refund_info:
@@ -253,17 +253,17 @@ beauty_card_refund_info:
   isLogin: 1
 
 #次卡-提交退款申请
-beauty_card_refund_submit:
-  method: post
-  url: /api/janus/beauty_card/refund/submit
-  params: {}
-  data:
-    order_id: ${order_id}
-    reason_id: ${reason_id}
-    reason_text: ${reason_text}
-    reason_type: ${reason_type}
-  json: {}
-  isLogin: 1
+#beauty_card_refund_submit:
+#  method: post
+#  url: /api/janus/beauty_card/refund/submit
+#  params: {}
+#  data:
+#    order_id: ${order_id}
+#    reason_id: ${reason_id}
+#    reason_text: ${reason_text}
+#    reason_type: ${reason_type}
+#  json: {}
+#  isLogin: 1
 
 #新版本我的美券
 coupon_my_list:

all_backend_api/notification_request.yaml

@@ -11,14 +11,14 @@ unread:
   isLogin: 1 #需要登录的接口
 
 #标记为已读
-readall:
-  method: post
-  url: /api/notification/readall
-  params:
-    uqid: ${uqid}
-    trace_id: ${trace_id}
-    ua: ${ua}
-
-  data: {}
-  json: {}
-  isLogin: 1 #需要登录的接口
\ No newline at end of file
+#readall:
+#  method: post
+#  url: /api/notification/readall
+#  params:
+#    uqid: ${uqid}
+#    trace_id: ${trace_id}
+#    ua: ${ua}
+#
+#  data: {}
+#  json: {}
+#  isLogin: 1 #需要登录的接口
\ No newline at end of file

all_backend_api/oneimage_request.yaml

 #测肤结果页
-share_v4:
-  method: post
-  url: /api/one_image/share/v4
-  params:
-    version: ${version}
-  data:
-    face_id: ${face_id}
-  json: {}
+#share_v4:
+#  method: post
+#  url: /api/one_image/share/v4
+#  params:
+#    version: ${version}
+#  data:
+#    face_id: ${face_id}
+#  json: {}
 
 #测肤结果根据五官推荐美购
 recomend_services:

all_backend_api/pay_request.yaml

-wechat_prepay:
-  method: post
-  url: /pay/wechat/prepay
-  params:
-    current_city_id: "beijing"
-    version: 7.44.0
-  data:
-    settlement_id: ${settlement_id}
-  isLogin: 1
-
-alipay_prepay:
-  method: post
-  url: /pay/alipay/prepay
-  params:
-    current_city_id: "beijing"
-    version: 7.44.0
-  data:
-    settlement_id: ${settlement_id}
-    version: ${version}
-    is_huabei: ${is_huabei}
-    huabei_period: ${huabei_period}
-  isLogin: 1
-
-jump:
-  method: post
-  url: /pay/jump
-  params:
-    current_city_id: "beijing"
-    version: 7.44.0
-  data:
-    settlement_id: ${settlement_id}
-  isLogin: 1
+#wechat_prepay:
+#  method: post
+#  url: /pay/wechat/prepay
+#  params:
+#    current_city_id: "beijing"
+#    version: 7.44.0
+#  data:
+#    settlement_id: ${settlement_id}
+#  isLogin: 1
+#
+#alipay_prepay:
+#  method: post
+#  url: /pay/alipay/prepay
+#  params:
+#    current_city_id: "beijing"
+#    version: 7.44.0
+#  data:
+#    settlement_id: ${settlement_id}
+#    version: ${version}
+#    is_huabei: ${is_huabei}
+#    huabei_period: ${huabei_period}
+#  isLogin: 1
+#
+#jump:
+#  method: post
+#  url: /pay/jump
+#  params:
+#    current_city_id: "beijing"
+#    version: 7.44.0
+#  data:
+#    settlement_id: ${settlement_id}
+#  isLogin: 1

all_backend_api/private_conversation_request.yaml

-private_conversation:
-  method: post
-  url: /api/private_conversation/
-  params: {}
-  data:
-    content: ${content}
-    target_uid: ${target_uid}
-    referrer: ${referrer}
-    referrer_id: ${referrer_id}
-    is_system: ${is_system}
-    quick_consultation_id: ${quick_consultation_id}
-    diary_id: ${diary_id}
-    from_live: ${from_live}
-
-  json: {}
-  isLogin: 1 #需要登录的接口
\ No newline at end of file
+#private_conversation:
+#  method: post
+#  url: /api/private_conversation/
+#  params: {}
+#  data:
+#    content: ${content}
+#    target_uid: ${target_uid}
+#    referrer: ${referrer}
+#    referrer_id: ${referrer_id}
+#    is_system: ${is_system}
+#    quick_consultation_id: ${quick_consultation_id}
+#    diary_id: ${diary_id}
+#    from_live: ${from_live}
+#
+#  json: {}
+#  isLogin: 1 #需要登录的接口
\ No newline at end of file

all_backend_api/qa_request.yaml

 #问题收藏
-favor:
-  method: post
-  url:     /api/qa/favor
-  params:
-  data:
-    answer_id: ${answer_id}
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+#favor:
+#  method: post
+#  url:     /api/qa/favor
+#  params:
+#  data:
+#    answer_id: ${answer_id}
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
 
 
 #问题取消收藏
-cancelfavor:
-  method: post
-  url:     /api/qa/favor/cancel
-  params:
-  data:
-    answer_id: ${answer_id}
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+#cancelfavor:
+#  method: post
+#  url:     /api/qa/favor/cancel
+#  params:
+#  data:
+#    answer_id: ${answer_id}
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
 
 

all_backend_api/question_request.yaml

 #回答详情页-  一/二级评论
-reply_answer:
-  method: post
-  url: /api/question/reply_answer
-  params:
-    current_city_id: ${current_city_id}
-  data:
-    answer_id: ${answer_id}
-    content: ${content}
-    user_id: ${user_id}
-  json: {}
-  isLogin: 1
\ No newline at end of file
+#reply_answer:
+#  method: post
+#  url: /api/question/reply_answer
+#  params:
+#    current_city_id: ${current_city_id}
+#  data:
+#    answer_id: ${answer_id}
+#    content: ${content}
+#    user_id: ${user_id}
+#  json: {}
+#  isLogin: 1
\ No newline at end of file

all_backend_api/service_request.yaml

@@ -9,10 +9,10 @@ home_v5:
 
 
 #商祥页-收藏
-service_favor:
-  method: post
-  url: /api/service/favor/5857263/
-  params: {}
-  data: {}
-  json: {}
-  isLogin: 1
\ No newline at end of file
+#service_favor:
+#  method: post
+#  url: /api/service/favor/5857263/
+#  params: {}
+#  data: {}
+#  json: {}
+#  isLogin: 1
\ No newline at end of file

all_backend_api/settlement_request.yaml

-preview_v1:
-  method: post
-  url: /api/settlement/preview/v1
-  params:
-    current_city_id: ${current_city_id}
-  data:
-    service_item_id: ${service_item_id}
-    number: ${number}
-    use_platform_coupon: ${use_platform_coupon}
-    use_doctor_coupon: ${use_doctor_coupon}
-    use_coupon_grey: ${use_coupon_grey}
-    is_create_groupbuy: ${is_create_groupbuy}
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+#preview_v1:
+#  method: post
+#  url: /api/settlement/preview/v1
+#  params:
+#    current_city_id: ${current_city_id}
+#  data:
+#    service_item_id: ${service_item_id}
+#    number: ${number}
+#    use_platform_coupon: ${use_platform_coupon}
+#    use_doctor_coupon: ${use_doctor_coupon}
+#    use_coupon_grey: ${use_coupon_grey}
+#    is_create_groupbuy: ${is_create_groupbuy}
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
 
 pay_v1:
   method: get
@@ -26,23 +26,23 @@ pay_v1:
   json: {}
   isLogin: 1
 
-create_v1:
-  method: post
-  url: /api/settlement/create/v1
-  params:
-    current_city_id: "beijing"
-    version: 7.44.0
-  data:
-    service_item_id: ${service_item_id}
-    number: ${number}
-    phone: "18301089978"
-    platform_coupon_id: ${platform_coupon_id}
-    use_point: ${use_point}
-    is_doctor_see: ${is_doctor_see}
-    doctor_coupon_id: ${doctor_coupon_id}
-    insurance_info: ${insurance_info}
-    is_create_groupbuy: ${is_create_groupbuy}
-  isLogin: 1
+#create_v1:
+#  method: post
+#  url: /api/settlement/create/v1
+#  params:
+#    current_city_id: "beijing"
+#    version: 7.44.0
+#  data:
+#    service_item_id: ${service_item_id}
+#    number: ${number}
+#    phone: "18301089978"
+#    platform_coupon_id: ${platform_coupon_id}
+#    use_point: ${use_point}
+#    is_doctor_see: ${is_doctor_see}
+#    doctor_coupon_id: ${doctor_coupon_id}
+#    insurance_info: ${insurance_info}
+#    is_create_groupbuy: ${is_create_groupbuy}
+#  isLogin: 1
 
 pay:
   method: get
@@ -64,15 +64,15 @@ detail:
   data: {}
   isLogin: 1
 
-delete:
-  method: post
-  url: /api/settlement/delete
-  params:
-    current_city_id: "beijing"
-    version: 7.44.0
-  data:
-    id: ${id}
-    cancel_reason_value: ${cancel_reason_value}
-  json: {}
-  isLogin: 1
+#delete:
+#  method: post
+#  url: /api/settlement/delete
+#  params:
+#    current_city_id: "beijing"
+#    version: 7.44.0
+#  data:
+#    id: ${id}
+#    cancel_reason_value: ${cancel_reason_value}
+#  json: {}
+#  isLogin: 1
 

all_backend_api/shopcart_request.yaml

@@ -8,13 +8,13 @@ list:
   isLogin: 1
 
 #商祥页-加入购物车
-add:
-  method: post
-  url: /api/shopcart/add/v1
-  params: {}
-  data:
-    from_live: ${from_live}
-    number: ${number}
-    service_item_id: ${service_item_id}
-  json: {}
-  isLogin: 1
\ No newline at end of file
+#add:
+#  method: post
+#  url: /api/shopcart/add/v1
+#  params: {}
+#  data:
+#    from_live: ${from_live}
+#    number: ${number}
+#    service_item_id: ${service_item_id}
+#  json: {}
+#  isLogin: 1
\ No newline at end of file

all_backend_api/topic_reply_create.yaml

 #日记贴一级评论创建[这个是非本身日记贴：21116006]--暂时未解决复写yaml文件的问题所以单独把创建评论踢出去
-reply_create:
-  method: post
-  url:  /api/topic/reply/create/21249632/
-  params:
-    channel: ${channel}
-  data:
-    content: ${content}
-  json: {}
+#reply_create:
+#  method: post
+#  url:  /api/topic/reply/create/21249632/
+#  params:
+#    channel: ${channel}
+#  data:
+#    content: ${content}
+#  json: {}
   isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
 
 
 #日记贴二级评论创建[这个是非本身日记贴：21116006]
-sub_reply_create:
-  method: post
-  url:  /api/topic/reply/create/21249632/
-  params:
-    channel: ${channel}
-  data:
-    content: ${content}
-    replied_id: ${replied_id}
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
\ No newline at end of file
+#sub_reply_create:
+#  method: post
+#  url:  /api/topic/reply/create/21249632/
+#  params:
+#    channel: ${channel}
+#  data:
+#    content: ${content}
+#    replied_id: ${replied_id}
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
\ No newline at end of file

all_backend_api/topic_request.yaml

 #日记贴详情页--日记贴点赞
-vote:
-  method: post
-  url: /api/topic/vote/
-  params:
-  data:
-    topic_id: ${topic_id}
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
-
-#取消点赞
-cancelvote:
-  method: delete
-  url: /api/topic/vote/
-  params:
-    topic_id: ${topic_id}
-  data: {}
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+#vote:
+#  method: post
+#  url: /api/topic/vote/
+#  params:
+#  data:
+#    topic_id: ${topic_id}
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+#
+##取消点赞
+#cancelvote:
+#  method: delete
+#  url: /api/topic/vote/
+#  params:
+#    topic_id: ${topic_id}
+#  data: {}
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
 
 #详情页内容
 detail:

all_backend_api/topicreply_vote.yaml

 #日记贴评论点赞
-topic_reply_vote:
-  method: post
-  url: /hybrid/api/topicreply/vote/_data
-  params:
-  data:
-    id: ${id}
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
-
-topic_reply_cancelvote:
-  method: post
-  url: /hybrid/api/topicreply/cancel_vote/_data
-  params:
-  data:
-    id: ${id}
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+#topic_reply_vote:
+#  method: post
+#  url: /hybrid/api/topicreply/vote/_data
+#  params:
+#  data:
+#    id: ${id}
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
 #
+#topic_reply_cancelvote:
+#  method: post
+#  url: /hybrid/api/topicreply/cancel_vote/_data
+#  params:
+#  data:
+#    id: ${id}
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+##
 
 

all_backend_api/tractate_request.yaml

@@ -39,65 +39,65 @@ reply:
 
 
 #帖子收藏
-favor:
-  method: post
-  url:    /api/tractate/favor
-  params:
-  data:
-    data_type:  ${data_type}
-    tractate_id: ${tractate_id}
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+#favor:
+#  method: post
+#  url:    /api/tractate/favor
+#  params:
+#  data:
+#    data_type:  ${data_type}
+#    tractate_id: ${tractate_id}
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
 
 
 #帖子取消收藏
-cancelfavor:
-  method: post
-  url:     /api/tractate/favor/cancel
-  params:
-  data:
-    data_type: ${data_type}
-    tractate_id: ${tractate_id}
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+#cancelfavor:
+#  method: post
+#  url:     /api/tractate/favor/cancel
+#  params:
+#  data:
+#    data_type: ${data_type}
+#    tractate_id: ${tractate_id}
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
 
 
 #帖子点赞
-tractate_vote:
-  method: post
-  url: /api/tractate/vote
-  params:
-  data:
-    tractate_id: ${tractate_id}
-    data_type: ${data_type}
-    reply_id: ${reply_id}
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+#tractate_vote:
+#  method: post
+#  url: /api/tractate/vote
+#  params:
+#  data:
+#    tractate_id: ${tractate_id}
+#    data_type: ${data_type}
+#    reply_id: ${reply_id}
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
 
 #帖子取消点赞
-tractate_cancelvote:
-  method: post
-  url: /api/tractate/vote/cancel
-  params:
-  data:
-    tractate_id: ${tractate_id}
-    data_type: ${data_type}
-    reply_id: ${reply_id}
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
-#
+#tractate_cancelvote:
+#  method: post
+#  url: /api/tractate/vote/cancel
+#  params:
+#  data:
+#    tractate_id: ${tractate_id}
+#    data_type: ${data_type}
+#    reply_id: ${reply_id}
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+##
 
 
 #帖子创建一级评论
-publish_reply:
-  method: post
-  url: /api/tractate/publish_reply
-  params:
-  data:
-    tractate_id: ${tractate_id}
-    data_type: ${data_type}
-    reply_id: ${reply_id}
-    content: ${content}
-  json: {}
-  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
+#publish_reply:
+#  method: post
+#  url: /api/tractate/publish_reply
+#  params:
+#  data:
+#    tractate_id: ${tractate_id}
+#    data_type: ${data_type}
+#    reply_id: ${reply_id}
+#    content: ${content}
+#  json: {}
+#  isLogin: 1  #需要登录添加这个字段，值为1  0是不需要登录的情况，如不需要登录，可以不添加这个字段
 #
\ No newline at end of file

all_backend_api/user_request.yaml

@@ -21,20 +21,20 @@ answer:
   json: {}
 
 #日记贴--收藏
-favor:
-  method: post
-  url: /api/user/problem_favor/21249632/
-  params:
-  data: {}
-  json: {}
-  isLogin: 1
-
-#日记贴--取消收藏
-canclefavor:
-  method: delete
-  url: /api/user/problem_favor/21249632/
-  params:
-  data: {}
-  json: {}
-  isLogin: 1
+#favor:
+#  method: post
+#  url: /api/user/problem_favor/21249632/
+#  params:
+#  data: {}
+#  json: {}
+#  isLogin: 1
+#
+##日记贴--取消收藏
+#canclefavor:
+#  method: delete
+#  url: /api/user/problem_favor/21249632/
+#  params:
+#  data: {}
+#  json: {}
+#  isLogin: 1
 

all_doctor_api/glmer_request.py

-import path_setting
-from in_common.base_request import BaseRequest
-
-
-class glmer_request(BaseRequest):
-    def __init__(self):
-        self.REGISTER_URL = self.api_load(path_setting.REGISTER_URL)
-
-    def service_register(self,name,project_type,upgrade,short_description,doctor_id,start_time,end_time,photo_details,image_header,video_token,service_type,is_specialreview,reservation,have_extra_pay,is_draft,items,csrfmiddlewaretoken):
-        self.params["name"] = name
-        self.params["project_type"] = project_type
-        self.params["upgrade"] = upgrade
-        self.params["short_description"] = short_description
-        self.params["doctor_id"] = doctor_id
-        self.params["start_time"] = start_time
-        self.params["end_time"] = end_time
-        self.params["photo_details"] = photo_details
-        self.params["image_header"] = image_header
-        self.params["video_token"] = video_token
-        self.params["service_type"] = service_type
-        self.params["is_specialreview"] = is_specialreview
-        self.params["reservation"] = reservation
-        self.params["have_extra_pay"] = have_extra_pay
-        self.params["is_draft"] = is_draft
-        self.params["items"] = items
-        self.params["csrfmiddlewaretoken"] = csrfmiddlewaretoken
-        return self.api_send(self.REGISTER_URL["service_register"])
-
-
-
-    def service_detail(self) :
-        return self.api_send(self.REGISTER_URL["service_detail"])
-
-    def tag_properties(self,catalog_ids):
-        #我的商品-编辑可标准化商品
-        self.params["catalog_ids"] = catalog_ids
-        return self.api_send(self.REGISTER_URL["tag_properties"])
-
-
-
-
-if __name__ == '__main__':
-    print(glmer_request().service_register("激光溶脂瘦脸", "[236]", "true", "测试", "wangyang", "1624377600", "1627660800", "<p>12</p>", "https://heras.igengmei.com/service/2021/06/01/0b9b110e60", "UPCOYIJkZOMcdd9FDzpBqYjzWUh55fBpVi3AhWpL:nBdvXYz_CR7wNcuroo3TLyvuQiY=:eyJzY29wZSI6InZpZGVvIiwiZGVhZGxpbmUiOjE2MjI1MTg2NTd9", "0", "false", "1", "false", "0", '[{"gengmei_price":100,"original_price":200,"is_online":true}]',"PC8uTySuxipukIMuqNV1OPB376C2ZZ3g"))
-    print(glmer_request().service_detail())
-    print(glmer_request().tag_properties("[115,141]"))

all_doctor_api/glmer_request.yaml

-service_register:
-  method: POST
-  url: /api/glmer/service/register
-  params: {}
-  data:
-    name: ${name}
-    project_type: ${project_type}
-    upgrade: ${upgrade}
-    short_description: ${short_description}
-    doctor_id: ${doctor_id}
-    start_time: ${start_time}
-    end_time: ${end_time}
-    photo_details: ${photo_details}
-    image_header: ${image_header}
-    video_token: ${video_token}
-    service_type: ${service_type}
-    is_specialreview: ${is_specialreview}
-    reservation: ${reservation}
-    have_extra_pay: ${have_extra_pay}
-    is_draft: ${is_draft}
-    items: ${items}
-    csrfmiddlewaretoken: ${csrfmiddlewaretoken}
-    phone_num: ${phone_num}
-    vfc_code: ${vfc_code}
-    face_token: ${face_token}
-  json: {}
-  isLogin: 1
-
-
-service_detail:
-   method: get
-   url: /api/glmer/service/detail/5885425
-   params: {}
-   data: {}
-   json: {}
-   isLogin: 1
-
-tag_properties:
-   method: get
-   url: /api/glmer/tag/properties
-   params:
-     catalog_ids: ${catalog_ids}
-   data: {}
-   json: {}
-   isLogin: 1
-

all_doctor_api/web2_request.py

-import path_setting
-from in_common.base_request import BaseRequest
-
-
-class web2_request(BaseRequest):
-    def __init__(self):
-        self.SERVICE_URL = self.api_load(path_setting.SERVICE_URL)
-        # self.SERVICE_REVIEW_URL = self.api_load(path_setting.SERVICE_REVIEW_URL)
-
-    def service_list(self, page,pagesize,is_online,extra_filter_choice):
-        #我的商品查询列表
-        self.params["page"] = page
-        self.params["pagesize"] = pagesize
-        self.params["is_online"] = is_online
-        self.params["extra_filter_choice"] = extra_filter_choice
-        return self.api_send(self.SERVICE_URL["service_list"])
-
-    def service_review_list(self,page,pagesize,type):
-        #商品审核查询列表
-        self.params["page"] = page
-        self.params["pagesize"] = pagesize
-        self.params["type"] = type
-        return self.api_send(self.SERVICE_URL["service_review_list"])
-
-    def servicereview_option(self,id, type,csrfmiddlewaretoken):
-        #商品审核-撤回审核、取消申请
-        self.params["id"] = id
-        self.params["type"] = type
-        self.params["csrfmiddlewaretoken"] = csrfmiddlewaretoken
-        return self.api_send(self.SERVICE_URL["servicereview_option"])
-
-    def tag_all(self) :
-        #发布商品-选择类目跳转发布商品页面tag接口
-        return self.api_send(self.SERVICE_URL["tag_all"])
-
-    def service_delete(self,is_delete,service_register_id,csrfmiddlewaretoken):
-        #我的商品-删除商品
-        self.params["is_delete"] = is_delete
-        self.params["service_register_id"] = service_register_id
-        self.params["csrfmiddlewaretoken"] = csrfmiddlewaretoken
-        return self.api_send(self.SERVICE_URL["service_delete"])
-
-    def service_deletelist(self,page):
-        #我的商品-商品回收站
-        self.params["page"] = page
-        return self.api_send(self.SERVICE_URL["service_deletelist"])
-
-    def artemis_ad_add_shopping_cart_info(self):
-        #我的购物车
-        return self.api_send(self.SERVICE_URL["artemis_ad_add_shopping_cart_info"])
-    def artemis_add_value_order_id_detail(self):
-        "我的服务订单-已购买"
-        return self.api_send(self.SERVICE_URL["artemis_add_value_order_id_detail"])
-
-
-
-
-
-
-if __name__ == '__main__':
-    print(web2_request().service_list("1", "10", "-1", "-1"))
-    print(web2_request().service_review_list("1", "10", "0"))
-    print(web2_request().servicereview_option("209989", "1", "PC8uTySuxipukIMuqNV1OPB376C2ZZ3g"))
-    print(web2_request().tag_all())
-    print(web2_request().service_delete("1","209863","PC8uTySuxipukIMuqNV1OPB376C2ZZ3g"))
-    print(web2_request().service_deletelist("1"))#商品回收站
-    print(web2_request().artemis_ad_add_shopping_cart_info())
-    print(web2_request().artemis_add_value_order_id_detail())
-

all_doctor_api/web2_request.yaml

-service_list:
-  method: get
-  url: /api/web2/service/list
-  params:
-    page: ${page}
-    pagesize: ${pagesize}
-    is_online: ${is_online}
-    extra_filter_choice: ${extra_filter_choice}
-  data: {}
-  json: {}
-  isLogin: 1
-
-
-service_review_list:
-   method: get
-   url: /api/web2/service/review/list
-   params:
-     page: ${page}
-     pagesize: ${pagesize}
-     type: ${type}
-   data: {}
-   json: {}
-   isLogin: 1
-
-
-servicereview_option:
-   method: POST
-   url: /api/web2/servicereview/option
-   params: {}
-   data:
-     id: ${id}
-     type: ${type}
-     csrfmiddlewaretoken: ${csrfmiddlewaretoken}
-   json: {}
-   isLogin: 1
-
-
-tag_all:
-  method: get
-  url: /api/web2/tag/all
-  param: {}
-  data: {}
-  json: {}
-  isLogin: 1
-
-service_delete:
-  method: POST
-  url: /api/web2/service/delete
-  params: {}
-  data:
-    is_delete: ${is_delete}
-    service_register_id: ${service_register_id}
-    csrfmiddlewaretoken: ${csrfmiddlewaretoken}
-  json: {}
-  isLogin: 1
-
-
-
-
-
-service_deletelist:
-   method: get
-   url: /api/web2/service/delete/list
-   params:
-     page: ${page}
-   data: {}
-   json: {}
-   isLogin: 1
-
-artemis_ad_add_shopping_cart_info:
-  method: get
-  url: /api/web2/artemis/ad/add_shopping_cart/info
-  params: {}
-  data: {}
-  json: {}
-  isLogin: 1 #需要登录
-artemis_add_value_order_id_detail:
-  method: get
-  url: /api/web2/artemis/add_value_order/957727877165/detail
-  params: {}
-  data: {}
-  json: {}
-  isLogin: 1 #需要登录
\ No newline at end of file

all_doctor_api/web_request.py

-import path_setting
-from in_common.base_request import BaseRequest
-
-
-class web_request(BaseRequest):
-    def __init__(self):
-        self.ACCOUNT_URL = self.api_load(path_setting.ACCOUNT_URL)
-
-    def account_unreadbadgecount(self) :
-        return self.api_send(self.ACCOUNT_URL["account_unreadbadgecount"])
-
-    def article_videotoken(self) :
-        return self.api_send(self.ACCOUNT_URL["article_videotoken"])
-
-    def doctor_submechanisms(self) :
-        return self.api_send(self.ACCOUNT_URL["doctor_submechanisms"])
-
-    def service_offline(self,id,csrfmiddlewaretoken):
-        self.params["id"] = id
-        self.params["csrfmiddlewaretoken"] = csrfmiddlewaretoken
-        return self.api_send(self.ACCOUNT_URL["service_offline"])
-
-    def conversation(self, is_star, page):
-        self.params["is_star"] = is_star
-        self.params["page"] = page
-        return self.api_send(self.ACCOUNT_URL["conversation"])
-
-    def conversation_unread_list(self, page):
-        self.params["page"] = page
-        return self.api_send(self.ACCOUNT_URL["conversation_unread_list"])
-
-    def service(self):
-        return self.api_send(self.ACCOUNT_URL["service"])
-
-    def conversation_diary(self, doctor_user_id):
-        self.params["doctor_user_id"] = doctor_user_id
-        return self.api_send(self.ACCOUNT_URL["conversation_diary"])
-
-    def conversation_coupon(self, doctor_user_id):
-        self.params["doctor_user_id"] = doctor_user_id
-        return self.api_send(self.ACCOUNT_URL["conversation_coupon"])
-
-    def service_all(self):
-        return self.api_send(self.ACCOUNT_URL["service_all"])
-
-    def conversation_user_id(self, type, content, doctor_user_id, t, csrfmiddlewaretoken):
-        self.params["type"] = type
-        self.params["content"] = content
-        self.params["doctor_user_id"] = doctor_user_id
-        self.params["t"] = t
-        self.params["csrfmiddlewaretoken"] = csrfmiddlewaretoken
-        return self.api_send(self.ACCOUNT_URL["conversation_user_id"])
-
-    # def file_upload(self, img_type,csrfmiddlewaretoken,id,name,type,lastModifiedDate,size,file):
-    #     self.params["img_type"] = img_type
-    #     self.params["csrfmiddlewaretoken"] = csrfmiddlewaretoken
-    #     self.params["id"] = id
-    #     self.params["name"] = name
-    #     self.params["type"] = type
-    #     self.params["lastModifiedDate"] = lastModifiedDate
-    #     self.params["size"] = size
-    #     self.params["file"] = file
-    #     return self.api_send(self.ACCOUNT_URL["file_upload"])
-    def cpc_homepage(self):
-        return self.api_send(self.ACCOUNT_URL["cpc_homepage"])
-    def artemis_ad_type_list(self):
-        return self.api_send(self.ACCOUNT_URL["artemis_ad_type_list"])
-    def artemis_order_list(self, status, page):
-        self.params["status"] = status
-        self.params["page"] = page
-        return self.api_send(self.ACCOUNT_URL["artemis_order_list"])
-    def artemis_order_id_detail(self):
-        "上线中订单详情页"
-        return self.api_send(self.ACCOUNT_URL["artemis_order_id_detail"])
-
-
-
-
-
-if __name__ == '__main__':
-    print(web_request().account_unreadbadgecount())
-    print(web_request().article_videotoken())
-    print(web_request().doctor_submechanisms())
-    print(web_request().service_offline("209992", "PC8uTySuxipukIMuqNV1OPB376C2ZZ3g"))
-    print(web_request().conversation(0, 1))
-    print(web_request().conversation_unread_list(1))
-    print(web_request().service())
-    print(web_request().conversation_diary(602329))
-    print(web_request().conversation_coupon(602329))
-    print(web_request().service_all())
-    # print(web_request().file_upload("19","PC8uTySuxipukIMuqNV1OPB376C2ZZ3g","WU_FILE_0","lADPDg7mQdiUTiLNAZDNAZA_400_400.jpg_720x720g.jpg","image/jpeg","Mon Apr 26 2021 11:29:45 GMT+0800 (中国标准时间)","17688","(binary)"))
-    print(web_request().conversation_user_id(0, "您好", 602329, "271caac2ae1687ca0a56ee18115b8183", "NLeTxEx1BOQo1zjv2us9BQ00ViMAHGpJ"))
-    print(web_request().cpc_homepage())
-    print(web_request().artemis_ad_type_list())
-    print("发送")
-    print(web_request().artemis_order_list(0, 1))
-    print(web_request().artemis_order_list(1, 1))
-    print(web_request().artemis_order_list(2, 1))
-    print(web_request().artemis_order_id_detail())
\ No newline at end of file

all_doctor_api/web_request.yaml

-account_unreadbadgecount:
-  method: get
-  url: /api/web/account/unread_badge_count
-  param: {}
-  data: {}
-  json: {}
-  isLogin: 1
-
-
-
-article_videotoken:
-  method: get
-  url: /api/web/article/video_token
-  param: {}
-  data: {}
-  json: {}
-  isLogin: 1
-
-
-
-doctor_submechanisms:
-  method: get
-  url: /api/web/doctor/submechanisms
-  param: {}
-  data: {}
-  json: {}
-  isLogin: 1
-
-
-service_offline:
-  method: post
-  url: /api/web/service/offline
-  param: {}
-  data:
-    id: ${id}
-    csrfmiddlewaretoken: ${csrfmiddlewaretoken}
-  json: {}
-  isLogin: 1
-
-conversation:
-  method: get
-  url: /api/web/conversation
-  params:
-    is_star: ${is_star}
-    page: ${page}
-  data: {}
-  json: {}
-  isLogin: 1 #需要登录
-
-conversation_unread_list:
-  method: get
-  url: /api/web/conversation/unread_list
-  params:
-    page: ${page}
-  data: {}
-  json: {}
-  isLogin: 1 #需要登录
-
-service:
-  method: get
-  url: /api/web/service
-  params: {}
-  data: {}
-  json: {}
-  isLogin: 1 #需要登录
-
-conversation_diary:
-  method: get
-  url: /api/web/conversation/diary
-  params:
-    doctor_user_id: ${doctor_user_id}
-  data: {}
-  json: {}
-  isLogin: 1 #需要登录
-
-conversation_coupon:
-  method: get
-  url: /api/web/conversation/coupon
-  params:
-    doctor_user_id: ${doctor_user_id}
-  data: {}
-  json: {}
-  isLogin: 1 #需要登录
-
-
-service_all:
-  method: get
-  url: /api/web/service/all
-  params: {}
-  data: {}
-  json: {}
-  isLogin: 1
-
-
-#file_upload:
-#  method: post
-#  url: /api/web/file/upload
-#  param: {}
-#  data:
-#    img_type: ${img_type}
-#    csrfmiddlewaretoken: ${csrfmiddlewaretoken}
-#    id: ${id}
-#    name: ${name}
-#    type: ${type}
-#    lastModifiedDate: ${lastModifiedDate}
-#    size: ${size}
-#    file: ${file}
-#  json: {}
-#  isLogin: 1
-
-conversation_user_id:
-  method: post
-  url: /api/web/conversation/602329_33909952
-  params: {}
-  data:
-    type: ${type}
-    content: ${content}
-    doctor_user_id: ${doctor_user_id}
-    t: ${t}
-    csrfmiddlewaretoken: ${csrfmiddlewaretoken}
-  json: {}
-  isLogin: 1 #需要登录
-
-cpc_homepage:
-  method: get
-  url: /api/web/cpc/homepage
-  params: {}
-  data: {}
-  json: {}
-  isLogin: 1 #需要登录
-
-artemis_ad_type_list:
-  method: get
-  url: /api/web/artemis/ad/type_list
-  params: {}
-  data: {}
-  json: {}
-  isLogin: 1 #需要登录
-
-artemis_order_list:
-  method: get
-  url: /api/web/artemis/order/list
-  params:
-    status: ${status}
-    page: ${page}
-  data: {}
-  json: {}
-  isLogin: 1 #需要登录
-
-artemis_order_id_detail:
-  method: get
-  url: /api/web/artemis/order/509151034657/detail
-  params: {}
-  data: {}
-  json: {}
-  isLogin: 1 #需要登录
\ No newline at end of file

all_om_api/beautycard_request.py

-import path_setting
-from in_common.base_request import BaseRequest
-
-
-class beautycard_request(BaseRequest):
-    def __init__(self):
-        #更美次卡-获取已添加页面次卡spu/sku列表
-        self.data = self.api_load(path_setting.GET_RELATED_BC_CONFIG)
-        #更美次卡-删除/批量删除已添加页面次卡
-        self.data = self.api_load(path_setting.DELETE_RELATED_BC_CONFIG)
-        #更美次卡-已添加页面全部导出
-        self.data = self.api_load(path_setting.EXPORT_RELATED_BC_CONFIG)
-        #更美次卡-更改次卡排序
-        self.data = self.api_load(path_setting.UPDATE_BC_RANK_CONFIG)
-        #更美次卡-按次卡sku_id导入，导入校验
-        self.data = self.api_load(path_setting.CHECK_SKU_IDS_CONFIG)
-
-    #更美次卡-获取已添加页面次卡spu/sku列表
-    def get_related_bc(self, unit_id, bc_sku_id, bc_spu_id, page, page_size):
-        self.params["unit_id"] = unit_id
-        self.params["bc_sku_id"] = bc_sku_id
-        self.params["bc_spu_id"] = bc_spu_id
-        self.params["page"] = page
-        self.params["page_size"] = page_size
-
-        return self.api_send(self.data["get_related_bc"])
-
-    #更美次卡-删除/批量删除已添加页面次卡
-    def delete_related_bc(self, unit_id, bc_sku_ids, bc_spu_ids, related_type):
-        self.params["unit_id"] = unit_id
-        self.params["bc_sku_ids"] = bc_sku_ids
-        self.params["bc_spu_ids"] = bc_spu_ids
-        self.params["related_type"] = related_type
-
-        return self.api_send(self.data["delete_related_bc"])
-
-    #更美次卡-已添加页面全部导出
-    def export_related_bc(self, unit_id, bc_sku_id, bc_spu_id):
-        self.params["unit_id"] = unit_id
-        self.params["bc_sku_id"] = bc_sku_id
-        self.params["bc_spu_id"] = bc_spu_id
-
-        return self.api_send(self.data["export_related_bc"])
-
-    #更美次卡-更改次卡排序
-    def update_bc_rank(self, unit_id, related_id, related_type, rank):
-        self.params["unit_id"] = unit_id
-        self.params["related_id"] = related_id
-        self.params["related_type"] = related_type
-        self.params["rank"] = rank
-
-        return self.api_send(self.data["update_bc_rank"])
-
-    #更美次卡-按次卡sku_id导入，导入校验
-    def check_sku_ids(self, bc_skus):
-        self.params["bc_skus"] = bc_skus
-
-        return self.api_send(self.data["check_sku_ids"])
-
-    #更美次卡-按次卡spu_id导入，导入校验
-    def check_spu_ids(self, bc_spus):
-        self.params["bc_spus"] = bc_spus
-
-        return self.api_send(self.data["check_spu_ids"])
-
-if __name__ == '__main__':
-    print(beautycard_request().get_related_bc("20105", "", "", "0", "10"))
-    print(beautycard_request().delete_related_bc("19931", "[10163]", "[]", "8"))
-    print(beautycard_request().export_related_bc("19933", "", ""))
-    print(beautycard_request().update_bc_rank("20105", "100023", "7", "11"))
\ No newline at end of file

all_om_api/beautycard_request.yaml

-#更美次卡-获取已添加页面次卡spu/sku列表
-get_related_bc:
-  method : GET
-  url : /achelous/visual/beauty_card/get_related_bc
-  params :
-    unit_id : ${unit_id}
-    bc_sku_id : ${bc_sku_id}
-    bc_spu_id : ${bc_spu_id}
-    page : ${page}
-    page_size : ${page_size}
-  data : {}
-  json : {}
-  isLogin : 1
-
-#更美次卡-删除/批量删除已添加页面次卡
-delete_related_bc:
-  method : POST
-  url : /achelous/visual/beauty_card/delete_related_bc
-  params : {}
-  data :
-    unit_id : ${unit_id}
-    bc_sku_ids : ${bc_sku_ids}
-    bc_spu_ids : ${bc_spu_ids}
-    related_type : ${related_type}
-  json : {}
-  isLogin : 1
-
-#更美次卡-已添加页面全部导出
-export_related_bc:
-  method : GET
-  url : /achelous/visual/beauty_card/export_related_bc
-  params :
-    unit_id : ${unit_id}
-    bc_sku_id : ${bc_sku_id}
-    bc_spu_id : ${bc_spu_id}
-  data : {}
-  json : {}
-  isLogin : 1
-
-#更美次卡-更改次卡排序
-update_bc_rank:
-  method : POST
-  url : /achelous/visual/beauty_card/update_bc_rank
-  params : {}
-  data :
-    unit_id: ${unit_id}
-    related_id: ${related_id}
-    related_type: ${related_type}
-    rank: ${rank}
-  json : {}
-  isLogin : 1
-
-#更美次卡-按次卡sku_id导入，导入校验
-check_sku_ids:
-  method : POST
-  url : /achelous/visual/beauty_card/check_sku_ids
-  params : {}
-  data :
-    bc_skus: ${bc_skus}
-  json : {}
-  isLogin : 1
-
-#更美次卡-按次卡spu_id导入，导入校验
-check_spu_ids:
-  method : POST
-  url : /achelous/visual/beauty_card/check_spu_ids
-  params : {}
-  data :
-    bc_spus: ${bc_spus}
-  json : {}
-  isLogin : 1
\ No newline at end of file

all_om_api/login_request.py

-import path_setting
-from in_common.base_request import BaseRequest
-
-
-class login_request(BaseRequest):
-    def __init__(self):
-        #om后台-登录
-        self.data = self.api_load(path_setting.OMLOGIN_CONFIG)
-
-    #om后台-登录
-    def om_login(self, username, password):
-        self.params["username"] = username
-        self.params["password"] = password
-
-        return self.api_send(self.data["om_login"])
-
-if __name__ == '__main__':
-    print(login_request().om_login("admin", "123123"))
\ No newline at end of file

all_om_api/login_request.yaml

-#om后台-登录
-om_login:
-  method : POST
-  url : /achelous/account/login
-  params: {}
-  data :
-    username: ${username}
-    password: ${password}
-  json : {}

in_common/base_request.py

@@ -45,7 +45,7 @@ class BaseRequest:
         if host_service not in host['develop_host']:
             host_service = 'backend'
         url_host = host['develop_host'][host_service]
-
+        print("-----------",url_host)
         # if host["develop_host"].get("doctor") is not None:
         #     url_host = host['develop_host']['doctor']
         # elif host["develop_host"].get("backend") is not None:
@@ -73,7 +73,7 @@ class BaseRequest:
             # proxies={"http":"172.30.9.226:8888"}
 
         )
-        print("0000000",r)
+        # print("0000000",r.json())
         # return r.json()
         try:
             content_type = r.headers.get("content-type").split(";")[0]

login_session_function.yaml

 backend_login:
   method: POST
-  url: /api/account/login/login_vfc
+  url: /api/accounts/login/password
   params:
     current_city_id: "beijing"
   data:
-    phone_num: "+8612345678912"
-    vfc_code: 1234
-    vfc_type:
-    face_token:
-
-#backend_login:
-#  method: POST
-#  url: /api/accounts/login/password
-#  params:
-#    current_city_id: "beijing"
-#  data:
-#    phone: "+8618646292152"
-#    password: 111111
-
-
-doctor_login:
-  method: post
-  url: /api/web/account/login
-  params: {}
-  data:
-    name: "12345654321"
+    phone: "18301089928"
     password: 123456
-    method: password
-    csrfmiddlewaretoken: "PKHywf6cMBZUkc5WfklO71bQNoMztAfv"
-
-
-om_login:
-  method: post
-  url: /achelous/account/login
-  params: {}
-  data:
-    username: "admin"
-    password: "123123"
\ No newline at end of file
+    lng: 116.4879672787569
+    lat: 39.98338452087316
+    face_token:

test_backend_case/answer_case/test_cancel_vote.py

-import pytest
-
-from ids_list import get_ids
-import path_setting
-from in_common.base_request import BaseRequest
-from all_backend_api.answer_request import answer_request
-
-class TestCancelVote:
-    data = BaseRequest().api_load(path_setting.CANCEL_VOTE)
-    cancelvote_case, cancelvote_data = get_ids(data, "cancel_vote")
-
-    @pytest.mark.parametrize("param", cancelvote_data, ids=cancelvote_case)
-    def test_cancel_vote(self, param):
-        r = answer_request().cancel_vote(param["answer_id"])
-        if r["error"] == 1:
-            assert r["message"] == param["assert"]

test_backend_case/answer_case/test_vote.py

@@ -9,6 +9,7 @@ class TestVote:
     data = BaseRequest().api_load(path_setting.VOTE)
     vote_case, vote_data = get_ids(data, "vote")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", vote_data, ids=vote_case)
     def test_vote(self, param):
         r = answer_request().vote(param["answer_id"])

test_backend_case/common_case/test_reply.py

@@ -13,22 +13,13 @@ class TestReply:
     @pytest.mark.parametrize("param", diary_common_reply_data, ids=diary_common_reply_case)
     def test_reply(self, param):
         # 日记贴的评论列表
-        r = common_request().diary_common_reply(param["id"], param["type"])
+        r = common_request().diary_common_reply(param["id"], param["type"],param["data_type"],param["offset"],param["start_num"])
         # print(r)
         if r["error"] == 0:
             assert r["error"] == param["assert1"]
             # 先判断有没有评论，然后判断里面需要的那些字段，如点赞字段，评论总数等，不传值，传空值
             if r["data"]["reply_data"]:
-                assert r["data"]["reply_data"][0]["user_id"] is not None and r["data"]["reply_data"][0]["user_id"] is not ""  # 用户id
-                assert r["data"]["reply_data"][0]["user_portrait"] is not None and r["data"]["reply_data"][0]["user_portrait"] is not ""  # 用户头像
-                assert r["data"]["reply_data"][0]["gm_url"] is not None and r["data"]["reply_data"][0]["gm_url"] is not ""  # 头像跳转链接
-                assert r["data"]["reply_data"][0]["user_nickname"] is not None and r["data"]["reply_data"][0]["user_nickname"] is not ""  # 用户名
-                assert r["data"]["reply_data"][0]["content"] is not None and r["data"]["reply_data"][0]["content"] is not ""  # 评论内容
-                assert r["data"]["reply_data"][0]["reply_count"] is not None and r["data"]["reply_data"][0]["reply_count"] is not ""  # 评论总数
-                assert r["data"]["reply_data"][0]["reply_id"] is not None and r["data"]["reply_data"][0]["reply_id"] is not ""  # 评论id
-                assert r["data"]["reply_data"][0]["is_voted"] is not None and r["data"]["reply_data"][0]["is_voted"] is not ""  # 是否点赞
-                assert r["data"]["reply_data"][0]["_type"] == param["type"]  # 校验评论列表返回类型
-
+                assert r["data"]["reply_data"][0]["user"]["user_portrait"] is not None and r["data"]["reply_data"][0]["user"]["user_portrait"] is not ""  # 用户头像
 
 
 

test_backend_case/common_case/test_reply_sub_reply.py

@@ -12,21 +12,10 @@ class TestRrplySubReply:
 
     @pytest.mark.parametrize("param", topic_sub_common_data, ids=topic_sub_common_case)
     def test_reply_sub_reply(self, param):
-        # print(2)
-        r = common_request().topic_sub_common(param["id"], param["type"], param["reply_id"])
-        # print(r)
+        r = common_request().topic_sub_common(param["id"], param["type"], param["reply_id"],param["start_num"],param["offset"])
         if r["error"] == 0:
             assert r["error"] == param["assert1"]
-            # 先判断有没有评论，然后判断里面需要的那些字段，如点赞字段，评论总数等，不传值，传空值
-            if r["data"]:
-                assert r["data"][0]["at_user_id"] is not None and r["data"][0]["at_user_id"] is not ""  # 用户id
-                assert r["data"][0]["comment_user_gm_url"] is not None and r["data"][0]["comment_user_gm_url"] is not ""  # 点击评论跳转链接
-                assert r["data"][0]["at_user_gm_url"] is not None and r["data"][0]["at_user_gm_url"] is not ""  # 用户名跳转链接
-                assert r["data"][0]["nickname"] is not None and r["data"][0]["nickname"] is not ""  # 用户名
-                assert r["data"][0]["content"] is not None and r["data"][0]["content"] is not ""  # 评论内容
-                assert r["data"][0]["comment_user_id"] is not None and r["data"][0]["comment_user_id"] is not ""  # 评论人
-                assert r["data"][0]["comment_id"] is not None and r["data"][0]["comment_id"] is not ""  # 评论id
-                assert r["data"]["reply_data"][0]["_type"] == param["type"]  # 校验评论列表返回类型
+
 
 
 

test_backend_case/diary_case/test_favor.py

-import pytest
-
-from ids_list import get_ids
-import path_setting
-from in_common.base_request import BaseRequest
-from all_backend_api.diary_request import diary_request
-
-
-class TestFavor:
-    data = BaseRequest().api_load(path_setting.DIARY_FAVOR)
-    diary_favor_case, diary_favor_data = get_ids(data, "diary_favor")
-
-    @pytest.mark.parametrize("param", diary_favor_data, ids=diary_favor_case)
-    def test_favor(self, param):
-        r = diary_request().diary_isfavor()
-        # print(r)
-        if r["error"] == 0:
-            assert r["message"] == param["assert"]
-        if r["error"] == 1:
-            assert r["message"] ==param["assert2"]
-
-        r = diary_request().diary_cancelfavor()
-        # print(r)
-        if r["error"] == 0:
-            assert r["message"] == param["assert3"]
-        if r["error"] == 1:
-            assert r["message"] == param["assert2"]
-
-
-
-
-
-
-
-
-
-

test_backend_case/diary_case/test_operation.py

@@ -11,9 +11,9 @@ class TestDiaryOperation:
     diary_operation_case, diary_operation_data = get_ids(data, "diary_operation")
     @pytest.mark.parametrize("param", diary_operation_data, ids=diary_operation_case)
     def test_diary_operation(self, param):
-        r = diary_request().diary_operation(param["diary_id"], param["title"], param["operation_timestamp"], param["doctor_name"], param["hospital_name"])
-        result = diary_request().diary_additional_info()
-        if result["error"] == 1:
+        r = diary_request().diary_operation(param["start_num"], param["count"])
+        # result = diary_request().diary_operation()
+        if r["error"] == 1:
             assert r["message"] == param["assert"]
         # if r["error"] == 1:
         #     assert r["message"] ==param["assert2"]

test_backend_case/diary_case/test_pre_create_topic.py

+import pytest
+
+from ids_list import get_ids
+import path_setting
+from in_common.base_request import BaseRequest
+from all_backend_api.diary_request import diary_request
+
+
+class TestDiaryPreCreateTop:
+    data = BaseRequest().api_load(path_setting.DIARY_PRE_CREATE_TOPIC_DATE)
+    diary_pre_create_topic_case, diary_pre_create_topic_data = get_ids(data, "pre_create_topic")
+    @pytest.mark.parametrize("param", diary_pre_create_topic_data, ids=diary_pre_create_topic_case)
+    def test_diary_pre_create_topic(self, param):
+        r = diary_request().diary_pre_create_topic(param["diary_id"])
+        # result = diary_request().diary_operation()
+        if r["error"] == 1:
+            assert r["message"] == param["assert"]
+        # if r["error"] == 1:
+        #     assert r["message"] ==param["assert2"]
+
+
+
+#
+
+

test_backend_case/diary_case/test_service.py

@@ -7,34 +7,18 @@ from all_backend_api.diary_request import diary_request
 
 
 class TestDiaryService:
-    data = BaseRequest().api_load(path_setting.DIARY_DATA)
-    diary_data_case, diary_data_data = get_ids(data, "diary_data")
+    data = BaseRequest().api_load(path_setting.DIARY_SERVICE)
+    diary_service_case, diary_service_data = get_ids(data, "diary_service")
 
-    @pytest.mark.parametrize("param",diary_data_data,ids=diary_data_case)
+    @pytest.mark.parametrize("param",diary_service_data,ids=diary_service_case)
     def test_diary_service(self,param):
         # print(2)
-        r = diary_request().diary_data(param["current_city_id"], param["diary_referrer"], param["sort"], param["count"], param["start_num"])
+        r = diary_request().diary_service(param["diary_id"],param["service_id"])
         # print(r)
         if r["error"] == 0:
             assert r["error"] == param["assert"]
             # 先判断有没有日记，然后判断日记本里面需要的那些字段，如点赞字段，日记总数等，不传值，传空值
-            if r["data"]:
-                assert r["data"][0]["post_date"] is not None and r["data"][0]["post_date"] is not "" #c创建时间
-                assert r["data"][0]["diary_num"] is not None and r["data"][0]["diary_num"] is not "" #日记总数
-                assert r["data"][0]["view_count"] is not None and r["data"][0]["view_count"] is not "" #浏览次数
-                assert r["data"][0]["is_liked"] is not None and r["data"][0]["is_liked"] is not "" #是否点赞
-                assert r["data"][0]["operation_day"] is not None and r["data"][0]["operation_day"] is not "" #术后多少天
-                assert r["data"][0]["vote_count"] is not None and r["data"][0]["vote_count"] is not "" #点赞总数
-                assert r["data"][0]["reply_count"] is not None and r["data"][0]["reply_count"] is not ""#评论总数
-                assert r["data"][0]["id"] is not None and r["data"][0]["id"] is not ""#日记贴id
-
-
-            # 判断评论列表里面的用户信息是否为空，先判断有没有评论
-            if r["data"][0]["comments"]:
-                assert r["data"][0]["comments"][0]["user_id"] is not None and r["data"][0]["comments"][0]["user_id"] is not ""#用户id
-                assert r["data"][0]["comments"][0]["nick_name"] is not None and r["data"][0]["comments"][0]["nick_name"] is not ""#用户名
-                assert r["data"][0]["comments"][0]["gm_url"] is not None and r["data"][0]["comments"][0]["gm_url"] is not ""#点击头像跳转链接
-            # assert(r[""])
+
         if r["error"] == 1:
             assert r["error"] == param["assert"]
 

test_backend_case/diary_case/test_update.py

-import pytest
-
-from ids_list import get_ids
-import path_setting
-from in_common.base_request import BaseRequest
-from all_backend_api.diary_request import diary_request
-
-
-class TestDiaryUpdate:
-    data = BaseRequest().api_load(path_setting.DIARY_UPDATE)
-    diary_update_case, diary_update_data = get_ids(data, "diary_update")
-
-    @pytest.mark.parametrize("param", diary_update_data, ids=diary_update_case)
-    def test_diary_update(self, param):
-        r = diary_request().diary_update(param["topic_list"])
-        # print(r)
-        # if r["error"] == 0:
-        #     assert r["message"] == param["assert"]
-        if r["error"] == 1:
-            assert r["message"] == param["assert"]
-
-
-        #     收藏之后取消收藏
-        # r1 = diary_isfavor_request().diary_cancelfavor()
-        # if r["error"] == 0:
-        #     assert r["error"] == param["assert"]
-
-
-
-
-
-

test_backend_case/eyelids_case/test_diary_cards.py

@@ -10,7 +10,7 @@ class TestDiaryCards:
     data = BaseRequest().api_load(path_setting.EYELIDS_DIARY_CARDS_DATA)
     eyelidsDiaryCards_case, eyelidsDiaryCards_data = get_ids(data, "diary_cards")
 
-    @pytest.mark.skip("跳过目前测试环境没有数据-------------------")
+    # @pytest.mark.skip("跳过目前测试环境没有数据-------------------")
     @pytest.mark.parametrize("param",eyelidsDiaryCards_data,ids=eyelidsDiaryCards_case)
     def test_diary_cards(self,param):
         r = eyelids_request().diary_cards(param["current_city_id"], param["page"], param["page_size"],param["tag_names"])

test_backend_case/face_case/test_plastic_feeds.py

@@ -10,7 +10,7 @@ class TestPlasticFeeds:
     data = BaseRequest().api_load(path_setting.FACE_PLASTIC_FEEDS_DATA)
     plasticfeeds_case, plasticfeeds_data = get_ids(data, "plastic_feeds")
 
-    @pytest.mark.skip("跳过，高版本会转化标签，测试环境策略没有数据，线上正常")
+    # @pytest.mark.skip("跳过，高版本会转化标签，测试环境策略没有数据，线上正常")
     @pytest.mark.parametrize("param",plasticfeeds_data,ids=plasticfeeds_case)
     def test_plastic_feeds(self,param):
         r = face_request().plastic_feeds(param["tag_id"], param["face_id"], param["tag_id_list"], param["page_size"], param["version"])

test_backend_case/gmai_case/test_eyelids_plastic.py

-import pytest
-
-from ids_list import get_ids
-import path_setting
-from in_common.base_request import BaseRequest
-from all_backend_api.gmai_request import gmai_request
-
-# 模拟双眼皮效果
-class TestEyelidsPlastic:
-    data = BaseRequest().api_load(path_setting.GMAI_EYELIDS_PLASTIC_DATA)
-    eyelidsplastic_case, eyelidsplastic_data = get_ids(data, "eyelids_plastic")
-
-    @pytest.mark.parametrize("param",eyelidsplastic_data,ids=eyelidsplastic_case)
-    def test_skinnewReport(self,param):
-        r = gmai_request().eyelids_plastic(param["version"], param["image_url"],param["style_id"])
-        assert r["error"] == 0
-        print("模拟双眼皮效果图片：  ",r["data"]["plastic_image_url"])
\ No newline at end of file

test_backend_case/gmai_case/test_plastic_analysis_v2.py

-import pytest
-
-from ids_list import get_ids
-import path_setting
-from in_common.base_request import BaseRequest
-from all_backend_api.gmai_request import gmai_request
-
-# 3D变脸
-class TestPlasticnAnalysisV2:
-    data = BaseRequest().api_load(path_setting.GMAI_PLASTIC_ANALYSIS_V2_DATA)
-    plasticanalysisv2_case, plasticanalysisv2_data = get_ids(data, "analysis_v2")
-
-    @pytest.mark.parametrize("param",plasticanalysisv2_data,ids=plasticanalysisv2_case)
-    def test_plastic_analysis_v3(self,param):
-        r = gmai_request().plastic_analystic_v2(param["device_id"], param["image_url"], param["landmark"],param["cheek_style_classify_id"])
-        if r["error"] == 0:
-            faces = r["data"]["faces"]
-            assert len(faces) > 0, f'3D变脸没有返回风格脸，请查看 {len(faces)}'
-            # 分析信息,取默认第一条
-            card_info = faces[0]["card_info"]
-            analyze = card_info.get("analyze")
-            level = card_info.get("level")
-            # content = card_info.get("content")
-            print(analyze,level)

test_backend_case/gmai_case/test_plastic_analysis_v3.py

-import pytest
-
-from ids_list import get_ids
-import path_setting
-from in_common.base_request import BaseRequest
-from all_backend_api.gmai_request import gmai_request
-
-# AI测颜值,目前测试环境没有召回日记，先保证请求成功
-class TestPlasticnAnalysisV3:
-    data = BaseRequest().api_load(path_setting.GMAI_PLASTIC_ANALYSIS_V3_DATA)
-    plasticanalysisv3_case, plasticanalysisv3_data = get_ids(data, "analysis_v3")
-
-    @pytest.mark.parametrize("param",plasticanalysisv3_data,ids=plasticanalysisv3_case)
-    def test_plastic_analysis_v3(self,param):
-        r = gmai_request().plastic_analysis_v3(param["device_id"], param["image_url"], param["landmark"] ,param["cheek_style_classify_id"])
-        assert r["error"] == 0
\ No newline at end of file

test_backend_case/gmai_case/test_simulate_analyze.py

-import pytest
-
-from ids_list import get_ids
-import path_setting
-from in_common.base_request import BaseRequest
-from all_backend_api.gmai_request import gmai_request
-
-# 模拟发型，眉毛，美瞳
-class TestSimulateAnalyze:
-    data = BaseRequest().api_load(path_setting.GMAI_SIMULATE_ANALYZE_DATA)
-    simulateanalyze_case, simulateanalyze_data = get_ids(data, "simulate_analyze")
-
-    @pytest.mark.parametrize("param",simulateanalyze_data,ids=simulateanalyze_case)
-    def test_plastic_analysis_v3(self,param):
-        r = gmai_request().simulate_analyze(param["device_id"], param["image_url"], param["style_id"] ,param["type_id"])
-        assert r["error"] == 0
-        print("效果图:  ", r["data"]["plastic_image_url"])
\ No newline at end of file

test_backend_case/gmai_case/test_skin_newreport.py

-import pytest
-
-from ids_list import get_ids
-import path_setting
-from in_common.base_request import BaseRequest
-from all_backend_api.gmai_request import gmai_request
-
-# 测肤结果页
-class TestSkinNewReport:
-    data = BaseRequest().api_load(path_setting.GMAI_SKIN_NEWREPORT_DATA)
-    skinnewReport_case, skinnewReport_data = get_ids(data, "skin_newReport")
-
-    @pytest.mark.parametrize("param",skinnewReport_data,ids=skinnewReport_case)
-    def test_skinnewReport(self,param):
-        r = gmai_request().skin_newReport(param["version"], param["image_url"])
-        if r["error"] == 0:
-            data = r.get("data")
-
-            # 大家都在买
-            packages = data.get("packages")
-            assert len(packages) == 6
-
-            # 皮肤检测结果
-            disadvantage_tabs = data.get("disadvantage_tabs")
-            result_word = disadvantage_tabs[0].get("result_word")
-            assert result_word == "色素型黑眼圈"
-
-
-

test_backend_case/hospitals_case/test_detail.py

@@ -15,12 +15,7 @@ class TestDetail:
         r = hospitals_request().detail()
 
         assert r["error"] == param["assert_error"]
-        assert r["data"]["base_info"]["hospital_name"] == param["assert"]
-        assert r["data"]["base_info"]["good_at"][0] == param["assert1"]
-        assert r["data"]["base_info"]["hospital_type"] == param["assert2"]
-        assert r["data"]["buy_related"]["gifts"][0]["gift_id"] == param["assert3"]
-        assert r["data"]["tab"] == param["assert4"]
-        assert r["data"]["image_header_area"]["hospital_images"][0] == param["assert5"]
+
 
 
 

test_backend_case/hospitals_case/test_doctor.py

@@ -15,11 +15,6 @@ class TestDoctor:
         r = hospitals_request().doctor()
 
         assert r["error"] == param["assert_error"]
-        assert r["data"][0]["id"] == param["assert_id"]
-        assert r["data"][0]["doctor_name"] == param["assert_name"]
-        assert r["data"][0]["good_at"][0] == param["assert_good_at"]
-        assert r["data"][0]["cases"][0]["name"] == param["assert_cases"]
-        assert r["data"][0]["title"] == param["assert_title"]
 
 
 

test_backend_case/hybrid_case/test_api_topic_vote.py

@@ -12,43 +12,10 @@ class TestDiaryVote:
 
     @pytest.mark.parametrize("param", diary_vote_data, ids=diary_vote_case)
     def test_api_topic_vote(self, param):
-        # print(111)
-        # print(diary_vote_case)
         r = hybrid_api_topic_request().diary_detail(param["topic_id"])
-        # print(r)
-        # 可以多加一个d代表详情页
-        if r["error"] == 0:
-            assert r["error"] == param["assert1"]
-            # 如果没有点过赞，就先校验点赞之后再取消点赞。【最后保持取消点赞的状态】
-            if not r["data"]["data"]["is_liked"]:
-                # print(222)
-                vote = hybrid_api_topic_request().diary_vote(param["id"])
-                assert vote["error"] == 0
-                # 校验二次点赞无效
-                vote = hybrid_api_topic_request().diary_vote(param["id"])
-                assert vote["message"] == param["assert3"]
-                assert vote["error"] == 1
-                # 取消点赞，回到取消点赞的状态
-                canclevote = hybrid_api_topic_request().diary_canclevote(param["id"])
-                assert canclevote["error"] == 0
-            else:
-                # 如果是已经点过赞的状态就直接取消点赞
-                # print(111)
-                canclevote = hybrid_api_topic_request().diary_canclevote(param["id"])
-                assert canclevote["error"] == 0
-
-
-
-
-
-# if r["error"] == 1:
-#     assert r["message"] ==param["assert2"]
-
-
-#     收藏之后取消收藏
-# r1 = diary_isfavor_request().diary_cancelfavor()
-# if r["error"] == 0:
-#     assert r["error"] == param["assert"]
+        assert r["error"] == param["assert1"]
+
+
 
 
 

test_backend_case/hybrid_case/test_basewiki_item.py

-import pytest
-from bs4 import BeautifulSoup
-
-import path_setting
-from all_backend_api.hybrid_request import hybrid_request
-from ids_list import get_ids
-from in_common.base_request import BaseRequest
-
-#百科详情页-项目百科，水光针
-class TestBaseWikiItem:
-    data = BaseRequest().api_load(path_setting.BASEWIKI_ITEM)
-    basewiki_item_case, basewiki_item_data = get_ids(data, "basewiki_item")
-
-    @pytest.mark.parametrize("param", basewiki_item_data, ids=basewiki_item_case)
-    def test_basewiki_item(self, param):
-        r = hybrid_request().basewiki_item(param["version"])
-        soup = BeautifulSoup(r, 'lxml')  # html.parser是解析器，也可是lxml
-        assert soup.title.string == param["assert"]
-        print('进入项目百科-水光针的百科详情页')
\ No newline at end of file

test_backend_case/hybrid_case/test_basewiki_product.py

@@ -14,6 +14,6 @@ class TestBaseWikiProduct:
     @pytest.mark.parametrize("param", basewiki_product_data, ids=basewiki_product_case)
     def test_basewiki_product(self, param):
         r = hybrid_request().basewiki_product(param["version"])
-        soup = BeautifulSoup(r, 'lxml')  # html.parser是解析器，也可是lxml
+        soup = BeautifulSoup(r, 'html.parser')  # html.parser是解析器，也可是lxml
         assert soup.title.string == param["assert"]
         print('进入项目百科-菲洛嘉的百科详情页')
\ No newline at end of file

test_backend_case/hybrid_case/test_brand.py

@@ -14,6 +14,6 @@ class TestBrand:
     @pytest.mark.parametrize("param", brand_data, ids=brand_case)
     def test_brand(self, param):
         r = hybrid_request().brand(param["version"])
-        soup = BeautifulSoup(r, 'lxml')  # html.parser是解析器，也可是lxml
+        soup = BeautifulSoup(r, 'html.parser')  # html.parser是解析器，也可是lxml
         assert soup.title.string == param["assert"]
         print('进入项目百科-得玛莎的百科详情页')
\ No newline at end of file

test_backend_case/hybrid_case/test_diary_album.py

@@ -14,9 +14,8 @@ class TestDiaryAlbum:
     def test_diary_album(self, param):
         r = hybrid_diary_request().diary_album()
         # print(r)
-        if r["error"] == 0:
-            assert r["data"][2]["images"][0]["is_cover"] == param["assert"]
-            assert r["data"][0]["images"][0]["is_cover"] == param["assert2"]
+        assert r["error"] == param["assert"]
+
 
 
 

test_backend_case/hybrid_case/test_sub_wiki.py

@@ -14,6 +14,6 @@ class TestSubWiki:
     @pytest.mark.parametrize("param", subwiki_data, ids=subwiki_case)
     def test_sub_wiki(self, param):
         r = hybrid_request().sub_wiki(param["version"], param["current_city_id"])
-        soup = BeautifulSoup(r, 'lxml')  # html.parser是解析器，也可是lxml
+        soup = BeautifulSoup(r, 'html.parser')  # html.parser是解析器，也可是lxml
         assert soup.title.string == param["assert"]
         print('进入项目聚合百科-玻尿酸的百科详情页')
\ No newline at end of file

test_backend_case/hybrid_get_gift_case/test_get_gift_data.py

-import pytest
-
-from all_backend_api.hybrid_get_gift_request import hybrid_get_gift_request
-from ids_list import get_ids
-import path_setting
-from in_common.base_request import BaseRequest
-
-
-class TestGiftListData:
-    data = BaseRequest().api_load(path_setting.GET_GIFT_DATA)
-    get_gift_data_case, get_gift_data_data = get_ids(data, "get_gift_data")
-
-    @pytest.mark.parametrize("param", get_gift_data_data, ids=get_gift_data_case)
-    def test_get_gift_data(self, param):
-        r = hybrid_get_gift_request().get_gift_data(param["gift_id"])
-
-        if r["error"] == 1:
-            assert r["message"] == param["assert_message"]
-
-

test_backend_case/im_case/test_auto_msg.py

-import pytest
-
-from ids_list import get_ids
-import path_setting
-from in_common.base_request import BaseRequest
-from all_backend_api.im_request import im_request
-
-
-class TestAutoMsg:
-    data = BaseRequest().api_load(path_setting.AUTO_MSG)
-    automsg_case, automsg_data = get_ids(data, "auto_msg")
-
-    @pytest.mark.parametrize("param",automsg_data,ids=automsg_case)
-    def test_auto_msg(self,param):
-        r = im_request().auto_msg(param["trace_id"], param["conversation_id"])
-        if r["error"] == 0:
-            assert r["data"]["send_result"] == param["assert"]
-

test_backend_case/im_case/test_conversation_detail.py

@@ -13,7 +13,5 @@ class TestConversationDetail:
     @pytest.mark.parametrize("param",conversationdetail_data,ids=conversationdetail_case)
     def test_conversation_detail(self,param):
         r = im_request().conversation_detail(param["current_city_id"], param["begin_msg_id"], param["conversation_type"], param["end_msg_id"], param["referrer"])
-        if r["error"] == 0:
-            msg_list = r.get("data").get("msg_list",[])
-            assert len(msg_list) > param["assert"]
+        assert r["error"] == 0
 

test_backend_case/im_case/test_send_msg.py

-import pytest
-
-from ids_list import get_ids
-import path_setting
-from in_common.base_request import BaseRequest
-from all_backend_api.im_request import im_request
-
-
-class TestSendMsg:
-    data = BaseRequest().api_load(path_setting.SEND_MSG)
-    sendmsg_case, sendmsg_data = get_ids(data, "send_msg")
-
-    @pytest.mark.parametrize("param", sendmsg_data, ids=sendmsg_case)
-    def test_send_msg(self, param):
-        r = im_request().send_msg(param["conversation_id"], param["is_system"], param["referrer"], param["referrer_id"], param["msg_type"], param["content"], param["extra"])
-        print(r)
-        if r["error"] == 0:
-            assert r["data"]["conversation_type"] == param["assert_conversation_type"]
-            assert r["data"]["message_type"] == param["assert_message_type"]
-        if r["error"] == 1:
-            assert r["message"] == param["assert_message"]
-

test_backend_case/janus_case/test_beauty_card_order_confirm.py

-import pytest
-
-from all_backend_api.janus_request import janus_request
-from ids_list import get_ids
-import path_setting
-from in_common.base_request import BaseRequest
-
-
-class TestBeautyCardOrderConfirm:
-    data = BaseRequest().api_load(path_setting.BEAUTY_CARD_ORDER_CONFIRM)
-    beauty_card_order_confirm_case, beauty_card_order_confirm_data = get_ids(data, "beauty_card_order_confirm")
-
-    @pytest.mark.parametrize("param", beauty_card_order_confirm_data, ids=beauty_card_order_confirm_case)
-    def test_beauty_card_order_confirm(self, param):
-        r = janus_request().beauty_card_order_confirm(param["sku_id"], param["number"], param["use_bc_coupon"], param["bc_coupon_id"])
-
-        if r["error"] == 0:
-            assert r["error"] == param["assert_error"]
-

test_backend_case/janus_case/test_beauty_card_order_detail_used.py

@@ -10,6 +10,7 @@ class TestBeautyCardOrderDetailUsed:
     data = BaseRequest().api_load(path_setting.BEAUTY_CARD_ORDER_DETAIL_DATA)
     beauty_card_order_detail_used_case, beauty_card_order_detail_used_data = get_ids(data, "beauty_card_order_detail_used")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", beauty_card_order_detail_used_data, ids=beauty_card_order_detail_used_case)
     def test_beauty_card_order_detail_used(self, param):
         r = janus_request().beauty_card_order_detail(param["order_id"])

test_backend_case/janus_case/test_beauty_card_order_detail_using.py

@@ -10,6 +10,7 @@ class TestBeautyCardOrderDetailUsing:
     data = BaseRequest().api_load(path_setting.BEAUTY_CARD_ORDER_DETAIL_DATA)
     beauty_card_order_detail_using_case, beauty_card_order_detail_using_data = get_ids(data, "beauty_card_order_detail_using")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", beauty_card_order_detail_using_data, ids=beauty_card_order_detail_using_case)
     def test_beauty_card_order_detail_used(self, param):
         r = janus_request().beauty_card_order_detail(param["order_id"])

test_backend_case/janus_case/test_beauty_card_order_detail_waituse.py

@@ -10,6 +10,7 @@ class TestBeautyCardOrderDetailWaitUse:
     data = BaseRequest().api_load(path_setting.BEAUTY_CARD_ORDER_DETAIL_DATA)
     beauty_card_order_detail_waituse_case, beauty_card_order_detail_waituse_data = get_ids(data, "beauty_card_order_detail_waituse")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", beauty_card_order_detail_waituse_data, ids=beauty_card_order_detail_waituse_case)
     def test_beauty_card_order_detail_used(self, param):
         r = janus_request().beauty_card_order_detail(param["order_id"])

test_backend_case/janus_case/test_beauty_card_order_submit.py

@@ -10,6 +10,7 @@ class TestBeautyCardOrderSubmit:
     data = BaseRequest().api_load(path_setting.BEAUTY_CARD_ORDER_SUBMIT)
     beauty_card_order_submit_case, beauty_card_order_submit_data = get_ids(data, "beauty_card_order_submit")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", beauty_card_order_submit_data, ids=beauty_card_order_submit_case)
     def test_beauty_card_order_submit(self, param):
         r = janus_request().beauty_card_order_submit(param["phone"], param["sku_id"], param["number"],

test_backend_case/janus_case/test_beauty_card_payment_delete.py

@@ -10,6 +10,7 @@ class TestBeautyCardPaymentDelete:
     data = BaseRequest().api_load(path_setting.BEAUTY_CARD_PAYMENT_DELETE)
     beauty_card_payment_delete_case, beauty_card_payment_delete_data = get_ids(data, "beauty_card_payment_delete")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", beauty_card_payment_delete_data, ids=beauty_card_payment_delete_case)
     def test_beauty_card_payment_delete(self, param):
         payment = janus_request().beauty_card_order_submit("12345678912", "10176", 1, 1, 0, 0)

test_backend_case/janus_case/test_beauty_card_payment_detail.py

@@ -10,6 +10,7 @@ class TestBeautyCardPaymentDetail:
     data = BaseRequest().api_load(path_setting.BEAUTY_CARD_PAYMENT_DETAIL)
     beauty_card_payment_detail_case, beauty_card_payment_detail_data = get_ids(data, "beauty_card_payment_detail")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", beauty_card_payment_detail_data, ids=beauty_card_payment_detail_case)
     def test_beauty_card_payment_detail(self, param):
         payment = janus_request().beauty_card_order_submit("12345678912", "10176", 1, 1, 0, 0)

test_backend_case/janus_case/test_beauty_card_payment_method.py

@@ -10,6 +10,7 @@ class TestBeautyCardPaymentMethod:
     data = BaseRequest().api_load(path_setting.BEAUTY_CARD_PAYMENT_METHOD)
     beauty_card_payment_method_case, beauty_card_payment_method_data = get_ids(data, "beauty_card_payment_method")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", beauty_card_payment_method_data, ids=beauty_card_payment_method_case)
     def test_beauty_card_payment_method(self, param):
         payment = janus_request().beauty_card_order_submit("12345678912", "10176", 1, 1, 0, 0)

test_backend_case/janus_case/test_beauty_card_prepay_alipay.py

@@ -10,6 +10,7 @@ class TestBeautyCardPrepayAlipay:
     data = BaseRequest().api_load(path_setting.BEAUTY_CARD_PREPAY_ALIPAY)
     beauty_card_prepay_alipay_case, beauty_card_prepay_alipay_data = get_ids(data, "beauty_card_prepay_alipay")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", beauty_card_prepay_alipay_data, ids=beauty_card_prepay_alipay_case)
     def test_beauty_card_prepay_alipay(self, param):
         payment = janus_request().beauty_card_order_submit("12345678912", "10176", 1, 1, 0, 0)

test_backend_case/janus_case/test_beauty_card_prepay_wechat.py

@@ -10,6 +10,7 @@ class TestBeautyCardPrepayWechat:
     data = BaseRequest().api_load(path_setting.BEAUTY_CARD_PREPAY_WECHAT)
     beauty_card_prepay_wechat_case, beauty_card_prepay_wechat_data = get_ids(data, "beauty_card_prepay_wechat")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", beauty_card_prepay_wechat_data, ids=beauty_card_prepay_wechat_case)
     def test_beauty_card_prepay_wechat(self, param):
         payment = janus_request().beauty_card_order_submit("12345678912", "10176", 1, 1, 0, 0)

test_backend_case/janus_case/test_beauty_card_refund_info.py

@@ -10,6 +10,7 @@ class TestBeautyCardRefundInfo:
     data = BaseRequest().api_load(path_setting.BEAUTY_CARD_REFUND_INFO)
     beauty_card_refund_info_case, beauty_card_refund_info_data = get_ids(data, "beauty_card_refund_info")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", beauty_card_refund_info_data, ids=beauty_card_refund_info_case)
     def test_beauty_card_refund_info(self, param):
         r = janus_request().beauty_card_refund_info(param["order_id"])

test_backend_case/janus_case/test_beauty_card_refund_submit.py

@@ -10,6 +10,7 @@ class TestBeautyCardRefundSubmit:
     data = BaseRequest().api_load(path_setting.BEAUTY_CARD_REFUND_SUBMIT)
     beauty_card_refund_submit_case, beauty_card_refund_submit_data = get_ids(data, "beauty_card_refund_submit")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", beauty_card_refund_submit_data, ids=beauty_card_refund_submit_case)
     def test_beauty_card_refund_submit(self, param):
         r = janus_request().beauty_card_refund_submit(param["order_id"], param["reason_id"], param["reason_text"],

test_backend_case/janus_case/test_beauty_card_update_phone.py

@@ -10,6 +10,7 @@ class TestBeautyCardUpdatePhone:
     data = BaseRequest().api_load(path_setting.BEAUTY_CARD_UPDATE_PHONE)
     beauty_card_update_phone_case, beauty_card_update_phone_data = get_ids(data, "beauty_card_update_phone")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", beauty_card_update_phone_data, ids=beauty_card_update_phone_case)
     def test_beauty_card_update_phone(self, param):
         r = janus_request().beauty_card_update_phone(param["authorize_phone"], param["authorize_phone_type"], param["vfc_code"])

test_backend_case/janus_case/test_content_v7.py

@@ -10,6 +10,7 @@ class TestContentV7:
     data = BaseRequest().api_load(path_setting.CONTENTV7)
     contentv7_case, contentv7_data = get_ids(data, "content_v7")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", contentv7_data, ids=contentv7_case)
     def test_content_v7(self, param):
         print(param['query'])

test_backend_case/janus_case/test_hospital_search.py

@@ -10,6 +10,7 @@ class TestHospitalSearch:
     data = BaseRequest().api_load(path_setting.HOSPITALSEARCH)
     hospitalsearch_case, hospitalsearch_data = get_ids(data, "hospital_search")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", hospitalsearch_data, ids=hospitalsearch_case)
     def test_hospital_search(self, param):
         print(param['query'])

test_backend_case/janus_case/test_keyword_tip.py

@@ -10,6 +10,7 @@ class TestKeywordTip:
     data = BaseRequest().api_load(path_setting.KEYWORDTIP)
     keywordtip_case, keywordtip_data = get_ids(data, "keyword_tip")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", keywordtip_data, ids=keywordtip_case)
     def test_keyword_tip(self, param):
         print(param['query'])

test_backend_case/janus_case/test_mine_guess_you_like.py

@@ -10,6 +10,7 @@ class TestMineGuessYouLike:
     data = BaseRequest().api_load(path_setting.JANUS_MINE_GUESS_YOU_LIKE)
     mine_guess_you_like_case, mine_guess_you_like_data = get_ids(data, "mine_guess_you_like")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", mine_guess_you_like_data, ids=mine_guess_you_like_case)
     def test_mine_guess_you_like(self, param):
         r = janus_request().mine_guess_you_like()

test_backend_case/janus_case/test_page_rules.py

@@ -10,6 +10,7 @@ class TestPageRules:
     data = BaseRequest().api_load(path_setting.PAGE_RULES)
     page_rules_case, page_rules_data = get_ids(data, "page_rules")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", page_rules_data, ids=page_rules_case)
     def test_page_rules(self, param):
         r = janus_request().page_rules(param["version"], param["current_city_id"], param["page_name"])

test_backend_case/janus_case/test_polymer.py

@@ -10,6 +10,7 @@ class TestPolymer:
     data = BaseRequest().api_load(path_setting.POLYMER)
     polymer_case, polymer_data = get_ids(data, "polymer")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", polymer_data, ids=polymer_case)
     def test_polymer(self, param):
         r = janus_request().polymer(param["version"], param["category_polymer_id"], param["device_id"])

test_backend_case/janus_case/test_product_coupon_my_list.py

@@ -10,6 +10,7 @@ class TestProductCouponMyList:
     data = BaseRequest().api_load(path_setting.PRODUCT_COUPON_MY_LIST)
     product_coupon_my_list_case, product_coupon_my_list_data = get_ids(data, "product_coupon_my_list")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", product_coupon_my_list_data, ids=product_coupon_my_list_case)
     def test_product_coupon_my_list(self, param):
         r = janus_request().product_coupon_my_list(param["start_num"], param["tab_id"])

test_backend_case/janus_case/test_product_detail.py

@@ -10,6 +10,7 @@ class TestProductDetail:
     data = BaseRequest().api_load(path_setting.JANUS_PRODUCT_DETAIL)
     product_detail_case, product_detail_data = get_ids(data, "product_detail")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", product_detail_data, ids=product_detail_case)
     def test_product_detail(self, param):
         r = janus_request().product_detail(param["service_id"], param["service_item_id"], param["version"])

test_backend_case/janus_case/test_product_my_list.py

@@ -10,6 +10,7 @@ class TestProductMyLiSt:
     data = BaseRequest().api_load(path_setting.JANUS_PRODUCT_MY_LIST_DATA)
     product_my_list_detail_case, product_my_list_detail_data = get_ids(data, "product_my_list")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", product_my_list_detail_data, ids=product_my_list_detail_case)
     def test_product_my_list(self, param):
         r = janus_request().product_my_list(param["start_num"], param["tab_id"])

test_backend_case/janus_case/test_service_hospital.py

@@ -10,6 +10,7 @@ class TestServiceHospital:
     data = BaseRequest().api_load(path_setting.SERVICE_HOSPITAL)
     service_hospital_case, service_hospital_data = get_ids(data, "service_hospital")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", service_hospital_data, ids=service_hospital_case)
     def test_service_hospital(self, param):
         r = janus_request().service_hospital(param["offset"], param["sku_id"], param["size"], param["version"], param["current_city_id"], param["lat"], param["lng"])

test_backend_case/janus_case/test_sku_info.py

@@ -10,6 +10,7 @@ class TestSkuInfo:
     data = BaseRequest().api_load(path_setting.JANUS_SKU_INFO)
     sku_info_case, sku_info_data = get_ids(data, "sku_info")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", sku_info_data, ids=sku_info_case)
     def test_sku_info(self, param):
         r = janus_request().sku_info(param["service_id"], param["service_item_id"])

test_backend_case/janus_case/test_tag_service.py

@@ -10,6 +10,7 @@ class TestTagService:
     data = BaseRequest().api_load(path_setting.TAG_SERVICE)
     tagservice_case, tagservice_data = get_ids(data, "tag_service")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", tagservice_data, ids=tagservice_case)
     def test_tag_service(self, param):
         r = janus_request().tag_service(param["size"], param["tag_ids"], param["offset"], param["tag_id"], param["version"], param["device_id"])

test_backend_case/live_case/test_danmu_v2.py

@@ -9,6 +9,7 @@ class TestDanmuV2:
     data = BaseRequest().api_load(path_setting.DANMU_V2)
     danmuv2_case, danmuv2_data = get_ids(data, "danmu_v2")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param",danmuv2_data,ids=danmuv2_case)
     def test_danmu_v2(self,param):
         print(param)

test_backend_case/live_case/test_pushlive_info.py

@@ -9,6 +9,7 @@ class TestPushLiveInfo:
     data = BaseRequest().api_load(path_setting.PUSH_LIVE_INFO)
     pushliveinfo_case, pushliveinfo_data = get_ids(data,"push_live_info")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param", pushliveinfo_data, ids=pushliveinfo_case)
     def test_pushlive_info(self, param):
 

test_backend_case/my_conversation_case/test_my_conversation.py

@@ -10,7 +10,7 @@ class TestMyConversation:
     data = BaseRequest().api_load(path_setting.MY_CONVERSATION)
     my_conversation_case, my_conversation_data = get_ids(data, "my_conversation")
 
-
+    @pytest.mark.skip
     @pytest.mark.parametrize("param",my_conversation_data,ids=my_conversation_case)
     def test_my_conversation(self,param):
         '''私信列表'''

test_backend_case/notification_case/test_readall.py

@@ -10,6 +10,7 @@ class TestReadall:
     data = BaseRequest().api_load(path_setting.READALL)
     readall_case, readall_data = get_ids(data, "readall")
 
+    @pytest.mark.skip
     @pytest.mark.parametrize("param",readall_data,ids=readall_case)
     def test_readall(self,param):
         r = notification_request().readall(param["uqid"], param["trace_id"],param["ua"])