def handle(self, *options, **kwoptions): if len(options) != 1: raise CommandError('Must provide a file') with open(options[0]) as f: for line in f: line = line.strip() # ingore blank lines if line == '': continue (last_name, first_name, email, username) = line.split(' ') password_chars = string.ascii_lowercase + string.digits password = ''.join(random.choice(password_chars) for x in range(6)) person = Person(first_name = first_name, last_name = last_name, username = username, email = email) person.set_password(password) person.is_staff = True person.is_superuser = True mail_text = EMAIL_TEXT % (first_name, username, password) send_mail('Welcome to ROSEdu People', mail_text, '*****@*****.**', [email]) person.save() print 'Invited %s %s' % (first_name, last_name)
def make_a_person(max=1): g, m, f = '','','' i = 1 while i <= max: i += 1 rg = random.randint(1,20) if rg >= 3: g = random.choice(GIVEN_NAMES) elif rg == 2: g = random.choice(INITIALS) rm = random.randint(1,50) if rm == 49: m = random.choice(GIVEN_NAMES) elif rm == 50: m = random.choice(INITIALS) rf = random.randint(0,10) if rf >= 1: f = random.choice(FAMILY_NAMES) name = ' '.join(('%s %s %s' % (g, m, f)).split()) if name == '': print('The name is empty!') return else: p = Person(name=name) p.save() print('Created person named %s' % p.name)
def getPerson(row, fields, importrec): Person, created = Person.objects.get_or_create( firstname=Person.normalize("firstname", getfield(fields, "nom", row)), lastname=Person.normalize("lastname", getfield(fields, "prenom", row)), birthday=Person.normalize("lastname", getfield(fields, "datenaissance", row)) ) if created: Person.sourcetype = "I" Person.sourceid = importrec.pk if "prenoms" in fields: Person.prenoms = Person.normalize("prenoms", getfield(fields, "prenoms", row)) if "uniquid" in fields: Person.uniquid = Person.normalize("uniquid", getfield(fields, "uniquid", row)) if "email" in fields: Person.email = Person.normalize("email", getfield(fields, "email", row)) if "mobile" in fields: Person.mobile = Person.normalize("mobile", getfield(fields, "mobile", row)) password = User.objects.make_random_password(length=8) Person.initpass = password Person.save() print "Created Person ", Person else: print "Existing Person", Person
def _link_adjudicator(request, pOriginalAdjudicatorName, pContestEvent): """ Link the passed adjudicator to the contest """ lAdjudicatorName = pOriginalAdjudicatorName if lAdjudicatorName.lower() == 'unknown': return # if it ends with a dot, remove it if lAdjudicatorName.endswith('.'): lAdjudicatorName = lAdjudicatorName[:-1] # if there is no space after a full stop then add one lAdjudicatorName = add_space_after_dot(lAdjudicatorName) # if there is no dot after an initial then add one lAdjudicatorName = add_dot_after_initial(lAdjudicatorName) # get rid of double spaces lAdjudicatorName = lAdjudicatorName.replace(" ", " ") lLastSpace = lAdjudicatorName.rfind(' ') if lLastSpace > 0: lAdjudicatorFirstNames = lAdjudicatorName[:lLastSpace].strip() lAdjudicatorSurname = lAdjudicatorName[lLastSpace:].strip() else: lAdjudicatorFirstNames = lAdjudicatorName lAdjudicatorSurname = lAdjudicatorName try: lPerson = Person.objects.filter( first_names__iexact=lAdjudicatorFirstNames, surname__iexact=lAdjudicatorSurname)[0] except IndexError: try: lPersonAlias = PersonAlias.objects.filter( name__iexact=lAdjudicatorName)[0] lPerson = lPersonAlias.person except IndexError: lPerson = Person() lPerson.surname = lAdjudicatorSurname lPerson.first_names = lAdjudicatorFirstNames lPerson.slug = slugify(lAdjudicatorName, instance=lPerson) lPerson.owner = request.user lPerson.lastChangedBy = request.user lPerson.save() notification(None, lPerson, 'people', 'person', 'new', request.user, browser_details(request)) lContestAdjudicator = ContestAdjudicator() lContestAdjudicator.contest_event = pContestEvent lContestAdjudicator.adjudicator_name = lPerson.name lContestAdjudicator.person = lPerson lContestAdjudicator.owner = request.user lContestAdjudicator.lastChangedBy = request.user lContestAdjudicator.save()
def add_person(r): if(r.method == "GET"): return render(r, 'edit_person.jinja') elif(r.method == "POST"): p = Person( first_name=r.POST['fname'], last_name=r.POST['lname'], nickname=r.POST['nickname'], active=True, info="" ) p.save() return redirect(people)
def create(request): """Render a form to create an entrepreneur.""" if request.method == "POST": user_form = UserForm(request.POST) startup_form = StartupForm(request.POST, request.FILES) if user_form.is_valid() and startup_form.is_valid(): user = user_form.save() startup = startup_form.save() person = Person() entrepreneur = Entrepreneur() person.user = user person.save() entrepreneur.person = person entrepreneur.startup = startup entrepreneur.save() msg = _("Your user and startup has been created successfully.") return render_to_response("entrepreneurs/create.html", { "msg": msg, "user": user, }, context_instance=RequestContext(request) ) else: return render_to_response("entrepreneurs/create.html", { "user_form": user_form, "startup_form": startup_form, }, context_instance=RequestContext(request) ) else: return render_to_response("entrepreneurs/create.html", { "user_form": UserForm(), "startup_form": StartupForm(), }, context_instance=RequestContext(request) )
def people_person_create(): from people.models import Person # 第一种 自动保存 print(Person.objects.create(name='Zhoufeng', age=23)) print(Person.objects.create(name='Zhoufeng', age=24)) print(Person.objects.create(name='Zhoufeng', age=25)) # 第二种 p = Person(name='WZ', age=13) p.save() # 第三种 p = Person(name='TWZ') p.age = 23 p.save() """
def add(request): name=request.GET.get('name') age = request.GET.get('age') person= Person() person.name=name person.age=age result= person.save() return HttpResponse(str(result))
def create(request): """Render a form to create an entrepreneur.""" if request.method == "POST": user_form = UserForm(request.POST) startup_form = StartupForm(request.POST, request.FILES) if user_form.is_valid() and startup_form.is_valid(): user = user_form.save() startup = startup_form.save() person = Person() entrepreneur = Entrepreneur() person.user = user person.save() entrepreneur.person = person entrepreneur.startup = startup entrepreneur.save() msg = _("Your user and startup has been created successfully.") return render_to_response("entrepreneurs/create.html", { "msg": msg, "user": user, }, context_instance=RequestContext(request)) else: return render_to_response("entrepreneurs/create.html", { "user_form": user_form, "startup_form": startup_form, }, context_instance=RequestContext(request)) else: return render_to_response("entrepreneurs/create.html", { "user_form": UserForm(), "startup_form": StartupForm(), }, context_instance=RequestContext(request))
def user(request): if request.POST: if '_save' in request.POST: p = Person.objects.filter(netid=request.POST['netid']) if (p): p1 = p[0]; p1.netid = request.POST['netid'] p1.first_name = request.POST['firstname'] p1.last_name = request.POST['lastname'] p1.lat = request.POST['lat-s'] p1.lon = request.POST['lon-s'] p1.save(); else: p1 = Person(netid=request.POST['netid'], first_name=request.POST['firstname'], last_name=request.POST['lastname'], lat=request.POST['lat-s'], lon=request.POST['lon-s']) p1.save(); return HttpResponseRedirect('/') elif '_cancel' in request.POST: return HttpResponseRedirect('/')
def activate(self, request, activation_key): """ Given an an activation key, look up and activate the user account corresponding to that key (if possible). After successful activation, the signal ``registration.signals.user_activated`` will be sent, with the newly activated ``User`` as the keyword argument ``user`` and the class of this backend as the sender. """ activated = RegistrationProfile.objects.activate_user(activation_key) if activated: signals.user_activated.send(sender=self.__class__, user=activated, request=request) person = Person(user=activated) activated.save() person.save() return activated
def activate(self, request, activation_key): """ Given an an activation key, look up and activate the user account corresponding to that key (if possible). After successful activation, the signal ``registration.signals.user_activated`` will be sent, with the newly activated ``User`` as the keyword argument ``user`` and the class of this backend as the sender. """ activated = RegistrationProfile.objects.activate_user(activation_key) if activated: signals.user_activated.send(sender=self.__class__, user=activated, request=request) person = Person(user=activated) activated.save() person.save() return activated
def create(request): """Render a form to create a mentor.""" if request.method == "POST": user_form = UserForm(request.POST) mentor_form = MentorForm(request.POST) if user_form.is_valid() and mentor_form.is_valid(): user = user_form.save() person = Person() mentor = mentor_form.save(commit=False) person.user = user person.save() mentor.person = person mentor.save() msg = _("Your user has been created successfully.") return render_to_response("mentors/create.html", { "msg": msg, "user": user, }, context_instance=RequestContext(request)) else: return render_to_response("mentors/create.html", { "user_form": user_form, "mentor_form": mentor_form, }, context_instance=RequestContext(request)) else: return render_to_response("mentors/create.html", { "user_form": UserForm(), "mentor_form": MentorForm(), }, context_instance=RequestContext(request))
def temp(): from people.models import Person p = Person(name='wz', age=13) p.save() p = Person(name='wz', age=23) p.save() p = Person(name='wangshijie', age=23) p.save()
def new_person(request): required_method_type = "POST" if not check_method_type(request, required_method_type): return invalid_method(required_method_type) try: parsed_body = json.loads(request.body.decode('utf-8')) except: return error('no body') for field in Person.required_fields: if field not in parsed_body: return error('mising fields') if 'api_key' in parsed_body: admin = check_api_key(parsed_body['api_key']) else: admin = False if not admin: return error('Admin only action') parsed_body['hashed_password'] = bcrypt.hashpw( parsed_body['password'].encode('utf-8'), bcrypt.gensalt()) try: del parsed_body['password'] del parsed_body['api_key'] except KeyError: return error('cant delete') person = Person(**parsed_body) try: person.save() except: print('ERROR: Can\'t create person.') print(sys.exc_info()) return error('Can\'t create person.') return JsonResponse(Person.admin_view(person))
def execute_upoad(file, user_id, block_id): global ERROR user_id = CocoUser.objects.get(user__id=user_id) block_id = Block.objects.get(id=block_id) file_name = str(os.path.splitext(file)[0]) file_name_list = str(os.path.splitext(file)[0].split('/')[-1]) village_errors_file = open(file_name + '_errors_village.csv', 'wb') wrtr = csv.writer(village_errors_file, delimiter=',', quotechar='"') wrtr.writerow(["Entry No.", "Village Name", "Error"]) village_success_file = open(file_name + '_success_village.csv', 'wb') wrtr_success = csv.writer(village_success_file, delimiter=',', quotechar='"') wrtr_success.writerow(["Entry No.", "Village Name"]) csvfile = open(file, 'rb') rows_villages = csv.DictReader(csvfile) village_querry_set = Village.objects.values_list('village_name','id').filter(block_id=block_id.id) village_map = dict(village_querry_set) i = 0 for row in rows_villages: if unicode(row['Village_Name']) not in village_map: i = i + 1 try: village = Village(user_created_id=user_id.id, village_name=unicode(row['Village_Name']), block_id=block_id.id) village.save() village_map[unicode(row['Village_Name'])] = village.id wrtr_success.writerow([i, unicode(row['Village_Name'])]) village_success_file.flush() except Exception as e: ERROR += 1 wrtr.writerow([i, unicode(row['Village_Name']), e]) village_errors_file.flush() village_success_file.close() village_errors_file.close() ERROR_FILENAMES.append(file_name_list + '_errors_village.csv') SUCCESS_FILENAMES.append(file_name_list + '_success_village.csv') group_errors_file = open(file_name + '_errors_group.csv', 'wb') wrtr = csv.writer(group_errors_file, delimiter=',', quotechar='"') wrtr.writerow(["Entry No.", "Shg Name", "Error"]) group_success_file = open(file_name + '_success_group.csv', 'wb') wrtr_success = csv.writer(group_success_file, delimiter=',', quotechar='"') wrtr_success.writerow(["Entry No.", "Shg Name"]) csvfile = open(file, 'rb') rows_groups = csv.DictReader(csvfile) group_querry_set = PersonGroup.objects.values_list('group_name', 'id') group_map = dict(group_querry_set) i = 0 for row in rows_groups: if unicode(row['Shg_Name']) + unicode(row['Village_Name']) not in group_map: i = i + 1 try: group = PersonGroup(user_created_id=user_id.id, partner_id=user_id.partner.id, group_name=row['Shg_Name'], village_id=village_map[unicode(row['Village_Name'])]) group.save() group_map[row['Shg_Name'] + unicode(row['Village_Name'])] = group.id wrtr_success.writerow([i, row['Shg_Name']]) group_success_file.flush() except Exception as e: ERROR += 1 wrtr.writerow([i, row['Shg_Name'], e] ) group_errors_file.flush() group_errors_file.close() group_success_file.close() ERROR_FILENAMES.append(file_name_list + '_errors_group.csv') SUCCESS_FILENAMES.append(file_name_list + '_success_group.csv') person_errors_file = open(file_name + '_errors_person.csv', 'wb') wrtr = csv.writer(person_errors_file, delimiter=',', quotechar='"') wrtr.writerow(["Entry No.", "Person Name", "Error"]) person_success_file = open(file_name + '_success_person.csv', 'wb') wrtr_success = csv.writer(person_success_file, delimiter=',', quotechar='"') wrtr_success.writerow(["Entry No.", "Person Name"]) csvfile = open(file, 'rb') rows_persons = csv.DictReader(csvfile) i = 0 for row in rows_persons: i = i + 1 try: person_name = ' '.join([unicode(row['Member_Name']), unicode(row['Member_Surname'])]) father_name = ' '.join([unicode(row['Husband_Father_Name']), unicode(row['Husband_Father_Surname'])]) gender = str(row['Gender(M/F)']) if (row['Age'] == ''): age = None else: age = float(row['Age']) if (str(row['Phone_Number']) == ''): phone_number = str('') else: phone_number = str(row['Phone_Number']) person = Person(user_created_id=user_id.id, partner_id=user_id.partner.id, person_name=person_name, father_name=father_name, village_id=village_map[unicode(row['Village_Name'])], group_id=group_map[row['Shg_Name'] + unicode(row['Village_Name'])], gender=gender, age = age, phone_no = phone_number ) person.save() wrtr_success.writerow([i, person_name]) person_success_file.flush() except Exception as e: ERROR += 1 wrtr.writerow([i, person_name, e]) person_errors_file.flush() person_errors_file.close() person_success_file.close() ERROR_FILENAMES.append(file_name_list + '_errors_person.csv') SUCCESS_FILENAMES.append(file_name_list + '_success_person.csv')
dates = production['dates'] for d in dates: start_date, end_date = d[0] place = d[1] location = theatres[place] log(' %s %s %s' % (start_date, end_date, location)) if not dry_run(): ProductionPlace.objects.get_or_create(production=production_obj, place=location, start_date=start_date, end_date=end_date) cast = production['cast'] for name in cast: m = re.match('(.*) (.*?)$', name) if m: first_name, last_name = m.group(1), m.group(2) else: first_name, last_name = u'', name log(' Actor: ' + first_name + ' ' + last_name) if not dry_run(): try: person, created = Person.objects.get_or_create(first_name=first_name, last_name=last_name) except: person = Person(first_name=first_name, last_name=last_name) person.save() Part.objects.get_or_create(production=production_obj, person=person, cast=True) if name in castLinks: person.web = castLinks[name] person.save()
def meet(request): # check that user is authenticated if (not request.user.is_authenticated()): return render(request, 'product_page.html') first = "False" p = Person.objects.filter(netid=request.user.username) if (not p): p1 = Person(netid=request.user.username) p1.save() # get information about the user currentNetid = request.user.username me = Person.objects.get(netid=currentNetid) # first time visiting the site? if request.method == 'GET': if (not isinstance(me.lat, Decimal)): first = "True" # updating profile if request.method == 'POST': # get information from the form pf = ProfileForm(request.POST) # if the form is valid, update the user's information if pf.is_valid(): cd = pf.cleaned_data p = Person.objects.filter(netid=currentNetid) # is the user already in the database? If so, just updated their info if (p): p1 = p[0]; p1.netid = currentNetid p1.first_name = cd['first_name'] p1.last_name = cd['last_name'] p1.lat = cd['lat_s'] p1.lon = cd['lon_s'] p1.start = cd['start'] p1.end = cd['end'] p1.company = cd['company'] p1.year = (int)(cd['year']) p1.desired = cd['desired'] p1.gender = cd['gender'] p1.save() # otherwise, create a new Person for the user else: p1 = Person(netid=currentNetid, first_name=['first_name'], last_name=cd['last_name'], lat=cd['lat_s'], lon=cd['lon_s'], company=cd['company'], year=cd['year']) p1.save() # render the templates t = get_template('tablefill.html') friends = me.friends.all() tfhtml = t.render(RequestContext(request, {'friend_list': friends})) t = get_template('myhousetablefill.html') myhouses = me.myhouses.all() myhtfhtml = t.render(RequestContext(request, {'my_houses': myhouses, 'me':me})) t = get_template('profile.html') html = t.render(RequestContext(request, {'form': pf})) data = {'success':'true', 'html':html, 'tfhtml':tfhtml, 'myhtfhtml':myhtfhtml} return HttpResponse(json.dumps(data), content_type = "application/json") # form is not valid else: pf.errors['lat_s'] = pf.error_class() t = get_template('profile.html') html = t.render(RequestContext(request, {'form': pf})) data = {'success':'false', 'html':html} return HttpResponse(json.dumps(data), content_type = "application/json") else: pf = ProfileForm(initial=model_to_dict(me)) friends = me.friends.all() houses = me.houses.all() myhouses = me.myhouses.all() return render(request, 'meet.html', {'form': pf, 'friend_list':friends, 'house_list':houses,'my_houses':myhouses, 'firstTime':first, 'me': me})
def enter_results(request, pContestSlug, pDate): """ Enter the actual results of the contest """ lForm = ResultsForm() lHowToCorrectErrors = '' try: lContest = Contest.objects.filter(slug=pContestSlug)[0] lContestEvent = ContestEvent.objects.filter(contest=lContest, date_of_event=pDate)[0] except IndexError: raise Http404() # if flag is set, forward to adjudicator and don't allow results to be added lToday = date.today() if lToday < lContestEvent.date_of_event and lContest.prevent_future_bands: return HttpResponseRedirect('/addresults/%s/%s/6/' % (pContestSlug, pDate)) if request.POST: try: lRadioSelection = request.POST['conductor_choice'] if lRadioSelection == 'newconductor': lNewConductorPerson = Person() lNewConductorPerson.name = request.POST['conductor'] lNewConductorPerson.slug = slugify( lNewConductorPerson.name, instance=lNewConductorPerson) lNewConductorPerson.lastChangedBy = request.user lNewConductorPerson.owner = request.user lNewConductorPerson.save() notification(None, lNewConductorPerson, 'people', 'person', 'new', request.user, browser_details(request)) elif lRadioSelection == 'alias': lPreviousConductorName = request.POST['conductoralias'] lConductorSerial = request.POST['conductorid'] lConductor = Person.objects.filter(id=int(lConductorSerial))[0] lPreviousName = PersonAlias() lPreviousName.name = lPreviousConductorName lPreviousName.person = lConductor lPreviousName.lastChangedBy = request.user lPreviousName.owner = request.user lPreviousName.save() notification(None, lPreviousName, 'people', 'person_alias', 'new', request.user, browser_details(request)) ## TODO create person alias here - we'll need to pass through the person id, not the conductor id except MultiValueDictKeyError: pass try: lRadioSelection = request.POST['band'] if lRadioSelection == 'newband': # create a new band lNewBandName = request.POST['newbandname'] lNewBandRegion = request.POST['newbandregion'] lNewBand = Band() lNewBand.name = lNewBandName lNewBand.slug = slugify(lNewBandName, instance=lNewBand) lNewBand.region = Region.objects.filter(id=lNewBandRegion)[0] lNewBand.owner = request.user lNewBand.lastChangedBy = request.user lNewBand.save() notification(None, lNewBand, 'bands', 'band', 'new', request.user, browser_details(request)) elif lRadioSelection == 'nameonly': lPreviousBandName = request.POST['oldbandname'] lBandSerial = request.POST['bandid'] lBand = Band.objects.filter(id=int(lBandSerial))[0] lPreviousName = PreviousBandName() lPreviousName.old_name = lPreviousBandName lPreviousName.band = lBand lPreviousName.lastChangedBy = request.user lPreviousName.owner = request.user lPreviousName.save() notification(None, lPreviousName, 'bands', 'band_alias', 'new', request.user, browser_details(request)) except MultiValueDictKeyError: pass lForm = ResultsForm(request.POST) lForm.event = lContestEvent if lForm.is_valid(): lForm.save(request, lContestEvent) return HttpResponseRedirect('/addresults/%s/%s/6/' % (pContestSlug, pDate)) else: lFormErrors = str(lForm.errors['results']) if lFormErrors.startswith(_CONDUCTOR_PREFIX): lConductorName = lFormErrors[len(_CONDUCTOR_PREFIX):-15] lConductorDropList = '<select name="conductorid">\n' lConductors = Person.objects.all() for conductor in lConductors: lAdd = True if conductor.end_date and lContestEvent.date_of_event > conductor.end_date: lAdd = False elif conductor.start_date and lContestEvent.date_of_event < conductor.start_date: lAdd = False if lAdd: lConductorDropList = lConductorDropList + '<option value="%s">%s, %s</option>\n' % ( conductor.id, conductor.surname, conductor.first_names) lConductorDropList = lConductorDropList + '</select>' lHowToCorrectErrors = """<input type="radio" name="conductor_choice" value="newconductor"/>Next submit will create a new conductor called: <input type="text" name="conductor" value="%s"/><br/> <input type="radio" name="conductor_choice" value="alias"/>Next submit will add a conductor alias of <b>%s</b> to %s<input type="hidden" name="conductoralias" value="%s"/><br/> <input type="radio" name="conductor_choice" value="nothing" checked="checked"/>Do nothing, correct it in the text box below.""" % ( lConductorName, lConductorName, lConductorDropList, lConductorName) if lFormErrors.startswith(_BAND_PREFIX): lBandName = lFormErrors[len(_BAND_PREFIX):-15] #lBandName = lFormErrors[len(_BAND_PREFIX):-15] lBandDropList = '<select name="bandid">\n' lBands = Band.objects.all() for band in lBands: lAdd = True if band.end_date and lContestEvent.date_of_event > band.end_date: lAdd = False elif band.start_date and lContestEvent.date_of_event < band.start_date: lAdd = False if lAdd: lBandDropList = lBandDropList + '<option value="%s">%s</option>\n' % ( band.id, band.name) lBandDropList = lBandDropList + '</select>' lRegionDropList = "" lContestRegion = "Unknown" if lContest.region: lContestRegion = lContest.region.name for region in Region.objects.all(): lRegionDropList += "<option value='" + str(region.id) + "'" if region.name == lContestRegion: lRegionDropList += " selected='selected'" lRegionDropList += ">" + region.name + "</option>\n" lHowToCorrectErrors = """You have two choices to fix this problem. You can either create a new band, or assign this name as an old name of an already existing band. Use existing bands where possible.<br/> <input type="radio" name="band" value="newband"/>Next submit will create a new band called: <input type="text" name="newbandname" value="%s"/> in <select name="newbandregion">%s</select> region<br/> <input type="radio" name="band" value="nameonly"/>Next submit will add a previous band name to %s called <b>%s</b><input type="hidden" name="oldbandname" value="%s"/><br/> <input type="radio" name="band" value="nothing" checked="checked"/>Do nothing, correct it in the text box below. """ % (lBandName, lRegionDropList, lBandDropList, lBandName, lBandName) return render_auth( request, 'addresults/bands.html', { "Contest": lContest, "ContestEvent": lContestEvent, "form": lForm, "HowToCorrectErrors": lHowToCorrectErrors, })
def enter_composer(request, pContestSlug, pDate): """ Enter composer for test piece, only shown if we don't match an existing piece """ try: lContest = Contest.objects.filter(slug=pContestSlug)[0] lContestEvent = ContestEvent.objects.filter(contest=lContest, date_of_event=pDate)[0] except IndexError: raise Http404() if request.POST: lComposerName = add_space_after_dot(request.POST['Composer']) lLastSpace = lComposerName.rfind(' ') if lLastSpace > 0: lComposerFirstNames = lComposerName[:lLastSpace].strip() lComposerSurname = lComposerName[lLastSpace:].strip() else: lComposerSurname = lComposerName lComposerFirstNames = '' lArrangerName = add_space_after_dot(request.POST['Arranger']) lArrangerFirstNames = '' lArrangerSurname = '' if len(lArrangerName.strip()) > 0: lLastSpace = lArrangerName.rfind(' ') if lLastSpace > 0: lArrangerFirstNames = lArrangerName[:lLastSpace].strip() lArrangerSurname = lArrangerName[lLastSpace:].strip() else: lArrangerSurname = lArrangerName lArrangerPerson = None lComposerPerson = None lTestPiece = lContestEvent.test_piece if len(lComposerName.strip()) > 0: try: lComposerPerson = Person.objects.filter( surname__iexact=lComposerSurname, first_names__iexact=lComposerFirstNames)[0] except IndexError: try: lPersonAlias = PersonAlias.objects.filter( name__iexact=lComposerName)[0] lArrangerPerson = lPersonAlias.person except IndexError: lPerson = Person() lPerson.surname = lComposerSurname lPerson.first_names = lComposerFirstNames lPerson.slug = slugify(lComposerName, instance=lPerson) lPerson.owner = request.user lPerson.lastChangedBy = request.user lPerson.save() lArrangerPerson = lPerson notification(None, lPerson, 'people', 'person', 'new', request.user, browser_details(request)) if len(lArrangerName.strip()) > 0: try: lArrangerPerson = Person.objects.filter( surname__iexact=lArrangerSurname, first_names__iexact=lArrangerFirstNames)[0] except IndexError: try: lPersonAlias = PersonAlias.objects.filter( name__iexact=lArrangerName)[0] lArrangerPerson = lPersonAlias.person except IndexError: lPerson = Person() lPerson.surname = lArrangerSurname lPerson.first_names = lArrangerFirstNames lPerson.slug = slugify(lArrangerName, instance=lPerson) lPerson.owner = request.user lPerson.lastChangedBy = request.user lPerson.save() lArrangerPerson = lPerson notification(None, lPerson, 'people', 'person', 'new', request.user, browser_details(request)) lTestPiece.arranger = lArrangerPerson lTestPiece.composer = lComposerPerson lTestPiece.save() return HttpResponseRedirect('/addresults/%s/%s/4/' % (pContestSlug, pDate)) else: if lContestEvent.test_piece == None or lContestEvent.test_piece.composer or lContestEvent.test_piece.arranger: return HttpResponseRedirect('/addresults/%s/%s/4/' % (pContestSlug, pDate)) else: cursor = connection.cursor() lComposerNames = [] cursor.execute( "select first_names || ' ' || surname || ' ' || coalesce (suffix, '') from people_person order by 1" ) rows = cursor.fetchall() for row in rows: lComposerNames.append(row[0].strip()) cursor.close() return render_auth( request, 'addresults/composer.html', { "Contest": lContest, "ContestEvent": lContestEvent, "Data": lComposerNames, })
def create(self, validated_data): new = Person(**validated_data) new.save() return new
def testdb(request): test1 = Person(name='runoob') test1.save() return HttpResponse("<p>数据添加成功!</p>")
def handle(self, *args, **options): name = u" ".join(map(lambda s: s.decode("utf8"),args)) print options person = Person(name=name, staff=options['staff']) person.save() print person.pk
def testdb(request): person = Person(name='runoob', age=13) person.save() return HttpResponse("<p>数据添加成功!</p>")
def test_person_name(self): p = Person(title="Sir", first_name="Bill", middle_name="Q.", last_name="Bloggs", suffix="Jr.") p.save() self.failUnlessEqual(p.name, "Sir Bill Q. Bloggs Jr.")