def persons(person_id):
db = Person()
if person_id.isdigit() and db.check_person(person_id):
person, as_actor, as_director, jobs = db.person_info(person_id)
return render_template('person.html', person=person, as_actor=as_actor,
as_director=as_director, jobs=jobs)
else:
return render_template('404.html')
def create_many():
persons = []
for i in range(10):
u = Person(name='张三' + str(i), age=i + 1)
persons.append(u)
db.session.add_all(persons)
db.session.commit()
return '创建完毕'
def add_person():
if request.method == 'POST':
form = request.form
fname = form.get('fname')
lname = form.get('lname')
email = form.get('email')
username = form.get('username')
person_id = form.get('person_id')
role = form.get('role')
group = form.get('group')
shift = form.get('shift')
platform = form.get('platform')
is_active = True
if person_id:
person = Person.query.get(person_id)
if person:
db.session.delete(person)
db.session.commit()
if not fname or lname or email or username:
if person_id:
person = Person(person_id=person_id,
fname=fname,
lname=lname,
email=email,
username=username,
is_active=is_active,
group=group,
role=role,
shift=shift,
platform=platform)
else:
person = Person(fname=fname,
lname=lname,
email=email,
username=username,
is_active=is_active,
group=group,
role=role,
shift=shift,
platform=platform)
db.session.add(person)
db.session.commit()
return redirect('/person')
return "of the jedi"
def add_person():
person = Person()
flag = random.randrange(100)
person.p_name = "你好小明%d" % flag
person.p_age = flag
db.session.add(person)
db.session.commit()
return "add success"
def test_nombre_getter(self):
au = Person(nombre='Pedro', apellidos='Juan Gutiérrez')
fp = datetime.date(1867, 1, 1)
cw = CreativeWork(nombre='El nido de la serpiente',
autor=au,
fechapub=fp)
self.assertTrue(cw.nombre == 'El nido de la serpiente')
self.assertTrue(cw.autor.nombre == 'Pedro')
self.assertTrue(cw.autor.apellidos == 'Juan Gutiérrez')
def add_name():
name = json.loads(request.data).get('name') or None
try:
p = Person(name=name)
db.session.add(p)
db.session.commit()
except ValueError:
abort(400, json.dumps({"status": "success"}))
return json.dumps({"name": {'name': p.name, 'id': p.id}})
def add_person(request):
for i in range(20):
person = Person()
flag = random.randrange(100)
person.p_name = 'tom%d' % flag
person.p_age = flag
person.p_sex = flag % 2
person.save()
return HttpResponse('批量创建成功')
def save_profile(backend, user, response, *args, **kwargs):
if backend.name == 'facebook':
person = Person.objects.filter(user=user).first()
if not person:
person = Person(user=user)
person.email = user.email
person.user_name = user.username
person.name = response.get('name')
person.save()
elif backend.name == 'google-oauth2':
person = Person.objects.filter(user=user).first()
if not person:
person = Person(user=user)
person.email = user.email
person.user_name = user.username
person.name = response.get('name')
person.save()
def test_befriend(self):
person = Person(index=0,
name='Test',
age=30,
has_died=False,
eye_color='black',
phone='000',
address='test')
friend = Person(index=1,
name='Friend',
age=30,
has_died=False,
eye_color='blue',
phone='000',
address='test')
person.befriend(friend)
self.assertEqual(1, len(person.friends))
self.assertEqual(person.friends[0].to_dict(), friend.to_dict())
def form_valid(self, form):
user = User.objects.create_user(username=form.cleaned_data['username'],
password=form.cleaned_data['pwd'],
email=form.cleaned_data['mail'])
user.save()
person = Person(user=user)
person.save()
return HttpResponseRedirect(self.get_success_url())
def register():
if request.method == 'POST':
# name = form.name.data
username = None
password = None
username = request.form['username']
password = request.form['password']
if( username == None or password == None ):
flash('Please enter all details', 'danger')
return redirect(url_for('register'))
# username = form.username.data
category = request.form['category']
# print (str(request.form['password']))
# print (str(request.form['confirm_password']))
# check entered passwords
password = sha256_crypt.encrypt(request.form['password'])
# password_candidate = request.form['password']
confirm_password = request.form['confirm_password']
person=None
if category == "user":
# person = User.query.filter_by(username=username).first()
person_type = 1
elif category == "app_dev":
# person = Application.query.filter_by(username=username).first()
person_type = 2
elif category == "nw_admin":
# person = Application.query.filter_by(username=username).first()
person_type = 3
# if person is None:
# flash('Username doesn\'t exist!!', 'danger')
# return redirect(url_for('register'))
if not sha256_crypt.verify(confirm_password, password):
flash('Passwords do not match!!', 'danger')
return redirect(url_for('register'))
password = password
try:
person = Person(username=username , password=password , person_type = person_type)
db.session.add(person)
db.session.commit()
except:
flash('Username already exists!!', 'danger')
return redirect(url_for('register'))
flash('You are now registered and can log in', 'success')
return redirect(url_for('index'))
return render_template('register.html')
def set_up_test_db():
person1 = Person(index=0, name='Test', age=30, has_died=False, eye_color='black', phone='000', address='test')
person2 = Person(index=1, name='Test', age=30, has_died=False, eye_color='black', phone='000', address='test')
friend = Person(index=2, name='Friend', age=30, has_died=False, eye_color='brown', phone='000', address='test')
company = Company(index=0, name='Test')
no_employees_company = Company(index=1, name='No Employees')
vegetable = Food(index=0, name='Lettuce', type=Food.VEGETABLE)
fruit = Food(index=1, name='Banana', type=Food.FRUIT)
person1.company = company
person1.foods.append(vegetable)
person1.foods.append(fruit)
person2.company = company
person1.befriend(friend)
person2.befriend(friend)
db.session.add(person1)
db.session.add(no_employees_company)
def commitFacialData(mood, timestamp, user_id):
#connection, cursor = connect()
mood = mood
time = timestamp
user_id = 2
newFacialData = Person(timestamp=time, mood=mood, user_id=4)
db.session.add(newFacialData)
db.session.commit()
print(True)
return True
def fill_db(data):
for person in data['results']:
person_data = dict()
person_data['gender'] = person['gender']
person_data['name'] = person['name']
person_data['email'] = person['email']
person_data['picture'] = person['picture']['medium']
new_person = Person(person_data)
db.session.add(new_person)
db.session.commit()
def login():
form = LoginForm()
if form.validate_on_submit():
user = Person.query.filter(Person.phone == form.phone.data).first()
if not user:
user = Person(phone=form.phone.data, active=True)
db.session.add(user)
db.session.commit()
return redirect(url_for('confirm', phone=form.phone.data))
return flask.render_template('login.html', form=form)
def register():
"""Regiser route for website."""
form = regist_form()
if form.validate_on_submit():
user = Person(username=form.username.data, email=form.email.data)
user.set_password(form.pass2.data)
db.session.add(user)
db.session.commit()
flash('You are now a regestered user')
return redirect(url_for('login'))
return render_template('regester.html', form=form)
def add_person(request):
per = Person()
per.name = '郭靖%d' % random.randrange(100)
per.sex = '男'
per.age = '%d' % random.randrange(18, 40)
per.save()
card = Card()
card.num = '413016199701219876'
card.pid = per
card.save()
return HttpResponse('数据关联成功')
def add_persons(request):
for i in range(15):
person = Person()
flag = random.randrange(100)
person.p_name = "Tom%d" % i
person.p_age = flag
person.p_sex = flag % 2
person.save()
return HttpResponse("批量创建成功")
async def main() -> None:
client = await edgedb.create_async_client()
await queries.create_movies(client)
direcror_id = (
await queries.create_new_person(
client,
first_name="Denis",
last_name="Villeneuve",
)
).id
persons = [
Person("Harrison", "Ford"),
Person("Ryan", "Gosling"),
Person("Ana", "de Armas"),
]
person_ids = []
for person in persons:
created_person = await queries.create_new_person(
client,
first_name=person.first_name,
last_name=person.last_name,
)
person_ids.append(created_person.id)
created_movie = await queries.create_new_movie(
client,
year=2017,
title="Blade Runner 2049",
director_id=direcror_id,
person_ids=person_ids,
)
movie = await queries.select_movie_by_id(client, id=created_movie.id)
print("Movie: ", movie)
print("Director name: ", movie.director.first_name, movie.director.last_name)
await client.aclose()
def __store_to_db(self, content):
try:
Person.objects.get(
name=content['name'],
external_identifier=content['external_identifier'])
except Person.DoesNotExist:
person_to_add = Person(
external_identifier=content['external_identifier'],
internal_identifier=content['internal_identifier'],
name=content['name'],
role=content['role'])
person_to_add.save()
def targetlist(workspace_id, list_id):
'''
For GET requests, return the given list.
For PUT requests, udpate the given list.
For DELETE requests, delete the given list.
'''
if not validate_workspace(workspace_id):
return 'workspace does not exist', 404
targetlist = List.query.filter_by(id=list_id,
workspace_id=workspace_id).first()
if targetlist is None:
return 'list does not exist', 404
# request is a GET
if request.method == 'GET':
schema = ListSchema(strict=True)
list_data = schema.dump(targetlist)
return jsonify(list_data)
# request is a DELETE
elif request.method == 'DELETE':
db.session.delete(targetlist)
update_workspace_ts(
Workspace.query.filter_lby(id=workspace_id).first())
db.session.commit()
return '', 204
# request is a PUT (update attributes of the List)
elif request.method == 'PUT':
req_json = request.get_json()
name = req_json['name']
targets = req_json['targets']
same_list = List.query.filter_by(name=name).first()
if same_list is not None and str(same_list.id) != list_id:
return json.dumps({'success': False}), 200, {
'ContentType': 'application/json'
}
targetlist.targets = []
for target in targets:
person = Person(first_name=target['first_name'],
last_name=target['last_name'],
email=target['email'])
targetlist.targets.append(person)
targetlist.name = name
update_workspace_ts(Workspace.query.filter_by(id=workspace_id).first())
db.session.commit()
schema = ListSchema(strict=True)
list_data = schema.dump(targetlist)
return jsonify(list_data[0]), 201
def save_profile(backend, user, response, *args, **kwargs):
if backend.name == 'facebook':
profile = user
try:
person = Person.objects.get(user=profile)
except:
person = Person(user=profile)
person.email = user.email
person.name = response.get('name')
person.save()
elif backend.name == 'google-oauth2':
profile = user
try:
person = Person.objects.get(user=profile)
except:
person = Person(user=profile)
person.email = user.email
person.name = response.get(
'name')['givenName'] + " " + response.get('name')['familyName']
person.save()
def _save_to_db(name, email, skills):
if name is not None:
try:
Person(name=name, email=email).save()
except:
pass
for skill in skills:
try:
Skill(name=skill).save()
except Exception as e:
print(e)
pass
def register_face():
form = RegistrationForm()
if form.validate_on_submit():
if form.images.data:
print(
"##############################################################\n"
)
print(form.images.data)
images = []
# random_hex = secrets.token_hex(8)
name = form.name.data
person = Person(name=name)
db.session.add(person)
db.session.commit()
id = Person.query.filter_by(name=name).first().id
has_at_least_one_image_with_single_face = False
for image in form.images.data:
# TODO see if there is one only one face in the image (because suppose if there are
# 2 persons in the image and the 2nd one tries to recognize himself then if id folder
# of 1st one comes first than the 2nd one's id folder, 2nd one will be recognized as
# 1st person as the photo is in 1st person's id folder)
face_image = faces.hasSingleFace(image)
if face_image is not None:
has_at_least_one_image_with_single_face = True
image_fn, image_path = save_image_to_dataset(
dir_name=str(id),
form_image_name=image.filename,
to_be_saved_image=face_image)
dataset = Dataset(image_file=image_fn, author=person)
db.session.add(dataset)
print(image_path)
images.append(image_fn)
if has_at_least_one_image_with_single_face is True:
db.session.commit()
faces.make_new_face_encodings()
flash(
f'Congratulations! Successfully registered the face as {form.name.data}. Try recognizing {form.name.data}.',
'success')
return redirect(
url_for('recognize_faces', title='Recognize Faces'))
else:
flash(
f'{form.name.data} not registered as there was no face in the image. Try providing different images.',
'danger')
return render_template('register_face.html',
title="Register Face",
selectedListElement="registerFace",
form=form)
return render_template('register_face.html',
title="Register Face",
selectedListElement="registerFace",
form=form)
def get_or_create_person(_name, _relation):
"""
Procedure that check if person exists in db, and create one if not.
:param _name: Person name
:param _relation: Relation of this person
:return: Person obj.
"""
_person = Person.query.filter_by(name=_name).first()
if not _person:
_person = Person(name=_name, relation=_relation)
db.session.add(_person)
db.session.commit()
return _person
def mutate(self, info, person, givenname, surname, gender, **kwargs):
person = Person(person_id=person_id,
givenname=givenname,
surname=surname,
gender=gender,
**kwargs)
user.save()
return CreateUser(id=person.id,
person_id=person.person_id,
givenname=person.name,
surname=person.last_name,
gender=person.gender)
def test_dynamic_person_schema(self):
p0 = Person(first_name='Adela', last_name='Zhu')
u0 = User(username='******',
email='*****@*****.**',
first_name='zack',
last_name='zhu')
d0 = Dependent(first_name='Ada', last_name='adA')
assert PersonSchema.dynamic_schema(p0) == PersonSchema
assert PersonSchema.dynamic_schema(u0) == UserSchema
assert PersonSchema.dynamic_schema(d0) == DependentSchema
assert type(
PersonSchema.dynamic_schema(d0)(many=True)) == DependentSchema
def load_people_data():
with open(PEOPLE_DATA, 'r') as f:
people = json.load(f)
# Load people
friends = []
for person in people:
db.session.add(
Person(
id=person['index'],
guid=person['guid'],
has_died=person['has_died'],
balance=person['balance'],
picture=person['picture'],
age=person['age'],
eye_colour=person['eyeColor'],
name=person['name'],
gender=person['gender'],
company_id=(person['company_id'] - 1),
username=person['email'],
phone=person['phone'],
address=person['address'],
about=person['about'],
registered=datetime.strptime(person['registered'],
'%Y-%m-%dT%H:%M:%S %z').date(),
friends=[],
tags=person['tags'],
greeting=person['greeting'],
fruits=[
x for x in person['favouriteFood'] if x in FRUITS_LIST
],
vegetables=[
x for x in person['favouriteFood'] if x not in FRUITS_LIST
],
))
# Store friends in tuple for later loading
for friend in person['friends']:
friends.append((person['index'], friend['index']))
# Tried to count tuple occurrence ignoring order, we found out that friend relationship is not two way.
# Thus, no cleaning necessary
# from collections import Counter
# counter = Counter(tuple(sorted(f)) for f in friends)
# print(counter)
# Load people friends relationship (Bulk inserts so its faster)
data = [dict(zip(('person_id', 'friend_id'), x)) for x in friends]
db.session.execute(people_friends_table.insert(), data)
db.session.commit()
def create_person():
data = request.get_json() or {}
# fields = ['first_name','last_name', 'age', 'favourite_color', 'nationality']
for elem in Config.PERSON_DATA_FIELDS:
if elem not in data:
return bad_request('must include ' +
str(Config.PERSON_DATA_FIELDS))
person = Person()
person.from_dict(data)
db.session.add(person)
db.session.commit()
app.logger.info("created person: " + str(person))
response = jsonify(person.to_dict())
response.response_code = 201
return response
def test_valid_book_object2(self):
au = Person(nombre='Fiodor', apellidos='Dostoyevski')
fp = datetime.date(1867, 1, 1)
cw = CreativeWork(nombre='Crimen y Castigo', autor=au, fechapub=fp)
b = Book(nombre=cw.nombre,
autor=cw.autor.nombre + ' ' + cw.autor.apellidos,
fechapub=cw.fechapub)
b.add_isbn('0-7582-3013-3')
db.session.add(b)
db.session.commit()
self.assertTrue(b.fechapub == datetime.date(1867, 1, 1))
self.assertTrue(b.id is not None)
self.assertTrue(b.nombre == 'Crimen y Castigo')
self.assertTrue(b.autor == 'Fiodor Dostoyevski')
self.assertTrue(b.isbn == '0-7582-3013-3')
