def add_employee():
"""doc"""
departments = db.session.query(models.Department).order_by(
models.Department.id)
positions = db.session.query(models.Position).order_by(models.Position.id)
form = forms.AddUser(request.form)
form.department_id.choices = [(dpt.id, dpt.department_name)
for dpt in departments]
form.position_id.choices = [(psn.id, psn.position_name)
for psn in positions]
if request.method == "POST":
if form.validate():
user = models.User(name_first=form.name_first.data,
name_second=form.name_second.data,
department_id=form.department_id.data,
position_id=form.position_id.data,
email=form.email.data,
tel=form.tel.data,
birth_date=form.birth_date.data)
try:
db.session.add(user)
db.session.commit()
return render_template('creation_success.html')
except Exc.IntegrityError as err:
return render_template('creation_failure.html', error=err)
return render_template('add_employee.html', form=form)
def setUp(self):
self.app = create_app('TESTING')
self.ctx = self.app.app_context()
self.ctx.push()
self.client = self.app.test_client()
Models.Role.objects.create(id=1,
name="Test",
permission=Models.Permission.ADMIN)
print Models.Role.objects.all()[0].permission
r = Models.Role.objects.all()[0]
user = Models.User(name="zhangsan",
password="******",
email="*****@*****.**",
role=[r])
user.save()
print "user model error: {}".format(user.errors)
user = {
'username': '******',
'password': '******',
}
resp = self.client.post('/authentication/token',
data=json.dumps(user),
headers={'Content-Type': 'application/json'})
login_resp = json.loads(resp.data)
self.token = login_resp.get('access_token')
print "login with token: {}".format(self.token)
def db_seed():
mercury = models.Planet(planet_name='Mercury',
planet_type='Class D',
home_star='Sol',
mass=2.258e23,
radius=1516,
distance=35.98e6)
venus = models.Planet(planet_name='Venus',
planet_type='Class K',
home_star='Sol',
mass=4.867e24,
radius=3760,
distance=67.24e6)
earth = models.Planet(planet_name='Earth',
planet_type='Class M',
home_star='Sol',
mass=5.972e24,
radius=3959,
distance=92.96e6)
db.session.add(mercury)
db.session.add(venus)
db.session.add(earth)
test_user = models.User(first_name='William',
last_name='Herschel',
email='*****@*****.**',
password='******')
db.session.add(test_user)
db.session.commit()
print('Database Seeded!')
def register():
if request.method == 'GET':
return render_template('register.html')
user = models.User(request.form['name'] , request.form['password'],request.form['email'])
db.session.add(user)
db.session.commit()
flash('User successfully registered')
return redirect(url_for('login'))
def test_save(self):
r = Models.Role.objects.all()[0]
u = Models.User(
name="zhangsan", password="******",
email="*****@*****.**", role=[r])
self.assertTrue(u.is_valid(), msg=u.errors)
status = u.save()
self.assertTrue(status)
def register():
# 处理表单数据(面向对象方式)-flask_wtf: 处理表单
form = RegisterForm()
if form.validate_on_submit():
user = Models.User(username=form.username.data,
email=form.email.data).save()
user.password = form.password.data
return redirect(url_for('auth.login'))
return render_template('register.html', form=form)
def register():
form = RegisterForm()
if form.validate_on_submit():
Models.User(username=form.username.data,
email=form.email.data,
password=generate_password_hash(
form.password.data)).save()
return redirect(url_for('auth.login'))
return render_template('register.html', form=form)
def setUp(self):
self.app = create_app('TESTING')
Models.Role.objects.create(id=1,
name="Test",
permission=Models.Permission.DELETE)
r = Models.Role.objects.all()[0]
Models.User(id=10000,
username="******",
password="******",
email="*****@*****.**",
role=r).save()
def create_admin():
users = Models.User.objects.filter(name='guest').first()
if not users:
role = Models.Role.objects.filter(name='DELETER').first()
Models.User(name="guest",
password="******",
email="*****@*****.**",
role=[role]).save()
print "create admin finish..."
else:
print "user admin exists..."
def register():
if current_user.is_authenticated:
return redirect(url_for('index'))
form = forms.RegistrationForm()
if form.validate_on_submit():
user = models.User(username=form.username.data, email=form.email.data)
user.set_password(form.password.data)
db.session.add(user)
db.session.commit()
flash('Congratulations! you are now registered!')
return redirect(url_for('login'))
return render_template('register.html', form=form)
def setUp(self):
self.app = create_app('TESTING')
self.ctx = self.app.app_context()
self.ctx.push()
self.client = self.app.test_client()
r = Models.Role.objects.create(name="Test",
permission=Models.Permission.DELETE)
print "create role with error: {}".format(r.errors)
user = Models.User(name="zhangsan",
password="******",
email="*****@*****.**",
role=[r])
print "setup with user error: {}".format(user.errors)
user.save()
def create_example_data():
with open('users.json', 'r') as f:
for data in json.loads(f.read()):
user = models.User(**data)
db.session.add(user)
try:
db.session.commit()
except:
db.session.rollback()
with open('transaction.json', 'r') as f:
for data in json.loads(f.read()):
data['date'] = datetime.fromtimestamp(data['date'])
tr = models.Transaction(**data)
db.session.add(tr)
db.session.commit()
def createUser(userId, email, source):
if source == 'google':
user = m.User(gId=userId, email=email)
userKey = user.put()
u = userKey.get()
setStream(u, 'fiction', 'sci-fi', 'english')
buildRecommendations(BASE_NUM_RECS, 0, False)
#Setup the first story in the user's stream
logging.info('setting first story in Stream for user')
stories = getStories(None, False, 0, 1, False)
s = stories[0]
updateStream([{
'userKey': u.key,
'storyKey': s['key'],
'title': s['title']
}])
return u
def register():
email = request.form['email']
test = models.User.query.filter_by(email=email).first()
if test:
return jsonify(message='email already used'), 409
first_name = request.form['first_name']
last_name = request.form['last_name']
password = request.form['password']
user = models.User(first_name=first_name,
last_name=last_name,
email=email,
password=password)
db.session.add(user)
db.session.commit()
return jsonify(message='user created!'), 201
def init_db():
"""
Initializes data in the database if necessary.
"""
# will create database and tables if not exist
db.create_all()
# will append a default user if none exist
if models.User.query.count() == 0:
default_user = models.User()
default_user.username = '******'
default_user.password = generate_password_hash('password')
default_user.first_name = 'John'
default_user.last_name = 'Smith'
db.session.add(default_user)
db.session.commit()
def register_user():
data = json.loads(request.data)
username = data.get('username')
password = data.get('password')
email = data.get('email')
user = user_schema({
'username': username,
'password': password,
'email': email
})
email_user = Models.User.objects.filter(email=user.get('email')).first()
name_user = Models.User.objects.filter(
username=user.get('username')).first()
if email_user or name_user:
resp = {'data': {}, 'msg': 'user exists', 'code': 1001, 'extra': {}}
else:
id = generator_user_id()
user = Models.User(email=user.get('email'),
id=id,
username=user.get('username'),
password=user.get('password'),
role=1)
status = user.is_valid()
if status:
user.save()
resp = {
'data': user.to_json(),
'msg': 'register success',
'code': 1000,
'extra': {}
}
else:
resp = {'data': {}, 'msg': user.errors, 'code': 1001, 'extra': {}}
return jsonify(**resp)
def add_user():
try:
user = Models.User(username=request.json.get('username'),
email=request.json.get('email'),
password=generate_password_hash(
request.json.get('password'))).save()
except:
abort(400)
return jsonify(user.to_dict()), 201 # 新建成功
@api_bp.route('/user/<string:username>/todolists')
def get_user_todolists(username):
user = Models.User.objects(username=username).first()
todolists = user.todolists
return jsonify(
{'todolists': [todolist.to_dict() for todolist in user.todolists]})
@api_bp.route('/user/<string:username>/todolist/<todolist_id>')
def get_user_todolist(username, todolist_id):
user = Models.User.objects(username=username).first()
todolist = Models.TodoList.objects(id=todolist_id).first()
if not user or username != todolist.creator.username:
abort(404)
return jsonify(todolist.to_dict())
def setUp(self):
self.user_1 = models.User(**{'_id': '6062dabdbbb2c3f109a049e9', 'username': '******', 'password': '******'})
from application import db, models
models.User(user_id=1,
first_name='Ashish',
last_name='Sheelavantar',
email='*****@*****.**',
password='******').save()
models.User(user_id=2,
first_name='Adam',
last_name='Zealander',
email='*****@*****.**',
password='******').save()
models.User(user_id=3,
first_name='Mellisa',
last_name='Atkins',
email='*****@*****.**',
password='******').save()
print("Loaded data into User collection")
models.Course(course_id=101,
title="Python",
description="Basics of Python language",
credits="3",
term="Semister 1").save()
models.Course(course_id=102,
title="Core Java",
description="Intro to Java Programming",
credits="5",
term="Semister 2").save()
models.Course(course_id=103,
title="Docker",
def test_defaults(self):
user = models.User()
self.assertIsNone(user.username)
self.assertIsNone(user.password_hash)
def post(self, store_id):
store = current_user.stores.filter_by(id=store_id).first()
if not store:
return tool.fail(404, u"店铺不存在")
self.parser.add_argument('company_id',
type=int,
required=True,
help="公司必填")
self.parser.add_argument('number',
type=unicode,
required=True,
help="快递单号必填")
self.parser.add_argument('no', type=int, default=None)
self.parser.add_argument('remark', type=unicode)
self.parser.add_argument('plan_at', type=lib.arrow_datetime)
self.parser.add_argument('status', type=int, default=0)
self.parser.add_argument('user', type=dict, required=True, help="用户必填")
args = self.parser.parse_args()
company = store.companies.filter_by(id=args.company_id).first()
if not company:
return tool.fail(400, u"公司不存在")
order = company.orders.filter_by(number=args.number).first()
if order:
return tool.fail(406, u"快递单号已存在")
if args.no:
if args.no < 1:
return tool.fail(407, u"编号不能小于 1")
if "id" in args.user:
user = store.users.filter_by(id=args.user['id']).first()
if "user_name_id" in args.user:
user_name = user.names.filter_by(
id=args.user['user_name_id']).first()
if not user_name:
return tool.fail(400, u"用户名字不存在")
else:
user_name = user.names.first()
# # 用户编号都存在时,看是否为他自己的
# order = models.Order.query.join(models.Company).join(models.Store).filter(
# models.Store.id == store.id,
# models.Order.no == args.no,
# models.Order.user != user,
# ).first()
# if order:
# return tool.fail(406, u"编号已存在")
if not user:
return tool.fail(400, u"用户不存在")
else:
# order = models.Order.query.join(models.Company).join(models.Store).filter(
# models.Store.id == store.id,
# models.Order.no == args.no,
# ).first()
# if order:
# return tool.fail(406, u"编号已存在")
if "mobile" not in args.user:
return tool.fail(400, u"联系方式必填")
if "name" not in args.user:
return tool.fail(400, u"姓名必填")
if store.get_user_by_mobile(args.user["mobile"]):
return tool.fail(406,
u"手机号码 {} 已存在".format(args.user["mobile"]))
user = models.User()
user.mobile = args.user["mobile"]
user_name = models.UserName(name=args.user["name"])
user.store = store
models.db.session.add(user)
user_name.user = user
if "address" in args.user:
user_name.address = args.user["address"]
if "remark" in args.user:
user_name.remark = args.user["remark"]
models.db.session.add(user_name)
order = models.Order()
if args.no:
order.no = args.no
else:
# 计算出 no
# 1 此用户已有未领取的快递时,编同一个号
no = models.Order.get_no(store.id)
order.no = no
order.user_name = user_name
order.company = company
order.number = args.number
order.status = args.status
if args.plan_at:
order.plan_at = args.plan_at.naive
models.db.session.add(order)
models.db.session.commit()
result = schemas.OrderSchema().dump(order)
return tool.success(result.data)
def Importation(secret=0):
""" Importation des données depuis le serveur """
# Vérifie que le fichier d'import existe bien (vérification du code secret)
nomFichier = os.path.join(basedir, "data/import_%d.crypt" % secret)
if not os.path.isfile(nomFichier):
return "fichier crypt inexistant"
# Décryptage du fichier
if IMPORT_AES == False :
return "AES non disponible"
cryptage_mdp = app.config['SECRET_KEY'][:10]
nomFichierZIP = nomFichier.replace(".crypt", ".zip")
resultat = DecrypterFichier(nomFichier, nomFichierZIP, cryptage_mdp)
os.remove(nomFichier)
# Décompression du fichier
import zipfile
if zipfile.is_zipfile(nomFichierZIP) == False :
return "Le fichier n'est pas une archive valide"
nomFichierDB = nomFichierZIP.replace(".zip", ".db")
fichierZip = zipfile.ZipFile(nomFichierZIP, "r")
buffer = fichierZip.read(os.path.basename(nomFichierDB))
f = open(nomFichierDB, "wb")
f.write(buffer)
f.close()
fichierZip.close()
os.remove(nomFichierZIP)
# Importation des données
from_db = "sqlite:///" + os.path.join(basedir, "data/" + os.path.basename(nomFichierDB))
to_db = app.config['SQLALCHEMY_DATABASE_URI']
# Ouvertures des bases
source, sengine = make_session(from_db)
smeta = MetaData(bind=sengine)
destination = db.session
dengine = db.engine
dmeta = MetaData(bind=dengine)
# Traitement de la table des paramètres
#app.logger.debug("Traitement de la table parametres...")
liste_parametres_destination = destination.query(models.Parametre).all()
dict_parametres_destination = {}
for parametre in liste_parametres_destination :
dict_parametres_destination[parametre.nom] = parametre
liste_tables_modifiees = []
liste_parametres_source = source.query(models.Parametre).all()
for parametre in liste_parametres_source :
# Mémorisation du paramètre
if parametre.nom in dict_parametres_destination :
# Modification si besoin d'un paramètre existant
if dict_parametres_destination[parametre.nom].parametre != parametre.parametre :
dict_parametres_destination[parametre.nom].parametre = parametre.parametre
else :
# Saisie d'un nouveau paramètre
destination.add(models.Parametre(nom=parametre.nom, parametre=parametre.parametre))
# Recherche la liste des tables à importer
if parametre.nom == "tables_modifiees_synchro" :
tables_modifiees_synchro = parametre.parametre.split(";")
destination.commit()
# Traitement de la table users
app.logger.debug("Traitement de la table users...")
liste_users_destination = destination.query(models.User).all()
dict_users_destination = {"familles" : {}, "utilisateurs" : {}}
for user in liste_users_destination :
if user.IDfamille != None :
dict_users_destination["familles"][user.IDfamille] = user
if user.IDutilisateur != None :
dict_users_destination["utilisateurs"][user.IDutilisateur] = user
liste_users_source = source.query(models.User).all()
liste_destination = []
for user_source in liste_users_source :
user_destination = None
# Recherche si l'user existe déjà dans la base destination
if user_source.IDfamille != None :
if user_source.IDfamille in dict_users_destination["familles"] :
user_destination = dict_users_destination["familles"][user_source.IDfamille]
if user_source.IDutilisateur != None :
if user_source.IDutilisateur in dict_users_destination["utilisateurs"] :
user_destination = dict_users_destination["utilisateurs"][user_source.IDutilisateur]
# Si l'user existe déjà, on le modifie si besoin
if user_destination != None :
if user_destination.identifiant != user_source.identifiant : user_destination.identifiant = user_source.identifiant
if user_destination.password != user_source.password : user_destination.password = user_source.password
if user_destination.nom != user_source.nom : user_destination.nom = user_source.nom
if user_destination.email != user_source.email : user_destination.email = user_source.email
if user_destination.actif != user_source.actif : user_destination.actif = user_source.actif
if user_destination.session_token != user_source.session_token : user_destination.session_token = user_source.session_token
# Si l'utilisateur n'existe pas, on le créé :
if user_destination == None :
destination.add(models.User(identifiant=user_source.identifiant, cryptpassword=user_source.password, nom=user_source.nom, email=user_source.email, \
role=user_source.role, IDfamille=user_source.IDfamille, IDutilisateur=user_source.IDutilisateur, actif=user_source.actif, \
session_token=user_source.session_token))
app.logger.debug("Enregistrement de la table users...")
destination.commit()
app.logger.debug("Fin de traitement de la table users.")
# Liste des autres tables à transférer
app.logger.debug("Traitement des autres tables...")
tables = [
"cotisations_manquantes", "cotisations", "factures", "types_pieces", "pieces_manquantes",
"reglements", "consommations", "periodes", "prefacturation", "ouvertures", "feries", "unites", "inscriptions",
"groupes", "activites", "individus", "messages", "regies", "pages", "blocs", "elements",
]
# Recherche si des actions sont présentes
nbre_actions_destination = destination.query(func.count(models.Action.IDaction)).scalar()
if nbre_actions_destination == 0 :
# S'il n'y a aucune actions présentes, on importe toute la table Actions de la source
tables.append("actions")
else :
# Sinon, on importe uniquement l'état des actions
liste_actions_source = source.query(models.Action).all()
for action in liste_actions_source :
# Update
table_actions_destination = Table('%sportail_actions' % PREFIXE_TABLES, dmeta, autoload=True)
u = table_actions_destination.update()
u = u.values({"etat" : action.etat, "traitement_date" : action.traitement_date, "reponse" : action.reponse})
u = u.where(table_actions_destination.c.ref_unique == action.ref_unique)
dengine.execute(u)
destination.commit()
# Suppression des tables
for nom_table in tables:
if nom_table in tables_modifiees_synchro :
try :
dengine.execute("DROP TABLE %s" % "%sportail_%s" % (PREFIXE_TABLES, nom_table))
except :
pass
app.logger.debug("Suppression des tables ok.")
# Création des tables
db.create_all()
# Remplissage des tables (ordre spécial)
app.logger.debug("Remplissage des autres tables...")
tables = [
"activites", "unites", "cotisations_manquantes", "cotisations", "factures", "types_pieces", "pieces_manquantes",
"reglements", "individus", "groupes", "inscriptions", "consommations", "periodes", "ouvertures", "prefacturation",
"feries", "messages", "regies", "pages", "blocs", "elements",
]
if "mysql" in to_db :
dengine.execute("SET foreign_key_checks = 0;")
for nom_table in tables:
if nom_table in tables_modifiees_synchro:
dtable = Table("%sportail_%s" % (PREFIXE_TABLES, nom_table), dmeta, autoload=True)
stable = Table("portail_%s" % nom_table, smeta, autoload=True)
NewRecord = quick_mapper(stable)
columns = list(stable.columns.keys())
data = source.query(stable).all()
listeDonnees = []
for record in data :
data = dict([(str(column), getattr(record, column)) for column in columns])
listeDonnees.append(data)
if len(listeDonnees) > 0 :
dengine.execute(dtable.insert(), listeDonnees)
# Commit de l'importation des tables
destination.commit()
if "mysql" in to_db :
dengine.execute("SET foreign_key_checks = 1;")
# Fermeture et suppression de la base d'import
source.close()
os.remove(os.path.join(basedir, "data/" + os.path.basename(nomFichierDB)))
app.logger.debug("Fin de l'importation.")
return True
