def file_to_string_iterable(self, cls, value):
if value.data is None:
if value.handle is None:
assert value.path is not None, "You need to write data to " \
"persistent storage first if you want to read it back."
try:
path = value.path
if not isabs(value.path):
path = join(value.store, value.path)
f = open(path, 'rb')
except IOError as e:
if e.errno == errno.ENOENT:
raise ResourceNotFoundError(value.path)
else:
raise InternalError("Error accessing requested file")
else:
f = value.handle
f.seek(0)
return _file_to_iter(f)
else:
if isinstance(value.data, (list,tuple)) and \
isinstance(value.data[0], mmap):
return _file_to_iter(value.data[0])
else:
return iter(value.data)
def update_movie(ctx, movie_id, title):
con = psycopg2.connect(con_str)
cur = con.cursor(cursor_factory=RealDictCursor)
cur.execute(
"""SELECT id, title FROM imdb_movies_api WHERE id = %(movie_id)s""",
{"movie_id": movie_id.zfill(7)})
res = cur.fetchall()
if len(res) == 0:
raise ResourceNotFoundError(faultstring='Not Found',
detail='Not Found')
movie = {
"id": movie_id,
"title": title if title else res[0]['title'],
}
for v in [('id', str), ('title', str)]:
if movie[v[0]] and not isinstance(movie[v[0]], v[1]):
raise InvalidInputError(faultstring='Bad Request',
detail='Bad Request')
cur.execute(
"""update imdb_movies_api set title=%(title)s where id=%(id)s""",
movie)
con.commit()
cur.close()
con.close()
return movie
def modify_user(user):
global user_database
if not (user.userid in user_database):
raise ResourceNotFoundError(user.userid)
user_database[user.userid] = user
def delete_user(userid):
global user_database
if not (userid in user_database):
raise ResourceNotFoundError(userid)
del user_database[userid]
def deserialize(self, ctx, message):
assert message in (self.REQUEST, self.RESPONSE)
self.event_manager.fire_event('before_deserialize', ctx)
if ctx.descriptor is None:
raise ResourceNotFoundError(ctx.method_request_string)
# instantiate the result message
if message is self.REQUEST:
body_class = unwrap_messages(ctx.descriptor.in_message,
self.skip_depth)
elif message is self.RESPONSE:
body_class = unwrap_messages(ctx.descriptor.out_message,
self.skip_depth)
if body_class:
# assign raw result to its wrapper, result_message
result_class = ctx.descriptor.in_message
value = ctx.in_body_doc.get(result_class.get_type_name(), None)
result_message = self._doc_to_object(result_class, value,
self.validator)
ctx.in_object = result_message
else:
ctx.in_object = []
self.event_manager.fire_event('after_deserialize', ctx)
def file_to_bytes_iterable(self, cls, value, **_):
if value.data is not None:
if isinstance(value.data, (list, tuple)) and \
isinstance(value.data[0], mmap):
return _file_to_iter(value.data[0])
return iter(value.data)
if value.handle is not None:
f = value.handle
f.seek(0)
return _file_to_iter(f)
assert value.path is not None, "You need to write data to " \
"persistent storage first if you want to read it back."
try:
path = value.path
if not isabs(value.path):
path = join(value.store, value.path)
assert abspath(path).startswith(value.store), \
"No relative paths are allowed"
return _file_to_iter(open(path, 'rb'))
except IOError as e:
if e.errno == errno.ENOENT:
raise ResourceNotFoundError(value.path)
else:
raise InternalError("Error accessing requested file")
def call_wrapper(self, ctx):
"""This method calls the call_wrapper method in the service definition.
This can be overridden to make an application-wide custom exception
management.
"""
if ctx.descriptor.body_style is BODY_STYLE_BARE:
ctx.in_object = [ctx.in_object]
elif ctx.descriptor.body_style is BODY_STYLE_EMPTY:
ctx.in_object = []
# service rpc
if ctx.descriptor.service_class is not None:
return ctx.descriptor.service_class.call_wrapper(ctx)
# class rpc
cls = ctx.descriptor.parent_class
if cls.__orig__ is not None:
cls = cls.__orig__
inst = cls.__respawn__(ctx)
if inst is None:
raise ResourceNotFoundError(
'{%s}%s' % (cls.get_namespace(), cls.get_type_name()))
args = ctx.in_object[1:]
if ctx.function is not None:
if ctx.descriptor.no_ctx:
return ctx.function(inst, *args)
else:
return ctx.function(inst, ctx, *args)
def deserialize(self, ctx, message):
assert message in (self.REQUEST, )
self.event_manager.fire_event('before_deserialize', ctx)
if ctx.descriptor is None:
raise ResourceNotFoundError(ctx.method_request_string)
req_enc = getattr(ctx.transport, 'request_encoding', None)
if req_enc is None:
req_enc = ctx.in_protocol.default_string_encoding
if ctx.descriptor.in_header is not None:
# HttpRpc supports only one header class
in_header_class = ctx.descriptor.in_header[0]
ctx.in_header = self.simple_dict_to_object(ctx.in_header_doc,
in_header_class,
self.validator,
req_enc=req_enc)
if ctx.descriptor.in_message is not None:
ctx.in_object = self.simple_dict_to_object(
ctx.in_body_doc,
ctx.descriptor.in_message,
self.validator,
req_enc=req_enc)
self.event_manager.fire_event('after_deserialize', ctx)
def update_book_copies(ctx, isbn, copies):
try:
book = BookModel.objects.filter(isbn=isbn).first()
book.copies += copies
book.save()
except BookModel.DoesNotExist:
raise ResourceNotFoundError('Book')
def generate_method_contexts(self, ctx):
"""Generates MethodContext instances for every callable assigned to the
given method handle.
The first element in the returned list is always the primary method
context whereas the rest are all auxiliary method contexts.
"""
call_handles = self.get_call_handles(ctx)
if len(call_handles) == 0:
raise ResourceNotFoundError('Method %r not found.' %
ctx.method_request_string)
retval = []
for sc, d in call_handles:
c = copy(ctx)
assert d != None
c.descriptor = d
c.service_class = sc
retval.append(c)
return retval
def deserialize(self, ctx, message):
assert message in (self.REQUEST, self.RESPONSE)
self.event_manager.fire_event('before_deserialize', ctx)
if ctx.descriptor is None:
raise ResourceNotFoundError(ctx.method_request_string)
# instantiate the result message
if message is self.REQUEST:
body_class = ctx.descriptor.in_message
elif message is self.RESPONSE:
body_class = ctx.descriptor.out_message
if body_class:
# assign raw result to its wrapper, result_message
doc = ctx.in_body_doc
class_name = self.get_class_name(body_class)
if self.ignore_wrappers:
doc = doc.get(class_name, None)
result_message = self._doc_to_object(body_class, doc,
self.validator)
ctx.in_object = result_message
else:
ctx.in_object = []
self.event_manager.fire_event('after_deserialize', ctx)
def faz_jogada(ctx, id, username, password, jogada, cidade, cor):
try:
session = Session.objects.get(session_hash=id)
session_state = SessionState.objects.get(session=session)
city = City.objects.get(name=cidade)
city_state = CityState.objects.get(session=session_state,
city=city)
res = ''
user = authenticate(username=username, password=password)
if user is not None:
player_state = PlayerState.objects.get(session=session_state,
user=user.id)
http_request = HttpRequest()
http_request.user = user
http_request.method = "POST"
if jogada == 'move':
http_request.POST = QueryDict.fromkeys(['city'],
value=city.id)
request = Request(http_request)
request.user = user
response = update_player_state(request, player_state.id,
session.session_hash)
res = "Aceite" if response.status_code == 200 else "Não aceite"
elif jogada == 'treat':
key = []
value = 0
if cor == "Black":
key.append('black_cubes')
value = city_state.black_cubes - 1
elif cor == "Yellow":
key.append("yellow_cubes")
value = city_state.yellow_cubes - 1
elif cor == "Red":
key.append("red_cubes")
value = city_state.red_cubes - 1
else:
key.append("blue_cubes")
value = city_state.blue_cubes - 1
http_request.POST = QueryDict.fromkeys(key, value=value)
request = Request(http_request)
request.user = user
response = update_city_state(request, city_state.id,
session.session_hash)
res = "Aceite" if response.status_code == 200 else "Não aceite"
else:
http_request.POST = QueryDict.fromkeys(
['research_station'], value=True)
request = Request(http_request)
request.user = user
response = update_city_state(request, city_state.id,
session.session_hash)
res = "Aceite" if response.status_code == 200 else "Não aceite"
return res
else:
raise InvalidCredentialsError('User')
except ObjectDoesNotExist:
raise ResourceNotFoundError('Session')
def set_method_descriptor(self, ctx):
"""DEPRECATED! Use :func:`generate_method_contexts` instead.
Method to be overriden to perform any sort of custom matching between
the method_request_string and the methods.
"""
name = ctx.method_request_string
if not name.startswith("{"):
name = '{%s}%s' % (self.app.interface.get_tns(), name)
ctx.service_class = self.app.interface.service_mapping.get(name, None)
if ctx.service_class is None:
raise ResourceNotFoundError('Method %r not bound to a service class.'
% name)
ctx.descriptor = ctx.app.interface.method_mapping.get(name, None)
if ctx.descriptor is None:
raise ResourceNotFoundError('Method %r not found.' % name)
def call_wrapper(self, ctx):
"""This is the application-wide exception transforming function."""
try:
return Application.call_wrapper(self, ctx)
except NoResultFound, e:
logger.exception(e)
ctx.out_string = ["Resource not found"]
raise ResourceNotFoundError() # Return HTTP 404
def call_wrapper(self, ctx):
try:
return ctx.service_class.call_wrapper(ctx)
except NoResultFound:
raise ResourceNotFoundError(ctx.in_object)
except Fault, e:
logging.error(e)
raise
def get_movie(ctx, movie_id):
con = psycopg2.connect(con_str)
cur = con.cursor(cursor_factory=RealDictCursor)
cur.execute(
"""SELECT id, title FROM imdb_movies_api WHERE id = %(movie_id)s""",
{"movie_id": movie_id.zfill(7)})
res = cur.fetchall()
cur.close()
con.close()
if len(res) == 0:
raise ResourceNotFoundError(faultstring='Not Found',
detail='Not Found')
return res
def _wrap(*args, **kwargs):
self = args[0]
try:
retval = f(*args, **kwargs)
self.session.expunge_all()
return retval
except NoResultFound:
raise ResourceNotFoundError(self.ctx.in_object)
except Fault, e:
log.err()
raise
def get_user(userid):
global user_database
# If rely on dict lookup raising KeyError here, you'll return an
# internal error to the client, which tells the client that there's
# something wrong in the server. However in this case, KeyError means
# invalid request, so it's best to return a client error.
# For the HttpRpc case, internal error is 500 whereas
# ResourceNotFoundError is 404.
if not (userid in user_database):
raise ResourceNotFoundError(userid)
return user_database[userid]
def devolve_book_loan(ctx, isbn):
try:
book = BookModel.objects.filter(isbn=isbn).first()
except BookModel.DoesNotExist:
raise ResourceNotFoundError('Book')
book_loan = BookLoanModel.objects.filter(
book=book,
return_date=None
).last()
book_loan.return_date = datetime.datetime.now()
book_loan.save()
return book_loan
def call_wrapper(self, ctx):
try:
return ctx.service_class.call_wrapper(ctx)
except NoResultFound:
raise ResourceNotFoundError(ctx.in_object)
except Fault as e:
log.err()
raise
except Exception as e:
log.err()
# This should not happen! Let the team know via email!
if EXCEPTION_ADDRESS:
email_exception(EXCEPTION_ADDRESS)
raise InternalError(e)
def info_jogo(ctx, session_hash):
try:
session = Session.objects.get(session_hash=session_hash)
session_state = SessionState.objects.get(session=session)
city_states = CityState.objects.all().filter(session=session_state)
player_states = PlayerState.objects.all().filter(
session=session_state)
res = {'research_centers': {}, 'players': {}, 'cities': {}}
for city_state in city_states:
city = city_state.city
if city_state.black_cubes > 0 or city_state.yellow_cubes > 0 or city_state.red_cubes > 0 or city_state.blue_cubes > 0:
res['cities'][city.name.replace(' ', '_')] = {}
if city_state.black_cubes > 0:
res['cities'][city.name.replace(
' ', '_')]['Black_Disease'] = city_state.black_cubes
if city_state.yellow_cubes > 0:
res['cities'][city.name.replace(
' ', '_')]['Yellow_Disease'] = city_state.yellow_cubes
if city_state.red_cubes > 0:
res['cities'][city.name.replace(
' ', '_')]['Red_Disease'] = city_state.red_cubes
if city_state.blue_cubes > 0:
res['cities'][city.name.replace(
' ', '_')]['Blue_Disease'] = city_state.blue_cubes
if city_state.research_station:
res['research_centers'][city.name.replace(' ', '_')] = {}
for player in player_states:
player_city = player.city
user = player.user
res['players'][user.username] = {
'position': player_city.name,
'neighbour_cities': {}
}
all_neighbours = player_city.connections.all()
for city in all_neighbours:
res['players'][user.username]['neighbour_cities'][
city.name.replace(' ', '_')] = {}
print(res)
return res
except ObjectDoesNotExist:
raise ResourceNotFoundError('Session')
def CreateEvent(ctx, CreateEventInput: EventTicketRequest):
create_event_url = ctx.udc.create_event_url
# Get auth_key, event, list section, callback URL
auth_key = ctx.udc.token
event = CreateEventInput.event
list_section = CreateEventInput.list_section
callback_type = CreateEventInput.callback_type
callback = CreateEventInput.callback
# Create payload and request to create_event_url
payload = create_request(event, list_section, callback, callback_type,
auth_key)
camunda_resp = requests.post(create_event_url, json=payload)
if camunda_resp.status_code == 404:
raise ResourceNotFoundError(camunda_resp)
elif not camunda_resp.ok:
raise InternalError(Exception("Spyne Server Error"))
return EventTicketResp(
200,
"Processing your input. Detail will be given to your callback URL")
def put_user(ctx, user):
if user.id is None:
ctx.udc.session.add(user)
ctx.udc.session.flush() # so that we get the user.id value
else:
if ctx.udc.session.query(User).get(user.id) is None:
# this is to prevent the client from setting the primary key
# of a new object instead of the database's own primary-key
# generator.
# Instead of raising an exception, you can also choose to
# ignore the primary key set by the client by silently doing
# user.id = None
raise ResourceNotFoundError('user.id=%d' % user.id)
else:
ctx.udc.session.merge(user)
return user.id
def deserialize(self, ctx, message):
assert message in (self.REQUEST,)
self.event_manager.fire_event('before_deserialize', ctx)
if ctx.descriptor is None:
raise ResourceNotFoundError(ctx.method_request_string)
if ctx.descriptor.in_header is not None:
# HttpRpc supports only one header class
in_header_class = ctx.descriptor.in_header[0]
ctx.in_header = self.flat_dict_to_object(ctx.in_header_doc,
in_header_class, self.validator)
if ctx.descriptor.in_message is not None:
ctx.in_object = self.flat_dict_to_object(ctx.in_body_doc,
ctx.descriptor.in_message, self.validator)
self.event_manager.fire_event('after_deserialize', ctx)
def deserialize(self, ctx, message):
assert message in (self.REQUEST, self.RESPONSE)
self.event_manager.fire_event('before_deserialize', ctx)
if ctx.descriptor is None:
raise ResourceNotFoundError(ctx.method_request_string)
if ctx.protocol.error:
ctx.in_object = None
ctx.in_error = self._doc_to_object(ctx, Fault, ctx.in_body_doc)
else:
if message is self.REQUEST:
header_class = ctx.descriptor.in_header
body_class = ctx.descriptor.in_message
elif message is self.RESPONSE:
header_class = ctx.descriptor.out_header
body_class = ctx.descriptor.out_message
# decode header objects
if (ctx.in_header_doc is not None and header_class is not None):
headers = [None] * len(header_class)
for i, (header_doc, head_class) in enumerate(
zip(ctx.in_header_doc, header_class)):
if header_doc is not None and i < len(header_doc):
headers[i] = self._doc_to_object(ctx, head_class,
header_doc)
if len(headers) == 1:
ctx.in_header = headers[0]
else:
ctx.in_header = headers
# decode method arguments
if ctx.in_body_doc is None:
ctx.in_object = [None] * len(body_class._type_info)
else:
ctx.in_object = self._doc_to_object(ctx, body_class,
ctx.in_body_doc)
self.event_manager.fire_event('after_deserialize', ctx)
def get(ctx, file_name):
path = os.path.join(os.path.abspath('./files'), file_name)
if not path.startswith(os.path.abspath('./files')):
raise ValidationError(file_name)
try:
f = open(path, 'r')
except IOError:
raise ResourceNotFoundError(file_name)
ctx.transport.resp_headers['Content-Disposition'] = (
'attachment; filename=%s;' % file_name)
data = f.read(BLOCK_SIZE)
while len(data) > 0:
yield data
data = f.read(BLOCK_SIZE)
f.close()
def _wrap(*args, **kwargs):
self = args[0]
try:
retval = f(*args, **kwargs)
self.session.expunge_all()
return retval
except NoResultFound:
raise ResourceNotFoundError(self.ctx.in_object)
except Fault as e:
log.err()
raise
except Exception as e:
log.err()
# This should not happen! Let the team know via email!
email_exception(EXCEPTION_ADDRESS)
raise InternalError(e)
def __init__(self, value):
ResourceNotFoundError.__init__(self,
faultstring='Value %r not found' % value
)
def del_user(ctx, user_id):
count = ctx.udc.session.query(User).filter_by(id=user_id).count()
if count == 0:
raise ResourceNotFoundError(user_id)
ctx.udc.session.query(User).filter_by(id=user_id).delete()
def get_container(ctx, pk):
try:
return FieldContainer.objects.get(pk=pk)
except FieldContainer.DoesNotExist:
raise ResourceNotFoundError('Container_submitseq')
def del_(ctx, obj_id):
count = ctx.udc.session.query(T).filter_by(id=obj_id).count()
if count == 0:
raise ResourceNotFoundError(obj_id)
ctx.udc.session.query(T).filter_by(id=obj_id).delete()
