def insert(request):
connection.register([MyRaw])
collName = get_database().raw
y = collName.MyRaw()
print request.POST["f_name"],'\t',request.POST["f_tags"],'\t',request.POST["f_content"]
y.name = request.POST["f_name"]
tag_l = request.POST["f_tags"].split(",")
y.tags = tag_l
y.content = request.POST["f_content"]
y.save()
name_id = "name"
tag_id = "tags"
content_id = "content"
obj = collName.MyRaw.find({name_id:request.POST["f_name"],content_id:request.POST["f_content"]})
obj_l = list(obj)
for i in obj_l:
obj_id = str(i._id)
print obj_id
#After Saving this it is important that we also include it in "to_reduce" collction
collName2 = get_database().to_reduce
z = collName2.ToReduce()
z._id = ObjectId(obj_id)
z.save()
return render(request,"raw_reduce/thankYou.html",{})
def tearDown(self):
for name in get_database().collection_names():
if name not in ('system.indexes', ):
get_database().drop_collection(name)
# because we have to manually control the creation and destruction of
# databases in Django <1.2, I'll destroy the database here
if not __django_12__:
self.connection.creation.destroy_test_db(self.old_database_name)
def tearDown(self):
for name in get_database().collection_names():
if name not in ('system.indexes',):
get_database().drop_collection(name)
# because we have to manually control the creation and destruction of
# databases in Django <1.2, I'll destroy the database here
if not __django_12__:
self.connection.creation.destroy_test_db(self.old_database_name)
def _read_GSystem(GSystem_ids):
collection = get_database()[GSystem.collection_name]
gstype_coll = get_database()[GSystemType.collection_name]
for id_ in GSystem_ids:
gsystem = collection.GSystem.one({'_id': ObjectId(id_)})
gsystem.name
gsystem.member_of
gstype_coll.GSystemType.one({'_id':gsystem.gsystem_type})
gsystem.attribute_set
gsystem.relation_set
gsystem.collection_set
def _create_GSystem(data,how_many):
collection = get_database()[GSystem.collection_name]
GSystem_ids = set()
gsys_type_coll = get_database()[GSystemType.collection_name]
gsys_type_cur = gsys_type_coll.GSystemType.find()
rel_type_coll = get_database()[RelationType.collection_name]
at_type_coll = get_database()[AttributeType.collection_name]
for i in range (how_many):
#To create GSystemType of capital
gsystem = collection.GSystem()
gsystem.name = unicode(data[1][i],"utf-8")
gsystem.member_of = u"GSystem"
gsystem.gsystem_type = gsys_type_cur[0]._id
at_type_name = at_type_coll.AttributeType.one({"name":"capital"}).name
gsystem.attribute_set = [{unicode(at_type_name):unicode(data[1][i],"utf-8")}]
rel_type_name = rel_type_coll.RelationType.one({"name":"is_capital_of"}).name
gsystem.relation_set =[{unicode(rel_type_name):unicode(data[0][i])}]
gsystem.collection_set = []
gsystem.save()
GSystem_ids.add(gsystem.pk)
#To create GSystemType of country
gsystem = collection.GSystem()
gsystem.name = unicode(data[0][i],"utf-8")
gsystem.member_of = u"GSystem"
gsystem.gsystem_type = gsys_type_cur[0]._id
at_type_name = at_type_coll.AttributeType.one({"name":"country"}).name
gsystem.attribute_set = [{unicode(at_type_name):unicode(data[0][i],"utf-8")}]
rel_type_name = rel_type_coll.RelationType.one({"name":"has_capital"}).name
gsystem.relation_set =[{rel_type_name:unicode(data[1][i])}]
gsystem.collection_set = []
gsystem.save()
GSystem_ids.add(gsystem.pk)
return GSystem_ids
def data_cleanup():
collection = get_database()[Author.collection_name]
collection.remove()
collection = get_database()[AttributeType.collection_name]
collection.remove()
collection = get_database()[GSystemType.collection_name]
collection.remove()
collection = get_database()[GSystem.collection_name]
collection.remove()
collection = get_database()[RelationType.collection_name]
collection.remove()
def perform_map_reduce(request):
#db = get_database()
#gs_collection = db[GSystem.collection_name]
#connection.register([ToReduce])
collName = get_database()["to_reduce"]
instances = collName.ToReduce.find()
y = list(instances)
#connection.register([MyReduce])
collName2 = get_database()["reduce"]
#connection.register([MyRaw])
collName3 = get_database()["raw"]
for x in y:
z = collName2.MyReduce()
orignal_doc = collName3.MyRaw.find_one({"_id":x._id})
z_old = collName2.MyReduce.find_one({"orignal":x._id})
print "ORIGNAL DOC >>>>>>>>>>>>>>>>>>>>>>>>",orignal_doc
if z_old:
print "OLD DOC >>>>>>>>>>>>>>>>>>>>> ",z_old
#z_old.name = dict(map_reduce(orignal_doc.name,mapper,reducer))
#z_old.tags = orignal_doc.tags
#z_old.content = dict(map_reduce(orignal_doc.content,mapper,reducer))
#z_old.save()
#collName2.MyReduce.remove({"orignal":x._id})
z_old.delete()
z.name = dict(map_reduce(orignal_doc.name,mapper,reducer))
#z.name = list(dict(map_reduce(orignal_doc.name,mapper,reducer)))
z.tags = orignal_doc.tags
z.content = dict(map_reduce(orignal_doc.content,mapper,reducer))
#z.content = list(dict(map_reduce(orignal_doc.content,mapper,reducer)))
z.orignal = x._id
print "NAME>>>>>>>>>>>>>>>>>",z.name
print "CONTENT>>>>>>>>>>>>>>",z.content
z.save()
print "OKOKOKOKK"
x.delete()
return render(request,"raw_reduce/thankYou.html",{"name":"pranav"})
def _update_attribute_type(attribute_type_ids):
collection = get_database()[AttributeType.collection_name]
for id_ in attribute_type_ids:
collection.update({'_id': ObjectId(id_)},
{'$set': {'name': u"edited_text",
'data_type':'bool',
'verbose_name':'mnbdvf',
'null':'false',
'blank':'false',
'help_text': u'help ... ,jkjkuh',
'max_digits': '15',
'decimal_places': '2',
'auto_now':'true',
'auto_now_at':'false',
'upload_to':u'url.....',
'path':u'url.......',
'verify_exist': 'true',
'min_length': '10',
'required': 'true',
'label': u'label text',
'unique': 'false',
'validators':'[is_blank, valid, is_email]',
'default': u'this is default',
'editable': 'false'}
},
upsert=False, multi=True)
def _read_attribute_type(attribute_type_ids):
collection = get_database()[AttributeType.collection_name]
for id_ in attribute_type_ids:
attribute_type = collection.AttributeType.one({'_id': ObjectId(id_)})
attribute_type.name
attribute_type.member_of
attribute_type.data_type
attribute_type.verbose_name
attribute_type.null
attribute_type.blank
attribute_type.help_text
attribute_type.max_digits
attribute_type.decimal_places
attribute_type.auto_now
attribute_type.auto_now_at
attribute_type.upload_to
attribute_type.path
attribute_type.verify_exist
attribute_type.min_length
attribute_type.required
attribute_type.label
attribute_type.unique
attribute_type.validators
attribute_type.default
attribute_type.editable
def _create_attribute_type():
collection = get_database()[AttributeType.collection_name]
attribute_type_ids = set()
attr_type_names = [u"country", u"capital"]
for i in attr_type_names:
attribute_type = collection.AttributeType()
attribute_type.name = i
attribute_type.member_of = u"attribute_type"
attribute_type.data_type = "unicode"
attribute_type.verbose_name = "Place"
attribute_type.null = True
attribute_type.blank = True
attribute_type.help_text = u"helptext"
attribute_type.max_digits = 10
attribute_type.decimal_places = 2
attribute_type.auto_now = True
attribute_type.auto_now_at = True
attribute_type.upload_to = u"url"
attribute_type.path = u"url/name"
attribute_type.verify_exist = True
attribute_type.min_length = 5
attribute_type.required = True
attribute_type.label = u"Label"
attribute_type.unique = True
attribute_type.validators = []
attribute_type.default = u"default"
attribute_type.editable = True
attribute_type.save()
attribute_type_ids.add(attribute_type.pk)
return attribute_type_ids
def render_to_response(self, request):
results = []
end = timezone.now()
start = end - timezone.timedelta(seconds=3600)
cursor = get_database().Diagnostic.find({
'timestamp': {
'$gte': start,
'$lt': end
},
}).sort('timestamp')
first = True
for doc in cursor:
if first:
keys = ['Timestamp']
for st in doc['status']:
for kv in st['values']:
keys.append(kv['key'])
if len(keys) >= 0:
continue
results.append('"%s"\n' % '","'.join(keys))
first = False
values = [timezone.make_naive(doc['timestamp'])]
for st in doc['status']:
for kv in st['values']:
values.append(kv['value'])
results.append('"%s"\n' % '","'.join(['%s' % v for v in values]))
return StreamingHttpResponse(results, content_type='text/csv')
def handle(self, *args, **options):
history_manager = HistoryManager()
rcs_obj = RCS()
collection = get_database()[Triple.collection_name]
cur = collection.Triple.find({"_type": "GAttribute"})
for n in cur:
if type(n["attribute_type"]) == ObjectId:
attr_type = collection.Node.one({"_id": n["attribute_type"]})
if attr_type:
collection.update(
{"_id": n["_id"]},
{
"$set": {
"attribute_type": {
"$ref": attr_type.collection_name,
"$id": attr_type._id,
"$db": attr_type.db.name,
}
}
},
)
else:
collection.remove({"_id": n["_id"]})
subject_doc = collection.Node.one({"_id": n.subject})
n.name = subject_doc.name + " -- " + n.attribute_type["name"] + " -- " + n.object_value
# Creates a history (version-file) for GAttribute documents
if history_manager.create_or_replace_json_file(n):
fp = history_manager.get_file_path(n)
message = "This document (" + n.name + ") is created on " + subject_doc.created_at.strftime("%d %B %Y")
rcs_obj.checkin(fp, 1, message.encode("utf-8"), "-i")
def load(request):
if not request.user.is_authenticated():
return HttpResponseRedirect("/accounts/login")
if request.method == 'POST':
form = ImportDeliciousForm(request.POST,request.FILES)
if form.is_valid():
db = get_database()[Bookmark.collection_name]
html=request.FILES['exported'].read().decode('utf8')
soup=BeautifulSoup(html)
for item in soup.findAll('dt'):
desc=''
next=item.findNextSiblings()
if next:
next=next[0]
if 'name' in dir(next) and next.name=='dd':
desc=unescape(u''.join(imap(unicode, next.contents)))
db.Bookmark({'url': urlSanitize(item.a['href']),
'seq': getNextVal('seq'),
'tags': item.a['tags'].split(','),
'user': unicode(request.user),
'created': datetime.fromtimestamp(float(item.a['add_date'])),
'private': item.a['private']=='1',
'title': unescape(unicode(item.a.string)),
'notes': unicode(desc)}).save()
return HttpResponseRedirect('/u/%s/' % request.user)
else:
form = ImportDeliciousForm()
return render_to_response('import.html', { 'form': form, }, context_instance=RequestContext(request) )
def test_homepage(self):
"""homepage shows a list of nodes and allows to add or delete
existing nodes """
response = self.client.get(reverse('homepage'))
self.assertTrue(response.status_code, 200)
self.assertTrue('No nodes in the gnowledge base' in response.content)
data = {'name': '',
'creationtime': '2010-12-31',
'tags': ' semantic web , network '}
response = self.client.post(reverse('homepage'), data)
self.assertEqual(response.status_code, 200)
self.assertTrue('class="errorlist"' in response.content)
self.assertTrue('This field is required' in response.content)
data['name'] = 'gnowsys'
response = self.client.post(reverse('homepage'), data)
self.assertEqual(response.status_code, 302)
response = self.client.get(reverse('homepage'))
self.assertTrue(response.status_code, 200)
self.assertTrue('gnowsys' in response.content)
self.assertTrue('31 December 2010' in response.content)
self.assertTrue('Tags: semantic web, network' in response.content)
collection = get_database()[Node.collection_name]
node = collection.Node.one()
assert node.topic == u"gnowsys"
delete_url = reverse('delete_node', args=[str(node._id)])
response = self.client.get(delete_url)
self.assertEqual(response.status_code, 302)
response = self.client.get(reverse('homepage'))
self.assertTrue(response.status_code, 200)
self.assertTrue('gnowsys' not in response.content)
def handle(self, *args, **options):
db=get_database()
collection = db[Node.collection_name]
"""
cur=collection.Node.find({'group_set':{'$exists':True}})
for each in cur:
gps = collection.Node.find({'_type':u'Group'})
for eachgps in gps:
grpname = unicode(eachgps.name)
if grpname.strip() in each.group_set:
each.group_set.remove(grpname)
each.group_set.append(eachgps._id)
for each_group_set_item in each.group_set:
if type(each_group_set_item)==unicode:
each.group_set.remove(each_group_set_item)
each.save()
"""
cur=collection.Node.find({'group_set':{'$exists':True}})
for n in cur:
gs = n.group_set
n.group_set = []
for group in gs:
if type(group) == unicode:
group_obj=collection.Node.one({'name': group})
if group_obj:
n.group_set.append(group_obj._id)
else:
n.group_set.append(group)
n.save()
def setUp(self):
if not __django_12__:
# Ugly but necessary
from django.db import load_backend
backend = load_backend('django_mongokit.mongodb')
def get(key):
return getattr(settings, key, None)
self.connection = backend.DatabaseWrapper({
'DATABASE_HOST':
get('MONGO_DATABASE_HOST'),
'DATABASE_NAME':
settings.MONGO_DATABASE_NAME,
'DATABASE_OPTIONS':
get('MONGO_DATABASE_OPTIONS'),
'DATABASE_PASSWORD':
get('MONGO_DATABASE_PASSWORD'),
'DATABASE_PORT':
get('MONGO_DATABASE_PORT'),
'DATABASE_USER':
get('MONGO_DATABASE_USER'),
'TIME_ZONE':
settings.TIME_ZONE,
})
self.old_database_name = settings.MONGO_DATABASE_NAME
self.connection.creation.create_test_db()
db = get_database()
assert 'test_' in db.name, db.name
def create_page(request):
if not request.is_ajax():
return HttpResponse(status=400, content="Only ajax requests are accepted here")
db = get_database()
try:
post_data = json.loads(request.body)
except ValueError:
resp = {'status': 'error', 'message': "Unable to parse json"}
return HttpResponse(json.dumps(resp), content_type='application/json', status=400)
if "items" not in post_data:
resp = {"status": "error", "message": "need param 'items'"}
return HttpResponse(json.dumps(resp), content_type='application/json', status=400)
elif "tags" not in post_data:
resp = {"status": "error", "message": "need param 'tags'"}
return HttpResponse(json.dumps(resp), content_type='application/json', status=400)
elif "name" not in post_data:
resp = {"status": "error", "message": "need param 'name'"}
return HttpResponse(json.dumps(resp), content_type='application/json', status=400)
post_data["slug"] = slugify(post_data["name"])
post_data["user"] = request.user.id
db.pages.save(post_data)
resp = {
'status': 'ok',
'message': 'Saved... Thanks!',
'slug': post_data["slug"]
}
return HttpResponse(json.dumps(resp), content_type='application/json')
def mongo_fetch(request):
collections = get_database()[DataMe.collection_name]
data_docs = collections.DataMe.find_one()
resp = {}
resp['name'] = data_docs['name']
resp['surname'] = data_docs['surname']
return json.dumps(str(resp), ensure_ascii=False)
def home(request):
db = get_database()
pages = db.pages.find()
return TemplateResponse(request, 'home.html', {'pages': pages})
return TemplateResponse(request, 'home.html')
def get_redirect_url(self, *args, **kwargs):
if self.request.user.is_authenticated():
collection = get_database()[Node.collection_name]
auth_obj = collection.GSystemType.one({'_type': u'GSystemType', 'name': u'Author'})
if auth_obj:
auth_type = auth_obj._id
auth = ""
auth = collection.Group.one({'_type': u"Author", 'name': unicode(self.request.user)})
# This will create user document in Author collection to behave user as a group.
if auth is None:
auth = collection.Author()
auth.name = unicode(self.request.user)
auth.password = u""
auth.member_of.append(auth_type)
auth.group_type = u"PUBLIC"
auth.edit_policy = u"NON_EDITABLE"
auth.subscription_policy = u"OPEN"
user_id = int(self.request.user.pk)
auth.created_by = user_id
auth.modified_by = user_id
if user_id not in auth.contributors:
auth.contributors.append(user_id)
auth.save()
# This will return a string in url as username and allows us to redirect into user group as soon as user logsin.
#return "/{0}/".format(auth.pk)
return "/home/"
def handle(self, *args, **options):
history_manager = HistoryManager()
rcs_obj = RCS()
collection = get_database()[Triple.collection_name]
cur = collection.Triple.find({'_type': 'GAttribute'})
for n in cur:
if type(n['attribute_type']) == ObjectId:
attr_type = collection.Node.one({'_id': n['attribute_type']})
if attr_type:
collection.update({'_id': n['_id']}, {
'$set': {
'attribute_type': {
"$ref": attr_type.collection_name,
"$id": attr_type._id,
"$db": attr_type.db.name
}
}
})
else:
collection.remove({'_id': n['_id']})
subject_doc = collection.Node.one({'_id': n.subject})
n.name = subject_doc.name + " -- " + n.attribute_type[
'name'] + " -- " + n.object_value
# Creates a history (version-file) for GAttribute documents
if history_manager.create_or_replace_json_file(n):
fp = history_manager.get_file_path(n)
message = "This document (" + n.name + ") is created on " + subject_doc.created_at.strftime(
"%d %B %Y")
rcs_obj.checkin(fp, 1, message.encode('utf-8'), "-i")
def mongo_fetch(request):
collections = get_database()[DataMe.collection_name]
data_docs = collections.DataMe.find_one()
resp = {}
resp['name'] = data_docs['name']
resp['surname'] = data_docs['surname']
return json.dumps(str(resp),ensure_ascii=False)
def export(request):
if not request.user.is_authenticated():
return HttpResponseRedirect("/accounts/login")
db = get_database()[Bookmark.collection_name]
return render_to_response('export.html',
{'bookmarks': db.find({'user': request.user.username.encode('utf8')})},
context_instance=RequestContext(request) )
def mongo_remove(request, name, surname, ustr):
collections = get_database()[DataMe.collection_name]
return str(
collections.remove({
'name': name,
'surname': surname,
'ustr': ustr
}))
def export(request):
if not request.user.is_authenticated():
return HttpResponseRedirect("/accounts/login")
db = get_database()[Bookmark.collection_name]
return render_to_response(
'export.html',
{'bookmarks': db.find({'user': request.user.username.encode('utf8')})},
context_instance=RequestContext(request))
def view(request, slug):
db = get_database()
page = db.pages.find_one({"slug": slug})
if page is None:
raise Http404
return TemplateResponse(request, 'page.html', {'page': page})
def _read_GSystemType(GSystemType_ids):
collection = get_database()[GSystemType.collection_name]
for id_ in GSystemType_ids:
gsystem_type = collection.GSystemType.one({'_id': ObjectId(id_)})
gsystem_type.name
gsystem_type.member_of
gsystem_type.attribute_type_set
def mongo_add(request, name='Smit', surname='Patwa', ustr='Pingu'): collections = get_database()[DataMe.collection_name] obj = collections.DataMe() obj['name'] = name obj['surname'] = surname obj['ur_str'] = ustr obj.save() return 'Saved'
def mongo_add(request, name='Smit', surname='Patwa', ustr='Pingu'):
collections = get_database()[DataMe.collection_name]
obj = collections.DataMe()
obj['name'] = name
obj['surname'] = surname
obj['ur_str'] = ustr
obj.save()
return 'Saved'
def handle(self, *args, **options):
collection = get_database()[Node.collection_name]
# Renames field: 'modified_by' to 'contributors'
collection.update({'modified_by': {'$exists': True}}, {'$rename': {'modified_by': "contributors"}}, upsert=False, multi=True)
# Updates location fields' values from '{}' (empty dictionary) to '[]' (empty list)
collection.update({'location': {}}, {'$set': {'location': []}}, upsert=False, multi=True)
def handle(self, *args, **options):
db = get_database()
collection = db[Node.collection_name]
# [A] Get the " GSystemType/AttributeType/RelationType " nodes (for whom 'gsystem_type' field doesn't exist)
cur_ty_mo = collection.Node.find({'_type': {'$in': ['GSystemType', 'AttributeType', 'RelationType']}})
# Listing the nodes
for n in cur_ty_mo:
# Replace 'member_of' field with ObjectId of MetaType to which that document belongs
# - But right now we don't have such MetaType documents
# - Currently going to keep 'member_of' field... EMPTY!
n.member_of = []
n.save()
# ===================================================================================================================================
# [B] Get the " GSystem/File/Group " nodes for whom 'member_of' and 'gsystem_type' fields exist
cur_nc_mo = collection.Node.find({'member_of': {'$exists': True}, 'gsystem_type': {'$exists': True}})
# Listing the nodes
for n in cur_nc_mo:
# Replace 'member_of' field with ObjectId of GSystemType to which that document belongs
if not n.gsystem_type:
# If 'gsystem_type' field is EMPTY
# - Special case: Exists with 'Group' documents, they consists of value only for 'member_of' field (not for 'gsystem_type' field)
# - In this case, 'member_of' field is a list that consists of name of the GSystemType (i.e. 'Group')
# - So extract this value first from 'member_of' field, then assign/override 'member_of' field with an empty list.
# - For extracted value (i.e. name of the GSystemType), fetch it's documents ObjectId from database; and append this ObjectId to the 'member_of' field
gsystem_name_list = n.member_of
n.member_of = []
# Iterate name list
for name in gsystem_name_list:
gsystem_node = collection.Node.one({'_type': 'GSystemType', 'name': name})
n.member_of.append(gsystem_node._id)
else:
# Else 'gsystem_type' field is NOT empty
# - This field contains list of ObjectIds' of GSystemType to which the document belongs
# - Assign/Override 'member_of' field with an empty list
# - Append these ObjectIds to the 'member_of' field
gsystem_oid_list = n.gsystem_type
n.member_of = []
n.member_of = gsystem_oid_list
n.save()
# Remove 'gsystem_type' field from already existing documents where ever it exists!
collection.update({'gsystem_type': {'$exists': True}}, {'$unset': {'gsystem_type': ""}}, multi=True)
def _update_GSystem(GSystem_ids):
collection = get_database()[GSystem.collection_name]
for id_ in GSystem_ids:
collection.update({'_id': ObjectId(id_)},
{'$set': {'name': u'edited_text',
'gsystem_type': u'52495d205a40920ab18ed028',
'relation_set': "{u'has_capital': u'Alberta'}",
'attribute_set': ''}
},
upsert=False, multi=True)
def _create_GSystemType():
collection = get_database()[GSystemType.collection_name]
GSystemType_ids = set()
at_coll = get_database()[AttributeType.collection_name]
at_cur = at_coll.AttributeType.find()
gsystem_type = collection.GSystemType()
gsystem_type.name = u"places"
gsystem_type.member_of = u"GSystemType"
for i in at_cur:
gsystem_type.attribute_type_set.append(i)
gsystem_type.save()
GSystemType_ids.add(gsystem_type.pk)
return GSystemType_ids
def edit_page_view(request, slug):
db = get_database()
page = db.pages.find_one({"slug": slug})
if page is None:
raise Http404
page["json"] = dumps(page)
return TemplateResponse(request, 'edit_page.html', {'page': page})
def edit_page(request):
if not request.is_ajax():
return HttpResponse(status=400, content="Only ajax requests are accepted here")
db = get_database()
try:
post_data = json.loads(request.body)
except ValueError:
resp = {'status': 'error', 'message': "Unable to parse json"}
return HttpResponse(json.dumps(resp), content_type='application/json', status=400)
if "id" not in post_data:
resp = {"status": "error", "message": "need param id"}
return HttpResponse(json.dumps(resp), content_type='application/json', status=400)
page = db.pages.find_one({"_id": ObjectId(post_data["id"])})
if page is None:
resp = {"status": "error", "message": "howto not found"}
return HttpResponse(json.dumps(resp), content_type='application/json', status=404)
if "items" not in post_data:
resp = {"status": "error", "message": "need param 'items'"}
return HttpResponse(json.dumps(resp), content_type='application/json', status=400)
elif "tags" not in post_data:
resp = {"status": "error", "message": "need param 'tags'"}
return HttpResponse(json.dumps(resp), content_type='application/json', status=400)
elif "change_reason" not in post_data:
resp = {"status": "error", "message": "need param 'change_reason'"}
return HttpResponse(json.dumps(resp), content_type='application/json', status=400)
page_revision = page
page_revision["change_reason"] = post_data["change_reason"]
page_revision["page_id"] = page_revision["_id"]
del page_revision["_id"]
db.pages.revisions.save(page)
del page["change_reason"]
page["items"] = post_data["items"]
page["tags"] = post_data["tags"]
page["name"] = post_data["name"]
page["user"] = request.user.id
page["_id"] = ObjectId(post_data["id"])
db.pages.save(page)
resp = {
'status': 'ok',
'message': 'Saved... Thanks!',
'slug': page["slug"],
"data": page
}
return HttpResponse(dumps(resp), content_type='application/json')
def _create_relation_type():
collection = get_database()[RelationType.collection_name]
gstype_coll = get_database()[GSystemType.collection_name]
relation_type_ids = set()
relation_type = collection.RelationType()
relation_type.name = u"has_capital"
relation_type.member_of = u"relation_type"
relation_type.inverse_name = u"is_capital_of"
relation_type.slug = "has_capital"
relation_type.subject_type = [gstype_coll.GSystemType.one({"name":"places"})._id]
relation_type.object_type = [gstype_coll.GSystemType.one({"name":"places"})._id]
relation_type.is_symmetric = True
relation_type.is_reflexive = True
relation_type.is_transitive = True
relation_type.save()
relation_type_ids.add(relation_type.pk)
#Automatic creation of reverse RelationType from above RelationType object
relation_type = collection.RelationType()
relation_type.name = u"is_capital_of"
relation_type.member_of = u"relation_type"
relation_type.inverse_name = u"has_capital"
relation_type.slug = "is_capital_of"
relation_type.subject_type = [gstype_coll.GSystemType.one({"name":"places"})._id]
relation_type.object_type = [gstype_coll.GSystemType.one({"name":"places"})._id]
relation_type.is_symmetric = True
relation_type.is_reflexive = True
relation_type.is_transitive = True
relation_type.save()
relation_type_ids.add(relation_type.pk)
return relation_type_ids
def getItemByUrl(url):
db = get_database()[Bookmark.collection_name]
if slugRe.match(url):
item = db.find_one({'seq': base62.to_decimal(url)})
else:
url = fixApacheMadness(url)
url = urlSanitize(url)
item = db.find_one({'url': url})
if not item:
raise Http404
return item
def getItemByUrl(url):
db = get_database()[Bookmark.collection_name]
if slugRe.match(url):
item=db.find_one({'seq':base62.to_decimal(url)})
else:
url=fixApacheMadness(url)
url=urlSanitize(url)
item=db.find_one({'url':url})
if not item:
raise Http404
return item
def test_creating_basic_node(self):
"""test to create a basic node """
collection = get_database()[Node.collection_name]
node = collection.Node()
node.name = u"gnowsys"
node.creationtime = datetime.datetime.now()
node.tags = [u"semantic web", u"network"]
node.validate()
node.save()
self.assertTrue(node['_id'])
self.assertEqual(node.name, u"gnowsys")
def _update_relation_type(relation_type_ids):
collection = get_database()[RelationType.collection_name]
for id_ in relation_type_ids:
collection.update({'_id': ObjectId(id_)},
{'$set': {'name': u'edited_text',
'inverse_name': u'xkmjdkgkl',
'slug':'slug-string',
'is_symmetric':'false',
'is_reflexive':'false',
'is_transitive':'false'}
},
upsert=False, multi=True)
def handle(self, *args, **options):
db = get_database()
collection = db[Node.collection_name]
cur = collection.Node.find({'type_of': {'$exists': True}})
for n in cur:
gst = n.type_of
if gst == 'profile_pic':
type_obj = collection.Node.one({'name': gst})
if type_obj:
n.type_of = ObjectId(type_obj._id)
n.save()
def _create_talks(how_many):
# 1 Create 1,000 talks
collection = get_database()[Talk.collection_name]
ids = set()
for i in range(how_many):
talk = collection.Talk()
talk.topic = __random_topic()
talk.when = __random_when()
talk.tags = __random_tags()
talk.duration = __random_duration()
talk.save()
ids.add(talk.pk)
return ids
def test_creating_talk_basic(self):
"""test to create a Talk instance"""
collection = get_database()[Talk.collection_name]
talk = collection.Talk()
talk.topic = u"Bla"
talk.when = datetime.datetime.now()
talk.tags = [u"foo", u"bar"]
talk.duration = 5.5
talk.validate()
talk.save()
self.assertTrue(talk['_id'])
self.assertEqual(talk.duration, 5.5)
def _read_relation_type(relation_type_ids):
collection = get_database()[RelationType.collection_name]
for id_ in relation_type_ids:
relation_type = collection.RelationType.one({'_id': ObjectId(id_)})
relation_type.name
relation_type.member_of
relation_type.inverse_name
relation_type.slug
relation_type.subject_type
relation_type.object_type
relation_type.is_symmetric
relation_type.is_reflexive
relation_type.is_transitive
def _read_author_nodes(author_ids):
collection = get_database()[Author.collection_name]
for id_ in author_ids:
author = collection.Author.one({'_id': ObjectId(id_)})
author.username
author.password
author.email
author.first_name
author.last_name
author.address
author.phone
author.is_active
author.is_staff
author.is_superuser
author.created_at
author.last_login
def _update_author_nodes(author_ids):
collection = get_database()[Author.collection_name]
for id_ in author_ids:
collection.update({'_id': ObjectId(id_)},
{'$set': {'username': u'edited_text',
'password': u'edit12%',
'email': u'*****@*****.**',
'first_name':'uyhskk',
'last_name':'ksdbmplp',
'phone':'4568965874L',
'is_active':'true',
'is_staff':'false',
'is_superuser':'******',
'created_at':'datetime.datetime(2013, 9, 20, 14, 13, 44, 304360)',
'last_login':'******'}
},
upsert=False, multi=True)
def delete(request, url):
if not request.user.is_authenticated():
return HttpResponseRedirect("/accounts/login")
url = fixApacheMadness(url)
try:
user = User.objects.get(username=request.user)
db = get_database()[Bookmark.collection_name]
for obj in db.find({'url': url, 'user': unicode(request.user)}):
for hash in obj.get('snapshot', []):
if not hash.strip(): continue
fname = "%s/snapshots/%s" % (settings.BASE_PATH, hash)
if os.path.exists(fname):
os.unlink(fname)
db.remove(obj)
except ObjectDoesNotExist:
print "meh delete not working. user, url or obj not existing"
return HttpResponseRedirect('/u/%s/' % request.user)
