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