def __init__(self,
moduleName,
centralHost=SUBSCRIBER_OPT_DEFAULTS['centralHost'],
context=None,
centralPublishEndpoint=SUBSCRIBER_OPT_DEFAULTS[
'centralPublishEndpoint'],
replay=None):
self.moduleName = moduleName
self.centralHost = centralHost
if context is None:
context = zmq.Context.instance()
self.context = context
self.centralPublishEndpoint = parseEndpoint(
centralPublishEndpoint,
defaultPort=DEFAULT_CENTRAL_PUBLISH_PORT,
centralHost=self.centralHost)
self.replayPaths = replay
if self.replayPaths is None:
self.replayPaths = []
self.handlers = {}
self.counter = 0
self.deserializer = serializers.get_deserializer('json')
self.stream = None
def __init__(self, graph, serializer_name, chunksize=None, **options):
self.graph = graph
self.deserializer = serializers.get_deserializer(serializer_name)
self.chunksize = chunksize
self.options = options
self.multiple_streams = getattr(self.deserializer, 'multiple_streams', False)
self.stream = None
def __init__(self, graph, serializer_name, chunksize=None, **options):
self.graph = graph
self.deserializer = serializers.get_deserializer(serializer_name)
self.chunksize = chunksize
self.options = options
self.multiple_streams = getattr(self.deserializer, 'multiple_streams',
False)
self.stream = None
def handle(self, *args, **options):
# Safety checks
if 'semifinal' not in settings.INSTALLED_APPS:
self.abort(
"Module 'semifinal' is not in INSTALLED_APPS. Please ensure you are using semifinal settings."
)
if not settings.PROLOGIN_SEMIFINAL_MODE:
self.abort(
"Your are not in semifinal mode. Please ensure you are using semifinal settings."
)
for model in (Edition, Event, Center, Contestant, User):
if model.objects.exists():
return self.db_not_empty(model.__class__.__name__)
deserializer = serializers.get_deserializer('json')
file = options['import_file']
with transaction.atomic():
edition = next(deserializer(file.readline()))
self.print(" Edition {}", edition.object)
edition.save()
center = next(deserializer(file.readline()))
self.print(" Center {}", center.object)
center.save()
event = next(deserializer(file.readline()))
self.print(" Event {}", event.object)
event.save()
for user in deserializer(file.readline()):
self.print(" User {}", user.object.username)
user.save()
for contestant in deserializer(file.readline()):
self.print(" Contestant {}",
contestant.object.user.username)
contestant.save()
# Admin user
self.print("\nCreating admin user 'admin'.")
while True:
self.print("Provide a password for user 'admin': ")
password = getpass.getpass("")
if password:
break
admin = User(username='******',
email='*****@*****.**',
is_active=True,
is_superuser=True,
is_staff=True)
admin.set_password(password)
admin.save()
self.print("Bootstrapping completed.")
def __init__(self,
moduleName,
context=None,
centralPublishEndpoint=SUBSCRIBER_OPT_DEFAULTS['centralPublishEndpoint']):
self.moduleName = moduleName
if context is None:
context = zmq.Context.instance()
self.context = context
self.centralPublishEndpoint = parseEndpoint(centralPublishEndpoint,
defaultPort=DEFAULT_CENTRAL_PUBLISH_PORT)
self.handlers = {}
self.counter = 0
self.deserializer = serializers.get_deserializer('json')
def __init__(self,
moduleName,
centralHost=SUBSCRIBER_OPT_DEFAULTS['centralHost'],
context=None,
centralPublishEndpoint=SUBSCRIBER_OPT_DEFAULTS['centralPublishEndpoint'],
replay=None):
self.moduleName = moduleName
self.centralHost = centralHost
if context is None:
context = zmq.Context.instance()
self.context = context
self.centralPublishEndpoint = parseEndpoint(centralPublishEndpoint,
defaultPort=DEFAULT_CENTRAL_PUBLISH_PORT,
centralHost=self.centralHost)
self.replayPaths = replay
if self.replayPaths is None:
self.replayPaths = []
self.handlers = {}
self.counter = 0
self.deserializer = serializers.get_deserializer('json')
self.stream = None
def test_get_unkown_deserializer(self):
with self.assertRaises(SerializerDoesNotExist):
serializers.get_deserializer("nonsense")
except:
from agent.models import AgentRecord, AgentDeviceRecord, AgentMarketingCampaign
from agent.views import AGENT as SETTINGS
from poster.encode import multipart_encode
from poster.streaminghttp import register_openers
from itertools import chain
import gzip, httplib, mimetypes, urllib, urllib2, StringIO, os, time
register_openers()
serializer = serializers.get_serializer('json')()
#serializer.options={'indent': 4, 'subclass': True}
serialize = serializer.serialize
deserialize = serializers.get_deserializer('json')
HELP = r"""
Go through database and upload data to main server.
send_data_agent [options] [agent settings]
Agent Options: (settings=value)
server=AGENT_SERVER server to which we connect to
site_id=AGENT_SITEID siteID used to identify with the server
customer_id=AGENT_CUSTOMERID customerID used to identify with the
server
save_settings=[False] if present then any change to customer_id or
agent_id will be persisted to settings file
by default this settings are taken from /etc/openproximity2/settings.xml
def __init__(self,peer):
self.cas = BasicCAS()
self.peer = peer
self.urlobj = urlparse(peer.url)
self.deserialize = get_deserializer('json')
from django.db import models
from django.http.response import Http404, HttpResponseBadRequest, HttpResponse, HttpResponseNotAllowed, HttpResponseForbidden
from django.core import serializers
import json
deseralizer = serializers.get_deserializer('extjson')
from extjs.forms import ReadForm
def user_is_staff(view_func):
def _wrapped_view(request, *args, **kwargs):
if request.user.is_staff:
return view_func(request, *args, **kwargs)
return HttpResponseForbidden()
return _wrapped_view
def _get_model_or_404(app, model):
model = models.get_model(app, model)
if model is None:
raise Http404()
return model
@user_is_staff
def read(request, app, model):
model = _get_model_or_404(app, model)
if request.method == "GET":
read = ReadForm(request.GET)
if read.is_valid():
query = model.objects.all()
def expander(cls, expandees):
if not hasattr(cls, '_expander'):
from django.core import serializers
cls._expander = staticmethod(
serializers.get_deserializer('python'))
return cls._expander(expandees)
parameters = clone.query.parameters
logger.debug(
u"""Retrieving : "%s" through %s
with parameters "%s" """
% (clone.model.__name__, resource.uri, force_unicode(parameters))
)
response = resource.get(**parameters)
except Exception, e:
raise ROAException(e)
response = force_unicode(response.body_string()).encode(DEFAULT_CHARSET)
for local_name, remote_name in ROA_MODEL_NAME_MAPPING:
response = response.replace(remote_name, local_name)
deserializer = serializers.get_deserializer(ROA_FORMAT)
if hasattr(deserializer, "deserialize_object"):
result = deserializer(response).deserialize_object(response)
else:
result = deserializer(response).next()
return result.object
def get(self, *args, **kwargs):
"""
Performs the query and returns a single object matching the given
keyword arguments.
"""
# special case, get(id=X) directly request the resource URL and do not
# filter on ids like Django's ORM do.
def clean_file(self):
stream = self.cleaned_data['file']
stream.seek(0)
deserializer = serializers.get_deserializer('json')
invalid_format = _(
"Invalid format: could not read or deserialize %(type)s")
try:
import_edition = next(deserializer(stream.readline())).object
except Exception:
raise ValidationError(invalid_format % {'type': "Edition"})
try:
edition = contest.models.Edition.objects.get(pk=import_edition.pk)
except contest.models.Edition.DoesNotExist:
raise ValidationError(_("Imported edition is invalid."))
try:
import_center = next(deserializer(stream.readline())).object
except Exception:
raise ValidationError(invalid_format % {'type': "Center"})
try:
center = contest.models.Center.objects.get(pk=import_center.pk)
except contest.models.Center.DoesNotExist:
raise ValidationError(_("Imported center is invalid."))
try:
import_event = next(deserializer(stream.readline())).object
except Exception:
raise ValidationError(invalid_format % {'type': "Event"})
try:
event = contest.models.Event.objects.get(pk=import_event.pk)
except contest.models.Event.DoesNotExist:
raise ValidationError(_("Imported event is invalid."))
if event.edition != edition or event.center != center:
raise ValidationError(
_("Imported event edition or center mismatches with known event."
))
try:
import_users = deserializer(stream.readline())
except Exception:
raise ValidationError(invalid_format % {'type': "User"})
user_pks = [user.object.pk for user in import_users]
if User.objects.filter(pk__in=user_pks).count() != len(user_pks):
raise ValidationError(_("Imported users mismatch."))
try:
import_contestants = [
item.object for item in deserializer(stream.readline())
]
except Exception:
raise ValidationError(invalid_format % {'type': "Contestant"})
contestant_pks = set(contestant.pk
for contestant in import_contestants)
challenge = event.challenge
our_contestants = {
contestant.pk: contestant
for contestant in (contest.models.Contestant.objects.filter(
pk__in=contestant_pks).select_related(
'edition', 'user', 'assignation_semifinal_event'))
}
contestants = [(contestant, our_contestants.get(contestant.pk))
for contestant in import_contestants]
try:
import_submissions = list(deserializer(stream.readline()))
import_codes = list(deserializer(stream.readline()))
import_explicitunlocks = list(deserializer(stream.readline()))
except Exception:
raise ValidationError(
invalid_format %
{'type': "Submission/SubmissionCode/ExplicitProblemUnlock"})
user_submissions = defaultdict(list)
for item in import_submissions:
user_submissions[item.object.user_id].append(item.object)
submission_codes = defaultdict(list)
for item in import_codes:
submission_codes[item.object.submission_id].append(item.object)
problem_unlocks = defaultdict(list)
for item in import_explicitunlocks:
problem_unlocks[(item.object.user_id,
item.object.problem)].append(item.object)
for contestant, our in contestants:
contestant.submissions = sorted(
user_submissions[contestant.user_id],
key=lambda s: challenge.problem(s.problem).difficulty)
contestant.score = sum(sub.score()
for sub in contestant.submissions)
for submission in contestant.submissions:
submission.all_codes = submission_codes[submission.id]
submission.code_count = len(submission.all_codes)
submission.unlock = problem_unlocks[(contestant.user_id,
submission.problem)]
contestants.sort(key=lambda pair: pair[0].score, reverse=True)
return SemifinalResults(event, contestants, import_submissions,
import_codes, import_explicitunlocks)
def expander(cls, expandees):
if not hasattr(cls, '_expander'):
from django.core import serializers
cls._expander = staticmethod(
serializers.get_deserializer('python'))
return cls._expander(expandees)
def __init__(self, peer):
self.cas = BasicCAS()
self.peer = peer
self.urlobj = urlparse(peer.url)
self.deserialize = get_deserializer('json')
def setUp(self):
XLSXDeserializer = serializers.get_deserializer("xlsx")
self.xlsx_deserializer = XLSXDeserializer(self._get_xlsx_stream())
def test_get_unkown_deserializer(self):
with self.assertRaises(SerializerDoesNotExist):
serializers.get_deserializer("nonsense")
except:
from agent.models import AgentRecord, AgentDeviceRecord, AgentMarketingCampaign
from agent.views import AGENT as SETTINGS
from poster.encode import multipart_encode
from poster.streaminghttp import register_openers
from itertools import chain
import gzip, httplib, mimetypes, urllib, urllib2, StringIO, os, time
register_openers()
serializer = serializers.get_serializer('json')()
#serializer.options={'indent': 4, 'subclass': True}
serialize=serializer.serialize
deserialize = serializers.get_deserializer('json')
HELP=r"""
Go through database and upload data to main server.
send_data_agent [options] [agent settings]
Agent Options: (settings=value)
server=AGENT_SERVER server to which we connect to
site_id=AGENT_SITEID siteID used to identify with the server
customer_id=AGENT_CUSTOMERID customerID used to identify with the
server
save_settings=[False] if present then any change to customer_id or
agent_id will be persisted to settings file
by default this settings are taken from /etc/openproximity2/settings.xml
