def get_user_orders(id=None):
page, per_page = get_page_from_args()
sort_by = request.args.get('sort_by')
is_desc = parse_int(request.args.get('is_desc'))
user_id = parse_int(request.args.get('user_id'))
# order_id = parse_int(request.args.get('order_id'))
status_id = parse_int(request.args.get('status'))
if user_id:
items = Order.get_items(user_id=user_id,
status_id=status_id,
page=page,
per_page=per_page,
sort_by=sort_by,
is_desc=is_desc)
return res([item.as_dict() for item in items])
elif id:
items = [Order.query.get(id)] if id else Order.get_items(
user_id=user_id,
status_id=status_id,
page=page,
per_page=per_page,
sort_by=sort_by,
is_desc=is_desc)
return res([item.as_dict() for item in items][0])
else:
return Responses.OPERATION_FAILED()
def user_get_products(id=None):
"""
get_products returns all product or the product with specific id
Args:
id ([type]): product id
Returns:
[type]: [description]
"""
page, per_page = get_page_from_args()
sort_by = request.args.get('sort_by')
sort_by_price = request.args.get('sort_by_price')
is_desc = parse_int(request.args.get('is_desc'))
category_id = parse_int(request.args.get('category'))
items = [Product.query.get(id)] if id else Product.get_items(
category_id=category_id,
page=page,
per_page=per_page,
sort_by=sort_by,
is_desc=is_desc)
variations = Variation.get_items(category_id=None,
page=1,
per_page=per_page,
sort_by=sort_by,
is_desc=is_desc)
all_product_variations = []
for item in items:
available_product_variations = []
for variation in variations:
if (item.id == variation.product_id):
available_product_variations.append(variation)
product_variations = ProductVariations(product=item)
product_variations.variations = available_product_variations
all_product_variations.append(product_variations)
if sort_by_price == 'price':
sorted_productVariations_by_price = sorted(
all_product_variations,
key=lambda x: x.variations[0].price,
reverse=False)
return res([
product_variation.as_dict()
for product_variation in sorted_productVariations_by_price
])
return res([
product_variation.as_dict()
for product_variation in all_product_variations
])
def user_get_product_pages_category(
category=None): # pagination details for products filtered by category
"""
get_products meeting criteria
Args:
id ([type]): product id
Returns:
[type]: [description]
"""
page, per_page = get_page_from_args()
sort_by = request.args.get('sort_by')
is_desc = parse_int(request.args.get('is_desc'))
category_details = []
if request.args.get('category') is None:
category_details = ProductCategory.get_category_from_name(category)
else:
category_details = ProductCategory.get_category_from_name(
request.args.get('category'))
cat_id = category_details[0].id
page_details = Product.get_items_pages(category_id=cat_id,
page=page,
per_page=per_page,
sort_by=sort_by,
is_desc=is_desc)
return res({
"total_items": page_details.total,
"no_of_pages": page_details.pages,
"per_page": page_details.per_page
})
def add_order_status():
json_dict = request.json
item = OrderStatus()
error = item.update(json_dict)
if len(error) > 0:
return Responses.OPERATION_FAILED()
return res(item.as_dict())
def user_get_product_categories(id=None):
page, per_page = get_page_from_args()
name = request.args.get('name')
items = [ProductCategory.query.get(id)
] if id else ProductCategory.get_items(
name=name, page=page, per_page=per_page)
return res([item.as_dict() for item in items])
def get_order_with_product(id=None):
item = Order.query.get(id)
order_with_product = OrderProducts(total_price=item.total_price)
order_with_product.firstname = item.firstname
order_with_product.lastname = item.lastname
order_with_product.email = item.email
order_with_product.address1 = item.address1
order_with_product.address2 = item.address2
order_with_product.city = item.city
order_with_product.post_code = item.post_code
order_with_product.country = item.country
order_with_product.phone = item.phone
order_with_product.late_charge = item.late_charge
if len(order_with_product.order_items) > 0:
order_with_product.order_items = [
] #empty the array again. and then get new data
for order_item in item.order_items:
order_item_with_product = Order_Item_With_Product(
order_item.quantity, order_item.start_date, order_item.end_date,
order_item.variation_id, order_item.days_returned_late)
variation = Variation.get_variation_from_id(order_item.variation_id)
product = Product.get_product_from_id(variation.product_id)
new_product = ProductSkeleton(name=product.name)
new_product.image = product.image.split(",")[0]
order_item_with_product.product = new_product
order_with_product.order_items.append(order_item_with_product)
return res(order_with_product.as_dict())
def calculate_order_cost():
json_dict = request.json
item = Order()
item.user_id = json_dict['user_id']
# item.firstname = json_dict['firstname']
# item.lastname = json_dict['lastname']
# item.email = json_dict['email']
# item.address1 = json_dict['address1']
# item.address2 = json_dict['address2']
# item.city = json_dict['city']
# item.post_code = json_dict['post_code']
# item.country = json_dict['country']
# item.phone = json_dict['phone']
order_items_dict = json_dict['order_items']
for order_item_dict in order_items_dict:
order_item = OrderItem()
if order_item.update_from_dict(order_item_dict):
item.order_items.append(order_item)
item.update_from_dict(json_dict)
response = Order.calculate_cost_for_users(item)
if response == -1:
return Responses.NO_ORDERS_EXCEEDED()
return res(response)
def get_order_pages(name=None): # pagination details for all orders
"""
get default get query
Args:
filter_queries (single query or query list, optional): example - [Article.category_id == 1] or Article.category_id == 1
page (int, optional): which page. Defaults to 1.
per_page (int, optional): how many items for each return. Defaults to 10.
order ([type], optional): example db.desc(Post.post_date) or db.asc
error_out (bool, optional): [description]. Defaults to False.
Returns:
[type]: [description]
"""
page, per_page = get_page_from_args()
sort_by = request.args.get('sort_by')
is_desc = parse_int(request.args.get('is_desc'))
user_id = parse_int(request.args.get('user'))
status_id = parse_int(request.args.get('status'))
page_details = Order.get_items_pages(user_id=user_id, status_id=status_id, page=page, per_page=per_page, sort_by=sort_by, is_desc=is_desc)
return res({"total_items": page_details.total, "no_of_pages": page_details.pages, "per_page": page_details.per_page})
def get_order_status(id=None):
page, per_page = get_page_from_args()
name = request.args.get('name')
per_page_for_stat = 50 # not many statuses so return all
items = [OrderStatus.query.get(id)] if id else OrderStatus.get_items(
name=name, page=page, per_page=per_page_for_stat)
return res([item.as_dict() for item in items])
def request_token():
"""
request_token takes in email and password, returns the authentication token
Returns:
[type]: [description]
"""
if request.json is None:
return Responses.OPERATION_FAILED()
email = request.json.get('email', None)
password = request.json.get('password', None)
user = User.authenticate(email, password)
# ensure email is confirmed
if not user.email_confirmed:
user.send_confirmation_email(user.email)
return Responses.UNCONFIRMED_USER()
if user:
token = create_access_token(identity=user.token_identity())
# refresh_token = create_refresh_token(identity=user.token_identity())
response, status = res()
set_access_cookies(response, token)
# set_refresh_cookies(response, refresh_token)
# identiti = get_jwt_identity()
# print(identiti)
# set token to httponly cookies
return response, status
return Responses.AUTHENTICATION_FAILED()
def add_article_category():
json_dict = request.json
item = ArticleCategory()
error = item.update(json_dict)
if len(error) > 0:
return Responses.OPERATION_FAILED()
return res(item.as_dict())
def get_article_categories(id=None):
page, per_page = get_page_from_args()
name = request.args.get('name')
items = [ArticleCategory.query.get(id)
] if id else ArticleCategory.get_items(
name=name, page=page, per_page=per_page)
return res([item.as_dict() for item in items])
def user_get_config_value(name=None):
"""
get_config_value for setting
"""
item = ConfigValues.get_config_value(name)
return res(item)
def get_cameras():
items = Camera.get(None, {
'name': 1,
'position': 1,
'count': 1,
'update_time': 1
})
return res([item.as_dict() for item in items])
def get_orders(id=None):
page, per_page = get_page_from_args()
sort_by = request.args.get('sort_by')
is_desc = parse_int(request.args.get('is_desc'))
user_id = parse_int(request.args.get('user'))
status_id = parse_int(request.args.get('status'))
items = [Order.query.get(id)] if id else Order.get_items(
user_id=user_id, status_id=status_id, page=page, per_page=per_page, sort_by=sort_by, is_desc=is_desc)
return res([item.as_dict() for item in items])
def quiz_form():
json_dict = request.json
quiz = QuizForm()
error = quiz.update(json_dict)
print(request.json)
# print(error)
if len(error) > 0:
return Responses.OPERATION_FAILED()
return res(quiz.as_dict())
def get_subscription_types(plan=None):
"""
get_subscription_types gets all subscription types
"""
page, per_page = get_page_from_args()
items = SubscriptionType.get_items(plan=plan, page=page, per_page=per_page)
return res([item.as_dict() for item in items])
def get_user_subscription(id=None):
"""
get_subscriptions gets all user subscriptions
"""
item = UserSubscription.get_subscription(user_id=id)
response = {}
if (len(item) > 0):
response = item[0]
return res(response.as_dict())
def add_subscription():
json_dict = request.json
item = UserSubscription(
user_id=json_dict['user_id'],
end_date=json_dict['end_date'],
subscription_type_id=json_dict['subscription_type_id'])
error = item.insert_as_new_item(json_dict)
if len(error) > 0:
return Responses.OPERATION_FAILED(error)
return res(item.as_dict())
def user_get_sizes(size=None):
"""
get_products meeting criteria
Args:
id ([type]): product id
Returns:
[type]: [description]
"""
page, per_page = get_page_from_args()
sort_by = request.args.get('sort_by')
sort_by_price = request.args.get('sort_by_price')
# category_id = parse_int(request.args.get('category'))
variations = Variation.get_items_for_size(size=size,
page=page,
per_page=per_page,
sort_by=sort_by)
all_product_variations = []
for variation in variations:
product = Product.get_product_from_id(variation.product_id)
product_variations = ProductVariations(product=product)
product_variations.variations = variation
all_product_variations.append(product_variations)
if sort_by_price == 'price':
sorted_productVariations_by_price = sorted(
all_product_variations,
key=lambda x: x.variations.price,
reverse=False)
return res([
product_variation.as_dict()
for product_variation in sorted_productVariations_by_price
])
return res([
product_variation.as_dict()
for product_variation in all_product_variations
])
def create_order():
json_dict = request.json
item = Order()
item.user_id = json_dict['user_id']
order_items_dict = json_dict['order_items']
for order_item_dict in order_items_dict:
order_item = OrderItem()
if order_item.update_from_dict(order_item_dict):
item.order_items.append(order_item)
item.update_from_dict(json_dict)
user = User.query.get(item.user_id)
#TODO renable when voucher functionality is done
# if user.subscribed:
# if UserSubscription.check_subscription_active(user.id):
# return Responses.SUBSCRIPTION_INACTIVE()
# if 'voucher_codes' in json_dict.keys():
# voucher_codes = json_dict['voucher_codes']
# number_vouchers_allowed = int(ConfigValues.get_config_value('max_no_of_vouchers'))
# if len(voucher_codes) > number_vouchers_allowed:
# return Responses.NO_VOUCHERS_EXCEEDED()
# vouchers = Voucher.get_vouchers(voucher_codes)
# if not vouchers[0]:
# return Responses.INVALID_VOUCHER()
# valid = Voucher.validate_voucher(vouchers)
# if valid:
# item.vouchers = vouchers
# item.calculate_discounted_cost()
# else:
details = item.calculate_cost()
if details != -1:
user.update({
'number_of_items_ordered_this_month':
int(details['no_items_this_month']),
'month_first_order':
details['month_first_order']
})
# convert date
if len(item.update(json_dict, force_insert=True)) > 0:
return Responses.OPERATION_FAILED()
#send email confirmation to user
Order.send_order_confirmation_email(order_number=item.id,
user_email=user.email)
# for item in item.order_items:
# item.m date_first_month_order.strftime('%Y-%m-%d %H:%M:%S')
return res(item.as_dict())
def add_cameras(pin):
if pin != os.getenv('PIN'):
return res("", "wrong pin", 403)
json_dict = request.json
query = {"name": json_dict['name']}
cameras = Camera.get(query)
if len(cameras) <= 0:
camera = Camera()
camera.name = json_dict['name']
camera.position = json_dict['position']
camera.street = json_dict['street']
camera.counts = [{
"count": json_dict['count'],
"update_time": datetime.now()
}]
camera.count = json_dict['count']
camera.update_time = datetime.now()
return res(camera.insert())
camera = cameras[0]
camera.add_count(json_dict['count'])
return res()
def get_current_user():
"""
get_user retruns user info for my account page
Returns:
(json string, status)
"""
identity = get_jwt_identity()
email = User.get_email_from_identity(identity)
if not email:
return Responses.AUTHENTICATION_FAILED()
user = User.get_user_by_email(email)
return res(user.as_dict())
def get_users(email=None):
"""
get_users gets all user or specify user
Args:
email ([type], optional): [description]. Defaults to None.
Returns:
[type]: [description]
"""
page, per_page = get_page_from_args()
items = [User.get_user_by_email(email)] if email else User.get(
page=page, per_page=per_page)
return res([item.as_dict() for item in items])
def add_subscription_type():
json_dict = request.json
if 'plan' not in json_dict:
return Responses.OPERATION_FAILED(Messages.NEEDED_FIELD_EMPTY)
if 'price' not in json_dict:
return Responses.OPERATION_FAILED(Messages.NEEDED_FIELD_EMPTY)
existing_item = SubscriptionType.get_items(plan=json_dict['plan'])
if len(existing_item) > 0:
return Responses.OBJECT_EXIST()
item = SubscriptionType(json_dict['plan'], json_dict['price'])
error = item.insert_as_new_item(json_dict, ['plan', 'price'])
if len(error) > 0:
return Responses.OPERATION_FAILED(error)
return res(item.as_dict())
def add_user():
json_dict = request.json
if 'email' not in json_dict:
return Responses.OPERATION_FAILED(Messages.EMAIL_EMPTY)
existing_item = User.get_user_by_email(json_dict['email'])
if existing_item:
return Responses.OBJECT_EXIST(Messages.EMAIL_EXIST)
# set admin email to confirmed
role = Role.query.get(json_dict['role_id'])
if (role.name == "admin"):
json_dict['email_confirmed'] = True
item = User()
error = item.insert_as_new_item(json_dict)
if len(error) > 0:
return Responses.OPERATION_FAILED(error)
return res(item.as_dict())
def get_articles(id=None):
page, per_page = get_page_from_args()
sort_by = request.args.get('sort_by')
is_desc = parse_int(request.args.get('is_desc'))
category_id = parse_int(request.args.get('category'))
user_id = parse_int(request.args.get('user'))
status_id = parse_int(request.args.get('status'))
items = [Article.query.get(id)] if id else Article.get_items(
category_id=category_id,
user_id=user_id,
status_id=status_id,
page=page,
per_page=per_page,
sort_by=sort_by,
is_desc=is_desc)
return res([item.as_dict() for item in items])
def get_vouchers(name=None):
"""
get_vouchers gets all vouchers
"""
page, per_page = get_page_from_args()
sort_by = request.args.get('sort_by')
is_desc = parse_int(request.args.get('is_desc'))
items = Voucher.get_items(name=name,
page=page,
per_page=per_page,
sort_by=sort_by,
is_desc=is_desc)
return res([item.as_dict() for item in items])
def get_subscriptions(id=None):
"""
get_subscriptions gets all user subscriptions
"""
page, per_page = get_page_from_args()
sort_by = request.args.get('sort_by')
is_desc = parse_int(request.args.get('is_desc'))
items = UserSubscription.get_items(id=id,
page=page,
per_page=per_page,
sort_by=sort_by,
is_desc=is_desc)
return res([item.as_dict() for item in items])
def add_order():
json_dict = request.json
item = Order()
item.user_id = json_dict['user_id']
item.status_id = json_dict['status_id']
order_items_dict = json_dict['order_items']
for order_item_dict in order_items_dict:
order_item = OrderItem()
order_item.update_from_dict(order_item_dict)
item.order_items.append(order_item)
item.calculate_cost()
if len(item.update(force_insert=True)) > 0:
return Responses.OPERATION_FAILED()
return res(item.as_dict())
