def get_good_byid(request, modal_name, obj_id):
"""根据商品ID获取商品详情"""
try:
obj_id = int(obj_id)
if request.method == 'POST' and request.is_ajax():
model_class, modal_templ = MODAL_DICT[modal_name]
obj = model_class.objects.get(pk=obj_id)
obj.csrfmiddlewaretoken = request.POST['csrfmiddlewaretoken']
good_photo = []
qualification = []
if obj is not None:
good_photo = obj.goodphoto_set.all()
qualification = obj.goodqualification_set.all()
result = {
'obj': obj,
'good_photo': good_photo,
'qualification': qualification
}
return render(request, modal_templ, result)
else:
raise Exception('异常请求')
except Exception, e:
log.exception("get_good_byid raise ,Error:%s" % e)
result = {
'status': 0,
'msg': str(e),
}
def save_order(request, model_name):
"""公用保存排序
post => [{"pk":"1","order":"1"},{"pk":"2","order":"2"}]
"""
result = {
'status': 0,
'msg': 'sb',
}
try:
if request.method == 'POST' and request.is_ajax():
order_name = request.POST.get('order_name', '')
order_data = request.POST.get('data', '')
json_order_data = json.loads(order_data)
print json_order_data
for data in json_order_data:
order = {}
order[order_name] = data['value']
MODEL_DICT[model_name].objects.filter(id=data['pk']).update(**order)
result = {
'status': 1,
'msg': '修改成功',
}
else:
raise Exception('异常请求')
except Exception, e:
log.exception("save_order %s" % e)
result = {
'status': 0,
'msg': str(e),
}
def get_order_log(request, modal_name, obj_id):
"""获取订单日志"""
try:
if request.method == 'POST' and request.is_ajax():
obj = Order.objects.filter(pk=obj_id).first()
obj.csrfmiddlewaretoken = request.POST['csrfmiddlewaretoken']
_, modal_templ = MODAL_DICT[modal_name]
# 退款操作日志
kwargs = {}
kwargs['data_type'] = ORDER_MODAL
kwargs['data_id'] = obj.id
op_logs = OperateRecord.objects.filter(**kwargs).order_by("-created")
result = {
'obj': obj,
'op_logs': op_logs
}
return render(request, modal_templ, result)
else:
raise Exception("请求异常")
except Exception, e:
log.exception("get_order_log raise,Error:%s" % e)
result = {
'status': 0,
'msg': str(e),
}
def grant_role_permission(request):
"""授权：将角色和权限关联"""
try:
if request.method == 'POST' and request.is_ajax():
with transaction.atomic():
role_id = request.POST.get("role_id")
role = Role.objects.filter(id=role_id).first()
if role is not None:
RolePermission.objects.filter(role_id=role_id).delete()
perm_code = request.POST.get("perm_code")
perm_codes = json.loads(perm_code)
for perm in perm_codes:
RolePermission.objects.create(
role=role,
codename=perm
)
result = {
'status': 1,
'msg': '授权成功'
}
else:
raise Exception("数据异常，请刷新后重试")
else:
raise Exception("请求异常")
except Exception, e:
log.exception("grant_role_permission raise, Error:%s" % e)
result = {
'status': 0,
'msg': str(e)
}
def get_refund_form(request, modal_name, obj_id):
"""后台:获取退款退货信息"""
try:
if request.method == 'POST' and request.is_ajax():
obj = RefundRecord.objects.get(id=obj_id)
obj.csrfmiddlewaretoken = request.POST['csrfmiddlewaretoken']
_, modal_templ = MODAL_DICT[modal_name]
# 订单列表详情
order_items = obj.order.orderitem_set.all()
# 退款操作日志
kwargs = {}
kwargs['data_type'] = REFUND_MODAL
kwargs['data_id'] = obj.id
op_logs = OperateRecord.objects.filter(**kwargs).order_by("-created")
result = {
'obj': obj,
'order_items': order_items,
'op_logs': op_logs
}
return render(request, modal_templ, result)
else:
raise Exception('异常请求')
except Exception, e:
log.exception("get_refund_form raise,Error:%s" % e)
result = {
'status': 0,
'msg': str(e),
}
def update_role_byform(request):
"""添加角色"""
try:
if request.method == 'POST' and request.is_ajax():
role_form = RoleAttrForm(request.POST)
if role_form.is_valid():
with transaction.atomic():
role_id = request.POST.get('role_id')
role_dict = role_form.cleaned_data
role = Role.objects.filter(id=role_id).first()
if role is not None:
role.name = role_dict['name']
role.desc = role_dict['desc']
role.usertype = role_dict['usertype']
role.save()
result = {
'status': 1,
'msg': "保存成功"
}
else:
raise Exception("web端异常，请稍后刷新重试")
else:
raise Exception("输入参数异常")
except Exception, e:
log.exception("request raise Exception,%s" % e)
result = {
'status': 0,
'msg': str(e)
}
def add_role_byform(request):
"""添加角色"""
try:
if request.method == 'POST' and request.is_ajax():
role_form = RoleAttrForm(request.POST)
if role_form.is_valid():
with transaction.atomic():
role_dict = role_form.cleaned_data
Role.objects.create(
name=role_dict['name'],
usertype=role_dict['usertype'],
desc=role_dict['desc']
)
result = {
'status': 1,
'msg': "保存成功"
}
else:
raise Exception("输入参数异常")
except Exception, e:
log.exception("request raise Exception,%s" % e)
result = {
'status': 0,
'msg': str(e)
}
def check_good_status(request):
""" 审核商品 """
try:
if request.method == 'POST' and request.is_ajax():
op_type = request.POST.get('op_type')
obj_id = request.POST.get('obj_id')
with transaction.atomic():
if op_type == 'ref': # 拒绝
good = Good.objects.filter(id=obj_id).first()
if good is not None:
good.is_qualified = 3
good.save()
else: # 通过并上架
good = Good.objects.filter(id=obj_id).first()
if good is not None:
good.is_qualified = 2
good.online_time = datetime.datetime.now()
good.is_online = 1
good.save()
result = {
'status': 1,
'msg': '修改成功'
}
else:
raise Exception('异常请求')
except Exception, e:
log.exception("ajax.check_good_status,error:%s" % e)
result = {
'status': 0,
'msg': str(e)
}
def import_excel_util(file_path, obj_dict):
"""
Excel 导入工具类
:param file_path: excel文件对象访问路径地址
:param obj_dict: 要存入的model对象属性
:return:
"""
try:
excel_data = xlrd.open_workbook(file_path) # 读取Excel文件对象
excel_sheet = excel_data.sheet_by_name(u'Sheet1') # 根据sheet名称获取工作表
# row_values = excel_sheet.row_values(0) # 读取第一行数据【表头标题】【数组长度等于总列数】
# col_values = excel_sheet.col_values(0) # 读取第一列数据
# th_valus = [{index: val} for index, val in enumerate(row_values)] # 表头数据
row_count = excel_sheet.nrows # 读取所有行数
col_count = excel_sheet.ncols # 读取列数
model_list = [] # 将excel数据封装成list
for row_n in range(1, row_count): # 循环1到总行数
model_dict = {} # 将单行数据封装成一个数据字典
for col_n in range(0, col_count): # 循环0到总列数
row_col_data = excel_sheet.cell(row_n, col_n).value # 读取列数据
model_dict[obj_dict[col_n]] = row_col_data # 字典封装
model_list.append(model_dict) # 将单行数据封装到list中作为返回值范围
return model_list
except Exception, e:
log.exception(e)
def switch_drug_online(request, method, obj_id):
"""商品上架下架"""
try:
if request.method == 'POST' and request.is_ajax():
is_online = ''
if method == 'on':
is_online = 1
elif method == 'off':
is_online = 2
good = Good.objects.filter(pk=obj_id).first()
if good is not None:
good.is_online = is_online
good.online_time = datetime.datetime.now()
good.save()
result = {
'status': 1,
'msg': '修改成功',
}
else:
raise Exception('异常请求')
except Exception, e:
log.exception("switch_drug_online raise,Error:%s" % e)
result = {
'status': 0,
'msg': str(e),
}
def sort_column(value):
# 因为table_sort是按字符串来排序的，导致20大于100。所以在20前面补0。
try:
if value:
return mark_safe('<span class="hide">%012.2f</span>%s' % (float(value), value))
else:
return value
except Exception, e:
log.exception("sort_column(value=%s) raise error=%s" % (value, e))
return mark_safe('<span class="hide">%s</span>%s' % (value, value))
def send_validate_code(request):
"""发送验证码"""
result = {'status': 0, 'msg': '网络异常，请稍后刷新重试'}
try:
if request.method == 'POST' and request.is_ajax():
# 验证电话号码
phone = request.POST.get('phone', '')
phone_re = re.compile('^0\d{2,3}\d{7,8}$|^1[358]\d{9}$|^147\d{8}$')
is_phone = phone_re.match(phone)
if is_phone:
# 判断这个用户存在与否
is_phone_exist = User.objects.filter(phone=str(phone)).first()
if is_phone_exist:
# # 避免多次发送短信
# request.session.set_expiry(180)
# phone_session = request.session.get('account_safety', '')
# if phone_session:
# result = {
# 'status': 0,
# 'msg': u'验证码已经发送，请注意查收'
# }
# return JsonResponse(result)
# 发送验证码
sms_msg = make_sms()
c = CaptchaStore()
# 把验证码存入session
request.session['account_safety'] = sms_msg[1]
# 存库
c.response = sms_msg[1]
c.challenge = phone
c.save()
result = {'status': 1, 'msg': '验证码已经发送，请注意查收'}
# 测试 可不发短信 去CaptchaStore中查看验证码
if not settings.DEBUG:
send_sms([phone], sms_msg[0])
result = {
'status': 1,
'key': c.hashkey,
}
return JsonResponse(result)
else:
# result = {
# 'status': 0,
# 'msg': u'这个电话没有注册，请先注册'
# }
# return JsonResponse(result)
raise Exception('这个电话没有注册，请先注册')
else:
result = {'status': 0, 'msg': '请输入正确的电话号码'}
return JsonResponse(result)
else:
raise Exception("请求异常")
except Exception, e:
log.exception("send_validate_code raise, Error:%s" % e)
result = {'status': 0, 'msg': str(e)}
def import_excel(request):
"""Excel导入"""
try:
if request.method == "POST":
excel_file = request.FILES.get("excel_file", None)
if excel_file:
# 自定义存储路径
rollfileName = "uploadfile/"
rollfilePath = os.path.join(settings.MEDIA_ROOT, rollfileName)
# 获取文件名后缀
filetype = excel_file.name.split(".")[-1]
# 生成随机字符串加后缀的文件名
filename = str(uuid.uuid1()) + '.' + filetype
file_path = rollfilePath + filename
# 打开文件存储路径
of = open(file_path, 'wb+')
# 向指定路径写入文件
for chunk in excel_file.chunks():
of.write(chunk) # 写入内容
of.close() # 关闭连接
log.info(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> start import excel >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
obj_dict = {0: "name", 1: "name_cn", 2: "position", 3: "qq", 4: "phone", 5: "tel"}
obj_list = import_excel_util(file_path, obj_dict)
os.remove(file_path) # 读取完成后，删除文件
with transaction.atomic():
count = 0
for obj in obj_list:
user_tmp = TestUser.objects.filter(name=obj['name'])
if user_tmp:
log.info("obj is exist")
continue
else:
TestUser.objects.create(
name=obj['name'],
password="******",
name_cn=obj['name_cn'],
position=obj['position'],
qq=obj['qq'],
phone=obj['phone'],
tel=obj['tel']
)
count+=1
log.info(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> insert successful ,insert %s data >>>>>>>>" % count)
log.info(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> end import excel >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
result = {"status": 1, "msg": "成功"}
else:
raise Exception("文件不存在")
elif request.method == "GET":
return render(request, "bgadmin/import_Excel.html", {})
else:
raise Exception("请求异常")
except Exception, e:
log.exception("import_excel %s" % e)
result = {"status": 0, "msg": "fail"}
def bulk_update_for_model(obj_list, commit_number=1000):
'''批量更新model_list数据，按照commit_number将obj_list分组批量更新'''
for temp_list in genr_sublist(obj_list, commit_number):
try:
for obj in temp_list:
obj.save(False, False)
transaction.commit()
except Exception, e:
log.exception("Object save error, e=%s" % (e))
transaction.rollback()
raise e
def bulk_update_for_sql(sql, value_list, commit_number=1000):
'''批量执行sql语句保存数据，按照commit_number将value_list分组批量更新'''
rowcount = 0
for group_value_list in genr_sublist(value_list, commit_number):
if group_value_list:
try:
cursor = connection.cursor()
for temp_list in group_value_list:
rowcount += cursor.executemany(
sql, temp_list) # sql语句里的字符串型参数 %s 两旁不加引号！
transaction.commit()
except Exception, e:
log.exception("SQL update error, e=%s" % (e))
transaction.rollback()
raise e
def execute_query_sql(sql, value_list=None, model_class=None):
'''
\传入SQL执行数据库查询操作，返回结果可以是dict_list，也可以是model_list；
value_list、model_class可以为空，model_class=None时，返回dict_list；
model_class为模型对象时，返回model_list，如果model_class不包含ResultSet的属性，则会将该属性加入到model对象中；
\查询时取了所有结果，如果数据量太大，需要在SQL语句中包含limit分页；
\该函数用于替代RawSQL，但不同的是调用会立即执行查询，如果真的想只在使用对象时查询，就可以使用RawSQL，其它情况下慎用
'''
script_type = None
if sql:
script_type = sql.lstrip()
script_type = script_type[0:script_type.find(" ")].lower()
try:
if script_type == "select":
# SQL语句格式："SELECT foo FROM bar WHERE baz = %s AND name = %s LIMIT %s, %s"
cursor = connection.cursor()
if not value_list:
cursor.execute(sql)
else:
cursor.execute(sql, value_list)
# 得到查询的列属性和结果
descr = cursor.description
result_set = cursor.fetchall()
# 将结果组装为字典列表
if model_class == None:
return [
dict(zip([column[0] for column in descr], row))
for row in result_set
]
# 将结果组装为模型列表
else:
model_obj_list = []
for row in result_set:
model_obj = model_class()
tuple_kv_list = zip([column[0] for column in descr], row)
for tuple_kv in tuple_kv_list:
setattr(model_obj, tuple_kv[0], tuple_kv[1])
model_obj_list.append(model_obj)
return model_obj_list
else:
raise SQLException, "SQL syntax error：[%s]" % sql
except Exception, e:
log.exception("SQL Statement execute error, e=%s" % (e))
raise e
def get_this_perm_role(request):
"""获取当前角色所有权限"""
try:
if request.method == 'POST' and request.is_ajax():
role_id = request.POST.get("role_id")
role_perms = RolePermission.objects.filter(role_id=role_id)
perm_lst = []
for item in role_perms:
perm_lst.append({'codename': item.codename})
result = {
'status': 1,
'perm_lst': json.dumps(perm_lst)
}
except Exception, e:
log.exception("get_this_perm_role raise, Error:%s" % e)
result = {
'status': 0,
'msg': str(e)
}
def del_role_byid(request, obj_id):
"""删除角色:用户表已经配置级联保护，权限表已配置权限级联删除"""
try:
if request.method == 'POST' and request.is_ajax():
with transaction.atomic():
del_role = Role.objects.filter(id=obj_id).first()
del_role.user_set.clear() # 清除用户角色关系
del_role.rolepermission_set.all().delete() # 清除角色权限关系
del_role.delete() # 删除角色
result = {
'status': 1,
'msg': '删除成功'
}
else:
raise Exception('请求异常')
except Exception, e:
log.exception("del_role_byid raise, Error:%s" % e)
result = {
'status': 0,
'msg': str(e)
}
def order_no_check(request, obj_id):
"""订单编号查看"""
try:
obj_id = int(obj_id)
if request.method == 'POST' and request.is_ajax():
user_pk = request.user.id
pk = int(obj_id)
order = Order.objects.filter(pk=pk).first()
user = User.objects.filter(pk=int(user_pk)).first()
return render(request, 'dtsadmin/modals/modal_approve_look_order.html', {
'order': order,
'user': user,
})
else:
raise Exception('系统忙,请稍后再试')
except Exception, e:
log.exception("dtsadmin.ajax.order_no_check Error:%s" % e)
result = {
'status': 0,
'msg': str(e),
}
return JsonResponse(result)
def delete_good(request, obj_id):
"""根据id删除某个对象"""
try:
obj_id = int(obj_id)
if request.method == 'POST' and request.is_ajax():
with transaction.atomic():
# 删除商品图片 ，资质图， 相关属性， 商品本身
GoodPhoto.objects.filter(good_id=obj_id).delete()
GoodQualification.objects.filter(good_id=obj_id).delete()
DrugAttr.objects.filter(good_id=obj_id).delete()
Good.objects.filter(pk=obj_id).delete()
result = {
'status': 1,
'msg': '删除成功',
}
else:
raise Exception('异常请求')
except Exception, e:
log.exception("delete_good raise ,Error:%s" % e)
result = {
'status': 0,
'msg': str(e),
}
def __insert_for_dict(table_name, field_string, field_list, objs):
'''将field_list对应的字典list objs批量插入'''
values_list = []
for obj in objs:
for field_name in field_list:
field_value = obj[field_name]
values_list.append(field_value)
arg_string = ', '.join([u'(' + ', '.join(['%s'] * len(field_list)) + ')'] *
len(objs))
sql = "INSERT INTO %s (%s) VALUES %s" % (
table_name,
field_string,
arg_string,
)
try:
cursor = connection.cursor()
cursor.execute(sql, values_list)
# transaction.commit_unless_managed()
except Exception, e:
log.exception("SQL Statement execute error, e=%s" % (e))
raise e
def paginate_for_sql(count_sql,
query_sql,
page_no,
page_size,
all_count=None,
recount=False):
'''
\根据SQL分页查询数据
count_sql格式：SELECT %s FROM auth_user order by shop_id
query_sql格式：SELECT username FROM auth_user order by shop_id
\注意：1)要保证django/core/paginator.py中有后来添加的for_sql函数
2)只有page_no=1或recount=True(需要每次都计算)的时候，才计算all_count，
\其它情况需传入all_count(从page_obj.paginator.count中获取)，因此当翻页查询后，还有添加、删除操作时，应该设置recount=True
'''
this_page = None
if page_no < 1 or page_size < 1 or not count_sql or not query_sql:
return this_page
try:
if page_no == 1 or recount:
count_sql = count_sql % ("count(*) all_count")
all_count = execute_query_sql(count_sql)[0]["all_count"]
query_sql += " LIMIT %s OFFSET %s" % (page_size,
(page_no - 1) * page_size)
data_list = execute_query_sql(query_sql)
try:
paginator = Paginator(data_list, page_size)
this_page = paginator.page(1)
this_page.for_sql(page_no, all_count)
except (EmptyPage, InvalidPage):
this_page = paginator.page(1)
this_page.for_sql(1, all_count)
except Exception, e:
log.exception("page_no=%s, page_size=%s, all_count=%s, e=%s" %
(page_no, page_size, all_count, e))
raise e
def send_validate_code_new(request):
"""发送验证码"""
result = {'status': 0, 'msg': '网络异常，请稍后刷新重试'}
try:
if request.method == 'POST' and request.is_ajax():
# 验证电话号码
phone = request.POST.get('phone', '')
phone_re = re.compile('^0\d{2,3}\d{7,8}$|^1[358]\d{9}$|^147\d{8}$')
is_phone = phone_re.match(phone)
if is_phone:
# 发送验证码
sms_msg = make_sms()
c = CaptchaStore()
# 把验证码存入session
request.session['account_safety'] = sms_msg[1]
# 存库
c.response = sms_msg[1]
c.challenge = phone
c.save()
result = {'status': 1, 'msg': '验证码已经发送，请注意查收'}
# 测试 可不发短信 去CaptchaStore中查看验证码
if not settings.DEBUG:
send_sms([phone], sms_msg[0])
result = {
'status': 1,
'key': c.hashkey,
}
return JsonResponse(result)
else:
result = {'status': 0, 'msg': '请输入正确的电话号码'}
return JsonResponse(result)
else:
raise Exception("请求异常")
except Exception, e:
log.exception("send_validate_code_new raise, Error:%s" % e)
result = {'status': 0, 'msg': str(e)}
if engine_type != '' and len(sql) > 0:
sql[0] = sql[0][0:-2] + 'engine=' + engine_type + '\n' + ';'
# 获取索引sql
index_sql = connection.creation.sql_indexes_for_model(model_class, style)
if index_sql:
sql.extend(index_sql)
model_class._meta.db_table = org_db_table
log.info("Creating table %s ......, Model is %s" %
(table_name, model_class))
try:
for statement in sql:
cursor.execute(statement) # 执行脚本
except Exception, e:
log.exception("SQL Statement execute error, e=%s" % (e))
return False
log.info("Create table %s success" % (table_name))
return True
# @transaction.commit_manually
def bulk_update_for_sql(sql, value_list, commit_number=1000):
'''批量执行sql语句保存数据，按照commit_number将value_list分组批量更新'''
rowcount = 0
for group_value_list in genr_sublist(value_list, commit_number):
if group_value_list:
try:
cursor = connection.cursor()
for temp_list in group_value_list:
def add_good(request):
"""添加商品"""
try:
if request.method == 'POST' and request.is_ajax():
if request.POST.get('member_price') != '':
request.POST.__setitem__('member_price', float(request.POST.get('member_price')) * 100)
if request.POST.get('retail_price') != '':
request.POST.__setitem__('retail_price', float(request.POST.get('retail_price')) * 100)
good_form = GoodDrugAttrForm(request.POST)
if good_form.is_valid():
good_dict = good_form.cleaned_data
with transaction.atomic():
good = Good.objects.create(
external_id=good_dict['external_id'],
name=good_dict['name'],
trade_name=good_dict['trade_name'],
brand=good_dict['brand'],
category_id=good_dict['category'],
supplier_id=good_dict['supplier'],
manufacturer=good_dict['manufacturer'],
locality=good_dict['locality'],
unit=good_dict['unit'],
prep_spec=good_dict['prep_spec'],
pack_spec=good_dict['pack_spec'],
retail_price=good_dict['retail_price'],
member_price=good_dict['member_price'],
stock_amount=good_dict['stock_amount'],
)
if good is not None:
for main_photo in request.FILES.getlist('main_photo'):
main_photo.name = str(int(time.time())) + "_%s" % main_photo.name
good.main_photo = main_photo
good.save()
# 商品属性
DrugAttr.objects.create(
good=good,
license=good_dict['license'],
dosage_form=good_dict['dosage_form'],
is_otc=bool(good_dict['is_otc']),
is_zybh=bool(good_dict['is_zybh']),
is_new=bool(good_dict['is_new']),
is_oem=bool(good_dict['is_oem']),
otc_type=good_dict['otc_type'],
recipe_type=good_dict['recipe_type'],
desc_drug=good_dict['desc_drug'],
desc_good=good_dict['desc_good'],
)
# 上传商品图片和商品资质
photo_index = 1
for good_photo in request.FILES.getlist('good_photo'):
good_photo.name = str(int(time.time())) + "_%s" % good_photo.name
GoodPhoto.objects.create(
good=good,
order_no=photo_index,
photo=good_photo,
upload_man=request.user
)
photo_index += 1
for good_qua in request.FILES.getlist('good_qua'):
good_qua.name = str(int(time.time())) + "_%s" % good_qua.name
GoodQualification.objects.create(
good=good,
photo=good_qua,
upload_man=request.user
)
result = {
'status': 1,
'msg': '添加成功',
}
else:
result = {
'status': 0,
'msg': '商品信息输入不完整',
}
else:
raise Exception('异常请求')
except Exception, e:
log.exception("add_good raise , Error:%s" % e)
result = {
'status': 0,
'msg': str(e),
}
def update_good(request):
"""更新商品"""
try:
if request.method == 'POST' and request.is_ajax():
if request.POST.get('member_price') != '':
request.POST.__setitem__('member_price', float(request.POST.get('member_price')) * 100)
if request.POST.get('retail_price') != '':
request.POST.__setitem__('retail_price', float(request.POST.get('retail_price')) * 100)
good_form = GoodDrugAttrForm(request.POST)
if good_form.is_valid():
good_dict = good_form.cleaned_data
with transaction.atomic():
up_good = Good.objects.filter(id=good_dict['fk_good_id']).first()
if up_good is not None:
# 更新商品属性
up_good.external_id = good_dict['external_id']
up_good.name = good_dict['name']
up_good.trade_name = good_dict['trade_name']
up_good.brand = good_dict['brand']
up_good.category_id = good_dict['category']
if good_dict['supplier'] != '':
up_good.supplier_id = good_dict['supplier']
up_good.manufacturer = good_dict['manufacturer']
up_good.locality = good_dict['locality']
up_good.unit = good_dict['unit']
up_good.prep_spec = good_dict['prep_spec']
up_good.pack_spec = good_dict['pack_spec']
if good_dict['retail_price'] != '':
up_good.retail_price = good_dict['retail_price']
if good_dict['member_price'] != '':
up_good.member_price = good_dict['member_price']
up_good.stock_amount = good_dict['stock_amount']
up_good.save()
# 更新商品主图
for main_photo in request.FILES.getlist('main_photo'):
main_photo.name = str(int(time.time())) + "_%s" % main_photo.name
up_good.main_photo = main_photo
up_good.save()
# 更新商品具体属性
drug_attr = DrugAttr.objects.filter(good_id=up_good.id).first()
if drug_attr is not None:
drug_attr.license = good_dict['license']
drug_attr.dosage_form = good_dict['dosage_form']
drug_attr.is_otc = bool(good_dict['is_otc'])
drug_attr.is_zybh = bool(good_dict['is_zybh'])
drug_attr.is_new = bool(good_dict['is_new'])
drug_attr.is_oem = bool(good_dict['is_oem'])
drug_attr.otc_type = good_dict['otc_type']
drug_attr.recipe_type = good_dict['recipe_type']
drug_attr.desc_drug = good_dict['desc_drug']
drug_attr.desc_good = good_dict['desc_good']
drug_attr.save()
else:
DrugAttr.objects.create(
good=up_good,
license=good_dict['license'],
dosage_form=good_dict['dosage_form'],
is_otc=bool(good_dict['is_otc']),
is_zybh=bool(good_dict['is_zybh']),
is_new=bool(good_dict['is_new']),
is_oem=bool(good_dict['is_oem']),
otc_type=good_dict['otc_type'],
recipe_type=good_dict['recipe_type'],
desc_drug=good_dict['desc_drug'],
desc_good=good_dict['desc_good'],
)
pho_ids = request.POST.get('pho_id')
qua_ids = request.POST.get('qua_id')
# 删除不需要保留商品主图
if pho_ids:
pho_ids_list = json.loads(pho_ids)
for key in pho_ids_list:
del_photo = GoodPhoto.objects.filter(id=key).first()
if del_photo is not None:
del_photo.photo.delete()
del_photo.delete()
else: # 删除所有原有商品主图
GoodPhoto.objects.filter(good_id=up_good.id).delete()
# 删除不需要的资质图
if qua_ids:
qua_ids_list = json.loads(qua_ids)
for key in qua_ids_list:
del_qua = GoodQualification.objects.filter(id=key).first()
if del_qua is not None:
del_qua.photo.delete()
del_qua.delete()
else: # 删除所有原有商品主图
GoodQualification.objects.filter(good_id=up_good.id).delete()
# 上传新的商品主图和商品资质
good_photo_files = request.FILES.getlist('good_photo')
order_no = 1
for good_photo in good_photo_files:
good_photo.name = str(int(time.time())) + "_%s" % good_photo.name
GoodPhoto.objects.create(
good=up_good,
order_no=order_no,
photo=good_photo,
upload_man=request.user
)
order_no += 1
for good_qua in request.FILES.getlist('good_qua'):
good_qua.name = str(int(time.time())) + "_%s" % good_qua.name
GoodQualification.objects.create(
good=up_good,
photo=good_qua,
upload_man=request.user
)
result = {
'status': 1,
'msg': '保存成功',
}
else:
result = {
'status': 0,
'msg': '商品信息输入异常',
}
else:
raise Exception('异常请求')
except Exception, e:
log.exception("update_good raise,Error:" % e)
result = {
'status': 0,
'msg': str(e),
}
