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 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