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,
