def customers_insert():
"""Lê form, instancia objeto e persiste no BD com SQLAlchemy"""
message = "Novo cadastro incluído com sucesso"
if request.method == "POST":
tax_id = request.form["tax_id"] #CNPJ
customer_type_id = request.form["customer_type_id"]
name = request.form["name"]
contact_name = request.form["contact_name"]
contact_phone = request.form["contact_phone"]
contact_email = request.form["contact_email"]
address_line1 = request.form["address_line1"]
address_line2 = request.form["address_line2"]
number = request.form["number"]
postal_code = request.form["postal_code"]
city = request.form["city"]
state = request.form["state"]
if Customer.query.filter_by(name=name).first():
message = "Já existe um cliente no cadastro com esse nome."
elif Customer.query.filter_by(contact_email=contact_email).first():
message = "Já existe um cliente no cadastro com este email de contato."
elif Customer.query.filter_by(tax_id=tax_id).first():
message = "Já existe um cliente no cadastro com esse CNPJ"
else:
customer = Customer(tax_id, customer_type_id, name, contact_name, contact_phone, contact_email, \
address_line1, address_line2, number, postal_code, city, state)
db.session.add(customer)
db.session.commit()
flash(message)
return redirect(url_for("customers_index"))
def test_customer_orders_relationship(self):
cust = Customer(username="******",
email="*****@*****.**",
first_name="first_test",
last_name="last_test",
middle_name="middle_test",
phone_number="123456789",
gender="M",
marital_status="Married")
cust.set_password('test_pass')
order = Order()
order2 = Order()
order3 = Order()
order_item = Order_Item(quantity=5)
order_item2 = Order_Item(quantity=10)
order_item3 = Order_Item(quantity=15)
product = Product(name="Spatula")
product2 = Product(name="Spoon")
product3 = Product(name="Spork")
cust.orders.append(order)
order.order_items.append(order_item)
product.order_items.append(order_item)
db.session.add(cust)
db.session.add(order)
db.session.add(product)
db.session.add(order_item)
db.session.commit()
def test_customer():
"""Test that Customer object is initialized correctly"""
first_name = "John"
last_name = "Doe"
email = "*****@*****.**"
phone_number = "123456789"
payment_info = "mastercard"
with allure.step('Initialize customer'):
customer = Customer(first_name, last_name, email, phone_number, payment_info)
with allure.step('Check first name'):
assert(customer.first_name == first_name)
with allure.step('Check last name'):
assert(customer.last_name == last_name)
with allure.step('Check email'):
assert(customer.email == email)
with allure.step('Check phone number'):
assert(customer.phone_number == phone_number)
with allure.step('Check payment info'):
assert(customer.payment_info == payment_info)
def signup():
form = RegisterForm()
if form.validate_on_submit():
data = form.data
if data["password"] != data["passwordtwo"]:
flash("密码不一致")
return redirect(url_for("home.signup"))
if data["usertype"] == 1:
customer = Customer.query.filter_by(email=data["email"]).count()
if customer == 1:
flash(generate_password_hash(data["password"]))
return redirect(url_for("home.signup"))
customer = Customer(
email = data["email"],
password = generate_password_hash(data["password"])
)
db.session.add(customer)
db.session.commit()
flash("Registration success！")
return redirect(url_for("home.login"))
if data["usertype"] == 2:
agent = Agent.query.filter_by(email=data["email"]).count()
if agent == 1:
flash("The email already exists!")
return redirect(url_for("home.signup"))
agent = Agent(
email=data["email"],
password=generate_password_hash(data["password"]),
booking_agent_id = ''.join(random.sample(string.ascii_letters + string.digits, 8))
)
db.session.add(agent)
db.session.commit()
flash("Registration success！")
return redirect(url_for("home.login"))
return render_template("home/signup.html",form=form)
def customer():
csv_file = request.files['files'] #gets input in bytes
csv_file = TextIOWrapper(csv_file, encoding='utf-8') #converts to string
csv_dict = csv.DictReader(
csv_file) #converts bytes into ordered dictionary
for row in csv_dict: #row is the iterrator
id = row['id']
first_name = row['first_name']
last_name = row['last_name']
gender = row['gender']
email = row['email']
age = row['age']
address = row['address']
state = row['state']
zipcode = row['zipcode']
phoneNumber = row['phoneNumber']
registerationDate = row['registerationDate']
# print(row)
user = Customer(id=id,
first_name=first_name,
last_name=last_name,
gender=gender,
email=email,
age=age,
address=address,
state=state,
zipcode=zipcode,
phoneNumber=phoneNumber,
registerationDate=registerationDate)
try:
db.session.add(user)
db.session.commit()
except IntegrityError:
raise customException1
return 'Created new user'
def insert_customers(self):
customers = extract_master_files_data(self.org_dir,
DATATYPES_NAMES["customer_name"])
for customer in customers:
customer_duplicate = self.if_duplicate_exists(
Customer, number=customer.number, org_id=self.org_id)
if customer_duplicate:
continue
db_customer = Customer(number=customer.number,
date_time=customer.date_time,
filepath=customer.filepath,
data_dir=customer.data_dir,
org_id=self.org_id,
first_name=customer.first_name,
surname=customer.surname,
addr1=customer.addr1,
addr2=customer.addr2,
addr3=customer.addr3,
postcode=customer.postcode,
phone=customer.phone,
email=customer.email,
overdraft_limit=customer.overdraft_limit,
custgroup_number=customer.custgroup_number)
db.session.add(db_customer)
db.session.commit()
print(db_customer)
def create_customer():
if request.method == 'POST':
ssn_id = request.form.get('ssn_id')
name = request.form.get('name')
age = request.form.get('age')
address = request.form.get('address')
state = request.form.get('state')
city = request.form.get('city')
try:
customer = Customer(ssn_id=ssn_id,
name=name,
age=age,
address=address,
state=state,
city=city)
status = CustomerStatus(ssn_id=ssn_id,
status="Active",
message="customer created successfully",
customer=customer)
db.session.add(customer)
db.session.add(status)
db.session.commit()
flash("Customer creation initiated successfully", 'success')
except Exception as e:
print(e)
flash("Something Went Wrong", 'error')
return render_template("create_customer.html")
def add_customer():
form = NewCustomerForm()
# TODO: is there a way to normalize the states to their 2-letter code?
# what about provinces? or other international locations?
if form.validate_on_submit():
print('validated')
customer = Customer(first_name=form.first_name.data,
last_name=form.last_name.data,
email=form.email.data,
birthday=form.birthday.data,
street1=form.street1.data,
street2=form.street2.data,
city=form.city.data,
state=form.state.data,
zip=form.zip.data
)
db.session.add(customer)
db.session.commit()
flash('Customer added')
return redirect(url_for('customer_edit', customer_id=customer.id))
else:
print('not validated')
return render_template('customer_add.html', title='Add new customer', form=form)
def add_system_auth(sys_id, asys_id, asys_key):
customer = Customer(system_id=sys_id,
access_system_id=asys_id,
access_system_key=generate_password_hash(asys_key))
db.session.add(customer)
db.session.commit()
db.session.close()
def createcustomer():
try:
form = CreateCustomer()
print("getting")
customer = Customer(customer_fname=form.customer_fname.data,
customer_lname=form.customer_lname.data,
company_name=form.company_name.data,
city=form.city.data,
state=form.state.data,
address=form.address.data,
zip_code=form.zip_code.data,
email=form.email.data,
phone_num=form.phone_num.data)
print("adding")
db.session.add(customer)
print("commiting")
db.session.commit()
except:
db.session.rollback()
print('I failed to create customer and rolled back')
form = CreateCustomer()
user = User.query.filter_by(username=current_user.username)
title = 'Cx'
return render_template('createcustomer.html',
month=month,
user=user,
title=title,
form=form)
def charge(quoteId):
stripe.api_key = current_app.config['STRIPE_SECRET_KEY']
q_request = QuoteRequests.query.filter_by(id=quoteId).first_or_404()
amount = q_request.generateTotal(stripe=True)
customer = Customer.query.filter_by(email=q_request.email).first()
if not customer:
stripe_customer = create_stripe_customer(q_request.email)
customer = Customer(
email=q_request.email,
stripe_id=stripe_customer.id
)
db.session.add(customer)
db.session.commit()
else:
stripe_customer = stripe.Customer.retrieve(customer.stripe_id)
stripe_customer.source = request.form['stripeToken']
stripe_customer.save()
charge = stripe.Charge.create(
customer=stripe_customer.id,
amount=amount,
currency='usd',
description='Flask Charge'
)
flash("Thank you for your payment!")
q_request.markComplete()
q_request.paid = True
db.session.commit()
return redirect(url_for('main.index'))
def create_customer():
data = request.get_json()
# VALIDATE POST DATA
try:
validate = customer_schema.load(data)
existing_customer = Customer.query.filter_by(name=data['name']).first()
if existing_customer is not None:
response = { 'message': 'customer already exists' }
return jsonify(response), 403
else:
# VALIDATION COMPLETE ADD NEW CUSTOMER
new_customer = Customer(**data)
db.session.add(new_customer)
db.session.commit()
try:
nc = customer_schema.dump(new_customer)
# kinesis.put_record(app.config['KINESIS_DATA_STREAM'], json.dumps(nc), "partitionkey")
except Exception as e:
print(e)
# CALL TO CLOUD WATCH OR OTHER ALERTING SYSTEM
response = { 'message': 'new customer registered', 'data': customer_schema.dump(new_customer) }
return jsonify(response), 202
except ValidationError as err:
errors = err.messages
validate = False
return jsonify(errors), 403
def customer():
if request.form.get('cname'):
# get customer details
cname = request.form.get('cname')
cnumber = request.form.get('cnumber')
fname = request.form.get('fname')
sname = request.form.get('sname')
email = request.form.get('email')
#enter customer into database
newCustomer = Customer(cname=cname,
cnumber=cnumber,
fname=fname,
sname=sname,
email=email)
db.session.add(newCustomer)
db.session.commit()
flash('New customer has been added')
return redirect(url_for('customers.customer'))
else: # on page enter
customers = Customer.query.all()
return render_template("customer.html", customers=customers)
def test_to_dict(self):
personal_loan_offer = PersonalLoanOffer(id=7,
predicted_response='Accepted',
prediction_probability=86.0,
actual_response='No')
customer = Customer(id=1,
income=100,
education=1,
cc_avg=1.50,
family=1,
cd_account=False,
age=40,
personal_loan_offer=personal_loan_offer)
assert customer.to_dict() == {
'age': 40,
'cc_avg': '1.5',
'cd_account': False,
'education': 'Undergraduate',
'family': 1,
'id': 1,
'income': 100,
'personal_loan_offer_id': 7,
'personal_loan_offer_prediction': 'Accepted',
'personal_loan_offer_prediction_probability': '86.0',
'personal_loan_offer_response': 'No',
}
def data_load(payload):
""" Loads a Customer into the database """
customer = Customer(0, payload['username'], payload['password'],
payload['firstname'], payload['lastname'],
payload['address'], payload['phone'], payload['email'],
payload['active'], payload['promo'])
customer.save()
def BookCustomerPackages(counter):
form = forms.RegisterCustomerHotels(meta={'csrf': False})
id = session['packageId']
if form.validate_on_submit():
for data in form.customer:
customer = Customer(firstName=data.firstName.data,
lastName=data.lastName.data,
email=data.email.data,
contactNo=data.contactNo.data)
db.session.add(customer)
db.session.flush()
pTransaction = PackageBooking(referenceNumber=referenceNumber,
customer=customer.id,
package=id)
db.session.add(pTransaction)
db.session.commit()
return redirect(
url_for('main.PayPackage',
counter=counter,
id=id,
ref=referenceNumber))
for count in range(counter):
# form.customer.pop_entry()
form.customer.append_entry()
return render_template('customer/packageCustomerForm.html',
form=form,
counter=counter)
def setUp(self):
self.app = app.test_client()
app.config['TESTING'] = True
app.config['DEBUG'] = True
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///testing.db'
db.drop_all()
db.create_all()
category1 = Category('Cleaning')
category2 = Category('Chemicals')
category3 = Category('Household Supplies')
product0 = Product('Bleach')
product1 = Product('toilet paper')
product2 = Product('mop')
product3 = Product('small bucket')
product5 = Product('hand soap')
product0.categories.extend([category1, category2])
product1.categories.extend([category2, category3])
product2.categories.append(category3)
product3.categories.append(category3)
product5.categories.append(category1)
order0 = Order(1, 'Waiting')
order1 = Order(1, 'Waiting')
order2 = Order(2, 'In Transit')
order3 = Order(3, 'Delivered')
customer1 = Customer('James T. Kirk')
customer2 = Customer('Jean Luc Picard')
customer3 = Customer('Jonathan Archer')
db.session.add_all([
order0, order1, order2, order3, customer1, customer2, customer3,
product0, product1, product2, product3, product5, category1,
category2, category3
])
db.session.commit()
order_item0 = OrderItem(5, product0.id, order0.id)
order_item1 = OrderItem(5, product0.id, order1.id)
order_item2 = OrderItem(2, product3.id, order1.id)
order_item3 = OrderItem(20, product1.id, order2.id)
order_item4 = OrderItem(1, product2.id, order3.id)
db.session.add_all(
[order_item0, order_item1, order_item2, order_item3, order_item4])
db.session.commit()
def build_customer_3():
return Customer(user_id=3,
email='*****@*****.**',
last_seen=datetime.utcnow(),
name='jack',
company='Twitter',
title='CEO',
about_me='i love my job',
phone_number='13880089002')
def customer(create_db):
data = generate_customer_data()
customer = Customer(**data)
create_db.session.add(customer)
create_db.session.commit()
customer = Customer.query.filter(
Customer.customer_name == customer.customer_name
).first()
return customer
def formSubmit():
username = request.form['username']
email = request.form['email']
nickname = request.form['nickname']
password = request.form['password']
com_pass = request.form['confirm_password']
user_type = request.form['user_type']
error = None
if username == '':
error = 'Please provide the username!'
elif email == '':
error = 'Please provide the email!'
elif nickname == '':
error = 'Please provide the nickname!'
elif password == '':
error = 'Please provide the password!'
elif com_pass == '':
error = 'Please provide the confirm password!'
elif len(password) < 4 or len(password) > 8:
error = 'Password of your choice is wrong!'
elif password != com_pass:
error = 'Password is not same "CONFIRM PASSWORD"!'
elif '@' not in email:
error = 'Your e-mail address is wrong!'
elif user_type != 'Customer' and user_type != 'Vendor':
error = "Please choose correct user type"
if error:
return render_template('formPage.html', message=error)
else:
from app.models import User
maximumId = db.session.query(func.max(User.id)).scalar()
if not maximumId: maximumId = 0
if user_type == 'Customer':
user = Customer(id=maximumId + 1,
user_name=request.form['username'],
e_mail=request.form['email'],
nickname=request.form['nickname'],
password=request.form['password'])
elif user_type == 'Vendor':
user = Vendor(id=maximumId + 1,
user_name=request.form['username'],
e_mail=request.form['email'],
nickname=request.form['nickname'],
password=request.form['password'])
db.session.add(user)
db.session.commit()
login_user(user)
return render_template('confirmpage.html',
id=maximumId + 1,
username=username,
email=email,
nickname=nickname,
user_type=user_type)
def register_customer():
"""
Takes a json object structured as so:
"""
# Converts json to python object
req_data = request.get_json()
# get email, name, password and username
user = Customer.query.filter_by(
username=req_data['Customer']['username']).first()
if not user:
try:
# DB ORM object
user = Customer(
username=req_data['Customer']['username'],
email=req_data['Customer']['email'],
first_name=req_data.get('Customer').get('firstName'),
last_name=req_data.get('Customer').get('lastName'),
middle_name=req_data.get('Customer').get('middleName'),
phone_number=req_data.get('Customer').get('phoneNumber'),
gender=req_data.get('Customer').get('gender'),
marital_status=req_data.get('Customer').get('maritalStatus'))
user.set_password(req_data['Customer']['password'])
if req_data.get('MailingAddress'):
address = req_data['MailingAddress']
mail = Mailing_Address(
street_address_1=address['streetAddress1'],
street_address_2=address['streetAddress2'],
zip_code=address["zipCode"],
state=address["state"],
country=address["country"],
customer=user)
bill = Billing_Address(
street_address_1=address['streetAddress1'],
street_address_2=address['streetAddress2'],
zip_code=address["zipCode"],
state=address["state"],
country=address["country"],
customer=user)
db.session.add(mail)
db.session.add(bill)
db.session.add(user)
db.session.commit()
return jsonify({'message': 'Successfully registered.'}), 201
except KeyError as e:
print(e)
return jsonify({'message': "No attribute %s exists" % e}), 400
except Exception as e:
print(e)
return jsonify(
{'message': "Error, could not register user: %s" % e}), 400
else:
return jsonify({'message': 'User already exists. Please Log in.'}), 202
def customer_init_func(row):
c = Category.query.filter_by(name=row['category']).first()
p = Customer(category=c,
display_as=row['display_as'],
firstname=row['firstname'],
lastname=row['lastname'],
adresse=row['adresse'],
telephone=row['telephone'],
email=row['email'])
return p
def customer(self, app):
customer = Customer(income=100,
education=1,
cc_avg=1.50,
family=1,
cd_account=False,
age=40)
db.session.add(customer)
db.session.commit()
return customer
def dummy():
# Create a user if they do not exist.
user = User.query.filter_by(email="*****@*****.**").first()
if not user:
user = User("*****@*****.**", "123456")
user.save()
for i in range(100):
# Add buckets to the database
bucket = Customer(faker.name.industry(), user.id)
customer.save()
def test_pagination(self):
# define 55 customers (3 pages at 25 per page)
customers = []
for i in range(0, 55):
customers.append(Customer(name='customer_{0:02d}'.format(i)))
db.session.add_all(customers)
db.session.commit()
# get first page of customer list
rv, json = self.client.get('/api/v1/customers/')
self.assertTrue(rv.status_code == 200)
self.assertTrue(len(json['customers']) == 25)
self.assertTrue('pages' in json)
self.assertIsNone(json['pages']['prev_url'])
self.assertTrue(json['customers'][0] == customers[0].get_url())
self.assertTrue(json['customers'][-1] == customers[24].get_url())
page1_url = json['pages']['first_url']
page2_url = json['pages']['next_url']
# get second page of customer list
rv, json = self.client.get(page2_url)
self.assertTrue(rv.status_code == 200)
self.assertTrue(len(json['customers']) == 25)
self.assertTrue(json['customers'][0] == customers[25].get_url())
self.assertTrue(json['customers'][-1] == customers[49].get_url())
self.assertTrue(page1_url == json['pages']['prev_url'])
page3_url = json['pages']['next_url']
self.assertTrue(page3_url == json['pages']['last_url'])
# get third page of customer list
rv, json = self.client.get(page3_url)
self.assertTrue(rv.status_code == 200)
self.assertTrue(len(json['customers']) == 5)
self.assertTrue(json['customers'][0] == customers[50].get_url())
self.assertTrue(json['customers'][-1] == customers[54].get_url())
self.assertTrue(json['pages']['prev_url'] == page2_url)
self.assertIsNone(json['pages']['next_url'])
# get second page, with expanded results
rv, json = self.client.get(page2_url + '&expanded=1')
self.assertTrue(rv.status_code == 200)
self.assertTrue(len(json['customers']) == 25)
self.assertTrue(json['customers'][0]['name'] == customers[25].name)
self.assertTrue(
json['customers'][0]['self_url'] == customers[25].get_url())
self.assertTrue(json['customers'][-1]['name'] == customers[49].name)
page1_url_expanded = json['pages']['prev_url']
# get first page expanded, using previous link from page 2
rv, json = self.client.get(page1_url_expanded)
self.assertTrue(rv.status_code == 200)
self.assertTrue(len(json['customers']) == 25)
self.assertTrue(json['customers'][0]['name'] == customers[0].name)
self.assertTrue(json['customers'][24]['name'] == customers[24].name)
def post(self):
data = request.get_json() or {}
if 'name' not in data:
return abort(400, 'must include name fields')
if Customer.query.filter_by(name=data['name']).first():
return abort(400, 'please use a different name')
customer = Customer()
customer.from_dict(data)
db.session.add(customer)
db.session.commit()
return customer.to_dict(), 201
def build_customer_2():
return Customer(user_id=2,
email='*****@*****.**',
last_seen=datetime.utcnow(),
name='zuck',
company='facebook',
title='CEO',
about_me='i love my job',
avatar_thumbnail_url='thumbnail',
avatar_url='image',
phone_number='13880089001')
def build_customer_1():
return Customer(user_id=1,
email='*****@*****.**',
last_seen=datetime.utcnow(),
name='larry',
company='google',
title='CEO',
about_me='i love my job',
avatar_thumbnail_url='thumbnail',
avatar_url='image',
phone_number='13880089000')
def login():
if current_user.is_authenticated:
return redirect(url_for('index'))
form = LoginForm()
if form.validate_on_submit():
user = Customer()
auth = user.auth(form.access_code.data)
if not auth:
flash('Invalid Access Code')
return redirect(url_for('login'))
return redirect('/emergency/%s' % user.id)
return render_template('login.html', title='Medifax Customer Portal Login', form=form)
def registerNext():
customer = Customer(cname=request.form["cname"],
cmail=request.form["cmail"],
cmobile=request.form["cmobile"],
caddress=request.form["caddress"],
cpassword=request.form['cpassword'])
db.session.add(customer)
db.session.commit()
return redirect(url_for('login'))
