def test_equality(self):
john_data = {
'_id': 42,
'name': 'John Doe',
'birthday': datetime(1995, 12, 12),
'gpa': 3.0
}
john = self.EasyIdStudent.build_from_mongo(data=john_data)
john2 = self.EasyIdStudent.build_from_mongo(data=john_data)
phillipe = self.EasyIdStudent.build_from_mongo(
data={
'_id': 3,
'name': 'Phillipe J. Fry',
'birthday': datetime(1995, 12, 12),
'gpa': 3.0
})
assert john != phillipe
assert john2 == john
assert john == DBRef(collection='student', id=john.pk)
john.name = 'William Doe'
assert john == john2
newbie = self.EasyIdStudent(name='Newbie')
newbie2 = self.EasyIdStudent(name='Newbie')
assert newbie != newbie2
def create_tenant(args, name):
db = db_connect()
if args.org:
org = args.org
else:
org = domain_generator()
tenant = tenant_find_by_domain(org)
print("Info: Organization name = " + org)
if tenant is None:
try:
inserted_id = db.tenants.insert_one({"name": name, "domainName": org}).inserted_id
db.applications.insert_one({
"_id" : org,
"friendlyName" : org,
"description" : "",
"qualifier" : "brsp01a",
"registrationDate" : int(datetime.datetime.now().strftime("%s")) * 1000,
"tenant" : DBRef("tenants", inserted_id)
})
return inserted_id
except Exception as e:
print(e)
sys.exit(1)
else:
return tenant['_id']
def test_lazy_reference_bad_set(self):
class Animal(Document):
name = StringField()
tag = StringField()
class Ocurrence(Document):
person = StringField()
animal = LazyReferenceField(Animal)
Animal.drop_collection()
Ocurrence.drop_collection()
class BadDoc(Document):
pass
animal = Animal(name="Leopard", tag="heavy").save()
baddoc = BadDoc().save()
for bad in (
42,
"foo",
baddoc,
DBRef(baddoc._get_collection_name(), animal.pk),
LazyReference(BadDoc, animal.pk),
):
with pytest.raises(ValidationError):
Ocurrence(person="test", animal=bad).save()
def to_mongo(self, document):
if isinstance(document, DBRef):
if not self.dbref:
return DBRef.id
return document
elif not self.dbref and isinstance(document, basestring):
return document
id_field_name = self.document_type._meta['id_field']
id_field = self.document_type._fields[id_field_name]
if isinstance(document, Document):
# We need the id from the saved object to create the DBRef
id_ = document.pk
if id_ is None:
self.error('You can only reference documents once they have'
' been saved to the database')
else:
id_ = document
id_ = id_field.to_mongo(id_)
if self.dbref:
collection = self.document_type._get_collection_name()
return DBRef(collection, id_)
return id_
def post(self, *args, **kwargs):
object_parent_id = ""
classify_name = self.get_argument("classify_name")
classify_url = self.get_argument("classify_url")
parent_classify_id = self.get_argument("classify_parent")
if parent_classify_id != "":
object_parent_id = ObjectId(parent_classify_id)
right_classify_item = {
"classify_name": classify_name,
"classify_url": classify_url,
"classify_color": "default",
"classify_parent": object_parent_id,
"classify_son": []
}
# 更新父类
right_classify_item_id = self.db.right_classify.insert_one(
right_classify_item).inserted_id
if right_classify_item_id:
self.db.right_classify.update({"_id": parent_classify_id}, {
"$push": {
"classify_son": DBRef('right_classify',
right_classify_item_id)
}
},
multi=True)
self.redirect("/")
def serviceto_role():
_json = request.json
_role_name = _json['role_name']
_service_name = _json['service_name']
existing_role = mongo.db.roles.find_one({'name': _role_name})
existing_service = mongo.db.services.find_one({
'name': _service_name,
})
# Add new service if not exist
if (existing_service is None) and _role_name:
mongo.db.services.insert({'name': _service_name, 'description': ''})
# Add new role if not exist
if (existing_role is None) and _service_name:
mongo.db.roles.insert({
'name': _role_name,
'description': '',
'services': []
})
# check if Role already has the service
if _role_name and existing_service:
existing_serviced = mongo.db.roles.find_one({
'name':
_role_name,
'services':
DBRef(collection="services", id=existing_service['_id'])
})
if existing_service and (existing_serviced is
None) and request.method == 'POST':
# update role with new existing service
mongo.db.roles.update_one({'name': _role_name}, {
'$push': {
'services':
DBRef(collection="services", id=existing_service['_id'])
}
})
message = {
'data': "null",
'result': {
'isError': 'false',
'message': 'service_to_role_added_successfully',
'status': 200,
}
}
# for json response
return jsonify(message)
else:
return not_found()
def post(cls, request, *args, **kwargs):
"""
Creates a new instance of the class, based on the body
received from the client.
If audit_logs is enabled on the class, then a log item will be created
for this action.
Broadcasts the action to all connected users.
:param request: client request
:type request: raccoon.utils.request.Request
:param args: not used
:param kwargs: instance body
:return: None
"""
if not cls.model:
raise ReplyError(404)
params = {}
for key, value in kwargs.items():
if value and hasattr(cls.model, key):
# !important
# Make value = ObjectId(value) if field is a reference field
field = cls.model._fields.get(key)
if type(field) is ReferenceField:
if not value:
value = None
else:
model_name = field.document_type._get_collection().name
value = DBRef(model_name, ObjectId(value))
params[key] = value
try:
response = cls.model.objects.create(**params)
except NotUniqueError as e:
log.info("Failed to create {}".format(cls.model.__name__),
exc_info=True)
raise ReplyError(409, cls.model.get_message_from_exception(e))
except InvalidDocumentError as e:
log.info("Invalid document {}".format(cls.model.__name__),
exc_info=True)
raise ReplyError(400, cls.model.get_message_from_exception(e))
if cls.audit_logs:
user = request.user
audit_log = AuditLog(user=user.email,
action='new {}'.format(cls.model.__name__),
message='{} {} added'.format(
cls.model.__name__, kwargs.get('name')))
audit_log.save()
request.broadcast(audit_log.get_dict(),
verb='post',
resource='/api/v1/auditlogs/',
admin_only=True)
request.broadcast(response.get_dict())
def __dict__(self):
return {
"name_song":
self.name_song,
"author":
DBRef(collection=DataBase.get_type_collection(self.author),
id=self.author.id)
}
def to_python(self, value):
"""Convert a MongoDB-compatible type to a Python type.
"""
if (not self.dbref and
not isinstance(value, (DBRef, Document, EmbeddedDocument))):
collection = self.document_type._get_collection_name()
value = DBRef(collection, self.document_type.id.to_python(value))
return value
def setUp(self):
"""Set up."""
self.referenced_doc = ReferencedDocument(name="hi")
self.referenced_doc.save()
self.doc = IDCheckDocument(ref=self.referenced_doc)
self.ref_doc = IDCheckDocument(enable_gj=True,
ref=DBRef("referenced_document",
self.referenced_doc.pk))
def dbref(self):
"""
Return a pymongo DBRef instance related to the document
"""
if not self.is_created:
raise NotCreatedError('Must create the document before'
' having access to DBRef')
return DBRef(collection=self.collection.name, id=self.pk)
def test_reference(self):
@self.instance.register
class MyReferencedDoc(Document):
class Meta:
collection_name = 'my_collection'
@self.instance.register
class OtherDoc(Document):
pass
to_refer_doc = MyReferencedDoc.build_from_mongo(
{'_id': ObjectId("5672d47b1d41c88dcd37ef05")})
ref = Reference(MyReferencedDoc, to_refer_doc.pk)
dbref = DBRef('my_collection', to_refer_doc.pk)
other_doc = OtherDoc.build_from_mongo(
{'_id': ObjectId("5672d47b1d41c88dcd37ef07")})
# Test reference equality
assert ref == to_refer_doc
assert ref == dbref
assert dbref == to_refer_doc
assert dbref == ref
assert to_refer_doc == ref
assert to_refer_doc == dbref
@self.instance.register
class MyDoc(Document):
ref = fields.ReferenceField(MyReferencedDoc,
attribute='in_mongo_ref')
MySchema = MyDoc.Schema
MyDataProxy = data_proxy_factory('My', MySchema())
d = MyDataProxy()
d.load({'ref': ObjectId("5672d47b1d41c88dcd37ef05")})
d.load({'ref': "5672d47b1d41c88dcd37ef05"})
assert d.dump() == {'ref': "5672d47b1d41c88dcd37ef05"}
assert d.get('ref').document_cls == MyReferencedDoc
d.set('ref', to_refer_doc)
assert d.to_mongo(update=True) == {
'$set': {
'in_mongo_ref': to_refer_doc.pk
}
}
assert d.get('ref') == ref
d.set('ref', ref)
assert d.get('ref') == ref
d.set('ref', dbref)
assert d.get('ref') == ref
with pytest.raises(ValidationError):
d.set('ref', other_doc)
not_created_doc = MyReferencedDoc()
with pytest.raises(ValidationError):
d.set('ref', not_created_doc)
bad_ref = Reference(OtherDoc, other_doc.pk)
with pytest.raises(ValidationError):
d.set('ref', bad_ref)
def test_mongodb_origin_DBRef_type(sdc_builder, sdc_executor, mongodb):
"""
DBRef datatype is a reference to a document in other collection.
Step 1. Create two collections(#1 and #2) in MongoDB and add sample documents in collection #1.
Step 2. Add test documents to collection #2 which refer to the sample documents in collection #1.
Step 3. Confirm that MongoDB origin reads the test documents from collection #2
The pipeline looks like:
mongodb_origin >> wiretap
"""
database_name = get_random_string(ascii_letters, 5)
collection1 = get_random_string(ascii_letters, 10)
collection2 = get_random_string(ascii_letters, 10)
logger.debug('database_name: %s, collection1: %s, collection2: %s' , database_name, collection1, collection2)
pipeline_builder = sdc_builder.get_pipeline_builder()
pipeline_builder.add_error_stage('Discard')
mongodb_origin = pipeline_builder.add_stage('MongoDB', type='origin')
mongodb_origin.set_attributes(capped_collection=False,
database=database_name,
collection=collection2)
wiretap = pipeline_builder.add_wiretap()
mongodb_origin >> wiretap.destination
pipeline = pipeline_builder.build().configure_for_environment(mongodb)
sdc_executor.add_pipeline(pipeline)
try:
# Step 1. A sample documents to collection #1
docs_in_database = copy.deepcopy(ORIG_DOCS)
mongodb_database = mongodb.engine[database_name]
mongodb_collection1 = mongodb_database[collection1]
insert_list = [mongodb_collection1.insert_one(doc) for doc in docs_in_database]
num_of_records = len(insert_list)
logger.info('Added %i documents into %s collection', num_of_records, collection1)
# Step 2. Generate test documents with DBRef datatype and insert to collection #2
logger.info('Adding test documents into %s collection...', collection2)
mongodb_collection2 = mongodb_database[collection2]
docs_in_col1 = [] # This will be used to compare the result
# Obtain sample document's _id from collection #1 and assign it to test document as inserting into collection #2
for doc in mongodb_collection1.find().sort('_id', 1):
# Sort by _id so that we can compare the result easily later
mongodb_collection2.insert_one({'test_ref': DBRef(collection=collection1, id=doc['_id'])})
docs_in_col1.append(doc)
# Step 3. Start pipeline and verify the documents using wiretap.
sdc_executor.start_pipeline(pipeline)
sdc_executor.wait_for_pipeline_metric(pipeline, 'input_record_count', 1)
sdc_executor.stop_pipeline(pipeline)
for record, expected in zip(wiretap.output_records, docs_in_col1):
assert record.get_field_data('/test_ref/$ref') == collection1
assert record.get_field_data('/test_ref/$id') == str(expected['_id'])
finally:
logger.info('Dropping %s database...', database_name)
mongodb.engine.drop_database(mongodb_origin.database)
def friendReq(id):
current_user = mongo.db.userReg.find_one({'email': session['email']})
existing_user = mongo.db.userReg.find_one({'_id': ObjectId(id)})
# check if userReg already has the friend
existing_friend = mongo.db.userReg.find_one({
'email':
session['email'],
'friends':
DBRef(collection="userReg", id=ObjectId(id))
})
if existing_friend:
#existing_friend = mongo.db.userReg.find_one({'email':session['email'], 'friends':DBRef(collection = "userReg", id = ObjectId(id) ) })
message = {
'data': "null",
'result': {
'isError': 'false',
'message': 'Friend Already Exist',
'status': 200,
}
}
return jsonify(message)
if existing_user and (existing_user != current_user) and (
existing_friend is None) and request.method == 'POST':
# update userReg with new existing friend
#mongo.db.userReg.update_one({'email':session['email'] },{ '$push': {'friend_pending': DBRef(collection = "userReg", id = ObjectId(id) ) } })
mongo.db.userReg.update_one({'_id': ObjectId(id)}, {
'$push': {
'friend_pending':
DBRef(collection="userReg", id=current_user['_id'])
}
})
message = {
'data': "null",
'result': {
'isError': 'false',
'message': 'Friend Request Sent',
'status': 200,
}
}
# for json response
return jsonify(message)
else:
return not_found()
def oparl_agendaItem_data(params):
data = db.get_agendaItem(search_params={'_id': ObjectId(params['_id'])})
if len(data) == 1:
data = oparl_agendaItem_layout(data[0], params)
meeting = db.get_meeting(search_params={'agendaItem': DBRef('agendaItem', ObjectId(params['_id']))})
if len(meeting):
data['meeting'] = "%s/oparl/meeting/%s%s" % (app.config['api_url'], meeting[0]['_id'], generate_postfix(params))
return data
elif len(data) == 0:
abort(404)
def oparl_consultation_data(params):
data = db.get_consultation(search_params={'_id': ObjectId(params['_id'])})
if len(data) == 1:
data = oparl_consultation_layout(data[0], params)
agendaItem = db.get_agendaItem(search_params={'consultation': DBRef('consultation', ObjectId(params['_id']))})
if len(agendaItem):
data['agendaItem'] = "%s/oparl/agendaItem/%s%s" % (app.config['api_url'], agendaItem[0]['_id'], generate_postfix(params))
return data
elif len(data) == 0:
abort(404)
def test_dereference_manipulator(self):
self.session = utils.get_session(self.config, inc_manipulators=False)
collection_a = self.session.get_collection('test_a')
collection_b = self.session.get_collection('test_b')
collection_a.insert({"_id": 1, "foo": "bar"})
collection_b.insert({"baz": "blah", "foo": DBRef(collection="test_a", id=1)})
manipulator = DereferenceManipulator(ref_fields=[('test_b', 'foo')])
self.session.add_manipulator(manipulator)
doc = collection_b.find_one({"baz": "blah"})
self.assertEqual(doc['foo'], 'bar')
def test_dbref(self):
student = self.Student()
with pytest.raises(exceptions.NotCreatedError):
student.dbref
# Fake document creation
student.id = ObjectId('573b352e13adf20d13d01523')
student.is_created = True
student.clear_modified()
assert student.dbref == DBRef(collection='student',
id=ObjectId('573b352e13adf20d13d01523'))
def view_paper(id):
"""
Gibt Dokumenten-Detailseite aus
"""
result = db.get_paper(search_params={'_id': ObjectId(id)},
deref={
'values': [
'body', 'mainFile', 'auxiliaryFile',
'relatedPaper', 'subordinatedPaper',
'superordinatedPaper'
]
})
if len(result) == 0:
abort(404)
result = result[0]
result['numberOfFiles'] = 0
if 'mainFile' in result:
result['numberOfFiles'] += 1
if 'auxiliaryFile' in result:
result['numberOfFiles'] += len(result['auxiliaryFile'])
result['consultation'] = db.get_consultation(
search_params={'paper': DBRef('paper', ObjectId(id))})
for consultation_id in range(len(result['consultation'])):
agendaItem_result = db.get_agendaItem(
search_params={
'consultation':
DBRef('consultation', result['consultation'][consultation_id]
['_id'])
})
if len(agendaItem_result):
result['consultation'][consultation_id][
'agendaItem'] = agendaItem_result[0]
meeting_result = db.get_meeting(
search_params={
'agendaItem':
DBRef(
'agendaItem', result['consultation'][consultation_id]
['agendaItem']['_id'])
})
if len(meeting_result):
result['consultation'][consultation_id]['agendaItem'][
'meeting'] = meeting_result[0]
return render_template('paper_details.html', paper=result)
def to_dict(self):
object_dict = {"db_ref": self.__db_ref}
internal_fields = dir(self)
for field in get_fields(self.__document_class_reference,
self.__document_name_reference):
if field["name"] in self.__extended_document or field[
"name"] in internal_fields:
if field["name"] in self.__extended_document:
value = self.__extended_document[field["name"]]
else:
value = getattr(self, field["name"])
if type(value) is list:
childs = []
for rec in value:
if type(field["type"]["list_type"]) is DocumentRef:
if type(rec) is DBRef:
childs.append(rec)
elif type(rec) is dict and "id" in rec:
childs.append(
DBRef(
field["type"]
["list_type"].db_ref.collection,
rec['id']))
elif hasattr(rec, 'id'):
childs.append(
DBRef(
field["type"]
["list_type"].db_ref.collection,
rec.id))
else:
childs.append(
DBRef(
field["type"]
["list_type"].db_ref.collection, rec))
elif "to_dict" in dir(rec):
childs.append(rec.to_dict())
else:
childs.append(rec)
object_dict[field["name"]] = childs
else:
object_dict[field["name"]] = value
return object_dict
def roleto_group():
_json = request.json
_group_name = _json['group_name']
_role_name = _json['role_name']
existing_group = mongo.db.groups.find_one({'name': _group_name})
existing_role = mongo.db.roles.find_one({'name': _role_name})
# Add new group if not exist
if _group_name and (existing_group is None):
mongo.db.groups.insert({
'name': _group_name,
'description': '',
'roles': [],
'services': []
})
# check if Group already has the Role
if _group_name and existing_role:
existing_roled = mongo.db.groups.find_one({
'name':
_group_name,
'roles':
DBRef(collection="roles", id=existing_role['_id'])
})
if existing_role and (existing_roled is None) and request.method == 'POST':
# Update groups with new existing role
mongo.db.groups.update_one({'name': _group_name}, {
'$push': {
'roles': DBRef(collection="roles", id=existing_role['_id'])
}
})
message = {
'data': "null",
'result': {
'isError': 'false',
'message': 'service_to_role_added_successfully',
'status': 200,
}
}
# for json response
return jsonify(message)
else:
return not_found()
def test_database(self):
client = self.client
db = client.pymongo_test
ops = [
(db.command, ['ping'], {}),
(db.create_collection, ['collection'], {}),
(db.list_collection_names, [], {}),
(db.validate_collection, ['collection'], {}),
(db.drop_collection, ['collection'], {}),
(db.dereference, [DBRef('collection', 1)], {}),
]
self._test_ops(client, *ops)
def test_dbref_to_mongo(self):
"""Make sure that calling to_mongo on a ReferenceField which
has dbref=False, but actually actually contains a DBRef returns
an ID of that DBRef.
"""
class Person(Document):
name = StringField()
parent = ReferenceField("self", dbref=False)
p = Person(name="Steve", parent=DBRef("person", "abcdefghijklmnop"))
assert p.to_mongo() == SON([("name", u"Steve"),
("parent", "abcdefghijklmnop")])
def test_reference(self, collection_moke):
class MyReferencedDoc(Document):
class Meta:
collection = collection_moke
class OtherDoc(Document):
pass
to_refer_doc = MyReferencedDoc.build_from_mongo(
{'_id': ObjectId("5672d47b1d41c88dcd37ef05")})
ref = Reference(MyReferencedDoc, to_refer_doc.pk)
dbref = DBRef(collection_moke.name, to_refer_doc.pk)
other_doc = OtherDoc.build_from_mongo(
{'_id': ObjectId("5672d47b1d41c88dcd37ef07")})
# Test reference equality
assert ref == to_refer_doc
assert ref == dbref
assert dbref == to_refer_doc
assert dbref == ref
assert to_refer_doc == ref
assert to_refer_doc == dbref
class MySchema(Schema):
ref = fields.ReferenceField(MyReferencedDoc,
attribute='in_mongo_ref')
d = DataProxy(MySchema())
d.load({'ref': ObjectId("5672d47b1d41c88dcd37ef05")})
d.load({'ref': "5672d47b1d41c88dcd37ef05"})
assert d.dump() == {'ref': "5672d47b1d41c88dcd37ef05"}
d.get('ref').document_cls == MyReferencedDoc
d.set('ref', to_refer_doc)
assert d.to_mongo(update=True) == {
'$set': {
'in_mongo_ref': to_refer_doc.pk
}
}
assert d.get('ref') == ref
d.set('ref', ref)
assert d.get('ref') == ref
d.set('ref', dbref)
assert d.get('ref') == ref
with pytest.raises(ValidationError):
d.set('ref', other_doc)
not_created_doc = MyReferencedDoc()
with pytest.raises(ValidationError):
d.set('ref', not_created_doc)
bad_ref = Reference(OtherDoc, other_doc.pk)
with pytest.raises(ValidationError):
d.set('ref', bad_ref)
def acceptFriendReq(id):
current_user = mongo.db.userReg.find_one({'email': session['email']})
pending_friend = mongo.db.userReg.find_one({
'email':
session['email'],
'friend_pending':
DBRef(collection="userReg", id=ObjectId(id))
})
if pending_friend:
# adding in both users friend list
mongo.db.userReg.update_one({'email': session['email']}, {
'$push': {
'friends': DBRef(collection="userReg", id=ObjectId(id))
}
})
mongo.db.userReg.update_one({'_id': ObjectId(id)}, {
'$push': {
'friends': DBRef(collection="userReg", id=current_user['_id'])
}
})
mongo.db.userReg.update_one(
{
'email': session['email'],
'friend_pending': DBRef(collection="userReg", id=ObjectId(id))
}, {'$pop': {
'friend_pending': -1
}})
message = {
'data': "null",
'result': {
'isError': 'false',
'message': 'Friend Request Accepted',
'status': 200,
}
}
return jsonify(message)
else:
return not_found()
def rm_service_fromgroup():
_json = request.json
_group_name = _json['group_name']
_service_name = _json['service_name']
existing_group = mongo.db.groups.find_one({'name': _group_name})
existing_service = mongo.db.services.find_one({
'name': _service_name,
})
# check if Role already has the service
if _group_name and existing_service:
existing_serviced = mongo.db.groups.find_one({
'name':
_group_name,
'services':
DBRef(collection="services", id=existing_service['_id'])
})
if existing_service and (existing_serviced) and request.method == 'POST':
# update role with pop the target existing service
mongo.db.groups.update_one(
{
'name':
_group_name,
'services':
DBRef(collection="services", id=existing_service['_id'])
}, {'$pop': {
'services': -1
}})
message = {
'data': "null",
'result': {
'isError': 'false',
'message': 'rm_service_fromgroup_successfully',
'status': 200,
}
}
# for json response
return jsonify(message)
else:
return not_found()
def process_formdata(self, valuelist):
if not valuelist:
return []
if len(valuelist) > 1:
oids = [clean_oid(id) for id in valuelist]
elif isinstance(valuelist[0], basestring):
oids = [
ObjectId(id.strip()) for id in valuelist[0].split(',')
if id.strip()
]
else:
raise ValueError('Unsupported form parameter: ' + valuelist)
self.data = [DBRef(self.model.lower(), oid) for oid in oids]
def test_dbref_to_mongo(self):
"""Make sure that calling to_mongo on a ReferenceField which
has dbref=False, but actually actually contains a DBRef returns
an ID of that DBRef.
"""
class Person(Document):
name = StringField()
parent = ReferenceField('self', dbref=False)
p = Person(name='Steve', parent=DBRef('person', 'abcdefghijklmnop'))
self.assertEqual(
p.to_mongo(),
SON([('name', u'Steve'), ('parent', 'abcdefghijklmnop')]))
def dbref(self, with_database=True, **kwargs):
"""Returns a DBRef for the current object.
If `with_database` is False, the resulting :class:`pymongo.dbref.DBRef`
won't have a :attr:`database` field.
Any other parameters will be passed to the DBRef constructor, as per the mongo specs.
"""
if not hasattr(self, '_id'):
self._id = ObjectId()
database = self._meta.database if with_database else None
return DBRef(self._meta.collection, self._id, database, **kwargs)
def ensure_owner_collection_migration():
"""We ran into an issue with 3.0.5 where Requests and Jobs got migrated over to
the Owner collection. This is in place to resolve that."""
database = get_db()
if database["owner"].count():
logger.warning(
"Found owner collection, migrating documents to appropriate collections. "
"This could take a while :)")
for doc in database["owner"].find({"_cls": "Owner.Request"}):
try:
del doc["_cls"]
if doc.get("has_parent"):
doc["parent"] = DBRef("request", doc["parent"].id)
database["request"].insert_one(doc)
except Exception:
logger.error(f"Error migrating request {doc['_id']}")
for doc in database["owner"].find({"_cls": "Owner.Job"}):
try:
del doc["_cls"]
database["job"].insert_one(doc)
except Exception:
logger.error(f"Error migrating job {doc['_id']}")
for doc in database["file"].find():
try:
if doc["owner_type"] == "REQUEST":
doc["request"] = doc["owner"]
elif doc["owner_type"] == "JOB":
doc["job"] = doc["owner"]
else:
logger.error(
f"Unable to migrate file {doc['_id']}: bad owner type")
database["file"].delete_one({"_id": doc["_id"]})
continue
doc["owner"] = None
database["file"].replace_one({"_id": doc["_id"]}, doc)
except Exception:
logger.error(f"Error migrating file {doc['_id']}, removing")
database["file"].delete_one({"_id": doc["_id"]})
logger.info("Dropping owner collection (this is intended!)")
database.drop_collection("owner")
def __init__(self, *args, **kwargs):
"""Inits the document with given data and validates the fields
(field validation bad idea during init?). If you define
``__init__`` method for your document class, make sure to call
this
::
class MyDoc(BaseDocument, dot_notation=True):
foo = Field(str)
bar = Field(int, required=False)
def __init__(self, *args, **kwargs):
super(MyDoc, self).__init__(*args, **kwargs)
# do other stuff
"""
# if input dict, merge (not updating) into kwargs
if args and not isinstance(args[0], dict):
raise TypeError('dict or dict subclass argument expected')
elif args:
for field_name, field_value in args[0].items():
if field_name not in kwargs:
kwargs[field_name] = field_value
super(BaseDocument, self).__init__()
for field_name, field in self.nanomongo.fields.items():
if hasattr(field, 'default_value'):
val = field.default_value
dict.__setitem__(self, field_name, val() if callable(val) else val)
# attach get_<field_name>_field methods for DBRef fields
if field.data_type in [DBRef] + DBRef.__subclasses__():
getter_name = 'get_%s_field' % field_name
doc_class = field.document_class if hasattr(field, 'document_class') else None
getter = ref_getter_maker(field_name, document_class=doc_class)
setattr(self, getter_name, six.create_bound_method(getter, self))
for field_name in kwargs:
if self.nanomongo.has_field(field_name):
self.nanomongo.validate(field_name, kwargs[field_name])
dict.__setitem__(self, field_name, kwargs[field_name])
else:
raise ExtraFieldError('Undefined field %s=%s in %s' %
(field_name, kwargs[field_name], self.__class__))
for field_name, field_value in self.items():
# transform dict to RecordingDict so we can track diff in embedded docs
if isinstance(field_value, dict):
dict.__setitem__(self, field_name, RecordingDict(field_value))
def dereference(self, session, ref, allow_none=False):
ref = DBRef(id=ref, collection=self.type.type.get_collection_name(),
database=self.db)
ref.type = self.type.type
return session.dereference(ref, allow_none=allow_none)
def dereference(self, session, ref, allow_none=False):
""" Dereference an ObjectID to this field's underlying type """
ref = DBRef(id=ref, collection=self.type.type.get_collection_name(),
database=self.db)
ref.type = self.type.type
return session.dereference(ref, allow_none=allow_none)
