def registry_get(request, name, doc_type, *args, **kwargs):
registry = import_object(settings.REGISTRY)
try:
obj = registry.get(name, doc_type)
except (KeyError,):
return jolly.http.HttpResponseNotFound({'error': 'not found'})
out = import_object(settings.OUTPUT_CONVERTER)
result = jolly.json_encode.encode(obj, out)
return result
def get(request, root_id, *args, **kwargs):
db = import_object(settings.DB)
try:
root = db.restore(root_id)
doc_id = kwargs.get('doc_id', root_id)
type_ = import_object(kwargs['doc_type'])
path = kwargs.get('path', ())
obj = db.get_obj(doc_id)
if obj is None:
return jolly.http.HttpResponseNotFound({'error': 'cannot restore 1'})
def follow_path(obj):
for p in path:
obj = p(obj)
if obj is None:
return obj
return obj
if isinstance(obj, list):
obj = [follow_path(o) for o in obj]
if any(o is None for o in obj):
return jolly.http.HttpResponseNotFound({'error': 'cannot restore 2'})
else:
obj = follow_path(obj)
if obj is None:
return jolly.http.HttpResponseNotFound({'error': 'cannot restore 2'})
except (KeyError, ImportError):
return jolly.http.HttpResponseNotFound({'error': 'cannot restore 3'})
if isinstance(obj, list):
if any(not isinstance(o, type_) for o in obj):
return jolly.http.HttpResponseNotFound({'error': 'bad type'})
else:
if not isinstance(obj, type_):
return jolly.http.HttpResponseNotFound({'error': 'bad type'})
user = request.user
if kwargs.get('private_view', False):
if isinstance(obj, list):
if any(not user.is_owner(o) for o in obj):
return jolly.http.HttpResponseUnauthorized(settings.AUTHENTICATION_REALM)
else:
if not user.is_owner(obj):
return jolly.http.HttpResponseUnauthorized(settings.AUTHENTICATION_REALM)
def is_visible(obj):
return not getattr(obj, 'private', False) or user.is_owner(obj)
out = import_object(settings.OUTPUT_CONVERTER)
result = jolly.json_encode.encode(obj, out)
return result
def post_breakpoint(request, *args, **kwargs):
import jolly.core
player_doc_id = request.GET['player']
db = jolly.db.create_database()
try:
player = db.restore_object(player_doc_id)
except KeyError:
return jolly.http.HttpResponseNotFound({'error': 'cannot restore'})
if not isinstance(player, jolly.core.Player):
return jolly.http.HttpResponseNotFound({'error': 'bad type'})
user = request.user
if not user.is_owner(player):
return jolly.http.HttpResponseUnauthorized(settings.AUTHENTICATION_REALM)
# Convert the data from XML/JSON to a Python dict
try:
data = json.loads(request.raw_post_data)
except ValueError:
return jolly.http.HttpResponseBadRequest()
value_resolver = import_object(settings.VALUE_RESOLVER)
breakpoint_types = dict((getattr(v, 'action_type'), v)
for v in dict((n, getattr(jolly.breakpoint, n))
for n in dir(jolly.breakpoint)).values()
if isinstance(v, type)
and hasattr(v, 'action_type'))
try:
type_ = breakpoint_types.setdefault(data['action-type'],
jolly.breakpoint.BreakPoint)
import inspect
args = inspect.getargspec(type_.__init__).args[2:]
parsed_args = {}
for arg in args:
parsed_args[arg] = value_resolver.resolve(data[arg.replace('_', '-')])
breakpoint = type_(player, **parsed_args)
except KeyError as exc:
return jolly.http.HttpResponseBadRequest({'error': str(exc)})
player.breakpoints.append(breakpoint)
db.dirty(player)
db.store_object(player)
url_resolver = import_object(settings.URL_RESOLVER)
return jolly.http.HttpResponseRedirect(url_resolver.get_url(breakpoint))
def delete_breakpoint(request, doc_id, *args, **kwargs):
import jolly.breakpoint
db = jolly.db.create_database()
try:
breakpoint = db.restore_object(doc_id)
except KeyError:
return jolly.http.HttpResponseNotFound({'error': 'cannot restore'})
if not isinstance(breakpoint, jolly.breakpoint.BreakPoint):
return jolly.http.HttpResponseNotFound({'error': 'bad type'})
user = request.user
if not user.is_owner(breakpoint):
return jolly.http.HttpResponseUnauthorized(settings.AUTHENTICATION_REALM)
try:
breakpoint.owner.breakpoints.remove(breakpoint)
except ValueError:
pass # DELETE is idempotent
else:
db.delete_object(doc_id)
game = breakpoint.owner.game
game.advance()
db.dirty_all()
db.store_object(game)
url_resolver = import_object(settings.URL_RESOLVER)
return jolly.http.HttpResponseRedirect('/{0}'.format(url_resolver.get_query_url_by_name('breakpoints', {'player': db.get_doc_id(breakpoint.owner)})))
def get(self, key, class_=None):
if class_:
if isinstance(class_, basestring):
class_ = import_object(class_)
return self.registry[class_][key]
items = self.lookup[key]
if len(items) == 1:
return list(items)[0]
raise KeyError(key)
def execute(self, command, env=None):
unit = command.arguments['unit']
speed_plot = command.arguments['speed-plot']
unit.properties['speed-plot'] = speed_plot
actions = [command.create_action('property-change', unit, '{0} changes speed plot'.format(unit.id), {'speed-plot': speed_plot}, True)]
actions.extend(super(ShuttleDetermineInitialSpeed, self).execute(command, env))
registry = import_object(settings.REGISTRY)
move = registry.get('move')
for impulse in speed_plot:
time = get_moment(command.time.turn, impulse, move.step)
cmd = Command(command.owner, move, time, {'unit': unit})
cmd.insert_into_queue(command.queue)
actions.append(command.create_action('queue-command', unit, "{0} queued 'Move' command at {1}".format(unit.id, time), {'command': cmd}, True))
return actions
def get_many(request, *args, **kwargs):
db = import_object(settings.DB)
query = kwargs.get('query', [])
where = []
for k in query:
if k in request.GET:
where.extend([k, request.GET[k]])
try:
view_name = settings.QUERY_VIEWS[kwargs['doc_type']]
objs = db.restore_view(view_name, where)
except (KeyError, ImportError):
return jolly.http.HttpResponseNotFound({'error': 'not found'})
user = request.user
if kwargs.get('private_view', False) and not all(user.is_owner(o) for o in obj):
return jolly.http.HttpResponseUnauthorized(settings.AUTHENTICATION_REALM)
def is_visible(obj):
return not getattr(obj, 'private', False) or user.is_owner(obj)
out = import_object(settings.OUTPUT_CONVERTER)
result = jolly.json_encode.encode(objs, out)
return result
def put_command(request, doc_id, *args, **kwargs):
import jolly.command
db = jolly.db.create_database()
try:
command = db.restore_object(doc_id)
except KeyError:
return jolly.http.HttpResponseNotFound({'error': 'cannot restore'})
if not isinstance(command, jolly.command.Command):
return jolly.http.HttpResponseNotFound({'error': 'bad type'})
user = request.user
if not user.is_owner(command):
return jolly.http.HttpResponseUnauthorized(settings.AUTHENTICATION_REALM)
# Convert the data from JSON to a Python dict
try:
data = json.loads(request.raw_post_data)
request_arguments = data['arguments']
except (KeyError, ValueError):
return jolly.http.HttpResponseBadRequest()
# Determine the arguments
value_resolver = import_object(settings.VALUE_RESOLVER)
arguments = {}
for pname, pvalue in request_arguments.items():
try:
arguments[pname] = value_resolver.resolve(pvalue)
except ValueError:
pass
try:
command.update_arguments(arguments)
except jolly.command.ArgumentException as e:
return jolly.http.HttpResponseBadRequest({'error': str(e.problems.keys())})
else:
game = command.owner.game
game.advance()
db.dirty_all()
db.store_object(game)
return jolly.http.HttpResponseRedirect(doc_id)
import os os.environ['DJANGO_SETTINGS_MODULE'] = 'test.settings' from django.conf import settings from jolly.util import import_object value_resolver = import_object(settings.VALUE_RESOLVER)
from django.conf import settings
from jolly.util import import_object
import jolly.core
import jolly.map
import sfb.movement
import setup
value_resolver = import_object(settings.VALUE_RESOLVER)
registry = import_object(settings.REGISTRY)
sequence_of_play = import_object(settings.SEQUENCE_OF_PLAY)
choice = import_object(settings.RANDOMIZER)
u = jolly.core.User('user1', '*****@*****.**', 'password1')
s = registry.get('admin-shuttle').create_system('shuttle1', {'speed-plot': sfb.movement.make_speed_plot(6), 'position': jolly.map.Position(jolly.map.HexLocation.parse('1012'), jolly.map.hexcompass.get('A'))})
p = jolly.core.Player('player1', [s])
p.owner = u
m = jolly.map.Map([42, 30])
g = jolly.core.Game('Test Game', sequence_of_play, m, [p], choice)
import sfb.command
import jolly.map
import sfb.chrono
import jolly.command
import jolly.breakpoint
ct1 = registry.get('shuttle-determine-initial-speed')
c1 = jolly.command.Command(p, ct1, sfb.chrono.get_moment(0, None, ct1.step), {'unit': s, 'speed-plot': sfb.movement.make_speed_plot(6)})
c1.insert_into_queue(p.queue, g)
def post_command(request, doc_id, *args, **kwargs):
import jolly.command
db = jolly.db.create_database()
try:
queue = db.restore_object(doc_id)
except KeyError:
return jolly.http.HttpResponseNotFound({'error': 'cannot restore'})
if not isinstance(queue, jolly.command.CommandQueue):
return jolly.http.HttpResponseNotFound({'error': 'bad type'})
user = request.user
if not user.is_owner(queue):
return jolly.http.HttpResponseUnauthorized(settings.AUTHENTICATION_REALM)
# Convert the data from XML/JSON to a Python dict
try:
data = json.loads(request.raw_post_data)
except ValueError:
return jolly.http.HttpResponseBadRequest()
value_resolver = import_object(settings.VALUE_RESOLVER)
# Ensure that a valid template is present
try:
template = value_resolver.resolve(data['template'])
if not isinstance(template, jolly.command.CommandTemplate):
return jolly.http.HttpResponseBadRequest({'error': 'template'})
except KeyError:
return jolly.http.HttpResponseBadRequest({'error': 'template'})
# Determine the parameters that have been set
try:
request_arguments = data['arguments']
except KeyError:
request_arguments = {}
response_arguments = {}
# Determine the time
try:
time = value_resolver.resolve(request_arguments['time'])
response_arguments['time'] = time
del request_arguments['time']
except KeyError:
response_arguments['time'] = None
except ValueError:
response_arguments['time'] = None
del request_arguments['time']
# Determine the issuer
issuer = queue.owner
# Determine the arguments
arguments = {}
for pname, pvalue in request_arguments.items():
try:
arguments[pname] = value_resolver.resolve(pvalue)
response_arguments[pname] = arguments[pname]
except ValueError:
pass
command = jolly.command.Command(issuer, template, time, arguments)
try:
command.insert_into_queue(queue)
except jolly.command.CommandException as e:
return jolly.http.HttpResponseBadRequest({'error': str(e.problems.keys())})
else:
db.dirty(queue)
db.store_object(queue)
url_resolver = import_object(settings.URL_RESOLVER)
return jolly.http.HttpResponseRedirect(url_resolver.get_url(command))
def root(request):
urlresolver = import_object(settings.URL_RESOLVER)
result = {'type': 'root',
'games': {'type': 'collection', 'href': urlresolver.get_query_url_by_name('games')},
'users': {'type': 'collection', 'href': urlresolver.get_query_url_by_name('users')}}
return result
