def get_orders_filters(
barista: str,
start_date: date = None,
end_date: date = None,
) -> Cursor:
"""
Get all order from a barista.
:param str barista: barista
:param date start_date: date start
:param date end_date: date end
:return Cursor: pymongo cursor
"""
collection = _get_mongo_db_client()[os.getenv('MONGODB_COLLECTION')]
filters = dict()
if barista is not None:
filters['barista'] = barista
if start_date is not None:
start_dt = datetime.strptime(f'{start_date} 00:00:00',
"%Y-%m-%d %H:%M:%S")
object_id_start = ObjectId.from_datetime(start_dt)
filters['_id'] = {'$gte': object_id_start}
if end_date is not None:
end_dt = datetime.strptime(f'{end_date} 00:00:00', "%Y-%m-%d %H:%M:%S")
object_id_end = ObjectId.from_datetime(end_dt)
filters['_id'] = {'$lte': object_id_end}
result = collection.find(filters)
return result
def daterange(duration): now = datetime.utcnow() current = pk > oid.from_datetime(now - duration) previous = (pk > oid.from_datetime(now - duration * 2)) & (pk < oid.from_datetime(now - duration)) return current, previous
def list_orders(
self,
barista: str,
start_date: date = None,
end_date: date = None,
) -> List[Order]:
filters = dict()
if barista is not None:
filters['barista'] = barista
if start_date is not None:
start_dt = datetime.strptime(f'{start_date} 00:00:00',
"%Y-%m-%d %H:%M:%S")
object_id_start = ObjectId.from_datetime(start_dt)
filters['_id'] = {'$gte': object_id_start}
if end_date is not None:
end_dt = datetime.strptime(f'{end_date} 00:00:00',
"%Y-%m-%d %H:%M:%S")
object_id_end = ObjectId.from_datetime(end_dt)
if filters.get('_id'):
filters['_id']['$lte'] = object_id_end
else:
filters['_id'] = {'$lte': object_id_end}
result = self._collection.find(filters)
orders = list(result)
for order in orders:
order['is_ready'] = self.__order_is_ready(order=order)
return [
MongoDBOrderHydration().hydrate(order=order) for order in orders
]
def delete_item(self, activity_id, **kwargs):
require_access(c.project.neighborhood, 'admin')
activity = Activity.query.get(_id=ObjectId(activity_id))
if not activity:
raise exc.HTTPGone
# find other copies of this activity on other user/projects timelines
# but only within a small time window, so we can do efficient searching
activity_ts = activity._id.generation_time
time_window = timedelta(hours=1)
all_copies = Activity.query.find({
'_id': {
'$gt': ObjectId.from_datetime(activity_ts - time_window),
'$lt': ObjectId.from_datetime(activity_ts + time_window),
},
'obj': activity.obj,
'target': activity.target,
'actor': activity.actor,
'verb': activity.verb,
'tags': activity.tags,
}).all()
log.info('Deleting %s copies of activity record: %s %s %s', len(all_copies),
activity.actor.activity_url, activity.verb, activity.obj.activity_url)
for activity in all_copies:
activity.query.delete()
return {'success': True}
def test_no_transition(self):
now = datetime.datetime.now()
oid_a = ObjectId.from_datetime(now)
oid_b = ObjectId.from_datetime(now - datetime.timedelta(seconds=1))
oid_c = ObjectId.from_datetime(now - datetime.timedelta(seconds=2))
self.content_store.append({"_id": oid_a}, "_id")
self.content_store.append({"_id": oid_b}, "_id")
self.content_store.append({"_id": oid_c}, "_id")
def process(context, documents):
return list(
map(
lambda oid: StateUpdate({"_id": oid}, "state2"),
[oid_a, oid_b, oid_c],
))
demo_worker, demo_work_context = self.create_demo_worker(
process, "state1", {"state2"})
demo_worker.work(demo_work_context)
assert self.actual_documents_by_id_desc() == [
{
"_id": oid_a
},
{
"_id": oid_b
},
{
"_id": oid_c
},
]
def delete_item(self, activity_id, **kwargs):
require_access(c.project.neighborhood, 'admin')
activity = Activity.query.get(_id=ObjectId(activity_id))
if not activity:
raise exc.HTTPGone
# find other copies of this activity on other user/projects timelines
# but only within a small time window, so we can do efficient searching
activity_ts = activity._id.generation_time
time_window = timedelta(hours=1)
all_copies = Activity.query.find({
'_id': {
'$gt': ObjectId.from_datetime(activity_ts - time_window),
'$lt': ObjectId.from_datetime(activity_ts + time_window),
},
'obj': activity.obj,
'target': activity.target,
'actor': activity.actor,
'verb': activity.verb,
'tags': activity.tags,
}).all()
log.info('Deleting %s copies of activity record: %s %s %s',
len(all_copies), activity.actor.activity_url, activity.verb,
activity.obj.activity_url)
for activity in all_copies:
activity.query.delete()
return {'success': True}
def hongbao():
"""
定期统计用户发送口令, 获取红包的情况
规则: 用户向派派发送口令, 获得红包
:return:
"""
from datetime import datetime
from bson import ObjectId
import re
redis = _redis_client()
# 获得已发红包的用户
processed_users = set(json.loads(redis.get('viae/viae.provisional.hongbao/processed_users') or '[]'))
# 获得红包处理进度的时间戳
utc_tz = timezone('UTC')
processed_since = redis.get('viae/viae.provisional.hongbao/processed_ts')
logger.info('Processing from %s' % processed_since)
processed_since = datetime.strptime(processed_since, '%Y-%m-%d %H:%M:%S').replace(tzinfo=utc_tz)
dummy_id = ObjectId.from_datetime(processed_since)
# 找到哪些用户发送过红包口令
pattern = re.compile(u'(体验旅行派APP领现金红包|新用户口令|领新用户红包|从微信过来领红包|下单送北京大房免费住)', re.IGNORECASE)
sender_list = mongo_hedy.Message.distinct('senderId',
{'_id': {'$gt': dummy_id}, 'receiverId': 10000, 'contents': pattern})
# 这些用户必须不在已发送红包的列表中, 并且为两天内注册的
final_senders = {}
user_dummy_id = ObjectId.from_datetime(processed_since - timedelta(days=7))
for s in filter(lambda v: v not in processed_users, sender_list):
u = mongo_yunkai.UserInfo.find_one({'userId': s, '_id': {'$gt': user_dummy_id}}, {'userId': 1, 'nickName': 1})
if not u:
continue
final_senders[u['userId']] = u
if final_senders:
# 准备报表
sections = []
for uid, user in sorted(final_senders.items(), key=lambda v: v[0]):
messages = mongo_hedy.Message.find({'senderId': uid, 'receiverId': 10000}, {'contents': 1})
c = '\n'.join([tmp['contents'] for tmp in messages])
sections.append(u'%d: %s\n%s\n\n' % (uid, user['nickName'], c))
processed_users.add(uid)
email_contents = ''.join(sections).strip()
from viae.job import send_email_to_group, send_email
logger.info('Sending hongbao stats')
send_email_to_group(groups='MARKETPLACE', subject=u'红包申请统计', body=email_contents)
# 默认7天过期
expire = 7 * 24 * 3600
redis.set('viae/viae.provisional.hongbao/processed_users', json.dumps(list(processed_users)), expire)
redis.set('viae/viae.provisional.hongbao/processed_ts',
(datetime.utcnow() - timedelta(minutes=20)).replace(tzinfo=utc_tz).strftime('%Y-%m-%d %H:%M:%S'), expire)
def _check_value_valid_not_none_(self, value):
if self.allow_none and value is None:
return
if isinstance(value, str) and not ObjectId.is_valid(value):
raise FieldOidStringInvalid(self.key, value)
if isinstance(value, datetime):
try:
ObjectId.from_datetime(value)
except struct.error:
raise FieldOidDatetimeOutOfRange(self.key, value)
def to_foreign(self, obj, name, value): # pylint:disable=unused-argument if isinstance(value, OID): return value if isinstance(value, datetime): return OID.from_datetime(value) if isinstance(value, timedelta): return OID.from_datetime(datetime.utcnow() + value) if isinstance(value, MutableMapping) and '_id' in value: return OID(value['_id']) return OID(unicode(value))
def tickets_stats_24hr():
window = datetime.utcnow() - timedelta(hours=24)
return TM.Ticket.query.find({
'_id': {
'$gte': ObjectId.from_datetime(window)
}
}).count()
def __init__(self, month, num, link, year,
news, safe_title, transcript, alt,
img, title, day, **kwargs):
dummy_id = str(ObjectId.from_datetime(datetime.datetime.now()))
db.Model.__init__(self, id=dummy_id, month=month, num=num, link=link, year=year,
news=news, safe_title=safe_title, transcript=transcript, alt=alt,
img=img, title=title, day=day, **kwargs)
def time_to_object_id(timestamps):
"""
时间戳转化为ObjectId
:param timestamps:
:return:
"""
return ObjectId.from_datetime(int(timestamps))
def purge_old_entries(self):
"""
Purge entries older than the expiry
:return:
"""
service = superdesk.get_resource_service("audit")
logger.info("Starting to purge audit logs at {}".format(utcnow()))
for _ in range(100): # make sure we don't get stuck
lookup = {
"$and": [{
"_id": {
"$lt": ObjectId.from_datetime(self.expiry)
}
}]
}
req = ParsedRequest()
req.sort = '[("_id", 1)]'
req.projection = '{"_id": 1}'
req.max_results = 1000
audits = service.get_from_mongo(req=req, lookup=lookup)
items = list(item.get("_id") for item in audits)
if len(items) == 0:
logger.info("Finished purging audit logs at {}".format(
utcnow()))
return
logger.info("Found {} audit items at {}".format(
len(items), utcnow()))
service.delete_ids_from_mongo(items)
logger.warning("Audit purge didn't finish in 100 iterations.")
def load(self):
self.log.debug("[LOAD] legacy_processor is preparing ...")
# extract sensors id list from mongoDB
sensorID_list = dict()
try:
_iter = self.MongoClient.typecapteur.find()
# parse 'typecapteur' collection (e.g temperature, co2, humidity etc etc)
for document in _iter:
# parse sensors: each sensor has an ID
# key nomCapteur: <topic/unitID/subID> e.g u4/campusfab/temperature/auto_92F8/79
# value = list( id associated with <topic/unitID/subID>, id piece )
for capteur_doc in document["Capteurs"]:
sensorID_list[
capteur_doc["idCapteur"]] = capteur_doc["nomCapteur"]
except Exception as e:
self.log.warning("while getting list of capteur " + str(e))
print("sensorID: " + str(sensorID_list))
# mongodb filter
_mongo_filter = dict()
# | start_id
if (self._start_id is not None):
try:
_mongo_filter['_id'] = {"$gte": ObjectId(self._start_id)}
except Exception as ex:
self.log.warning("while creating mongoDB filter from _id: " +
str(ex))
sys.exit(1)
# | start_date
elif (self._start_date is not None):
try:
# generate an id from data
# [apr.20] there exist a two hours shift between ObjectId time and real utc measuretime ?!?!
_mongo_filter['_id'] = {
"$gte": ObjectId.from_datetime(self._start_date)
}
except Exception as ex:
self.log.warning("while creating mongoDB filter from _id: " +
str(ex))
# self._shutdownEvent.set()
sys.exit(1)
# generate mongoDB iterator
_src_iterator = self.MongoClient[self.coll_name].find(_mongo_filter)
# _src_iterator = self._src.find( self._collection_name, query=_mongo_filter, skip=1000000 )
# generate importer iterator
cur_iter = dict()
cur_iter['sensorID'] = sensorID_list
cur_iter['iterators'] = [_src_iterator]
self.overall_processed = 0
print(_src_iterator[0])
# log.info("MongoDB connection is UP featuring:\n\t{0:,d} measures :)\n\t{1:,d} unmanaged measures :(".format(mydb.measure.count(),mydb.failedData.count()) )
return cur_iter
def test_all_valid_multiple_transitions(self):
now = datetime.datetime.now()
oid_a = ObjectId.from_datetime(now)
oid_b = ObjectId.from_datetime(now - datetime.timedelta(seconds=1))
oid_c = ObjectId.from_datetime(now - datetime.timedelta(seconds=2))
self.content_store.append({"_id": oid_a, "_state": "state1"}, "_id")
self.content_store.append({"_id": oid_b, "_state": "state1"}, "_id")
self.content_store.append({"_id": oid_c, "_state": "state1"}, "_id")
def process(context, documents):
return list(
map(
lambda oid: StateUpdate({"_id": oid}, "state2",
{"$set": {
"attr1": "a"
}}),
[oid_a, oid_b],
)) + list(
map(
lambda oid: StateUpdate({"_id": oid}, "state3",
{"$set": {
"attr2": "b"
}}),
[oid_c],
))
demo_worker, demo_work_context = self.create_demo_worker(
process, "state1", {"state2", "state3"})
demo_worker.work(demo_work_context)
assert self.actual_documents_by_id_desc() == [
{
"_id": oid_a,
"_state": "state2",
"attr1": "a"
},
{
"_id": oid_b,
"_state": "state2",
"attr1": "a"
},
{
"_id": oid_c,
"_state": "state3",
"attr2": "b"
},
]
def referrer_stat():
"""
统计用户注册时的邀请信息
:return:
"""
from viae.database import redis_client, mongo_yunkai
from pytz import timezone
from bson import ObjectId
# 上一次处理邀请是什么时候
ts = redis_client.get('viae/viae.job.referrer_stat/ts')
if not ts:
ts = datetime.utcnow().replace(year=2012, tzinfo=timezone('UTC'))
else:
ts = datetime.strptime(ts, '%Y-%m-%d %H:%M:%S').replace(tzinfo=timezone('UTC'))
dummy_id = ObjectId.from_datetime(ts)
# 这一时间段中, 哪些注册用户是有referrer的?
referrers = {} # {100056: {nickname: 'Zephyre', inviting: [100256, 100884]}}
user_cache = {} # {100056: userInfo}
for new_user in mongo_yunkai.UserInfo.find({'_id': {'$gt': dummy_id}, 'referrer': {'$ne': None}},
{'userId': 1, 'nickName': 1, 'referrer': 1}):
# 缓存用户
new_user_id = long(new_user['userId'])
user_cache[new_user_id] = new_user
# 查找推荐人
referrer_id = long(new_user['referrer'])
if referrer_id not in referrers:
r = mongo_yunkai.UserInfo.find_one({'userId': referrer_id}, {'userId': 1, 'nickName': 1})
referrers[referrer_id] = {'nickname': r['nickName'], 'inviting': set([])}
user_cache[r['userId']] = r
# referrer就是邀请人
referrer = referrers[referrer_id]
referrer['inviting'].add(new_user_id)
# 构造统计报表
time_range = ' ~ '.join(map(lambda v: str(v), [ts, datetime.now().replace(tzinfo=timezone('UTC'))]))
sections = []
# 按照邀请人数的数量, 从多到少排序
for uid, info in sorted(referrers.items(), key=lambda v: len(v[1]['inviting']), reverse=True):
head = u'%s(%d)邀请了%d位用户:' % (user_cache[uid]['nickName'], uid, len(info['inviting']))
invited_desc_list = []
for invited_uid in info['inviting']:
invited_desc_list.append(u'%s(%d)' % (user_cache[invited_uid]['nickName'], invited_uid))
invited_desc = '\n'.join(invited_desc_list)
sections.append('%s\n%s' % (head, invited_desc))
if sections:
send_email_to_group('MARKETPLACE', u'新用户邀请状况统计', time_range + '\n\n' + '\n\n'.join(sections))
now_ts = (datetime.utcnow().replace(tzinfo=timezone('UTC')) - timedelta(hours=1)).strftime('%Y-%m-%d %H:%M:%S')
redis_client.set('viae/viae.job.referrer_stat/ts', now_ts, 7 * 24 * 3600)
def _get_records_by_date(date):
""" Get learning records from LRS (Querying by specific date) """
result = lrs.find(
{
"actor.name": session['username'],
"_id": {
"$gt": ObjectId.from_datetime(date),
"$lt": ObjectId.from_datetime(date + timedelta(days=1))
}
}, {
"actor.name": 1,
"action": 1,
"eventTime": 1,
"object.name": 1
})
return result
def test_cleanup_orphaned_versions_integration(library):
_id = ObjectId.from_datetime(dt(2013, 1, 1))
with patch('bson.ObjectId', return_value=_id):
with ArcticTransaction(library, symbol, 'u1', 'l1') as mt:
mt.write(symbol, ts1)
assert library._versions.find({'parent': {'$size': 1}}).count() == 1
library._cleanup_orphaned_versions(False)
assert library._versions.find({'parent': {'$size': 1}}).count() == 1
def test_cleanup_orphaned_versions_integration(library):
_id = ObjectId.from_datetime(dt(2013, 1, 1))
with patch('bson.ObjectId', return_value=_id):
with ArcticTransaction(library, symbol, 'u1', 'l1') as mt:
mt.write(symbol, ts1)
assert mongo_count(library._versions, filter={'parent': {'$size': 1}}) == 1
library._cleanup_orphaned_versions(False)
assert mongo_count(library._versions, filter={'parent': {'$size': 1}}) == 1
def find(self, start, end, limit=50, *args, **kwargs):
"""
find by creation date, using start and end dates as range
"""
# check if spec has been specified, build on top of it
fc = kwargs.get('spec', dict())
# filter _id on start and end dates
fc['_id'] = {'$gte': ObjectId.from_datetime(start),
'$lte': ObjectId.from_datetime(end)}
if not self.collection:
collection_name = kwargs.get('collection_name',
MONGODB_DEFAULT_COLLECTION)
self.set_collection(collection_name)
return self.collection.find(fc, limit=limit)
def general_obj_from_time(from_datetime=None, time_delta=None):
if from_datetime is None or not isinstance(from_datetime,
datetime.datetime):
from_datetime = datetime.datetime.now() # 时间元组
if time_delta: # time_delta 是datetime.timedelta 类型,可以进行时间的加减运算
from_datetime = from_datetime + time_delta
return ObjectId.from_datetime(from_datetime)
def delete_older_than(cls, datetime_: datetime) -> int:
"""
Delete all batches older than the given datetime.
:param datetime_: the datetime before which the batches are to be deleted.
:return: the number of batches that were deleted.
"""
return cls.objects.filter(
id__lte=ObjectId.from_datetime(datetime_)).delete()
def _cast_to_desired_type_(self, value) -> Any:
if isinstance(value, datetime):
return ObjectId.from_datetime(value)
elif isinstance(value, str):
return ObjectId(value)
elif isinstance(value, ObjectId):
return value
else:
raise FieldValueInvalid(self.key, value)
def _delete_recent_module_(self, keyword):
"""Delete modules which is created and marked inactive within `Bot.AutoReply.DeleteDataMins` minutes."""
now = now_utc_aware()
self.delete_many(
{
OID_KEY: {
"$lt":
ObjectId.from_datetime(now),
"$gt":
ObjectId.from_datetime(now - timedelta(
minutes=Bot.AutoReply.DeleteDataMins))
},
AutoReplyModuleModel.KEY_KW_CONTENT: keyword,
AutoReplyModuleModel.Active.key: False
},
collation=case_insensitive_collation
if AutoReply.CaseInsensitive else None)
def get_object_id(from_datetime=None, span_days=0, span_hours=0, span_minutes=0, span_weeks=0):
'''根据时间手动生成一个objectid，此id不作为存储使用'''
if not from_datetime:
from_datetime = datetime.datetime.now()
from_datetime = from_datetime + datetime.timedelta(days=span_days,
hours=span_hours,
minutes=span_minutes,
weeks=span_weeks)
return ObjectId.from_datetime(generation_time=from_datetime)
def unprocessed_before(cls, datetime_: datetime) -> bool:
"""
Assess whether there are unprocessed Uploads older than the specified datetime.
:param datetime_: the datetime to check against.
:return: True if there are unprocessed Uploads older than the specified datetime, False
otherwise.
"""
return (cls.objects.filter(id__lte=ObjectId.from_datetime(datetime_),
to_publish=True).count() > 0)
def find(self, start, end, limit=50, *args, **kwargs):
"""
find by creation date, using start and end dates as range
"""
# check if spec has been specified, build on top of it
fc = kwargs.get('spec', dict())
# filter _id on start and end dates
fc['_id'] = {
'$gte': ObjectId.from_datetime(start),
'$lte': ObjectId.from_datetime(end)
}
if not self.collection:
collection_name = kwargs.get('collection_name',
MONGODB_DEFAULT_COLLECTION)
self.set_collection(collection_name)
return self.collection.find(fc, limit=limit)
def comment_cud(post_id, comment_id):
if request.method == 'POST':
comment = request.get_json()
comment['timestamp'] = str(datetime.datetime.now())
comment['id'] = ObjectId.from_datetime(datetime.datetime.now())
database['posts'].update({'_id': ObjectId(post_id)},
{'$push': {
'comments': comment
}})
comment['id'] = str(comment['id'])
comm_user = ugd({'_id': ObjectId(comment['commenting_user'])})
comment['commenting_user'] = comm_user
return comment
elif request.method == 'PUT':
comment = request.get_json()
comment['timestamp'] = str(datetime.datetime.now())
new_comment = comment
new_comment['commenting_user'] = comment['commenting_user']['id']
#Remove old comment
database['posts'].update(
{'_id': ObjectId(post_id)},
{'$pull': {
'comments': {
'id': ObjectId(comment_id)
}
}})
# Insert new comment
database['posts'].update({'_id': ObjectId(post_id)},
{'$push': {
'comments': new_comment
}})
return comment
elif request.method == 'DELETE':
comment = database['posts'].find({"_id": ObjectId(post_id)},
{'comments': 1})
comment = [x['comments'] for x in comment][0]
comment = [x for x in comment if x['id'] == ObjectId(comment_id)][0]
comment['id'] = str(comment['id'])
database['posts'].update(
{'_id': ObjectId(post_id)},
{'$pull': {
'comments': {
'id': ObjectId(comment_id)
}
}})
return comment
return {}
def hot(top, days=1):
"""
dtype : day, week, month
get top hot news by dtype
"""
now = datetime.datetime.now()
start = now + datetime.timedelta(-days)
cond = {'_id':{'$gte':ObjectId.from_datetime(start)}}
r,v = m_page(TName,size=top,sort=[('hot',-1),('_id',-1)],**cond)
return v
def __init__(self, first_name, last_name, email, password, **kwargs):
"""Create instance."""
dummy_id = str(ObjectId.from_datetime(datetime.datetime.now()))
db.Model.__init__(self,
id=dummy_id,
first_name=first_name,
last_name=last_name,
email=email,
password=password,
**kwargs)
self.set_password(password)
def object_id_from_datetime(from_datetime,
span_days=None,
span_hours=None,
span_minutes=None,
span_weeks=None):
'''根据时间手动生成一个objectid，此id不作为存储使用'''
print from_datetime
dateArray = datetime.datetime.utcfromtimestamp(from_datetime)
vtime = dateArray - datetime.timedelta(days=span_days)
return ObjectId.from_datetime(generation_time=vtime)
def remove_old_stories():
client = get_mongo_client()
db = client.get_default_database()
article_collection = db['articles']
two_days_ago = datetime.utcnow() - timedelta(days=2)
two_days_ago = ObjectId.from_datetime(two_days_ago)
query = {'_id': {'$lt': two_days_ago}}
article_collection.remove(query)
close_mongo_client(client)
def delete_older_than(cls, datetime_: datetime) -> None:
"""
Delete all Uploads older than the given datetime.
:param datetime_: the datetime to check against.
"""
objects = cls.objects.filter(id__lte=ObjectId.from_datetime(datetime_))
n_deleted = objects.delete()
_LOGGER.info(
"Upload documents deletion completed.",
extra=dict(n_deleted=n_deleted,
created_before=datetime_.isoformat()),
)
def test_id_based_key(self):
"""Test ID-based key generation."""
# From record
rec = IdBasedKeySample()
rec.id_ = ObjectId.from_datetime(dt.datetime.fromtimestamp(123456789))
key1 = rec.to_key()
self.assertEqual(key1, 'IdBasedKeySample=' + str(rec.id_))
# Using static method
key1 = rec.to_key()
key2 = IdBasedKeySample.create_key(id_=rec.id_)
self.assertEqual(key2, 'IdBasedKeySample=' + str(rec.id_))
def add_order(order: Order, ) -> Order:
"""
Add a new document at mongoDB.
:param Order order: order
:return Order: order inserted
"""
collection = _get_mongo_db_client()[os.getenv('MONGODB_COLLECTION')]
now = datetime.now()
order.dt_created = now.strftime("%Y-%m-%d %H:%M:%S")
collection.insert_one(
document=dict(_id=ObjectId.from_datetime(now), **order.dict()))
return order
def purge_old_entries(self):
"""Purge entries older than the expiry"""
logger.info("Starting to purge audit logs at {}".format(utcnow()))
service = superdesk.get_resource_service("audit")
time_start = time()
service.delete_from_mongo(
{"_id": {
"$lt": ObjectId.from_datetime(self.expiry)
}})
time_diff = time() - time_start
logger.info(
f"Finished purging audit logs. Took {time_diff:.4f} seconds")
def delete_older_than(cls, datetime_: datetime) -> None:
"""
Delete all batches older than the given datetime.
:param datetime_: the datetime before which the batches are to be deleted.
"""
objects = cls.objects.filter(id__lte=ObjectId.from_datetime(datetime_))
count = objects.count()
objects.delete()
_LOGGER.info(
"BatchFile documents deletion completed.",
extra=dict(n_deleted=count, created_before=datetime_.isoformat()),
)
def setup_class(cls):
setup_connection('mongodb://localhost',
'YUCCASTATS_TESTS_DB_STATS',
'test_statistics',
'YUCCASTATS_TESTS_DB_SUPPORT')
tenants = [
{"idTenant": -4, "tenantName": "smartlab",
"tenantDescription": "Smartlab and reference environment",
"tenantCode": "test-smartlab",
"dataCollectionName": "data",
"dataCollectionDb": "YUCCASTATS_TESTS_DB_smartlab",
"measuresCollectionName": "measures",
"measuresCollectionDb": "YUCCASTATS_TESTS_DB_smartlab",
"socialCollectionName": "social",
"socialCollectionDb": "YUCCASTATS_TESTS_DB_smartlab",
"mediaCollectionName": "media",
"mediaCollectionDb": "YUCCASTATS_TESTS_DB_smartlab",
"archiveDataCollectionName": "archivedata",
"archiveDataCollectionDb": "YUCCASTATS_TESTS_DB_smartlab",
"archiveMeasuresCollectionName": "archivemeasures",
"archiveMeasuresCollectionDb": "YUCCASTATS_TESTS_DB_smartlab"},
{"idTenant": -1, "tenantName": "csp",
"tenantDescription": "CSP - Innovazione nelle ICT",
"tenantCode": "test-csp",
"dataCollectionName": "data",
"dataCollectionDb": "YUCCASTATS_TESTS_DB_csp",
"measuresCollectionName": "Measures",
"measuresCollectionDb": "YUCCASTATS_TESTS_DB_csp",
"socialCollectionName": "social",
"socialCollectionDb": "YUCCASTATS_TESTS_DB_csp",
"mediaCollectionName": "media",
"mediaCollectionDb": "YUCCASTATS_TESTS_DB_csp",
"archiveDataCollectionName": "archivedata",
"archiveDataCollectionDb": "YUCCASTATS_TESTS_DB_csp",
"archiveMeasuresCollectionName": "archivemeasures",
"archiveMeasuresCollectionDb": "YUCCASTATS_TESTS_DB_csp"},
]
get_support_db().tenant.insert(tenants)
cls.tenants = [t['tenantCode'] for t in tenants]
cls.counts = {}
for tenant_info in tenants:
cols = get_data_collections(tenant_info)
for idx, col in enumerate(cols):
items_to_insert = (idx+1)*10
cls.counts[col.name] = items_to_insert
ids = [ObjectId.from_datetime(datetime(2001, 1, 1, 1, x) + timedelta(days=x))
for x in range(items_to_insert)]
col.insert((dict(count=i, _id=ids[i]) for i in range(items_to_insert)))
def find_tokens(cls, kw, from_id=None):
first_request = False;
if not from_id:
d = datetime.datetime.utcnow() - datetime.timedelta(seconds=cls.TTL)
from_id = ObjectId.from_datetime(d)
first_request = True
q = mongoengine.Q(tokens__all=kw) & mongoengine.Q(id__gt=from_id)
obj = cls.objects(q)
if not len(obj) and first_request:
obj = cls.objects(mongoengine.Q(tokens__all=kw))
return obj[:25]
def put(self,message_id):
'''发布评论'''
args = add_comment_parser.parse_args()
message = Message.objects(id=message_id).first()
user = User.objects(id=args['user_id']).first()
comment = Comment()
comment.comment_id = str(ObjectId.from_datetime(generation_time=datetime.datetime.now()))
comment.content = args['content']
comment.publisher = user.name
comment.publisher_id = str(user.id)
comment.publish_time = time.time() * 1000
message.comments.append(comment)
message.update(comments = message.comments)
return {'code':200,'msg':'发布评论成功'}
def get_by_table_id(self, table_id, since_date):
table_id = utils.as_object_id(table_id)
if since_date:
# Create a dummy chat id which is then used to ensure that only
# chats which were created after the since date are returned
query_chat_id = ObjectId.from_datetime(since_date)
query = self.db.chat.find({"table_id": table_id, "_id": {"$gt": query_chat_id}})
else:
query = self.db.chat.find({"table_id": table_id})
results = list(query.sort("_id", 1).limit(100))
chats = []
for document in results:
chats.append(ChatMessage().from_db(document))
return chats
def _monitor(self, collection, query_key, query):
# TODO: Handle doc removal
# TODO: Batch requests
try:
query = {'doc.{0}'.format(k): v for k, v in query.items()}
query['_id'] = {'$gt': ObjectId.from_datetime(datetime.utcnow())}
opslog = self.opslog(collection)
cursor = opslog.find(query, tailable=True, await_data=True)
item = tail(cursor.tail)
while True:
ops, err = next(item)
if err:
raise err
print(ops)
if not ops['doc'].get('_id'):
_log.warn('Opslog for collection "{0}" contains a '
'document with no _id'.format(collection))
continue
if ops['op'] == 'insert':
doc = ops['doc']
elif ops['op'] == 'update':
doc = ops['updated']
response = json.dumps({
'response': 'subscribe',
'query': query_key,
'collection': collection,
'result': [doc],
})
for request in list(self.subscriptions[query_key]):
if request.is_closed:
self.subscriptions[query_key].remove(request)
continue
request.send(response)
if not self.subscriptions[query_key]:
break
except Exception as e:
_log.exception(e)
finally:
if query_key in self.subscriptions:
del self.subscriptions[query_key]
def _get_or_generate_id(self, doc):
return doc[self.doc_id] if self.doc_id in doc else ObjectId.from_datetime(datetime.now())
def id_between(after, before, query={}):
query.update({
'$and': [{'_id': {'$gte': ObjectId.from_datetime(after),
'$lte': ObjectId.from_datetime(before)}}]
})
return query
def tickets_stats_24hr():
window = datetime.utcnow() - timedelta(hours=24)
return TM.Ticket.query.find({'_id': {'$gte': ObjectId.from_datetime(window)}}).count()
def test_document_assignment(self, Sample):
now = _dt.utcnow().replace(microsecond=0)
instance = Sample({'_id': ObjectId.from_datetime(now)})
assert instance.field.replace(tzinfo=None) == now
def oid_con(seed):
value = int(seed)
dt = datetime.datetime.fromtimestamp(value)
return ObjectId.from_datetime(dt)
