def clientes2(): data = request.json client = Client() #PASOXXX clienteexiste = Client.query.filter_by(rut=data["rut"]).first() if clienteexiste is not None: return jsonify({"ERROR": "RUT DE CLIENTE YA EXISTE"}), 200 client.name = data["name"] client.rut = data["rut"] client.direccion = data["direccion"] client.website = data["website"] client.email = data["email"] client.phone = data["phone"] client.users_id = data["users_id"] #user.password = sha256.hash(data["password"]) db.session.add(client) #PASOXXX db.session.commit() return jsonify(client.serialize()), 200
def upload_from_csv_and_add_to_db(): with open('department.csv', 'r') as c_file: reader = csv.reader(c_file) for n, row in enumerate(reader): if n == 0: pass else: department = Department(id=row[0], city=row[1], count_of_workers=row[2]) session.add(department) with open('client.csv', 'r') as c_file: reader = csv.reader(c_file) for n, row in enumerate(reader): if n == 0: pass else: client = Client(id=row[0], first_name=row[1], last_name=row[2], education=row[3], passport=row[4], city=row[5], age=row[6], department_id=row[7]) session.add(client) with open('application.csv', 'r') as c_file: reader = csv.reader(c_file) for n, row in enumerate(reader): if n == 0: pass else: application = Application(suma=row[1], credit_state=row[2], currency=row[3], client_id=row[4]) session.add(application) session.commit()
def new_client(self, cmd, anon_ch): valid, msg, owner = self.check_new_params(cmd) if valid: try: api_server, key, secret, access_token, refresh_token = self.generate_client(cmd, owner) except ClientException as e: ch = ClientsChannel(name=anon_ch) ch.put({'status': 'error', 'message': e.msg}) return None cl = Client(**{'tenant': cmd['tenant'], 'actor_id': cmd['actor_id'], 'worker_id': cmd['worker_id'], 'client_key': key, 'client_name': cmd['worker_id'], }) clients_store[cl.id] = cl self.send_client(api_server, key, secret, access_token, refresh_token, anon_ch) else: anon_ch.put({'status': 'error', 'message': 'Invalid command parameters: {}'.format(msg)})
def clients(): if request.method == 'GET': query = Client.query() all_clients = [{ 'name': client.name, 'id': client.key.urlsafe().decode('utf-8') } for client in query] return jsonify(all_clients), 200 elif request.method == 'POST': client_name = request.json.get('name') if not client_name: raise Exception('Request body must have the name property') query = Client.query().filter(Client.name == client_name) clients = [client.name for client in query] if len(clients) >= 1: raise Exception(f'Client with name {client_name} already exists') new_client = Client(name=client_name) new_client.put() return jsonify({'success': True}), 200 else: raise Exception('Method not supported')
def client_add(cls, request): try: token = jwt.decode(request.token, 'secret') #CHECA EL TOKEN user = Usuarios.get_by_id( token['user_id'] ) #obtiene el usuario para poder acceder a los metodos declarados en models.py en la seccion de myclient = Client() if myclient.client_m( request, user.key ) == 0: #llama a la funcion declarada en models.py en la seccion de PRODUCTS codigo = 1 else: codigo = -3 #la funcion josue_m puede actualizar e insertar #depende de la ENTRADA de este endpoint method message = CodeMessage(code=codigo, message='Client added') except jwt.DecodeError: message = CodeMessage(code=-2, message='Invalid token') except jwt.ExpiredSignatureError: message = CodeMessage(code=-1, message='Token expired') return message
def on_convert(self, request): if should_exclude_visitor(request): return json_success({'excluded': 'true'}, request) experiment_name = request.args.get('experiment') client_id = request.args.get('client_id') kpi = request.args.get('kpi', None) if client_id is None or experiment_name is None: return json_error({'message': 'missing arguments'}, request, 400) client = Client(client_id, self.redis) try: experiment = Experiment.find(experiment_name, self.redis) if cfg.get('enabled', True): dt = None if request.args.get("datetime"): dt = dateutil.parser.parse(request.args.get("datetime")) alternative = experiment.convert(client, dt=dt, kpi=kpi) else: alternative = experiment.control.name except ValueError as e: return json_error({'message': str(e)}, request, 400) resp = { 'alternative': { 'name': alternative }, 'experiment': { 'name': experiment.name, }, 'conversion': { 'value': None, 'kpi': kpi }, 'client_id': client_id } return json_success(resp, request)
def create_client(request, client_id): if request.method == 'GET': if client_id: client = Client.objects.get(id=client_id) data = client.as_dict() else: data = {} data['client_id'] = client_id return render(request, 'new_client_form.html', data) if request.method == 'POST': data = request.POST if client_id: client = Client.objects.get(id=client_id) else: # Creating a new client client = Client() client.create_from_dict(data, request.user) client.save() return HttpResponseRedirect('/crc/list_clients')
def register(): form = RegistrationForm() if request.method == 'POST' and form.validate_on_submit(): mail = form.mail.data client = db.session.query(Client).filter(Client.mail == mail).first() if client: if client.password_valid(form.password.data): session['auth'] = client.id return redirect('/account/') else: err_msg = 'Не верный пароль вводишь ты' return render_template('register.html', form=form, err_msg=err_msg) else: new_client = Client(mail=mail, password_hash=generate_password_hash(form.password.data)) db.session.add(new_client) db.session.commit() session['auth'] = True return redirect('/account/') elif request.method == 'POST' and not form.validate_on_submit(): return render_template('register.html', form=form) else: return render_template('register.html', form=form)
def set_up_database(): Session = sessionmaker(bind=engine) session = Session() with open('department.csv') as source: reader = csv.DictReader(source) for d in reader: department = \ Department(idDepartment=int(d['idDepartment']), DepartmentCity=d['DepartmentCity'], CountOfWorkers=int(d['CountOfWorkers'])) session.add(department) with open('client.csv') as source: reader = csv.DictReader(source) for c in reader: client = \ Client(idClient=int(c['idClient']), FirstName=c['FirstName'], LastName=c['LastName'], Education=c['Education'], Passport=c['Passport'], City=c['City'], Age=int(c['Age']), department_id=int(c['Department_idDepartment'])) session.add(client) with open('application.csv') as source: reader = csv.DictReader(source) for a in reader: application = \ Application(idApplication=int(a['idApplication']), Sum=int(a['Sum']), CreditState=a['CreditState'], Currency=a['Currency'], client_id=int(a['Client_idClient'])) session.add(application) session.commit()
def register(self): if request.method == u'POST': client_key = self.generate_client_key() secret = self.generate_client_secret() # TODO: input sanitisation? name = request.form.get(u"name") description = request.form.get(u"description") callback = request.form.get(u"callback") pubkey = request.form.get(u"pubkey") # TODO: redirect? # TODO: pubkey upload # TODO: csrf info = { u"client_key": client_key, u"name": name, u"description": description, u"secret": secret, u"pubkey": pubkey } client = Client(**info) client['callbacks'].append(callback) client['user_id'] = g.user.get_id() client_id = client.insert() if not 'client_ids' in g.user: g.user.client_ids = [] g.user.client_ids.append(client_id) g.user.save() return render_template(u"client.html", **info) else: clients = Client.get_collection().find( {'_id': { '$in': [ObjectId(oid) for oid in g.user.client_ids] }}) return render_template(u"register.html", clients=clients)
def create_client(jwt): data = request.get_json() name = data.get('name') country = data.get('country') email = data.get('email') if not name or not country or not email: abort(412) return jsonify({ 'success': False, 'message': 'required fields expected' }), 412 else: try: client = Client(name=name, country=country, email=email) client.insert() return jsonify({ 'success': True, 'email': email, 'message': 'client created' }) except AssertionError as e: abort(422)
def departments_detail(department_id=None): if request.method == 'POST': first_name = request.form['first_name'] last_name = request.form['last_name'] education = request.form['education'] passport = request.form['passport'] city = request.form['city'] age = request.form['age'] new_client = Client(department_id=department_id, first_name=first_name, last_name=last_name, education=education, passport=passport, city=city, age=age) app.session.add(new_client) app.session.commit() clients = app.session.query(Department).filter( Department.id == department_id).first().clients return render_template('departments_details.html', clients=clients)
def setUp(self): self.user = User(username='******', password='******') self.client = Client(user=self.user, redirect_uris=[REDIRECT_URI], realms=['read'], client_key=CONSUMER_KEY, client_secret=CONSUMER_SECRET) self.request_token = RequestToken(client=self.client, token=REQUEST_TOKEN, secret=REQUEST_TOKEN_SECRET, redirect_uri=REDIRECT_URI, realms=['read'], user=self.user) self.access_token = AccessToken(client=self.client, user=self.user, realms=[REDIRECT_URI], token=ACCESS_TOKEN, secret=ACCESS_TOKEN_SECRET) self.nonce = Nonce(client_key=self.client.client_key, timestamp=TIMESTAMP, nonce=NONCE, request_token=REQUEST_TOKEN, access_token=ACCESS_TOKEN)
async def chat(websocket: websockets.WebSocketServerProtocol, _): logger.info(f'New connection: [{websocket.remote_address}]') new_client = Client(nick='anon', websocket=websocket) while True: try: client_raw_msg = await websocket.recv() command, error_msg = parse_client_input(client_raw_msg, new_client) if command is None: await websocket.send(error_msg) continue await COMMAND_PROCESSORS[command.command](command) new_client = command.sender except websockets.ConnectionClosed: await websocket.close() logger.info( f'Close connection with : {new_client.websocket.remote_address}' ) break
def signupClient(): if request.method == "POST": new_client = json.loads(request.data) password = request.json.get('password', None) email = request.json.get('email', None) hashed = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt()) client = Client( name=new_client["name"], email=new_client["email"], password=hashed, role=new_client["role"] ) db.session.add(client) db.session.commit() return jsonify(client.serialize()), 200 if request.method == "GET": client_signup = Client.query.all() all_client_signup = list(map(lambda client: client.serialize(), client_signup)) return jsonify(all_client_signup), 200
def generate_fake_data(): fake = Faker('es_ES') fake.add_provider(PhoneNumberProvider) for _ in range(100): pass new_fake_client = Client() new_fake_client.name = fake.name() new_fake_client.address = fake.address() new_fake_client.id_city = random.randint(1, 3) new_fake_client.telephone_number = fake.phone_number() new_fake_client.active = 1 db.session.add(new_fake_client) for _ in range(100): new_fake_order = Order() new_fake_order.id_client = random.randint(1, 99) new_fake_order.date = fake.date_between_dates( date_start=datetime(2021, 1, 1), date_end=datetime(2021, 2, 26)).isoformat() new_fake_order.address = fake.address() new_fake_order.current_status = Order.DELIVERED_STATUS new_fake_order.is_delivery = random.randint(0, 1) == 1 new_fake_order.telephone_number = fake.phone_number() text = fake.text() new_fake_order.observations = (text[:255]) if len(text) > 255 else text new_order_line = OrderLine() new_order_line.id_product = 2 new_order_line.quantity = 1 new_order_line.unitary_price = 210 new_order_line.total_price = 210 new_fake_order.order_lines.append(new_order_line) db.session.add(new_fake_order) db.session.commit()
def test_get_sessions_success(self): trainer = Trainer(name='Mostafa', gender='male', age=28) trainer.insert() client = Client(name='Yehia', gender='male', age=102) client.insert() session = Session(name='Mostafa-Yehia training session', trainer_id=trainer.id, client_id=client.id) session.insert() res = self.client().get( '/sessions', headers={'Authorization': 'Bearer {}'.format(manager_jwt_token)}) data = json.loads(res.data) self.assertEqual(res.status_code, 200) self.assertEqual(data['success'], True) self.assertTrue(data['sessions']) trainer.delete() client.delete() session.delete()
def handle_clients(client_id=0): headers = {"Content-Type": "application/json"} if request.method == "POST": print("creating client") client = request.json print(request.json) new_client = Client(client["name"], client["lastName"], client["company"], client["position"], client["email"], client["phone"], client["extraPhone"], client["sector"], client["city"], client["country"], client["linkedin"], client["source"], client["observations"]) db.session.add(new_client) db.session.commit() response_body = {"status": "HTTP_200_OK. Ok"} status_code = 200 elif request.method == "GET": user_client_list = Client.query.all() response_body = [] for client in user_client_list: response_body.append(client.serialize()) status_code = 200 elif request.method == "DELETE": Client.query.filter_by(id=client_id).delete() db.session.commit() response_body = { "result": "ok", "status": "HTTP_204_NO_CONTENT. User and tasks deleted." } status_code = 204 return make_response(json.dumps(response_body), status_code, headers)
def handle_client(): """ Create client and retrieve all clients """ # ******************* POST REQUEST ******************* if request.method == 'POST': body = request.get_json() if body is None: raise APIException( "You need to specify the request body as a json object", status_code=400) if 'name' not in body: raise APIException('You need to specify the name', status_code=400) if 'email' not in body: raise APIException('You need to specify the email', status_code=400) if 'password' not in body: raise APIException('You need to specify the password', status_code=400) client1 = Client(name=body['name'], email=body['email'], password=body['password']) db.session.add(client1) db.session.commit() return jsonify(client1.serialize()), 200 # ******************* GET REQUEST ******************* if request.method == 'GET': all_clients = Client.query.all() all_clients = list(map(lambda x: x.serialize(), all_clients)) return jsonify(all_clients), 200 return "Invalid Method", 404
def clients(id=None): if request.method == 'GET': if id is not None: client = Client.query.get(id) if client: return jsonify(client.serialize()), 200 else: return jsonify({"client": "Not Found"}) else: clients = Client.query.all() clients = list(map(lambda client: client.serialize(), clients)) return jsonify(clients), 200 if request.method == 'POST': name = request.json.get('name') email = request.json.get('email') phone = request.json.get('phone') if not name: return jsonify({"msg": "name is required"}), 422 if not email: return jsonify({"msg": "email is required"}), 422 if not phone: return jsonify({"msg": "phone is required"}), 422 client = Client() client.name = name client.email = email client.phone = phone db.session.add(client) db.session.commit() return jsonify(client.serialize()), 201 if request.method == 'DELETE': client = Client.query.get(id) db.session.delete(client) db.session.commit() return jsonify({'client': 'Deleted'}), 200
def add_edit_client(request, client_id=None): """ Method is used to create or edit some existing client. When new client is created notification email is sended on current logged user email. :param client_id: ID of the client, which is edited :type client_id: Integer """ template_name = 'settings/clients/add_edit_client.html' from_email = settings.EMAIL_HOST to_email = request.user.email text = { 'created_email_body': _("New client has been successfully created on {0}. To authorize it \ use this generated key {1} ."), 'created_email_subject': _("New client has been successfully created"), 'created': _("Client '{0}' with id={1} has been created"), 'created_log': _("Email after creation sended for client '{0}' with id={1}"), 'created_success': _('Additional info were sended on email'), 'edited': "Client '{0}' with id={1} has been edited" } if client_id: client = get_object_or_404(Client, pk=client_id) else: client = Client() client.key = get_random_string(length=32) if request.POST: client_form = ClientForm(request.POST, instance=client) if client_form.is_valid(): client_form.save() if not client_id: log.info(text['created'].format(client.name, client.id)) if from_email and to_email: send_mail( text['created_email_subject'], text['created_email_body'].format( settings.DOMAIN_NAME, client.key), from_email, [to_email]) log.info(text['created_log'].format( client.name, client.id)) else: log.info(text['edited'].format(client.name, client.id)) messages.add_message(request, messages.SUCCESS, text['created_success']) return HttpResponseRedirect(reverse('settings:clients_list'), {'messages': messages}) else: client_form = ClientForm(instance=client) return TemplateResponse( request, template_name, { 'client_form': client_form, 'client_id': client_id if client_id else None, 'client': client if client_id else None, 'moduls': client.moduls() if client_id else None })
def create(ctx, name, company, email, position): """Creates a new client""" client_service = ClientService(ctx.obj['clients_table']) client = Client(name, company, email, position) client_service.create_client(client)
def client_list(): page = 'Client List' if request.method == "POST": try: excel_file = request.get_array(field_name='client_list_file') # Check for valid SF client list excel file # NOTE: This feature is dependent on Service Fusion customer report # If they change their excel format, the source code has to be # modified to accomodate. if (excel_file[5][5] == 'Primary Contact First Name' and excel_file[5][6] == 'Primary Contact Last Name' and excel_file[5][7] == 'Primary Contact Phone 1' and excel_file[5][14] == 'Primary Service Location Address 1' and excel_file[5][15] == 'Primary Service Location Address 2' and excel_file[5][16] == 'Primary Service Location City' and excel_file[5][27] == 'Date Created'): for each_line in excel_file[6:]: email = str(each_line[8]).strip() first_name = str(each_line[5]).strip() last_name = str(each_line[6]).strip() phone = filter(str.isdigit, str(each_line[7]).strip()) address1 = str(each_line[15]).strip() address2 = str(each_line[14]).strip() city = str(each_line[16]).strip() state = str(each_line[17]).strip() zip_code = str(each_line[18]).strip() added_date = str(each_line[27]).strip() is_subscribed = "T" client_id = (first_name + last_name + zip_code).lower() if Client.query.filter( Client.first_name == first_name, Client.last_name == last_name).count() == 1: client = Client.query.filter_by(id=client_id).first() client.email = email client.first_name = first_name client.last_name = last_name client.added_date = added_date client.phone = phone client.address1 = address1 client.address2 = address2 client.city = city client.state = state client.zip_code = zip_code elif Client.query.filter_by(id=client_id).count() == 0: client = Client(id=client_id, email=email, first_name=first_name, last_name=last_name, added_date=added_date, phone=phone, address1=address1, address2=address2, city=city, state=state, zip_code=zip_code, is_subscribed=is_subscribed) db.session.add(client) db.session.commit() flash("Synced successfully", "alert-success") else: flash("Invalid file, try again", 'alert-danger') return render_template('employee_site/client/client_list.html', page=page) except Exception as e: flash(e, 'alert-danger') return render_template('employee_site/client/client_list.html', page=page) else: return render_template('employee_site/client/client_list.html', page=page)
def generate_client(): client = Client() client.client_id = gen_salt(40) client.client_type = "public" mongo.db.clients.insert(_to_json(client)) return client
def add_client(request_data): name = request_data.get('name') identifier = request_data.get('identifier') new = Client(url='www.notfound.com', name=name, identifier=identifier) new.save() return new
def populate_datastore(): client_key_name1 = 'client01' client1 = Client(key_name=client_key_name1, id='12345678', name='Organic Oranges LLC', domain=db.Link("http://client1.clickin-tech.appspot.com")) client1.put() client_key_name2 = 'client02' client2 = Client(key_name=client_key_name2, id='87654321', name='Green Trees Inc.', domain=db.Link("http://client2.clickin-tech.appspot.com")) client2.put() admin_key_name1 = 'admin001' admin1 = Client_User(key_name=admin_key_name1, client=client1, id='001002', name='Daniel Alves', email='*****@*****.**') admin1.put() admin_key_name2 = 'admin002' admin2 = Client_User(key_name=admin_key_name2, client=client1, id='001005', name='Andres Iniesta', email='*****@*****.**') admin2.put() admin_key_name5 = 'admin05' admin5 = Client_User(key_name=admin_key_name5, client=client2, id='0010011', name='Josep Guardiola', email='*****@*****.**') admin5.put() admin_key_name6 = 'admin06' admin6 = Client_User(key_name=admin_key_name6, client=client2, id='0010016', name='Lionel Messi', email='*****@*****.**') admin6.put() #ClickIn People Search app_key_name1 = 'app1' app1 = App(key_name=app_key_name1, client=client1, app_id='163185560402939', api_key='807c2277abe596cfe542927858105306', app_secret='aae6abb4d6bf0b41f066c387ab36e486', name='ClickIn People Search', domain=db.Link("http://app1.client1.clickin-tech.appspot.com/")) app1.put() #Click In People Search 2 app_key_name2 = 'app2' app2 = App(key_name=app_key_name2, client=client1, app_id='114549068628127', api_key='7f15ffb2b72ff6c4a6d08daebca21a52', app_secret='61545bcd8a3d9fc6a8107eaed5cbe4de', name='ClickIn People Search 2', domain=db.Link("http://app2.client1.clickin-tech.appspot.com/")) app2.put() #Cool Running App app_key_name3 = 'app3' app3 = App(key_name=app_key_name3, client=client2, app_id='107411582680918', api_key='7a55f39fb4e0371aad78e1bd8dd517af', app_secret='c12b89b5f815cebe27636cd8c50a6264', name='Cool Running App', domain=db.Link("http://app1.client2.clickin-tech.appspot.com/")) app3.put()
def test_client(self): client = Client(name='Client A') db.session.add(client) db.session.commit() assert client.name == 'Client A'
def handle(self): self.data = self.request.recv(1024).strip() route = decrypt(self.data) route = Route.fromrequest(route) # print(route.get_sel()) if (route.get_sel() == "init"): print("A file system node is initialising the connection") # A file system node is initialising the connection fs = FileSystem(len(filesystems) + 1, port=route.body['port'], files=route.body['files']) # Save the generated id and key pair (for faster lookups) filesystems[fs.get_id()] = fs response = fs.serialize() print("Registering file system node with id:", fs.get_id()) response = encrypt(response) self.request.sendall(response) elif (route.get_sel() == "update"): print("A file system node is updating its files") id = route.body['id'] update_fs = filesystems[id] update_fs.set_files(route.body['files']) response = encrypt(json.dumps({'result': 'successful'})) self.request.sendall(response) elif (route.get_sel() == "login"): print("A client node is trying to login") if (route.body['username'] == "admin" and route.body['password'] == "password"): # Successful login cl = Client(len(clients) + 1) clients[cl.get_id()] = cl response = cl.serialize() print("Successful login and key generated for client:", cl.get_id()) response = encrypt(response) self.request.sendall(response) else: # Login failed self.request.sendall(bytes('\0', 'utf-8')) elif (route.get_sel() == "ls"): print("A client node is requesting all files") response = generate_listing() response = encrypt(json.dumps(response)) self.request.sendall(response) elif route.get_sel() == "comm": # Initial communication for Needham Schroeder fs_id = route.body['id'] fs_key = filesystems[fs_id].get_key() print("A client node is initialising communication with a FS node", fs_id) # Generate session key session_key = os.urandom(16).hex() encrypted_session_key = encrypt(session_key, fs_key) response = encrypt( json.dumps({ 'key': session_key, 'encrypted': encrypted_session_key.hex() })) self.request.sendall(response)
from requestr import db from models import Client if __name__ == "__main__": db.create_all() client_A = Client("A") client_B = Client("B") client_C = Client("C") db.session.add(client_A) db.session.add(client_B) db.session.add(client_C) db.session.commit()
DBSession.flush() for user in old_DBSession.query(old_User).all(): new_user = User(id=user.id, login=user.login, name=user.name, intl_name=user.intl_name, birthday=user.birthday, created_at=user.signup_date, is_active=user.is_active) if user.default_locale_id: new_user.default_locale_id = user.default_locale_id DBSession.add(new_user) DBSession.flush() for client in old_DBSession.query(old_Client).all(): new_client = Client(id=client.id, user_id=client.user_id, created_at=client.creation_time, is_browser_client=client.is_browser_client) DBSession.add(new_client) DBSession.flush() for email in old_DBSession.query(old_Email).all(): new_email = Email(id=email.id, user_id=email.user_id, email=email.email) DBSession.add(new_email) DBSession.flush() for passhash in old_DBSession.query(old_Passhash).all(): new_passhash = Passhash(id=passhash.id, user_id=passhash.user_id, hash=passhash.hash) DBSession.add(new_passhash) DBSession.flush() for userblob in old_DBSession.query(old_UserBlobs).all(): new_userblob = UserBlobs(client_id=userblob.client_id,