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.")
