def get(self):
# 編集確認
person_id = self.request.get("id")
person_obj = ''
if (person_id):
person_obj = Person.get( person_id )
# 所有しない発言者IDを指定された場合は一覧へリダイレクトする
if person_obj and person_obj.owner != users.get_current_user():
self.redirect(urls.APP_PERSON_URL)
return
# 所有する発言者を取得します
query = Person.all()
query.filter( 'owner = ', users.get_current_user() )
query.order('-created_on')
owned_persons = query.fetch(limit = 1000)
# 所有する発言者の名言を取得する
meigens = ''
if person_obj:
query = Meigen.all()
query.filter( 'owner = ', users.get_current_user() )
query.filter( 'person = ', person_obj )
meigens = query.fetch(limit = 1000)
# 画面を表示する
Viewer.generate(Viewer(), self.response, TEMPLATE_PATH, { 'persons': owned_persons, 'current_person': person_obj, 'meigens': meigens } )
def doperson(request,username,method):
person=Person.objects.get(username=username)
if request.user.is_superuser:
if request.method=="GET":
result=1
elif request.method=="POST":
result=2
if method=='delete':#删除确认
person.delete()
elif method=='update':#更新表单
#update
personinfo_name = ['name', 'sex', 'age', 'adno','home','profession', 'education', 'disease_history', 'disease_age_h',
'disease_current','disease_age_c', 'used_drugs', 'using_drugs']
try:
person = Person.objects.get(username=username)
except Person.DoesNotExist:
person = Person(username=username)
for key in personinfo_name:
setattr(person,key,request.POST.get(key,''))
person.save()
else:#显示查看界面
result=0
else:#无权操作
result=-1
return render_to_response('person.html', locals())
def setUp(self):
self.dad = Person(full_name='John Smith Senior', mother=None, father=None)
self.dad.save()
self.mom = Person(full_name='Jane Smith', mother=None, father=None)
self.mom.save()
self.kid = Person(full_name='John Smith Junior', mother=self.mom, father=self.dad)
self.kid.save()
def post(self):
email = self.request.get("email")
name = self.request.get("name")
person = Person.get_by_key_name(name)
if not person:
person = Person(key_name=email, email=email, name=name)
person.put()
def get(self):
person = Person(first_name='Pedro',
last_name='Perez',
email='*****@*****.**',
birth_date=date(1983, 2, 21))
person.put()
self.response.write('Inserted Person!')
def create_new_user(self, rawname, role, email=""):
""" Creates a new Person record with a unique username, or returns a person wiht the matching username"""
ut = Utils()
username = ut.cleanUserName(rawname)
if ut.validateUserName(username):
# check for username
person = self.get_person(username)
# create a new person if we have not got this one
if person == None:
person = Person()
person.email = email
person.passhash = ""
# no passhash if not got a direct logon
person.username = username
person.displayname = ut.tidyUserName(
rawname
) # allow the username to be updated on the myHoots or profile or summink
person.before_put()
person.role = role
person.put()
self._person = person
return username
else:
return ""
def register(request):
if request.method == 'GET':
return httputils.render_html(request,'gobang/register.html', {})
else:
email = request.POST.get('email', default = None)
passwd = request.POST.get('passwd', default = None)
username = request.POST.get('username', default = None)
validation_code = request.POST.get('validation_code', default = None)
#check input not none
for item in (email, passwd,username,validation_code):
if item is None:
return render(request, 'gobang/register.html',{'error_msg':'input has none'})
#check validation code right
server_validation_code = validation_cache.get(email)
if server_validation_code is None or server_validation_code != validation_code:
return render(request, 'gobang/register.html',{'error_msg':'validation code not right'})
#insert db and use model to check input format right
added_person = Person(username=username,passwd=passwd,email=email)
try:
added_person.save()
except Exception as e:
#record exception
gobang_logger.error("insert db error, {0}".format(e))
return render(request, 'gobang/register.html',{'error_msg':str(e)})
#set sessions and redirect
request.session['login'] = True
request.session['pk'] = added_person.pk
request.session['username'] = added_person.username
return HttpResponseRedirect('/gobang/index')
def post(self):
continue_uri = self.request.get('continue')
person = Person()
person.first_name = self.request.get('first_name')
person.last_name = self.request.get('last_name')
person.put()
self.redirect(continue_uri)
def merge_people(elem):
"""
Parses data from "<Person />" tags
Checks if entry already exists
If so, do a merge
else, import the model data
Saves model to mysql database
"""
for p in elem :
person_filter_obj = Person.objects.filter(wcdb_id = p.get('ID'))
if (len(person_filter_obj) != 0):
person = person_filter_obj[0] #if person exists, use it
person.name = p.get('Name')
else: #else make a new one
person = Person(name = p.get('Name'), wcdb_id = p.get('ID'))
kind = p.find('Kind')
location = p.find('Location')
common = p.find('Common')
if (kind != None):
person.kind = kind.text
if (location != None):
person.location = location.text
if (common != None):
merge_common(common, person)
person.save()
def create_player(first, last):
person = Person(first_name=first, last_name=last)
person.save()
player = Player(person=person)
player.save()
return player
def person(self):
cookie, is_new_cookie = self.get_cookie()
if is_new_cookie:
person = Person.create(cookie)
else:
person = Person.get_by_cookie(cookie)
return person
def setUp(self):
Redis().flushall()
p1 = Person(name='Test User 1', ssn='123456789')
p1.save()
pn1 = PhoneNumber(person=p1, label='Test 1', phone_number='5558675309')
pn1.save()
from django import db
db.reset_queries()
def save(self):
password = self.cleaned_data.pop('password1')
self.cleaned_data.pop('password2')
person = Person(**self.cleaned_data)
person.set_password(password)
person.save()
return person
def test_setter(self):
# The "full_name" property hasn't provided a "set" method.
self.assertRaises(AttributeError, setattr, self.a, 'full_name', 'Paul McCartney')
# But "full_name_2" has, and it can be used to initialise the class.
a2 = Person(full_name_2 = 'Paul McCartney')
a2.save()
self.assertEqual(a2.first_name, 'Paul')
def createUser(self, user_info, user, uri):
# Verifying authenticity of signup request
if user:
print "Printing User Info Object"
print user_info
requested_role = user_info["role"]
if users.is_current_user_admin():
requestee_role = 'admin'
else:
requestee_role = self.getCurrentUserRole(user)[0]
print requestee_role
print requested_role
if requestee_role == 'superintendent' and requested_role not in ['principal','teacher','student']:
return {
'error': 'User does not have permissions to create that role'
}
elif requestee_role == 'principal' and requested_role not in ['teacher', 'student']:
return {
'error': 'User does not have permissions to create that role'
}
elif requestee_role == 'teacher' and requested_role not in ['student']:
return {
'error': 'User does not have permissions to create that role'
}
elif requestee_role == False:
return {
'error': 'User does not have permissions to create that role'
}
else:
# Check to see if user already exists
try:
email = user_info.email
query = Person.query(Person.email == email)
person = query.fetch(1)
person = person[0]
print person
if person:
print "User already exists..."
return {
'error': 'User already exists'
}
except:
print "Creating User..."
guid = str(uuid4())
f_name = user_info["f_name"]
l_name = user_info["l_name"]
person = Person(f_name=f_name, l_name=l_name, email=user_info["email"], role=[user_info["role"]], guid=guid)
person.put()
# self.sendEmail(f_name, l_name, user_info["email"], guid, uri)
return person
else:
return {
'error': 'No user logged in'
}
def setUp(self):
self.person1 = Person(name = "Person1")
self.person2 = Person(name = "Person2")
self.person3 = Person(name = "Person3")
self.person4 = Person(name = "Person4")
self.person1.save()
self.person2.save()
self.person3.save()
self.person4.save()
def get_image_info(self, uid, name):
post_data = {'api_key': self.api_key(),
'api_secret': self.api_secret(),
'img_uid': uid}
r = requests.post(self.base_url() + 'GetImageInfo', post_data)
json_obj = json.loads(r.content)
p = Person(uid=json_obj['faces'][0]['uid'], name=name)
p.save()
return r
def magic(request):
p1 = Person(login = "******", hashedPassword = "******")
p1.save()
k1 = Tokena(value = "please come in", active = True, belongs_to = p1, created=datetime.datetime.utcnow())
k1.save()
k2 = Tokena(value = "you're not welcome", active = False, belongs_to = p1, created=datetime.datetime.utcnow())
k2.save()
print k1
print k2
return HttpResponse("nice", RequestContext(request))
def familytree_primitives_data():
filter_surnames = set(x for x in request.values.get('surname', '').lower().split(',') if x)
# only show given individual
single_person = request.values.get('single_person')
if single_person:
people = [Person.get(single_person)]
else:
people = sorted(Person.find(), key=lambda p: p.group_name)
relatives_of = request.values.get('relatives_of')
if relatives_of:
central_person = Person.get(relatives_of)
people = central_person.related_people
# only find ancestors of given person
ancestors, descendants = None, None
ancestors_of = request.values.get('ancestors_of')
if ancestors_of:
central_person = Person.get(ancestors_of)
ancestors = central_person.find_ancestors()
descendants_of = request.values.get('descendants_of')
if descendants_of:
central_person = Person.get(descendants_of)
descendants = central_person.find_descendants()
if ancestors_of or descendants_of:
people = set(list(ancestors or [])) | set(list(descendants or []))
def _prepare_item(person):
names_lowercase = (n.lower() for n in person.group_names)
if filter_surnames:
intersects = filter_surnames & set(names_lowercase)
if not intersects:
return
# ethical reasons
if person.death.year:
tmpl = '{born} — {dead}'
else:
tmpl = '{born}'
description = tmpl.format(born=person.birth.year_formatted or '?',
dead=person.death.year_formatted or '?')
return {
'id': person.id,
'title': person.name,
'parents': [p.id for p in person.get_parents()],
'spouses': [p.id for p in person.get_partners()],
'description': description,
'gender': person.gender,
}
prepared = (_prepare_item(p) for p in people)
filtered = (p for p in prepared if p)
return json.dumps(list(filtered))
def addperson():
meeting = get_meeting()
names = [x.name for x in meeting.people]
if request.method == 'POST':
name = request.form['username']
if name not in names:
person = Person(name=name)
person.save()
meeting.people.append(person)
meeting.save()
return redirect('/status/%s' % name)
def create(self):
login = self.request.get("login")
password = self.request.get("password")
token = Person.create_login_token(login, password)
if token:
self.respond_with({
"key": token,
"personKey": str(Person.get_by_login_token(token).key())
})
else:
self.respond_with_error("Invalid login or password")
def setUp(self):
# create classifcation
self.classification = create_classification('Men\'s Open')
# create an Address and a Field
self.address = Address(street='ABC Street')
self.address.save()
self.field = Field(name='Field 1', address=self.address)
self.field.save()
# create teams
self.team_1 = create_team('Team 1', self.classification)
self.team_2 = create_team('Team 2', self.classification)
# create some players
self.player_1 = create_player('One', '1')
self.player_2 = create_player('Two', '2')
self.player_3 = create_player('Three', '3')
# assign the players
self.playfor_1 = PlayFor(player=self.player_1, team=self.team_1, from_date=datetime.date.today())
self.playfor_1.save()
self.playfor_2 = PlayFor(player=self.player_2, team=self.team_1, from_date=datetime.date.today())
self.playfor_2.save()
self.playfor_3 = PlayFor(player=self.player_3, team=self.team_1, from_date=datetime.date.today())
self.playfor_3.save()
# create referee
person = Person(first_name='Ref', last_name='Ref')
person.save()
self.referee = Referee(person=person)
self.referee.save()
# create two seasons
self.season_1 = create_season(self.classification, 'Division 1', '2014-2015', datetime.date.today(), datetime.date.today())
self.season_2 = create_season(self.classification, 'Division 2', '2015-2016', datetime.date.today(), datetime.date.today())
# create some games
self.matchday_season_1 = Matchday(season=self.season_1, label='1', date=datetime.date.today())
self.matchday_season_1.save()
self.game_season_1 = Game(matchday=self.matchday_season_1, date=datetime.date.today(),
away_team=self.team_1, home_team=self.team_2, referee=self.referee,
played=True, field=self.field)
self.game_season_1.save()
self.matchday_season_2 = Matchday(season=self.season_2, label='2', date=datetime.date.today())
self.matchday_season_2.save()
self.game_season_2 = Game(matchday=self.matchday_season_2, date=datetime.date.today(),
away_team=self.team_1, home_team=self.team_1, referee=self.referee,
played=True, field=self.field)
self.game_season_2.save()
def post(self, user_id):
auth_key = request.args.get('key')
user = User.authenticate(user_id, auth_key)
if user:
supposed_person = request.get_json(force=True)
person = Person()
person.user_id = user_id
person.name = supposed_person['name']
db.session.add(person)
db.session.commit()
if person.person_id:
return json.jsonify(person.as_dict())
return json.jsonify({})
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
person = Person()
person.name = form.cleaned_data['name']
person.email = form.cleaned_data['email']
person.save()
return HttpResponseRedirect('../list/')
else:
form = RegistrationForm()
return render(request, '../templates/register.html', {'form': form})
def get_person_by_email(email):
"""Helper method to get the Person object corresponding to the given email.
Creates a new Person object if one didn't exist already.
"""
person = Person.get_by_id(email, parent=get_parent_key_from_email(email))
logging.info("person = " + str(person))
if not person:
logging.info("Failed to find person by id, creating new user")
# DONE: Create a new person with the id = email and parent of get_parent_key_from_email
person = Person(parent=get_parent_key_from_email(email),
id=email)
person.put()
return person
def post(self):
user = users.get_current_user()
if user:
if user.email() in admins:
#Allow picture replacement for admins
person = Person.get_by_id(self.request.get('rcsid'))
else:
person = Person.query(Person.linked_account == user).get()
if person:
person.picture = images.resize(self.request.get('file'), 150, 150)
person.put()
logging.debug('Uploaded Picture: ' + person.rcsid)
return
def test_create(self):
from django.conf import settings
from django import db
settings.DEBUG = True
p2 = Person(name='Test User 2', ssn='123456788')
p2.save()
self.assertEqual(len(db.connection.queries), 1)
p2_r = Person.objects.get(pk=p2.pk)
self.assertEqual(p2, p2_r)
self.assertEqual(len(db.connection.queries), 1)
def save(self):
username = self.cleaned_data['username']
password = self.cleaned_data['password']
email = self.cleaned_data['email']
user = User.objects.create_user(username = username, email = email, password = password)
user.save()
person = Person(user = user, verified = True, email = email, name = username)
person.save()
self.person = person
activate = Activation(key = str(uuid.uuid4()), person = person)
activate.save()
self.activate = activate
self.success = True
return (self.person, self.activate)
def post(self, username):
user = self.authenticate()
if user:
supposed_person = request.get_json(force=True)
person = Person()
person.person_id = 1 if len(
user.people.all()) == 0 else user.people.all()[-1].person_id + 1
person.user_id = user.user_id
person.name = supposed_person['name']
db.session.add(person)
db.session.commit()
if person.person_id:
return json.jsonify(person.as_dict())
raise InvalidUsage()
def look_command(self, msg):
channel = self.person.channel
if not channel:
msg.reply(u'* 您應該先進頻道內再用此一語法查詢.')
return
if not msg.arg:
q = Person.all().filter('channel =', channel)
else:
q = Person.all().filter('channel =', channel).filter('name =', msg.arg)
people = q.fetch(self._NAME_LIMIT + 1)
lines = []
for p in people:
lines.append(u'*** %s email 是 %s' % (p.name, p.user.email()))
msg.reply(u'\n'.join(lines))
def test_queryset_iter_method(self):
query_set = PeopleQuerySet(items=[
Person(name='secondary_actor',
height='100',
films=[1],
species=['species1']),
Person(name='main_actor',
height='90',
films=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
species=['species2']),
Person(name='another_actor',
height='50',
films=[1, 2, 3, 4],
species=['species1'])
])
expected = [
Person(name='secondary_actor',
height='100',
films=[1],
species=['species1']),
Person(name='main_actor',
height='90',
films=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
species=['species2']),
Person(name='another_actor',
height='50',
films=[1, 2, 3, 4],
species=['species1'])
]
for idx, person in enumerate(query_set):
self.assertEqual(expected[idx].name, person.name)
self.assertEqual(expected[idx].height, person.height)
self.assertEqual(expected[idx].films_count, person.films_count)
self.assertEqual(expected[idx].species, person.species)
def test_signals(self):
user = Person(
2, "New Name", "LastName",
datetime.datetime.strptime("30 Nov 00", "%d %b %y").date(), "bio",
"*****@*****.**", "name_", "*****@*****.**", "other")
user.save()
record = ModelsActions.objects.latest('date_with_time')
self.assertEqual(record.action, 0)
user.bio = "This is new Biography"
user.save()
record = ModelsActions.objects.latest('date_with_time')
self.assertEqual(record.action, 1)
user.delete()
record = ModelsActions.objects.latest('date_with_time')
self.assertEqual(record.action, 2)
def put_person():
# get the name first, if no name then fail
name = request.form.get("name")
if not name:
return make_response(jsonify({"code": 403,
"msg": "Cannot put person. Missing mandatory fields."}), 403)
person_id = request.form.get("id")
if not person_id:
p = Person(name=name)
else:
p = Person(id=person_id, name=name)
db.session.add(p)
try:
db.session.commit()
except sqlalchemy.exc.SQLAlchemyError as e:
error = "Cannot put person. "
print(app.config.get("DEBUG"))
if app.config.get("DEBUG"):
error += str(e)
return make_response(jsonify({"code": 404, "msg": error}), 404)
return jsonify({"code": 200, "msg": "success"})
def add_coin_in_notification(update: Update, context: CallbackContext):
coin_id = update.callback_query.data.replace(
f"{Callback.ADD_COIN_IN_NOTIFICATION[1]}_", "")
user_id = update.effective_user.id
try:
with db.atomic():
coin = Coin.create(
coin_id=coin_id,
person=Person.get(Person.telegram_id == user_id))
logging.info(coin)
except IntegrityError as err:
logging.error(f"{str(err)} {update.effective_user.id}")
def signup():
form = SignupForm()
if form.validate_on_submit():
newperson = Person(form.firstname.data, form.lastname.data,
form.email.data, form.password.data)
db.session.add(newperson)
db.session.commit()
session['email'] = newperson.email
person = Person.query.filter_by(email=session['email']).first()
name = person.firstname
return redirect(url_for('dashboard', name=name))
return render_template('signup.html', form=form)
def test_order_by_films_count(self):
query_set = PeopleQuerySet(items=[
Person(name='secondary_actor',
height='100',
films=[1],
species=['species1']),
Person(name='main_actor',
height='90',
films=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
species=['species2'])
])
ordered_results = query_set.order_by(attribute='films_count')
self.assertEqual(ordered_results.items[0].name, 'main_actor')
self.assertEqual(ordered_results.items[0].films_count, 10)
self.assertEqual(ordered_results.items[0].height, 90)
self.assertEqual(ordered_results.items[0].species, 'species2')
self.assertEqual(ordered_results.items[1].name, 'secondary_actor')
self.assertEqual(ordered_results.items[1].films_count, 1)
self.assertEqual(ordered_results.items[1].height, 100)
self.assertEqual(ordered_results.items[1].species, 'species1')
def add_person():
person = Person(
id=-1,
first_name=request.json['firstName'],
last_name=request.json['lastName'],
age=request.json['age'],
height=request.json['height'],
description=request.json['description'],
)
db.add_person(person)
return jsonify({'person': 'true'}), 201
def submit(requests):
errors = []
if requests.method == "POST":
if not requests.POST.get('name', ''):
errors.append("输入姓名。")
if not requests.POST.get('address', ''):
errors.append("输入家庭住址。")
if not requests.POST.get('ble_mac', ''):
errors.append("输入蓝牙地址。")
if not errors:
#print(requests.POST['name'])
p = Person.objects.filter(ble_mac=requests.POST['ble_mac'])
if len(p) > 0:
errors.append("该蓝牙已被使用")
else:
p = Person(name=requests.POST['name'],
address=requests.POST['address'],
birth=requests.POST['birthday'],
ble_mac=requests.POST['ble_mac'])
p.save()
return HttpResponseRedirect('/index/')
return render_to_response('sign-up.html', {'errors': errors})
def add_person(jwt):
body = request.get_json()
if not ('firstname' in body and 'lastname' in body
and 'birthdate' in body):
abort(404)
firstname = body.get('firstname')
lastname = body.get('lastname')
birthdate = body.get('birthdate')
try:
person = Person(firstname=firstname,
lastname=lastname,
birthdate=birthdate)
person.insert()
return jsonify({'success': True})
except:
abort(422)
def savePersonToSQLite(self, **kwargs):
person = Person(id=kwargs['id'],
abstracts=kwargs['abstracts'],
platform_id=kwargs['platform_id'])
if not session.query(Person).filter(Person.id == kwargs['id']).first():
session.add(person)
session.commit()
print '人员-------%s------信息保存成功!' % (kwargs['id'])
else:
print '人员-------%s------信息已存在,无需重复保存!' % (kwargs['id'])
def add_people(ctx, names):
"""Add new people into the archive"""
dbsession = ctx.obj['dbsession']
for name in names:
if '$' in name:
name, slug = name.split('$')
else:
slug = name.replace(' ', '-').lower()
person = dbsession.query(Person).filter(Person.slug == slug).first()
if not person:
person = Person(slug=slug, title=name, status='unconfirmed')
dbsession.add(person)
dbsession.commit()
def test_company_people(self):
c = Company(name="CoolCats")
p = Person(name="Elise")
self.session.add(c)
self.session.add(p)
self.assertTrue(len(c.people) < 1)
c.people.append(p)
self.session.add(c)
result = self.session.query(Company).filter_by(name="CoolCats").first()
p_again = result.people[0]
self.assertEqual(p_again.name, "Elise")
def People_agregar():
name = request.json.get("name", None)
color_ojos = request.json.get("color_ojos", None)
color_cabello = request.json.get("color_cabello", None)
gender = request.json.get("gender", None)
person = Person(name=name,
color_ojos=color_ojos,
color_cabello=color_cabello,
gender=gender)
db.session.add(person)
db.session.commit()
#user=json.loads(name, color_ojos, color_cabello,gender)
return jsonify({"people": "ok"})
def handle_add_person():
body = request.get_json()
if body is None:
raise APIException("Body cannont be empty", status_code=400)
if 'full_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 'address' not in body:
raise APIException('You need to specify the address', status_code=400)
if 'phone' not in body:
raise APIException('You need to specify the phone', status_code=400)
person = Person(username=body['username'],
email=body['email'],
full_name=body['full_name'],
address=body['address'],
phone=body['phone'])
db.session.add(person)
db.session.commit()
return jsonify(person.serialize()), 200
def create_person():
"""
Create a person and marries partners if eligible.
"""
try:
data = request.get_json(force=True)
first_name = data.get('first_name')
last_name = data.get('last_name')
partner_id = data.get('partner_id')
partner = None
if first_name is None:
raise InvalidRequestException('First name is required')
if last_name is None:
raise InvalidRequestException('Last name is required')
if partner_id is not None:
partner = Person.get_or_none(Person.id == partner_id)
if partner is None:
raise NotFoundException('Partner not found')
if partner.partner is not None:
raise ConflictException('Partner already married')
result = Person(first_name=first_name,
last_name=last_name,
partner=partner)
result.save()
if partner is not None:
partner.partner = result
partner.save()
response = generate_response(model_to_dict(result), 201)
except Exception as e:
app.logger.error(e)
response = generate_error_response(e)
return response
def post(self):
person = Person()
if users.get_current_user():
person.owner = users.get_current_user()
person.name = self.request.get('navn')
person.put()
self.redirect('/')
def save(self):
password = self.cleaned_data.pop('password1')
self.cleaned_data.pop('password2')
person = Person(**self.cleaned_data)
person.set_password(password)
person.save()
return person
def person_insert(payload):
'''
create and insert person
privet /person post methods
get data (name, gender, day_of_birth, day_of_death, notes, address,
nickname, status) from json requst then insert data into person object
scope requires authtction post:person
insert into person (name, gender, day_of_birth, day_of_death, notes,
address, nickname, status) VALUES /*from json requst*/(name, gender,
day_of_birth,day_of_death, notes, address, nickname, status)
return name of person, and 200 success
if any problem in name raise 422 if gender not m, f, male, female raise
400
'''
data = request.get_json()
name = data.get('name', None)
gender = data.get('gender', None)
day_of_birth = data.get('day_of_birth', None)
day_of_death = data.get('day_of_death', None)
notes = data.get('notes', None)
address = data.get('address', None)
nickname = data.get('nickname', None)
status = data.get('status', None)
if not name:
abort(422)
if gender == "m" or "f" or "male" or "female":
person = Person(name=name,
gender=gender,
day_of_birth=day_of_birth,
day_of_death=day_of_death,
notes=notes,
address=address,
nickname=nickname,
status=status)
person.insert()
return jsonify({"success": True, "persons": name})
else:
abort(400)
def update(person_id, person):
"""
This function updates an existing person in the people structure
:param person_id: Id of the person to update in the people structure
:param person: person to update
:return: updated person structure
"""
fname = person.get("fname")
lname = person.get("lname")
# Get the person requested from the db into session
update_person = Person.query.filter(
Person.person_id == person_id).one_or_none()
# Did we find an existing person?
if update_person is not None:
# turn the passed in person into a db object
schema = PersonSchema()
update = Person(lname=lname, fname=fname)
# Set the id to the person we want to update
update.person_id = update_person.person_id
# merge the new object into the old and commit it to the db
db.session.merge(update)
db.session.commit()
# return updated person in the response
data = schema.dump(update_person)
return data, 200
# Otherwise, nope, didn't find that person
else:
abort(404, f"Person not found for Id: {person_id}")
def make_pizzas(halves):
pairs = get_pairs(halves)
wholes = []
for pair in pairs:
if len(pair) == 2:
half1 = db.session.query(Half).filter_by(id=pair[0]).first()
half2 = db.session.query(Half).filter_by(id=pair[1]).first()
person1 = Person(email=half1.email, location=half1.location)
person2 = Person(email=half2.email, location=half2.location)
whole = Pizza(person1=person1, person2=person2)
whole.topping1_left = half1.topping1
whole.topping2_left = half1.topping2
whole.topping3_left = half1.topping3
whole.topping1_right = half2.topping1
whole.topping2_right = half2.topping2
whole.topping3_right = half2.topping3
whole.sauce = 'Tomato'
whole.size = 'Large'
whole.time_added = datetime.datetime.now()
wholes.append(whole)
else:
wholes.append(db.session.query(Half).filter_by(id=pair[0]).first())
return wholes
def insert():
""" Controller: this is an insertion method to control
the insertion of new persons into our tsv file.
"""
if (widgets_entry['name'].get() and widgets_entry['last_name'].get()
and widgets_entry['city'].get()):
individu = Person(widgets_entry["name"].get(),
widgets_entry["last_name"].get(),
widgets_entry["phone"].get(),
widgets_entry["adresse"].get(),
widgets_entry["city"].get())
if individu.already_exists():
messagebox.askretrycancel('Already exists',
'The person already exists!')
else:
individu.insert_to_file()
print('New person inserted succefully!')
else:
messagebox.showerror('Error', 'Name, Last name and city are required!')
def signup():
form = SignupForm()
if request.method == 'POST':
if not form.validate():
return render_template('signup.html', form=form)
else:
newperson = Person(form.firstname.data, form.lastname.data,
form.email.data, form.password.data)
db.session.add(newperson)
db.session.commit()
session['email'] = newperson.email
return redirect(url_for('profile'))
elif request.method == 'GET':
return render_template('signup.html', form=form)
def add_person():
person = Person()
personForm = PersonForm(obj=person)
if request.method == 'POST':
if personForm.validate_on_submit():
personForm.populate_obj(person)
app.logger.debug(f'Person to save {person}')
# save
db.session.add(person)
db.session.commit()
return redirect(url_for('index'))
return render_template('add.html', form=personForm)
class CreatePersonView(CreateView):
queryset = Person()
template_name = 'person.html'
form_class = PersonForm
success_url = '/'
def form_valid(self, form):
#if not self.request.session.exists(self.request.session.session_key):
self.request.session.create()
# print type(self.request.session)
form.instance.session = Session.objects.get(
session_key=self.request.session.session_key)
print form.instance.session
return super(CreatePersonView, self).form_valid(form)
def create_new_person():
"""function will create new person with parameters name, age, balance, email, and adress and add to the db"""
name = request.json['name']
age = request.json['age']
balance = request.json['balance']
email = request.json['email']
address = request.json['address']
new_person = Person(name, age, balance, email, address)
db.session.add(new_person)
db.session.commit()
return jsonify(new_person)
def message_received(self, msg):
"""Handle all messages; overrides CommandHandlerMixin."""
logging.debug('%s said "%s"', msg.sender, msg.body)
match = re.match(r'^([^/]+)(/.*)?$', msg.sender)
if not match:
msg.reply('* Hey, you\'re using a weird JID!')
return
self.person = Person.PersonByEmail(match.group(1))
if not self.person:
msg.reply('* Sorry, who are you?')
return
super(XmppController, self).message_received(msg)
def handle_person():
# POST request
if request.method == 'POST':
body = request.get_json()
user1 = Person(name=body['name'], email=body['email'])
db.session.add(user1)
db.session.commit()
return "ok", 200
# GET request
if request.method == 'GET':
all_people = Person.query.all()
all_people = list(map(lambda x: x.serialize(), all_people))
return jsonify(all_people), 200
def handle_query():
if request.method =='GET':
people_query = Person.query.all()
all_people = list(map(lambda x: x.serialize(), people_query))
return jsonify(all_people), 200
if request.method =='POST':
#user1 = Person(username="******", email="*****@*****.**")
body = request.get_json()
user1 = Person(full_name=body.get('full_name'), username=body.get('username'), email=body.get('email'), phone=body.get('phone'), address=body.get('address'))
db.session.add(user1)
db.session.commit()
return jsonify(user1.id), 200
def create_witness():
form = CreateForm(request.form)
if request.method == 'POST' and form.validate():
name = form.name.data
age = form.age.data
comment = form.comment.data
# トランザクション
with db.session.begin(subtransactions=True):
new_person = Person(name, age, comment)
db.session.add(new_person)
db.session.commit()
return redirect(url_for('witness_list'))
return render_template('create_witness.html', form=form)
def say_hello():
danny = Person(name='Danny', catchphrase='Howdy')
try:
db.session.add(danny)
db.session.commit()
except:
db.session.rollback()
print(sys.exc_info())
finally:
db.session.close()
dannyGet = Person.query.first()
return dannyGet.catchphrase + '!' + ' ' + dannyGet.name
