def get_create_list(self, result_mapping):
staff_list = result_mapping.get(StaffGenerator.get_key())
role_list = result_mapping.get(RoleGenerator.get_key())
department_list = result_mapping.get(DepartmentGenerator.get_key())
auth_list = []
for staff in staff_list:
if staff.id == 1:
department = department_list[0]
role = role_list[0]
else:
department = random.choice(department_list)
role = random.choice(role_list)
auth_access_department = DictWrapper({})
auth_access_department.staff = staff
auth_access_department.access_id = department.id
auth_access_department.access_type = AccessTypes.DEPARTMENT
auth_access_role = DictWrapper({})
auth_access_role.staff = staff
auth_access_role.access_id = role.id
auth_access_role.access_type = AccessTypes.ROLE
auth_list.append(auth_access_department)
auth_list.append(auth_access_role)
return auth_list
def init(self, obj_info):
obj_infos = []
if type(obj_info) == list:
for obj in obj_info:
obj_infos.append(DictWrapper(obj))
else:
obj_infos.append(DictWrapper(obj_info))
return obj_infos
def summing(cls, measure_shop_qs):
total_sales_sum_list = []
add_order_number_sum_list = []
add_order_total_money_sum_list = []
single_point_total_money_sum_list = []
through_number_sum_list = []
through_money_sum_list = []
total_freight_sum_list = []
sum_data = DictWrapper({})
for measure_shop in measure_shop_qs:
total_sales_sum_list.append(measure_shop.total_sales)
add_order_number_sum_list.append(measure_shop.add_order_number)
add_order_total_money_sum_list.append(
measure_shop.add_order_total_money)
single_point_total_money_sum_list.append(
measure_shop.single_point_total_money)
through_number_sum_list.append(measure_shop.through_number)
through_money_sum_list.append(measure_shop.through_money)
total_freight_sum_list.append(measure_shop.total_freight)
sum_data.total_sales = sum(total_sales_sum_list)
sum_data.add_order_number = sum(add_order_number_sum_list)
sum_data.add_order_total_money = sum(add_order_total_money_sum_list)
sum_data.single_point_total_money = sum(
single_point_total_money_sum_list)
sum_data.through_number = sum(through_number_sum_list)
sum_data.through_money = sum(through_money_sum_list)
sum_data.total_freight = sum(total_freight_sum_list)
sum_data = cls.calculation_byitem(sum_data)
return sum_data
def summing(cls, measure_staff_qs):
new_number_sum_list = []
exhale_number_sum_list = []
call_number_sum_list = []
wechat_number_sum_list = []
sum_data = DictWrapper({})
for measure_staff in measure_staff_qs:
new_number_sum_list.append(measure_staff.new_number)
exhale_number_sum_list.append(measure_staff.exhale_number)
call_number_sum_list.append(measure_staff.call_number)
wechat_number_sum_list.append(measure_staff.wechat_number)
sum_data.new_number = sum(new_number_sum_list)
sum_data.exhale_number = sum(exhale_number_sum_list)
sum_data.call_number = sum(call_number_sum_list)
sum_data.wechat_number = sum(wechat_number_sum_list)
sum_data.call_rate = "0%"
if sum_data.exhale_number > 0:
sum_data.call_rate = "{rate}%".format(rate=str(
round((sum_data.call_number / sum_data.exhale_number *
100), 2)))
return sum_data
def parse(self, all_parms):
data = all_parms.copy()
pro_parms = {}
fields = self.parser.get_fields()
for field, helper in fields.items():
if field in data:
value = data.pop(field)
try:
pro_parms[field] = helper.execute(value)
except Exception as e:
raise pro_errors(ProtocolCodes.PROTOCOL_FORMAT_ERROR,
field,
helper.get_field().__class__.__name__)
else:
raise pro_errors(ProtocolCodes.PROTOCOL_LOST_PARAM, field)
return DictWrapper(pro_parms), DictWrapper(data)
def execute_task(self, group, task):
exec_parms = DictWrapper(json.loads(task.exec_parms))
organization, operator = self.get_shop_infos(exec_parms)
if organization and operator:
organization = self.create_customer_infos(organization, operator)
return organization
return None
def check(self, row_list):
fields = self.get_fields()
row_infos = DictWrapper({})
error_infos = {}
for index, field in enumerate(fields):
cell = row_list[index]
if isinstance(cell, str):
cell = cell.strip()
key, helper = fields[index]
try:
row_infos.update({key: helper.parse(cell)})
except Exception as e:
error_infos.update({key: [helper, index]})
error_msg = ""
if error_infos:
error_info_list = [ helper.get_desc() \
for helper, _ in error_infos.values()]
error_msg = ', '.join(error_info_list)
return row_infos, error_msg
def get_create_list(self, result_mapping):
order_list = result_mapping.get(OrderGenerator.get_key())
service_list = []
for order in order_list:
service = DictWrapper({})
server = StaffHelper().generate()
service.customer = order.customer
service.order = order
service.seller = order._chance.staff
service.server = server
service.end_time = order.create_time + datetime.timedelta(days=365)
service.remark = "服务单备注"
service_list.append(service)
return service_list
def get_create_list(self, result_mapping):
order_list = result_mapping.get(OrderGenerator.get_key())
logistics_list = []
# 暂时一笔订单只发一个
for order in order_list:
logistics = DictWrapper({})
logistics.order = order
logistics.customer = order.customer
logistics.company = LogisticsCompanyHelper().generate()
logistics.number = LogisticsNumberHelper().generate()
logistics.total_quantity = order.total_quantity
logistics.create_time = order.create_time + datetime.timedelta(
days=2)
logistics_list.append(logistics)
return logistics_list
def get_shop_infos(self, shop_infos):
page = pq(url=shop_infos.url, opener=lambda link, **kw:
urllib.request.urlopen(link).read().decode("utf-8"))
infor_board = page.find('.s_major')
if infor_board:
phone, name = infor_board.find('.s_tel').text().split(' ')
address = infor_board.find('.s_add span').text()
organization = DictWrapper({
'name': shop_infos.name,
'site': shop_infos.url,
'city': shop_infos.city,
'industry': '装修',
'source': SourceType.ZYW,
'address': address,
})
operator = DictWrapper({
'name': name,
'phone': phone,
})
return organization, operator
else:
print("error : {}".format(shop_infos))
return None, None
def _get_shop_task(ele_list):
shop_tasks = []
for ele_obj in ele_list:
shop_info = ele_obj.parents('li:first').find('span.l_txt')
a_obj = shop_info.find('.li_tle b a')
shop_name = a_obj.text()
shop_url = a_obj.attr('href')
if shop_name and shop_url:
shop_tasks.append(DictWrapper({
'url': shop_url,
'city': addr,
'name': shop_name
}))
return shop_tasks
def get_shop_infos(self, shop_infos):
url = shop_infos.url
page = pq(url=url, opener=lambda link, **kw:
urllib.request.urlopen(link).read().decode("utf-8"))
infor_board = page.find('.shop_introduce')
if infor_board:
shop = infor_board.find('.temp-company-v span').text().split(' ')[0]
name = infor_board.find('.ico-shop-01').text()
phone = infor_board.find('.ico-shop-02').text()
tel = infor_board.find('.ico-shop-03').text()
wx = infor_board.find('.ico-shop-05').text()
title_list = infor_board.find('.c999').text().split(' ')
content_list = infor_board.find('.con').text().split(' ')
other = dict(zip(title_list, content_list))
relative = infor_board.find('.jyhname').text()
organization = DictWrapper({
'name': shop,
'site': url,
'address': "{} {}".format(shop_infos.address, shop_infos.layer),
'category': shop_infos.category,
'city': "浙江-义务",
'industry': '小商品',
'source': SourceType.YWG,
'other': json.dumps(other),
'relative': relative,
})
operator = DictWrapper({
'name': name,
'phone': phone,
'tel': tel,
'wx': wx,
'phone': phone,
})
return organization, operator
else:
raise Exception("error : {}".format(url))
def hung_measure_forshops(cls, shop_list):
"""店铺挂载店铺绩效"""
current_time = datetime.datetime.now()
day_begin = '%d-%02d-01' % (current_time.year, current_time.month)
day_begin = datetime.datetime.strptime("2018-05-01", '%Y-%m-%d')
day_end = datetime.datetime.strptime("2018-06-01", '%Y-%m-%d')
measure_shop_qs = MeasureShop.search(record_date__range=(day_begin,
day_end))
chance_time = day_begin
init_data = {}
while (chance_time < current_time):
init_data[chance_time.strftime('%Y-%m-%d')] = DictWrapper({})
init_data_item = init_data[chance_time.strftime('%Y-%m-%d')]
init_data_item.total_sales = 0
init_data_item.add_order_number = 0
init_data_item.through_number = 0
init_data_item.through_money = 0
init_data_item.shop = None
chance_time = chance_time + datetime.timedelta(days=1)
shop_mapping = {}
for shop in shop_list:
shop.measure_shop = init_data
shop_mapping[shop.id] = shop
last_day = day_begin + datetime.timedelta(days=-1)
measure_shop_qs = measure_shop_qs.values('shop_id', 'record_date').\
annotate(count = Count('record_date'), sum_total_sales = Sum('total_sales'), sum_add_order_number = Sum('add_order_number'), \
sum_through_number = Sum('through_number'), sum_through_money = Sum('through_money'))
for measure_shop_item in measure_shop_qs:
if measure_shop_item["shop_id"] in shop_mapping:
shop_month_date_item = shop_mapping[
measure_shop_item["shop_id"]].measure_shop[
measure_shop_item["record_date"].strftime('%Y-%m-%d')]
shop_month_date_item.total_sales = measure_shop_item[
"sum_total_sales"]
shop_month_date_item.add_order_number = measure_shop_item[
"sum_add_order_number"]
shop_month_date_item.through_number = measure_shop_item[
"sum_through_number"]
shop_month_date_item.through_money = measure_shop_item[
"sum_through_money"]
return shop_list
def calculate(cls, user_id, role):
cur_time, expire_time = cls._get_time_scope()
random_num = random.randint(1, 99999)
token_str = cls._token_fmt.format(user_id = user_id,\
timestamp = cur_time, random_num = random_num)
token_md5 = hashlib.md5(token_str.encode("utf-8")).hexdigest()
size = int(len(token_md5) / 2)
auth_token = token_md5[:size]
renew_flag = token_md5[size:]
return DictWrapper({
"renew_flag": renew_flag,
"user_id": user_id,
"role": role,
"expire_time": expire_time,
"auth_token": auth_token,
})
def get_create_list(self, result_mapping):
staff_list = result_mapping.get(StaffGenerator.get_key())
account_list = []
for staff in staff_list:
if staff.name == "admin":
username = staff.name
else:
username = staff.phone
account_info = DictWrapper({
"username": username,
"password": hashlib.md5("123456".encode('utf8'))\
.hexdigest(),
"status": StatusType.ENABLE,
"staff": staff
})
account_list.append(account_info)
return account_list
def get_create_list(self, result_mapping):
logistics_list = result_mapping.get(LogisticsGenerator.get_key())
item_list = []
# 暂时一笔订单只发一个
for logistics in logistics_list:
for order_item in OrderItem.query(order=logistics.order):
item = DictWrapper({})
item.logistics = logistics
item.customer = logistics.customer
item.order_item = order_item
item.quantity = order_item.quantity
item_list.append(item)
return item_list
def formatting(self, value):
if type(value) is not dict:
raise Exception("paramter is not dict")
fields = self.get_fields()
result = {}
for key, helper in fields.items():
if key not in value:
if self._is_required:
raise Exception("paramter '{}' losted".format(key))
else:
continue
try:
cur_value = helper.format(value[key])
except Exception as e:
print('====~~~~~~~~~~~~~~~~~~>>>> ', value[key],
type(value[key]))
raise Exception("paramter '{}' format error, e = {}".format(
key, e))
else:
result[key] = cur_value
return DictWrapper(result)
def parsing(self, value):
if type(value) is str:
value = self.json_loads(value)
if type(value) is dict:
fields = self.get_fields()
result = {}
for key, helper in fields.items():
if key not in value:
if helper._is_required:
raise Exception("paramter '{}' losted".format(key))
else:
continue
try:
cur_value = helper.parse(value[key])
except Exception as e:
raise Exception("paramter '{}' format error".format(key))
else:
result[key] = cur_value
return DictWrapper(result)
raise Exception("paramter is not dict")
def summing(cls, sum_data, **search_info):
sum_measure_data = DictWrapper({})
sum_measure_data.volume_total = 0
sum_measure_data.open_number_total = 0
sum_measure_data.activation_number_total = 0
sum_measure_data.conversion_rate_total = "0%"
sum_measure_data.open_rate_total = "0%"
sum_measure_data.activation_rate_total = "0%"
if 'cur_user' in search_info:
user_pro = search_info.pop('cur_user')
if not user_pro._is_admin:
search_info.update({"service__seller_id__in": user_pro._staff_id_list})
if "begin_time" in search_info:
begin_time = search_info.pop("begin_time")
search_info.update({"order__pay_time__gte":\
datetime.datetime(begin_time.year, begin_time.month, begin_time.day, 0, 0, 0)})
if "end_time" in search_info:
end_time = search_info.pop("end_time")
search_info.update({"order__pay_time__lte":\
datetime.datetime(end_time.year, end_time.month, end_time.day, 23, 59, 59)})
if "staff__in" in search_info:
staff_list = search_info.pop("staff__in")
search_info.update({"service__seller__in":staff_list})
service_item_qs = cls.search_qs(**search_info)
sum_measure_data.volume_total = service_item_qs.count()
for service_item in service_item_qs:
if service_item.dsinfo_status != "red":
sum_measure_data.open_number_total += 1
if service_item.rebate_status != "red":
sum_measure_data.activation_number_total += 1
if sum_data.new_number > 0 and sum_measure_data.volume_total > 0:
sum_measure_data.conversion_rate_total = "{number}%".format(number = round((sum_measure_data.volume_total \
/ sum_data.new_number) * 100, 2))
if sum_measure_data.volume_total > 0 and sum_measure_data.open_number_total > 0:
sum_measure_data.open_rate_total = "{number}%".format(number = round((sum_measure_data.open_number_total \
/ sum_measure_data.volume_total) * 100, 2))
if sum_measure_data.volume_total > 0 and sum_measure_data.activation_number_total > 0:
sum_measure_data.activation_rate_total = "{number}%".format(number = round((sum_measure_data.activation_number_total \
/ sum_measure_data.volume_total) * 100, 2))
return sum_measure_data
def get_create_list(self, result_mapping):
item_list = result_mapping.get(LogisticsItemGenerator.get_key())
service_list = result_mapping.get(ServiceGenerator.get_key())
service_mapping = {service.order: service for service in service_list}
service_item_list = []
for item in item_list:
try:
product_model = item.order_item.goods.product_model
order = item.order_item.order
except Exception as e:
# 当获取不到信息时，默认跳过发货(理论上应该是发货前，发货中，发货后）
continue
for _ in range(item.quantity):
try:
equipment = EquipmentModelHelper().generate(\
product_model = product_model, can_send = True)
service_item = DictWrapper({})
service_item.customer = item.customer
service_item.order = order
service_item.service = service_mapping.get(order)
service_item.equipment = equipment
service_item.buyinfo_status = EquipStatusHelper().generate(
)
service_item.dsinfo_status = EquipStatusHelper().generate()
service_item.rebate_status = EquipStatusHelper().generate()
service_item.sn_status = EquipStatusHelper().generate()
service_item.remark = "设备服务单备注"
service_item_list.append(service_item)
except Exception as e:
print("缺少库存")
return service_item_list
def get(cls, auth_str):
token_str = redis.get(auth_str, cls._cache_category)
if token_str is None:
raise api_errors(ApiCodes.INTERFACE_TOKEN_INVALIED)
return cls(DictWrapper(json.loads(token_str)))
def Statistics(cls, search_time=None):
if isinstance(search_time, dict):
search_time_in = search_time['search_time']
user_pro = search_time['cur_user']
if search_time_in is None:
current_time = datetime.datetime.now()
else:
current_time = search_time_in
cur_date_first = datetime.date(current_time.year, current_time.month,
1)
cur_date_last = datetime.date(current_time.year, current_time.month +
1, 1) - datetime.timedelta(1)
if user_pro:
measure_staff_list = MeasureStaffHelper.search_qs(
begin_time=cur_date_first,
end_time=cur_date_last,
cur_user=user_pro)
else:
measure_staff_list = MeasureStaffHelper.search_qs(
begin_time=cur_date_first, end_time=cur_date_last)
measure_staff_mapping = {}
cal_time = cur_date_last
while (cal_time >= cur_date_first):
temp_calc = DictWrapper({})
temp_calc.new_number = 0
temp_calc.exhale_number = 0
temp_calc.call_number = 0
temp_calc.call_rate = '0%'
temp_calc.wechat_number = 0
temp_calc.volume = 0
temp_calc.conversion_rate = '0%'
temp_calc.open_number = 0
temp_calc.open_rate = '0%'
temp_calc.activation_number = 0
temp_calc.activation_rate = '0%'
temp_calc_day = {}
time_str = cal_time.strftime('%Y-%m-%d')
measure_staff_mapping[time_str] = temp_calc
cal_time = cal_time - datetime.timedelta(1)
for measure_staff in measure_staff_list:
report_date_str = str(measure_staff.report_date)
temp_item = measure_staff_mapping[report_date_str]
temp_item["new_number"] += measure_staff.new_number
temp_item["exhale_number"] += measure_staff.exhale_number
temp_item["call_number"] += measure_staff.call_number
temp_item["wechat_number"] += measure_staff.wechat_number
return measure_staff_mapping
def _get_response_data(self, result):
result = DictWrapper(result)
status = result.status
if status != "ok":
return None
return result.result
