def quiz(request, group_id):
"""Renders a list of all 'Quiz-type-GSystems' available within the database.
"""
try:
group_id = ObjectId(group_id)
except:
group_name, group_id = get_group_name_id(group_id)
title = gst_quiz.name
quiz_nodes = node_collection.find({
'member_of': gst_quiz._id,
'group_set': ObjectId(group_id)
}).sort('last_update', -1)
gst_quiz_item_id = node_collection.one({
'_type': 'GSystemType',
'name': u'QuizItem'
})._id
quiz_item_nodes = node_collection.find({
'member_of': {
'$all': [gst_quiz_item_id]
},
'group_set': {
'$all': [ObjectId(group_id)]
}
}).sort('last_update', -1)
return render_to_response("ndf/quiz.html", {
'title': title,
'quiz_nodes': quiz_nodes,
'quiz_item_nodes': quiz_item_nodes,
'groupid': group_id,
'group_id': group_id
},
context_instance=RequestContext(request))
def partner_showcase(request, group_id):
group_name, group_id = get_group_name_id(group_id)
all_source = node_collection.find({
'attribute_set.source': {
'$exists': True,
'$ne': ''
}
}).distinct('attribute_set.source')
partner_group = node_collection.one({
'_type': 'GSystemType',
'name': 'PartnerGroup'
})
source_partners = node_collection.find({
'_type': 'Group',
'member_of': {
'$in': [partner_group._id]
},
'name': {
'$in': all_source
}
}).sort('name', 1)
return render_to_response('ndf/partner_showcase.html', {
'group_id': group_id,
'groupid': group_id,
'source_partners': source_partners
},
context_instance=RequestContext(request))
def explore_drafts(request):
title = 'drafts'
module_sort_list = None
module_sort_list = get_attribute_value(group_id, 'items_sort_list')
context_variable = {
'title': title,
'group_id': group_id, 'groupid': group_id,
}
if module_sort_list:
modules_cur = map(Node,module_sort_list)
context_variable.update({'modules_is_cur': False})
else:
modules_cur = node_collection.find({'member_of': gst_module_id ,'status':'PUBLISHED'}).sort('last_update', -1)
context_variable.update({'modules_is_cur': True})
module_unit_ids = [val for each_module in modules_cur for val in each_module.collection_set ]
gstaff_access = check_is_gstaff(group_id,request.user)
draft_query = {'member_of': gst_base_unit_id,
'_id': {'$nin': module_unit_ids},
'status':'PUBLISHED',
}
if not gstaff_access:
draft_query.update({'$or': [
{'created_by': request.user.id},
{'group_admin': request.user.id},
{'author_set': request.user.id},
# No check on group-type PUBLIC for DraftUnits.
# {'group_type': 'PUBLIC'}
]})
base_unit_cur = node_collection.find(draft_query).sort('last_update', -1)
# print "\nbase: ", base_unit_cur.count()
'''
base_unit_cur = node_collection.find({'member_of': gst_base_unit_id,
'_id': {'$nin': module_unit_ids},
'status':'PUBLISHED',
'$or': [
{'created_by': request.user.id},
{'group_admin': request.user.id},
{'author_set': request.user.id},
# {'group_type': 'PUBLIC'}
]}).sort('last_update', -1)
'''
# base_unit_page_cur = paginator.Paginator(base_unit_cur, page_no, GSTUDIO_NO_OF_OBJS_PP)
# base_unit_page_cur = paginator.Paginator(base_unit_cur, page_no, GSTUDIO_NO_OF_OBJS_PP)
context_variable.update({'modules_cur': modules_cur,'units_cur': base_unit_cur})
return render_to_response(
# "ndf/explore.html", changed as per new Clix UI
"ndf/explore_2017.html",
# "ndf/lms_explore.html",
context_variable,
context_instance=RequestContext(request))
def adminDashboard(request):
'''
methods for class view
'''
objects_details = []
nodes = node_collection.find({'_type': "GSystem"})
group_obj = node_collection.find(
{'$and': [{
"_type": u'Group'
}, {
"name": u'home'
}]})
groupid = ""
if group_obj:
groupid = str(group_obj[0]._id)
group_name = group_obj[0].name
for each in nodes:
objects_details.append({
"Id": each._id,
"Title": each.name,
"Type": each.type_of,
"Author": User.objects.get(id=each.created_by).username,
"Group": ",".join(each.group_set)
})
template = "ndf/adminDashboard.html"
variable = RequestContext(
request, {
'class_name': "GSystem",
"nodes": objects_details,
"groupid": groupid,
"group_name": group_name
})
return render_to_response(template, variable)
def explore_groups(request):
title = 'groups'
gstaff_access = check_is_gstaff(group_id, request.user)
if gstaff_access:
group_cur = node_collection.find({
'_type': 'Group',
'member_of': gst_group._id
}).sort('last_update', -1)
else:
group_cur = node_collection.find({
'_type': 'Group',
'member_of': gst_group._id,
'name': {
'$nin': GSTUDIO_DEFAULT_GROUPS
}
}).sort('last_update', -1)
context_variable = {
'title': title,
'doc_cur': group_cur,
'card': 'ndf/simple_card.html',
'group_id': group_id,
'groupid': group_id
}
return render_to_response("ndf/explore.html",
context_variable,
context_instance=RequestContext(request))
def explore_drafts(request,page_no=1):
title = 'drafts'
modules_cur = node_collection.find({'member_of': gst_module_id }).sort('last_update', -1)
module_unit_ids = [val for each_module in modules_cur for val in each_module.collection_set ]
modules_cur.rewind()
modules_page_cur = paginator.Paginator(modules_cur, page_no, GSTUDIO_NO_OF_OBJS_PP)
base_unit_cur = node_collection.find({'member_of': gst_base_unit_id,
'_id': {'$nin': module_unit_ids},
'status':'PUBLISHED',
'$or': [
{'created_by': request.user.id},
{'group_admin': request.user.id},
{'author_set': request.user.id},
{'group_type': 'PUBLIC'}
]}).sort('last_update', -1)
base_unit_page_cur = paginator.Paginator(base_unit_cur, page_no, GSTUDIO_NO_OF_OBJS_PP)
context_variable = {
'title': title, 'modules_cur': modules_cur,
'units_cur': base_unit_cur,
'group_id': group_id, 'groupid': group_id,
}
return render_to_response(
# "ndf/explore.html", changed as per new Clix UI
"ndf/explore_2017.html",
# "ndf/lms_explore.html",
context_variable,
context_instance=RequestContext(request))
def explore_drafts(request):
title = 'drafts'
module_sort_list = None
module_sort_list = get_attribute_value(group_id, 'items_sort_list')
context_variable = {
'title': title,
'group_id': group_id, 'groupid': group_id,
}
if module_sort_list:
modules_cur = map(Node,module_sort_list)
context_variable.update({'modules_is_cur': False})
else:
modules_cur = node_collection.find({'member_of': gst_module_id ,'status':'PUBLISHED'}).sort('last_update', -1)
context_variable.update({'modules_is_cur': True})
module_unit_ids = [val for each_module in modules_cur for val in each_module.collection_set ]
gstaff_access = check_is_gstaff(group_id,request.user)
draft_query = {'member_of': gst_base_unit_id,
'_id': {'$nin': module_unit_ids},
'status':'PUBLISHED',
}
if not gstaff_access:
draft_query.update({'$or': [
{'created_by': request.user.id},
{'group_admin': request.user.id},
{'author_set': request.user.id},
# No check on group-type PUBLIC for DraftUnits.
# {'group_type': 'PUBLIC'}
]})
base_unit_cur = node_collection.find(draft_query).sort('last_update', -1)
# print "\nbase: ", base_unit_cur.count()
'''
base_unit_cur = node_collection.find({'member_of': gst_base_unit_id,
'_id': {'$nin': module_unit_ids},
'status':'PUBLISHED',
'$or': [
{'created_by': request.user.id},
{'group_admin': request.user.id},
{'author_set': request.user.id},
# {'group_type': 'PUBLIC'}
]}).sort('last_update', -1)
'''
# base_unit_page_cur = paginator.Paginator(base_unit_cur, page_no, GSTUDIO_NO_OF_OBJS_PP)
# base_unit_page_cur = paginator.Paginator(base_unit_cur, page_no, GSTUDIO_NO_OF_OBJS_PP)
context_variable.update({'modules_cur': modules_cur,'units_cur': base_unit_cur})
return render_to_response(
# "ndf/explore.html", changed as per new Clix UI
"ndf/explore_2017.html",
# "ndf/lms_explore.html",
context_variable,
context_instance=RequestContext(request))
def quiz(request, group_id):
"""Renders a list of all 'Quiz-type-GSystems' available within the database.
"""
group_obj = get_group_name_id(group_id, get_obj=True)
group_id = group_obj._id
group_name = group_obj.name
title = gst_quiz.name
quiz_nodes = node_collection.find({'member_of': gst_quiz._id, 'group_set': ObjectId(group_id)}).sort('last_update', -1)
# gst_quiz_item_ids = [gst_quiz_item._id]
quiz_item_nodes = node_collection.find({'member_of': gst_quiz_item._id,
'group_set': ObjectId(group_id)}).sort('last_update', -1)
if "CourseEventGroup" in group_obj.member_of_names_list or "announced_unit" in group_obj.member_of_names_list:
# gst_quiz_item_ids = [gst_quiz_item_event._id]
if not quiz_item_nodes.count():
quiz_item_nodes = node_collection.find({'member_of': gst_quiz_item_event._id,
'group_set': ObjectId(group_id)}).sort('last_update', -1)
supported_languages = ['Hindi', 'Telugu']
print "\nquiz_item_nodes: ", quiz_item_nodes.count()
return render_to_response("ndf/quiz.html",
{'title': title,
'quiz_nodes': quiz_nodes,
'quiz_item_nodes': quiz_item_nodes,
'groupid':group_id,
'group_id':group_id,
'supported_languages': supported_languages
},
context_instance=RequestContext(request)
)
def adminDashboardClass(request, class_name="GSystem"):
'''
fetching class's objects
'''
group_set = ""
if request.method=="POST":
search = request.POST.get("search","")
classtype = request.POST.get("class","")
nodes = node_collection.find({'name':{'$regex':search, '$options': 'i' },'_type':classtype})
else :
nodes = node_collection.find({'_type':class_name})
objects_details = []
for each in nodes:
member = []
# for members in each.member_of:
# obj = node_collection.one({ '_id': members})
# if obj:
# member.append(obj.name+" - "+str(members))
member = []
member_of_list = []
collection_list = []
attribute_type_set = []
relation_type_set = []
if class_name == "GSystemType":
for members in each.member_of:
member.append(node_collection.one({ '_id': members}).name)
# member_of_list.append(node_collection.one({'_id':members}).name+" - "+str(members))
for coll in each.collection_set:
collection_list.append(node_collection.one({ '_id': coll}).name)
# collection_list.append(node_collection.one({ '_id': coll}).name+" - "+str(coll))
for at_set in each.attribute_type_set:
attribute_type_set.append(at_set.name)
# attribute_type_set.append(at_set.name+" - "+str(at_set._id))
for rt_set in each.relation_type_set:
relation_type_set.append(rt_set.name)
# relation_type_set.append(rt_set.name+" - "+str(rt_set._id))
if class_name in ("GSystem","File"):
group_set = [node_collection.find_one({"_id":eachgroup}).name for eachgroup in each.group_set if node_collection.find_one({"_id":eachgroup}) ]
objects_details.append({"Id":each._id,"Title":each.name,"Type":", ".join(member),"Author":User.objects.get(id=each.created_by).username,"Group":", ".join(group_set),"Creation":each.created_at})
elif class_name in ("GAttribute","GRelation"):
objects_details.append({"Id":each._id,"Title":each.name,"Type":"","Author":"","Creation":""})
else :
objects_details.append({"Id":each._id,"Title":each.name,"Type":", ".join(member),"Author":User.objects.get(id=each.created_by).username,"Creation":each.created_at,'member_of':", ".join(member_of_list), "collection_list":", ".join(collection_list), "attribute_type_set":", ".join(attribute_type_set), "relation_type_set":", ".join(relation_type_set)})
groups = []
group = node_collection.find({'_type':"Group"})
for each in group:
groups.append({'id':each._id,"title":each.name})
systemtypes = []
systemtype = node_collection.find({'_type':"GSystemType"})
for each in systemtype:
systemtypes.append({'id':each._id,"title":each.name})
groupid = ""
group_obj= node_collection.find({'$and':[{"_type":u'Group'},{"name":u'home'}]})
if group_obj:
groupid = str(group_obj[0]._id)
template = "ndf/adminDashboard.html"
variable = RequestContext(request, {'class_name':class_name, "nodes":objects_details, "Groups":groups, "systemtypes":systemtypes, "url":"data", "groupid":groupid})
return render_to_response(template, variable)
def quiz(request, group_id):
"""Renders a list of all 'Quiz-type-GSystems' available within the database.
"""
group_obj = get_group_name_id(group_id, get_obj=True)
group_id = group_obj._id
group_name = group_obj.name
title = gst_quiz.name
quiz_nodes = node_collection.find({
'member_of': gst_quiz._id,
'group_set': ObjectId(group_id)
}).sort('last_update', -1)
gst_quiz_names = ['QuizItem']
if "CourseEventGroup" in group_obj.member_of_names_list:
gst_quiz_names.append('QuizItemEvent')
gst_quiz_item = node_collection.find({
'_type': 'GSystemType',
'name': {
'$in': gst_quiz_names
}
})
gst_quiz_item_ids = [each_quiz_gst._id for each_quiz_gst in gst_quiz_item]
quiz_item_nodes = node_collection.find({
'member_of': {
'$in': gst_quiz_item_ids
},
'group_set': ObjectId(group_id)
}).sort('last_update', -1)
return render_to_response("ndf/quiz.html", {
'title': title,
'quiz_nodes': quiz_nodes,
'quiz_item_nodes': quiz_item_nodes,
'groupid': group_id,
'group_id': group_id
},
context_instance=RequestContext(request))
def video_search(request,group_id):
# ins_objectid = ObjectId()
# if ins_objectid.is_valid(group_id) is False :
# group_ins = node_collection.find_one({'_type': "Group","name": group_id})
# auth = node_collection.one({'_type': 'Author', 'name': unicode(request.user.username) })
# if group_ins:
# group_id = str(group_ins._id)
# else :
# auth = node_collection.one({'_type': 'Author', 'name': unicode(request.user.username) })
# if auth :
# group_id = str(auth._id)
# else :
# pass
try:
group_id = ObjectId(group_id)
except:
group_name, group_id = get_group_name_id(group_id)
vidcol = node_collection.find({'mime_type':{'$regex': 'video'}})
if request.method=="GET":
keyword=request.GET.get("search","")
vid_search = node_collection.find({'$and':[{'mime_type':{'$regex': 'video'}},{'$or':[{'name':{'$regex':keyword}},{'tags':{'$regex':keyword}}]}]})
template="ndf/file_search.html"
variable=RequestContext(request,{'file_collection':vid_search,'view_name':'video_search','newgroup':group_id})
return render_to_response(template,variable)
def create_rts(factory_relation_types,user_id):
meta_type_id = ""
member_of_type_id = ""
for each in factory_relation_types:
subject_type_id_list = []
object_type_id_list = []
object_cardinality = None
is_reflexive = None
is_transitive = None
for key,value in each.items():
at_name = key
inverse_name = value['inverse_name']
if "meta_type" in value:
meta_type_name = value['meta_type']
meta_type = node_collection.one({'$and':[{'_type':'MetaType'},{'name':meta_type_name}]})
if meta_type:
meta_type_id = meta_type._id
if "member_of" in value:
member_of_name = value['member_of']
member_of_type = node_collection.one({'$and':[{'_type':'MetaType'},{'name':member_of_name}]})
if member_of_type:
member_of_type_id = member_of_type._id
for s in value['subject_type']:
if s == "*":
node_s = node_collection.find({'_type': u'GSystemType'},{'_id':1})
subject_type_id_list = [each_node._id for each_node in node_s]
else:
node_s = node_collection.one({'$and':[{'_type': u'GSystemType'},{'name': s}]})
if node_s is None:
node_s = node_collection.one({'$and':[{'_type': u'MetaType'},{'name': s}]})
subject_type_id_list.append(node_s._id)
for rs in value['object_type']:
if rs == "*":
node_s = node_collection.find({'_type': u'GSystemType'},{'_id':1})
object_type_id_list = [each_node._id for each_node in node_s]
else:
node_rs = node_collection.one({'$and':[{'_type': u'GSystemType'},{'name': rs}]})
if node_rs is None:
node_rs =node_collection.one({'$and':[{'_type': u'MetaType'},{'name': rs}]})
object_type_id_list.append(node_rs._id)
if "object_cardinality" in value:
object_cardinality = value["object_cardinality"]
if "is_reflexive" in value:
is_reflexive = value["is_reflexive"]
if "is_transitive" in value:
is_transitive = value["is_transitive"]
create_relation_type(at_name, inverse_name, user_id, subject_type_id_list, object_type_id_list, meta_type_id, object_cardinality, member_of_type_id, is_reflexive, is_transitive)
def send_event_notif_to_all_grp_members(group_obj, app_set_id, event_node, user_list):
group_id = group_obj._id
to_user_list = []
event_organizer_str = ""
event_coordinator_str = ""
event_organized_by = []
event_attendees = []
event_coordinator = []
for i in event_node.relation_set:
if unicode('event_organised_by') in i.keys():
event_organized_by = i['event_organised_by']
if unicode('has_attendees') in i.keys():
event_attendees = i['has_attendees']
if unicode('event_coordinator') in i.keys():
event_coordinator = i['event_coordinator']
try:
event_url = "/"+str(group_id)+"/event/"+str(app_set_id) +"/"+str(event_node._id)
site = Site.objects.get(pk=1)
site = site.name.__str__()
event_link = "http://" + site + event_url
event_organized_by_cur = node_collection.find({"_id":{'$in':event_organized_by}})
event_coordinator_cur = node_collection.find({"_id":{'$in':event_coordinator}})
for i in event_coordinator_cur:
event_coordinator_str = event_coordinator_str + i.name + " "
for i in event_organized_by_cur:
event_organizer_str = event_coordinator_str + i.name + " "
render_label = render_to_string(
"notification/label.html",
{
"sender": "metaStudio",
"activity": "Event Created",
"conjunction": "-"
})
if user_list:
for j in event_attendees:
auth = node_collection.one({"_id":ObjectId(j)})
user_obj = User.objects.get(id=auth.created_by)
if user_obj not in to_user_list:
to_user_list.append(user_obj)
else:
for each_member in group_obj.author_set:
user_obj = User.objects.get(id=each_member)
if user_obj not in to_user_list:
to_user_list.append(user_obj)
if event_organized_by:
msg_string = "\n Event is organized by " + str ( event_organizer_str )
else:
msg_string = ""
message_string = "Invitation for Event"+ " " + str(event_node.name) + msg_string + "\n Event will be co-ordinated by " +str (event_coordinator_str) + "\n- Please click [[" + event_link + "][here]] to view the details of the event"
notification.create_notice_type(render_label, message_string, "notification") ##This is sent via email to all attendees in the group
notification.send(to_user_list, render_label, {"from_user":"******"})
except Exception as mailerror:
error_msg = "Unable to send notifications!!! ", str(mailerror)
# print error_msg
pass
def index(request, group_id):
# ins_objectid = ObjectId()
# if ins_objectid.is_valid(group_id) is False :
# group_ins = node_collection.find_one({'_type': "Group","name": group_id})
# auth = node_collection.one({'_type': 'Author', 'name': unicode(request.user.username) })
# if group_ins:
# group_id = str(group_ins._id)
# else :
# auth = node_collection.one({'_type': 'Author', 'name': unicode(request.user.username) })
# if auth :
# group_id = str(auth._id)
# else :
# pass
try:
group_id = ObjectId(group_id)
except:
group_name, group_id = get_group_name_id(group_id)
tag_coll = []
selected_topic = None
topic_coll = node_collection.find({"_type": u"GSystem"})
topic_count = topic_coll.count()
#print "here: " + str(topic_coll)
topics = node_collection.find({"_type": u"GSystem"})
#Tag collection
tag_count = 0
for topic1 in topics:
for tag1 in topic1.tags:
tag_coll.append(tag1)
tag_count += 1
context = RequestContext(request, {
'title': "WikiData Topics",
'topic_coll': topic_coll
})
template = "ndf/wikidata.html"
variable = RequestContext(request, {'title': "WikiData Topics"})
context_variables = {'title': "WikiData Topics"}
context_instance = RequestContext(request, {
'title': "WikiData Topics",
'groupid': group_id,
'group_id': group_id
})
attribute_set = None
return render(
request, template, {
'title': "WikiData Topics",
'topic_coll': topic_coll,
'tag_count': tag_count,
'tag_coll': tag_coll,
'selected_topic': selected_topic,
'attribute_set': attribute_set,
'groupid': group_id,
'group_id': group_id,
'topic_count': topic_count
})
def module(request, group_id, module_id=None):
"""
* Renders a list of all 'modules' available within the database.
"""
# ins_objectid = ObjectId()
# if ins_objectid.is_valid(group_id) is False :
# group_ins = node_collection.find_one({'_type': "Group","name": group_id})
# auth = node_collection.one({'_type': 'Author', 'name': unicode(request.user.username) })
# if group_ins:
# group_id = str(group_ins._id)
# else :
# auth = node_collection.one({'_type': 'Author', 'name': unicode(request.user.username) })
# if auth :
# group_id = str(auth._id)
# else :
# pass
try:
group_id = ObjectId(group_id)
except:
group_name, group_id = get_group_name_id(group_id)
if module_id is None:
module_ins = node_collection.find_one({'_type':"GSystemType", "name":"Module"})
if module_ins:
module_id = str(module_ins._id)
if request.method == "POST":
# Module search view
title = GST_MODULE.name
search_field = request.POST['search_field']
module_coll = node_collection.find({'member_of': {'$all': [ObjectId(GST_MODULE._id)]},
'$or': [{'name': {'$regex': search_field, '$options': 'i'}},
{'tags': {'$regex':search_field, '$options': 'i'}}],
'group_set': {'$all': [ObjectId(group_id)]}
}).sort('last_update', -1)
# module_nodes_count = course_coll.count()
return render_to_response("ndf/module.html",
{'title': title,
'appId':app._id,
'searching': True, 'query': search_field,
'module_coll': module_coll, 'groupid':group_id, 'group_id':group_id
},
context_instance=RequestContext(request)
)
elif GST_MODULE._id == ObjectId(module_id):
# Module list view
title = GST_MODULE.name
module_coll = node_collection.find({'member_of': {'$all': [ObjectId(module_id)]}, 'group_set': {'$all': [ObjectId(group_id)]}})
template = "ndf/module.html"
variable = RequestContext(request, {'title': title, 'appId':app._id, 'module_coll': module_coll, 'group_id': group_id, 'groupid': group_id})
return render_to_response(template, variable)
def batch(request, group_id):
"""
* Renders a list of all 'batches' available within the database.
"""
group_name, group_id = get_group_name_id(group_id)
# ins_objectid = ObjectId()
# st_student = node_collection.one({'_type':'GSystemType','name':'Student'})
# if ins_objectid.is_valid(group_id) is False :
# group_ins = node_collection.find_one({'_type': "Group","name": group_id})
# auth = node_collection.one({'_type': 'Author', 'name': unicode(request.user.username) })
# if group_ins:
# group_id = str(group_ins._id)
# else :
# auth = node_collection.one({'_type': 'Author', 'name': unicode(request.user.username) })
# if auth :
# group_id = str(auth._id)
# else :
# pass
nussd_course_type_name = ""
announced_course_name = ""
if request.method == "POST":
announced_course_name = request.POST.get("announced_course_name", "")
nussd_course_type_name = request.POST.get("nussd_course_name", "")
# colg_gst = node_collection.one({'_type': "GSystemType", 'name': 'College'})
# req_colg_id = node_collection.one({'member_of': colg_gst._id, 'relation_set.has_group': ObjectId(group_id)})
batch_coll = node_collection.find({'member_of': GST_BATCH._id, 'relation_set.has_course': ObjectId(announced_course_name)})
# for each_batch in batch_coll:
# each_batch['batch_name_human_readble'] = (each_batch.name).replace('_',' ')
else:
batch_coll = node_collection.find({'member_of': GST_BATCH._id, 'relation_set.batch_in_group':ObjectId(group_id)})
fetch_ATs = ["nussd_course_type"]
req_ATs = []
for each in fetch_ATs:
each = node_collection.one({'_type': "AttributeType", 'name': each}, {'_type': 1, '_id': 1, 'data_type': 1, 'complex_data_type': 1, 'name': 1, 'altnames': 1})
if each["data_type"] == "IS()":
dt = "IS("
for v in each.complex_data_type:
dt = dt + "u'" + v + "'" + ", "
dt = dt[:(dt.rfind(", "))] + ")"
each["data_type"] = dt
each["data_type"] = eval(each["data_type"])
each["value"] = None
req_ATs.append(each)
# users_in_group = node_collection.one({'_id':ObjectId(group_id)}).author_set
template = "ndf/batch.html"
variable = RequestContext(request, {'batch_coll': batch_coll,
'appId': app._id,
'nussd_course_name_var': nussd_course_type_name,
'announced_course_name_var': announced_course_name,
'ATs': req_ATs, 'group_id': group_id,
'groupid': group_id, 'title': GST_BATCH.name,
'st_batch_id': GST_BATCH._id})
return render_to_response(template, variable)
def gst_attributes(gst_name_or_id):
if not gst_name_or_id:
return node_collection.find({'_type': 'AttributeType'}).distinct('name')
try:
gst_id = ObjectId(gst_name_or_id)
except Exception as e:
gst_name, gst_id = GSystemType.get_gst_name_id(gst_name_or_id)
return [at.name for at in node_collection.find({'_type': 'AttributeType', 'subject_type': gst_id})]
def gst_attributes(gst_name_or_id):
if not gst_name_or_id:
return node_collection.find({'_type': 'AttributeType'}).distinct('name')
try:
gst_id = ObjectId(gst_name_or_id)
except Exception as e:
gst_name, gst_id = GSystemType.get_gst_name_id(gst_name_or_id)
return [at.name for at in node_collection.find({'_type': 'AttributeType', 'subject_type': gst_id})]
def explore_drafts(request, page_no=1):
title = 'drafts'
modules_cur = node_collection.find({
'member_of': gst_module_id
}).sort('last_update', -1)
module_unit_ids = [
val for each_module in modules_cur
for val in each_module.collection_set
]
modules_cur.rewind()
modules_page_cur = paginator.Paginator(modules_cur, page_no,
GSTUDIO_NO_OF_OBJS_PP)
base_unit_cur = node_collection.find({
'member_of':
gst_base_unit_id,
'_id': {
'$nin': module_unit_ids
},
'status':
'PUBLISHED',
'$or': [{
'created_by': request.user.id
}, {
'group_admin': request.user.id
}, {
'author_set': request.user.id
}, {
'group_type': 'PUBLIC'
}]
}).sort('last_update', -1)
base_unit_page_cur = paginator.Paginator(base_unit_cur, page_no,
GSTUDIO_NO_OF_OBJS_PP)
context_variable = {
'title': title,
'modules_cur': modules_cur,
'units_cur': base_unit_cur,
'group_id': group_id,
'groupid': group_id,
}
return render_to_response(
# "ndf/explore.html", changed as per new Clix UI
"ndf/explore_2017.html",
# "ndf/lms_explore.html",
context_variable,
context_instance=RequestContext(request))
def explore_groups(request):
title = 'groups'
gstaff_access = check_is_gstaff(group_id,request.user)
if gstaff_access:
group_cur = node_collection.find({'_type': 'Group', 'member_of': gst_group._id}).sort('last_update', -1)
else:
group_cur = node_collection.find({'_type': 'Group', 'member_of': gst_group._id,'name':{'$nin':GSTUDIO_DEFAULT_GROUPS }}).sort('last_update', -1)
context_variable = {'title': title, 'doc_cur': group_cur, 'card': 'ndf/simple_card.html',
'group_id': group_id, 'groupid': group_id}
return render_to_response(
"ndf/explore.html",
context_variable,
context_instance=RequestContext(request))
def list_units(request, group_id):
'''
listing of units
'''
parent_group_name, parent_group_id = Group.get_group_name_id(group_id)
all_base_units = node_collection.find({
'_type': 'Group',
'group_set': {'$in': [parent_group_id]},
'member_of': {'$in': [gst_base_unit_id]},
'$or':[
{'status': u'PUBLIC'},
{
'$and': [
{'access_policy': u"PRIVATE"},
{'created_by': request.user.id}
]
}
]
}).sort('last_update', -1)
template = "ndf/explore_2017.html"
req_context = RequestContext(request, {
'group_id': parent_group_id,
'all_unit_objs': all_base_units
})
return render_to_response(template, req_context)
def handle(self, *args, **options):
gst_base_unit_name, gst_base_unit_id = GSystemType.get_gst_name_id('announced_unit')
gst_course_ev_gr = node_collection.one({'_type': 'GSystemType', 'name': 'CourseEventGroup'})
all_course_groups = node_collection.find({'_type': 'Group', 'member_of': {'$in': [gst_course_ev_gr._id, gst_base_unit_id]} })
all_course_groups_count = all_course_groups.count()
csv_created_count = 0
for gr_index, each_group_obj in enumerate(all_course_groups, 1):
assessment_and_quiz_data = True
print "\n\n[ %d / %d ]" % (gr_index, all_course_groups_count)
try:
print "Exporting CSV for :", each_group_obj.name, "(Altnames:", each_group_obj.altnames, ")\n"
except Exception as e:
print "\n!! Exception in printing name of unit: ", e
print "\n\nExporting CSV for :", each_group_obj._id, "\n"
pass
csv_created_count += export_group_analytics(each_group_obj, assessment_and_quiz_data)
# print "Enter 'group name(case sensitive)' OR 'id': "
# group_name_or_id = raw_input()
# group_obj = Group.get_group_name_id(group_name_or_id, get_obj=True)
# if not group_obj:
# raise ValueError('\nSorry. Request could not be visited. \
# \nGroup/Course, matching argument entered "' + group_name_or_id + '" does not exists!!')
# export_group_analytics(group_obj,False)
print "RESULT OF CSV EXPORT:\n\t- CREATED: %d\n\t- NOT CREATED: %d"%(csv_created_count, (all_course_groups_count - csv_created_count))
print "=" * 100
def link_login_ac():
"""This function links Author GSystem and Respecive Person's Sub-type GSystem.
"""
users = User.objects.all()
has_login_rt = node_collection.one({
'_type': "RelationType",
'name': "has_login"
})
for each in users:
person_node = node_collection.find(
{'attribute_set.email_id': each.email})
auth_node = node_collection.one({
'_type': "Author",
'email': each.email
})
if person_node.count() <= 0 or auth_node is None:
error_message = "\n Either person_node or auth_node doesn't exists for given email (" + each.email + ") !!!"
log_list.append(error_message)
continue
for pn in person_node:
gr_node = create_grelation(pn._id, has_login_rt, auth_node._id)
info_message = "\n This GRelation created for " + str(
gr_node.name) + "."
log_list.append(info_message)
def get_user_replies(request, group_id, user_name_or_id):
group_obj = get_group_name_id(group_id, get_obj=True)
group_id = group_obj._id
user_obj = None
try:
if user_name_or_id.isdigit():
user_obj = User.objects.get(pk=int(user_name_or_id))
else:
user_obj = User.objects.get(username=(user_name_or_id).strip())
if user_obj:
gst_reply = node_collection.one({
'_type': 'GSystemType',
'name': 'Reply'
})
user_replies = node_collection.find({
'member_of': gst_reply._id,
'group_set': ObjectId(group_id),
'contributors': user_obj.pk
}).sort('last_update', -1)
return render_to_response('ndf/user_interactions.html', {
'group_id': group_id,
'groupid': group_id,
'group_name': group_obj.name,
'user_replies': user_replies,
'user_obj': user_obj
},
context_instance=RequestContext(request))
except Exception as no_user:
return HttpResponse('No such User found')
def quiz_details(request, group_id, node_id):
try:
group_id = ObjectId(group_id)
except:
group_name, group_id = get_group_name_id(group_id)
title = gst_quiz.name
gst_quiz_item = node_collection.one({
'_type': 'GSystemType',
'name': u'QuizItem'
})
quiz_node = node_collection.one({'_id': ObjectId(node_id)})
quiz_item_nodes = node_collection.find({
'_id': {
'$in': quiz_node.collection_set
},
'member_of': gst_quiz_item._id
}).sort('last_update', -1)
# quiz_node.get_neighbourhood(quiz_node.member_of)
context_variables = {
'groupid': group_id,
'group_id': group_id,
'title': title,
'node': quiz_node,
'quiz_item_nodes': quiz_item_nodes
}
return render_to_response("ndf/quiz_details.html",
context_variables,
context_instance=RequestContext(request))
def explore_groups(request,page_no=1):
title = 'workspaces'
gstaff_access = check_is_gstaff(group_id,request.user)
query = {'_type': 'Group', 'status': u'PUBLISHED',
'agency_type':u"School",
'$or': [
{'access_policy': u"PUBLIC"},
{'$and': [
{'access_policy': u"PRIVATE"},
{'created_by': request.user.id}
]
}
],
'member_of': {'$in': [gst_group._id],
'$nin': [gst_course._id, gst_basecoursegroup._id, ce_gst._id, gst_course._id, gst_base_unit_id]},
}
if gstaff_access:
query.update({'group_type': {'$in': [u'PUBLIC', u'PRIVATE']}})
else:
query.update({'name': {'$nin': GSTUDIO_DEFAULT_GROUPS_LIST},
'group_type': u'PUBLIC'})
group_cur = node_collection.find(query).sort('last_update', -1)
grp_page_cur = paginator.Paginator(group_cur, page_no, GSTUDIO_NO_OF_OBJS_PP)
context_variable = {'title': title, 'groups_cur': group_cur, 'card': 'ndf/card_group.html',
'group_id': group_id, 'groupid': group_id,'grp_page_cur': grp_page_cur}
return render_to_response(
"ndf/explore_2017.html",
context_variable,
context_instance=RequestContext(request))
def get_thread_comments_count(request, group_id, thread_node_id):
return HttpResponse(
node_collection.find({
'member_of': reply_st._id,
'origin.thread_id': ObjectId(thread_node_id)
}).count())
# return HttpResponse(json.dumps(result_set))
def update_username(username_existing_expected_map={}):
user_tokens_map_seperator = "-"
for existing, expected in username_existing_expected_map.iteritems():
check_in_username = user_tokens_map_seperator + existing + user_tokens_map_seperator + GSTUDIO_INSTITUTE_ID
auth_cur = node_collection.find({
'_type': u'Author',
'name': {
'$regex': unicode(check_in_username),
'$options': 'i'
}
})
print "\nUpdating Author instances for: '%s' \n" % existing
for each_auth in auth_cur:
print "\nOLD: ", each_auth.name
each_auth.name = each_auth.name.replace(existing, expected)
each_auth.save()
print "NEW: ", each_auth.name
print "-------------------------------------------"
print "\nUpdating User instances for: '%s' \n" % existing
user_cur = User.objects.filter(
username__endswith=unicode(check_in_username))
for each_user in user_cur:
print "\nOLD: ", each_user.username
each_user.username = each_user.username.replace(existing, expected)
print "NEW: ", each_user.username
each_user.save()
print "\n=========================================== \n"
def handle(self, *args, **options):
gst_course_ev_gr = node_collection.one({'_type': 'GSystemType', 'name': 'CourseEventGroup'})
all_course_groups = node_collection.find({'_type': 'Group', 'member_of': {'$in': [gst_course_ev_gr._id]}})
for each_group_obj in all_course_groups:
print "\n\n Exporting CSV for: ", each_group_obj.name, "(", each_group_obj.altnames, ")\n"
export_group_analytics(each_group_obj)
def delete_user_artifacts(user_ids_list):
print "inside delete_user_artifacts"
try:
user_ids_list = map(int, user_ids_list)
print "\n unit_ids ", user_ids_list, UNIT_IDS
all_nodes = node_collection.find({
'_type': 'GSystem',
'created_by': {
'$in': user_ids_list
},
'group_set': {
'$in': UNIT_IDS
}
})
print "\nArtifacts: ", all_nodes.count()
if all_nodes.count():
for each_node in all_nodes:
print ".",
log_file.write("\n**********************************\n")
log_file.write(
"deleting the artifact node {0} created by {1}".format(
each_node._id, each_node.created_by))
delete_node(each_node._id, deletion_type=1)
else:
log_file.write("\n**********************************\n")
log_file.write("No artifacts found for {0}".format(UNIT_IDS))
except Exception as del_user_artifacts_err:
error_log = "\n !!! Error found while deleting user artifacts."
error_log += "\nError: " + str(del_user_artifacts_err)
log_file.write(str(error_log))
print error_log
def handle(self, *args, **options):
grp = node_collection.one({'_type': 'Group', '_id': ObjectId('5315b7497d9d331e53c12bda')})
# grp = node_collection.one({'_type': 'Group', 'name': 'home'})
lisp = []
themes_list = []
theme_item_list = []
if grp:
nodes = node_collection.find({'_type': 'GSystem', 'group_set': ObjectId(grp._id), 'member_of': {'$in': [theme_GST._id]} })
for each in nodes:
if each.collection_set:
for l in each.collection_set:
lisp.append(l)
nodes.rewind()
for e in nodes:
if e._id not in lisp:
themes_list.append(e._id)
nodes.rewind()
for theme_item in nodes:
if theme_item._id not in themes_list:
theme_item.member_of = []
theme_item.member_of.append(theme_item_GST._id)
theme_item.save()
else:
print "\n Mahagyan Group not exists ... "
def get_possible_batches(request, group_id):
'''
Returns:
* Batches of selected course
'''
group_name, group_id = get_group_name_id(group_id)
response_dict = {"success": False}
new_batch_node = None
if request.is_ajax() and request.method == "POST":
ac_id = request.POST.get("ac_id", '')
create_new_batch = request.POST.get("create_new_batch", '')
response_dict["success"] = True
batch_user_list_dict = []
list_of_members = []
if ac_id:
batch_cur = node_collection.find({'member_of': GST_BATCH._id,
'relation_set.has_course': ObjectId(ac_id)})
for each_batch in batch_cur:
each_batch_dict = {}
if each_batch.relation_set:
for rel in each_batch.relation_set:
list_of_members = []
if rel and 'has_batch_member' in rel:
list_of_members.append(rel['has_batch_member'])
list_of_members.append(str(each_batch._id))
each_batch_dict[each_batch.name] = list_of_members
batch_user_list_dict.append(each_batch_dict)
# batch_user_list_dict.append(str(each_batch._id))
# print "\n\nBatches----------", batch_user_list_dict
response_dict["old_batches"] = batch_user_list_dict
return HttpResponse(json.dumps(response_dict, cls=NodeJSONEncoder))
def partner_showcase(request, group_id):
group_name, group_id = get_group_name_id(group_id)
all_source = node_collection.find({'attribute_set.source': {'$exists': True, '$ne': ''} }).distinct('attribute_set.source')
partner_group = node_collection.one({'_type': 'GSystemType', 'name': 'PartnerGroup'})
source_partners = node_collection.find({'_type': 'Group', 'member_of': {'$in': [partner_group._id]}, 'name': {'$in': all_source} }).sort('name',1)
return render_to_response('ndf/partner_showcase.html',
{
'group_id': group_id, 'groupid': group_id,
'source_partners': source_partners
}, context_instance=RequestContext(request)
)
def videoDashboard(request, group_id, video_id):
# ins_objectid = ObjectId()
# if ins_objectid.is_valid(group_id) is False :
# group_ins = node_collection.find_one({'_type': "Group","name": group_id})
# auth = node_collection.one({'_type': 'Author', 'name': unicode(request.user.username) })
# if group_ins:
# group_id = str(group_ins._id)
# else :
# auth = node_collection.one({'_type': 'Author', 'name': unicode(request.user.username) })
# if auth :
# group_id = str(auth._id)
# else :
# pass
try:
group_id = ObjectId(group_id)
except:
group_name, group_id = get_group_name_id(group_id)
if video_id is None:
video_ins = node_collection.find_one({'_type':"GSystemType", "name":"Video"})
if video_ins:
video_id = str(video_ins._id)
vid_col = node_collection.find({'member_of': {'$all': [ObjectId(video_id)]},'_type':'File', 'group_set': {'$all': [group_id]}})
template = "ndf/videoDashboard.html"
already_uploaded=request.GET.getlist('var',"")
variable = RequestContext(request, {'videoCollection':vid_col, 'already_uploaded':already_uploaded, 'newgroup':group_id})
return render_to_response(template, variable)
def create_factory_schema_mapper(path):
# dump_list = [type_json]
schema_dump_path = os.path.join(path, 'factory_schema.json')
all_factory_types = node_collection.find({
'$or': [{
'_type': {
'$in': TYPES_LIST
}
}, {
'_type': u'Group',
'name': {
'$in': GSTUDIO_DEFAULT_GROUPS_LIST
}
}]
})
factory_json_list = []
for each_type in all_factory_types:
each_type_json = type_json.copy()
each_type_json['_type'] = each_type._type
each_type_json['name'] = each_type.name
each_type_json['source_id'] = each_type._id
factory_json_list.append(each_type_json)
with open(schema_dump_path, 'w+') as schema_file_out:
schema_file_out.write(json_util.dumps(factory_json_list))
def read_file(request, group_id):
all_fgs = node_collection.find({'_type': 'GSystem', 'member_of': gst_file._id})
return render_to_response('ndf/filehive_listing.html', {
'group_id': group_id, 'groupid': group_id,
'all_filehives': all_fgs
}, context_instance=RequestContext(request))
def partner_list(request, group_id):
group_obj = get_group_name_id(group_id, get_obj=True)
app_gst = node_collection.one({'_type': 'GSystemType', 'name': 'PartnerGroup'})
group_nodes = None
collection_set = []
# groups_category = None
if group_obj:
group_id = group_obj._id
group_name = group_obj.name
groups_category = group_obj.agency_type
# groups_category = "Partner" if groups_category == "Partner" else "Group"
group_obj = node_collection.one({'_id': ObjectId(group_id)})
# if group_obj:
# for each in group_obj.collection_set:
# node = node_collection.one({'_id': each})
# collection_set.append(node)
group_nodes = node_collection.find({'_id': {'$in':group_obj.post_node}}).sort("last_update",-1)
# print GSTUDIO_NROER_MENU_MAPPINGS.get(group_name, None)
# print GSTUDIO_NROER_MENU
return render_to_response("ndf/partner_list.html",
{'group_nodes': group_nodes,
# "groups_category": groups_category,
'group_obj':group_obj,
'groupid': group_id, 'group_id': group_id, "app_gst": partner_group_gst,
}, context_instance=RequestContext(request))
def handle(self, *args, **options):
'''
For all users having any of the following element in their username,
must have the agency-type set to Teacher for their respective Author objects
'''
print "\n 'agency-type=Teacher' setting Script Invoked."
teacher_element_set = [
'carbon', 'chlorine', 'copper', 'helium', 'iron', 'nitrogen',
'oxygen', 'silver', 'sodium', 'zinc'
]
ele_user_id_list = list(
User.objects.filter(
reduce(or_, [
Q(username__icontains=ele_name)
for ele_name in teacher_element_set
])).values_list('id', flat=True))
ele_auth_cur = node_collection.find({
'_type': 'Author',
'created_by': {
'$in': ele_user_id_list
},
'agency_type': {
'$ne': 'Teacher'
}
})
print "\n Total Authors not having Teacher agency-type: ", ele_auth_cur.count(
)
for each_auth in ele_auth_cur:
try:
each_auth.agency_type = 'Teacher'
except Exception, e:
each_auth['agency_type'] = 'Teacher'
each_auth.save()
def update_username(username_existing_expected_map={}):
user_tokens_map_seperator = "-"
# try:
# with open('../doc/release-scripts/user-tokens.json') as tokens:
# user_tokens_map = json.load(tokens)
# user_tokens_map_seperator = user_tokens_map['seperator']
# except Exception as e:
# print e
for existing, expected in username_existing_expected_map.iteritems():
check_in_username = user_tokens_map_seperator + existing + user_tokens_map_seperator + GSTUDIO_INSTITUTE_ID
auth_cur = node_collection.find({'_type': u'Author', 'name': {'$regex': unicode(check_in_username), '$options': 'i'} })
print "\nUpdating Author instances for: '%s' \n"%existing
for each_auth in auth_cur:
print "\nOLD: ", each_auth.name
each_auth.name = each_auth.name.replace(existing, expected)
each_auth.save()
print "NEW: ", each_auth.name
print "-------------------------------------------"
print "\nUpdating User instances for: '%s' \n"%existing
user_cur = User.objects.filter(username__endswith=unicode(check_in_username))
for each_user in user_cur:
print "\nOLD: ", each_user.username
each_user.username = each_user.username.replace(existing, expected)
print "NEW: ", each_user.username
each_user.save()
print "\n=========================================== \n"
def read_file(request, group_id):
all_fgs = node_collection.find({'_type': 'GSystem', 'member_of': gst_file._id})
return render_to_response('ndf/filehive_listing.html', {
'group_id': group_id, 'groupid': group_id,
'all_filehives': all_fgs
}, context_instance=RequestContext(request))
def adminDashboard(request):
'''
methods for class view
'''
objects_details = []
nodes = node_collection.find({'_type':"GSystem"})
group_obj= node_collection.find({'$and':[{"_type":u'Group'},{"name":u'home'}]})
groupid = ""
if group_obj:
groupid = str(group_obj[0]._id)
for each in nodes:
objects_details.append({"Id":each._id,"Title":each.name,"Type":each.type_of,"Author":User.objects.get(id=each.created_by).username,"Group":",".join(each.group_set)})
template = "ndf/adminDashboard.html"
variable = RequestContext(request, {'class_name':"GSystem","nodes":objects_details,"groupid":groupid})
return render_to_response(template, variable)
def list_themes(request, group_id):
try:
group_id = ObjectId(group_id)
except:
group_name, group_id = get_group_name_id(group_id)
title = theme_GST.name
nodes = node_collection.find(
{
'member_of': {
'$all': [theme_GST._id]
},
'group_set': {
'$all': [ObjectId(group_id)]
}
}, {
'_id': 1,
'name': 1,
'created_by': 1,
'created_at': 1
})
return render_to_response("ndf/list_themes.html", {
'groupid': group_id,
'group_id': group_id,
'nodes': nodes,
'theme_GST': theme_GST
},
context_instance=RequestContext(request))
def list_buddy(request, group_id='home'):
'''
fetching all buddies.
'''
buddies_authid_name_dict= request.session.get('buddies_authid_name_dict', {})
buddies_authid_list = request.session.get('buddies_authid_list', [])
# to load all user's at page load time (performance penalty, kept for ref):
#
# filter_authors = [ObjectId(auth_oid)for auth_oid in buddies_authid_list]
# all_inst_users = User.objects.filter(username__iendswith=GSTUDIO_INSTITUTE_ID)
# all_inst_authors = node_collection.find({
# '_type': u'Author',
# # '_id': {'$nin': filter_authors},
# 'name': {
# '$regex': GSTUDIO_INSTITUTE_ID + '$'
# },
# 'created_by': {'$ne': request.user.id}
# })
selected_buddies_obj_list = node_collection.find({
'_id': {'$in': [ObjectId(b) for b in buddies_authid_list]}
})
template = 'ndf/buddy_list.html'
variable = RequestContext(request, {
"group_id": group_id, 'all_inst_users': selected_buddies_obj_list,
'buddies_id_name_dict': buddies_authid_name_dict,
'buddies_id_list': buddies_authid_list
})
return render_to_response(template, variable)
def explore_groups(request,page_no=1):
title = 'workspaces'
gstaff_access = check_is_gstaff(group_id,request.user)
query = {'_type': 'Group', 'status': u'PUBLISHED',
'$or': [
{'access_policy': u"PUBLIC"},
{'$and': [
{'access_policy': u"PRIVATE"},
{'created_by': request.user.id}
]
}
],
'member_of': {'$in': [gst_group._id],
'$nin': [gst_course._id, gst_basecoursegroup._id, ce_gst._id, gst_course._id, gst_base_unit_id]},
}
if gstaff_access:
query.update({'group_type': {'$in': [u'PUBLIC', u'PRIVATE']}})
else:
query.update({'name': {'$nin': GSTUDIO_DEFAULT_GROUPS_LIST},
'group_type': u'PUBLIC'})
group_cur = node_collection.find(query).sort('last_update', -1)
grp_page_cur = paginator.Paginator(group_cur, page_no, GSTUDIO_NO_OF_OBJS_PP)
context_variable = {'title': title, 'groups_cur': group_cur, 'card': 'ndf/card_group.html',
'group_id': group_id, 'groupid': group_id,'grp_page_cur': grp_page_cur}
return render_to_response(
"ndf/explore_2017.html",
context_variable,
context_instance=RequestContext(request))
def create_users_dump(path, user_id_list):
dump_list = [user_json]
schema_dump_path = os.path.join(path, 'users_dump.json')
auth_cur = node_collection.find({'_type': 'Author',
'created_by': {'$in': user_id_list}},
{'name':1, 'email': 1, 'created_by': 1})
user_json_list = []
for each_auth in auth_cur:
try:
user_obj = User.objects.get(pk=each_auth.created_by)
except Exception as no_user:
pass
if user_obj:
each_user_json = user_json.copy()
each_user_json['user_id'] = user_obj.id
each_user_json['user_name'] = user_obj.username
# for email
user_email_val = user_obj.email
if user_email_val == '':
user_email_val = user_obj.username
each_user_json['user_email'] = user_email_val
each_user_json['user_author_id'] = str(each_auth._id)
user_json_list.append(each_user_json)
with open(schema_dump_path, 'w+') as schema_file_out:
schema_file_out.write(json.dumps(user_json_list))
def update_default_st(field):
default_st_cur = node_collection.find({'_type': 'GSystemType',
'name': {'$in': GSTUDIO_DEFAULT_SYSTEM_TYPES_LIST}})
default_st_ids = [st._id for st in default_st_cur]
if default_st_ids:
field.extend(default_st_ids)
return field
def discussion_delete_reply(request, group_id, node_id):
try:
group_id = ObjectId(group_id)
except:
group_name, group_id = get_group_name_id(group_id)
nodes_to_delete = json.loads(request.POST.get("nodes_to_delete", "[]"))
deleted_replies = []
node_obj = node_collection.one({'_id': ObjectId(node_id)})
# print "\n\nnode_obj.name", node_obj.name, node_obj.member_of_names_list,node_obj._id
for each_reply in nodes_to_delete:
temp_reply = node_collection.one({"_id": ObjectId(each_reply)})
if temp_reply:
deleted_replies.append(temp_reply._id.__str__())
temp_reply.delete()
replies_cur = node_collection.find({'origin.thread_id': ObjectId(node_id)})
# print "\n replies_cur",replies_cur.count()
if (not replies_cur.count()) and (int(request.user.id) in node_obj.author_set):
author_set_ids = node_obj.author_set
author_set_ids.remove(int(request.user.id))
node_obj.author_set = author_set_ids
node_obj.save()
return HttpResponse(json.dumps(deleted_replies))
def discussion_delete_reply(request, group_id, node_id):
try:
group_id = ObjectId(group_id)
except:
group_name, group_id = get_group_name_id(group_id)
nodes_to_delete = json.loads(request.POST.get("nodes_to_delete", "[]"))
deleted_replies = []
node_obj = node_collection.one({'_id': ObjectId(node_id)})
# print "\n\nnode_obj.name", node_obj.name, node_obj.member_of_names_list,node_obj._id
for each_reply in nodes_to_delete:
temp_reply = node_collection.one({"_id": ObjectId(each_reply)})
if temp_reply:
deleted_replies.append(temp_reply._id.__str__())
temp_reply.delete()
replies_cur = node_collection.find({'origin.thread_id': ObjectId(node_id)})
# print "\n replies_cur",replies_cur.count()
if (not replies_cur.count()) and (int(request.user.id) in node_obj.author_set):
author_set_ids = node_obj.author_set
author_set_ids.remove(int(request.user.id))
node_obj.author_set = author_set_ids
node_obj.save()
return HttpResponse(json.dumps(deleted_replies))
def videoDashboard(request, group_id, video_id):
# ins_objectid = ObjectId()
# if ins_objectid.is_valid(group_id) is False :
# group_ins = node_collection.find_one({'_type': "Group","name": group_id})
# auth = node_collection.one({'_type': 'Author', 'name': unicode(request.user.username) })
# if group_ins:
# group_id = str(group_ins._id)
# else :
# auth = node_collection.one({'_type': 'Author', 'name': unicode(request.user.username) })
# if auth :
# group_id = str(auth._id)
# else :
# pass
try:
group_id = ObjectId(group_id)
except:
group_name, group_id = get_group_name_id(group_id)
if video_id is None:
video_ins = node_collection.find_one({'_type':"GSystemType", "name":"Video"})
if video_ins:
video_id = str(video_ins._id)
vid_col = node_collection.find({'member_of': {'$all': [ObjectId(video_id)]},'_type':'File', 'group_set': {'$all': [group_id]}})
template = "ndf/videoDashboard.html"
already_uploaded=request.GET.getlist('var',"")
variable = RequestContext(request, {'videoCollection':vid_col, 'already_uploaded':already_uploaded, 'newgroup':group_id})
return render_to_response(template, variable)
def query_doc(request, doc_id_or_name=None, option=None):
if ObjectId.is_valid(doc_id_or_name):
doc_id_or_name = ObjectId(doc_id_or_name)
query_res = node_collection.find(
{'$or': [{
'_id': doc_id_or_name
}, {
'name': unicode(doc_id_or_name)
}]})
result = []
for each_doc in query_res:
if option in ['nbh', 'NBH', 'get_neighbourhood']:
each_doc.get_neighbourhood(each_doc.member_of)
result.append(json.dumps(each_doc, cls=NodeJSONEncoder,
sort_keys=True))
return render_to_response('ndf/dev_query_doc.html', {
'result': result,
'query': doc_id_or_name,
'count': query_res.count()
},
context_instance=RequestContext(request))
def list_units(request, group_id):
'''
listing of units
'''
parent_group_name, parent_group_id = Group.get_group_name_id(group_id)
all_base_units = node_collection.find({
'_type':
'Group',
'group_set': {
'$in': [parent_group_id]
},
'member_of': {
'$in': [gst_base_unit_id]
},
'$or': [{
'status': u'PUBLIC'
}, {
'$and': [{
'access_policy': u"PRIVATE"
}, {
'created_by': request.user.id
}]
}]
}).sort('last_update', -1)
template = "ndf/explore_2017.html"
req_context = RequestContext(request, {
'group_id': parent_group_id,
'all_unit_objs': all_base_units
})
return render_to_response(template, req_context)
def get_possible_batches(request, group_id):
'''
Returns:
* Batches of selected course
'''
group_name, group_id = get_group_name_id(group_id)
response_dict = {"success": False}
new_batch_node = None
if request.is_ajax() and request.method == "POST":
ac_id = request.POST.get("ac_id", '')
create_new_batch = request.POST.get("create_new_batch", '')
response_dict["success"] = True
batch_user_list_dict = []
list_of_members = []
if ac_id:
batch_cur = node_collection.find({
'member_of':
GST_BATCH._id,
'relation_set.has_course':
ObjectId(ac_id)
})
for each_batch in batch_cur:
each_batch_dict = {}
if each_batch.relation_set:
for rel in each_batch.relation_set:
list_of_members = []
if rel and 'has_batch_member' in rel:
list_of_members.append(rel['has_batch_member'])
list_of_members.append(str(each_batch._id))
each_batch_dict[each_batch.name] = list_of_members
batch_user_list_dict.append(each_batch_dict)
# batch_user_list_dict.append(str(each_batch._id))
# print "\n\nBatches----------", batch_user_list_dict
response_dict["old_batches"] = batch_user_list_dict
return HttpResponse(json.dumps(response_dict, cls=NodeJSONEncoder))
def update_username(username_existing_expected_map={}):
user_tokens_map_seperator = "-"
for existing, expected in username_existing_expected_map.iteritems():
check_in_username = user_tokens_map_seperator + existing + user_tokens_map_seperator + GSTUDIO_INSTITUTE_ID
auth_cur = node_collection.find({'_type': u'Author', 'name': {'$regex': unicode(check_in_username), '$options': 'i'} })
print "\nUpdating Author instances for: '%s' \n" % existing
for each_auth in auth_cur:
print "\nOLD: ", each_auth.name
each_auth.name = each_auth.name.replace(existing, expected)
each_auth.save()
print "NEW: ", each_auth.name
print "-------------------------------------------"
print "\nUpdating User instances for: '%s' \n" % existing
user_cur = User.objects.filter(username__endswith=unicode(check_in_username))
for each_user in user_cur:
print "\nOLD: ", each_user.username
each_user.username = each_user.username.replace(existing, expected)
print "NEW: ", each_user.username
each_user.save()
print "\n=========================================== \n"
def delete_thread(request,group_id,forum_id,node_id):
""" Changing status of thread to HIDDEN
"""
ins_objectid = ObjectId()
if ins_objectid.is_valid(node_id) :
thread=node_collection.one({'_id':ObjectId(node_id)})
else:
return
forum = node_collection.one({'_id': ObjectId(forum_id)})
if ins_objectid.is_valid(group_id) is False :
group_ins = node_collection.find_one({'_type': "Group","name": group_id})
auth = node_collection.one({'_type': 'Author', 'name': unicode(request.user.username) })
if group_ins:
group_id = str(group_ins._id)
else :
auth = node_collection.one({'_type': 'Author', 'name': unicode(request.user.username) })
if auth :
group_id = str(auth._id)
else :
pass
op = node_collection.collection.update({'_id': ObjectId(node_id)}, {'$set': {'status': u"HIDDEN"}})
node=node_collection.one({'_id':ObjectId(node_id)})
forum_threads = []
exstng_reply = node_collection.find({'$and':[{'_type':'GSystem'},{'prior_node':ObjectId(forum._id)}],'status':{'$nin':['HIDDEN']}})
exstng_reply.sort('created_at')
forum_node=node_collection.one({'_id':ObjectId(forum_id)})
for each in exstng_reply:
forum_threads.append(each.name)
#send notifications to all group members
colg=node_collection.one({'_id':ObjectId(group_id)})
for each in colg.author_set:
if each != colg.created_by:
bx=get_userobject(each)
if bx:
activity=request.user.username+" -deleted thread "
prefix=" in the forum "+forum_node.name
link="http://"+sitename+"/"+str(colg._id)+"/forum/"+str(forum_node._id)
msg=activity+"-"+node.name+prefix+"- in the group '"+colg.name+"' created by you."+"'\n"+"Please visit "+link+" to see the forum."
# no_check=forum_notification_status(group_id,auth._id)
# if no_check:
ret = set_notif_val(request,group_id,msg,activity,bx)
activity=request.user.username+" -deleted thread "
prefix=" in the forum "+forum_node.name
bx=get_userobject(colg.created_by)
if bx:
link="http://"+sitename+"/"+str(colg._id)+"/forum/"+str(forum_node._id)
msg=activity+"-"+node.name+prefix+"- in the group '"+colg.name+"' created by you."+"'\n"+"Please visit "+link+" to see the forum."
# no_check=forum_notification_status(group_id,auth._id)
# if no_check:
ret = set_notif_val(request,group_id,msg,activity,bx)
#send notification code ends here
variables = RequestContext(request,{
'forum':forum,
'groupid':group_id,'group_id':group_id,
'forum_created_by':User.objects.get(id=forum.created_by).username
})
return render_to_response("ndf/forumdetails.html",variables)
def explore_groups(request,page_no=1):
from gnowsys_ndf.settings import GSTUDIO_NO_OF_OBJS_PP
title = 'groups'
gstaff_access = check_is_gstaff(group_id,request.user)
if gstaff_access:
group_cur = node_collection.find({'_type': 'Group', 'member_of': gst_group._id}).sort('last_update', -1)
else:
group_cur = node_collection.find({'_type': 'Group', 'member_of': gst_group._id,'name':{'$nin':GSTUDIO_DEFAULT_GROUPS }}).sort('last_update', -1)
ce_page_cur = paginator.Paginator(group_cur, page_no, GSTUDIO_NO_OF_OBJS_PP)
context_variable = {'title': title, 'doc_cur': group_cur, 'card': 'ndf/simple_card.html',
'group_id': group_id, 'groupid': group_id,'ce_page_cur':ce_page_cur}
return render_to_response(
"ndf/explore.html",
context_variable,
context_instance=RequestContext(request))
def group_summary(request,group_id):
'''
Renders the summary of all the activities done by the members of the Group
'''
group_name, group_id = get_group_name_id(group_id)
query("group",{ "group_id" : group_id })
data = {}
pipe = [{'$match' : { 'group_id' : str(group_id)}}, {'$group': {'_id': '$user.name', 'num_of_activities': {'$sum': 1}}}]
sorted_list = analytics_collection.aggregate(pipeline=pipe)
sorted_list_acc_activities = sorted(sorted_list['result'],key = lambda k:k[u'num_of_activities'],reverse=True)
data['active_users'] = []
i=0
for doc in sorted_list_acc_activities :
data['active_users'].append({ "name" : (doc[u'_id']) , "activities" : doc[u'num_of_activities'] } )
i+=1
if i==3:
break
Course = node_collection.find_one({"_type":"GSystemType","name":"Course"})
CourseEventGroup = node_collection.find_one({"_type":"GSystemType","name":"CourseEventGroup"})
TwistGst = node_collection.find_one({"_type":"GSystemType","name":"Twist"})
data['forums'] = db['Nodes'].find({"url":"forum", "group_set":ObjectId(group_id)}).count()
data['threads'] = db['Nodes'].find({"member_of":ObjectId(TwistGst._id),"group_set":ObjectId(group_id)}).count()
regx=re.compile("^Reply of:.*")
data['replies'] = db['Nodes'].find({"name": regx,"group_set":ObjectId(group_id)}).count()
data['files'] = db['Nodes'].find({"url":"file", "group_set":ObjectId(group_id)}).count()
data['pages'] = db['Nodes'].find({"url":"page", "group_set":ObjectId(group_id)}).count()
data['total_activities'] = analytics_collection.find({ "group_id" : unicode(group_id)}).count()
data['Courses'] = node_collection.find({"type_of":Course._id}).count()
data['announce_courses'] = node_collection.find({"prior_node":ObjectId(group_id),"member_of":CourseEventGroup._id}).count()
data['recent'] = {}
specific_date = datetime.datetime.now() - datetime.timedelta(days=7)
data['recent']['forums'] = analytics_collection.find({"action.key": {"$in" : ['create', 'edit']}, "group_id": str(group_id), "obj.forum" : { '$exists' : 'true'},"timestamp":{'$gte':specific_date}}).count()
data['recent']['threads'] = analytics_collection.find({"action.key": {"$in" : ['create', 'edit']}, "group_id": str(group_id), "obj.thread" : { '$exists' : 'true'},"timestamp":{'$gte':specific_date}}).count()
data['recent']['replies'] = analytics_collection.find({"action.key": {"$in" : ['add']}, "group_id": str(group_id), "obj.reply" : { '$exists' : 'true'},"timestamp":{'$gte':specific_date}}).count()
data['recent']['files'] = analytics_collection.find({"action.key": {"$in" : ['create', 'edit']}, "group_id": str(group_id), "obj.file" : { '$exists' : 'true'},"timestamp":{'$gte':specific_date}}).count()
data['recent']['pages'] = analytics_collection.find({"action.key": {"$in" : ['create', 'edit']}, "group_id": str(group_id), "obj.page" : { '$exists' : 'true'},"timestamp":{'$gte':specific_date}}).count()
data['recent']['create_edit_course'] = analytics_collection.find({"action.key": {"$in" : ['create', 'edit']}, "group_id": str(group_id), "obj.course" : { '$exists' : 'true'},"timestamp":{'$gte':specific_date}}).count()
return render (request ,"ndf/analytics_group_summary.html",
{ "data" : data, "group_id" : group_id, "groupid" : group_id})
def api_get_field_values(request, field_name):
'''
GET /api/v2/tags
'''
field_name = api_name_model_name_dict.get(field_name, field_name)
gsystem_structure_dict = GSystem.structure
gsystem_keys = gsystem_structure_dict.keys()
if field_name in gsystem_keys:
json_result = '[]'
oid_fields = [ k for k, v in gsystem_structure_dict.iteritems() if v in [bson.objectid.ObjectId, [bson.objectid.ObjectId]] ]
user_fields = ['created_by', 'modified_by', 'contributors']
# MONGO
if field_name in oid_fields:
result_list = node_collection.find({ '_id': {'$in': node_collection.find({}).distinct(field_name) } }).distinct('name')
# USER
elif field_name in user_fields:
# mapping user id to username.
result_list = node_collection.find({'_type': 'Author', 'created_by': {'$in': node_collection.find({}).distinct(field_name) } }).distinct('name')
# OTHER
else:
# overriden from settings
GSTUDIO_WORKING_GAPPS = [u'Page', u'File']
gstudio_working_gapps_mof_list = node_collection.find({'_type': 'GSystemType', 'name': {'$in': GSTUDIO_WORKING_GAPPS} }).distinct('_id')
result_list = node_collection.find({'_type': 'GSystem', 'status': u'PUBLISHED', 'access_policy': 'PUBLIC', 'member_of': {'$in': gstudio_working_gapps_mof_list}}).distinct(field_name)
return HttpResponse(json.dumps(result_list, ensure_ascii=False, cls=NodeJSONEncoder, sort_keys=True, indent=4).encode('utf16'), content_type='application/json')
elif field_name in node_collection.find({'_type': 'AttributeType'}).distinct('name'):
return HttpResponse( json.dumps(node_collection.find().distinct('attribute_set.' + field_name), sort_keys=True, indent=4), content_type='application/json')
return HttpResponse(["Invalid Field"], content_type='application/json')
