def delete_product(id=None):
"""
get_products returns all product or the product with specific id
Args:
id ([type]): product id
Returns:
[type]: [description]
"""
item = Product.query.get(id)
variations = Variation.get_items_for_id(product_id=item.id)
# delete variations before product
for variation in variations:
if len(variation.delete()) > 0:
return Responses.OPERATION_FAILED()
# deletes product
error = item.delete()
if len(error) > 0:
return Responses.OPERATION_FAILED()
return Responses.SUCCESS()
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 new_variation2():
variation = Variation()
variation.name = 'XXS'
variation.price = '11.99'
variation.stock = 1
variation.total_stock = 3
variation.next_available_date = datetime.datetime(2020, 9, 17)
variation.retail_price = 35.99
return variation
def new_variation():
variation = Variation()
variation.name = 'XS'
variation.price = '17.99'
variation.stock = 2
variation.total_stock = 3
variation.next_available_date = datetime.datetime(2020, 8, 17)
variation.retail_price = 33.99
return variation
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_productsearch(name=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')
is_desc = parse_int(request.args.get('is_desc'))
itemSearchResult = []
products = Product.query.filter(Product.name.like("%" + name + "%")).all()
if len(products) > 0:
for item in products:
variations = Variation.get_items_for_id(item.id)
product_variations = ProductVariations(product=item)
product_variations.variations = variations
itemSearchResult.append(product_variations)
categories = ProductCategory.query.filter(
ProductCategory.name.like("%" + name + "%")).all()
if len(categories) > 0:
for category in categories:
productsInCategory = Product.get_items(category_id=category.id,
page=page,
per_page=50,
sort_by=sort_by,
is_desc=is_desc)
for product in productsInCategory:
variations = Variation.get_items_for_id(product.id)
product_variations = ProductVariations(product=product)
product_variations.variations = variations
itemSearchResult.append(product_variations)
return res([
product_variation.as_dict() for product_variation in itemSearchResult
])
def update_product(id):
item = Product.query.get(id)
if not item:
return Responses.NOT_EXIST()
json_dict = request.json
if len(item.update(json_dict['product'])) > 0:
return Responses.OPERATION_FAILED()
current_variations = Variation.query.filter_by(product_id=item.id).all()
current_variations_names = []
for variation in current_variations:
current_variations_names.append(variation.name)
variations_dict = json_dict['variations']
for variation_dict in variations_dict:
variation = Variation()
variation.update_from_dict(variation_dict)
if variation.next_available_date != None: # ensure this is a date string
if is_date(variation.next_available_date):
variation.next_available_date = datetime.datetime.strptime(
variation.next_available_date, '%Y-%m-%d %H:%M:%S')
if variation.name in current_variations_names:
for current_variation in current_variations:
if variation.name == current_variation.name:
if len(current_variation.update(variation_dict)) > 0:
return Responses.OPERATION_FAILED()
else: #a new variation is being added to this product
if len(variation.update()) > 0:
return Responses.OPERATION_FAILED()
return Responses.SUCCESS()
def add_product():
json_dict = request.json
item = Product()
error = item.update(json_dict['product'])
if len(error) > 0:
return Responses.OPERATION_FAILED()
product = Product.query.filter_by(
name=json_dict['product']['name']).first()
variations = []
variations_dict = json_dict['variations']
for variation_dict in variations_dict:
variation = Variation()
if variation.update_from_dict(variation_dict):
variation.product_id = product.id
if variation.next_available_date != None: # ensure this is a date string
if is_date(variation.next_available_date):
variation.next_available_date = datetime.datetime.strptime(
variation.next_available_date, '%Y-%m-%d %H:%M:%S')
variations.append(variation)
for variation in variations:
if len(variation.update()) > 0:
return Responses.OPERATION_FAILED()
return Responses.SUCCESS()
def delete_variation(id=None):
"""
get_products returns all product or the product with specific id
Args:
id ([type]): product id
Returns:
[type]: [description]
"""
variation = Variation.get_variation_from_id(id)
# delete variation before product
if len(variation.delete()) > 0:
return Responses.OPERATION_FAILED()
return Responses.SUCCESS()
def user_get_quicksearch(name=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')
is_desc = parse_int(request.args.get('is_desc'))
category_id = parse_int(request.args.get('category'))
date = request.args.get('date')
size = request.args.get('size')
requested_date = datetime.strptime(date, '%Y-%m-%d %H:%M:%S')
variations = Variation.get_items_for_size(
size=size, page=page, per_page=100,
sort_by=sort_by) # show only 100 results
all_product_variations = []
for variation in variations:
if int(variation.stock) < 0:
if variation.next_available_date != None:
nad = datetime.strptime(variation.next_available_date,
'%Y-%m-%d %H:%M:%S')
if requested_date > nad + relativedelta(days=14):
product = Product.get_product_from_id(variation.product_id)
product_variations = ProductVariations(product=product)
product_variations.variations = variation
all_product_variations.append(product_variations)
else:
product = Product.get_product_from_id(variation.product_id)
product_variations = ProductVariations(product=product)
product_variations.variations = variation
all_product_variations.append(product_variations)
return res([
product_variation.as_dict()
for product_variation in all_product_variations
])
def user_variations(name=None):
"""
gets all unique variation types
Args:
id ([type]): product id
Returns:
[type]: [description]
"""
variations = Variation.get_unique_variations().all()
variation_names = []
for variation in variations:
variation_names.append(variation.name)
variation_dict = { i : variation_names[i] for i in range(0, len(variation_names) ) }
return res(variation_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 user_get_product_pages_size(
size=None): # pagination details for products filtered by size
"""
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')
page_details = Variation.get_items_for_size_paging(size=size,
page=page,
per_page=per_page,
sort_by=sort_by)
return res({
"total_items": page_details.total,
"no_of_pages": page_details.pages,
"per_page": page_details.per_page
})
def new_variation() -> Response:
variation: Variation = Variation.from_json(request.json)
db.session.add(variation)
db.session.commit()
return jsonify(variation.to_json()), 201
db.session.add(CLIENT_ID)
db.session.add(ACCESS_TOKEN)
db.session.add(BEARER_REFRESH_TOKEN)
db.session.add(IMGUR_ACCOUNT_ID)
db.session.add(IMGUR_ACCOUNT_USERNAME)
db.session.add(STRIPE_PUBLISHABLE_KEY)
db.session.add(STRIPE_S_KEY)
db.session.add(member)
db.session.add(user)
db.session.add(user2)
db.session.add(subtype)
db.session.add(subtype2)
db.session.add(usersubscription)
for x in range(1, 11):
variation = Variation('S')
variation.product_id = x
variation.price = 10
variation.retail_price = variation.price * 3
variation.stock = 1
variation1 = Variation('M')
variation1.product_id = x
variation1.price = 20
variation1.retail_price = variation1.price * 3
variation1.stock = 1
variation2 = Variation('L')
variation2.product_id = x
variation2.price = 30
variation2.retail_price = variation2.price * 3
variation2.stock = 1
variation3 = Variation('XL')
def init_database():
db = AC().db
# Create the database and the database table
db.create_all()
member = Role("member")
admin = Role("admin")
user = User("*****@*****.**", "1q2w3e4r")
user.email_confirmed = True
user2 = User("*****@*****.**", "1q2w3e4r")
user3 = User("*****@*****.**", "1q2w3e4r")
user4 = User("*****@*****.**", "1q2w3e4r")
user.role = admin
user2.email_confirmed = True
user2.subscribed = True
user3.email_confirmed = True
user3.subscribed = True
user4.email_confirmed = False
max_no_products_per_month = ConfigValues('max_no_products_per_month', 20)
max_no_free_products_adayalite_user = ConfigValues(
'max_no_free_products_adayalite_user', 4)
max_no_of_items_per_order_adayalifestyle = ConfigValues(
'max_no_of_items_per_order_adayalifestyle', 4)
max_no_products_per_order = ConfigValues('max_no_products_per_order', 4)
min_duration_of_rental = ConfigValues('min_duration_of_rental', 4)
max_duration_of_rental = ConfigValues('max_duration_of_rental', 7)
max_no_of_vouchers = ConfigValues('max_no_of_vouchers', 2)
MAIL_USERNAME = ConfigValues('MAIL_USERNAME', '*****@*****.**')
MAIL_PASSWORD = ConfigValues('MAIL_PASSWORD', 'adaya1234')
MAIL_SERVER = ConfigValues('MAIL_SERVER', 'smtp.gmail.com')
MAIL_PORT = ConfigValues('MAIL_PORT', 465)
MAIL_DEFAULT_SENDER = ConfigValues('MAIL_DEFAULT_SENDER',
'*****@*****.**')
EMAIL_PASSWORD_RESET_SECRET_KEY = ConfigValues(
'EMAIL_PASSWORD_RESET_SECRET_KEY', 'Thisisasecret!')
SIB_KEY = ConfigValues('SIB_KEY', 'gzryVUPZHa1GW7n6')
subtype = SubscriptionType(plan='Adaya Lite', price=10)
subtype2 = SubscriptionType(plan='Adaya Premium', price=40)
usersubscription = UserSubscription()
usersubscription.user_id = 2
usersubscription.current_start_date = datetime.now()
usersubscription.current_end_date = datetime.strptime(
'2020-09-06 05:58:00', '%Y-%m-%d %H:%M:%S')
usersubscription.subscription_type = subtype
usersubscription2 = UserSubscription()
usersubscription2.user_id = 3
usersubscription2.current_start_date = datetime.now()
usersubscription2.current_end_date = datetime.strptime(
'2020-08-06 05:58:00', '%Y-%m-%d %H:%M:%S')
usersubscription2.subscription_type = subtype2
voucher = Voucher('HAO20')
voucher.discount_fixed_amount = 100
voucher.product_id = 3
voucher.redeem_by = datetime.strptime('2020-8-13 00:00:00',
'%Y-%m-%d %H:%M:%S')
voucher2 = Voucher('LUO20')
voucher2.discount_fixed_amount = 8.00
voucher2.product_id = 1
voucher2.redeem_by = datetime.strptime('2020-8-13 00:00:00',
'%Y-%m-%d %H:%M:%S')
for x in range(1, 11):
variation = Variation('S')
variation.product_id = x
variation.price = 10
variation.stock = 1
variation1 = Variation('M')
variation1.product_id = x
variation1.price = 20
variation1.stock = 1
variation2 = Variation('L')
variation2.product_id = x
variation2.price = 30
variation2.stock = 1
variation3 = Variation('XL')
variation3.product_id = x
variation3.price = 40
variation3.stock = 1
db.session.add(variation)
db.session.add(variation1)
db.session.add(variation2)
db.session.add(variation3)
db.session.add(max_no_products_per_order)
db.session.add(max_no_products_per_month)
db.session.add(max_no_free_products_adayalite_user)
db.session.add(max_no_of_items_per_order_adayalifestyle)
db.session.add(min_duration_of_rental)
db.session.add(max_duration_of_rental)
db.session.add(max_no_of_vouchers)
db.session.add(MAIL_USERNAME)
db.session.add(MAIL_PASSWORD)
db.session.add(MAIL_SERVER)
db.session.add(MAIL_PORT)
db.session.add(MAIL_DEFAULT_SENDER)
db.session.add(EMAIL_PASSWORD_RESET_SECRET_KEY)
db.session.add(SIB_KEY)
db.session.add(voucher)
db.session.add(voucher2)
db.session.add(member)
db.session.add(user)
db.session.add(user2)
db.session.add(user3)
db.session.add(user4)
db.session.add(subtype)
db.session.add(subtype2)
db.session.add(usersubscription)
db.session.add(usersubscription2)
food_category = ProductCategory('food')
clothes_category = ProductCategory('cloth')
food_article = ArticleCategory('food-article')
clothes_article = ArticleCategory('cloth-article')
status = ArticleStatus('draft')
order_status = OrderStatus('completed')
db.session.add(order_status)
db.session.add(food_article)
db.session.add(clothes_article)
db.session.add(food_category)
db.session.add(clothes_category)
for x in range(10):
product = Product('Haoluo')
article = Article(randomString(10))
order = Order()
order_item = OrderItem()
order_item.quantity = 1
order_item.variation_id = 2
order_item.start_date = datetime.strptime('2020-4-1 00:00:00',
'%Y-%m-%d %H:%M:%S')
order_item.end_date = datetime.strptime('2020-4-8 00:00:00',
'%Y-%m-%d %H:%M:%S')
order.order_items = []
order.order_items.append(order_item)
article_category = food_article
category = food_category
if x % 2 == 0:
category = clothes_category
article_category = clothes_article
product.category = category
article.category = article_category
article.status = status
db.session.add(order)
db.session.add(product)
db.session.add(order_item)
db.session.add(article)
db.session.commit()
yield db
db.drop_all()
def charge_customer_offline():
json_dict = request.json
user_id = json_dict['user_id']
order_id = json_dict['order_id']
item = Order.query.get(order_id)
order_items = item.order_items
total_cost = 0.00
for order_item in order_items:
variation = Variation.get_variation_from_id(order_item.variation_id)
if order_item.days_returned_late > 14:
total_cost += float(variation.retail_price)
else:
total_cost += (0.5 * float(variation.price)) * int(order_item.days_returned_late)
stripe_total_price = int (float(total_cost) * 100)
publishable_key = ConfigValues.get_config_value('STRIPE_PK')
user = User.query.get(user_id)
if not user.stripe_customer_id:
return Responses.OPERATION_FAILED()
user_stripe_id = user.stripe_customer_id
stripe.api_key = ConfigValues.get_config_value('STRIPE_SK')
try:
# List the customer's payment methods to find one to charge
payment_methods = stripe.PaymentMethod.list(
customer = user_stripe_id,
type='card'
)
# Create and confirm a PaymentIntent with the
# order amount, currency, Customer and PaymentMethod IDs
# If authentication is required or the card is declined, Stripe
# will throw an error
intent = stripe.PaymentIntent.create(
amount=stripe_total_price,
currency='gbp',
payment_method=payment_methods['data'][0]['id'],
customer=user_stripe_id,
confirm=True,
off_session=True
)
responseObject = jsonify({
'succeeded': True,
'publicKey': publishable_key,
'clientSecret': intent.client_secret
})
order = Order.query.get(order_id)
order.update({'late_charge': str(total_cost),'late_charge_paid': 1})
return responseObject.json
except stripe.error.CardError as e:
err = e.error
if err.code == 'authentication_required':
# Bring the customer back on-session to authenticate the purchase
# You can do this by sending an email or app notification to let them know
# the off-session purchase failed
# Use the PM ID and client_secret to authenticate the purchase
# without asking your customers to re-enter their details
Payment.send_payment_request_authorisation_email(user.email)
order = Order.query.get(order_id)
order.update({'late_charge': str(total_cost),'late_charge_paid': 0})
return jsonify({
'error': 'authentication_required',
'paymentMethod': err.payment_method.id,
'amount': total_cost,
'card': err.payment_method.card,
'publicKey': publishable_key,
'clientSecret': err.payment_intent.client_secret
}).json
elif err.code:
# The card was declined for other reasons (e.g. insufficient funds)
# Bring the customer back on-session to ask them for a new payment method
Payment.send_payment_failed_email(user.email)
order = Order.query.get(order_id)
order.update({'late_charge': str(total_cost),'late_charge_paid': 0})
return jsonify({
'error': err.code,
'publicKey': publishable_key,
'clientSecret': err.payment_intent.client_secret
}).json
def user_get_productcategories(category=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')
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'))
print(category)
cat_id = category_details[0].id
# category_details = ProductCategory.get_category_from_name(category)
# cat_id = category_details[0].id
items = Product.get_items(category_id=cat_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
) # TODO UPDATE from one page, done as only currently small number of prods
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
])
