def getWithdrawData(self, request, ap_params, wp_params, program_kwargs):
"""Return data for withdraw.
"""
program = program_logic.getFromKeyFieldsOr404(program_kwargs)
fields = {
'program': program,
}
idx = request.GET.get('idx', '')
idx = int(idx) if idx.isdigit() else -1
if idx == 0:
fields['status'] = ['accepted', 'completed']
params = ap_params
elif idx == 1:
fields['status'] = ['withdrawn']
params = wp_params
else:
return responses.jsonErrorResponse(request, "idx not valid")
contents = lists.getListData(request, params, fields, 'public')
json = simplejson.dumps(contents)
return responses.jsonResponse(request, json)
def showDuplicates(self,
request,
access_type,
page_name=None,
params=None,
**kwargs):
"""View in which a host can see which students have been assigned
multiple slots.
For params see base.view.Public().
"""
from google.appengine.api import taskqueue
from soc.modules.gsoc.logic.models.proposal_duplicates import logic \
as duplicates_logic
from soc.modules.gsoc.logic.models.proposal_duplicates_status import \
logic as ds_logic
program_entity = program_logic.getFromKeyFieldsOr404(kwargs)
context = helper.responses.getUniversalContext(request)
helper.responses.useJavaScript(context, params['js_uses_all'])
context['page_name'] = page_name
fields = {'program': program_entity, 'is_duplicate': True}
template = 'modules/gsoc/program/show_duplicates.html'
context['duplicates'] = duplicates_logic.getForFields(fields)
duplicates_status = ds_logic.getOrCreateForProgram(program_entity)
context['duplicates_status'] = duplicates_status
if request.POST:
post_data = request.POST
# pass along these params as POST to the new task
task_params = {'program_key': program_entity.key().id_or_name()}
task_url = '/tasks/gsoc/proposal_duplicates/start'
# checks if the task newly added is the first task
# and must be performed repeatedly every hour or
# just be performed once right away
if 'calculate' in post_data:
task_params['repeat'] = 'yes'
elif 'recalculate' in post_data:
task_params['repeat'] = 'no'
# adds a new task
new_task = taskqueue.Task(params=task_params, url=task_url)
new_task.add()
return helper.responses.respond(request,
template=template,
context=context)
def assignSlots(self, request, access_type, page_name=None,
params=None, **kwargs):
"""View that allows to assign slots to orgs.
"""
from soc.modules.gsoc.views.models.organization import view as org_view
program_entity = program_logic.getFromKeyFieldsOr404(kwargs)
description = self.DEF_SLOTS_ALLOCATION_MSG
org_params = org_view.getParams().copy()
org_params['list_description'] = description
org_params['list_template'] = "modules/gsoc/program/list/allocation.html"
org_params['public_field_props'] = {
"link_id": {
"hidden": True,
}
}
org_params['public_row_action'] = {}
org_params['public_row_extra'] = lambda entity: {}
org_params['public_conf_extra'] = {
"rowNum": -1,
"rowList": [],
}
org_params['public_field_keys'] = [
"name", "slots_desired", "nr_applications", "nr_mentors",
"locked", "slots_ass", "slots", "link_id",
]
org_params['public_field_names'] = [
"Name", "Desired", "#Proposals", "#Mentors",
"Locked?", "Slots Assigned", "Slots Visible to Org", "Link ID",
]
fields = {
'scope': program_entity,
'status': ['new', 'active', 'inactive']
}
return_url = "http://%(host)s%(index)s" % {
'host' : system.getHostname(),
'index': redirects.getSlotsRedirect(program_entity, params)
}
context = {
'total_slots': program_entity.slots,
'uses_json': True,
'uses_slot_allocator': True,
'return_url': return_url,
}
return self.list(request, 'allow', page_name=page_name, params=org_params,
filter=fields, context=context)
def showDuplicates(self, request, access_type, page_name=None,
params=None, **kwargs):
"""View in which a host can see which students have been assigned
multiple slots.
For params see base.view.Public().
"""
from google.appengine.api import taskqueue
from soc.modules.gsoc.logic.models.proposal_duplicates import logic \
as duplicates_logic
from soc.modules.gsoc.logic.models.proposal_duplicates_status import \
logic as ds_logic
program_entity = program_logic.getFromKeyFieldsOr404(kwargs)
context = helper.responses.getUniversalContext(request)
helper.responses.useJavaScript(context, params['js_uses_all'])
context['page_name'] = page_name
fields = {'program': program_entity,
'is_duplicate': True}
template = 'modules/gsoc/program/show_duplicates.html'
context['duplicates'] = duplicates_logic.getForFields(fields)
duplicates_status = ds_logic.getOrCreateForProgram(program_entity)
context['duplicates_status'] = duplicates_status
if request.POST:
post_data = request.POST
# pass along these params as POST to the new task
task_params = {'program_key': program_entity.key().id_or_name()}
task_url = '/tasks/gsoc/proposal_duplicates/start'
# checks if the task newly added is the first task
# and must be performed repeatedly every hour or
# just be performed once right away
if 'calculate' in post_data:
task_params['repeat'] = 'yes'
elif 'recalculate' in post_data:
task_params['repeat'] = 'no'
# adds a new task
new_task = taskqueue.Task(params=task_params, url=task_url)
new_task.add()
return helper.responses.respond(request, template=template,
context=context)
def overview(self, request, access_type,
page_name=None, params=None, **kwargs):
"""View that allows Program Admins to see/control all StudentProjects.
For args see base.View().public()
"""
program_entity = program_logic.getFromKeyFieldsOr404(kwargs)
if request.POST:
return self.overviewPost(request, params, program_entity)
else: #request.GET
return self.overviewGet(request, page_name, params, program_entity,
**kwargs)
def populate(self, redirect, request, args, kwargs):
"""Populates the fields in the RequestData object.
Args:
request: Django HTTPRequest object.
args & kwargs: The args and kwargs django sends along.
"""
super(RequestData, self).populate(redirect, request, args, kwargs)
if kwargs.get('sponsor') and kwargs.get('program'):
program_keyfields = {
'link_id': kwargs['program'],
'scope_path': kwargs['sponsor']
}
self.program = program_logic.getFromKeyFieldsOr404(
program_keyfields)
else:
self.program = self.site.active_program
self.program_timeline = self.program.timeline
org_app_fields = {'scope': self.program}
self.org_app = org_app_logic.getOneForFields(org_app_fields)
self.timeline = TimelineHelper(self.program_timeline, self.org_app)
if kwargs.get('organization'):
org_keyfields = {
'link_id': kwargs.get('organization'),
'scope_path': self.program.key().id_or_name(),
}
self.organization = org_logic.getFromKeyFieldsOr404(org_keyfields)
if self.user:
key_name = '%s/%s' % (self.program.key().name(), self.user.link_id)
self.profile = profile.GSoCProfile.get_by_key_name(
key_name, parent=self.user)
self.is_host = self.program.scope.key() in self.user.host_for
if self.profile:
orgs = set(self.profile.mentor_for + self.profile.org_admin_for)
org_map = dict((i.key(), i) for i in db.get(orgs))
self.mentor_for = org_map.values()
self.org_admin_for = [
org_map[i] for i in self.profile.org_admin_for
]
self.student_info = self.profile.student_info
def overview(self,
request,
access_type,
page_name=None,
params=None,
**kwargs):
"""View that allows Program Admins to see/control all StudentProjects.
For args see base.View().public()
"""
program_entity = program_logic.getFromKeyFieldsOr404(kwargs)
if request.POST:
return self.overviewPost(request, params, program_entity)
else: #request.GET
return self.overviewGet(request, page_name, params, program_entity,
**kwargs)
def populate(self, redirect, request, args, kwargs):
"""Populates the fields in the RequestData object.
Args:
request: Django HTTPRequest object.
args & kwargs: The args and kwargs django sends along.
"""
super(RequestData, self).populate(redirect, request, args, kwargs)
if kwargs.get('sponsor') and kwargs.get('program'):
program_keyfields = {'link_id': kwargs['program'],
'scope_path': kwargs['sponsor']}
self.program = program_logic.getFromKeyFieldsOr404(program_keyfields)
else:
self.program = self.site.active_program
self.program_timeline = self.program.timeline
org_app_fields = {'scope': self.program}
self.org_app = org_app_logic.getOneForFields(org_app_fields)
self.timeline = TimelineHelper(self.program_timeline, self.org_app)
if kwargs.get('organization'):
org_keyfields = {
'link_id': kwargs.get('organization'),
'scope_path': self.program.key().id_or_name(),
}
self.organization = org_logic.getFromKeyFieldsOr404(org_keyfields)
if self.user:
key_name = '%s/%s' % (self.program.key().name(), self.user.link_id)
self.profile = profile.GSoCProfile.get_by_key_name(
key_name, parent=self.user)
self.is_host = self.program.scope.key() in self.user.host_for
if self.profile:
orgs = set(self.profile.mentor_for + self.profile.org_admin_for)
org_map = dict((i.key(), i) for i in db.get(orgs))
self.mentor_for = org_map.values()
self.org_admin_for = [org_map[i] for i in self.profile.org_admin_for]
self.student_info = self.profile.student_info
def assignSlots(self,
request,
access_type,
page_name=None,
params=None,
**kwargs):
"""View that allows to assign slots to orgs.
"""
from soc.modules.gsoc.views.models.organization import view as org_view
org_params = org_view.getParams().copy()
org_params['list_template'] = 'soc/program/allocation/allocation.html'
org_params['list_heading'] = 'soc/program/allocation/heading.html'
org_params['list_row'] = 'soc/program/allocation/row.html'
org_params['list_pagination'] = 'soc/list/no_pagination.html'
program_entity = program_logic.getFromKeyFieldsOr404(kwargs)
description = self.DEF_SLOTS_ALLOCATION_MSG
content = self._getOrgsWithProfilesList(program_entity, org_view,
description, False)
contents = [content]
return_url = "http://%(host)s%(index)s" % {
'host': system.getHostname(),
'index': redirects.getSlotsRedirect(program_entity, params)
}
context = {
'total_slots': program_entity.slots,
'uses_json': True,
'uses_slot_allocator': True,
'return_url': return_url,
}
return self._list(request, org_params, contents, page_name, context)
def showDuplicates(self,
request,
access_type,
page_name=None,
params=None,
**kwargs):
"""View in which a host can see which students have been assigned
multiple slots.
For params see base.view.Public().
"""
from django.utils import simplejson
from soc.modules.gsoc.logic.models.proposal_duplicates import logic as duplicates_logic
program_entity = program_logic.getFromKeyFieldsOr404(kwargs)
if request.POST and request.POST.get('result'):
# store result in the datastore
fields = {
'link_id': program_entity.link_id,
'scope': program_entity,
'scope_path': program_entity.key().id_or_name(),
'json_representation': request.POST['result']
}
key_name = duplicates_logic.getKeyNameFromFields(fields)
duplicates_logic.updateOrCreateFromKeyName(fields, key_name)
response = simplejson.dumps({'status': 'done'})
return http.HttpResponse(response)
context = helper.responses.getUniversalContext(request)
helper.responses.useJavaScript(context, params['js_uses_all'])
context['uses_duplicates'] = True
context['uses_json'] = True
context['page_name'] = page_name
# get all orgs for this program who are active and have slots assigned
fields = {'scope': program_entity, 'slots >': 0, 'status': 'active'}
query = org_logic.logic.getQueryForFields(fields)
to_json = {
'nr_of_orgs': query.count(),
'program_key': program_entity.key().id_or_name()
}
json = simplejson.dumps(to_json)
context['info'] = json
context['offset_length'] = 10
fields = {'link_id': program_entity.link_id, 'scope': program_entity}
duplicates = duplicates_logic.getForFields(fields, unique=True)
if duplicates:
# we have stored information
# pylint: disable-msg=E1103
context['duplicate_cache_content'] = duplicates.json_representation
context['date_of_calculation'] = duplicates.calculated_on
else:
# no information stored
context['duplicate_cache_content'] = simplejson.dumps({})
template = 'soc/program/show_duplicates.html'
return helper.responses.respond(request,
template=template,
context=context)
def slots(self,
request,
acces_type,
page_name=None,
params=None,
**kwargs):
"""Returns a JSON object with all orgs allocation.
Args:
request: the standard Django HTTP request object
access_type : the name of the access type which should be checked
page_name: the page name displayed in templates as page and header title
params: a dict with params for this View, not used
"""
from django.utils import simplejson
program_entity = program_logic.getFromKeyFieldsOr404(kwargs)
program_slots = program_entity.slots
filter = {
'scope': program_entity,
'status': 'active',
}
query = org_logic.logic.getQueryForFields(filter=filter)
organizations = org_logic.logic.getAll(query)
locked_slots = adjusted_slots = {}
if request.method == 'POST' and 'result' in request.POST:
result = request.POST['result']
submit = request.GET.get('submit')
load = request.GET.get('load')
stored = program_entity.slots_allocation
if load and stored:
result = stored
from_json = simplejson.loads(result)
locked_slots = dicts.groupDictBy(from_json, 'locked', 'slots')
if submit:
program_entity.slots_allocation = result
program_entity.put()
orgs = {}
applications = {}
max = {}
for org in organizations:
orgs[org.link_id] = org
applications[org.link_id] = org.nr_applications
max[org.link_id] = min(org.nr_mentors, org.slots_desired)
max_slots_per_org = program_entity.max_slots
min_slots_per_org = program_entity.min_slots
algorithm = 2
allocator = allocations.Allocator(orgs.keys(), applications, max,
program_slots, max_slots_per_org,
min_slots_per_org, algorithm)
result = allocator.allocate(locked_slots)
data = []
# TODO: remove adjustment here and in the JS
for link_id, count in result.iteritems():
org = orgs[link_id]
data.append({
'link_id': link_id,
'slots': count,
'locked': locked_slots.get(link_id, 0),
'adjustment': adjusted_slots.get(link_id, 0),
})
return self.json(request, data)
def assignedProposals(self,
request,
access_type,
page_name=None,
params=None,
filter=None,
**kwargs):
"""Returns a JSON dict containing all the proposals that would have
a slot assigned for a specific set of orgs.
The request.GET limit and offset determines how many and which
organizations should be returned.
For params see base.View.public().
Returns: JSON object with a collection of orgs and proposals. Containing
identification information and contact information.
"""
get_dict = request.GET
if not (get_dict.get('limit') and get_dict.get('offset')):
return self.json(request, {})
try:
limit = max(0, int(get_dict['limit']))
offset = max(0, int(get_dict['offset']))
except ValueError:
return self.json(request, {})
program_entity = program_logic.getFromKeyFieldsOr404(kwargs)
fields = {'scope': program_entity, 'slots >': 0, 'status': 'active'}
org_entities = org_logic.logic.getForFields(fields,
limit=limit,
offset=offset)
orgs_data = {}
proposals_data = []
# for each org get the proposals who will be assigned a slot
for org in org_entities:
org_data = {'name': org.name}
fields = {'scope': org, 'status': 'active', 'user': org.founder}
org_admin = org_admin_logic.getForFields(fields, unique=True)
if org_admin:
# pylint: disable-msg=E1103
org_data['admin_name'] = org_admin.name()
org_data['admin_email'] = org_admin.email
proposals = student_proposal_logic.getProposalsToBeAcceptedForOrg(
org, step_size=program_entity.max_slots)
if not proposals:
# nothing to accept, next organization
continue
# store information about the org
orgs_data[org.key().id_or_name()] = org_data
# store each proposal in the dictionary
for proposal in proposals:
student_entity = proposal.scope
proposals_data.append({
'key_name':
proposal.key().id_or_name(),
'proposal_title':
proposal.title,
'student_key':
student_entity.key().id_or_name(),
'student_name':
student_entity.name(),
'student_contact':
student_entity.email,
'org_key':
org.key().id_or_name()
})
# return all the data in JSON format
data = {'orgs': orgs_data, 'proposals': proposals_data}
return self.json(request, data)
def assignSlots(self,
request,
access_type,
page_name=None,
params=None,
**kwargs):
"""View that allows to assign slots to orgs.
"""
from soc.modules.gsoc.views.models.organization import view as org_view
program_entity = program_logic.getFromKeyFieldsOr404(kwargs)
description = self.DEF_SLOTS_ALLOCATION_MSG
org_params = org_view.getParams().copy()
org_params['list_description'] = description
org_params[
'list_template'] = "modules/gsoc/program/list/allocation.html"
org_params['public_field_props'] = {
"link_id": {
"hidden": True,
}
}
org_params['public_row_action'] = {}
org_params['public_row_extra'] = lambda entity: {}
org_params['public_conf_extra'] = {
"rowNum": -1,
"rowList": [],
}
org_params['public_field_keys'] = [
"name",
"slots_desired",
"nr_applications",
"nr_mentors",
"locked",
"slots_ass",
"slots",
"link_id",
]
org_params['public_field_names'] = [
"Name",
"Desired",
"#Proposals",
"#Mentors",
"Locked?",
"Slots Assigned",
"Slots Visible to Org",
"Link ID",
]
fields = {
'scope': program_entity,
'status': ['new', 'active', 'inactive']
}
return_url = "http://%(host)s%(index)s" % {
'host': system.getHostname(),
'index': redirects.getSlotsRedirect(program_entity, params)
}
context = {
'total_slots': program_entity.slots,
'uses_json': True,
'uses_slot_allocator': True,
'return_url': return_url,
}
return self.list(request,
'allow',
page_name=page_name,
params=org_params,
filter=fields,
context=context)
def slots(self, request, acces_type, page_name=None, params=None, **kwargs):
"""Returns a JSON object with all orgs allocation.
Args:
request: the standard Django HTTP request object
access_type : the name of the access type which should be checked
page_name: the page name displayed in templates as page and header title
params: a dict with params for this View, not used
"""
program_entity = program_logic.getFromKeyFieldsOr404(kwargs)
program_slots = program_entity.slots
filter = {
'scope': program_entity,
'status': ['new', 'active', 'inactive'],
}
query = org_logic.getQueryForFields(filter=filter)
organizations = org_logic.getAll(query)
if request.method == 'POST' and 'result' in request.POST:
result = request.POST['result']
submit = request.GET.get('submit')
load = request.GET.get('load')
stored = program_entity.slots_allocation
if load and stored:
result = stored
if submit:
program_entity.slots_allocation = result
program_entity.put()
orgs = {}
applications = {}
max = {}
for org in organizations:
orgs[org.link_id] = org
applications[org.link_id] = org.nr_applications
max[org.link_id] = org.slots_desired
max_slots_per_org = program_entity.max_slots
min_slots_per_org = program_entity.min_slots
algorithm = 2
allocator = allocations.Allocator(orgs.keys(), applications, max,
program_slots, max_slots_per_org,
min_slots_per_org, algorithm)
from_json = simplejson.loads(program_entity.slots_allocation)
locked_slots = dicts.groupDictBy(from_json, 'locked', 'slots')
result = allocator.allocate(locked_slots)
data = []
for link_id in orgs.keys():
data.append({
'link_id': link_id,
'slots': result.get(link_id,0),
'locked': bool(locked_slots.get(link_id))
})
return self.json(request, data)
def assignedProposals(self, request, access_type, page_name=None,
params=None, filter=None, **kwargs):
"""Returns a JSON dict containing all the proposals that would have
a slot assigned for a specific set of orgs.
The request.GET limit and offset determines how many and which
organizations should be returned.
For params see base.View.public().
Returns: JSON object with a collection of orgs and proposals. Containing
identification information and contact information.
"""
get_dict = request.GET
if not (get_dict.get('limit') and get_dict.get('offset')):
return self.json(request, {})
try:
limit = max(0, int(get_dict['limit']))
offset = max(0, int(get_dict['offset']))
except ValueError:
return self.json(request, {})
program_entity = program_logic.getFromKeyFieldsOr404(kwargs)
fields = {'scope': program_entity,
'slots >': 0,
'status': 'active'}
org_entities = org_logic.getForFields(fields,
limit=limit, offset=offset)
orgs_data = {}
proposals_data = []
# for each org get the proposals who will be assigned a slot
for org in org_entities:
org_data = {'name': org.name}
fields = {'scope': org,
'status': 'active',
'user': org.founder}
org_admin = org_admin_logic.getForFields(fields, unique=True)
if org_admin:
# pylint: disable=E1103
org_data['admin_name'] = org_admin.name()
org_data['admin_email'] = org_admin.email
proposals = student_proposal_logic.getProposalsToBeAcceptedForOrg(
org, step_size=program_entity.max_slots)
if not proposals:
# nothing to accept, next organization
continue
# store information about the org
orgs_data[org.key().id_or_name()] = org_data
# store each proposal in the dictionary
for proposal in proposals:
student_entity = proposal.scope
proposals_data.append(
{'key_name': proposal.key().id_or_name(),
'proposal_title': proposal.title,
'student_key': student_entity.key().id_or_name(),
'student_name': student_entity.name(),
'student_contact': student_entity.email,
'org_key': org.key().id_or_name()
})
# return all the data in JSON format
data = {'orgs': orgs_data,
'proposals': proposals_data}
return self.json(request, data)
