def __init__(self, username): # TODO: self.transport.http.resp_code = HTTP_401 Fault.__init__( self, faultcode='Client.LoginUnsupported', faultstring='Login Unsupported for non free user %r' % username)
def _from_soap(in_envelope_xml, xmlids=None, **kwargs): """Parses the xml string into the header and payload. """ ns_soap = kwargs.pop('ns', ns.NS_SOAP11_ENV) if xmlids: resolve_hrefs(in_envelope_xml, xmlids) if in_envelope_xml.tag != '{%s}Envelope' % ns_soap: raise Fault('Client.SoapError', 'No {%s}Envelope element was found!' % ns_soap) header_envelope = in_envelope_xml.xpath('e:Header', namespaces={'e': ns_soap}) body_envelope = in_envelope_xml.xpath('e:Body', namespaces={'e': ns_soap}) if len(header_envelope) == 0 and len(body_envelope) == 0: raise Fault('Client.SoapError', 'Soap envelope is empty!') header = None if len(header_envelope) > 0: header = header_envelope[0].getchildren() body = None if len(body_envelope) > 0 and len(body_envelope[0]) > 0: body = body_envelope[0][0] return header, body
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 Fault("Client", "Method %r not found." % 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 else: raise Exception("what?") if ctx.in_error: ctx.in_error = Fault(**ctx.in_error) elif body_class: ctx.in_object = self._doc_to_object(body_class, ctx.in_body_doc, self.validator) else: ctx.in_object = [] self.event_manager.fire_event('after_deserialize', ctx)
def update_whois_info(id, wInfo): for entry in EntryContainer.entries: if entry.id == id: for contact in wInfo.contacts: if contactparser.contact_exists(contact.id): res, status = contactparser.edit_contact( contact.id, contact) if status != 200: raise Fault( faultcode="Server", faultstring= "Internal error when updating contacts!") else: res, status = contactparser.add_contact(contact) if status != 201: raise Fault(faultcode="Server", faultstring= "Internal error when adding contacts!") entry.id = wInfo.id entry.website = wInfo.website entry.ipaddress = wInfo.ipaddress entry.contacts = wInfo.contacts return wInfo raise Fault(faultcode="Client", faultstring="Could not find entry with given id!")
def __init__(self, obj, custom_msg='The value %r could not be validated.'): s = repr(obj) if len(s) > MAX_STRING_FIELD_LENGTH: s = s[:MAX_STRING_FIELD_LENGTH] + "(...)" Fault.__init__(self, 'Client.ValidationError', custom_msg % s)
def __init__(self): # TODO: self.transport.http.resp_code = HTTP_401 Fault.__init__(self, faultcode='Client.AuthorizationError', faultstring='You are not authorized to access this resource.' )
def changeMovieSoap(Id, Title, Genre, Release_date, Rating, Album_ID): try: r = requests.get('http://web1:81/albums/' + Album_ID) if r.status_code == 200 and re.search('^[0-9]?$', Id): movies[int(Id)]['Title'] = Title movies[int(Id)]['Genre'] = Genre movies[int(Id)]['Rating'] = Rating movies[int(Id)]['Release_date'] = Release_date movies[int(Id)]['Album_ID'] = Album_ID movie = movies[int(Id)] else: raise Fault(faultcode='Client', faultstring='', faultactor='', detail={ 'Message': 'Error. Service Albums status is not 200.' }) return Movie(ID=movie["ID"], Title=movie["Title"], Genre=movie["Genre"], Rating=movie["Rating"], Release_date=movie["Release_date"], Album_ID=movie["Album_ID"]) except: raise Fault( faultcode='Client', faultstring='', faultactor='', detail={'Message': 'Error. Service Albums is not available.'})
def __init__(self, user_name): # TODO: self.transport.http.resp_code = HTTP_401 Fault.__init__(self, faultcode='Client.AuthenticationError', faultstring='Invalid authentication request for %r' % user_name )
def __init__(self): Fault.__init__( self, faultcode="Documented", faultstring="A documented fault", faultactor='http://faultactor.example.com', )
def _from_soap(in_envelope_xml, xmlids=None): '''Parses the xml string into the header and payload.''' if xmlids: resolve_hrefs(in_envelope_xml, xmlids) if in_envelope_xml.tag != '{%s}Envelope' % ns.soap_env: raise Fault('Client.SoapError', 'No {%s}Envelope element was found!' % ns.soap_env) header_envelope = in_envelope_xml.xpath('e:Header', namespaces={'e': ns.soap_env}) body_envelope = in_envelope_xml.xpath('e:Body', namespaces={'e': ns.soap_env}) if len(header_envelope) == 0 and len(body_envelope) == 0: raise Fault('Client.SoapError', 'Soap envelope is empty!' % ns.soap_env) header = None if len(header_envelope) > 0: header = header_envelope[0].getchildren() body = None if len(body_envelope) > 0 and len(body_envelope[0]) > 0: body = body_envelope[0][0] return header, body
def __init__(self): Fault.__init__(self, faultcode="Documented", faultstring="A documented fault", faultactor='http://faultactor.example.com', detail=etree.Element('something') )
def change_password(ctx, UserName, Password): token = ctx.in_header.Token user_name = ctx.in_header.UserName if all([user_name, token]): result = handlers.change_password(UserName, Password, token) if result['result']: return result['message'] raise Fault(result['side'], result['message']) raise Fault('Client', 'Нет прав доступа.')
def set_stock_price(ctx, StockName, Price): user_name = ctx.in_header.UserName token = ctx.in_header.Token if all([user_name, token]): result = handlers.set_stock_price(user_name, token, StockName, Price) if result['result']: return result['message'] raise Fault(result['side'], result['message']) raise Fault('Client', 'Нет прав доступа.')
def find_infraction(self, id): try: infraction = Infraction.objects.get(pk=id) return infraction except IntegrityError as e: raise Fault(faultcode=str(e.args[0]), faultstring=e.args[1]) except Infraction.DoesNotExist: raise Fault(faultcode='404', faultstring=str('Infraction not exist'))
def get_whois_info(id): if id == None: raise Fault(faultcode="Client", faultstring="'id' field is empty") for entry in EntryContainer.entries: if entry.id == id: entry.updateContactList() return entry raise Fault(faultcode="Client", faultstring="Entry not found with given id!")
def find_municipality(self, id): try: municipality = Municipality.objects.get(pk=id) return municipality except IntegrityError as e: raise Fault(faultcode=str(e.args[0]), faultstring=e.args[1]) except Municipality.DoesNotExist: raise Fault(faultcode='404', faultstring=str('Municipality not exist'))
def _handle_rpc_body(self, p_ctx) -> typing.Optional[Fault]: """ Do the heavy lifting of the request handling here. This can be run in a thread. """ self.get_in_object(p_ctx) if p_ctx.in_error: logger.error(p_ctx.in_error) return p_ctx.in_error self.get_out_object(p_ctx) if p_ctx.out_error: logger.error(p_ctx.out_error) return p_ctx.out_error try: self.get_out_string(p_ctx) except Exception as e: p_ctx.out_error = Fault("Server", get_fault_string_from_exception(e)) logger.exception(p_ctx.out_error, exc_info=e) return p_ctx.out_error have_protocol_headers = (isinstance(p_ctx.out_protocol, HttpRpc) and p_ctx.out_header_doc is not None) if have_protocol_headers: p_ctx.transport.resp_headers.update(p_ctx.out_header_doc) return None
def handle_rpc(self, request, *args, **kwargs): """Handle rpc request. :params request: Django HttpRequest instance. :returns: HttpResponse instance. """ contexts = self.get_contexts(request) p_ctx, others = contexts[0], contexts[1:] if p_ctx.in_error: return self.handle_error(p_ctx, others, p_ctx.in_error) self.get_in_object(p_ctx) if p_ctx.in_error: logger.error(p_ctx.in_error) return self.handle_error(p_ctx, others, p_ctx.in_error) self.get_out_object(p_ctx) if p_ctx.out_error: return self.handle_error(p_ctx, others, p_ctx.out_error) try: self.get_out_string(p_ctx) except Exception, e: logger.exception(e) p_ctx.out_error = Fault('Server', get_fault_string_from_exception(e)) return self.handle_error(p_ctx, others, p_ctx.out_error)
def decompose_incoming_envelope(self, ctx, message): """Sets ``ctx.in_body_doc``, ``ctx.in_header_doc`` and ``ctx.method_request_string`` using ``ctx.in_document``. """ assert message in (ProtocolBase.REQUEST, ProtocolBase.RESPONSE) # set ctx.in_header ctx.transport.in_header_doc = None # use an rpc protocol if you want headers. doc = ctx.in_document ctx.in_header_doc = None ctx.in_body_doc = doc if len(doc) == 0: raise Fault("Client", "Empty request") logger.debug('\theader : %r' % (ctx.in_header_doc)) logger.debug('\tbody : %r' % (ctx.in_body_doc)) if not isinstance(doc, dict) or len(doc) != 1: raise ValidationError("Need a dictionary with exactly one key " "as method name.") mrs, = doc.keys() ctx.method_request_string = '{%s}%s' % (self.app.interface.get_tns(), mrs)
def _parse_xml_string(xml_string, parser, charset=None): xml_string = iter(xml_string) chunk = next(xml_string) if isinstance(chunk, six.binary_type): string = b''.join(chain((chunk, ), xml_string)) else: string = ''.join(chain((chunk, ), xml_string)) if charset: string = string.decode(charset) try: try: root, xmlids = etree.XMLID(string, parser) except ValueError as e: logger.debug('ValueError: Deserializing from unicode strings with ' 'encoding declaration is not supported by lxml.') root, xmlids = etree.XMLID(string.encode(charset), parser) except XMLSyntaxError as e: logger_invalid.error("%r in string %r", e, string) raise Fault('Client.XMLSyntaxError', str(e)) return root, xmlids
def delete_whois_info(id): for entry in EntryContainer.entries: if entry.id == id: EntryContainer.entries.remove(entry) return "Item deleted!" raise Fault(faultcode="Client", faultstring="Entry not found with given id!")
def add_infraction(self, infraction): data = infraction.as_dict() try: inf = Infraction.objects.create(**data) sendmailnotification = Sendmail() sendmailnotification.send_mail( mail_list=[data['offender_mail']], subject='Multa de Transito - Simit Services', template='infraction_mail', offender_name=str(inf.offender_name), infraction_id=str(inf.id), date=str(inf.date), location=str(inf.location)) return Infraction.objects.filter(id=inf.id).values( 'id', 'date', 'road_type', 'road_name', 'municipality', 'location', 'plate', 'infraction_code', 'vehicle_type', 'vehicle_service', 'offender_type', 'offender_document_type', 'offender_document_id', 'offender_name', 'offender_license_id', 'offender_address', 'offender_age', 'offender_phone', 'offender_mail', 'owner_document_type', 'owner_document_id', 'owner_name', 'company_id', 'company_name', 'transit_agent_name', 'transit_agent_entity', 'transit_agent_id', 'transit_agent_observations', 'document_url', 'state', 'state_date').first() except IntegrityError as e: raise Fault(faultcode=str(e.args[0]), faultstring=e.args[1])
def serialize(self, ctx, message): assert message in (self.REQUEST, self.RESPONSE) self.event_manager.fire_event('before_serialize', ctx) if ctx.out_error is not None: ctx.out_document = [Fault.to_dict(ctx.out_error.__class__, ctx.out_error)] else: # get the result message if message is self.REQUEST: out_type = ctx.descriptor.in_message elif message is self.RESPONSE: out_type = ctx.descriptor.out_message if out_type is None: return out_type_info = out_type._type_info # instantiate the result message out_instance = out_type() # assign raw result to its wrapper, result_message for i in range(len(out_type_info)): attr_name = out_type_info.keys()[i] setattr(out_instance, attr_name, ctx.out_object[i]) ctx.out_document = self._object_to_doc(out_type, out_instance), self.event_manager.fire_event('after_serialize', ctx)
def add_infraction(self, infraction): data = infraction.as_dict() try: inf = Infraction.objects.create(**data) sendmailnotification = SendMailNotifications() sendmailnotification.send_mail( list_emails=[data['offender_mail']], subject='Multa de Transito - Simit Services', content_xml='<h2>Multa de Transito N0: ' + str(inf.id) + '</h2></br><p>' + 'Estimado Infractor se ha creado una nueva Multa de Transito asociado al ciudadano ' + str(inf.offender_document_id) + ' - ' + str(inf.offender_name) + '</p></br><p>Realice el pago lo mas pronto posible para evitar sanciones</p>' + '<br><h3>SIMIT Services</h3>') return Infraction.objects.filter(id=inf.id).values( 'id', 'date', 'road_type', 'road_name', 'municipality', 'location', 'plate', 'infraction_code', 'vehicle_type', 'vehicle_service', 'offender_type', 'offender_document_type', 'offender_document_id', 'offender_name', 'offender_license_id', 'offender_address', 'offender_age', 'offender_phone', 'offender_mail', 'owner_document_type', 'owner_document_id', 'owner_name', 'company_id', 'company_name', 'transit_agent_name', 'transit_agent_entity', 'transit_agent_id', 'transit_agent_observations', 'document_url', 'state', 'state_date').first() except IntegrityError as e: raise Fault(faultcode=str(e.args[0]), faultstring=e.args[1])
def serialize(self, ctx, message): assert message in (self.REQUEST, self.RESPONSE) self.event_manager.fire_event('before_serialize', ctx) if ctx.out_error is not None: ctx.out_document = [ Fault.to_dict(ctx.out_error.__class__, ctx.out_error) ] else: # get the result message if message is self.REQUEST: out_type = ctx.descriptor.in_message elif message is self.RESPONSE: out_type = ctx.descriptor.out_message if out_type is None: return out_type_info = out_type._type_info # instantiate the result message out_instance = out_type() # assign raw result to its wrapper, result_message for i in range(len(out_type_info)): attr_name = out_type_info.keys()[i] setattr(out_instance, attr_name, ctx.out_object[i]) ctx.out_document = self._object_to_doc(out_type, out_instance), self.event_manager.fire_event('after_serialize', ctx)
def test_ctor_defaults(self): fault = Fault() self.assertEqual(fault.faultcode, 'Server') self.assertEqual(fault.faultstring, 'Fault') self.assertEqual(fault.faultactor, '') self.assertEqual(fault.detail, None) self.assertEqual(repr(fault), "Fault(Server: 'Fault')")
def addTicketToEvent(MovieName, NumberOfTickets): try: if (len(MovieName) == 0): raise Fault(faultcode='Client', faultstring='', faultactor='', detail={ 'Message': 'Error. Title not provided or is invalid' }) if (NumberOfTickets < 1): raise Fault( faultcode='Client', faultstring='', faultactor='', detail={'Error. TicNumber not provided or is invalid'}) requestData = {'title': MovieName} r = requests.get('http://service:81/movies', params=requestData) eventID = r.json() for i in range(0, NumberOfTickets): lastId = int(ticketsDB[len(ticketsDB) - 1]['ID']) + 1 ticket = { 'ID': str(lastId), 'Barcode': '', 'EID': eventID[0]['ID'], 'Current_Zone': '0', 'Rated': '0' } ticketsDB.append(ticket) eventTickets = [ tic for tic in ticketsDB if (tic['EID'] == str(eventID[0]['ID'])) ] m = [] for ticket in eventTickets: m.append( Ticket(ID=ticket["ID"], Barcode=ticket["Barcode"], EID=ticket["EID"], Current_Zone=ticket["Current_Zone"], Rated=ticket["Rated"])) return m except requests.RequestException as e: raise Fault(faultcode='503', faultstring='', faultactor='', detail={'Message': str(e)})
def process_request(self, ctx): """Takes a MethodContext instance. Returns the response to the request as a native python object. If the function throws an exception, it returns None and sets the exception object to ctx.out_error. Overriding this method would break event management. So this is not meant to be overridden unless you know what you're doing. """ try: # fire events self.event_manager.fire_event('method_call', ctx) if ctx.service_class is not None: ctx.service_class.event_manager.fire_event('method_call', ctx) # call the method ctx.out_object = self.call_wrapper(ctx) # out object is always an iterable of return values. see # MethodContext docstrings for more info if ctx.descriptor.body_style is not BODY_STYLE_WRAPPED or \ len(ctx.descriptor.out_message._type_info) <= 1: # the return value should already be wrapped by a sequence. ctx.out_object = [ctx.out_object] # Now that the processing is switched to the outgoing message, point # ctx.protocol to ctx.out_protocol ctx.protocol = ctx.outprot_ctx # fire events self.event_manager.fire_event('method_return_object', ctx) if ctx.service_class is not None: ctx.service_class.event_manager.fire_event( 'method_return_object', ctx) except Fault as e: if e.faultcode == 'Client' or e.faultcode.startswith('Client.'): logger_client.exception(e) else: logger.exception(e) ctx.out_error = e # fire events self.event_manager.fire_event('method_exception_object', ctx) if ctx.service_class is not None: ctx.service_class.event_manager.fire_event( 'method_exception_object', ctx) except Exception as e: logger.exception(e) ctx.out_error = Fault('Server', get_fault_string_from_exception(e)) # fire events self.event_manager.fire_event('method_exception_object', ctx) if ctx.service_class is not None: ctx.service_class.event_manager.fire_event( 'method_exception_object', ctx)
def edit_municipality(self, municipality): data = municipality.as_dict() try: Municipality.objects.filter(id=data['id']).update(**data) return Municipality.objects.filter(id=data['id']).values( 'id', 'dian_code', 'name').first() except IntegrityError as e: raise Fault(faultcode=str(e.args[0]), faultstring=e.args[1])
def _eb_deferred(ret, request, p_ctx, others, resource): app = p_ctx.app # DRY this with what's in Application.process_request if issubclass(ret.type, Redirect): try: ret.value.do_redirect() # Now that the processing is switched to the outgoing message, # point ctx.protocol to ctx.out_protocol p_ctx.protocol = p_ctx.outprot_ctx _cb_deferred(None, request, p_ctx, others, resource, cb=False) # fire events app.event_manager.fire_event('method_redirect', p_ctx) if p_ctx.service_class is not None: p_ctx.service_class.event_manager.fire_event( 'method_redirect', p_ctx) except Exception as e: logger_server.exception(e) p_ctx.out_error = Fault('Server', get_fault_string_from_exception(e)) # fire events app.event_manager.fire_event('method_redirect_exception', p_ctx) if p_ctx.service_class is not None: p_ctx.service_class.event_manager.fire_event( 'method_redirect_exception', p_ctx) elif issubclass(ret.type, Fault): p_ctx.out_error = ret.value ret = resource.handle_rpc_error(p_ctx, others, p_ctx.out_error, request) # fire events app.event_manager.fire_event('method_exception_object', p_ctx) if p_ctx.service_class is not None: p_ctx.service_class.event_manager.fire_event( 'method_exception_object', p_ctx) request.write(ret) else: p_ctx.out_error = ret.value ret.printTraceback() p_ctx.out_error = InternalError(ret.value) # fire events app.event_manager.fire_event('method_exception_object', p_ctx) if p_ctx.service_class is not None: p_ctx.service_class.event_manager.fire_event( 'method_exception_object', p_ctx) request.finish()
def Login(ctx, _this, userName, password): self = ctx.udc if (userName == 'root' and password == 'Embe1mpls') or \ (userName == 'u' and password == 'p') or \ (userName == 'user' and password == 'pass'): self.auth = serializers.AuthResponse() self.auth.key = self.login_id return self.auth.serialize() raise Fault('Client.Authentication', 'Authorization failed')
def changeMovieAlbumSoap(Id, Title, Genre, Release_date, Rating, Album, AlbumGenre, Producer, Artist): if Artist != '': try: for i in range(0, len(movies)): if movies[i]["ID"] == Id: r = requests.put('http://web1:81/albums/' + movies[i]["Album_ID"], json={ "Album": Album, "Artist": Artist, "Genre": AlbumGenre, "Producer": Producer }) if r.status_code == 200 and re.search('^[0-9]?$', Id): movies[i]['Title'] = Title movies[i]['Genre'] = Genre movies[i]['Rating'] = Rating movies[i]['Release_date'] = Release_date movie = movies[i] else: raise Fault( faultcode='Client', faultstring='', faultactor='', detail={ 'Message': 'Error. Service Albums status is not 200.' }) return Movie(ID=movie["ID"], Title=movie["Title"], Genre=movie["Genre"], Rating=movie["Rating"], Release_date=movie["Release_date"], Album_ID=movie["Album_ID"]) except: raise Fault(faultcode='Client', faultstring='', faultactor='', detail={ 'Message': 'Error. Service Albums is not available.' })
def test_to_parent_w_detail(self): from lxml.etree import Element element = Element('testing') detail = Element('something') fault = Fault(detail=detail) cls = Fault XmlDocument().to_parent(None, cls, fault, element, 'urn:ignored') (child,) = element.getchildren() self.assertTrue(child.find('detail').find('something') is detail)
def serialize(self, ctx, message): assert message in (self.REQUEST, self.RESPONSE) self.event_manager.fire_event('before_serialize', ctx) if ctx.out_error is not None: ctx.out_document = [ [MessagePackRpc.MSGPACK_RESPONSE, 0, Fault.to_dict(ctx.out_error.__class__, ctx.out_error)] ] return # get the result message if message is self.REQUEST: out_type = ctx.descriptor.in_message msgtype = MessagePackRpc.MSGPACK_REQUEST method_name_or_error = ctx.descriptor.operation_name elif message is self.RESPONSE: out_type = ctx.descriptor.out_message msgtype = MessagePackRpc.MSGPACK_RESPONSE method_name_or_error = None else: raise Exception("what?") if out_type is None: return out_type_info = out_type._type_info # instantiate the result message out_instance = out_type() # assign raw result to its wrapper, result_message for i, (k, v) in enumerate(out_type_info.items()): attr_name = k out_instance._safe_set(attr_name, ctx.out_object[i], v) # transform the results into a dict: if out_type.Attributes.max_occurs > 1: params = (self._to_dict_value(out_type, inst, set()) for inst in out_instance) else: params = self._to_dict_value(out_type, out_instance, set()) ctx.out_document = [[msgtype, 0, method_name_or_error, params]] self.event_manager.fire_event('after_serialize', ctx)
def serialize(self, ctx, message): assert message in (self.REQUEST, self.RESPONSE) self.event_manager.fire_event('before_serialize', ctx) if ctx.out_error is not None: ctx.out_document = [MessagePackRpc.MSGPACK_RESPONSE, 0, Fault.to_dict(ctx.out_error.__class__, ctx.out_error)] else: # get the result message if message is self.REQUEST: out_type = ctx.descriptor.in_message elif message is self.RESPONSE: out_type = ctx.descriptor.out_message if out_type is None: return out_type_info = out_type._type_info # instantiate the result message out_instance = out_type() # assign raw result to its wrapper, result_message for i in range(len(out_type_info)): attr_name = out_type_info.keys()[i] setattr(out_instance, attr_name, ctx.out_object[i]) # transform the results into a dict: if out_type.Attributes.max_occurs > 1: ctx.out_document = [[MessagePackRpc.MSGPACK_RESPONSE, 0, None, (self._to_value(out_type, inst) for inst in out_instance) ]] else: ctx.out_document = [[MessagePackRpc.MSGPACK_RESPONSE, 0, None, self._to_value(out_type, out_instance), ]] self.event_manager.fire_event('after_serialize', ctx)
def __init__(self, reason, username, device_id): # TODO: self.transport.http.resp_code = HTTP_401 if reason == "badLogin": Fault.__init__( self, faultcode='Client.LoginInvalid', faultstring="Username or Password Fail for %r'" % username) elif reason == "freeUser": details = {'SonosError': "666", } Fault.__init__( self, faultcode='Client.LoginUnsupported', faultstring='%r is not a premium account.' % username, detail=details) elif reason == "unsupportedTerritory": Fault.__init__( self, faultcode="Client.UnsupportedTerritory", faultstring='%r is not in a supported territory.' % username)
def __init__(self, value): Fault.__init__(self, faultcode='Client.KeyError', faultstring='Value %r not found' % value )
def __init__(self, fault_object, fault_string="You do not have permission to access this resource"): Fault.__init__(self, 'Client.InvalidCredentialsError', fault_string)
def __init__(self, faultstring=""): Fault.__init__(self, 'Client.ArgumentError', faultstring)
def __init__(self, err): Fault.__init__( self, faultcode="ElbeProjectError", faultstring=str(err))
def __init__(self, faultstring=""): Fault.__init__(self, 'Client.RequestTooLong', faultstring)
def __init__(self, faultstring=""): Fault.__init__(self, 'Client.RequestNotAllowed', faultstring)
def __init__(self): Fault.__init__( self, faultcode="ElbeAuthenticationFailed", faultstring="Authentication Failed")
def __init__(self, faultstring="Requested resource not found"): Fault.__init__(self, 'Client.ResourceNotFound', faultstring)
def serialize(self, ctx, message): assert message in (self.REQUEST, self.RESPONSE) self.event_manager.fire_event('before_serialize', ctx) # construct the soap response, and serialize it nsmap = self.app.interface.nsmap ctx.out_document = { "ver": self.version, } if ctx.out_error is not None: ctx.out_document[self.FAULT] = Fault.to_dict(Fault, ctx.out_error) else: if message is self.REQUEST: header_message_class = ctx.descriptor.in_header body_message_class = ctx.descriptor.in_message elif message is self.RESPONSE: header_message_class = ctx.descriptor.out_header body_message_class = ctx.descriptor.out_message # assign raw result to its wrapper, result_message out_type_info = body_message_class._type_info out_object = body_message_class() keys = iter(out_type_info) values = iter(ctx.out_object) while True: try: k = keys.next() except StopIteration: break try: v = values.next() except StopIteration: v = None setattr(out_object, k, v) ctx.out_document[self.BODY] = ctx.out_body_doc = \ self._object_to_doc(body_message_class, out_object) # header if ctx.out_header is not None and header_message_class is not None: if isinstance(ctx.out_header, (list, tuple)): out_headers = ctx.out_header else: out_headers = (ctx.out_header,) ctx.out_header_doc = out_header_doc = [] for header_class, out_header in zip(header_message_class, out_headers): out_header_doc.append(self._object_to_doc(header_class, out_header)) if len(out_header_doc) > 1: ctx.out_document[self.HEAD] = out_header_doc else: ctx.out_document[self.HEAD] = out_header_doc[0] self.event_manager.fire_event('after_serialize', ctx)
def __init__(self): Fault.__init__(self, faultcode="ElbeInvalidState", faultstring="Project is Busy ! Operation Invalid")
def __init__(self): Fault.__init__(self, faultcode='Client.UnauthenticatedError', faultstring='This resource can only be accessed after authentication.' )
def __init__(self): Fault.__init__( self, faultcode="ElbeNotLoggedIn", faultstring="Not authenticated ! " "Cant let you perform this command.")
def __init__(self, exc): Fault.__init__( self, faultcode="ElbeValidationError", faultstring=exc.__repr__())
def __init__(self): Fault.__init__( self, faultcode="ElbeNotAuthorized", faultstring="Not Authorized ! Cant let you perform this command.")
def __init__(self, fault_object, fault_string="Requested resource %r not found"): Fault.__init__(self, 'Client.ResourceNotFound', fault_string % fault_object)
def __init__(self, faultstring="", data=""): Fault.__init__(self, 'Client.InvalidInput', repr((faultstring, data)))
def __init__(self, error): Fault.__init__(self, 'Server', "InternalError: An unknown error has occured.")
def __init__(self, faultstring): Fault.__init__(self, 'Client.SchemaValidationError', faultstring)
def __init__(self, faultstring): Fault.__init__(self, 'Client.ValidationError', 'The value %r could not be validated.' % faultstring)
def __init__(self, data=None): Fault.__init__(self, "Client.MessagePackDecodeError", data)
def __init__(self): Fault.__init__(self, faultcode="Documented", faultstring="A documented fault", faultactor='http://faultactor.example.com', )