Example #1
0
def test_unserialization():

    item = ItemModel('item_name', 10, True, '12345')

    serialized = item.serialize()

    assert item == ItemModel.unserialize(serialized)
 def unlock(self, filter, user, etag):
     item_model = ItemModel(self.data_layer)
     filter[LOCK_USER] = user
     # filter[ETAG] = etag
     item = item_model.find_one(filter)
     if item:
         updates = {LOCK_USER: None, 'lock_time': None}
         item_model.update(filter, updates)
    def test_store_relationship(self):
        with self.app_context():
            store = StoreModel('test_store')
            item = ItemModel('test', 19.99, 1)

            store.save_to_db()
            item.save_to_db()

            self.assertEqual(item.store.name, 'test_store')
Example #4
0
    def test_store_relationship(self):
        with self.app_context():
            store = StoreModel('test')
            item = ItemModel('test_item', 19.99, 1)
            store.save_to_db()
            item.save_to_db()

            self.assertEqual(store.items.count(), 1)
            self.assertEqual(store.items.first().name, 'test_item')
Example #5
0
def test_serialization():

    item = ItemModel('item_name', 10, True, '12345')

    expected_serialization = {'name': 'item_name',
                              'quantity': 10,
                              'usable': True,
                              'user_id': '12345'}

    assert item.serialize() == expected_serialization
Example #6
0
    def test_item_json(self):
        item = ItemModel('test', 19.99, 1)
        expected = {
            'name': 'test',
            'price': 19.99
        }

        self.assertEqual(item.json(), expected,
                         f'The JSON export of the item is incorrect. '
                         f'Received {item.json()}, expected {expected}')
 def test_put_update_item(self):
     with self.app() as client:
         with self.app_context():
             StoreModel('test').save_to_db()
             ItemModel('test', 19, 1).save_to_db()
             self.assertEqual(ItemModel.find_by_name('test').price, 19)
             response = client.put('/item/test', data={'name': 'test', 'price': 17, 'store_id': 1})
             self.assertEqual(response.status_code, 200)
             self.assertDictEqual({'name': 'test', 'price': 17}, json.loads(response.data))
             self.assertEqual(ItemModel.find_by_name('test').price, 17)
 def lock(self, filter, user, etag):
     item_model = ItemModel(self.data_layer)
     item = item_model.find_one(filter)
     if item and self._can_lock(item, user):
         # filter[ETAG] = etag
         updates = {LOCK_USER: user, 'lock_time': utcnow()}
         item_model.update(filter, updates)
         item[LOCK_USER] = user
     else:
         raise SuperdeskError('Item locked by another user')
     return item
    def test_item_json(self):
        item = ItemModel('test', 19.99)
        expected = {
            'name': 'test',
            'price': 19.99
        }

        self.assertEqual(
            item.json(),
            expected,
            "The JSON export of the item is incorrect. Received {}, expected {}.".format(item.json(), expected))
    def put(self, name):
        data = Item.parser.parse_args()

        item = ItemModel.find_by_name(name)

        if item:
            item.price = data['price']
        else:
            item = ItemModel(name, **data)

        item.save_to_db()

        return item.json()
Example #11
0
    def post(self, name):
        if ItemModel.find_by_name(name):
            return {'message': "An item with name '{}' already exists.".format(name)}

        data = Item.parser.parse_args()

        item = ItemModel(name, data['price'], data['store_id'])

        try:
            item.save_to_db()
        except:
            return {"message": "An error occurred inserting the item."}

        return item.json()
    def post(self, name):
        if ItemModel.find_by_name(name):
            return {'message': "An item with name '{}' already exists.".format(name)}, 400

        data = Item.parser.parse_args()

        item = ItemModel(name, **data)

        try:
            item.save_to_db()
        except:
            return {"message": "An error occurred inserting the item."}, 500

        return item.json(), 201
Example #13
0
    def test_store_json_with_item(self):
        with self.app_context():

            store = StoreModel('test')
            item = ItemModel('test_item', 19.99, 1)

            store.save_to_db()
            item.save_to_db()

            expected = {
                'name': 'test',
                'items': [{'name': 'test_item', 'price': 19.99}]
            }

            self.assertDictEqual(store.json(), expected)
    def test_put_update_item(self):
        with self.app() as c:
            with self.app_context():
                StoreModel('test').save_to_db()
                c.put('/item/test', data={'price': 17.99, 'store_id': 1})
                r = c.put('/item/test', data={'price': 18.99, 'store_id': 1})

                self.assertEqual(r.status_code, 200)
                self.assertEqual(ItemModel.find_by_name('test').price, 18.99)
Example #15
0
 def get(self):
     user_id = get_jwt_identity()
     items = [item.json() for item in ItemModel.find_all()]
     if user_id:
         return {'items': items}, 200
     return {
         'items': [item['name'] for item in items],
         'message': 'More data available if you log in.'
     }, 200
    def test_put_item(self):
        with self.app() as c:
            with self.app_context():
                StoreModel('test').save_to_db()
                r = c.put('/item/test', data={'price': 17.99, 'store_id': 1})

                self.assertEqual(r.status_code, 200)
                self.assertEqual(ItemModel.find_by_name('test').price, 17.99)
                self.assertDictEqual(d1={'name': 'test', 'price': 17.99},
                                     d2=json.loads(r.data))
    def delete(self, name):
        claims = get_jwt_claims()
        if not claims['is_admin']:
            return {'message': 'Admin privilege required.'}, 401

        item = ItemModel.find_by_name(name)
        if item:
            item.delete_from_db()
            return {'message': 'Item deleted.'}
        return {'message': 'Item not found.'}, 404
    def test_crud(self):
        with self.app_context():
            item = ItemModel('test', 19.99)

            self.assertIsNone(ItemModel.find_by_name('test'),
                              "Found an item with name {}, but expected not to.".format(item.name))

            item.save_to_db()

            self.assertIsNotNone(ItemModel.find_by_name('test'))

            item.delete_from_db()

            self.assertIsNone(ItemModel.find_by_name('test'))
    def test_crud(self):
        with self.app_context():
            store = StoreModel('test')
            store.save_to_db()
            item = ItemModel('test', 19.99, 1)

            self.assertIsNone(ItemModel.find_by_name('test'), "Found an item with name 'test' before save_to_db")

            item.save_to_db()

            self.assertIsNotNone(ItemModel.find_by_name('test'),
                                 "Did not find an item with name 'test' after save_to_db")

            item.delete_from_db()

            self.assertIsNone(ItemModel.find_by_name('test'), "Found an item with name 'test' after delete_from_db")
Example #20
0
    def put(self, name):
        data = Item.parser.parse_args()
        item = ItemModel.find_by_name(name)
        if item is None:
            item = ItemModel(name, data['price'], data['store_id'])
        else:
            item.price = data['price']

        item.save_to_db()
        return item.json()
    def get(self):
        """
        Here we get the JWT identity, and then if the user is logged in (we were able to get an identity)
        we return the entire item list.

        Otherwise we just return the item names.

        This could be done with e.g. see orders that have been placed, but not see details about the orders
        unless the user has logged in.
        """
        user_id = get_jwt_identity()
        items = [item.json() for item in ItemModel.find_all()]
        if user_id:
            return {'items': items}, 200
        return {
            'items': [item['name'] for item in items],
            'message': 'More data available if you log in.'
        }, 200
Example #22
0
 def get(self, id):
     items = ItemModel.find_by_user(id)
     if items:
         return {"items": list(map(lambda x: x.json(), items))}
     return {"message": "Item not found"}, 404
Example #23
0
    def delete(self, name):
        item = ItemModel.find_by_name(name)
        if item:
            item.delete_from_db()

        return {"message": "item {} deleted".format(name)}
Example #24
0
 def delete(self, name):
     item = ItemModel.find_by_name(name)
     if item:
         item.delete_from_db()
         return {"message": ITEM_DELETED}, 200
     return {"message": ITEM_NOT_FOUND}, 404
Example #25
0
 def delete(self, name):
     item = ItemModel.find_by_name(name)
     if item:
         item.delete_from_db()
     return {"message": "Item Deleted."}, 200
Example #26
0
 def get(self, name):
     #item = self.get_item_by_name(name)
     item = ItemModel.get_item_by_name(name)
     if item:
         return item.json()
     return {'message': 'item not found'}, 404
Example #27
0
 def get(self, name):
     item = ItemModel.find_by_name(name)  #could also be Item.find_by_name
     if item is not None:
         return item.json()
     else:
         return {"message": "item not found"}, 404
 def get(self, name):
     item = ItemModel.find_by_name(name)
     if item:
         #because now it returns an item object
         return item.json()
     return {'message':'Item not found!'}, 404
Example #29
0
 def get(self, name):
     res = ItemModel.findByName(name)
     if res:
         return res.json(), 200
     else:
         return {"item": "item not found"}, 404
Example #30
0
 def get(self, name):
     item = ItemModel.findByName(name)
     if item:
         return item.json()
     return {'message': 'Item doesn\'t exist'}, 404
Example #31
0
    def test_store_json_with_item(self):
        with self.app_context():
            store = StoreModel('test')
            item = ItemModel('test_item', 19.99, 1)

            store.save_to_db()
            item.save_to_db()

            expected = {
                'name': 'test',
                'items': [{
                    'name': 'test_item',
                    'price': 19.99
                }]
            }

            self.assertDictEqual(store.json(), expected)

        with self.app_context():
            item = ItemModel('test', 19.99, 1)

            self.assertIsNone(
                ItemModel.find_by_name('test'),
                "Found an item iwth name {}, but expected not to.".format(
                    item.name))

            item.save_to_db()

            self.assertIsNotNone(ItemModel.find_by_name('test'))

            item.delete_from_db()

            self.assertIsNone(ItemModel.find_by_name('test'))
 def test_crud(self):
     with self.app_context():
         item = ItemModel('test', 19.99)
         item.save_to_db()
         self.assertIsNone(ItemModel.find_by_name('test'))
         self.assertIsNotNone(ItemModel.find_by_name('test'))
Example #33
0
    def test_crud(self):
        item = ItemModel("test", 19.99)

        self.
Example #34
0
 def delete(self, name: str):
     item = ItemModel.find_by_name(name)
     if item:
         item.delete_from_db()
     return "", 204
Example #35
0
 def get(self, name):
     item = ItemModel.find_by_name(name)
     if item:
         return item.json(
         )  # as ItemModel returns a object and not a dictionary
     return {"message": "item not founddd"}, 404
Example #36
0
 def delete(self, name):
     item = ItemModel.find_by_name(name)
     if item:
         item.delete_from_db()
         return {'message': 'Item was deleted'}
     return {'message': 'Item not existing'}
Example #37
0
 def get(self, name):
     item = ItemModel.find_by_name(name)
     if item:
         return item.json()
     return {"message": f"Item with name {name} not found."}, 404
Example #38
0
 def get(self, name):
     item = ItemModel.find_by_name(name)
     if item:
         return item_schema.dump(item), 200
     return {"message": ITEM_NOT_FOUND}, 404
Example #39
0
    today = datetime.date.today()
    weekday = today.weekday()
    start_delta = datetime.timedelta(days=weekday, weeks=1)
    start_of_previous_week = today - start_delta
    start = start_of_previous_week + datetime.timedelta(days=0)
    end = start_of_previous_week + datetime.timedelta(days=6)
    return start, end


with app.app_context():
    previousWeekStart, previousWeekEnd = getPreviousWeekDateTime()
    categories = CategoryModel.get_all()
    for category in categories:
        categoryTypes = CategoryTypeModel.find_by_categoryID(category.id)
        for categoryType in categoryTypes:
            items = ItemModel.find_by_category_type(categoryType.id)
            availableItemQuantity = 0
            for item in items:
                availableItemQuantity += item.quantity
            queueItems = QueueItemModel.find_by_categoryTypeID(categoryType.id)
            userQueueItems = {}
            requestedQuantity = 0
            for queueItem in queueItems:
                requestedQuantity += queueItem.request.quantity
                if queueItem.userID not in userQueueItems:
                    userQueueItems[queueItem.userID] = [queueItem]
                else:
                    userQueueItems[queueItem.userID].append(queueItem)
                queueItem.allocation = 0
                queueItem.save_to_db()
            if availableItemQuantity >= requestedQuantity:
 def get(self, name):
     item = ItemModel.find_by_name(name)
     if item:
         return item.json()
     return {'message': 'Item not found'}, 404
 def delete(self, name):
     item = ItemModel.find_by_name(name)
     if item:
         item.delete_from_db()
         return {'message': 'Item deleted.'}
     return {'message': 'Item not found.'}, 404
 def get(self):
     return {'items': [x.json() for x in ItemModel.find_all()]}
Example #43
0
    def get(self, item_name):
        item = ItemModel.find_by_name(item_name)

        if item:
            return item.json()
        return {'message': f"{item_name} is not existed in database."}, 404        
Example #44
0
 def get(self):
     return {"items": item_list_schema.dump(ItemModel.find_all())}, 200
Example #45
0
    def test_json(self):
        i = ItemModel('Name', 10.00)
        expected = {'name': 'Name', 'price': 10.00}

        self.assertDictEqual(expected, i.json(), "JSON received does not match expected. Received {} expected {}".format(i.json(), expected))
Example #46
0
 def get(self, name):
     item = ItemModel.find_by_name(name)
     if item:
         return item.json()
     return {"message": "Item not found"}, 404
Example #47
0
 def get(cls):
     return {'items': [x.json() for x in ItemModel.find_all()]}, 200
Example #48
0
 def get(self, name):
     item = ItemModel.find_by_name(name)
     if item:
         return item.json()
     return {'message' : 'Item not found'}, 404
Example #49
0
 def delete(cls, name: str):
     item = ItemModel.find_by_name(name)
     if item:
         item.delete_from_db()
         return {'message': ITEM_DELETED}
     return {'message': ITEM_NOT_FOUND}
Example #50
0
    def delete(self, name):
        item = ItemModel.find_by_name(name)
        if item:
            item.delete_from_db()

        return {'message' : 'Item deleted'}
Example #51
0
 def get(cls, name: str):
     item = ItemModel.find_by_name(name)
     if item:
         return item.json()
     return {'message': ITEM_NOT_FOUND}, 404
Example #52
0
 def delete(cls, name: str):
     item = ItemModel.find_by_name(name)
     if item:
         item.delete_from_db()
         return {"message": ITEM_DELETED}, 200
     return {"message": ITEM_DELETED}, 404
Example #53
0
 def delete(self, name):
     item = ItemModel.findByName(name)
     if item is None:
         return {'message': f'Item with name \'{name}\' doesn\'t exist'}
     item.delete()
     return {'message': f'Item with name \'{name}\' Deleted'}
Example #54
0
 def delete(self, name):
     item = ItemModel.find_by_name(name)
     if item:
         item.delete_from_db()
     return {"message": "Item Was Successfully Deleted"}
 def delete(self, name):
     item = ItemModel.find_by_name(name)
     if item is None:
         return {"message": "Item does not exists"}
     item.delete_from_db()
     return {"message": "Item deleted successfully."}
Example #56
0
 def get(self, name):  # defining methods that the resouce is going to accept
     item = ItemModel.find_by_name(name)
     if item:
         return item.json()
     return {'message': 'Item not found'}, 404