예제 #1
0
def getProperties(command):
    '''
    Function to return a list containing the properties of the filter query
    :param command: a list containing the user command, split by whitespaces
    :return:  another list containing the arguments of the filter command which can be of two types:
        greater/less than X - all transactions greater/less than X (given amount of money)
        greater/less than X before Y - all transactions greater/less than X (given amount of money) before given day(Y)
    :raises exception whenever there is a syntax error, a value error or an invalid parameter error.
    '''
    if len(command) < 3:
        raise CommandError("Filter command - Syntax error!")
    if len(command) == 4:
        raise CommandError("Filter command - Syntax error!")
    if command[1] != 'than':
        raise CommandError("Filter command - Syntax error!")
    if len(command) > 3 and command[3] != 'before':
        raise CommandError("Filter command - Syntax error!")
    if not representsInt(command[2]):
        raise InvalidParameters("Filter command - amount is not an integer!")
    if int(command[2]) <= 0:
        raise InvalidParameters(
            "Filter command - amount should be strictly positive!")
    if len(command) > 3 and not representsInt(command[4]):
        raise InvalidParameters("Filter command - day is not an integer!")
    if len(command) > 3 and int(command[4]) <= 0:
        raise InvalidParameters(
            "Filter command - day should be strictly positive!")
    arguments = [command[0], int(command[2])]
    if len(command) > 3:
        arguments.append(int(command[4]))
    return arguments
예제 #2
0
def getReplaceTransaction(command):
    '''
    A function to handle the Replace Transaction Feature

    :param command: the command the user has inputted
                the transaction the user wants to insert
    '''
    if len(command) < 4:
        raise CommandError("Replace command - Syntax error!")
    if command[-2] != 'with':
        raise CommandError("Replace command - Syntax error!")
    if not representsInt(command[-1]):
        raise InvalidParameters("Replace command - Amount not an integer!")
    if int(command[-1]) <= 0:
        raise InvalidParameters(
            'Replace command - Amount cannot be negative or null!')
    argsList = command[1].split(',')
    if len(argsList) < 3:
        raise CommandError("Replace command - Not enough parameters!")
    if not representsInt(argsList[0]):
        raise InvalidParameters("Replace command - Date not an integer!")
    if int(argsList[0]) <= 0:
        raise InvalidParameters(
            "Replace command - Date should be strictly positive!")
    if argsList[1] not in ['in', 'out']:
        raise InvalidParameters(
            'Replace command - Transaction type unknown, should be only in or out'
        )
    newAmount = int(command[-1])
    day = int(argsList[0])
    description = ','.join(argsList[2:])
    if len(command) > 4:
        description = description + ' ' + ' '.join(command[2:-2])
    return (day, argsList[1], newAmount, description)
예제 #3
0
파일: client.py 프로젝트: altai/nova2ools
 def __validate_response(self, response):
     if response.status / 100 == 2:
         return
     if response.status == 400:  # Bad Request
         json_response = json.loads(response.read())
         raise CommandError(
             1, "Bad Request: {0}".format(
                 json_response["badRequest"]["message"]))
     if response.status / 100 == 4:
         raise CommandError(1, response.reason)
     raise CommandError(
         1, "Unhandled response code: %s (%s)" %
         (response.status, response.reason))
예제 #4
0
def getSortArguments(command):
    '''
    Function to get the arguments of Sort command
    :param command: a list containing the whitespace-split command from the user
    :return: a tuple ('asc'/'desc', 'day'/'in'/'out') representing the arguments the the sort function
    :raises exception whenever there is a syntax error, a value error or an invalid parameter error.
    '''
    if len(command) < 3:
        raise CommandError("Sort command - Syntax Error!")
    if command[1] != 'sort':
        raise CommandError("Sort command - Syntax Error!")
    if command[2] != 'day' and command[2] != 'in' and command[2] != 'out':
        raise CommandError("Sort command - Syntax Error!")
    return (command[0], command[2])
예제 #5
0
def getMaxArguments(command):
    '''
    Function to get the arguments of Max command
    :param command: a list containing the whitespace-split command from the user
    :return: an string from the set {"in", "out"} which is the argument of the max command
    :raises exception whenever there is a syntax error, a value error or an invalid parameter error.
    '''
    if len(command) < 3:
        raise CommandError("Max command - Syntax error!")
    if command[1] != 'in' and command[1] != 'out':
        raise InvalidParameters("Max command - Unknown type of transaction")
    if command[2] != 'day':
        raise CommandError("Max command - Syntax error!")
    return command[1]
예제 #6
0
파일: client.py 프로젝트: altai/nova2ools
    def auth_keystone(self):
        token = self.options.token
        password = self.options.password
        username = self.options.username
        tenant_id = self.options.tenant_id
        tenant_name = self.options.tenant_name
        if token:
            params = {"auth": {"token": {"id": token}}}
        elif username and password:
            params = {
                "auth": {
                    "passwordCredentials": {
                        "username": username,
                        "password": password
                    }
                }
            }
        else:
            raise CommandError(1,
                               "A username and password or token is required")

        if tenant_id:
            params['auth']['tenantId'] = tenant_id
        elif tenant_name:
            params['auth']['tenantName'] = tenant_name
        _, access = self.request(self.options.auth_url + "/tokens",
                                 "POST",
                                 body=params,
                                 headers={"Content-Type": "application/json"})
        if access is None:
            raise CommandError(1, "You are not authenticated")
        self.token_info = TokenInfo(access)

        if not self.management_url and self.service_type:
            self.set_service_type(self.service_type)

        self.auth_headers = {"X-Auth-Token": self.token_info.get_token()}
        if not tenant_id:
            try:
                tenant_id = access['access']['token']['tenant']['id']
            except Exception:
                raise CommandError(
                    1,
                    "Response json object doesn't contain chain 'access->token->tenant->id'"
                )
            self.options.tenant_id = tenant_id
        self.auth_headers["X-Tenant"] = tenant_id
        if tenant_name:
            self.auth_headers["X-Tenant-Name"] = tenant_name
예제 #7
0
def getAddTransaction(command):
    '''
    A function to handle the Add Transaction Feature

    :param command: the command the user has inputted
    :return a tuple (day, amount, in/out, description) which describes
                the transaction the user wants to add
            or None if there is a command syntax error
    '''
    if len(command) < 2:
        raise CommandError("Add command - Syntax Error!")
    argsList = command[1].split(',')
    if len(argsList) < 3:
        raise InvalidParameters("Add command - Not enough parameters!")
    if not representsInt(argsList[0]):
        raise InvalidParameters(
            "Add command - The amount of money not an integer!")
    if int(argsList[0]) <= 0:
        raise InvalidParameters(
            "Add command - The amount of money should be strictly positive!")
    if argsList[1].lower() not in ["in", "out"]:
        raise InvalidParameters(
            "Add command - The only known types are in and out!")
    description = ','.join(argsList[2:])
    if len(command) > 2:
        description = description + ' ' + ' '.join(command[2:])
    transaction = (datetime.datetime.now().day, int(argsList[0]), argsList[1],
                   description)
    return transaction
예제 #8
0
def getInsertTransaction(command):
    '''
    A function to handle the Insert Transaction Feature

    :param command: the command the user has inputted
    :return a tuple (day, amount, in/out, description) which describes
                the transaction the user wants to insert
            or None if there is a command syntax error
    '''
    if len(command) < 2:
        raise CommandError("Insert Command - Syntax Error!")
    argsList = command[1].split(',')
    if len(argsList) < 4:
        raise InvalidParameters("Insert Command - Not enough parameters!")
    if not representsInt(argsList[0]):
        raise InvalidParameters("Insert Command - Day not an integer!")
    if int(argsList[0]) <= 0:
        raise InvalidParameters(
            "Insert Command - Day should be strictly positive!")
    if not representsInt(argsList[1]):
        raise InvalidParameters("Insert Command - Amount not an integer!")
    if int(argsList[1]) <= 0:
        raise InvalidParameters(
            "Insert Command - Amount cannot be negative or nul!")
    if argsList[2].lower() not in ["in", "out"]:
        raise InvalidParameters(
            "Insert Command - The only known transaction types are in and out")
    description = ','.join(argsList[3:])
    if len(command) > 2:
        description = description + ' ' + ' '.join(command[2:])
    transaction = (int(argsList[0]), int(argsList[1]), argsList[2],
                   description)
    return transaction
예제 #9
0
파일: client.py 프로젝트: altai/nova2ools
 def url_for(self, service_type, endpoint_type='publicURL'):
     try:
         return self.token_info.url_for(service_type=service_type,
                                        endpoint_type=endpoint_type)
     except EndpointNotFound:
         raise CommandError(
             1, "Could not find `%s' in service catalog" % service_type)
예제 #10
0
 def getCommand(self):
     #gets the command from the user and calls the validation functions
     cmd = input("Please choose an option from above: ")
     print()
     if cmd == "":
         raise CommandError("Enter is not an option.")
     self._validateinteger.validate_integer(cmd)
     return str(cmd)
예제 #11
0
파일: client.py 프로젝트: altai/nova2ools
    def auth(self):
        if self.options.token:
            self.__token = self.options.token
        self.management_url = self.options.endpoint
        if not (self.options.token and self.options.endpoint):
            if not self.options.auth_url:
                raise CommandError(1, "Authentication URL is required")

            if self.options.use_keystone is None:
                raise CommandError(
                    1, "You should select auth type (use_keystone parameter)")
            if self.options.use_keystone:
                self.auth_keystone()
            else:
                self.auth_nova()
        else:
            self.auth_headers = {
                "X-Auth-Token": self.__token,
            }
예제 #12
0
    def handle_request(self, socket_file):
        first_byte = socket_file.read(1)
        if not first_byte:
            raise Disconnect()

        try:
            # Delegate to the appropriate handler based on
            # the first byte.
            return self.handlers[first_byte](socket_file)
        except KeyError:
            raise CommandError('bad request')
예제 #13
0
파일: server.py 프로젝트: foxyblue/inmemdb
    def get_response(self, data):
        """Here we'll actually unpack the data sent by the client,
        execute the command they specified, and pass back the
        return value.
        """
        if not isinstance(data, list):
            try:
                data = data.split()
            except:
                CommandError('Request must be list or simple string.')

        if not data:
            raise CommandError('Missing command')

        command = data[0].upper()
        if command not in self._commands:
            raise CommandError('unrecognized command: %s' % command)

        logger.info("{} request received.".format(command))
        return self._commands[command](*data[1:])
예제 #14
0
def getAllArguments(command):
    '''
    Function to get the arguments of All command
    :param command: a list containing the whitespace-split command from the user
    :return: either 'in' or 'out' parsed from what the user inserted
    :raises exception whenever there is a syntax error, a value error or an invalid parameter error.
    '''
    if len(command) < 2:
        raise CommandError("All filter - syntax error!")
    if command[1] != "in" and command[1] != 'out':
        raise InvalidParameters("All filter - the only known types are in/out")
    return command[1]
예제 #15
0
def getSumArgument(command):
    '''
    Function to get the arguments of Sum command
    :param command: a list containing the whitespace-split command from the user
    :return: an integer representing the sum of all the 'in' transaction or 'out' transaction.
    :raises exception whenever there is a syntax error, a value error or an invalid parameter error.
    '''
    if len(command) < 2:
        raise CommandError("Sum command - Syntax error!")
    if command[1] != 'in' and command[1] != 'out':
        raise InvalidParameters("Sum command - Unknown transaction type!")
    return command[1]
예제 #16
0
def getBalanceArguments(command):
    '''
    Function to get the arguments of Balance command
    :param command: a list containing the whitespace-split command from the user
    :return: an integer representing the day when the use wants to know it's balance
    :raises exception whenever there is a syntax error, a value error or an invalid parameter error.
    '''
    if len(command) < 2:
        raise CommandError("Balance - syntax error!")
    if not representsInt(command[1]):
        raise InvalidParameters("Balance - day should be integer!")
    if int(command[1]) <= 0:
        raise InvalidParameters("Balance - day should be positive!")
    return int(command[1])
예제 #17
0
파일: client.py 프로젝트: altai/nova2ools
    def auth_nova(self):
        auth_headers = {
            "X-Auth-User": self.options.username,
            "X-Auth-Key": self.options.password,
            "X-Auth-Project-Id": self.options.tenant_name
        }
        resp, _ = self.request(self.options.auth_url,
                               "GET",
                               headers=auth_headers)
        self.__token = resp.getheader("X-Auth-Token")

        if not self.__token:
            raise CommandError(1, "You are not authorized")

        if not self.management_url:
            self.management_url = resp.getheader("X-Server-Management-Url")
        self.auth_headers = {
            "X-Auth-Project-Id": self.options.tenant_name,
            "X-Auth-Token": self.__token
        }
예제 #18
0
def getFilterArguments(command):
    '''
    Function to return a list of arguments which represents the Filter command arguments
    :param command: a list of strings which is the input string split by whitespaces
    :return:
    '''
    if len(command) < 2:
        raise CommandError("Filter command - Syntax Error.")
    if command[1] != 'in' and command[1] != 'out':
        raise InvalidParameters(
            "Filter command - the first parameter should be either in or out.")
    if len(command) > 2 and not representsInt(command[2]):
        raise InvalidParameters(
            "Filter command - the second arguments should be an integer.")
    if len(command) > 2 and not int(command[2]) < 0:
        raise InvalidParameters(
            "Filter command - the second arguments should be positive.")
    args = [command[1]]
    if len(command) > 2:
        args.append(command[2])
    return args
예제 #19
0
    def _write(self, buf, data):
        if isinstance(data, str):
            data = data.encode('utf-8')

        if isinstance(data, bytes):
            buf.write('$%s\r\n%s\r\n' % (len(data), data.decode('utf-8')))
        elif isinstance(data, int):
            buf.write(':%s\r\n' % data)
        elif isinstance(data, Error):
            buf.write('-%s\r\n' % data.message)
        elif isinstance(data, (list, tuple)):
            buf.write('*%s\r\n' % len(data))
            for item in data:
                self._write(buf, item)
        elif isinstance(data, dict):
            buf.write('%%%s\r\n' % len(data))
            for key in data:
                self._write(buf, key)
                self._write(buf, data[key])
        elif data is None:
            buf.write('$-1\r\n')
        else:
            raise CommandError("unrecognized type: '%s'" % type(data))
예제 #20
0
def getRemoveTransactionInterval(command):
    '''
    A function to handle the Remove Interval Transaction

    :param command: the command the user has inputted
    :return a tuple (startDay, endDay) which describes
                the date interval that the user wants to remoev
            or None if there is a command syntax error
    :raise CommandError, ValueError, SyntaxError
    '''
    if command[1] != 'from' or command[3] != 'to':
        raise CommandError("Remove command - Syntax Error!")
    if representsInt(command[2]) == False or representsInt(
            command[4]) == False:
        raise InvalidParameters("Remove command - Dates should be integers!")
    if int(command[2]) <= 0:
        raise InvalidParameters("Remove command - Days should be strictly!")
    startDate = int(command[2])
    endDate = int(command[4])
    if startDate > endDate:
        raise InvalidParameters(
            "Remove command - Dates do not form an interval!")
    return (startDate, endDate)
예제 #21
0
파일: client.py 프로젝트: foxyblue/inmemdb
 def execute(self, *args):
     self._protocol.write_response(self._fh, args)
     resp = self._protocol.handle_request(self._fh)
     if isinstance(resp, Error):
         raise CommandError(resp.message)
     return resp
예제 #22
0
 def test_command_error(self):
     cmd = ""
     with self.assertRaises(CommandError) as context:
         if cmd == "":
             raise CommandError("Enter is not an option.")
     self.assertTrue("\n[COMMAND ERROR] -> Enter is not an option." in str(context.exception))
예제 #23
0
 def callCommand(self, commands, command):
     #calls the specific function in a given dict
     if command not in commands:
         raise CommandError(str(command) + " is not an option.")
     commands[command]()