def test_write(self):
        (DbProxy.get_instance()).write = MagicMock(return_value=1)
        res = UserData.get_instance().write("eytan", "pswd")
        self.assertEqual(1, res)

        (DbProxy.get_instance()).write = MagicMock(return_value=0)
        res = UserData.get_instance().write("eytan", "pswd")
        self.assertEqual(0, res)
    def test_delete(self):
        (DbProxy.get_instance()).delete = MagicMock(return_value=1)
        res = (UserData.get_instance()).delete(username="******")
        self.assertEqual(1, res)

        res = (UserData.get_instance()).delete(password="******")
        self.assertEqual(1, res)

        (DbProxy.get_instance()).delete = MagicMock(return_value=0)
        res = (UserData.get_instance()).delete(is_system_manager=True)
        self.assertEqual(0, res)
    def delete(self,
               policy_ref: int = None,
               precondition_product: str = "",
               precondition_min_amount: int = None,
               precondition_min_basket_price: float = None):
        """
        Delete users from the DB.
        <attribute> will composite a constraint of where to delete.
        example(if old_username != ""), it will composite the constraint-
                                               where(user.username == username).

        :return: the number of deleted rows.
        """
        const_lst = []
        if not (policy_ref is None):
            const_lst.append(
                Expression(self.__tbl.policy_ref, OP.EQ, policy_ref))
        if not (precondition_product == ""):
            const_lst.append(
                Expression(self.__tbl.precondition_product, OP.EQ,
                           precondition_product))
        if not (precondition_min_amount is None):
            const_lst.append(
                Expression(self.__tbl.precondition_min_amount, OP.EQ,
                           precondition_min_amount))
        if not (precondition_min_basket_price is None):
            const_lst.append(
                Expression(self.__tbl.precondition_min_basket_price, OP.EQ,
                           precondition_min_basket_price))
        where_expr = and_exprs(const_lst)
        return (DbProxy.get_instance()).delete(self.__tbl,
                                               where_expr=where_expr)
Ejemplo n.º 4
0
    def write(self, product_name: str, store_name: str, price: float,
              category: str, amount: int, purchase_type: int):
        """
        Write a product to db.

        :param purchase_type:
        :param product_name: pk
        :param store_name: pk
        :param price:
        :param category:
        :param amount:
        :return: size of user tbl after inserting the new one.
        """
        attributes_as_dictionary = {
            self.__attributes_as_dictionary[self.__attr_product_name]:
            product_name,
            self.__attributes_as_dictionary[self.__attr_store_name]:
            store_name,
            self.__attributes_as_dictionary[self.__attr_price]:
            price,
            self.__attributes_as_dictionary[self.__attr_category]:
            category,
            self.__attributes_as_dictionary[self.__attr_amount]:
            amount,
            self.__attributes_as_dictionary[self.__attr_purchase_type]:
            purchase_type
        }

        return (DbProxy.get_instance()).write(self.__tbl,
                                              attributes_as_dictionary)
    def delete(self,
               purchase_id: int = None,
               product_name: str = "",
               product_purchase_price: float = None,
               amount: int = None):
        """
        Delete store owner appointments from the DB.
        <attribute> will composite a constraint of where to delete.
        example(if old_username != ""), it will composite the constraint-
                                               where(user.username == username).

        :return: the number of deleted rows.
        """
        const_lst = []
        if not (purchase_id is None):
            const_lst.append((Expression(self.__tbl.purchase_id, OP.EQ,
                                         purchase_id)))
        if not (product_name == ""):
            const_lst.append((Expression(self.__tbl.product_name, OP.EQ,
                                         product_name)))
        if not (product_purchase_price is None):
            const_lst.append((Expression(self.__tbl.product_purchase_price,
                                         OP.EQ, product_purchase_price)))
        if not (amount is None):
            const_lst.append((Expression(self.__tbl.amount, OP.EQ, amount)))
        where_expr = and_exprs(const_lst)
        return (DbProxy.get_instance()).delete(self.__tbl,
                                               where_expr=where_expr)
Ejemplo n.º 6
0
    def read(self,
             attributes_to_read: [str],
             username: str = "",
             password: str = "",
             is_system_manager: bool = None):
        """
        Read users from db.
        Raise exception if an attribute in attributes_to_read is illegal.
        <attribute> will composite a constraint of where to read.
        example(if old_username != ""), it will composite the constraint-
                                               where(user.username == username).

        :param attributes_to_read: the list of attributes that will return from the db.
                                    type: [str]
        :param username: pk
        :param password:
        :param is_system_manager:
        :return: list of dictionaries that contain attributes_to_read fields.
        """
        if len(attributes_to_read) > 0:
            for attribute in attributes_to_read:
                if attribute.lower(
                ) not in self.__attributes_as_dictionary.keys():
                    raise AttributeError("Attribute " + attribute +
                                         " doesn't exist in " +
                                         str(type(self.__tbl)) + ".")
        else:
            attributes_to_read = [
                self.__attr_username, self.__attr_password,
                self.__attr_is_system_manager
            ]

        const_lst = []
        if not (username == ""):
            const_lst.append(Expression(self.__tbl.username, OP.EQ, username))
        if not (password == ""):
            const_lst.append(Expression(self.__tbl.password, OP.EQ, password))
        if is_system_manager is not None:
            const_lst.append(
                Expression(self.__tbl.is_system_manager, OP.EQ,
                           is_system_manager))
        where_expr = and_exprs(const_lst)

        result = (DbProxy.get_instance()).read(self.__tbl,
                                               where_expr=where_expr)
        output_lst = []
        for data_obj in result:
            user_data_as_dictionary = {}
            if self.__attr_username in attributes_to_read:
                user_data_as_dictionary[
                    self.__attr_username] = data_obj.username
            if self.__attr_password in attributes_to_read:
                user_data_as_dictionary[
                    self.__attr_password] = data_obj.password
            if self.__attr_is_system_manager in attributes_to_read:
                user_data_as_dictionary[
                    self.__attr_is_system_manager] = data_obj.is_system_manager
            output_lst.append(user_data_as_dictionary)

        return output_lst
Ejemplo n.º 7
0
    def delete(self,
               username: str = "",
               password: str = "",
               is_system_manager: bool = None):
        """
        Delete users from the DB.
        <attribute> will composite a constraint of where to delete.
        example(if old_username != ""), it will composite the constraint-
                                               where(user.username == username).

        :param username: pk. will composite a constraint of where to update.
        :param password: will composite a constraint of where to update.
        :param is_system_manager: will composite a constraint of where to update.
        :return: the number of deleted rows.
        """
        const_lst = []
        if not (username == ""):
            const_lst.append(Expression(self.__tbl.username, OP.EQ, username))
        if not (password == ""):
            const_lst.append(Expression(self.__tbl.password, OP.EQ, password))
        if is_system_manager is not None:
            const_lst.append(
                Expression(self.__tbl.is_system_manager, OP.EQ,
                           is_system_manager))
        where_expr = and_exprs(const_lst)

        return (DbProxy.get_instance()).delete(self.__tbl,
                                               where_expr=where_expr)
    def delete(self,
               policy_ref: int = None,
               policy1_ref: int = None,
               policy2_ref: int = None,
               flag: int = None):
        """
        Delete users from the DB.
        <attribute> will composite a constraint of where to delete.
        example(if old_username != ""), it will composite the constraint-
                                               where(user.username == username).

        :return: the number of deleted rows.
        """
        const_lst = []
        if not (policy_ref is None):
            const_lst.append(
                Expression(self.__tbl.policy_ref, OP.EQ, policy_ref))
        if not (policy1_ref is None):
            const_lst.append(
                Expression(self.__tbl.policy1_ref, OP.EQ, policy1_ref))
        if not (policy2_ref is None):
            const_lst.append(
                Expression(self.__tbl.policy2_ref, OP.EQ, policy2_ref))
        if not (flag is None):
            const_lst.append(Expression(self.__tbl.flag, OP.EQ, flag))
        where_expr = and_exprs(const_lst)

        return (DbProxy.get_instance()).delete(self.__tbl,
                                               where_expr=where_expr)
Ejemplo n.º 9
0
    def update(self, old_username: str = "", old_product_ref: int = None, old_amount: int = None,
               new_username: str = "", new_product_ref: int = None, new_amount: int = None):
        """
        Update products in baskets in the db.
        old_<attribute> will composite a constraint of where to update.
        example(if old_username != ""), it will composite the constraint-
                                                where(user.username == old_username).
        new_<attribute> will update the <attribute> to the new value.
        example(if new_username != ""), it will update-
                                                update(user.username = new_username).

        :return: the number of updated rows.
        """
        const_lst = []
        if not (old_username == ""):
            const_lst.append(Expression(self.__tbl.username, OP.EQ, old_username))
        if not (old_product_ref is None):
            const_lst.append(Expression(self.__tbl.product_ref, OP.EQ, old_product_ref))
        if not (old_amount is None):
            const_lst.append(Expression(self.__tbl.amount, OP.EQ, old_amount))
        where_expr = and_exprs(const_lst)

        attributes_as_dictionary = {}
        if not (new_username == ""):
            attributes_as_dictionary[self.__attributes_as_dictionary[self.__attr_username]] = new_username
        if not (new_product_ref is None):
            attributes_as_dictionary[self.__attributes_as_dictionary[self.__attr_product_ref]] = new_product_ref
        if not (new_amount is None):
            attributes_as_dictionary[self.__attributes_as_dictionary[self.__attr_amount]] = new_amount

        if len(attributes_as_dictionary) == 0:
            raise AttributeError("Nothing to update")

        return DbProxy.get_instance().update(self.__tbl, attributes_as_dictionary, where_expr)
    def delete(self,
               appointee_username: str = "",
               store_name: str = "",
               appointer_username: str = ""):
        """
        Delete store owner appointments from the DB.
        <attribute> will composite a constraint of where to delete.
        example(if old_username != ""), it will composite the constraint-
                                               where(user.username == username).

        :return: the number of deleted rows.
        """
        const_lst = []
        if not (appointee_username == ""):
            const_lst.append((Expression(self.__tbl.appointee_username, OP.EQ,
                                         appointee_username)))
        if not (store_name == ""):
            const_lst.append(
                Expression(self.__tbl.store_name, OP.EQ, store_name))
        if not (appointer_username == ""):
            const_lst.append((Expression(self.__tbl.appointer_username, OP.EQ,
                                         appointer_username)))
        where_expr = and_exprs(const_lst)
        return (DbProxy.get_instance()).delete(self.__tbl,
                                               where_expr=where_expr)
    def write(self,
              policy_name: str,
              store_name: str,
              product_name: str,
              percentage: float,
              valid_until: datetime,
              is_active: bool = True):
        """
        Write a store to db.

        :param store_name:
        :param founder_username:
        :return: size of user tbl after inserting the new one.
        """
        attributes_as_dictionary = {
            self.__attributes_as_dictionary[self.__attr_policy_name]:
            policy_name,
            self.__attributes_as_dictionary[self.__attr_store_name]:
            store_name,
            self.__attributes_as_dictionary[self.__attr_product_name]:
            product_name,
            self.__attributes_as_dictionary[self.__attr_percentage]:
            percentage,
            self.__attributes_as_dictionary[self.__attr_valid_until]:
            valid_until,
            self.__attributes_as_dictionary[self.__attr_is_active]: is_active
        }

        return (DbProxy.get_instance()).write(self.__tbl,
                                              attributes_as_dictionary)
    def write(self,
              date: datetime = datetime(datetime.now().year,
                                        datetime.now().month,
                                        datetime.now().day),
              guests: int = 0,
              subscribers: int = 0,
              store_managers: int = 0,
              store_owners: int = 0,
              system_managers: int = 0):
        """
        Write a statistics to db.
        :return: size of user tbl after inserting the new one.
        """
        attributes_as_dictionary = {
            self.__attributes_as_dictionary[self.__attr_date]:
            date,
            self.__attributes_as_dictionary[self.__attr_guests]:
            guests,
            self.__attributes_as_dictionary[self.__attr_subscribers]:
            subscribers,
            self.__attributes_as_dictionary[self.__attr_store_managers]:
            store_managers,
            self.__attributes_as_dictionary[self.__attr_store_owners]:
            store_owners,
            self.__attributes_as_dictionary[self.__attr_system_managers]:
            system_managers
        }

        return (DbProxy.get_instance()).write(self.__tbl,
                                              attributes_as_dictionary)
    def write(self,
              policy_ref: int = None,
              precondition_product: str = "",
              precondition_min_amount: int = None,
              precondition_min_basket_price: float = None):
        """
        Write a store to db.

        :param store_name:
        :param founder_username:
        :return: size of user tbl after inserting the new one.
        """
        attributes_as_dictionary = {
            self.__attributes_as_dictionary[self.__attr_policy_ref]:
            policy_ref,
            self.__attributes_as_dictionary[self.__attr_precondition_product]:
            precondition_product,
            self.__attributes_as_dictionary[self.__attr_precondition_min_amount]:
            precondition_min_amount,
            self.__attributes_as_dictionary[self.__attr_precondition_min_basket_price]:
            precondition_min_basket_price
        }

        return (DbProxy.get_instance()).write(self.__tbl,
                                              attributes_as_dictionary)
    def read(self,
             attributes_to_read: [str],
             appointee_username: str = "",
             store_name: str = "",
             appointer_username: str = ""):
        """
        Read store owner appointment from db.
        Raise exception if an attribute in attributes_to_read is illegal.
        <attribute> will composite a constraint of where to read.
        example(if old_username != ""), it will composite the constraint-
                                               where(user.username == username).

        :param attributes_to_read: lst of attributes to read.
        :param appointee_username: pk.
        :param store_name: pk.
        :param appointer_username:
        :return: dict of the result data.
        """
        if len(attributes_to_read) > 0:
            for attribute in attributes_to_read:
                if attribute.lower(
                ) not in self.__attributes_as_dictionary.keys():
                    raise AttributeError("Attribute " + attribute +
                                         " doesn't exist in " +
                                         str(type(self.__tbl)) + ".")
        else:
            attributes_to_read = self.__attributes_as_dictionary.keys()

        const_lst = []
        if not (appointee_username == ""):
            const_lst.append((Expression(self.__tbl.appointee_username, OP.EQ,
                                         appointee_username)))
        if not (store_name == ""):
            const_lst.append(
                Expression(self.__tbl.store_name, OP.EQ, store_name))
        if not (appointer_username == ""):
            const_lst.append((Expression(self.__tbl.appointer_username, OP.EQ,
                                         appointer_username)))
        where_expr = and_exprs(const_lst)

        result = (DbProxy.get_instance()).read(self.__tbl,
                                               where_expr=where_expr)
        output_lst = []
        for data_obj in result:
            data_as_dictionary = {}
            if self.__attr_appointee_username in attributes_to_read:
                data_as_dictionary[
                    self.
                    __attr_appointee_username] = data_obj.appointee_username
            if self.__attr_store_name in attributes_to_read:
                data_as_dictionary[
                    self.__attr_store_name] = data_obj.store_name
            if self.__attr_appointer_username in attributes_to_read:
                data_as_dictionary[
                    self.
                    __attr_appointer_username] = data_obj.appointer_username
            output_lst.append(data_as_dictionary)

        return output_lst
Ejemplo n.º 15
0
    def test_update(self):
        try:
            (UserData.get_instance()).update()
            self.fail()
        except AttributeError:
            pass
        except Exception:
            self.fail()

        DbProxy.get_instance().update = MagicMock(return_value=1)
        res = UserData.get_instance().update(new_is_system_manager=True)
        self.assertEqual(res, 1)

        DbProxy.get_instance().update = MagicMock(return_value=1)
        res = UserData.get_instance().update(old_password="******",
                                             old_is_system_manager=True,
                                             new_is_system_manager=False)
        self.assertEqual(res, 1)
Ejemplo n.º 16
0
    def update(self,
               old_username: str = "",
               old_password: str = "",
               old_is_system_manager: bool = None,
               new_username: str = "",
               new_password: str = "",
               new_is_system_manager: bool = None):
        """
        Update users in the db.
        old_<attribute> will composite a constraint of where to update.
        example(if old_username != ""), it will composite the constraint-
                                                where(user.username == old_username).
        new_<attribure> will update the <attribute> to the new value.
        example(if new_username != ""), it will update-
                                                update(user.username = new_username).


        :param old_username: pk. will composite a constraint on the username.
        :param old_password: will composite a constraint on the password.
        :param old_is_system_manager: will composite a constraint on the is_system_manager.
        :param new_username: pk. will update the username to the new value.
        :param new_password: will update the password to the new value.
        :param new_is_system_manager: will update the is_system_manager to the new value.
        :return: the number of updated rows.
        """
        const_lst = []
        if not (old_username == ""):
            const_lst.append(
                Expression(self.__tbl.username, OP.EQ, old_username))
        if not (old_password == ""):
            const_lst.append(
                Expression(self.__tbl.password, OP.EQ, old_password))
        if old_is_system_manager is not None:
            const_lst.append(
                Expression(self.__tbl.is_system_manager, OP.EQ,
                           old_is_system_manager))
        where_expr = and_exprs(const_lst)

        attributes_as_dictionary = {}
        if not (new_username == ""):
            attributes_as_dictionary[self.__attributes_as_dictionary[
                self.__attr_username]] = new_username
        if not (new_password == ""):
            attributes_as_dictionary[self.__attributes_as_dictionary[
                self.__attr_password]] = new_password
        if new_is_system_manager is not None:
            attributes_as_dictionary[self.__attributes_as_dictionary[self.__attr_is_system_manager]] = \
                new_is_system_manager

        if len(attributes_as_dictionary) == 0:
            raise AttributeError("Nothing to update")

        return DbProxy.get_instance().update(self.__tbl,
                                             attributes_as_dictionary,
                                             where_expr)
Ejemplo n.º 17
0
    def read(self,
             attributes_to_read: [str],
             store_name="",
             founder_username=""):
        """
        Read users from db.
        Raise exception if an attribute in attributes_to_read is illegal.
        <attribute> will composite a constraint of where to read.
        example(if old_username != ""), it will composite the constraint-
                                               where(user.username == username).

        :param founder_username:
        :param store_name:
        :param attributes_to_read: the list of attributes that will return from the db.
                                    type: [str]

        :return: list of dictionaries that contain attributes_to_read fields.
        """
        if len(attributes_to_read) > 0:
            for attribute in attributes_to_read:
                if attribute.lower(
                ) not in self.__attributes_as_dictionary.keys():
                    raise AttributeError("Attribute " + attribute +
                                         " doesn't exist in " +
                                         str(type(self.__tbl)) + ".")
        else:
            attributes_to_read = [
                self.__attr_store_name, self.__attr_founder_username
            ]

        const_lst = []
        if not (store_name == ""):
            const_lst.append(
                Expression(self.__tbl.store_name, OP.EQ, store_name))
        if not (founder_username == ""):
            const_lst.append(
                Expression(self.__tbl.founder_username, OP.EQ,
                           founder_username))
        where_expr = and_exprs(const_lst)

        result = (DbProxy.get_instance()).read(self.__tbl,
                                               where_expr=where_expr)
        output_lst = []
        for data_obj in result:
            data_as_dictionary = {}
            if self.__attr_store_name in attributes_to_read:
                data_as_dictionary[
                    self.__attr_store_name] = data_obj.store_name
            if self.__attr_founder_username in attributes_to_read:
                data_as_dictionary[
                    self.__attr_founder_username] = data_obj.founder_username
            output_lst.append(data_as_dictionary)

        return output_lst
Ejemplo n.º 18
0
    def write(self, username: str = "", store_name: str = "", total_price: float = None, date: datetime = None):
        """
        write store owner appointment to db.

        :return:
        """
        attributes_as_dictionary = {self.__attributes_as_dictionary[self.__attr_username]: username,
                                    self.__attributes_as_dictionary[self.__attr_store_name]: store_name,
                                    self.__attributes_as_dictionary[self.__attr_total_price]: total_price,
                                    self.__attributes_as_dictionary[self.__attr_date]: date}

        return (DbProxy.get_instance()).write(self.__tbl, attributes_as_dictionary)
Ejemplo n.º 19
0
    def write(self, username: str, product_ref: int, amount: int):
        """
        Write a products in basket to db.

        :param username:
        :param product_ref:
        :param amount:
        :return: size of user tbl after inserting the new one.
        """
        attributes_as_dictionary = {self.__attributes_as_dictionary[self.__attr_username]: username,
                                    self.__attributes_as_dictionary[self.__attr_product_ref]: product_ref,
                                    self.__attributes_as_dictionary[self.__attr_amount]: amount}

        return (DbProxy.get_instance()).write(self.__tbl, attributes_as_dictionary)
    def update(self,
               old_policy_ref: int = None,
               old_policy1_ref: int = None,
               old_policy2_ref: int = None,
               old_flag: int = None,
               new_policy1_ref: int = None,
               new_policy2_ref: int = None,
               new_flag: int = None):
        """
        Update users in the db.
        old_<attribute> will composite a constraint of where to update.
        example(if old_username != ""), it will composite the constraint-
                                                where(user.username == old_username).
        new_<attribute> will update the <attribute> to the new value.
        example(if new_username != ""), it will update-
                                                update(user.username = new_username).

        :return: the number of updated rows.
        """
        const_lst = []
        if not (old_policy_ref is None):
            const_lst.append(
                Expression(self.__tbl.policy_ref, OP.EQ, old_policy_ref))
        if not (old_policy1_ref is None):
            const_lst.append(
                Expression(self.__tbl.policy1_ref, OP.EQ, old_policy1_ref))
        if not (old_policy2_ref is None):
            const_lst.append(
                Expression(self.__tbl.policy2_ref, OP.EQ, old_policy2_ref))
        if not (old_flag is None):
            const_lst.append(Expression(self.__tbl.flag, OP.EQ, old_flag))
        where_expr = and_exprs(const_lst)

        attributes_as_dictionary = {}
        if not (new_policy1_ref == ""):
            attributes_as_dictionary[self.__attributes_as_dictionary[self.__attr_policy1_ref]] = \
                new_policy1_ref
        if not (new_policy2_ref is None):
            attributes_as_dictionary[self.__attributes_as_dictionary[self.__attr_policy2_ref]] = \
                new_policy2_ref
        if not (new_flag is None):
            attributes_as_dictionary[self.__attributes_as_dictionary[self.__attr_flag]] = \
                old_flag

        if len(attributes_as_dictionary) == 0:
            raise AttributeError("Nothing to update")

        return DbProxy.get_instance().update(self.__tbl,
                                             attributes_as_dictionary,
                                             where_expr)
Ejemplo n.º 21
0
    def read(self, attributes_to_read: [str], purchase_id: int = None, username: str = "", store_name: str = "",
             total_price: float = None, date: datetime = None):
        """
        Read store owner appointment from db.
        Raise exception if an attribute in attributes_to_read is illegal.
        <attribute> will composite a constraint of where to read.
        example(if old_username != ""), it will composite the constraint-
                                               where(user.username == username).

        :return: dict of the result data.
        """
        if len(attributes_to_read) > 0:
            for attribute in attributes_to_read:
                if attribute.lower() not in self.__attributes_as_dictionary.keys():
                    raise AttributeError("Attribute " + attribute + " doesn't exist in " + str(type(self.__tbl)) + ".")
        else:
            attributes_to_read: list = list(self.__attributes_as_dictionary.keys())
            attributes_to_read.remove(self.__attr_purchase_id)

        const_lst = []
        if not (purchase_id is None):
            const_lst.append((Expression(self.__tbl.purchase_id, OP.EQ, purchase_id)))
        if not (username == ""):
            const_lst.append((Expression(self.__tbl.username, OP.EQ, username)))
        if not (store_name == ""):
            const_lst.append(Expression(self.__tbl.store_name, OP.EQ, store_name))
        if not (total_price is None):
            const_lst.append((Expression(self.__tbl.total_price, OP.EQ, total_price)))
        if not (date is None):
            const_lst.append((Expression(self.__tbl.date, OP.EQ, date)))
        where_expr = and_exprs(const_lst)

        result = (DbProxy.get_instance()).read(self.__tbl, where_expr=where_expr)
        output_lst = []
        for data_obj in result:
            data_as_dictionary = {}
            if self.__attr_purchase_id in attributes_to_read:
                data_as_dictionary[self.__attr_purchase_id] = data_obj.purchase_id
            if self.__attr_username in attributes_to_read:
                data_as_dictionary[self.__attr_username] = data_obj.username.username
            if self.__attr_store_name in attributes_to_read:
                data_as_dictionary[self.__attr_store_name] = data_obj.store_name.store_name
            if self.__attr_total_price in attributes_to_read:
                data_as_dictionary[self.__attr_total_price] = data_obj.total_price
            if self.__attr_date in attributes_to_read:
                data_as_dictionary[self.__attr_date] = data_obj.date
            output_lst.append(data_as_dictionary)

        return output_lst
Ejemplo n.º 22
0
    def test_read(self):
        try:
            (UserData.get_instance()).read(["not_attribute"])
            self.fail()
        except AttributeError:
            pass
        except Exception:
            self.fail()

        (DbProxy.get_instance()).read = MagicMock(
            return_value=[StubUserData("eytan", "password", False)])
        res = (UserData.get_instance()).read([], username="******")
        self.assertEqual((res[0]['username'], res[0]['password'],
                          res[0]['is_system_manager']),
                         ("eytan", "password", False))

        res = (UserData.get_instance()).read([], password="******")
        self.assertEqual((res[0]['username'], res[0]['password'],
                          res[0]['is_system_manager']),
                         ("eytan", "password", False))

        (DbProxy.get_instance()).read = MagicMock(return_value=[])
        res = (UserData.get_instance()).read([], is_system_manager=True)
        self.assertListEqual([], res)
    def update(self,
               old_appointee_username: str = "",
               old_store_name: str = "",
               old_appointer_username: str = "",
               new_appointee_username: str = "",
               new_store_name: str = "",
               new_appointer_username: str = ""):
        """
        Update store owner appointment in the db.
        old_<attribute> will composite a constraint of where to update.
        example(if old_username != ""), it will composite the constraint-
                                                where(user.username == old_username).
        new_<attribute> will update the <attribute> to the new value.
        example(if new_username != ""), it will update-
                                                update(user.username = new_username).

        :return: the number of updated rows.
        """
        const_lst = []
        if not (old_appointee_username == ""):
            const_lst.append((Expression(self.__tbl.appointee_username, OP.EQ,
                                         old_appointee_username)))
        if not (old_store_name == ""):
            const_lst.append(
                Expression(self.__tbl.store_name, OP.EQ, old_store_name))
        if not (old_appointer_username == ""):
            const_lst.append((Expression(self.__tbl.appointer_username, OP.EQ,
                                         old_appointer_username)))
        where_expr = and_exprs(const_lst)

        attributes_as_dictionary = {}
        if not (new_appointee_username == ""):
            attributes_as_dictionary[self.__attributes_as_dictionary[self.__attr_appointee_username]] = \
                new_appointee_username
        if not (new_store_name == ""):
            attributes_as_dictionary[self.__attributes_as_dictionary[
                self.__attr_store_name]] = new_store_name
        if not (new_appointer_username == ""):
            attributes_as_dictionary[self.__attributes_as_dictionary[self.__attr_appointer_username]] = \
                new_appointer_username
        if len(attributes_as_dictionary) == 0:
            raise AttributeError("Nothing to update")

        return DbProxy.get_instance().update(self.__tbl,
                                             attributes_as_dictionary,
                                             where_expr)
Ejemplo n.º 24
0
    def read(self, attributes_to_read: [str], username: str = "", product_ref: int = None, amount: int = None):
        """
        Read products in baskets from db.
        Raise exception if an attribute in attributes_to_read is illegal.
        <attribute> will composite a constraint of where to read.
        example(if old_username != ""), it will composite the constraint-
                                               where(user.username == username).

        :param username: pk.
        :param product_ref: pk.
        :param amount:
        :param attributes_to_read: the list of attributes that will return from the db.
                                    type: [str]

        :return: list of dictionaries that contain attributes_to_read fields.
        """
        if len(attributes_to_read) > 0:
            for attribute in attributes_to_read:
                if attribute.lower() not in self.__attributes_as_dictionary.keys():
                    raise AttributeError("Attribute " + attribute + " doesn't exist in " + str(type(self.__tbl)) + ".")
        else:
            attributes_to_read = list(self.__attributes_as_dictionary.keys())

        const_lst = []
        if not (username == ""):
            const_lst.append(Expression(self.__tbl.username, OP.EQ, username))
        if not (product_ref is None):
            const_lst.append(Expression(self.__tbl.product_ref, OP.EQ, product_ref))
        if not (amount is None):
            const_lst.append(Expression(self.__tbl.amount, OP.EQ, amount))
        where_expr = and_exprs(const_lst)

        result = (DbProxy.get_instance()).read(self.__tbl, where_expr=where_expr)
        output_lst = []
        for data_obj in result:
            user_data_as_dictionary = {}
            if self.__attr_username in attributes_to_read:
                user_data_as_dictionary[self.__attr_username] = data_obj.username.username
            if self.__attr_product_ref in attributes_to_read:
                user_data_as_dictionary["store_name"] = data_obj.product_ref.store_name.store_name
                user_data_as_dictionary["product_name"] = data_obj.product_ref.product_name
            if self.__attr_amount in attributes_to_read:
                user_data_as_dictionary[self.__attr_amount] = data_obj.amount
            output_lst.append(user_data_as_dictionary)

        return output_lst
Ejemplo n.º 25
0
    def write(self, store_name="", founder_username=""):
        """
        Write a store to db.

        :param store_name:
        :param founder_username:
        :return: size of user tbl after inserting the new one.
        """
        attributes_as_dictionary = {
            self.__attributes_as_dictionary[self.__attr_store_name]:
            store_name,
            self.__attributes_as_dictionary[self.__attr_founder_username]:
            founder_username
        }

        return (DbProxy.get_instance()).write(self.__tbl,
                                              attributes_as_dictionary)
Ejemplo n.º 26
0
    def delete(self, username: str = "", product_ref: int = None, amount: int = None):
        """
        Delete products in baskets from the DB.
        <attribute> will composite a constraint of where to delete.
        example(if old_username != ""), it will composite the constraint-
                                               where(user.username == username).

        :return: the number of deleted rows.
        """
        const_lst = []
        if not (username == ""):
            const_lst.append(Expression(self.__tbl.username, OP.EQ, username))
        if not (product_ref is None):
            const_lst.append(Expression(self.__tbl.product_ref, OP.EQ, product_ref))
        if not (amount is None):
            const_lst.append(Expression(self.__tbl.amount, OP.EQ, amount))
        where_expr = and_exprs(const_lst)
        return (DbProxy.get_instance()).delete(self.__tbl, where_expr=where_expr)
    def delete(self,
               discount_policy_id: int = None,
               policy_name: str = "",
               store_name="",
               product_name: str = "",
               percentage: float = None,
               valid_until: datetime = None,
               is_active: bool = None):
        """
        Delete users from the DB.
        <attribute> will composite a constraint of where to delete.
        example(if old_username != ""), it will composite the constraint-
                                               where(user.username == username).

        :return: the number of deleted rows.
        """
        const_lst = []
        if not (discount_policy_id is None):
            const_lst.append(
                Expression(self.__tbl.discount_policy_id, OP.EQ,
                           discount_policy_id))
        if not (policy_name == ""):
            const_lst.append(
                Expression(self.__tbl.policy_name, OP.EQ, policy_name))
        if not (store_name == ""):
            const_lst.append(
                Expression(self.__tbl.store_name, OP.EQ, store_name))
        if not (product_name == ""):
            const_lst.append(
                Expression(self.__tbl.product_name, OP.EQ, product_name))
        if not (percentage is None):
            const_lst.append(
                Expression(self.__tbl.percentage, OP.EQ, percentage))
        if not (valid_until is None):
            const_lst.append(
                Expression(self.__tbl.valid_until, OP.EQ, valid_until))
        if not (is_active is None):
            const_lst.append(Expression(self.__tbl.is_active, OP.EQ,
                                        is_active))
        where_expr = and_exprs(const_lst)
        return (DbProxy.get_instance()).delete(self.__tbl,
                                               where_expr=where_expr)
    def write(self, appointee_username: str, store_name: str,
              appointer_username: str):
        """
        write store owner appointment to db.

        :param appointee_username: pk
        :param store_name:pk
        :param appointer_username:
        :return:
        """
        attributes_as_dictionary = {
            self.__attributes_as_dictionary[self.__attr_appointee_username]:
            appointee_username,
            self.__attributes_as_dictionary[self.__attr_store_name]:
            store_name,
            self.__attributes_as_dictionary[self.__attr_appointer_username]:
            appointer_username
        }

        return (DbProxy.get_instance()).write(self.__tbl,
                                              attributes_as_dictionary)
Ejemplo n.º 29
0
    def write(self,
              username: str,
              password: str,
              is_system_manager: bool = False):
        """
        Write a user to db.

        :param username: pk
        :param password: user password.
        :param is_system_manager:
        :return: size of user tbl after inserting the new one.
        """
        attributes_as_dictionary = {
            self.__attributes_as_dictionary[self.__attr_username]:
            username,
            self.__attributes_as_dictionary[self.__attr_password]:
            password,
            self.__attributes_as_dictionary[self.__attr_is_system_manager]:
            is_system_manager
        }

        return (DbProxy.get_instance()).write(self.__tbl,
                                              attributes_as_dictionary)
    def delete(self,
               date: datetime = None,
               guests: int = None,
               subscribers: int = None,
               store_managers: int = None,
               store_owners: int = None,
               system_managers: int = None):
        """
        Delete statistics from the DB.
        <attribute> will composite a constraint of where to delete.
        example(if old_username != ""), it will composite the constraint-
                                               where(user.username == username).

        :return: the number of deleted rows.
        """
        const_lst = []
        if not (date is None):
            const_lst.append(Expression(self.__tbl.date, OP.EQ, date))
        if not (guests is None):
            const_lst.append(Expression(self.__tbl.guests, OP.EQ, guests))
        if not (subscribers is None):
            const_lst.append(
                Expression(self.__tbl.subscribers, OP.EQ, subscribers))
        if not (store_managers is None):
            const_lst.append(
                Expression(self.__tbl.store_managers, OP.EQ, store_managers))
        if not (store_owners is None):
            const_lst.append(
                Expression(self.__tbl.store_owners, OP.EQ, store_owners))
        if not (system_managers is None):
            const_lst.append(
                Expression(self.__tbl.system_managers, OP.EQ, system_managers))
        where_expr = and_exprs(const_lst)

        return (DbProxy.get_instance()).delete(self.__tbl,
                                               where_expr=where_expr)