def post(cls, name):
"""
The async function that handles POST requests.
:param name: item name to be created.
:return:
"""
# Check whether the request is properly made.
if ItemModel.find_by_name(name):
return {
'message': "An item with name '{}' already exists".format(name)
}, 400
# Load data
request_data = cls.parser.parse_args()
# Create a new item
item = ItemModel(name, **request_data)
try:
item.save_to_db()
except Exception as e:
return {
'message':
'An error occured inserting the item. Here is the error {}'.
format(e)
}, 500 # Internal Server Error
# Return "response" with item and status code 201: CREATED
return item.json(), 201
def create(event, context):
logger.debug(f'Event received: {json.dumps(event)}')
data = json.loads(event.get('body'))
item = ItemModel(id=str(uuid4()),
name=data.get('name'),
description=data.get('description', 'None'),
slot=data.get('slot'),
quality=data.get('quality'),
damage=data.get('damage'),
level=data.get('level'),
crit_chance=data.get('crit_chance'),
stamina=data.get('stamina'),
is_warrior=data.get('is_warrior', False),
is_sorcerer=data.get('is_sorcerer', False),
is_archer=data.get('is_archer', False),
is_rogue=data.get('is_rogue', False))
item.save()
response = {
'statusCode': 200,
'body': json.dumps(item, cls=ModelEncoder),
'headers': {
'Access-Control-Allow-Origin': '*'
}
}
logger.debug(f'Response: {json.dumps(response)}')
return response
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('fqdn',
type=str,
required=True,
help='FQDN cannot be blank!')
parser.add_argument('ip_address',
type=str,
required=True,
help='IP Address cannot be blank!')
parser.add_argument('mac_address',
type=str,
required=True,
help='MAC Address cannot be blank!')
parser.add_argument('owned_by',
type=str,
required=True,
help='Owned By cannot be blank!')
parser.add_argument('serial_number',
type=str,
required=True,
help='Serial Number Address cannot be blank!')
args = parser.parse_args()
item = ItemModel(fqdn=args['fqdn'],
ip_address=args['ip_address'],
mac_address=args['mac_address'],
owned_by=args['owned_by'],
serial_number=args['serial_number'])
cmdb_manager.insert_item(item)
#return message, status.HTTP_201_CREATED
return Response(status=201)
def post(self, name):
if ItemModel.find_by_name(name) is not None:
return {"message": "Item already exists"}, 403
else:
data = Item.parser.parse_args()
item = ItemModel(name, **data)
item.save_to_db()
return item.json(), 200
def mutate(self, info, product_id=None):
cart = CartModel(total=0)
db_session.add(cart)
db_session.commit()
if product_id is not None:
local_product_id=from_global_id(product_id)[1]
item = ItemModel(cart_id=cart.id,product_id=local_product_id)
db_session.add(item)
db_session.commit()
return CartCreate(cart=cart)
def post(self):
data = Item.parser.parse_args()
name = data['name']
if ItemModel.find_by_name(name):
return {'message': f'Item {name} already exist'}, 400
item = ItemModel(**data)
item.save_to_db()
return json.loads(item.to_json()), 201
def put(self):
data = parser.parse_args()
new_item = ItemModel(title=data['title'],
description=data['description'],
price=data['price'])
try:
new_item.save_to_db()
return {'message': 'Item {} was created'.format(data['title'])}
except Exception as e:
return {'message': str(e)}, 500
def post(self, name):
data = Item.parser.parse_args()
if ItemModel.find_by_name(name):
return {'message': 'Item with name {} already exists.'.format(name)}, 400
item = ItemModel(name, **data)
try:
item.save_to_db()
except:
return {'message': 'Internal server error creating item'}, 500
return item.json(), 201
def put(self, name):
data = Item.parser.parse_args()
item = ItemModel.find_by_name(name)
if not item:
item = ItemModel(name, **data)
else:
item.price = data['price']
item.store_id = data['store_id']
item.save_to_db()
return item.json(), 200
def create_item():
if request.method == "POST":
name = request.form['name']
model_id = request.args.get('model_id')
#image logic
username = session['username']
folder = f"user_{username}"
# validation and sanity checks
if model_id is None:
return "Missing model number"
if 'file1' not in request.files:
return "Missing file part"
if ItemModel.find_by_storeid_and_itemname(model_id, name):
return gettext("web_items_alredyexists")
file1 = request.files['file1']
#data = image_schema.load(file1)
try:
#image_path = image_helper.save_image(data["image"], folder=folder)
image_path = image_helper.save_image(file1,
folder=os.path.join(
folder, model_id))
logger.info(image_path)
basename = image_helper.get_basename(image_path)
logger.info(basename)
except UploadNotAllowed: # forbidden file type
extension = image_helper.get_extension(file1)
return f"Unable to upload the extension {extension}"
#create item in database
item = ItemModel(name=name,
filename=file1.filename,
objname=image_path,
store_id=model_id)
print(item)
try:
item.save_to_db()
except:
return "Error creating item"
return redirect(url_for(".index", model_id=model_id))
#Get implementation
model_id = request.args.get('model_id')
return render_template("items/new_item.html", model_id=model_id)
def post(self, name):
if ItemModel.find_by_name(name):
return {'message': 'A item with that name already exists'}, 400
data = Item.parser.parse_args()
item = ItemModel(name, **data)
try:
item.save()
except:
return dict(message="An error occurred inserting the item"), 500
return {'message': 'Item created successfully'}, 201
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'])
try:
item.insert()
except:
return {"message": "An error occurred inserting the item."}
return item.json()
def _populate_model(entity):
if not entity:
return None
model = ItemModel()
model.id = get_resource_id_from_key(entity.key)
model.item_id = entity.item_id
model.user_ids = entity.user_ids
model.total_likes = entity.total_likes
model.total_dislikes = entity.total_dislikes
model.total_preferences = entity.total_preferences
model.created_timestamp = entity.created_timestamp
model.latest_timestamp = entity.latest_timestamp
return model
def put(self):
data = Item.parser.parse_args()
name = data['name']
if ItemModel.find_by_name(name):
_data = {}
for key in data:
if data.get(key):
_data[key] = data[key]
ItemModel.find_by_name(name).update(**_data)
return {'message': f'{name} has been edited'}
item = ItemModel(**data)
item.save_to_db()
return json.loads(item.to_json())
def put(self, name):
data = Item.parser.parse_args()
item = ItemModel.find_by_name(name)
if item is None:
item = ItemModel(name, **data)
else:
item.price = data['price']
item.store_id = data['store_id']
try:
item.save()
except:
return dict(message="An error ocurred updating the item"), 500
return item.json()
def addItem():
print("request", request)
req = request.get_json()
print("req", req, type(req))
print([key for key in ["name", "price"] if key not in req.keys()])
if len([key for key in ["name", "price"] if key not in req.keys()]) > 0:
return {"error": "invalid request"}, 400
if "tag" in req and db.session.query(TagModel.TagModel)\
.filter_by(name=req["tag"]).scalar() is None:
return {"error": "invalid tag"}, 400
try:
db.session.add(ItemModel.ItemModel(**req))
db.session.commit()
except Exception as e:
return {"error": str(e)}, 503
context = {"status": "success!"}
return jsonify(**context)
def put(self, name):
data = Item.parser.parse_args()
item = ItemModel.find_by_name(name)
updated_item = ItemModel(name,data['price'])
if item is None:
try:
updated_item.insert()
except:
return {"message": "An error occurred inserting the item."}
else:
try:
updated_item.update()
except:
raise
return {"message": "An error occurred updating the item."}
return updated_item.json()
def put(cls, name):
"""
The async function that handles PUT requests.
:param name: item name to create or update.
:return:
"""
# Load and parse data
request_data = cls.parser.parse_args()
# Check whether name already exists
item = ItemModel.find_by_name(name)
# If name doesn't exist, create. Otherwise, update.
if item is None:
item = ItemModel(name, **request_data)
else:
item.price = request_data['price']
# In either case: insert or update we need to save to db ==> save_to_db()
item.save_to_db()
# Return item.
return item.json()
def mutate(self,info,cart_id,product_id):
local_cart_id, local_product_id = from_global_id(cart_id)[1], from_global_id(product_id)[1]
item = ItemModel(cart_id=local_cart_id,product_id=local_product_id)
db_session.add(item)
db_session.commit()
return CartAdd(cart=item.cart)
def __init__(self):
self.model = ItemModel()
