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 listUser():
email = session['email']
dataList = 0
counter = 0
adminUser = False
if ('all' in session['read_access']):
dataList = FCCDB.UserModel.find()
counter = FCCDB.UserModel.find().count()
adminUser = True
else:
return error("YOU ARE NOT AUTHORIZED FOR THIS PAGE")
dataListSorted = dataList.sort('registered', pymongo.ASCENDING)
if (((int(request.args['page']) - 1) * 10) > int(counter)):
return page_not_found('500')
pageSource = paginator.Paginator(dataListSorted, request.args['page'], 10)
return render_template('listUser.html',
dataList=fixCursor(dataListSorted),
email=email,
pgSource=pageSource,
adminUser=adminUser)
def list():
email = session['email']
dataList = 0
counter = 0
adminUser = False
if ('all' in session['read_access']):
dataList = FCCDB.PsapModel.find()
counter = FCCDB.PsapModel.find().count()
adminUser = True
else:
dataList = FCCDB.PsapModel.find(
{'PSAP ID': {
'$in': [int(i) for i in session['read_access']]
}})
counter = FCCDB.PsapModel.find({
'PSAP ID': {
'$in': [int(i) for i in session['read_access']]
}
}).count()
dataListSorted = dataList.sort('PSAP ID', pymongo.ASCENDING)
if (((int(request.args['page']) - 1) * 10) > int(counter)):
return page_not_found('500')
pageSource = paginator.Paginator(dataListSorted, request.args['page'], 10)
return render_template('list.html',
dataList=fixCursor(dataListSorted),
email=email,
pgSource=pageSource,
adminUser=adminUser)
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 my_groups(request, group_id, page_no=1):
from gnowsys_ndf.settings import GSTUDIO_NO_OF_OBJS_PP
# if request.user == 'AnonymousUser':
# raise 404
try:
auth = get_group_name_id(group_id, get_obj=True)
except:
user_id = eval(group_id)
auth = node_collection.one({'_type': "Author", 'created_by': user_id})
usrid = auth.created_by
current_user = usrid
if current_user:
exclued_from_public = ""
if int(current_user) == int(usrid):
Access_policy = ["PUBLIC", "PRIVATE"]
if int(current_user) != int(usrid):
Access_policy = ["PUBLIC"]
else:
Access_policy = ["PUBLIC"]
exclued_from_public = ObjectId(task_gst._id)
group_cur = node_collection.find({
'_type':
"Group",
'name': {
'$nin': ["home", auth.name]
},
"access_policy": {
"$in": Access_policy
},
'status':
u'PUBLISHED',
'$or': [{
'group_admin': int(usrid)
}, {
'author_set': int(usrid)
}]
}).sort('last_update', -1)
group_page_cur = paginator.Paginator(group_cur, page_no,
GSTUDIO_NO_OF_OBJS_PP)
auth_id = auth._id
title = 'My Groups'
return render_to_response('ndf/my-groups.html', {
'group_id': group_id,
'groupid': group_id,
'node': auth,
'title': title,
'group_cur': group_cur,
'group_page_cur': group_page_cur
},
context_instance=RequestContext(request))
def modifyUser():
dataList = 0
counter = 0
adminUser = False
if ('all' in session['read_access']):
dataList = FCCDB.UserModel.find()
counter = FCCDB.UserModel.find().count()
adminUser = True
else:
return error("YOU ARE NOT AUTHORIZED FOR THIS PAGE")
f = 0
v1 = 0
v2 = 0
userHolder = 0
if ('email' in request.args):
modifyNode = FCCDB.UserModel.find_one(
{'email': unicode(request.args['email'])})
userHolder = request.args['email']
if 'read_access' in request.args:
v1 = modifyNode['read_access']
v2 = unicode(request.args['read_access'])
modifyNode['read_access'] = unicode(request.args['read_access'])
modifyNode.save()
f = 'PSAP Name'
if 'write_access' in request.args:
v1 = modifyNode['write_access']
v2 = unicode(request.args['write_access'])
modifyNode['write_access'] = unicode(request.args['write_access'])
f = 'Write Access'
modifyNode.save()
dataList = FCCDB.UserModel.find()
counter = FCCDB.UserModel.find().count()
dataListSorted = dataList.sort('PSAP ID', pymongo.ASCENDING)
if (((int(request.args['page']) - 1) * 10) > int(counter)):
return page_not_found('500')
pageSource = paginator.Paginator(dataListSorted, request.args['page'], 10)
return render_template('modifyUser.html',
dataList=fixCursor(dataListSorted),
email=session['email'],
pgSource=pageSource,
cItem=f,
v1=v1,
v2=v2,
psapidNum=userHolder,
adminUser=adminUser)
def subscribe():
email = session['email']
temp = 0
subsNode = 0
psapinfo = 0
if ('psapid' in request.args):
subsNode = FCCDB.UserModel.find_one({'email': email})
temp = subsNode
subsNode.addSub('11')
subsNode['subscription'].append(unicode('11'))
subsNode.save()
psapinfo = unicode(request.args['psapid'])
dataList = 0
counter = 0
adminUser = False
if ('all' in session['read_access']):
dataList = FCCDB.PsapModel.find()
counter = FCCDB.PsapModel.find().count()
adminUser = True
else:
dataList = FCCDB.PsapModel.find(
{'PSAP ID': {
'$in': [int(i) for i in session['read_access']]
}})
counter = FCCDB.PsapModel.find({
'PSAP ID': {
'$in': [int(i) for i in session['read_access']]
}
}).count()
dataListSorted = dataList.sort('PSAP ID', pymongo.ASCENDING)
if (((int(request.args['page']) - 1) * 10) > int(counter)):
return page_not_found('500')
pageSource = paginator.Paginator(dataListSorted, request.args['page'], 10)
return render_template('subscribe.html',
dataList=fixCursor(dataListSorted),
email=email,
pgSource=pageSource,
subscribed=temp,
subscription=session['subscription'],
subscribedNode=psapinfo,
adminUser=adminUser)
def my_performance(request, group_id, page_no=1):
from gnowsys_ndf.settings import GSTUDIO_NO_OF_OBJS_PP
if str(request.user) == 'AnonymousUser':
raise Http404("You don't have an authority for this page!")
try:
auth_obj = get_group_name_id(group_id, get_obj=True)
user_id = auth_obj.created_by
except:
user_id = eval(group_id)
auth_obj = node_collection.one({
'_type': "Author",
'created_by': user_id
})
auth_id = auth_obj._id
title = 'my performance'
# my_modules_cur.rewind()
my_units = node_collection.find({
'member_of': {
'$in': [ce_gst._id, announced_unit_gst._id, gst_group._id]
},
'name': {
'$nin': GSTUDIO_DEFAULT_GROUPS_LIST
},
'author_set': request.user.id
}).sort('last_update', -1)
group_page_cur = paginator.Paginator(my_units, page_no,
GSTUDIO_NO_OF_OBJS_PP)
return render_to_response(
'ndf/lms_dashboard.html',
{
'group_id': auth_id,
'groupid': auth_id,
'node': auth_obj,
'title': title,
# 'my_course_objs': my_course_objs,
'units_cur': my_units,
'my_perf_page_cur': group_page_cur
# 'modules_cur': my_modules_cur
},
context_instance=RequestContext(request))
def explore_basecourses(request,page_no=1):
from gnowsys_ndf.settings import GSTUDIO_NO_OF_OBJS_PP
gstaff_access = check_is_gstaff(group_id,request.user)
if not gstaff_access:
return HttpResponseRedirect(reverse('explore_courses'))
title = 'base courses'
course_cur = node_collection.find({'member_of': gst_course._id}).sort('last_update', -1)
ce_page_cur = paginator.Paginator(course_cur, page_no, GSTUDIO_NO_OF_OBJS_PP)
context_variable = {'title': title, 'doc_cur': course_cur, 'card': 'ndf/event_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 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 deleteUser():
dataList = 0
counter = 0
adminUser = False
if ('all' in session['read_access']):
dataList = FCCDB.UserModel.find()
counter = FCCDB.UserModel.find().count()
adminUser = True
else:
return error("YOU ARE NOT AUTHORIZED FOR THIS PAGE")
email = session['email']
temp = 0
if ('email' in request.args):
deleteNode = FCCDB.UserModel.find(
{'email': unicode(request.args['email'])})
temp = deleteNode[0]
deleteNode[0].delete()
else:
dataList = FCCDB.UserModel.find()
counter = FCCDB.UserModel.find().count()
dataListSorted = dataList.sort('PSAP ID', pymongo.ASCENDING)
if (((int(request.args['page']) - 1) * 10) > int(counter)):
return page_not_found('500')
pageSource = paginator.Paginator(dataListSorted, request.args['page'], 10)
return render_template('deleteUser.html',
dataList=fixCursor(dataListSorted),
email=email,
pgSource=pageSource,
deleted=temp,
adminUser=adminUser)
def explore_courses(request,page_no=1):
from gnowsys_ndf.settings import GSTUDIO_NO_OF_OBJS_PP
title = 'courses'
ce_cur = node_collection.find({'member_of': ce_gst._id,
'$or': [
{'created_by': request.user.id},
{'group_admin': request.user.id},
{'author_set': request.user.id},
{'group_type': 'PUBLIC'}
]}).sort('last_update', -1)
ce_page_cur = paginator.Paginator(ce_cur, page_no, GSTUDIO_NO_OF_OBJS_PP)
context_variable = {
'title': title, 'doc_cur': ce_cur,
'group_id': group_id, 'groupid': group_id,
'card': 'ndf/event_card.html', 'ce_page_cur':ce_page_cur
}
return render_to_response(
"ndf/explore.html",
context_variable,
context_instance=RequestContext(request))
def data_review(request, group_id, page_no=1, **kwargs):
'''
To get all the information related to every resource object in the group.
To get processed context_variables into another variable,
pass <get_paged_resources=True> as last arg.
e.g:
context_variables = data_review(request, group_id, page_no, get_paged_resources=True)
'''
try:
group_id = ObjectId(group_id)
except:
group_name, group_id = get_group_name_id(group_id)
files_obj = node_collection.find({
'member_of': {
'$in': [
ObjectId(file_id._id),
ObjectId(page_id._id),
ObjectId(theme_gst_id._id),
ObjectId(group_gst_id._id)
]
},
# '_type': 'File', 'fs_file_ids': {'$ne': []},
'group_set': {
'$in': [ObjectId(group_id)]
},
'$or': [{
'access_policy': u"PUBLIC"
}, {
'$and': [{
'access_policy': u"PRIVATE"
}, {
'created_by': request.user.id
}]
}]
# {'member_of': {'$all': [pandora_video_st._id]}}
}).sort("created_at", -1)
# implementing pagination: paginator.Paginator(cursor_obj, <int: page no>, <int: no of obj in each page>)
# (ref: https://github.com/namlook/mongokit/blob/master/mongokit/paginator.py)
paged_resources = paginator.Paginator(files_obj, page_no, 10)
# list to hold resources instances with it's attributes and relations
files_list = []
for each_resource in paged_resources.items:
# each_resource, ver = get_page(request, each_resource)
each_resource.get_neighbourhood(each_resource.member_of)
files_list.append(node_collection.collection.GSystem(each_resource))
# print "==============", each_resource.name, " : ", each_resource.group_set
# print "\n\n\n========", each_resource.keys()
# for each, val in each_resource.iteritems():
# print each, "--", val,"\n"
# print "files_obj.count: ", files_obj.count()
files_obj.close()
context_variables = {
"group_id": group_id,
"groupid": group_id,
"files": files_list,
"page_info": paged_resources,
"urlname": "data_review_page",
"second_arg": "",
"static_educationalsubject": GSTUDIO_RESOURCES_EDUCATIONAL_SUBJECT,
# "static_language": EXTRA_LANG_INFO,
"static_language": GSTUDIO_RESOURCES_LANGUAGES,
"static_educationaluse": GSTUDIO_RESOURCES_EDUCATIONAL_USE,
"static_interactivitytype": GSTUDIO_RESOURCES_INTERACTIVITY_TYPE,
"static_educationalalignment": GSTUDIO_RESOURCES_EDUCATIONAL_ALIGNMENT,
"static_educationallevel": GSTUDIO_RESOURCES_EDUCATIONAL_LEVEL,
"static_curricular": GSTUDIO_RESOURCES_CURRICULAR,
"static_audience": GSTUDIO_RESOURCES_AUDIENCE,
"static_status": list(STATUS_CHOICES),
"static_textcomplexity": GSTUDIO_RESOURCES_TEXT_COMPLEXITY
}
if kwargs.get('get_paged_resources', False):
return context_variables
template_name = "ndf/data_review.html"
return render_to_response(template_name,
context_variables,
context_instance=RequestContext(request))
def get_dr_search_result_dict(request, group_id, search_text=None, page_no=1):
try:
group_id = ObjectId(group_id)
except:
group_name, group_id = get_group_name_id(group_id)
# check if request is from form or from next page
if request.GET.has_key("search_text"):
search_text = request.GET.get("search_text", "")
else:
search_text = search_text.replace("+", " ")
get_req = request.GET.copy()
# adding values to GET req
get_req.update({"search_text": search_text})
# overwriting request.GET with newly created QueryDict instance get_req
request.GET = get_req
search_reply = json.loads(
results_search(request, group_id, return_only_dict=True))
exact_search_res = search_reply["exact"]["name"]
result_ids_list = [
ObjectId(each_dict["_id"]) for each_dict in exact_search_res
]
result_cur = node_collection.find({
"_id": {
"$in": result_ids_list
},
'member_of': {
'$in': [ObjectId(file_id._id),
ObjectId(page_id._id)]
}
})
paged_resources = paginator.Paginator(result_cur, page_no, 10)
# list to hold resources instances with it's attributes and relations
files_list = []
for each_resource in paged_resources.items:
each_resource, ver = get_page(request, each_resource)
each_resource.get_neighbourhood(each_resource.member_of)
files_list.append(node_collection.collection.GSystem(each_resource))
return render_to_response(
"ndf/data_review.html",
{
"group_id": group_id,
"groupid": group_id,
"files": files_list,
"page_info": paged_resources,
"urlname": "data_review_search_page",
"second_arg": search_text,
"search_text": search_text,
"static_educationalsubject": GSTUDIO_RESOURCES_EDUCATIONAL_SUBJECT,
# "static_language": EXTRA_LANG_INFO,
"static_language": GSTUDIO_RESOURCES_LANGUAGES,
"static_educationaluse": GSTUDIO_RESOURCES_EDUCATIONAL_USE,
"static_interactivitytype": GSTUDIO_RESOURCES_INTERACTIVITY_TYPE,
"static_educationalalignment":
GSTUDIO_RESOURCES_EDUCATIONAL_ALIGNMENT,
"static_educationallevel": GSTUDIO_RESOURCES_EDUCATIONAL_LEVEL,
"static_curricular": GSTUDIO_RESOURCES_CURRICULAR,
"static_audience": GSTUDIO_RESOURCES_AUDIENCE,
"static_status": list(STATUS_CHOICES),
"static_textcomplexity": GSTUDIO_RESOURCES_TEXT_COMPLEXITY
},
context_instance=RequestContext(request))
def imageDashboard(request, group_id, image_id=None, page_no=1):
from gnowsys_ndf.settings import GSTUDIO_NO_OF_OBJS_PP
'''
fetching image acording to group name
'''
# 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 image_id is None:
image_ins = node_collection.find_one({
'_type': "GSystemType",
"name": "Image"
})
if image_ins:
image_id = str(image_ins._id)
# img_col = node_collection.find({'_type': 'File', 'member_of': {'$all': [ObjectId(image_id)]}, 'group_set': ObjectId(group_id)}).sort("last_update", -1)
files_cur = node_collection.find(
{
'_type': {
'$in': ["GSystem"]
},
'member_of': file_gst._id,
'group_set': {
'$all': [ObjectId(group_id)]
},
'if_file.mime_type': {
'$regex': 'image'
}
# 'created_by': {'$in': gstaff_users},
# '$or': [
# {
# },
# {
# '$or': [
# {'access_policy': u"PUBLIC"},
# {
# '$and': [
# {'access_policy': u"PRIVATE"},
# {'created_by': request.user.id}
# ]
# }
# ],
# }
# { 'collection_set': {'$exists': "true", '$not': {'$size': 0} }}
# ]
},
{
'name': 1,
'_id': 1,
'fs_file_ids': 1,
'member_of': 1,
'mime_type': 1,
'if_file': 1
}).sort("last_update", -1)
# print "file count\n\n\n",files_cur.count()
image_page_info = paginator.Paginator(files_cur, page_no,
GSTUDIO_NO_OF_OBJS_PP)
template = "ndf/ImageDashboard.html"
already_uploaded = request.GET.getlist('var', "")
variable = RequestContext(
request, {
'imageCollection': files_cur,
'already_uploaded': already_uploaded,
'groupid': group_id,
'group_id': group_id,
'image_page_info': image_page_info
})
return render_to_response(template, variable)
def resource_list(request, group_id, app_id=None, page_no=1):
"""
* Renders a list of all 'Resources' available within the database (except eBooks).
"""
is_video = request.GET.get('is_video', "")
try:
group_id = ObjectId(group_id)
except:
group_name, group_id = get_group_name_id(group_id)
if app_id is None:
app_id = str(app._id)
# # Code for displaying user shelf
# shelves = []
# shelf_list = {}
# auth = node_collection.one({'_type': 'Author', 'name': unicode(request.user.username) })
# if auth:
# has_shelf_RT = node_collection.one({'_type': 'RelationType', 'name': u'has_shelf' })
# dbref_has_shelf = has_shelf_RT.get_dbref()
# shelf = collection_tr.Triple.find({'_type': 'GRelation', 'subject': ObjectId(auth._id), 'relation_type': dbref_has_shelf })
# shelf_list = {}
# if shelf:
# for each in shelf:
# shelf_name = node_collection.one({'_id': ObjectId(each.right_subject)})
# shelves.append(shelf_name)
# shelf_list[shelf_name.name] = []
# for ID in shelf_name.collection_set:
# shelf_item = node_collection.one({'_id': ObjectId(ID) })
# shelf_list[shelf_name.name].append(shelf_item.name)
# else:
# shelves = []
# # End of user shelf
# pandoravideoCollection = node_collection.find({'member_of':pandora_video_st._id, 'group_set': ObjectId(group_id) })
# if e_library_GST._id == ObjectId(app_id):
title = e_library_GST.name
file_id = GST_FILE._id
datavisual = []
no_of_objs_pp = 24
# filters = request.POST.get("filters", "")
# filters = json.loads(filters)
# filters = get_filter_querydict(filters)
# print "filters in E-Library : ", filters
# declaring empty (deliberately to avoid errors), query dict to be pass-on in query
query_dict = []
# query_dict = filters
selfilters = urllib.unquote(request.GET.get('selfilters', ''))
if selfilters:
selfilters = json.loads(selfilters)
query_dict = get_filter_querydict(selfilters)
query_dict.append({'attribute_set.educationaluse': {'$ne': 'eBooks'}})
# files = node_collection.find({
# 'member_of': ObjectId(GST_FILE._id),
# '_type': 'File',
# 'fs_file_ids': {'$ne': []},
# 'group_set': ObjectId(group_id),
# '$and': query_dict,
# '$or': [
# { 'access_policy': u"PUBLIC" },
# { '$and': [
# {'access_policy': u"PRIVATE"},
# {'created_by': request.user.id}
# ]
# }
# ]
# }).sort("last_update", -1)
files = node_collection.find({
# 'member_of': {'$in': [GST_FILE._id, GST_PAGE._id]},
'member_of': {
'$in': [GST_FILE._id]
},
# '_type': 'File',
# 'fs_file_ids': {'$ne': []},
'group_set': {
'$all': [ObjectId(group_id)]
},
'$and':
query_dict,
'$or': [{
'access_policy': u"PUBLIC"
}, {
'$and': [{
'access_policy': u"PRIVATE"
}, {
'created_by': request.user.id
}]
}]
}).sort("last_update", -1)
# print "files.count : ", files.count()
# pageCollection=node_collection.find({'member_of':GST_PAGE._id, 'group_set': ObjectId(group_id),
# '$or': [
# { 'access_policy': u"PUBLIC" },
# { '$and': [
# {'access_policy': u"PRIVATE"},
# {'created_by': request.user.id}
# ]
# }
# ],
# 'type_of': {'$in': [wiki_page._id]}
# }).sort("last_update", -1)
educationaluse_stats = {}
if files:
eu_list = [] # count
for each in files:
eu_list += [
i.get("educationaluse") for i in each.attribute_set
if i.has_key("educationaluse")
]
files.rewind()
if set(eu_list):
if len(set(eu_list)) > 1:
educationaluse_stats = dict(
(x, eu_list.count(x)) for x in set(eu_list))
elif len(set(eu_list)) == 1:
educationaluse_stats = {eu_list[0]: eu_list.count(eu_list[0])}
educationaluse_stats["all"] = files.count()
# print educationaluse_stats
result_paginated_cur = files
result_pages = paginator.Paginator(result_paginated_cur, page_no,
no_of_objs_pp)
collection_pages_cur = node_collection.find({
'member_of': {
'$in': [GST_FILE._id]
},
'group_set': {
'$all': [ObjectId(group_id)]
},
'$and':
query_dict,
'$or': [{
'access_policy': u"PUBLIC"
}, {
'$and': [{
'access_policy': u"PRIVATE"
}, {
'created_by': request.user.id
}]
}],
'collection_set': {
'$exists': "true",
'$not': {
'$size': 0
}
}
}).sort("last_update", -1)
coll_page_count = collection_pages_cur.count(
) if collection_pages_cur else 0
collection_pages = paginator.Paginator(collection_pages_cur, page_no,
no_of_objs_pp)
datavisual.append({
"name": "Doc",
"count": educationaluse_stats.get("Documents", 0)
})
datavisual.append({
"name": "Page",
"count": educationaluse_stats.get("Pages", 0)
})
datavisual.append({
"name": "Image",
"count": educationaluse_stats.get("Images", 0)
})
datavisual.append({
"name": "Video",
"count": educationaluse_stats.get("Videos", 0)
})
datavisual.append({
"name": "Interactives",
"count": educationaluse_stats.get("Interactives", 0)
})
datavisual.append({
"name": "Audios",
"count": educationaluse_stats.get("Audios", 0)
})
datavisual.append({
"name": "eBooks",
"count": educationaluse_stats.get("eBooks", 0)
})
if collection_pages_cur:
datavisual.append({"name": "Collections", "count": coll_page_count})
datavisual = json.dumps(datavisual)
return render_to_response(
"ndf/resource_list.html",
{
'title': title,
'app': e_library_GST,
'appId': app._id,
"app_gst": app,
# 'already_uploaded': already_uploaded,'shelf_list': shelf_list,'shelves': shelves,
'files': files,
"detail_urlname": "file_detail",
'ebook_pages': educationaluse_stats.get("eBooks", 0),
# 'page_count': pageCollection.count(),
# 'page_nodes':pageCollection
'file_pages': result_pages,
'image_pages': educationaluse_stats.get("Images", 0),
'interactive_pages': educationaluse_stats.get("Interactives", 0),
'educationaluse_stats': json.dumps(educationaluse_stats),
'doc_pages': educationaluse_stats.get("Documents", 0),
'video_pages': educationaluse_stats.get("Videos", 0),
'audio_pages': educationaluse_stats.get("Audios", 0),
'collection_pages': collection_pages,
'collection': collection_pages_cur,
'groupid': group_id,
'group_id': group_id,
"datavisual": datavisual,
},
context_instance=RequestContext(request))
def elib_paged_file_objs(request, group_id, filetype, page_no):
'''
Method to implement pagination in File and E-Library app.
'''
if request.is_ajax() and request.method == "POST":
group_name, group_id = get_group_name_id(group_id)
no_of_objs_pp = 24
result_pages = None
filters = request.POST.get("filters", "")
filters = json.loads(filters)
filters = get_filter_querydict(filters)
# print "filters in E-Library : ", filters
# declaring empty (deliberately to avoid errors), query dict to be pass-on in query
# query_dict = [{}]
query_dict = filters
selfilters = urllib.unquote(request.GET.get('selfilters', ''))
if selfilters:
selfilters = json.loads(selfilters)
query_dict = get_filter_querydict(selfilters)
query_dict.append({'attribute_set.educationaluse': {'$ne': u'eBooks'}})
detail_urlname = "file_detail"
if filetype != "all":
# if filetype == "Pages":
# detail_urlname = "page_details"
# result_cur = node_collection.find({'member_of': GST_PAGE._id,
# '_type': 'GSystem',
# 'group_set': {'$all': [ObjectId(group_id)]},
# '$or': [
# {'access_policy': u"PUBLIC"},
# {'$and': [
# {'access_policy': u"PRIVATE"},
# {'created_by': request.user.id}
# ]
# }
# ]
# }).sort("last_update", -1)
# result_paginated_cur = result_cur
# result_pages = paginator.Paginator(result_paginated_cur, page_no, no_of_objs_pp)
# elif filetype == "Collections":
if filetype == "Collections":
pass
# detail_urlname = "page_details"
# result_cur = node_collection.find({
# 'member_of': {'$in': [GST_FILE._id, GST_PAGE._id]},
# 'group_set': {'$all': [ObjectId(group_id)]},
# '$or': [
# {'access_policy': u"PUBLIC"},
# {'$and': [
# {'access_policy': u"PRIVATE"},
# {'created_by': request.user.id}
# ]
# }
# ],
# 'collection_set': {'$exists': "true", '$not': {'$size': 0} }
# }).sort("last_update", -1)
# # print "=====================", result_cur.count()
# result_paginated_cur = result_cur
# result_pages = paginator.Paginator(result_paginated_cur, page_no, no_of_objs_pp)
# # print "=====================", result_pages
# query_dict.append({ 'collection_set': {'$exists': "true", '$not': {'$size': 0} } })
else:
query_dict.append({"attribute_set.educationaluse": filetype})
# print filters
# if filters:
# temp_list = []
# for each in filters:
# filter_grp = each["or"]
# for each_filter in filter_grp:
# temp_dict = {}
# each_filter["selFieldText"] = cast_to_data_type(each_filter["selFieldText"], each_filter["selFieldPrimaryType"])
# if each_filter["selFieldPrimaryType"] == unicode("list"):
# each_filter["selFieldText"] = {"$in": each_filter["selFieldText"]}
# if each_filter["selFieldGstudioType"] == "attribute":
# temp_dict["attribute_set." + each_filter["selFieldValue"]] = each_filter["selFieldText"]
# temp_list.append(temp_dict)
# # print "temp_list : ", temp_list
# elif each_filter["selFieldGstudioType"] == "field":
# temp_dict[each_filter["selFieldValue"]] = each_filter["selFieldText"]
# temp_list.append(temp_dict)
# if temp_list:
# query_dict.append({ "$or": temp_list})
# print "query_dict : ", query_dict
files = node_collection.find({
'member_of': {
'$in': [GST_FILE._id]
},
# 'member_of': {'$in': [GST_FILE._id, GST_PAGE._id]},
# '_type': 'File',
# 'fs_file_ids': {'$ne': []},
'group_set': {
'$all': [ObjectId(group_id)]
},
'$and':
query_dict,
'$or': [{
'access_policy': u"PUBLIC"
}, {
'$and': [{
'access_policy': u"PRIVATE"
}, {
'created_by': request.user.id
}]
}]
}).sort("last_update", -1)
educationaluse_stats = {}
# print "files_count: ", files.count()
# if filetype == "Pages":
# filter_result = "True" if (result_cur.count() > 0) else "False"
# else:
if files: # and not result_pages:
# print "=======", educationaluse_stats
eu_list = [] # count
collection_set_count = 0
for each in files:
eu_list += [
i.get("educationaluse") for i in each.attribute_set
if i.has_key("educationaluse")
]
collection_set_count += 1 if each.collection_set else 0
files.rewind()
if set(eu_list):
if len(set(eu_list)) > 1:
educationaluse_stats = dict(
(x, eu_list.count(x)) for x in set(eu_list))
elif len(set(eu_list)) == 1:
educationaluse_stats = {
eu_list[0]: eu_list.count(eu_list[0])
}
educationaluse_stats["all"] = files.count()
educationaluse_stats["Collections"] = collection_set_count
result_paginated_cur = files
result_pages = paginator.Paginator(result_paginated_cur, page_no,
no_of_objs_pp)
filter_result = "True" if (files.count() > 0) else "False"
if filetype == "Collections":
detail_urlname = "page_details"
result_cur = node_collection.find({
'member_of': {
'$in': [GST_FILE._id, GST_PAGE._id]
},
'group_set': {
'$all': [ObjectId(group_id)]
},
'$and':
query_dict,
'$or': [{
'access_policy': u"PUBLIC"
}, {
'$and': [{
'access_policy': u"PRIVATE"
}, {
'created_by': request.user.id
}]
}],
'collection_set': {
'$exists': "true",
'$not': {
'$size': 0
}
}
}).sort("last_update", -1)
# print "=====================", result_cur.count()
result_paginated_cur = result_cur
result_pages = paginator.Paginator(result_paginated_cur, page_no,
no_of_objs_pp)
# if filetype == "all":
# if files:
# result_paginated_cur = files
# result_pages = paginator.Paginator(result_paginated_cur, page_no, no_of_objs_pp)
# # else:
# elif filetype == "Documents":
# d_Collection = node_collection.find({'_type': "GAttribute", 'attribute_type.$id': gattr._id,"subject": {'$in': coll} ,"object_value": "Documents"}).sort("last_update", -1)
# doc = []
# for e in d_Collection:
# doc.append(e.subject)
# result_paginated_cur = node_collection.find({ '$or':[{'_id': {'$in': doc}},
# {'member_of': {'$nin': [ObjectId(GST_IMAGE._id), ObjectId(GST_VIDEO._id),ObjectId(pandora_video_st._id)]},
# '_type': 'File', 'group_set': {'$all': [ObjectId(group_id)]},
# # 'mime_type': {'$not': re.compile("^audio.*")},
# '$or': [
# {'access_policy': u"PUBLIC"},
# {'$and': [{'access_policy': u"PRIVATE"}, {'created_by': request.user.id}]}
# ]
# }]
# }).sort("last_update", -1)
# result_pages = paginator.Paginator(result_paginated_cur, page_no, no_of_objs_pp)
# print "educationaluse_stats: ", educationaluse_stats
return render_to_response(
"ndf/file_list_tab.html", {
"filter_result": filter_result,
"group_id": group_id,
"group_name_tag": group_id,
"groupid": group_id,
'title': "E-Library",
"educationaluse_stats": json.dumps(educationaluse_stats),
"resource_type": result_paginated_cur,
"detail_urlname": detail_urlname,
"filetype": filetype,
"res_type_name": "",
"page_info": result_pages
},
context_instance=RequestContext(request))
def explore_courses(request, page_no=1):
# this will be announced tab
title = 'courses'
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)
primary_lang_tuple = get_language_tuple(GSTUDIO_PRIMARY_COURSE_LANGUAGE)
'''
katkamrachana - 14June2017
About following query:
[A]. Finding CourseEventGroup instances(First $and in $or):
Find CourseEventGroup instances, that are published.
Get courses that are linked to the request.user
Also find courses, that are "PUBLIC AND LANGUAGE falls under
GSTUDIO_PRIMARY_COURSE_LANGUAGE"
Hence, Apply language constraint. Introduced to display concerned
course for i2c(in 3 languages)
[B]. Finding announced_unit instances(Second $and in $or):
Find announced_unit instances, that are published.
Get courses that are linked to the request.user
Also find courses, that are "PUBLIC"
No check on language
[C]. Check using _type field in case conditions A and B fail, only Groups are
to be listed and not GSystems
[D]. Check using name field in case conditions A and B fail,
executing condition C then do not display factory Groups.
'''
base_unit_cur = node_collection.find({
'$or': [{
'$and': [{
'member_of': ce_gst._id
}, {
'status': 'PUBLISHED'
}, {
'$or': [{
'created_by': request.user.id
}, {
'group_admin': request.user.id
}, {
'author_set': request.user.id
}, {
'$and': [
{
'group_type': 'PUBLIC'
},
{
'language': primary_lang_tuple
},
]
}]
}]
}, {
'$and': [{
'member_of': announced_unit_gst._id
}, {
'status': 'PUBLISHED'
}, {
'$or': [{
'created_by': request.user.id
}, {
'group_admin': request.user.id
}, {
'author_set': request.user.id
}, {
'group_type': 'PUBLIC'
}]
}]
}],
'_type':
'Group',
'name': {
'$nin': GSTUDIO_DEFAULT_GROUPS_LIST
},
'_id': {
'$nin': module_unit_ids
},
}).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_basecourses(request, page_no=1):
title = 'courses'
# ce_cur = node_collection.find({'member_of': ce_gst._id,
# '$or': [
# {'created_by': request.user.id},
# {'group_admin': request.user.id},
# {'author_set': request.user.id},
# {'group_type': 'PUBLIC'}
# ]}).sort('last_update', -1)
# ce_page_cur = paginator.Paginator(ce_cur, page_no, GSTUDIO_NO_OF_OBJS_PP)
# parent_group_name, parent_group_id = Group.get_group_name_id(group_id)
'''
ce_cur = node_collection.find({
'_type': 'Group',
# 'group_set': {'$in': [parent_group_id]},
'member_of': {'$in': [gst_base_unit_id]},
'$or':[
{'group_type': u'PUBLIC'},
{
'$and': [
{'access_policy': u"PRIVATE"},
{'created_by': request.user.id}
]
}
],
'status': u'PUBLISHED'
}).sort('last_update', -1)
'''
gstaff_access = check_is_gstaff(group_id, request.user)
query = {
'_type': 'Group',
'status': u'PUBLISHED',
'member_of': {
'$in': [gst_base_unit_id]
},
}
if gstaff_access:
query.update({'group_type': u'PRIVATE'})
else:
query.update({'group_type': u'PUBLIC'})
if request.user.is_authenticated():
query.update({
'$and': [{
'group_type': u'PRIVATE'
}, {
'created_by': request.user.id
}]
})
ce_cur = node_collection.find(query).sort('last_update', -1)
ce_page_cur = paginator.Paginator(ce_cur, page_no, GSTUDIO_NO_OF_OBJS_PP)
# print ce_cur.count()
title = 'base courses'
context_variable = {
'title': title,
'doc_cur': ce_cur,
'group_id': group_id,
'groupid': group_id,
'card': 'ndf/card_group.html',
'ce_page_cur': ce_page_cur
}
return render_to_response(
# "ndf/explore.html", changed as per new Clix UI
"ndf/explore_2017.html",
context_variable,
context_instance=RequestContext(request))
def modify():
f = 0
v1 = 0
v2 = 0
psapHolder = 0
if ('psapid' in request.args):
# modifyNode = FCCDB.PsapModel.find({'PSAP ID':int(request.args['psapid'])})
modifyNode = FCCDB.PsapModel.find_one(
{'PSAP ID': int(request.args['psapid'])})
psapHolder = request.args['psapid']
# temp = modifyNode[0]
if 'pName' in request.args:
v1 = modifyNode['PSAP Name']
v2 = unicode(request.args['pName'])
modifyNode['PSAP Name'] = unicode(request.args['pName'])
modifyNode.save()
f = 'PSAP Name'
if 'state' in request.args:
v1 = modifyNode['State']
v2 = unicode(request.args['state'])
modifyNode['State'] = unicode(request.args['state'])
f = 'State'
modifyNode.save()
if 'county' in request.args:
v1 = modifyNode['County']
v2 = unicode(request.args['county'])
modifyNode['County'] = request.args['county']
f = 'County'
modifyNode.save()
if 'city' in request.args:
v1 = modifyNode['City']
v2 = unicode(request.args['city'])
modifyNode['City'] = request.args['city']
f = 'City'
modifyNode.save()
if 'toc' in request.args:
v1 = modifyNode['Type of Change']
v2 = unicode(request.args['toc'])
modifyNode['Type of Change'] = request.args['toc']
f = 'Type of Change'
modifyNode.save()
if 'comments' in request.args:
v1 = modifyNode['Comments']
v2 = unicode(request.args['comments'])
modifyNode['Comments'] = request.args['comments']
f = 'Comments'
modifyNode.save()
if 'text2911' in request.args:
v1 = modifyNode['Text to 911']
v2 = unicode(request.args['text2911'])
modifyNode['Text to 911'] = request.args['text2911']
f = 'Text to 911'
modifyNode.save()
if 'psapcontact' in request.args:
v1 = modifyNode['PSAP Contact']
v2 = unicode(request.args['psapcontact'])
modifyNode['PSAP Contact'] = request.args['psapcontact']
f = 'PSAP Contact'
modifyNode.save()
dataList = 0
counter = 0
adminUser = False
if ('all' in session['write_access']):
dataList = FCCDB.PsapModel.find()
counter = FCCDB.PsapModel.find().count()
adminUser = True
else:
dataList = FCCDB.PsapModel.find(
{'PSAP ID': {
'$in': [int(i) for i in session['write_access']]
}})
counter = FCCDB.PsapModel.find({
'PSAP ID': {
'$in': [int(i) for i in session['write_access']]
}
}).count()
dataListSorted = dataList.sort('PSAP ID', pymongo.ASCENDING)
if (((int(request.args['page']) - 1) * 10) > int(counter)):
return page_not_found('500')
pageSource = paginator.Paginator(dataListSorted, request.args['page'], 10)
return render_template('modify.html',
dataList=fixCursor(dataListSorted),
email=session['email'],
pgSource=pageSource,
cItem=f,
v1=v1,
v2=v2,
psapidNum=psapHolder,
adminUser=adminUser)
def page(request, group_id, app_id=None, page_no=1):
"""Renders a list of all 'Page-type-GSystems' available within the database.
"""
try:
group_id = ObjectId(group_id)
except:
group_name, group_id = get_group_name_id(group_id)
if app_id is None:
app_ins = node_collection.find_one({
'_type': "GSystemType",
"name": "Page"
})
if app_ins:
app_id = str(app_ins._id)
from gnowsys_ndf.settings import GSTUDIO_NO_OF_OBJS_PP
content = []
version = []
con = []
group_object = node_collection.one({'_id': ObjectId(group_id)})
# Code for user shelf
shelves = []
shelf_list = {}
auth = node_collection.one({
'_type': 'Author',
'name': unicode(request.user.username)
})
if request.method == "POST":
title = gst_page.name
search_field = request.POST['search_field']
page_nodes = node_collection.find({
'member_of': {
'$all': [ObjectId(app_id)]
},
'$or': [{
'$and': [{
'name': {
'$regex': search_field,
'$options': 'i'
}
}, {
'$or': [{
'access_policy': u"PUBLIC"
}, {
'$and': [{
'access_policy': u"PRIVATE"
}, {
'created_by': request.user.id
}]
}]
}]
}, {
'$and': [{
'tags': {
'$regex': search_field,
'$options': 'i'
}
}, {
'$or': [{
'access_policy': u"PUBLIC"
}, {
'$and': [{
'access_policy': u"PRIVATE"
}, {
'created_by': request.user.id
}]
}]
}]
}],
'group_set': {
'$all': [ObjectId(group_id)]
},
'status': {
'$nin': ['HIDDEN']
}
}).sort('last_update', -1)
paginator_pages = paginator.Paginator(page_nodes, page_no,
GSTUDIO_NO_OF_OBJS_PP)
return render_to_response("ndf/page_list.html", {
'title': title,
'appId': app._id,
'shelf_list': shelf_list,
'shelves': shelves,
'searching': True,
'query': search_field,
'page_nodes': page_nodes,
'groupid': group_id,
'group_id': group_id,
'page_info': paginator_pages
},
context_instance=RequestContext(request))
elif gst_page._id == ObjectId(app_id):
group_type = node_collection.one({'_id': ObjectId(group_id)})
group_info = group_type_info(group_id)
node = node_collection.find({'member_of': ObjectId(app_id)})
title = gst_page.name
"""
Below query returns only those documents:
(a) which are pages,
(b) which belongs to given group,
(c) which has status either as DRAFT or PUBLISHED, and
(d) which has access_policy either as PUBLIC or if PRIVATE then it's created_by must be the logged-in user
"""
page_nodes = node_collection.find({
'member_of': {
'$all': [ObjectId(app_id)]
},
'group_set': {
'$all': [ObjectId(group_id)]
},
'$or': [{
'access_policy': u"PUBLIC"
}, {
'$and': [{
'access_policy': u"PRIVATE"
}, {
'created_by': request.user.id
}]
}],
'status': {
'$nin': ['HIDDEN']
}
}).sort('last_update', -1)
paginator_pages = paginator.Paginator(page_nodes, page_no,
GSTUDIO_NO_OF_OBJS_PP)
return render_to_response("ndf/page_list.html", {
'title': title,
'appId': app._id,
'shelf_list': shelf_list,
'shelves': shelves,
'page_nodes': page_nodes,
'groupid': group_id,
'group_id': group_id,
'page_info': paginator_pages
},
context_instance=RequestContext(request))
else:
# Page Single instance view
page_node = node_collection.one({"_id": ObjectId(app_id)})
thread_node = None
allow_to_comment = None
annotations = None
if page_node:
annotations = json.dumps(page_node.annotations)
page_node.get_neighbourhood(page_node.member_of)
thread_node, allow_to_comment = node_thread_access(
group_id, page_node)
return render_to_response('ndf/page_details.html', {
'node': page_node,
'node_has_thread': thread_node,
'appId': app._id,
'group_id': group_id,
'shelf_list': shelf_list,
'allow_to_comment': allow_to_comment,
'annotations': annotations,
'shelves': shelves,
'groupid': group_id
},
context_instance=RequestContext(request))
def ebook_listing(request, group_id, page_no=1):
from gnowsys_ndf.settings import GSTUDIO_NO_OF_OBJS_PP
import urllib
try:
group_id = ObjectId(group_id)
except:
group_name, group_id = get_group_name_id(group_id)
selfilters = urllib.unquote(request.GET.get('selfilters', ''))
# print "===\n", selfilters, "===\n"
query_dict = [{}]
if selfilters:
selfilters = json.loads(selfilters)
query_dict = get_filter_querydict(selfilters)
# else:
# query_dict.append({'collection_set': {'$exists': "true", '$not': {'$size': 0} }})
# print "\n----\n", query_dict
# all_ebooks = node_collection.find({
# # "_type": "File",
# # "attribute_set.educationaluse": "eBooks",
# '$and': query_dict,
# 'collection_set': {'$exists': "true", '$not': {'$size': 0} }
# })
all_ebooks = node_collection.find({
'member_of': {
'$in': [GST_FILE._id, GST_PAGE._id]
},
# '_type': 'File',
# 'fs_file_ids': {'$ne': []},
'group_set': {
'$in': [ObjectId(group_id)]
},
'attribute_set.educationaluse':
'eBooks',
'$and':
query_dict,
'$or': [{
'access_policy': u"PUBLIC"
}, {
'$and': [{
'access_policy': u"PRIVATE"
}, {
'created_by': request.user.id
}]
}],
'collection_set': {
'$exists': "true",
'$not': {
'$size': 0
}
}
}).sort("last_update", -1)
ebooks_page_info = paginator.Paginator(all_ebooks, page_no,
GSTUDIO_NO_OF_OBJS_PP)
return render_to_response("ndf/ebook.html", {
"all_ebooks": all_ebooks,
"ebook_gst": ebook_gst,
"page_info": ebooks_page_info,
"title": "eBooks",
"group_id": group_id,
"groupid": group_id
},
context_instance=RequestContext(request))
def my_desk(request, group_id, page_no=1):
if str(request.user) == 'AnonymousUser':
raise Http404("You don't have an authority for this page!")
try:
auth_obj = get_group_name_id(group_id, get_obj=True)
user_id = auth_obj.created_by
except:
user_id = eval(group_id)
auth_obj = node_collection.one({
'_type': "Author",
'created_by': user_id
})
auth_id = auth_obj._id
title = 'my desk'
from gnowsys_ndf.settings import GSTUDIO_NO_OF_OBJS_PP
# modules_cur = node_collection.find({'member_of': gst_module_id }).sort('last_update', -1)
# my_course_objs = get_user_course_groups(user_id)
# module_unit_ids = [val for each_module in modules_cur for val in each_module.collection_set ]
# modules_cur.rewind()
# print my_course_objs
# base_unit_cur = node_collection.find({'member_of': {'$in': [ce_gst._id, announced_unit_gst._id]},
# 'author_set': request.user.id,
# }).sort('last_update', -1)
# my_list_unit = []
# for each in base_unit_cur:
# my_list_unit.append(each._id)
# base_unit_cur.rewind()
# my_modules_cur = node_collection.find({'member_of': gst_module_id ,'collection_set':{'$in':my_list_unit } }).sort('last_update', -1)
# my_modules = []
# for each in my_modules_cur:
# my_modules.append(each._id)
my_units = node_collection.find({
'member_of': {
'$in': [ce_gst._id, announced_unit_gst._id, gst_group._id]
},
'name': {
'$nin': GSTUDIO_DEFAULT_GROUPS_LIST
},
'author_set': request.user.id
}).sort('last_update', -1)
my_units_page_cur = paginator.Paginator(my_units, page_no,
GSTUDIO_NO_OF_OBJS_PP)
# my_modules_cur.rewind()
return render_to_response(
'ndf/lms_dashboard.html',
{
'group_id': auth_id,
'groupid': auth_id,
'node': auth_obj,
'title': title,
# 'my_course_objs': my_course_objs,
'units_cur': my_units,
'my_units_page_cur': my_units_page_cur
# 'modules_cur': my_modules_cur
},
context_instance=RequestContext(request))
