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 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 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 get_customer():
uuid_dt = uuid.uuid1()
name = f'{uuid_dt}'
email = f'{name}@email.com'
customer = MongoCustomer(uuid=uuid_dt, name=name, email=email)
customer.save()
return customer
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 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 create_customer(name, identity_card_number, phone):
customer = Customer()
customer.name = name
customer.identity_card_number = identity_card_number
if phone != '':
customer.phone = phone
db.session.add(customer)
db.session.commit()
return customer
def signup(request):
print("Yes i am there")
cid=random_with_N_digits(10)
fname = request.POST.get("first_name")
lname = request.POST.get("last_name")
email = request.POST.get("email")
pwd = request.POST.get("password")
typ=request.POST.get("type")
R1=Customer(customer_Id=cid,first_Name=fname,last_Name=lname,email=email,password=pwd,type=typ)
R1.save()
#return HttpResponseRedirect ("Successfully Created").render(request,'dashboard.html' ,{"firstname":fname})
return HttpResponse("Successfully Created")
def project_init(row):
c = Project.query.filter_by(name=row['Categorie']).first()
customer = Customer()
customer.id = row['Id']
customer.category = c
customer.display_as = row['Raison Sociale']
customer.firstname = row['Nom']
customer.lastname = row['Prénoms']
customer.adresse = row['Adresse']
customer.telephone = row['Téléphone']
customer.email = row['Email']
return customer
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 patch(self, id):
"""
Patch customer
"""
customer = Customer.get(id=id, ignore=404)
if customer is None:
abort(404, 'Customer not found.')
data = request.json
updated = False
if data.get('email', None) is not None:
email_search = Customer.search().query(
'match', email=data['email']).execute()
if len(email_search) > 0 and email_search.hits[0].meta.id != id:
abort(400, error='Email already exist.')
customer.email = data['email']
updated = True
if data.get('phone_number', None) is not None:
phone_search = Customer.search().query(
'match', phone_number=data['phone_number']).execute()
if len(phone_search) != 0 and phone_search.hits[0].meta.id != id:
abort(400, error='Phone number already exist.')
customer.phone_number = data['phone_number']
updated = True
if data.get('bluetooth_mac_address', None) is not None:
mac_address_search = Customer.search().query(
'match',
bluetooth_mac_address=data['bluetooth_mac_address']).execute()
if len(mac_address_search
) > 0 and mac_address_search.hits[0].meta.id != id:
abort(400, error='Bluetooth mac address already exist.')
customer.bluetooth_mac_address = data['bluetooth_mac_address']
updated = True
if data.get('last_name', None) is not None:
customer.last_name = data['last_name']
updated = True
if data.get('first_name', None) is not None:
customer.first_name = data['first_name']
updated = True
if updated:
customer.save()
return 'Customer successfully patched.', 204
def create():
form = CustomerForm(request.form)
msg = request.args.get('msg')
if request.method == 'GET':
customers = Customer.query.all()
return render_template('layouts/default.html',
content=render_template('pages/customers.html',
form=form,
msg=msg,
customers=customers))
if form.validate_on_submit():
# assign form data to variables
title = request.form.get('title', '', type=str)
gcpCustomerId = request.form.get('gcpCustomerId', '', type=str)
notes = request.form.get('notes', '', type=str)
customerActive = True
# filter customer out of database through title
customer = Customer.query.filter_by(title=title).first()
if customer:
#do update
customer.title = title
customer.gcpCustomerId = gcpCustomerId
customer.notes = notes
# commit change and save the object
db.session.commit()
msg = 'Customer Updated'
else:
#do insert
customer = Customer(title, gcpCustomerId, notes)
customer.save()
msg = 'Customer Created'
customers = Customer.query.all()
return render_template('layouts/default.html',
content=render_template('pages/customers.html',
form=form,
msg=msg,
customers=customers))
else:
return render_template('layouts/default.html',
content=render_template('pages/customers.html',
form=form,
msg="shit broke"))
def customer_create():
params = request.json
required_fields = ['fullname', 'phone']
for rf in required_fields:
if not params.has_key(rf):
raise BadRequest("Need `%s` field" % rf,
jsonify({'errCode': 'ERROR_FIELD_REQUIRED'}))
if not len(params['fullname']):
raise BadRequest("Fullname not null",
jsonify({'errCode': 'ERROR_FULLNAME_IS_NULL'}))
phone = params['phone']
email = params['email']
note = params.get('note', "")
if not re.match(PHONE_PATTERN, phone):
raise BadRequest("Phone is not true format",
response=jsonify({'errCode': 'ERROR_PHONE_FORMAT'}))
if not re.match(EMAIL_PATTERN, email):
raise BadRequest("Email is not true format",
jsonify({'errCode': 'ERROR_EMAIL_FORMAT'}))
if len(note) > 1000:
raise BadRequest("Note is too long",
jsonify({'errCode': 'ERROR_NOTE_TOO_LONG'}))
conds = (Customer.phone == params['phone'])
if params.get('email'):
conds |= (Customer.email == params['email'])
customer_obj = Customer.query.filter(conds).first()
if customer_obj:
raise SecurityError("Customer %s is existed!" % params['fullname'],
jsonify({'errCode': 'ERROR_CUSTOMER_IS_EXISTED'}))
#TODO verify email and phone
customer_obj = Customer()
customer_obj.fullname = params['fullname']
customer_obj.email = email
customer_obj.phone = phone
customer_obj.note = note
customer_obj.birthday = params.get('birthday')
customer_obj.created_at = datetime.datetime.utcnow()
customer_obj.updated_at = datetime.datetime.utcnow()
db.session.add(customer_obj)
db.session.commit()
customer_obj = Customer.query.filter(Customer.phone == phone).first()
return jsonify(customer_obj.to_dict())
def add_customer():
if not current_user.is_authenticated:
return redirect(url_for('login'))
form = CreateCustomerForm()
if form.validate_on_submit():
user = Customer()
create = user.create(form)
if create:
flash("New customer created with the email: %s" % form.email.data)
url = "/customers"
return redirect(url)
else:
flash('Customer creation failed.')
return render_template('customers/add.html', title='Add a Customer | Medifax', form=form)
def customer_get(id):
if id:
customer = Customer.query.filter_by(site_id=g.sid, branch_id=g.bid,is_active='Y', id=id).first()
else:
no = db.session.query(db.func.max(Customer.no)).filter_by(
site_id=g.sid, branch_id=g.bid).scalar() or 0
no = no + 1
customer = Customer(site_id=g.sid, branch_id=g.bid)
customer.no = no
customer.code = 'C' + str(no).zfill(4)
schema = CustomerSchema()
return jsonify({
'customer': schema.dump(customer).data
})
def create_app(config_name='default'):
"""
Create Flask app
:param config_name:
:return: Flask
"""
from .api import blueprint as api_blueprint
app = Flask(__name__)
CORS(app, resources={r"/api/*": {"origins": "*"}})
app.config.from_object(config[config_name])
config[config_name].init_app(app)
connections.create_connection(
hosts=[config[config_name].ELASTICSEARCH_HOST], timeout=20)
from app.models import User, Customer, Deal, Device, BluetoothLog
with app.app_context():
User.init()
Customer.init()
Deal.init()
Device.init()
BluetoothLog.init()
user_search = User.search().execute()
if len(user_search) == 0:
user = User(username='******')
user.hash_password('averdier')
user.save()
app.register_blueprint(api_blueprint)
extensions(app)
@app.after_request
def after_request(response):
response.headers.add('Access-Control-Allow-Origin', '*')
if request.method == 'OPTIONS':
response.headers[
'Access-Control-Allow-Methods'] = 'DELETE, GET, POST, PUT'
headers = request.headers.get('Access-Control-Request-Headers')
if headers:
response.headers['Access-Control-Allow-Headers'] = headers
return response
return app
def create_customerlist(current_user):
"""
Create a Customer from the sent json data.
:param current_user: Current User
:return:
"""
if request.content_type == 'application/json':
data = request.get_json()
name = data.get('name')
if name:
user_customer = Customer(name.lower(), current_user.id)
user_customer.save()
return response_for_created_customer(user_customer, 201)
return response('failed', 'Missing name attribute', 400)
return response('failed', 'Content-type must be json', 202)
def reset_token(token):
if current_user.is_authenticated:
return redirect(url_for('home'))
customer = Customer.verify_reset_token(token)
if customer is None:
foodseller = Foodseller.verify_reset_token(token)
if foodseller is None:
flash('that is an invalid or expired token')
return redirect(url_for('reset_request'))
else:
form = ResetPasswordForm()
if form.validate_on_submit():
hashed_password = bcrypt.generate_password_hash(form.password.data.decode('utf-8'))
foodseller.password = hashed_password
db.session.commit()
flash('Password updated, you can login now')
return redirect(url_for('login'))
else:
form = ResetPasswordForm()
if form.validate_on_submit():
hashed_password = bcrypt.generate_password_hash(form.password.data.decode('utf-8'))
customer.password = hashed_password
db.session.commit()
flash('Password updated, you can login now')
return redirect(url_for('login'))
return render_template('reset_token.html', title='Reset Password', form=form)
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 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 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 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 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 get_customers(id):
"""
Retrieve a single Customer
This endpoint will return a Customer based on it's id
---
tags:
- Customers
produces:
- application/json
parameters:
- name: id
in: path
description: ID of customer to retrieve
type: integer
required: true
responses:
200:
description: Customer returned
schema:
$ref: '#/definitions/Customer'
404:
description: Customer not found
"""
customer = Customer.find(id)
if not customer:
raise NotFound("Customer with id '{}' was not found.".format(id))
return make_response(jsonify(customer.serialize()), status.HTTP_200_OK)
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 test_get_customer_promo_list(self):
""" Get a list of Customers with given promo status TRUE """
customer = Customer.find_by_promo(True)
resp = self.app.get('/customers?promo=true')
self.assertEqual(resp.status_code, status.HTTP_200_OK)
data = json.loads(resp.data)
self.assertTrue(len(data) == 1)
def orderCreate():
body = request.get_json()
customer = Customer.objects().filter(id=body['customer']).first().to_json()
customer = json.loads(customer)
req = Notifications.SendUser(customer['notification'])
items = Order(**body).save()
return Response(items.to_json(), mimetype="application/json", status=200)
def delete(self, id):
"""
Delete customer
"""
customer = Customer.get(id=id, ignore=404)
if customer is None:
abort(404, 'Customer not found.')
customer.delete()
if Customer.get(id=id, ignore=404) is not None:
abort(400, error='Unable to delete customer.')
return 'Customer successfully deleted.', 204
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 get(self):
args = parser.parse_args()
per_page = min(args['per_page'], 100)
page = args['page']
query = Customer.to_collection_dict(Customer.query, page, per_page)
data = {
'customers': query['items'],
'page': page,
'per_page': per_page,
'total_pages': query['_meta']['total_pages'],
'total_items': query['_meta']['total_items'],
}
if query['has_next']:
data.update(
{
'next_page': api.url_for(
CustomersService,
page=page + 1,
per_page=per_page
)
}
)
if query['has_prev']:
data.update(
{
'prev_page': api.url_for(
CustomersService,
page=page - 1,
per_page=per_page
)
}
)
return data
def deactivate_customers(id):
"""
Deactivate a Customer
This endpoint will deactivate a Customer based the body that is posted
---
tags:
- Customers
produces:
- application/json
parameters:
- name: id
in: path
description: ID of customer to retrieve
type: integer
required: true
responses:
200:
description: Customer updated the active status
schema:
$ref: '#/definitions/Customer'
404:
description: Pet not found
"""
customer = Customer.find(id)
if not customer:
abort(status.HTTP_404_NOT_FOUND,
"Customer with id '{}' was not found.".format(id))
customer.active = False
customer.save()
return make_response(jsonify(customer.serialize()), status.HTTP_200_OK)
def customer_add():
result = None
f = request.get_json()
if f['customer']: f = f['customer']
forms = {
'site_id': g.sid,
'branch_id': g.bid,
'firstname': f.get('firstname') or '',
'lastname': f.get('lastname') or '',
'gender': f.get('gender') or None,
'email': f.get('email') or None,
'phone': f.get('phone') or '',
'img': f.get('img') or None,
'img_path': f.get('img_path') or None
}
email = f.get('email') or ''
cust = Customer.query.filter_by(site_id=g.sid, branch_id=g.bid, email=email).first()
if cust:
# customer already existed
result = cust
else:
# save new customer
customer = Customer(site_id=g.sid, branch_id=g.bid)
for k, v in forms.iteritems():
setattr(customer, k, v)
if customer.code is None:
no = db.session.query(db.func.max(Customer.no)).filter_by(
site_id=g.sid, branch_id=g.bid).scalar() or 0
no = no + 1
customer.no = no
customer.code = 'C' + str(no).zfill(4)
db.session.add(customer)
db.session.commit()
result = customer
# serializer for customer
data = {}
if result:
schema = CustomerSchema()
data = schema.dump(result).data
return jsonify({ 'result': data })
