def save(self, *args, **kwargs):
db = get_mongo_client()
cd = self.cleaned_data
event_code = str(uuid.uuid4())
pay_load = dict(event_code=event_code, event_name=cd['event_name'])
db.menu_event.insert_one(pay_load)
return event_code
def clean_event_name(self):
db = get_mongo_client()
event_name = self.cleaned_data['event_name'].strip()
res = db.menu_event.find_one({'event_name': event_name})
if res:
raise forms.ValidationError(_("The project name already exists"))
return event_name
def save(self):
db = get_mongo_client()
if self.entity_id:
entity_id = ObjectId(self.entity_id)
return db[self.COLLECTION].update_one({'_id': entity_id},
{'$set': self.values})
else:
return db[self.COLLECTION].insert_one(self.values)
def tearDownClass(cls):
super(BaseTestCase, cls).tearDownClass()
# Clean up the test library
db = get_mongo_client()
db.client.drop_database(db.name)
client = get_redis_client()
client.flushdb()
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=_("ID is illegal")))
redis_values_should_remove = defaultdict(list)
menus_records = list(db['menus'].find(
{
'_id': {
"$in": obj_ids
},
'menu_status': 'valid'
}, {
'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=_("Records don't exist")))
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': 'invalid',
'creator': request.user.username,
'create_time': datetime.now(),
}
try:
db.menus.update_many({'_id': {
"$in": obj_ids
}}, {"$set": update_payload})
# Simultaneous delete redis data
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=_("Operation failed, please try again later")))
return self.render_json_response(dict(state=True, msg=_("ok")))
def _build_event_choices(cls):
db = get_mongo_client()
choices = [(x["event_code"], x["event_name"])
for x in db['menu_event'].find({},
projection={
'_id': False,
'event_code': True,
'event_name': True
})]
return choices
def raw_query(self, query):
db = get_mongo_client()
docs = db[self.collection].find(query).sort('_id', pymongo.DESCENDING)
result = []
for doc in docs:
try:
result.append(self.klass(**doc))
except TypeError:
logger.error('Permission data corruption! class: {}, doc: {}'
.format(self.klass, doc))
return result
def save(self, *args, **kwargs):
"""When adding, update is add value if there is the same dimension value, project plus ListType"""
cd = self.cleaned_data
value_list = cd['value']
chinese_name = self.request.user.username
error_datas = []
end_time = cd['end_time'].replace(tzinfo=None)
db = get_mongo_client()
redis_client = get_redis_client()
for value in value_list:
payload = dict(end_time=end_time,
menu_desc=cd['menu_desc'],
menu_status='valid',
create_time=datetime.datetime.now(),
creator=chinese_name)
value = value.strip()
dimension = cd['dimension']
menu_type = cd['menu_type']
event_code = cd.get('event_code')
condition = dict(value=value,
event_code=event_code,
menu_type=menu_type,
dimension=dimension)
res = db.menus.find_one(condition)
try:
if not res:
payload.update(condition)
db.menus.insert_one(payload)
else:
db.menus.update_one({"_id": res.get("_id", '')},
{"$set": payload})
# 同时写redis
redis_key = build_redis_key(event_code, dimension, menu_type)
if redis_key:
redis_client.sadd(redis_key, value)
except Exception:
error_datas.append(value)
return error_datas
def add_element_to_menu(event_code,
menu_type,
dimension,
element,
end_time=None,
menu_desc=None):
"""
Add elements to the list
:param str|unicode event_code: List item code
:param str|unicode menu_type: ListType black white gray
:param str|unicode dimension: List dimensions user_id / ip / ...
:param str|unicode element: Elements placed on the list
:param datetime end_time: Failure time
:param str|unicode menu_desc: Note
:return:
"""
end_time = (end_time or datetime.now() + timedelta(hours=1))
menu_desc = menu_desc or get_sample_str(15)
payload = dict(end_time=end_time,
menu_desc=menu_desc,
menu_status='valid',
create_time=datetime.now(),
creator='test',
value=element,
event_code=event_code,
dimension=dimension,
menu_type=menu_type)
db = get_mongo_client()
insert_result = db['menus'].insert_one(payload)
redis_client = get_redis_client()
redis_key = build_redis_key(event_code,
dimension=dimension,
menu_type=menu_type)
if redis_key:
redis_client.sadd(redis_key, element)
return str(insert_result.inserted_id)
def post(self, request, *args, **kwargs):
db = get_mongo_client()
event_code = request.POST.get('id', '')
res = db.menu_event.find_one({'event_code': event_code})
if not res:
return self.render_json_response(
dict(state=False, error=_("not found")))
# 1. Make sure it's not used by list management
if db.menus.find_one({"event": event_code}):
return self.render_json_response(
dict(state=False, error=_("List generated, delete cannot be")))
# 2. Make sure it's not used by a list policy
is_using = self._check_event(event_code)
if is_using:
return self.render_json_response(
dict(state=False,
error=_("List Policy generated, unable to delete")))
db.menu_event.delete_one({'event_code': event_code})
return self.render_json_response(dict(state=True, msg=_("ok")))
def get_qs_count(self):
db = get_mongo_client()
count = db[self.collection_name].count()
return count
def get_queryset(self):
db = get_mongo_client()
qs = db[self.collection_name].find()
return qs
def _get_test_mongo_client(db_name='test_risk_control'):
return get_mongo_client(db_name)
def get_qs_count(self):
db = get_mongo_client()
count = db[self.collection_name].find(
self.build_filter_query()).count()
return count
def get_queryset(self):
db = get_mongo_client()
qs = db[self.collection_name].find(self.build_filter_query(),
sort=[("create_time",
pymongo.DESCENDING)])
return qs
def create_menu_event(event_code=None, event_name=None):
db = get_mongo_client()
payload = dict(event_code=event_code or str(uuid.uuid4()),
event_name=event_name or get_sample_str(length=8))
db['menu_event'].insert_one(payload)
return payload
def render_event(value):
db = get_mongo_client()
res = db['menu_event'].find_one({'event_code': value}) or {}
return res.get('event_name', value)
def render_event_code(value):
db = get_mongo_client()
res = db.menu_event.find_one({'event_code': value})
if not res:
return value
return res.get('event_name', value)
def delete_by_element(self, container, element):
db = get_mongo_client()
db[self.collection].update({}, {'$pull': {container: element}})
def all_fields(self):
db = get_mongo_client()
return db[self.collection].find({})
def all(self, meta_only=False):
db = get_mongo_client()
projection = {f: True for f in self.projection_fields} if meta_only else {}
return db[self.collection].find(projection=projection)
def delete(self):
db = get_mongo_client()
if not self.entity_id:
return
entity_id = ObjectId(self.entity_id)
db[self.COLLECTION].delete_one({'_id': entity_id})
def get(self, item):
db = get_mongo_client()
doc = db[self.collection].find_one({self.primary_key: item})
if not doc:
return None
return self.klass(**doc)
def multi_get(self, items):
db = get_mongo_client()
docs = db[self.collection].find({self.primary_key: {'$in': items}}) \
.sort('_id', pymongo.DESCENDING)
return [self.klass(**doc) for doc in docs]
def get_by_id(self, entity_id):
db = get_mongo_client()
doc = db[self.collection].find_one({'_id': ObjectId(entity_id)})
if not doc:
return None
return self.klass(**doc)
def _build_event_choices(cls):
db = get_mongo_client()
choices = [(x["event_code"], x["event_name"])
for x in db['menu_event'].find()]
return choices
