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 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 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 test_str(self):
person = Person(first_name='Name', last_name='last name')
self.assertEquals(
str(person),
'Name last name',
)
def composerarranger(self):
"""
Return first of composer or arranger
"""
if self.composer:
return self.composer
if self.arranger:
return self.arranger
return Person()
def test_delete_should_not_hard_delete(self):
# create - this item exists already
payload_existing = {**payload, "person": Person(pk=2)}
instance = PersonWidgetDefinition.objects.create(**payload_existing)
instance.delete()
self.assertTrue(isinstance(instance, PersonWidgetDefinition))
self.assertEqual(instance.group_widget, True)
self.assertEqual(instance.user_widget, False)
def test_delete_should_hard_delete(self):
payload_existing = {**payload, "person": Person(pk=2)}
instance = PersonWidgetDefinition.objects.get(**payload_existing)
instance.group_widget = False
instance.save()
_sum, _ = instance.delete()
self.assertEqual(_sum, 1)
with self.assertRaises(PersonWidgetDefinition.DoesNotExist):
PersonWidgetDefinition.objects.get(**payload_existing)
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 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 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 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 deal_excel(self):
upload_file = UploadRecord.objects.filter(upload_time=self.timestamp).first()
file_path = upload_file.excel_file.path
book = xlrd.open_workbook(file_path)
for sheet in book.sheets():
for row in sheet.get_rows():
try:
p_name = row[0].value
p_num = row[1].value
if p_name == '':
break
if not str(p_num).isalnum():
break
birthday_str = p_num[6:14]
birthday = datetime.strptime(birthday_str, "%Y%m%d")
if int(p_num[16]) % 2 == 0:
sex = False
else:
sex = True
except Exception as e:
logger.error(e)
upload_file.status = '解析出错误，请确认表格格式。'
upload_file.save()
else:
Person(
name=p_name,
id_num=p_num,
birthday=birthday,
sex=sex,
create_time=self.timestamp
).save()
upload_file.status = '解析成功'
upload_file.save()
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')
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
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 testdb(request):
test1 = Person(name='runoob')
test1.save()
return HttpResponse("<p>数据添加成功！</p>")
def person_instance(self):
return Person(name="test person", linkedin_url="https://www.linkedin.com/in/testperson")
'name': 'test stack 3',
'description': 'test description 3'
}
create_stack_payload4 = {
'name': 'test stack 4',
'description': 'test description 4'
}
create_stack_payload5 = {
'name': 'test stack 5',
'description': 'test description 5'
}
payload = {
"person": Person(pk=2),
"widget_definition": WidgetDefinition(pk=1),
}
payload = {
"person": Person(pk=2),
"widget_definition": WidgetDefinition(pk=16),
}
class PersonModelTests(TestCase):
fixtures = ['resources/fixtures/default_data.json', ]
def setUp(self):
# create user - done by fixture for now
self.admin_user = Person.objects.get(pk=1)
def handle(self, *args, **options):
cursor = connection.cursor()
if connection.vendor == 'mysql':
cursor.execute('SET FOREIGN_KEY_CHECKS = 0')
cursor.execute('TRUNCATE TABLE `{0}`'.format(
Company._meta.db_table))
cursor.execute('TRUNCATE TABLE `{0}`'.format(
County._meta.db_table))
cursor.execute('TRUNCATE TABLE `{0}`'.format(City._meta.db_table))
cursor.execute('TRUNCATE TABLE `{0}`'.format(State._meta.db_table))
cursor.execute('TRUNCATE TABLE `{0}`'.format(
Address._meta.db_table))
cursor.execute('TRUNCATE TABLE `{0}`'.format(
Person._meta.db_table))
cursor.execute('SET FOREIGN_KEY_CHECKS = 1')
else:
Company.objects.all().delete()
State.objects.all().delete()
County.objects.all().delete()
City.objects.all().delete()
Address.objects.all().delete()
Person.objects.all().delete()
with open(options.get('csv-file-path'), 'rU') as f:
FIRST_NAME_INDEX = 0
LAST_NAME_INDEX = 1
COMPANY_INDEX = 2
ADDRESS_INDEX = 3
CITY_INDEX = 4
COUNTY_INDEX = 5
STATE_INDEX = 6
ZIP_INDEX = 7
PHONE_INDEX = 8
EMAIL_INDEX = 10
WEB_INDEX = 11
data = csv.reader(f)
# IMPORT:
# companies, states
companies = {}
states = {}
f.readline()
for row in data:
if companies.get(row[COMPANY_INDEX]) is None:
companies[row[COMPANY_INDEX]] = Company(
name=row[COMPANY_INDEX])
if states.get(row[STATE_INDEX]) is None:
states[row[STATE_INDEX]] = State(name=row[STATE_INDEX])
Company.objects.bulk_create(companies.values())
State.objects.bulk_create(states.values())
companies = dict(map(lambda v: (v.name, v), Company.objects.all()))
states = dict(map(lambda v: (v.name, v), State.objects.all()))
# IMPORT:
# counties
counties = {}
f.seek(0)
f.readline()
for row in data:
if counties.get(row[COUNTY_INDEX]) is None:
counties[row[COUNTY_INDEX]] = County(
name=row[COUNTY_INDEX], state=states[row[STATE_INDEX]])
County.objects.bulk_create(counties.values())
counties = dict(map(lambda v: (v.name, v), County.objects.all()))
# IMPORT:
# cities
cities = {}
f.seek(0)
f.readline()
for row in data:
if cities.get(row[CITY_INDEX]) is None:
cities[row[CITY_INDEX]] = City(
name=row[CITY_INDEX],
state=states[row[STATE_INDEX]],
county=counties[row[COUNTY_INDEX]])
City.objects.bulk_create(cities.values())
cities = dict(map(lambda v: (v.name, v), City.objects.all()))
# IMPORT:
# addresses
addresses = {}
f.seek(0)
f.readline()
for row in data:
if addresses.get(row[ADDRESS_INDEX]) is None:
addresses[row[ADDRESS_INDEX]] = Address(
name=row[ADDRESS_INDEX],
city=cities[row[CITY_INDEX]],
zip=row[ZIP_INDEX])
Address.objects.bulk_create(addresses.values())
addresses = dict(map(lambda v: (v.name, v), Address.objects.all()))
# IMPORT:
# persons
persons = []
f.seek(0)
f.readline()
for row in data:
persons.append(
Person(first_name=row[FIRST_NAME_INDEX],
last_name=row[LAST_NAME_INDEX],
address=addresses[row[ADDRESS_INDEX]],
company=companies[row[COMPANY_INDEX]],
phone=row[PHONE_INDEX],
email=row[EMAIL_INDEX],
web=row[WEB_INDEX]))
Person.objects.bulk_create(persons)
print '%d persons have been imported' % len(persons)
def testdb(request):
person = Person(name='runoob', age=13)
person.save()
return HttpResponse("<p>数据添加成功！</p>")
