def testMoveWhenEmpty(self):
# 5 mins of data, every 30 secs = 10 entries per entry type. There are
# 3 entry types, so 30 entries
# First all the entries are in the usercache
self.assertEqual(len(self.uc1.getMessage()), 30)
self.assertEqual(len(list(self.ts1.find_entries())), 0)
# Then we move entries for user1 into longterm
enuah.UserCacheHandler.getUserCacheHandler(
self.testUserUUID1).moveToLongTerm()
# So we end up with all user1 entries in longterm
self.assertEqual(len(self.uc1.getMessage()), 0)
self.assertEqual(len(list(self.ts1.find_entries())), 30)
# Add an invalid type
edb.get_usercache_db().insert({
'user_id':
self.testUserUUID1,
'_id':
boi.ObjectId('572d3621d282b8f30def7e85'),
'data': {
u'transition': None,
'currState': u'STATE_ONGOING_TRIP'
},
'metadata': {
'plugin': 'none',
'write_ts': self.curr_ts - 25,
'time_zone': u'America/Los_Angeles',
'platform': u'ios',
'key': u'statemachine/transition',
'read_ts': self.curr_ts - 27,
'type': u'message'
}
})
# Re-run long-term for the user
enuah.UserCacheHandler.getUserCacheHandler(
self.testUserUUID1).moveToLongTerm()
# That was stored in error_db, no errors in main body
self.assertEqual(
edb.get_timeseries_error_db().find({
"user_id": self.testUserUUID1
}).count(), 1)
self.assertEqual(len(self.uc1.getMessage()), 0)
self.assertEqual(len(list(self.ts1.find_entries())), 30)
def add_file(oid, file_in):
''' Attaches the given file to the manifest represented by oid.
has a true/false return type to show result of addition. Can fail if
given an invalid oid, or if there was no file provided.'''
if(oid and file_in):
#make sure that the manifest exists before we write the file to the database
newOID = objectid.ObjectId(oid)
doc = m_col.find_one({"_id": newOID})
if(doc):
file_id = fs.put(file_in)
if(file_id):
m_col.find_one_and_update({"_id": newOID}, {"$push": {"file_ids": file_id}}) #we need to add the file id to the file id list
return "True"
return "Did not insert file"
return "Did not find document"
return "Did not get oid or file_in" #we failed somewhere
def get(self):
_imgid = self.get_argument('imgid', default=None)
referer = self.get_argument('referer', default=None)
#referer = base64.decodestring(referer)
imgid = None
try:
imgid = objectid.ObjectId(_imgid)
if not mongo.image.find_one({'_id': imgid}):
raise
except:
raise
mongo.image.update({'_id': imgid}, {'$inc': {'favs': -1}})
mongo.private.remove({'uid': self.session.uid, 'imgid': imgid})
def get(self):
questionary_service = QuestionaryService()
questionary = questionary_service.find_questionary(
questionary_id=objectid.ObjectId(
self.get_argument(name="_id")
)
)
self.write(
json.dumps(
{
"_id": str(questionary['_id']),
"patient_id": questionary['patient_id'],
"question_answer_pairs": questionary['question_answer_pairs']
}
)
)
def POST(self):
param=web.input(id="")
artdata={
"title": param.title,
"brief": param.brief,
"author": param.author,
"content": param.content,
"type":param.type,
"time":datetime.datetime.now(),
}
if len(param.id)==0:
res=database.news.insert_one(artdata)
return DefJsonEncoder.encode({"id":str(res.inserted_id),"res":0})
else:
database.news.update_one({"_id":objectid.ObjectId(param.id)},{"$set":artdata})
return DefJsonEncoder.encode({"id":param.id,"res": 0})
def cache_hot_images(self, days):
from lib.encoder import MongoEncoder
self.delete_cache()
imgs = [i[0] for i in self._get_hot_images(days)]
imgs.reverse()
print 'hot image size', len(imgs)
for i in imgs:
try:
img = mongo.image.find_one({'_id': objectid.ObjectId(i)})
if img:
self.c.rpush(self.name, json.dumps(img, cls=MongoEncoder))
except:
raise
continue
async def on_record_change(self, e):
rdoc = await record.get(objectid.ObjectId(e['value']),
record.PROJECTION_PUBLIC)
if rdoc['uid'] != self.user['_id'] or \
rdoc['domain_id'] != self.domain_id or rdoc['pid'] != self.pid:
return
# check permission for visibility: contest
if rdoc['tid']:
now = datetime.datetime.utcnow()
tdoc = await contest.get(rdoc['domain_id'], rdoc['tid'])
if (not contest.RULES[tdoc['rule']].show_func(tdoc, now) and
(self.domain_id != tdoc['domain_id'] or
not self.has_perm(builtin.PERM_VIEW_CONTEST_HIDDEN_STATUS))):
return
# TODO(iceboy): join from event to improve performance?
self.send(rdoc=rdoc)
def fetch_userboards(username):
db = DatabaseConnection()
coluser = db[User.table_name]
colboard = db[Board.table_name]
colimg = db[Img.table_name]
item = coluser.find_one({"username": username})
if len(item["boardids"]) == 0: return None
boarddocs_and_imgdocs = []
for boardid in item["boardids"]:
boarddoc = colboard.find_one({"_id": objectid.ObjectId(boardid)})
imgdocs = colimg.find({
"username": boarddoc["username"],
"board": boarddoc["board"]
})
boarddocs_and_imgdocs.append((boarddoc, imgdocs))
return reversed(boarddocs_and_imgdocs)
def post_factory(uid):
"""
Make Post or ResponsePost class from DB data.
uid -- Identity key in DB.
return -- Post or ResponsePost object.
"""
db_res = db.posts.find_one({'_id': objectid.ObjectId(uid)})
if 'link' in db_res:
re_post = response_post.ResponsePost('', '', '', '')
re_post.get_post(uid)
else:
re_post = post.Post('', '', '')
re_post.get_post(uid)
return re_post
def getQuestionsByQuestionID(questionID):
questionID = oID.ObjectId(questionID) if (
type(questionID) != oID.ObjectId) else questionID
questionDoc = questionCol.find_one({'_id': questionID})
if (questionDoc != None):
answerList = AnswerClass.Answer.getAnswersByAnswersCursor(
questionDoc['answers'])
likeList = LikeClass.Like.getLikesByLikesCursor(
questionDoc['likes'])
question=Question(questionDoc['userID'],questionDoc['userMail'],questionDoc['title'],questionDoc['detail'],questionDoc['videoLink']\
,questionDoc['videoTime'],questionDoc['point'],answerList,likeList,questionDoc['_id'])
return question
else:
return None
async def save_comment(self, link_id, uid, nick, content):
await self.comment_collection.insert({
'link_id': link_id,
'uid': uid,
'nick': nick,
'comment': content,
'timestamp': self.timestamp,
'date': int(time.time())
})
await self.link_collection.update({'_id': objectid.ObjectId(link_id)},
{'$inc': {
'comments': 1
}})
# ACCOUNT ACTION
await self.update_account(uid, "评论")
def _reset_password(self, auth_request, user_id, user_auth_dict):
"""Resets the user's password."""
try:
is_token_valid = _assert_valid_salt(
auth_request.auth_token, auth_request.email + user_id +
user_auth_dict.get('hashedPassword'), int(time.time()))
if not is_token_valid:
flask.abort(403, "Le jeton d'authentification est périmé.")
except ValueError as error:
flask.abort(
401,
"Le jeton d'authentification n'a pas été généré par ce serveur : %s."
% error)
self._db.user_auth.replace_one(
{'_id': objectid.ObjectId(user_id)},
{'hashedPassword': auth_request.hashed_password})
def get(self, cateid):
try:
cid = objectid.ObjectId(cateid)
except:
raise tornado.web.HTTPError(404)
category = theme_mongo.category.find_one({'_id': cid})
if not category:
raise tornado.web.HTTPError(404)
apks = theme_mongo.apk.find({'cid': cid})
self.render(
"list.html",
apklist=apks,
category=category,
type=2,
)
def get(self, cateid):
print 'edit handler', cateid
try:
cid = objectid.ObjectId(cateid)
except:
raise tornado.web.HTTPError(404)
cate = theme_mongo.category.find_one({'_id': cid})
if not cate:
raise tornado.web.HTTPError(404)
self.render(
"editCate.html",
context=self.context,
category=cate,
message='',
)
def addOffer():
# Bounce any requests that are not JSON type requests
if not request.is_json:
raise UnsupportedMediaType()
if session.get('user') is None:
raise Unauthorized()
body = request.get_json()
if body.get('job_id') is None:
raise BadRequest('missing job_id property')
if body.get('price') is None:
raise BadRequest('missing price property')
if body.get('start_time') is None:
raise BadRequest('missing start_time property')
job_id = body.get('job_id')
price = body.get('price')
start_time = body.get('start_time')
userId = session.get('user')["$oid"]
job = jobs.find_one({"_id":ObjectId.ObjectId(job_id)})
job = json.loads(json_util.dumps(job))
if job is None:
raise BadRequest("invalid Job ID")
if job["max_price"] < price:
raise BadRequest("Price out of range")
offer = {'userId': userId,
'jobId':job_id,
'price':price,
'start_time': start_time
}
try:
offerId = offers.insert_one(offer).inserted_id
#return jsonify(status='OK',message='inserted successfully')
#return str(postId)
except DuplicateKeyError:
raise NotFound('offer already exists')
# check that mongo didn't fail
return Response(status=201)
def create_use_case(request: use_case_pb2.UseCaseCreateRequest, requester_email: str) \
-> use_case_pb2.UseCase:
"""Create a use case from a user."""
unused_, user_database, database = mongo.get_connections_from_env()
identifier = request.WhichOneof('identifier')
if not identifier:
flask.abort(400, "Il manque un identifiant pour créer le cas d'usage.")
query: dict[str, Any]
if request.email:
_log_request(request.email, requester_email, database)
query = {'hashedEmail': auth.hash_user_email(request.email)}
elif request.ticket_id:
query = {'supportTickets.ticketId': request.ticket_id}
else:
query = {'_id': objectid.ObjectId(request.user_id)}
# Find user.
user_dict = user_database.user.find_one(query)
if not user_dict:
flask.abort(
404,
f'Aucun utilisateur avec l\'identifiant "{getattr(request, identifier)}" '
f"({identifier}) n\'a été trouvé.")
# Find next free index in use case pool.
last_use_case_in_pool = database.use_case.find(
{'poolName': request.pool_name},
{'_id': 0, 'indexInPool': 1},
).sort('indexInPool', pymongo.DESCENDING).limit(1)
next_index = next((u.get('indexInPool', 0) for u in last_use_case_in_pool), -1) + 1
# Convert user to use case.
use_case_proto = privacy.user_to_use_case(user_dict, request.pool_name, next_index)
if not use_case_proto:
flask.abort(500, 'Impossible to read user data.')
if not request.pool_name:
return use_case_proto
# Save use case.
use_case = json_format.MessageToDict(use_case_proto)
use_case['_id'] = use_case.pop('useCaseId')
database.use_case.insert_one(use_case)
return use_case_proto
def clean_users(database: mongo.UsersDatabase,
dry_run: bool = True,
max_users: int = 0) -> Tuple[int, int, int]:
"""Clean inactive users and guests who registered before a given date."""
users = get_users(database)
num_users_cleaned = 0
num_users_updated = 0
num_errors = 0
for user in users:
user_proto = proto.create_from_mongo(user, user_pb2.User, 'user_id')
if max_users and (num_users_cleaned + num_users_updated +
num_errors) >= max_users:
return num_users_cleaned, num_users_updated, num_errors
if not user_proto:
num_errors += 1
continue
try:
user_id = objectid.ObjectId(user_proto.user_id)
except bson.errors.InvalidId:
logging.exception('Tried to modify a user with an invalid ID "%s"',
user_proto.user_id)
num_errors += 1
continue
deletion_date = compute_deletion_date(user_proto)
if deletion_date >= datetime.datetime.today():
set_deletion_check_date(user_proto, deletion_date, database,
dry_run)
num_users_updated += 1
continue
if dry_run:
logging.info('Cleaning user "%s"', str(user_id))
num_users_cleaned += 1
elif auth.delete_user(user_proto, database):
num_users_cleaned += 1
else:
num_errors += 1
return num_users_cleaned, num_users_updated, num_errors
def importStandComboDeliverFee():
fee_op = mongo_client.get_col_op_test("priceManage","purchaseFee");
area_op = mongo_client.get_col_op_prod("baseConfig", "area")
df = pd.read_excel("C:/Users/zhu/Desktop/导入导出/采购价/送货费-标准套餐-模板.xlsx")
dataList = np.array(df).tolist()
addList = []
errorList = []
for data in dataList:
print(data)
one = {}
one["_id"] = str(objectid.ObjectId())
one["groupId"] = "5ce3c643eeeb414fbc908323"
one["groupName"] = "标准套餐"
one["priority"] = 2
one["feeType"] = "basicDeliveryFee"
one["name"] = data[0]
one["template"] = "费用 = $基础送货费;返回 费用；"
area = area_op.find_one({"mergerName":data[3]+data[4]+data[5]})
if area is None:
errorList.append(data);
continue
keys = {
"combos": [{"comboId": data[6], "comboName": data[7]}],
"destinations":[{"destinationId":area.get("code"),"destinationName":area.get("mergerName")}]}
one["keys"] = keys
one["vars"] = [{"varName":"$基础送货费","varValue":data[8]}]
one["createTime"] = Timestamp(1559098387, 253)
one["lastUpdateTime"] = Timestamp(1559785785, 272)
one["version"] = 1
one["creator"] = "15000000000"
one["creatorName"] = "测试九江管理员"
one["modifier"] = "15000000000"
one["modifierName"] = "测试九江管理员"
addList.append(one)
fee_op.insert_many(addList)
el = pd.DataFrame(errorList);
el.to_excel("error_scd.xlsx", index=False)
def assign_record(db, account, callid):
'''
Update record assigned flag
'''
try:
result = yield db.calls.update(
{'_id': objectid.ObjectId(callid)},
{'$set': {
'assigned': True,
'accountcode': account
}})
except Exception, e:
logging.exception(e)
raise e
return
def test_queue_import_dataset_passes_experiment_to_task(self):
mock_open = mock.mock_open()
experiment_id = oid.ObjectId()
subject = hpc.HPCJobSystem({})
with mock.patch('batch_analysis.job_systems.hpc_job_system.open',
mock_open,
create=True):
subject.queue_import_dataset('dataset.importer', '/tmp/dataset',
experiment_id)
mock_file = mock_open()
self.assertTrue(mock_file.write.called)
script_contents = mock_file.write.call_args[0][0]
self.assertIn(
"python {0} {1} {2} {3}".format(
hpc.quote(task_import_dataset.__file__), 'dataset.importer',
'/tmp/dataset', str(experiment_id)), script_contents)
def insert_service():
#print(session)
if ('msn' in session):
msn = session['msn']
print(msn, 'this is insert page')
mrc = mongo.db.MRCObject.find_one({"msn": msn})
services = mongo.db.ServiceObject.find(
{"_id": {
"$in": mrc['services']
}})
print(mrc['services'])
form = InsertService()
#print('insert ki ocham')
if (form.validate_on_submit()):
session.pop('msn', None)
id = objectid.ObjectId()
challan = form.challan.data
prev_mtr_rdng = form.prev_mtr_rdng.data
present_mtr_rdng = form.present_mtr_rdng.data
qty = form.qty.data
yeild = form.yeild.data
exec_name = form.exec_name.data
remarks = form.remarks.data
row = {
"_id": id,
"challan": challan,
"prev_mtr_rdng": prev_mtr_rdng,
"present_mtr_rdng": present_mtr_rdng,
"qty": qty,
"yield": yeild,
"exec_name": exec_name
}
#print('inserted')
x = mongo.db.ServiceObject.insert_one(row)
#print(x, 'hey hi')
mongo.db.MRCObject.update({"msn": msn},
{"$addToSet": {
"services": id
}})
flash('Row added succesfully')
return render_template('insert_service.html',
form=form,
title="InsertService",
services=services)
else:
return render_template('error_page.html')
def get(self, thumbid):
ctype = self.get_argument('type', default=1)
ctype = int(ctype)
img = None
try:
tid = objectid.ObjectId(thumbid)
if ctype == 1:
img = live_mongo.filefs.get(tid).read()
else:
img = theme_mongo.filefs.get(tid).read()
if not img:
raise
except:
raise tornado.web.HTTPError(404)
self.set_header('Content-Type', 'image/jpg')
self.write(img)
def __init__(self, store, subject, lease_time=None, token=None):
"""Ensure we can take a lock on this subject."""
super(MongoTransaction, self).__init__(store, subject,
lease_time=lease_time, token=token)
self.object_id = objectid.ObjectId(
hashlib.sha256(utils.SmartStr(self.subject)).digest()[:12])
if lease_time is None:
lease_time = config_lib.CONFIG["Datastore.transaction_timeout"]
self.expires = time.time() + lease_time
self.document = self.store.latest_collection.find_and_modify(
query={"_id": self.object_id, "expires": {"$lt": time.time()}},
update=dict(_id=self.object_id, expires=self.expires),
upsert=False, new=True)
if self.document:
# Old transaction expired and we hold a lock now:
self.locked = True
return
# Maybe the lock did not exist yet. To create it, we use a lock to reduce
# the chance of deleting some other lock created at the same time. Note that
# there still exists a very small race if this happens in multiple processes
# at the same time.
with self.lock_creation_lock:
document = self.store.latest_collection.find({"_id": self.object_id})
if not document.count():
self.UpdateLease(lease_time)
cursor = self.store.latest_collection.find({"_id": self.object_id})
if cursor.count() != 1:
self._DeleteLock()
logging.warn("Multiple lock rows for %s", subject)
raise data_store.TransactionError("Error while locking %s." % subject)
self.document = cursor.next()
if self.document["expires"] != self.expires:
raise data_store.TransactionError("Subject %s is locked" % subject)
# We hold a lock now:
self.locked = True
return
raise data_store.TransactionError("Subject %s is locked" % subject)
def upsert(self, node):
if node.node_id:
node_id = node.node_id
else:
node_id = objectid.ObjectId(node.node_id)
self.collection.replace_one({"_id": node_id}, {
"_id": node_id,
"value": node.value,
"location": {
"type": "Point",
"coordinates": [node.coordinates[1], node.coordinates[0]]
}
},
upsert=True)
return Node(node_id=node_id,
coordinates=node.coordinates,
value=node.value)
def get_post(self, uid: str):
"""
Get contribution from DB.
uid -- identity ID
"""
res = db.posts.find_one({'_id': objectid.ObjectId(uid)})
if 'link' not in res:
raise TypeError(repr(res) + ' is not link contribution.')
self.id = str(res['_id'])
self.content = res['content']
self.password = res['password']
self.lang = res['lang']
self.link = res['link']
self.created_at = res['created_at']
self.deleted_at = res['deleted_at']
def update():
if session.get('user') is None:
raise Unauthorized()
if not request.is_json:
raise UnsupportedMediaType()
body = request.get_json()
if body.get("phone") is not None:
number = body.get('phone')
if len(number)==10 and number.isdigit():
resp =authy_api.phones.verification_start(number, 1, via='sms')
if resp.content["success"]:
users.update_one({'_id':ObjectId.ObjectId(session.get('user')["$oid"])},{'$set':{'phone':number}})
else:
return Response("Invalid number",400)
else:
raise BadRequest("invalid phone number")
if body.get("first_name"):
users.update_one({'_id':ObjectId.ObjectId(session.get('user')["$oid"])},{'$set':{'first_name':body.get("first_name")}})
if body.get("last_name"):
users.update_one({'_id':ObjectId.ObjectId(session.get('user')["$oid"])},{'$set':{'last_name':body.get("last_name")}})
if body.get("zipcode"):
users.update_one({'_id':ObjectId.ObjectId(session.get('user')["$oid"])},{'$set':{'zipcode':body.get("zipcode")}})
if body.get("password"):
password_hash = security.generate_password_hash(body.get('password'))
users.update_one({'_id':ObjectId.ObjectId(session.get('user')["$oid"])},{'$set':{'password':password_hash}})
if body.get("payment"):
users.update_one({'_id':ObjectId.ObjectId(session.get('user')["$oid"])},{'$set':{'payment':body.get("payment")}})
if body.get("vehicle"):
users.update_one({'_id':ObjectId.ObjectId(session.get('user')["$oid"])},{'$set':{'vehicle':body.get("vehicle")}})
serializable_user_obj = json_util.dumps(session.get('user'))
return Response(serializable_user_obj, 200)
def add_friend(userId):
friend = json.loads(request.data)
if friend["status"] == "pendiente":
friend_request = {"id":userId,"status":"por confirmar"}
db.db.usuario_collection.update({"_id":objectid.ObjectId(userId)},{"$addToSet":{"friends":friend}})
db.db.usuario_collection.update({"_id":objectid.ObjectId(friend["id"])},{"$addToSet":{"friends":friend_request}})
elif friend["status"] == "amigos":
db.db.room_collection.insert_one({"users":[userId, friend["id"]], "name":userId+friend["id"]})
room = db.db.room_collection.find_one({"name":userId+friend["id"]})
roomId = str(room["_id"])
db.db.usuario_collection.update_one({"_id":objectid.ObjectId(userId),"friends.id":friend["id"]},{"$set":{"friends.$.status":friend["status"]}})
db.db.usuario_collection.update_one({"_id":objectid.ObjectId(userId),"friends.id":friend["id"]},{"$set":{"friends.$.room" : roomId}}, upsert = True)
db.db.usuario_collection.update_one({"_id":objectid.ObjectId(friend["id"]),"friends.id":userId},{"$set":{"friends.$.status":friend["status"]}})
db.db.usuario_collection.update_one({"_id":objectid.ObjectId(friend["id"]),"friends.id":userId},{"$set":{"friends.$.room" : roomId}}, upsert = True)
user = JsonEncodeOne(db.db.usuario_collection.find_one({"_id":objectid.ObjectId(userId)}))
return {"loggedIn":True,"user":user}
def get(self, apkid):
print 'modify handler'
ctype = self.get_argument("type", default=1)
ctype = int(ctype)
try:
pid = objectid.ObjectId(apkid)
if ctype == 1:
apk = live_mongo.apk.find_one({'_id': pid})
else:
apk = theme_mongo.apk.find_one({'_id': pid})
if not apk:
raise
except:
raise tornado.web.HTTPError(404)
if ctype == 1:
cates = live_mongo.category.find()
tags = live_mongo.apk2tag.find({'apkid': pid})
taglist = []
for i in tags:
taglist.append(i['name'])
if taglist:
tag = ','.join(taglist)
else:
tag = ''
else:
cates = theme_mongo.category.find()
tags = theme_mongo.theme2tag.find({'apkid': pid})
taglist = []
for i in tags:
taglist.append(i['name'])
if taglist:
tag = ','.join(taglist)
else:
tag = ''
if not cates:
return self.redirect("/home")
self.render(
"modify.html",
apk=apk,
tag=tag,
categorys=cates,
type=ctype,
)
def delete(self, test_id):
curr_user = self.get_secure_cookie(auth_const.OPENID)
curr_user_role = self.get_secure_cookie(auth_const.ROLE)
if curr_user is not None:
query = {'_id': objectid.ObjectId(test_id)}
test_data = yield dbapi.db_find_one(self.table, query)
if not test_data:
raises.NotFound(message.not_found(self.table, query))
if curr_user == test_data['owner'] or \
curr_user_role.find('administrator') != -1:
yield dbapi.db_delete('applications',
{'test_id': test_data['id']})
yield dbapi.db_delete('reviews', {'test_id': test_data['id']})
self._delete(query=query)
else:
raises.Forbidden(message.no_auth())
else:
raises.Unauthorized(message.no_auth())
def fetch_movies(self, id=None):
if id is None:
return [a['title'] for a in self.mycol.find()]
li = []
command = {'_id': objectid.ObjectId(id)}
for item in self.mycol.find(command):
dic = {
'title': item['title'],
'img': item['img'],
'rate': item['rate'],
'comments': item['details']
}
li.append(dic)
return li
