def _build_url(self): if not self.sid: raise appier.OperationalError(message="No account sid provided") if not self.auth_token: raise appier.OperationalError(message="No auth token provided") self.secure_url = self.base_template % (self.sid, self.auth_token) self.account_url = self.secure_url + "Accounts/%s/" % self.sid
def login_key(cls, key): # verifies that secret key is provided, is considered valid for domain # and that it is correctly and properly defined (required for validation) if not key: raise appier.OperationalError( message="Secret key must be provided", code=400) # tries to retrieve the account with the provided username, so that # the other validation steps may be done as required by login operation account = cls.get(key=key, rules=False, build=False, raise_e=False) if not account: raise appier.OperationalError(message="No valid account found", code=403) # verifies that the retrieved account is currently enabled, because # disabled accounts are not considered to be valid ones if not account.enabled: raise appier.OperationalError(message="Account is not enabled", code=403) # "touches" the current account meaning that the last login value will be # updated to reflect the current time and then returns the current logged # in account to the caller method so that it may used (valid account) account.touch_login_s() return account
def _build_url(self): if self.is_oauth(): self.base_url = "https://%s/" % API_DOMAIN return if not self.username: raise appier.OperationalError(message="No username provided") if not self.password: raise appier.OperationalError(message="No password provided") self.base_url = "https://%s:%s@%s/" % (self.username, self.password, API_DOMAIN)
def reset_s(self, password, password_confirm): if not password: raise appier.OperationalError(message="No password provided", code=400) if not password == password_confirm: raise appier.OperationalError( message="Invalid password confirmation", code=400) self.password = password self.password_confirm = password_confirm self.reset_token = None self.save()
def _build_url(self): if not self.api_key: raise appier.OperationalError(message = "No API key provided") if not self.password: raise appier.OperationalError(message = "No password provided") if not self.store_url: raise appier.OperationalError(message = "No store URL provided") self.base_url = "https://%s:%s@%s/" % ( self.api_key, self.password, self.store_url ) self.website_url = "http://%s/" % (self.website_url or self.store_url)
def _csv_read( cls, file, mime_type = None, strict = False, named = False, delimiter = ",", quotechar = "\"", quoting = csv.QUOTE_MINIMAL, encoding = "utf-8" ): is_unicode = appier.legacy.PYTHON_3 if appier.legacy.is_bytes(file): mime_type, data = mime_type, file else: _file_name, mime_type, data = file is_csv = mime_type in ("text/csv", "application/vnd.ms-excel") if not is_csv and strict: raise appier.OperationalError( message = "Invalid MIME type '%s'" % mime_type ) if is_unicode: data = data.decode(encoding) buffer = appier.legacy.StringIO(data) else: buffer = appier.legacy.BytesIO(data) csv_reader = csv.reader( buffer, delimiter = delimiter, quotechar = quotechar, quoting = quoting ) return csv_reader
def _json_read(cls, file, strict=False, encoding="utf-8"): _file_name, mime_type, data = file is_json = mime_type in ("text/json", "application/json") if not is_json and strict: raise appier.OperationalError(message="Invalid MIME type '%s'" % mime_type) data = data.decode(encoding) json_data = json.loads(data) return json_data
def loads(self, value): cls = self.__class__ if isinstance(value, cls): self._datetime = value._datetime elif isinstance(value, datetime.datetime): self._datetime = value elif isinstance(value, (int, float)): self._datetime = datetime.datetime.utcfromtimestamp(value) else: raise appier.OperationalError()
def login(cls, username, password, insensitive=True): # in case the (case) insensitive option is enabled and the username # is defined the value is converted to lower case so that a proper # comparison may be used (not case sensitive) if insensitive and username: username = username.lower() # verifies that both the provided username and password are valid # and that are correctly and properly defined (required for validation) if not username or not password: raise appier.OperationalError( message="Both username and password must be provided", code=400) # tries to retrieve the account with the provided username, so that # the other validation steps may be done as required by login operation account = cls.get(username=username, rules=False, build=False, raise_e=False) if not account: raise appier.OperationalError(message="No valid account found", code=403) # verifies that the retrieved account is currently enabled, because # disabled accounts are not considered to be valid ones if not account.enabled: raise appier.OperationalError(message="Account is not enabled", code=403) # retrieves the value of the password for the stored account and then # verifies that the value matched the one that has been provided _password = account.password if not cls.verify(_password, password): raise appier.OperationalError( message="Invalid or mismatch password", code=403) # "touches" the current account meaning that the last login value will be # updated to reflect the current time and then returns the current logged # in account to the caller method so that it may used (valid account) account.touch_login_s() return account
def recover(cls, identifier, send_email=False): # verifies if a valid identifier has been provided because that value # is required for the proper account recover process to be executed if not identifier: raise appier.OperationalError( message="An identifier must be provided", code=400) # creates the keyword based arguments that are going to be used to provide # an extra layer of or based filtering to the retrieval process of the account # that is going to be performed next kwargs = {"$or": [dict(username=identifier), dict(email=identifier)]} account = cls.get(build=False, raise_e=False, **kwargs) # in case no account has been retrieved an error is raised indicating such # problem, as that is required for the account recover process if not account: raise appier.OperationalError(message="No valid account found", code=403) # runs the recover instance method that should generate a new reset token # for the account and send the proper notifications return account.recover_s(send_email=send_email)
def _handle_error(error, fallback=None, code=400, encoding="utf-8"): # reads the complete set of data from the error (assumes # that the error is string based and implements a read interface) data = error.read() # tries to retrieve the proper message by decoding the # received bytes using the provided encoding value, in # case it fails sets a default message (as fallback) is_bytes = appier.legacy.is_bytes(data) try: data_s = data.decode(encoding) if is_bytes else str(data) except UnicodeDecodeError: data_s = "Undefined message" try: # tries to load the data as a JSON based message (for # structure parsing) may fail due to bad JSON structure # if the message data is not JSON valid data_j = json.loads(data_s) # tries to retrieve the message from the provided # information, as expected by the structure message = data_j.get("message", None) except Exception: # in case there was an unexpected error interpreting # the data then sets the data itself as the message message = data_s # in case the message is defined special final characters # must be removed in order to normalize the message if message: message = message.rstrip(".") # in case there is no message then uses the fallback instead # as the fallback should represent the same error but in a # much broader sense (less accurate) fallback = fallback or data_s message = message or fallback # raises the error as an exception using the proper internal # usage error format (as expected by upper layers) raise appier.OperationalError(message=message, code=code)
def upgrade_service(self, id, batch_size=1, interval=2000, full_upgrade=True, try_finish=True, safe=True, launch_config=None): url = self.base_url + "services/%s?action=upgrade" % id if try_finish: self._service_try_finish(id) if launch_config == None: launch_config = self._service_launch_config(id) if safe and not self._service_active(id): raise appier.OperationalError( message="Service is currently not ready for upgrade") contents = self.post( url, data_j=dict(inServiceStrategy=dict(batchSize=batch_size, intervalMillis=interval, fullUpgrade=full_upgrade, launchConfig=launch_config, secondaryLaunchConfigs=[]))) data = contents["data"] return data
def raiser(): raise appier.OperationalError(message = "hello") struct = appier.lazy_dict(
def raiser(): raise appier.OperationalError(message="hello")
def ensure_set(self, **kwargs): for key, value in kwargs.items(): if value: continue raise appier.OperationalError(message="Invalid %s received '%s'" % (key, value))
def _build_url(self): if not self.store_url: raise appier.OperationalError(message = "No store URL provided") self.base_url = "https://%s/" % self.store_url
def ensure_method(cls, payment_method): if payment_method == "credit_card": return raise appier.OperationalError(message="Unexpected payment method")
def _build_url(self): if not self.repo: raise appier.OperationalError(message="No repo name provided") if not self.base_url: raise appier.OperationalError(message="No base URL provided") self.base_url = self.base_url % self.repo
def _ensure_same(message = None): if element._is_same(): return message = message or "Element (%s) is not the same" % element._text() raise appier.OperationalError(message = message)