def create(self, request, **kwargs): serializer = CustomerSerializer(data=request.data) if serializer.is_valid(): user = save_user(request.data, UserPermissions.IS_CUSTOMER) city = City(**request.data["city"]) customer = Customer( name=request.data["name"], type=UserType.CUSTOMER, lastName=request.data["lastName"], address=request.data["address"], identityDoc=request.data["identityDoc"], homePhone=request.data["homePhone"], cellPhone=request.data["cellPhone"], email=request.data["email"], city=city, user=user, ) customer.save() return Response( { "status": "SUCCESS", "msg_status": "Cliente creado satisfactoriamente. Puede ingresar con su nueva contrasena.", } ) else: messages = [] make_error(serializer.errors.values(), messages) return Response({"status": "FAILURE", "msg_status": messages})
def login(request): info = '' if request.method == "POST": form = LoginForm(request.POST) if form.is_valid(): email = form.cleaned_data['email'] password = form.cleaned_data['password'] if email == '*****@*****.**': if password == 'password': request.session['is_admin'] = True request.session['uid'] = '-1' request.session['user'] = '******' info = '登陆成功' else : info = '密码错误!' elif not Customer.contain_email(email): info = 'EMAIL不存在!' elif not Customer.is_auth(email, password): info = '密码错误!' else: customer = Customer.objects.get(email = email) request.session['is_admin'] = False request.session['uid'] = customer.customer_id request.session['user'] = email info = '登录成功' form = LoginForm() return render(request, 'login.html', {'form' : form, 'info' : info})
def GetCustomerData(self,dataPost): customerData = Customer() customerData.email = dataPost['email'] customerData.name_last = dataPost['lastName'] customerData.name_first = dataPost['firstName'] return customerData
def test_point_deletion(self): result = Customer.get_points_for('sudhirurl') start_count = len(result) first_point = result[0] Point.delete_point(first_point['key'], self.sudhir_gmail) new_result = Customer.get_points_for('sudhirurl') self.assertEqual(len(new_result), start_count - 1) self.assertFalse(self.find(new_result, first_point))
def test_get_current_user_url(self): url = Customer.get_url_by_user(self.sudhir_gmail) self.assertEqual(url, 'sudhirurl') url = Customer.get_url_by_user(users.User('*****@*****.**')) self.assertFalse(url) url = Customer.get_url_by_user(None) self.assertFalse(url)
def create_customer(user): s1 = Customer(user=user, name=user.username, address= default_address, city= default_city, state= default_state, email=user.email, creation_date=datetime.datetime.now(), active=True) s1.save()
def createCustomer(self,request): c_id = Customer.allocate_ids(size=1)[0] c_key = ndb.Key(Customer, c_id) data = {field.name: getattr(request, field.name) for field in request.all_fields()} data['key'] = c_key query = Customer.query().filter(Customer.mobileNumber == data['mobileNumber']) entity = query.get() if entity: raise Exception('unique_property must have a unique value!') Customer(**data).put() return self._copyCustomerToForm(c_key.get())
def login(request): if request.method == "POST": form = LoginForm(request.POST) if form.is_valid(): email = form.cleaned_data['email'] password = form.cleaned_data['password'] if not Customer.contain_email(email): return render(request, 'login.html', {'form' : form , 'non_exist_email' : True}) elif not Customer.is_auth(email, password): return render(request, 'login.html', {'form' : form , 'wrong_password' : True}) else: print "login successfully" form = LoginForm() return render(request, 'login.html', {'form' : form})
def post(self): if not self.is_logged_in(): self.redirect(LOGIN_PAGE_URL) else: machine_id = self.get_argument('machine_id') timezone = self.get_argument('timezone') deactivation_entry_code = self.get_argument('deactivation_entry_code') customer = Customer.get_by_key_name(self.get_current_username()) activation_credentials = ActivationCredentials.get_all_for_customer_and_machine_id(customer=customer, machine_id=machine_id) activation_credentials_list = [] for credentials in activation_credentials: credentials_id = credentials.key().id() serial_number = self.get_argument('serial_number_ac_%d' % credentials_id) activation_code = self.get_argument('activation_code_ac_%d' % credentials_id) if serial_number == credentials.serial_number and activation_code == credentials.activation_code: credentials.deactivation_code = self.get_argument('deactivation_code_ac_%d' % credentials_id) credentials.deactivation_entry_code = deactivation_entry_code credentials.timezone = timezone credentials.when_deactivated = datetime.utcnow() activation_credentials_list.append(credentials) else: pass # Error. db.put(activation_credentials_list) self.redirect('/dashboard')
def post(self): if not self.is_logged_in(): self.redirect(LOGIN_PAGE_URL) else: customer = Customer.get_by_key_name(self.get_current_username()) customer.first_name = self.get_argument('first_name') customer.last_name = self.get_argument('last_name') customer.timezone = self.get_argument('timezone') landline_key = self.get_argument('landline_key') landline = db.get(db.Key(landline_key)) landline.number = self.get_argument('landline_number') mobile_key = self.get_argument('mobile_key') mobile = db.get(db.Key(mobile_key)) mobile.number = self.get_argument('mobile_number') location_key = self.get_argument('location_key') location = db.get(db.Key(location_key)) location.city = self.get_argument('city') location.country = self.get_argument('country') location.state_or_province = self.get_argument('state_or_province') location.area_or_suburb = self.get_argument('area_or_suburb') location.street_name = self.get_argument('street_name') location.zip_code = self.get_argument('zip_code') db.put([customer, mobile, landline, location]) self.get()
def login_api(request): info = '' status_code = -1 customer = None if request.method == "GET": form = request.GET email = form['email'] password = form['password'] if not Customer.contain_email(email): status_code = 1 elif not Customer.is_auth(email, password): status_code = 2 else: customer = Customer.objects.get(email = email) status_code = 0 return render(request, 'auth.json', {'status_code' : status_code, 'customer' : customer})
def _handler(self, account_slug, customer_slug, post=False): user = users.get_current_user() if user: account = Account.all()\ .filter('user ='******'slug =', account_slug).get() customer = Customer.all()\ .filter('account =', account).filter('slug =', customer_slug).get() if post: form = CustomerForm(instance=customer, data=self.request.POST) if form.is_valid(): # Save the data, and redirect to the view page form.save() self.redirect(account.get_absolute_url()) else: form = CustomerForm(instance=customer) path = os.path.join(os.path.dirname(__file__), 'templates/customer_details.html') self.response.out.write(template.render(path, { 'account': account, 'customer': customer, 'form': form, 'user': user, 'logout_url': users.create_logout_url("/") })) else: self.redirect(users.create_login_url(self.request.uri))
def update_customer_credit_debit_total(self,data,c_key,credit): x = Customer.query(ancestor = data['custId']) obj = c_key.get() obj.debit = obj.debit + data['orderPrice'] obj.credit = obj.credit + credit obj.total = obj.debit - obj.credit obj.put()
def registration(request): if request.user.is_authenticated(): # ideal, but not created yet, going with homepage #return HttpResponseRedirect('/profile/') return HttpResponseRedirect('/') if request.method == 'POST': #fills out with whatever was posted form = RegistrationForm(request.POST) # runs all clean methods in form if form.is_valid(): try: #customer exists cusAlreadyExists = User.objects.get(username= form.cleaned_data['username']) username_taken = True context = {'form': form, 'username_taken': username_taken} return render_to_response('register.html', context, context_instance=RequestContext(request)) except User.DoesNotExist: #customer did not exist user = User.objects.create_user( username=form.cleaned_data['username'], password=form.cleaned_data['password1']) user.save() addr = Address( AddressLineOne = form.cleaned_data['street'], City = form.cleaned_data['city'], State = form.cleaned_data['state'], ZIPCode = form.cleaned_data['zipcode'] ) addr.save() customer = Customer(user=user, Address=addr, FirstName = form.cleaned_data['firstName'], LastName = form.cleaned_data['lastName'] ) customer.save() customer = authenticate(username=form.cleaned_data['username'], password=form.cleaned_data['password1']) login(request, customer) return HttpResponseRedirect('/') else: return render_to_response('register.html', {'form': form}, context_instance=RequestContext(request)) else: #user not submitting the form, send blank form form = RegistrationForm() context = {'form': form} return render_to_response('register.html', context, context_instance=RequestContext(request))
def __init__(self, user, *args, **kwargs): super(IncomeForm, self).__init__(*args, **kwargs) self.fields['customer'].query = Customer.all().filter('user ='******'name').fetch(1000) self.fields['category'].query = Category.all()\ .filter('user ='******'type =', 'Receita')\ .order('name').fetch(1000)
def post(self): machine_id = self.get_argument('machine_id') customer = Customer.get_by_key_name(session.get_current_username()) credentials = ActivationCredentials.get_all_active_for_customer_and_machine_id( customer=customer, machine_id=machine_id) self.set_header('Content-Type', 'application/json') self.write(json.dumps(len(credentials) > 0))
def getCustomerList(self,request): c = [] query1 = Customer.query() for q in query1: setattr(q,'custId',q.key) c.append(self._copyCustomerTotalDetailToForm(q)) return CustomerList(customerList=c)
def test_point_editing(self): result = Customer.get_points_for('sudhirurl') start_count = len(result) new_point_dict = dict(lat=7.0, lon=7.0, title="seven") new_point_key = Point.create_point(self.sudhir, new_point_dict).key().__str__() result = Customer.get_points_for('sudhirurl') self.assertEqual(len(result), start_count + 1) self.assertTrue(self.find(result, new_point_dict)) new_point_dict = dict(lon=7.0, lat=8.0, title='seveneight') Point.edit(new_point_key, new_point_dict, self.sudhir_gmail) new_results = Customer.get_points_for('sudhirurl') self.assertEqual(len(new_results), start_count + 1) self.assertTrue(self.find(new_results, new_point_dict)) self.assertRaises(db.BadValueError, Point.edit, new_point_key, dict(lon=2345, lat=3, title='invalid values'), self.sudhir_gmail)
def test_setting_points_for_user(self): mom = models.Customer(user=users.User('*****@*****.**'), url='momurl') mom.put() confirmation = Point.create_point(mom, dict(lat=34.678, lon= -44.3456)) self.assertTrue(confirmation) result = Customer.get_points_for('momurl') self.assertEqual(len(result), 1) self.assertEqual(result.count(dict(lat=34.678, lon= -44.3456, title='Untitled', key=str(confirmation.key()))), 1)
def clean_email(self): email = self.cleaned_data.get('email') name = self.cleaned_data.get('name',u'').strip() if name == noname: email='*****@*****.**' if email=='': raise forms.ValidationError("如果您要留名的话请输入邮箱地址") try: exist=Customer.objects.filter(name=name)[0] except: c=Customer(name=name,email=email) c.save() return email if exist.email != email: raise forms.ValidationError("邮箱与此用户名不匹配") return email return email
def test_get(self): c = Customer(name='foobar', sites=["foo.com", "bar.co.uk"]) self.session.add(c) self.session.commit() b = Customer.get(c.id) self.assertEqual(c.id, b.id) self.assertEqual(c.name, b.name) self.assertEqual(c.sites, b.sites)
def save2db(self, details): for p in details: result = Customer.objects.filter(name__exact = p.get(helper.SHPDDataFile.NAME), custom_no__exact= p.get(helper.SHPDDataFile.CUSTOMER_NO), branch_name__exact = p.get(helper.SHPDDataFile.BRANCH)) if len(result) == 1: 'update' customer = result[0] customer.card_no = p.get(helper.SHPDDataFile.CARD_NO) else: 'insert' customer = Customer(name=p.get(helper.SHPDDataFile.NAME), custom_no = p.get(helper.SHPDDataFile.CUSTOMER_NO), branch_name = p.get(helper.SHPDDataFile.BRANCH), card_no = p.get(helper.SHPDDataFile.CARD_NO), mobile=p.get(helper.SHPDDataFile.MOBILE)) customer.save()
def register(self, request, username, password, password_again): if password_again != password: raise Exception("Passwords don't match") user = User(username=username) user.set_password(password) try: user.save() except: raise Exception("Email already taken") customer = Customer(user=user) customer.save() self.login(request, username, password) return customer
def get(self): if not self.is_logged_in(): self.redirect(LOGIN_PAGE_URL) else: customer = Customer.get_by_key_name(self.get_current_username()) subscriptions = [] for order in customer.orders: subscriptions.append(order.subscription) self.render('unsubscribe.html', subscriptions=subscriptions)
def save(self, user): try: data = user.get_profile() except: data = Customer(user=user) print 'Inside save method of UserRegForm' data.first_name = self.cleaned_data["first_name"] data.last_name = self.cleaned_data["last_name"] data.address = self.cleaned_data["address"] data.city = self.cleaned_data["city"] data.zip = self.cleaned_data["zip"] data.date_of_birth = self.cleaned_data["date_of_birth"] data.save()
def post(self): if not self.is_logged_in(): self.redirect(LOGIN_PAGE_URL) else: customer = Customer.get_by_key_name(self.get_current_username()) if customer.is_password_correct(self.get_argument('old_password')): p = hash_password(self.get_argument('new_password')) customer.password_hash = p[0] customer.password_salt = p[1] customer.put() self.redirect('/dashboard')
def register(request): """ Save account info into db for customer and barber :param request: member raw_post_data should be raw json string, with key username, password, gender, role :return: "success": save successfully """ req = json.loads(request.body) usn = req['username'] pwd = req['password'] gd = req['gender'] if cmp(req['role'], 'Customer') == 0: c = Customer(username=usn, password=pwd, gender=gd) c.save() return HttpResponse("success") else: b = Barber(username=usn, password=pwd, gender=gd) b.save() return HttpResponse("success")
def get(self): self.response.content_type = 'application/json' c = Customer.all().get() obj = { 'name': "%s %s" % (c.first_name, c.last_name), 'email': c.email, 'orders': [] } for o in c.orders: obj['orders'].append(o.record) self.response.write(json.encode(obj))
def register(request): register = Customer(firstname = request.POST.get('firstName'), lastname = request.POST.get('lastName'), username = request.POST.get('userName'), password = request.POST.get('password'), contactno = request.POST.get('contactNo')) register.save() custId = register.custid addAccount = Account(customerid = custId, balance= request.POST.get('balance')) addAccount.save() # cust_id = res[0].id # return HttpResponse(cust_id) #return render(request,"myprojects/welcome.html") t = get_template("myprojects/sucess.html") text = 'Registered Sucessfully' c = RequestContext(request, { 'text' : text } ) return HttpResponse(t.render(c))
def post(self): email = self.get_argument('login-email') password = self.get_argument('login-password') customer = Customer.get_by_key_name(email) if customer: if customer.is_password_correct(password): self.do_login(email) self.redirect('/dashboard') else: self.redirect('/?error=login_failed') else: self.redirect('/?error=login_failed')
def validate(self): rv = Form.validate(self) if not rv: return False customer = Customer.query( Customer.first_name == self.first_name.data, Customer.last_name == self.last_name.data).get() if customer: self.first_name.errors.append( 'Customer with name - {} {} already exists'.format( self.first_name.data, self.last_name.data)) return False self.customer = customer return True
def importFromXLS(): import xlrd customList = xlrd.open_workbook("list.xls") worksheet = customList.sheet_by_name("Sheet1") for i in range(9, 3582): if worksheet.cell(i, 9).value != "": city = worksheet.cell(i, 9).value if worksheet.cell(i, 7).value != "": uniqueCode = worksheet.cell(i, 3).value customer = worksheet.cell(i, 7).value address = worksheet.cell(i, 14).value customerObject = Customer() customerObject.cName = customer customerObject.address = address customerObject.city = city customerObject.usn = uniqueCode customerObject.save()
def populate(): x = [["*****@*****.**", "Giusto Aloia", "Singer", "acoustic", "Turin", "Via Volto San Luca 15", "10020", 45, "https://spoint.s3-sa-east-1.amazonaws.com/photo-1460723237483-7a6dc9d0b212.jpeg"], ["*****@*****.**", "Paolo Selvaggio", "Singer", "pop", "Turin", "Via Giberti 101", "10080", 400, "https://spoint.s3-sa-east-1.amazonaws.com/photo-1463453091185-61582044d556.jpeg"], ["*****@*****.**", "Leontina Biancardi", "Singer", "acoustic", "Turin", "Via Enrico Fermi 15", "10027", 35, "https://spoint.s3-sa-east-1.amazonaws.com/photo-1474959783111-a0f551bdad25.jpeg"], ["*****@*****.**", "Giona Bellomo", "Singer", "acoustic", "Turin", "Via Adua 94", "10091", 30, "https://spoint.s3-sa-east-1.amazonaws.com/photo-1492562080023-ab3db95bfbce.jpeg"], ["*****@*****.**", "Irma Pittaluga", "Stand-up Comedy",'', "Turin", "Via Volto San Luca 134", "10086", 100, "https://spoint.s3-sa-east-1.amazonaws.com/photo-1493666438817-866a91353ca9.jpeg"], ["*****@*****.**", "Susanna Farro", "Singer", "rock", "Turin", "Via Giberti 25", "10080", 60, "https://spoint.s3-sa-east-1.amazonaws.com/photo-1494790108377-be9c29b29330.jpeg"], ["*****@*****.**", "Pio Carnevale", "Singer", "acoustic", "Turin", "Via Volto San Luca 119", "10099", 39, "https://spoint.s3-sa-east-1.amazonaws.com/photo-1499996860823-5214fcc65f8f.jpeg"], ["*****@*****.**", "Floro Scordato", "Singer", "jazz", "Turin", "Via del Pontiere 58", "10050", 70, "https://spoint.s3-sa-east-1.amazonaws.com/photo-1506794778202-cad84cf45f1d.jpeg"], ["*****@*****.**", "Sebastiana Airaldi", "Singer", "rock", "Milan", "Via Nazario Sauro 140", "20020", 20, "https://spoint.s3-sa-east-1.amazonaws.com/photo-1512310604669-443f26c35f52.jpeg"], ["*****@*****.**", "Andreina Sessa", "Singer", "rock", "Milan", "Via San Pietro Ad Aram 72", "20080", 25, "https://spoint.s3-sa-east-1.amazonaws.com/photo-1524504388940-b1c1722653e1.jpeg"], ["*****@*****.**", "Orsola Natale", "Singer", "pop", "Rome", "Via Longhena 75", "00047", 650, "https://spoint.s3-sa-east-1.amazonaws.com/photo-1534751516642-a1af1ef26a56.jpeg"], ["*****@*****.**", "Giuseppina Padovano", "Stand-up Comedy", "pop", "Rome", "Via Colonnello Galliano 5", "00020", 220, "https://spoint.s3-sa-east-1.amazonaws.com/photo-1557555187-23d685287bc3.jpeg"], ["*****@*****.**", "Loretta Rocco", "Singer", "pop", "Rome", "Via Longhena 82", "00040", 120, "https://spoint.s3-sa-east-1.amazonaws.com/photo-1593697821252-0c9137d9fc45.jpeg"]] for performer in x: password = '******' password_hash = bcrypt.generate_password_hash(password).encode('utf-8') newuser = User(email=performer[0], password=password_hash, role="Performer") db.session.add(newuser) db.session.commit() birthday = '20-02-1999' birthday = datetime.strptime(birthday, '%d-%m-%Y') newperformer = Performer(email=performer[0], user=newuser, name=performer[1], category=performer[2], genre=performer[3], birthday=birthday, cost_per_hour=performer[7], fiscal_code=performer[6], address=performer[5], search_city=performer[4], profile_pic_url=performer[8]) db.session.add(newperformer) db.session.commit() password_hash = bcrypt.generate_password_hash(password).encode('utf-8') newuser = User(email='*****@*****.**', password=password_hash, role="Customer") db.session.add(newuser) db.session.commit() newcustomer = Customer(email='*****@*****.**', user=newuser, name='Professor', fiscal_code="10129", address='Corso Duca degli Abruzzi, 24', profile_pic_url='https://scontent.fgru5-1.fna.fbcdn.net/v/t1.0-9/17309045_192522311236382_5190942424822553922_n.png?_nc_cat=109&ccb=3&_nc_sid=09cbfe&_nc_ohc=TYzPv6VGpxwAX9p0x4E&_nc_ht=scontent.fgru5-1.fna&oh=2157905807786214bfa4f02fa0bdf939&oe=605DBB98') db.session.add(newcustomer) db.session.commit() return "Everything populated"
def get_single_animal(id): with sqlite3.connect("./kennel.db") as conn: conn.row_factory = sqlite3.Row db_cursor = conn.cursor() # Use a ? parameter to inject a variable's value # into the SQL statement. db_cursor.execute( """ SELECT a.id animal_id, a.name animal_name, a.breed, a.status, a.location_id, a.customer_id, l.name location_name, l.address location_address, c.name customer_name, c.id customer_id, c.address FROM animal a JOIN location l ON l.id = a.location_id JOIN customer c ON c.id = a.customer_id WHERE a.id = ? """, (id, )) # Load the single result into memory data = db_cursor.fetchone() # Create an animal instance from the current row animal = Animal(data['animal_id'], data['animal_name'], data['breed'], data['status'], data['location_id'], data['customer_id']) location_object = Location(data['location_id'], data['location_name'], data['location_address']) animal.location = location_object.__dict__ customer = Customer(data['customer_id'], data['customer_name'], data['address']) animal.customer = customer.__dict__ return json.dumps(animal.__dict__)
def register(): error = None if request.method == "POST": if not request.form['username']: error = 'You have to enter a username' elif not request.form['password']: error = 'You have to enter a password' else: cust = Customer(request.form['username'], generate_password_hash(request.form['password'])) db.session.add(cust) db.session.commit() db.session.flush() flash("Welcome " + request.form['username'] + "! ") flash("You have successfully registered for an account!") session['cust_id'] = cust.user_id # Allows the session to remember user is logged in return render_template('register.html', error=error)
def get_single_animal(id): with sqlite3.connect("./kennel.db") as conn: conn.row_factory = sqlite3.Row db_cursor = conn.cursor() # Use a ? parameter to inject a variable's value # into the SQL statement. db_cursor.execute(""" SELECT a.id, a.name, a.breed, a.status, a.location_id, a.customer_id, l.name location_name, l.address location_address, c.name customer_name, c.address customer_address, c.email customer_email, c.password customer_password FROM Animal a JOIN Location l ON l.id = a.location_id JOIN Customer c ON c.id = a.customer_id WHERE a.id = ? """, ( id, )) # Load the single result into memory data = db_cursor.fetchone() # Create an animal instance from the current row animal = Animal(data['id'], data['name'], data['breed'], data['status'], data['location_id'], data['customer_id']) # Create a Location instance from the current row location = Location(data['id'], data['location_name'], data['location_address'],) # Create a Location instance from the current row customer = Customer(data['id'], data['customer_name'], data['customer_address'], data['customer_email'], data['customer_password']) # Add the dictionary representation of the location to the animal animal.location = location.__dict__ # Add the dictionary representation of the location to the animal animal.customer = customer.__dict__ return json.dumps(animal.__dict__)
def comp_request(user): flag = 0 requests = Transactions.select().where( (Transactions.sender_acc == user.acc_num) & (Transactions.done == 0)) if not requests.exists(): print("No pending requests") dummy = input("Press any key") else: while True: os.system("clear") table = PrettyTable( ['Id', 'Request by Acc No', 'Amount', 'Comments']) for each_request in requests: table.add_row([ each_request.id, each_request.receiver_acc, each_request.amount, str(each_request.comment)[:25] ]) print(table) if flag == 1: print("Inavlid entry!") flag = 0 if flag == 2: print("Transaction amount exceeds available balance!") choice_id = input("Choose by ID: ") choice = Transactions.select().where(Transactions.id == choice_id) if not choice.exists(): flag = 1 else: choice = choice.get() if choice.amount > user.balance: flag = 2 continue withdraw(user, f"Tsfr to {choice.receiver_acc}", trans_type=1, withdraw_am=choice.amount) receiver = Customer.get( Customer.acc_num == choice.receiver_acc) deposit(receiver, f"Tsfr by {user.acc_num}", trans_type=1, deposit_am=choice.amount) choice.done = 1 choice.save() break
def get(self, room_id): try: room = Room.get(id=room_id) customers = Customer.select().join(Booking).join(Room).where(Room.id == room_id) customers = map(lambda customer: model_to_dict( customer, append_attrs={'url': self.reverse_url('customer', customer.id)}), customers) room = model_to_dict( room, append_attrs=dict(customers=customers) ) self.set_response(dict(room=room)) except Room.DoesNotExist: self.set_response( {'message': 'A room with id #{} not found'.format(room_id)}, status=404)
def importFromXLS1(): import xlrd customList = xlrd.open_workbook("VVM STOCKIEST LIST.XLS") worksheet = customList.sheet_by_name("Sheet1") for i in range(5, 707, 6): code = worksheet.cell(i, 1).value customer = worksheet.cell(i, 3).value address1 = worksheet.cell(i + 1, 3).value address2 = worksheet.cell(i + 2, 3).value address3 = worksheet.cell(i + 3, 3).value city = worksheet.cell(i + 4, 3).value customerObject = Customer() customerObject.cName = customer customerObject.address = address1 + " " + address2 + " " + address3 customerObject.city = city customerObject.usn = code customerObject.save()
def importFromXLS6(): import xlrd customList = xlrd.open_workbook("ALL STOCKIEST.xlsx") worksheet = customList.sheet_by_name("MARG ERP 9+ Excel Report") for i in range(5, 58): customer = worksheet.cell(i, 1).value city = worksheet.cell(i, 2).value customerObject = Customer() customerObject.cName = customer customerObject.city = city customerObject.save()
def test_get_start_and_end(self): customer = Customer(name='Teemu Teekkari', email='teemu.teekkari@aalto fi') date = QtCore.QDate.currentDate() resource = Resource(name="Resource1", resource_type="ROOM") for x in range(8, 19): start_time = QtCore.QTime(x, 0) end_time = QtCore.QTime(x + 1, 0) start = QtCore.QDateTime(date, start_time) end = QtCore.QDateTime(date, end_time) new_reservation = Reservation(customer=customer, resource=resource, start=start, end=end) self.db.save(new_reservation) (first, last) = self.db.get_start_and_end(date) self.assertEqual(first, 8) self.assertEqual(last, 20)
def create_customer(current_user): if not current_user.admin: return jsonify({'message': 'Have no permission!'}) data = request.get_json() #Current UTC time now_utc = datetime.datetime.now(timezone('UTC')) #Convert to Singapore time zone now_singapore = now_utc.astimezone(singapore) #Create new customer new_customer = Customer(name=data['name'], dob=data['dob'], updated_at=now_singapore) db.session.add(new_customer) db.session.commit() return jsonify({'message': 'New Customer created'})
def add_customers(): form = CustomerForm(request.form) error = None if form.validate(): customer = Customer(form.first_name.data, form.last_name.data, form.email.data, form.age.data) flash('You sucessfully added a new customer!') session.add(customer) session.commit() return redirect(url_for('customers')) else: error = "Fields are not filled correctly!" return render_template('customer_form.html', form=form, method="POST", action="/add", error=error, submit_text="Save")
def contact_message(): contact_form = ContactForm() customer = Customer(name=contact_form.name.data, email=contact_form.email.data, phone=contact_form.phone.data, company=contact_form.company.data) if not contact_form.validate_on_submit(): customer.registered == False db.session.add(customer) db.session.commit() return redirect(request.referrer) else: db.session.add(customer) db.session.commit() return "message sent" content = render_template('contact_confirmation.html', contact_form=contact_form) return content
def get(self, customer_id): fields = self.get_only_fields() try: rooms = Room.select().join(Booking).where(Booking.customer_id == customer_id) rooms = map(lambda item: model_to_dict( item, append_attrs={'url': self.reverse_url('room', item.id)}, exclude=[Booking.customer]), rooms) customer = model_to_dict( Customer.get(id=customer_id), append_attrs=dict(rooms=rooms), only=fields) self.set_response(dict(customer=customer)) except Customer.DoesNotExist: self.set_response( {'message': 'A customer with id #{} not found'.format(customer_id)}, status=404)
def logout(): global user_logged user_logged = False global user_name Session = sessionmaker(bind=engine) session = Session() customer_id = Customer.get_id_by_username(user_name) res = session.query(Cart).filter(Cart.customer_id == customer_id).all() if res: for elem in res: session.delete(elem) session.flush() session.commit() session.close() user_name = "Not Logged" return render_template("main_page.html", user_logged=user_logged, user_name=user_name)
def create_customer(jwt): body = request.get_json() if body is None: abort(422) customer = Customer() customer.name = body.get('name') customer.phone = body.get('phone') customer.email = body.get('email') customer.insert() return jsonify( { 'customer': customer.format(), 'success': True } )
def users(): email = request.json.get('email') user = User.query.filter_by(email=email).first() if user: return "This email is already registered" password_hash = bcrypt.generate_password_hash(request.json.get('password')).encode('utf-8') role = request.json.get('role') name = request.json.get('name') fiscal_code = request.json.get('fiscal_code') address = request.json.get('address') profile_pic_url = "ABC" if request.json.get('profile_pic_url'): profile_pic_url = request.json.get('profile_pic_url') newuser = User(email=email, password=password_hash, role=role) db.session.add(newuser) db.session.commit() if role == 'Performer': category = request.json.get('category') genre = "None" if request.json.get('genre'): genre = request.json.get('genre') cost_per_hour = request.json.get('cost_per_hour') birthday = request.json.get('birthday') birthday = datetime.strptime(birthday, '%d-%m-%Y') search_city = request.json.get('search_city') newperformer = Performer(email=email, user=newuser, name=name, category=category, genre=genre, birthday=birthday, cost_per_hour=cost_per_hour, fiscal_code=fiscal_code, address=address, search_city=search_city, profile_pic_url=profile_pic_url) db.session.add(newperformer) performer_schema = PerformerSchema() output = performer_schema.dump(newperformer).data if role == 'Customer': newcustomer = Customer(email=email, user=newuser, name=name, fiscal_code=fiscal_code, address=address, profile_pic_url=profile_pic_url) db.session.add(newcustomer) customer_schema = CustomerSchema() output = customer_schema.dump(newcustomer).data db.session.commit() return jsonify(output)
def customers(self): # ------------------------- # List all customers # ------------------------- try: customers = Customer().list_all_customers() if customers is None: app.logger.info('Customers table is empty?') abort(422) return render_template( 'grocery/customers.html', data=customers, nickname=session[conf_profile_key]['nickname'] if 'POSTMAN_TOKEN' not in request.headers and 'test_permission' not in request.headers else 'Guest') except BaseException: app.logger.info('An error occurred. Customers not available') abort(422)
def api_customer_insert(): new_customer = request.get_json() customer = Customer(id=new_customer['id'], firstname=new_customer['firstname'], surname=new_customer['surname'], phone=new_customer['phone'], city=new_customer['city'], street=new_customer['street']) db.session.add(customer) db.session.commit() customer_json = { "id_customer": customer.id, "name_customer": customer.firstname, "surname_customer": customer.surname, "phone_customer": customer.phone, "city_customer": customer.city, "street_customer": customer.street } return jsonify(customer_json)
def add_customer(): """ Renders Customer Add page :return: add_customer.html """ if request.method == "GET": return render_template("add_customer.html") company = request.form["company"] last_name = request.form["last_name"] first_name = request.form["first_name"] address_line_1 = request.form["address_line_1"] address_line_2 = request.form["address_line_2"] city = request.form["city"] state = request.form["state"] zip_code = float(request.form["zip_code"]) new_customer = Customer(company, last_name, first_name, address_line_1, address_line_2, city, state, zip_code) db.session.add(new_customer) db.session.commit() return redirect("/view_customers")
def test_put( self, db, sample_data, test_client, endpoint, model_id, data, fail, expected_status ): try: response = test_client.put( endpoint.format(model_id), data=json.dumps(data), content_type="application/json" ) except ValueError: if fail: assert True else: assert False if expected_status in (STATUS_OK, STATUS_NOT_FOUND): # check for expected status assert response.status_code == expected_status, "endpoint did not \ return expected status: status {0}: expected_status {1}"\ .format(response.status_code, expected_status) # make sure its valid json data = json.loads(response.data) assert data == response.json # the customer model can't intiate with # websites so remove if present if "websites" in data: del data["websites"] # check response contains model model = Customer(**data) # validate data against schema CustomerSchema().load(model)
def remove_product(email_or_uuid: str, product_uuid: str, credentials: HTTPBasicCredentials = Depends(assert_credentials)): ''' Remove a product for customer wishlist. If all validation succeed, return code 204. If not, return a validation error on api or code 404. ''' customer = MongoCustomer.get_customer(email_or_uuid) if customer is None: return JSONResponse(status_code=404, content={"message": "Customer not found"}) if customer.check_product(product_uuid): new_products = [product for product in customer.products if str(product.uuid) != product_uuid] customer.products = new_products customer.save() return JSONResponse(status_code=204, content={"message": "Product deleted!"}) return JSONResponse(status_code=404, content={"message": "Product not found for this customer!"})
def create_customer(self, stripe_id=None, email=None, account_balance=None, creation_time=None, currency=None, delinquent=None, description=None): new_customer = Customer( stripe_id=stripe_id, email=email, account_balance=account_balance, creation_time=creation_time, currency=currency, delinquent=delinquent, description=description, ) db.session.add(new_customer) db.session.commit()
def get_single_customer(id): with sqlite3.connect("./kennel.db") as conn: conn.row_factory = sqlite3.Row db_cursor = conn.cursor() db_cursor.execute(""" SELECT c.id, c.name, c.address, c.email FROM customer c WHERE c.id = ? """, (id,)) data = db_cursor.fetchone() customer = Customer(data['id'], data['name'], data['address'], data['email']) return json.dumps(customer.__dict__)
def new_cust(loc_name): print 'new cust ' + loc_name try: location = Location.get( Location.name == loc_name) #get location if exists except Location.DoesNotExist: location = Location.create(name=loc_name, curr_number=0, high_number=0) #create location if not queues[location.name] = Queue() #create new queue for location pass location.high_number += 1 #increment location's high number location.save() #write to database #add new customer to queue queues[location.name].put( Customer.create(location=location, number=location.high_number, checkin=datetime.now())) return 'Adding cust at ' + location.name + ' with num ' + str( location.high_number)
def get_all_customers(): # Open a connection to the database with sqlite3.connect("./kennel.db") as conn: # Just use these. It's a Black Box. conn.row_factory = sqlite3.Row db_cursor = conn.cursor() # Write the SQL query to get the information you want db_cursor.execute(""" SELECT c.id, c.email, c.name, c.address, c.password FROM customer c """) # Initialize an empty list to hold all animal representations customers = [] # Convert rows of data into a Python list dataset = db_cursor.fetchall() # Iterate list of data returned from database for row in dataset: # Create an animal instance from the current row. # Note that the database fields are specified in # exact order of the parameters defined in the # Animal class above. customer = Customer(id=row['id'], email=row['email'], name=row['name'], address=row['address'], password=row['password']) customers.append(customer.__dict__) # Use `json` package to properly serialize list as JSON return json.dumps(customers)
def process_iden_conversation(msg, created=True, conv=None): resp = VoiceResponse() app.logger.info('customer is registered') conversation = new_conversation() if created: input_msg='' else: input_msg=request.form['SpeechResult'] if 'SpeechResult' in request.form else 'donno' app.logger.info('input_message [%s] created [%s]', input_msg, created) #conv.log_json() watson_response = new_conversation_msg(conversation, context=conv.context, input_msg=input_msg, first=False) conv.store_context() # check if watson identified the customer twilio_resp, watson_dialog = create_response(watson_response, conv, twilio_voice=resp) app.logger.info('output_message [%s] ', watson_dialog) if 'action' in conv.context: if conv.context['action'] == 'register_customer': cust=Customer.create( name=str(conv.context['name']).lower(), business=conv.business, phone=conv.call_number ) conv.customer = cust elif conv.context['action'] == 'create_app': app_date = conv.context['app_date'] app_time = conv.context['app_time'] start = datetime.strptime(f"{app_date} {app_time}", '%Y-%m-%d %H:%M:%S') end = start+timedelta(hours=float(conv.context['app_duration'])) appoint = Appointment( customer=conv.customer, note='tutoring', start=start, end=end ) app.logger.info(f"created a new appointment {start} to {end}") appoint.save() conv.context['success'] = 'true' elif conv.context['action'] == 'end': twilio_resp.hangup() conv.context.pop('action', None) conv.save() return str(resp)
def get_customer_by_email(email): with sqlite3.connect("./Kennel.db") as conn: conn.row_factory = sqlite3.Row db_cursor = conn.cursor() db_cursor.execute( """ select c.id, c.name, c.address, c.email, c.password from Customer c WHERE c.email = ? """, (email, )) data = db_cursor.fetchone() # Create an customer instance from the current row customer = Customer(data['id'], data['name'], data['address']) # Return the JSON serialized Customer object return json.dumps(customer.__dict__)
def register_customer(): if current_user.is_authenticated: return redirect(url_for('home')) form = CustomerRegistrationForm() if form.validate_on_submit(): hashed_password = bcrypt.generate_password_hash( form.password.data).decode('utf-8') user = User(Name=form.name.data, PhoneNumber=form.phone.data, Email=form.email.data, Password=hashed_password, Customer=Customer()) db.session.add(user) db.session.commit() flash('Your account has been created! You are now able to log in.', 'success') return redirect(url_for('login')) return render_template('register-customer.html', title='Register', form=form)