def form_layout():
if request.method == "POST":
seller = request.form["seller"]
buyer = request.form["buyer"]
sold_price = request.form["sold_price"]
closing_date = datetime.strptime(request.form['closing_date'],
'%d-%m-%Y %H:%M %p')
Type = request.form["Type"]
status = request.form["status"]
address = request.form["address"]
new_sale = Sales(seller, buyer, sold_price, closing_date, Type, status,
address)
db_session.add(new_sale)
db_session.commit()
data = {
"id": new_sale.id,
"seller": seller,
"buyer": buyer,
"sold_price": sold_price,
"closing_date": request.form['closing_date'],
"Type": Type,
"status": status,
"address": address
}
pusher_client.trigger('table', 'new-record', {'data': data})
return redirect("/form-layout", code=302)
else:
sales = Sales.query.all()
return render_template('form-layout.html', sales=sales)
def add_sale(self, req_f, data):
db = self.db
target_show = req_f['select_show_id']
# str_date = target_show[0:10]
# date = datetime.strptime(str_date, '%Y-%m-%d').date()
# venue = target_show[13:]
#
# show = get_show_record(date, venue) #could either include this in a hidden column, use its attributes to replace the usage of data/venue above
items_id_data = db.session.query(Merch.merch_id).all()
items_name_data = db.session.query(Merch.merch_name).all()
item_tuples = [
(item_id, item_name)
for item_id, item_name in zip(items_id_data, items_name_data)
]
for item in item_tuples:
merch_id = item[0][0]
merch_name = item[1][0]
amount = data[merch_name]
sold = int(amount)
new_sale = Sales(target_show, merch_id, merch_name, sold)
db.session.add(new_sale)
db.session.commit()
def sales2db(response):
bytes_data = response.read()
wb = xlrd.open_workbook(file_contents=bytes_data)
ws = wb.sheets()[1]
for i in range(9, 63):
cell = ws.cell(i, 0)
if cell.ctype != 0:
value = ws.cell(i, 1).value
if value == 'Sutherland':
value = 'SutherlandShire'
value = ''.join(x.lower() for x in value if x.isalpha())
median = ws.cell(i, 3).value
annual_rate_median = ws.cell(i, 9).value
sales = Sales(value, str(median),
'{:.4f}'.format(annual_rate_median))
# print(value,median,annual_rate_median)
sales.save()
def post(self):
"""
Agregar nueva venta a un usuario.
ej:
/sale/add
con el siguiente mensaje:
{
"uuid": "889e068d-b098-4da2-82dd-4c712a0446b6",
"user_email": "*****@*****.**",
"amount": 123.45,
"date": "2017-10-15 11:35"
}
"""
sales_form = obtain_sales_data()
user = Users.get_user(sales_form.user_email.data)
if user and user.activate and not user.disabled:
if not Sales.get_sales_by_uuid(sales_form.uuid.data):
sales = Sales(uuid=sales_form.uuid.data,
user_email=sales_form.user_email.data,
amount=sales_form.amount.data,
date=sales_form.date.data,
canceled=sales_form.canceled.data)
sales.save()
return {
'Message':
'La venta nro: {} del usuario: {} se cargo con exito!'.
format(sales.uuid, user.email)
}
else:
return {'Message': 'Esta venta ya se encuentra registrada.'}
else:
if not user:
return {'Message': 'Error, el usuario no existe.'}
else:
if not user.activate:
return {
'Message': 'Error, el usuario no se encuentra activo.'
}
if user.disabled:
return {
'Message':
'Error, el usuario se encuentra desactivado.'
}
return {'Message': 'Error desconocido.'}
def get_sales_collections():
qs = Sales.objects()
entries = []
for sale in qs:
entries.append({
'id': '{}/{}'.format(request.base_url, sale.lga_name),
'lga_name': sale.lga_name,
'median': sale.median,
'annual_rate_median': sale.annual_rate_median
})
return jsonify(title='NSW Rent Data', id=request.base_url,
entry=entries), 200
def transactionsNewPostbeta():
# POST request
if request.method == 'POST':
body = request.get_json()
missing_item = verify_json(body, 'products_id', 'quantity',
'warehouses_id')
if missing_item:
raise APIException('You need to specify the ' + missing_item,
status_code=400)
if 'sales_id' in body[0]:
purchases = Purchases()
db.session.add(purchases)
db.session.commit()
purchases_id = purchases.id
for e in body:
e["purchases_id"] = purchases_id
else:
sales = Sales()
db.session.add(sales)
db.session.commit()
sales_id = sales.id
for e in body:
e["sales_id"] = sales_id
for e in body:
transactions = Transactions(purchases_id=e['purchases_id'],
products_id=e['products_id'],
sales_id=e['sales_id'],
quantity=e['quantity'],
warehouses_id=e['warehouses_id'])
db.session.add(transactions)
for e in body:
products = Products.query.get(e['products_id'])
products.quantity = int(products.quantity) + e['quantity']
db.session.commit()
all_transactions = Transactions.query.filter().order_by(
Transactions.id)
all_transactions = list(map(lambda e: e.serialize(), all_transactions))
return jsonify(all_transactions), 200
# GET request
if request.method == 'GET':
all_transactions = Transactions.query.all()
all_transactions = list(map(lambda e: e.serialize(), all_transactions))
return jsonify(all_transactions), 200
return "Invalid Method", 404
def create_tables_and_insert(self):
cursor = self._cnx.cursor()
tables = Setup.DataSetup().get_table_creation()
drop_tables = (
"DROP TABLE if exists `sacramentocrimejanuary2006`, `salesjan2009`, `techcrunchcontinentalusa`, "
"`sacramentorealestatetransactions`; ")
cursor.execute(drop_tables)
# if table does not exist, create it, parse csv, then insert into table
# if table exists, assume the csv has already been parsed and continue
for table_name in tables:
table_description = tables[table_name]
try:
print("Creating table {}: ".format(table_name))
cursor.execute(table_description)
csv_path = self.root_dir + '/data/' + table_name + '.csv'
reader = list(csv.reader(open(csv_path)))
data_objects = []
# get list of objects for table_name
print('Inserting rows into {}'.format(table_name))
if table_name == 'TechCrunchcontinentalUSA':
for row in reader:
data_objects.append(CompanyRecord.Record(*row[0:]))
del data_objects[0]
self.insert_record(data_objects)
elif table_name == 'SalesJan2009':
for row in reader:
data_objects.append(Sales.Sales(*row[0:]))
del data_objects[0]
self.insert_sale(data_objects)
elif table_name == 'Sacramentorealestatetransactions':
for row in reader:
data_objects.append(
Transaction.RealEstateTransaction(*row[0:]))
del data_objects[0]
self.insert_transaction(data_objects)
elif table_name == 'SacramentocrimeJanuary2006':
for row in reader:
data_objects.append(CrimeRecord.CrimeRecord(*row[0:]))
del data_objects[0]
self.insert_crimerec(data_objects)
except mysql.connector.Error as err:
if err.errno == errorcode.ER_TABLE_EXISTS_ERROR:
print("Table already exists. Exiting...")
else:
print(err.msg)
else:
print("Table successfully created.")
cursor.close()
self._cnx.close()
def add_information(users):
for user in users:
sales = Sales.get_sales_by_email(user['email'])
total_sales = 0
total = 0.0
for sale in sales:
if not sale.canceled:
total_sales += 1
total += sale.amount
else:
total_sales += 1
user['total_sales'] = total_sales
user['total'] = total
return users
def create(self, data):
customers_id = data['customers_id']
items = data['items']
self.buy_at_most_ten_diferrent_books(items)
price = self.apply_discount(items, customers_id)
total = price.total
discount = price.discount
sales = Sales(customers_id, total, discount)
db.session.add(sales)
for item in items:
new_items = Items(sales.id, item['books_id'], item['quantity'])
sales.items.append(new_items)
db.session.add(new_items)
db.session.commit()
return create_sales(sales)
def post(self, uuii):
"""
Cancelar una venta especificando su uuii.
ej: /sales/Escribir el uuii/cancel
"""
sale = Sales.get_sales_by_uuid(uuii)
if sale and not sale.canceled:
sale.canceled = True
sale.save()
return {
'Message':
'La venta {} fue anulada con exito!'.format(sale.uuid)
}
else:
if not sale:
return {'Message': 'Error. La venta no existe.'}
return {
'Message':
'Error. La venta {} se encuentra anulada.'.format(sale.uuid)
}
def salesAllGet():
# POST request
if request.method == 'POST':
body = request.get_json()
sales = Sales()
db.session.add(sales)
db.session.commit()
all_sales = Sales.query.all()
all_sales = list(map(lambda e: e.serialize(), all_sales))
return jsonify(all_sales), 200
# GET request
if request.method == 'GET':
all_sales = Sales.query.all()
all_sales = list(map(lambda e: e.serialize(), all_sales))
return jsonify(all_sales), 200
return "Invalid Method", 404
def add_sale(id, product, units_sold, sold_date):
s_list.append(Sales(id, product, units_sold, sold_date))
return make_response(jsonify({"message": "Collection created"}), 201)
from flask import Flask, request, jsonify
from models import Category, Product, Sales
# inspiration
# https://flask-restless.readthedocs.io/en/latest/quickstart.html
# Create the Flask application and the Flask-SQLAlchemy object.
app = Flask(__name__)
# simple `dataset` ~ dummy data
p_list = [
Product(1, 'fish', '1234', '235', 'sea', 'kg'),
Product(2, 'chicken', '154', '25', 'meat', 'kg')
]
s_list = [
Sales(1, 'fish sticks', 40, datetime.datetime(2020, 5, 17)),
Sales(2, 'chicken fingers', 50, datetime.datetime(2019, 4, 17)),
Sales(3, 'chicken fingers', 2, datetime.datetime(2019, 4, 18)),
Sales(4, 'chips', 35, datetime.datetime(2019, 8, 17))
]
c_list = [Category(1, 'import'), Category(2, 'export')]
'''handles GET requests with different directories without "id" as specified on the task'''
@app.route('/')
@app.route('/api/<categories>/', methods=['GET'])
def handler(categories):
if request.method == 'GET':
query_params = normalize_query(request.args)
if not query_params:
return getRequest_all(categories)
def get(self, email):
sales = Sales.get_sales_by_email_w_all(email)
sales.raw_output()
sales = sales.all()
sales_json = [serial(sale) for sale in sales]
return sales_json, 201