def post(self, request, *args, **kwargs):
uuid = request.POST.get('uuid', None)
if uuid:
client = get_redis_client()
name = 'user_strategy:{}'.format(uuid)
d = client.hgetall(name)
strategy_body = d['strategy_body']
members = strategy_body.split(",")
history = {"user_id": "xxxxxx"}
req_body = {"user_id": "xxxxxx"}
for member in members:
history[member] = "yyyyyy"
req_body[member] = "yyyyyy"
ts = int(time.time())
history_data = []
for _ in range(3):
history["timestamp"] = ts
history_data.append(history)
return self.render_json_response({
'state': True,
'history_data': history_data,
'req_body': req_body
})
else:
return self.render_json_response({'state': False})
def post(self, request, *args, **kwargs):
uuid_ = request.POST.get('uuid', None)
if uuid_:
client = get_redis_client()
name = 'rule:{}'.format(uuid_)
try:
strategy_group_list = json.loads(client.hget(
name, 'strategys'))
strategy_list = [
d['strategy_list'][0] for d in strategy_group_list
]
uuids = [x[0] for x in strategy_list]
members = (self._get_bool_strategy_args(uuids, client)
| self._get_freq_strategy_args(uuids, client)
| self._get_menu_strategy_args(uuids, client)
| self._get_user_strategy_args(uuids, client))
except Exception:
return self.render_json_response({'state': False})
req_body = {}
for member in members:
req_body[member] = "xxxxxx"
return self.render_json_response({
'state': True,
'req_body': req_body
})
else:
return self.render_json_response({'state': False})
def get_rule(self):
uuid_ = self.request.GET.get('id')
if not uuid_:
raise Http404
client = get_redis_client()
name = 'rule:{}'.format(uuid_)
d = client.hgetall(name)
if not d:
raise Http404
data = {}
for key in ('status', 'title', 'describe', 'end_time', 'id', 'uuid'):
data[key] = d[key]
try:
rule_list = json.loads(d["strategys"])
except ValueError:
rule_list = []
for rule in rule_list:
rule['group_name'] = rule['name']
rule['weight'] = rule.get('weight', '')
rule['control_display'] = CONTROL_MAP.get(rule['control'],
rule['control'])
rule['strategy_name'] = ";".join(x[2]
for x in rule['strategy_list']
if len(x) == 3)
rule['strategy_list_str'] = json.dumps(rule['strategy_list'])
data['rule_list'] = rule_list
return data
def post(self, request, *args, **kwargs):
form = MenuStrategyTestForm(data=request.POST)
if form.is_valid():
uuid_ = request.POST.get('strategy')
req_body = form.cleaned_data['req_body']
results = []
client = get_redis_client()
name = 'strategy_menu:{}'.format(uuid_)
d = client.hgetall(name)
strategy = MenuStrategy(d)
func = strategy.get_callable()
if not isinstance(req_body, list):
req_body = [req_body]
for req in req_body:
res = func(req)
results.append(u"命中" if res else u"不命中")
if len(results) == 1:
results = results[0]
data = dict(state=True, data=results)
else:
data = dict(state=False, error=errors_to_dict(form.errors))
return self.render_json_response(data)
def post(self, request, *args, **kwargs):
form = self.form_class(data=request.POST)
if form.is_valid():
uuid_ = form.cleaned_data['strategy']
req_body = form.cleaned_data["req_body"]
history_data = form.cleaned_data['history_data'] or None
client = get_redis_client()
name = 'user_strategy:{}'.format(uuid_)
d = client.hgetall(name)
strategy = UserStrategy(d)
strategy_day = int(d['strategy_day'])
threshold = int(d['strategy_limit'])
if not isinstance(req_body, list):
req_body = [req_body]
if history_data:
func = strategy.get_callable()
raw_results = [func(req, history_data) for req in req_body]
else:
func = strategy.get_callable_from_threshold_list(
[strategy_day, threshold])
raw_results = [func(req) for req in req_body]
results = [u"命中" if i else u"不命中" for i in raw_results]
if len(results) == 1:
results = results[0]
data = dict(
state=True,
data=results,
)
else:
data = dict(state=False, error=errors_to_dict(form.errors))
return self.render_json_response(data)
def post(self, request, *args, **kwargs):
form = self.form_class(data=request.POST)
if form.is_valid():
uuid_ = request.POST.get('strategy')
req_body = request.POST.get('req_body', '')
req_body = json.loads(req_body)
client = get_redis_client()
name = 'bool_strategy:{}'.format(uuid_)
d = client.hgetall(name)
strategy = BoolStrategy(d)
func = strategy.get_callable()
if not isinstance(req_body, list):
req_body = [req_body]
results = []
for req in req_body:
resp = func(req)
if resp:
results.append(u"命中")
else:
results.append(u"不命中")
if len(results) == 1:
results = results[0]
data = dict(state=True, data=results)
else:
data = dict(state=False, error=errors_to_dict(form.errors))
return self.render_json_response(data)
def _build_strategy_choices(cls):
client = get_redis_client()
choices = []
for name in client.scan_iter(match="user_strategy:*"):
d = client.hgetall(name)
if 'uuid' in d and 'strategy_name' in d:
choices.append((d['uuid'], d['strategy_name']))
return choices
def _check_event(self, event_code):
"""check名单项目是否被名单策略原子引用"""
client = get_redis_client()
for r in client.scan_iter(match="strategy_menu:*"):
event_id = client.hget(r, 'event')
if event_code == event_id:
return True
return False
def post(self, request, *args, **kwargs):
uuid_ = request.POST.get('id', None)
if uuid_:
client = get_redis_client()
name = 'rule:{}'.format(uuid_)
client.delete(name)
return self.render_json_response({'state': True, 'msg': "ok"})
return self.render_json_response({'state': False, 'error': u"未找到规则"})
def save(self):
client = get_redis_client()
cd = self.cleaned_data
name_key = cd['name_key']
name_show = cd['name_show']
content = cd['content']
content.update(name_show=name_show)
client.hset(self.map_key, name_key, json.dumps(content))
return name_key
def tearDownClass(cls):
super(BaseTestCase, cls).tearDownClass()
# 清理测试库
db = get_mongo_client()
db.client.drop_database(db.name)
client = get_redis_client()
client.flushdb()
def clean_name_key(self):
name_key = self.cleaned_data['name_key']
if not re.match(self.name_key_pattern, name_key):
raise forms.ValidationError("输入错误，包含某些特殊字符")
client = get_redis_client()
if client.hget(self.map_key, name_key):
raise forms.ValidationError("该数据源已存在")
return name_key
def post(self, request, *args, **kwargs):
db = get_mongo_client()
ids = request.POST.get('ids')
try:
assert ids
obj_ids = [ObjectId(id_) for id_ in ids.split(',')]
except Exception:
return self.render_json_response(dict(state=False, error=u"id不合法"))
redis_values_should_remove = defaultdict(list)
menus_records = list(db['menus'].find(
{
'_id': {
"$in": obj_ids
},
'menu_status': u'有效'
}, {
'event_code': True,
'_id': False,
'dimension': True,
'menu_type': True,
'value': True,
}))
if not menus_records:
return self.render_json_response(dict(state=False,
error=u"记录均不存在"))
for d in menus_records:
redis_key = build_redis_key(d['event_code'], d['dimension'],
d['menu_type'])
if redis_key:
redis_values_should_remove[redis_key].append(d['value'])
update_payload = {
'menu_status': u'无效',
'creator': request.user.username,
'create_time': datetime.now(),
}
try:
db.menus.update_many({'_id': {
"$in": obj_ids
}}, {"$set": update_payload})
# 同时删除redis中数据
redis_client = get_redis_client()
pipeline = redis_client.pipeline(transaction=False)
for key, values in redis_values_should_remove.items():
pipeline.srem(key, *values)
pipeline.execute()
except Exception:
return self.render_json_response(
dict(state=False, error=u"操作失败，请稍后重试"))
return self.render_json_response(dict(state=True, msg="ok"))
def post(self, request, *args, **kwargs):
uuid = request.POST.get('uuid', None)
if uuid:
client = get_redis_client()
name = 'strategy_menu:{}'.format(uuid)
d = client.hgetall(name)
dimension = d['dimension']
req_body = {dimension: "xxxxx"}
else:
req_body = {}
return self.render_json_response({'state': True, 'req_body': req_body})
def render_strategy_source(self, value):
client = get_redis_client()
data = client.hget("CONFIG_SOURCE_MAP", value)
if data:
try:
name = json.loads(data).get('name_show', '')
except ValueError:
return value
if name:
return u"{0}({1})".format(name, value)
return value
def is_exists(self, cleaned_data):
client = get_redis_client()
temp = copy.deepcopy(cleaned_data)
temp.pop("strategy_desc", None)
temp.pop("strategy_name", None)
keys = sorted(temp.keys())
values_sign = "".join([temp[x] for x in keys])
exists = client.sismember(settings.STRATEGY_SIGN_KEY, values_sign)
self.values_sign = values_sign
if exists in (0, '0'):
return False
return True
def save(self):
client = get_redis_client()
uuid_ = str(uuid.uuid4())
name = 'bool_strategy:{}'.format(uuid_)
payload = {}
for key in ('strategy_name', 'strategy_desc', 'strategy_var',
'strategy_op', 'strategy_func', 'strategy_threshold'):
payload[key] = self.cleaned_data.get(key, '')
payload['uuid'] = uuid_
client.hmset(name, payload)
client.sadd(settings.STRATEGY_SIGN_KEY, self.values_sign)
return uuid_
def save(self, *args, **kwargs):
client = get_redis_client()
uuid_ = str(uuid.uuid4())
name = 'strategy_menu:{}'.format(uuid_)
payload = {'uuid': uuid_}
for key in ('strategy_name', 'strategy_desc', 'menu_op', 'event',
'dimension', 'menu_type'):
payload[key] = self.cleaned_data.get(key, '')
client.hmset(name, payload)
client.sadd(settings.STRATEGY_SIGN_KEY, self.values_sign)
return uuid_
def save(self, *args, **kwargs):
client = get_redis_client()
uuid_ = str(uuid.uuid4())
name = 'user_strategy:{}'.format(uuid_)
payload = {}
for key in ('strategy_name', 'strategy_desc', 'strategy_day',
'strategy_body', 'strategy_limit', 'strategy_source'):
payload[key] = self.cleaned_data.get(key, '')
payload['uuid'] = uuid_
client.hmset(name, payload)
client.sadd(settings.STRATEGY_SIGN_KEY, self.values_sign)
return uuid_
def clean(self):
client = get_redis_client()
cd = self.cleaned_data
source_key = cd['strategy_source']
strategy_body_str = cd.get('strategy_body', '')
valid_bodys = json.loads(client.hget('CONFIG_SOURCE_MAP', source_key))
for strategy_body in strategy_body_str.split(','):
if strategy_body not in valid_bodys:
self.errors['strategy_body'] = [
u"数据源没有{}。".format(strategy_body)
]
return
fields = [str(cd.get(x, "")) for x in USER_STRATEGY_UNIQ_SET_KEYS]
if not all(fields):
return
values_sign = ":".join(fields)
client = get_redis_client()
if client.sismember(settings.STRATEGY_SIGN_KEY, values_sign):
self.errors['strategy_name'] = [u"该条记录已存在,请勿重复添加"]
self.values_sign = values_sign
def create_data_source(source_key=None, source_name=None, fields=None):
source_key = source_key or get_sample_str(8)
source_name = source_name or get_sample_str(8)
fields = fields or ['user_id', 'uid']
# 目前仅仅用于测试中，为了简单，type暂不可配置
content = {field: 'string' for field in fields}
content['name_show'] = source_name
map_key = 'CONFIG_SOURCE_MAP'
client = get_redis_client()
client.hset(map_key, source_key, json.dumps(content))
return source_key
def _check_strategy(strategy_id):
"""校验策略原子是否被生效中的规则引用"""
client = get_redis_client()
using_rule_ids = []
for r in client.scan_iter(match="rule:*"):
rule = client.hgetall(r)
strategy_group_list = json.loads(rule.get("strategys", '[]'))
for strategy_group in strategy_group_list:
strategy_list = strategy_group.get("strategy_list", [])
for stategy_data in strategy_list:
if stategy_data and stategy_data[0] == strategy_id:
using_rule_ids.append(rule["id"])
return bool(using_rule_ids), using_rule_ids
def get_queryset(self):
client = get_redis_client()
qs = client.hgetall("CONFIG_SOURCE_MAP")
new_qs = []
name = self.request.GET.get('name', None)
for name_key in qs:
item = {"name_key": name_key}
content = json.loads(qs[name_key])
name_show = content.pop('name_show', '')
if name and name not in name_show:
continue
item['name_show'] = name_show
item['content'] = json.dumps(content)
new_qs.append(item)
return new_qs
def create(self, creator_name, title, describe, status, end_time,
strategy_confs):
strategy_obj = Strategys()
new_strategy_confs = []
for name, strategy_uuids, control, custom, weight in strategy_confs:
strategy_uuids = strategy_uuids.split(';')
new_strategy_confs.append({
'name':
name,
'custom':
custom,
'control':
control,
'weight':
weight,
'strategy_list': [[
strategy_uuid,
strategy_obj.get_thresholds(strategy_uuid),
strategy_obj.get_strategy_name(strategy_uuid)
] for strategy_uuid in strategy_uuids]
})
strategy_list = sorted(new_strategy_confs,
key=lambda x: int(x["weight"]),
reverse=True)
rule_uuid = str(uuid.uuid4())
payload = {
'uuid': rule_uuid,
'user': creator_name,
'update_time': str(int(time.time())),
'end_time': datetime.strftime(end_time, '%Y-%m-%d %H:%M:%S'),
'title': title,
'describe': describe,
'status': status,
'strategys': json.dumps(strategy_list)
}
client = get_redis_client()
rule_id = client.incr(settings.LAST_RULE_ID_KEY)
payload['id'] = rule_id
rule_key = 'rule:{}'.format(rule_uuid)
client.hmset(rule_key, payload)
return str(rule_id), rule_uuid
def post(self, request, *args, **kwargs):
uuid = request.POST.get('id', None)
is_using, using_rule_ids = _check_strategy(uuid)
if is_using:
return self.render_json_response(
dict(state=False,
error=u"该策略原子正被规则{}引用".format(
(', '.join(using_rule_ids)))))
client = get_redis_client()
name = self.key_tpl.format(uuid=uuid)
data = client.hgetall(name)
values_sign = self.get_values_sign(data)
client.srem(settings.STRATEGY_SIGN_KEY, values_sign)
client.delete(name)
return self.render_json_response(dict(state=True, msg="ok"))
def get_source_data(self):
client = get_redis_client()
data_list = client.hgetall("CONFIG_SOURCE_MAP")
rs = []
for name_key in data_list:
item = {"name_key": name_key}
raw_content = json.loads(data_list[name_key])
name_show = raw_content.pop('name_show', '')
content = []
for en, type_ in raw_content.items():
zh = self.field_en_zh_map.get(en, en)
content.append({'name': en, 'desc': zh, 'type': type_})
item['name_show'] = name_show
item['content'] = content
rs.append(item)
return rs
def get_queryset(self):
form_obj = self.filter_form(data=self.request.GET)
form_obj.full_clean()
status, rule_name = form_obj.cleaned_data.get(
'status'), form_obj.cleaned_data.get('rule_name')
client = get_redis_client()
result = []
for rule_key in client.scan_iter(match="rule:*"):
rule_config = client.hgetall(rule_key)
if status and rule_config.get('status', '') != status:
continue
if rule_name and rule_name not in rule_config.get('title', ''):
continue
result.append(rule_config)
return result
def post(self, request, *args, **kwargs):
uuid = request.POST.get('uuid', None)
if uuid:
client = get_redis_client()
name = 'bool_strategy:{}'.format(uuid)
d = client.hgetall(name)
strategy_func = d['strategy_func']
required_args = BuiltInFuncs.get_required_args(strategy_func)
req_body = {}
for member in required_args:
req_body[member] = "xxxxxx"
return self.render_json_response({
'state': True,
'req_body': req_body
})
else:
return self.render_json_response({'state': False})
def post(self, request, *args, **kwargs):
try:
data = self._parse_data(request)
except ValueError as e:
return self.render_json_response({
'state': False,
'error': str(e),
})
client = get_redis_client()
name = 'rule:{}'.format(data['uuid'])
for key, value in self._build_key_value(data):
client.hset(name, key, value)
return self.render_json_response({
'state': True,
'redirect_url': reverse("rule:detail")
})
def post(self, request, *args, **kwargs):
try:
data = json.loads(request.POST.get('data', '{}'))
# 从参数中获取需要修改的规则uuid
rule_uuid = data.get('rule_uuid', None)
# 从参数中获取需要修改的策略组的下标
strategy_index = data.get('strategy_index', None)
# 从参数中获取前端传参过来的策略列表
new_strategy_confs = data.get('strategy_list', None)
assert strategy_index is not None
assert isinstance(strategy_index, int) and strategy_index >= 0
assert all((rule_uuid, new_strategy_confs))
except (AssertionError, TypeError, ValueError):
return self.render_json_response({'state': False, 'msg': '参数校验失败'})
client = get_redis_client()
try:
# 从redis中获取需要修改的规则所有数据
rule_conf = client.hgetall("rule:{}".format(rule_uuid))
# 从规则数据中获取策略组数据列表
strategy_confs = json.loads(rule_conf.get('strategys'))
# 从策略组列表中找出需要编辑的策略组
strategy_conf = strategy_confs[strategy_index]
except (TypeError, ValueError, IndexError, RedisError):
return self.render_json_response({'state': False, 'msg': '配置读取失败'})
strategys_obj = Strategys()
strategy_conf['strategy_list'] = [[
x['strategy_uuid'], x['threshold_list'],
strategys_obj.build_strategy_name_from_thresholds(
x['strategy_uuid'], x['threshold_list'])
] for x in new_strategy_confs] # 构造编辑后的策略组
strategy_confs[strategy_index] = strategy_conf # 回写策略组
rule_conf["strategys"] = json.dumps(strategy_confs)
rule_conf['user'] = request.user.username
rule_conf['update_time'] = str(int(time.time()))
try:
client.hmset("rule:{}".format(rule_uuid), rule_conf) # 回写规则数据
except RedisError:
return self.render_json_response({'state': False, 'msg': '配置回写失败'})
return self.render_json_response({'state': True})
