def ImportAlumni(uploaded_csv):
reader = csv.DictReader(uploaded_csv)
for row in reader:
######USER INFO
try:
u = umod.User.objects.get(username=row['email'])
if row['program'] == "I-MISM" or row['program'] == 'N-MISM':
u.program = row['program']
else:
u.program = row['program']
except umod.User.DoesNotExist:
u = umod.User()
u.username = row['email']
u.program = row['program']
u.first_name = row['first_name']
u.last_name = row['last_name']
u.email = row['email']
u.street = row['street']
u.city = row['city']
u.state = row['state']
u.zipcode = row['zipcode']
u.country = row['country']
u.phone = row['phone']
u.graduation_year = row['graduation_year']
u.graduation_semester = row['graduation_semester']
u.save()
def create_user(db: Session, user: schemas.UserCreate):
hashed_password = pwd_context.hash(user.password)
db_user = models.User(username=user.username, mobile=user.mobile, hashed_password=hashed_password)
db.add(db_user)
db.commit()
db.refresh(db_user)
return db_user
def init_db(db: Session, email: EmailStr, password: str):
user_dict = {
'email': email,
'firstname': 'Super',
'lastname': 'Admin',
'password_hash': get_password_hash(password)
}
perms = ['can_create_permission', 'can_view_permission', 'can_modify_permission', 'can_delete_permission']
role_perms = ['can_create_role', 'can_view_role', 'can_modify_role', 'can_delete_role']
group_perms = ['can_create_group', 'can_view_group', 'can_modify_group', 'can_delete_group']
perm_admin = ac_models.Role(name='permission_admin')
role_admin = ac_models.Role(name='role_admin')
group_admin = ac_models.Role(name='group_admin')
for perm_name in perms:
perm = ac_models.Permission(name=perm_name)
perm_admin.permissions.append(perm)
db.add(perm)
for perm_name in role_perms:
perm = ac_models.Permission(name=perm_name)
role_admin.permissions.append(perm)
db.add(perm)
for perm_name in group_perms:
perm = ac_models.Permission(name=perm_name)
group_admin.permissions.append(perm)
db.add(perm)
super_admin_group = ac_models.Group(name='super_admin_group')
super_admin_group.roles.append(perm_admin)
super_admin_group.roles.append(role_admin)
super_admin_group.roles.append(group_admin)
user = users_models.User(**user_dict)
user.groups.append(super_admin_group)
db.add_all([perm_admin, role_admin, group_admin, super_admin_group, user])
db.commit()
def register(request):
registration_form = forms.Registration(request.POST or None)
reg_context = {
'reg_form': registration_form,
}
if registration_form.is_valid():
registration_obj = models.User()
#registration_obj.name = registration_form.cleaned_data['name']
registration_obj.first_name = registration_form.cleaned_data[
'first_name']
registration_obj.last_name = registration_form.cleaned_data[
'last_name']
registration_obj.user_name = registration_form.cleaned_data[
'user_name']
registration_obj.zipcode = registration_form.cleaned_data['zipcode']
registration_obj.email = registration_form.cleaned_data['email']
registration_obj.address = registration_form.cleaned_data['address']
registration_obj.password = registration_form.cleaned_data['password']
registration_obj.confirm_password = registration_form.cleaned_data[
'confirm_password']
registration_obj.pickup_arrangement = registration_form.cleaned_data[
'pickup_arrangement']
#registration_obj.tool_pickup_preference = registration_form.cleaned_data['tool_pickup_preference']
# registration_obj.tool_location = registration_form.cleaned_data['tool_location']
registration_obj.save()
return HttpResponseRedirect('/')
return render(request, 'register.html', reg_context)
def setup(self):
super(TestFacebookAccountModel, self).setup()
# Create a default user to use for these tests
self.user = usermodels.User(full_name='Silly Person',
first_name="Silly")
self.user.put()
def handle(self, *args, **options):
"""
username, password, email, phone, is_staff = 1
:param args:
:param options:
:return:
"""
faker = Faker(locale="zh_CN")
try:
user_list = []
num = options['num']
print(num)
for i in range(num[0]):
print(i)
user_obj = models.User(username=faker.name(),
password=make_password(
faker.password()),
email=faker.email(),
phone=faker.phone_number(),
is_staff=1)
print(user_obj)
user_list.append(user_obj)
print(user_list)
models.User.objects.bulk_create(user_list)
except:
raise CommandError('%s用户名已存在请重试' % faker.name())
self.stdout.write('用户创建成功')
def commit(self):
u = umod.User()
u.first_name = form.cleaned_data.get('first_name')
u.last_name = form.cleaned_data.get('last_name')
u.email = form.cleaned_data.get('email')
u.username = form.cleaned_data.get('username')
u.set_password(form.cleaned_data.get('password'))
u.save()
def setup(self):
super(TestGameModel, self).setup()
self.user = usermodels.User(full_name='Rowan Atkinson',
first_name="Rowan")
self.user.put()
self.cat = models.SportCategory(name='Basketball')
self.cat.put()
def create_user(db: Session, user_data: schemas.UserCreate):
user_dict = user_data.dict()
unhashed_password = user_dict.pop('password')
hashed_password = get_password_hash(unhashed_password)
user_dict['password_hash'] = hashed_password
user = models.User(**user_dict)
db.add(user)
db.commit()
db.refresh(user)
return user
def test_blank_last_name(self):
user = models.User(email="*****@*****.**",
password="******",
first_name="haha",
last_name="")
with self.assertValidationErrors(
self,
fields=['last_name'],
messages=['This field cannot be blank.']):
user.save()
def test_blank_email(self):
user = models.User(password="******",
first_name="haha",
last_name="hihihi")
with self.assertValidationErrors(self,
fields=['email'],
messages=[
'This field cannot be blank.'
]):
user.save()
self.assertEqual(user.id, None)
def _invalid_email(self, email):
user = models.User(email=email,
password="******",
first_name="haha",
last_name="hihihi")
with self.assertValidationErrors(self,
fields=['email'],
messages=[
'Enter a valid email address.'
]):
user.save()
self.assertEqual(user.id, None)
def test_create(self):
user = models.User(
email="*****@*****.**",
first_name="First",
last_name="Last",
)
models.create_partner_user(None, user, True)
self.assertTrue(
models.User.objects.filter(email="*****@*****.**").exists())
self.assertTrue(
models.UserProfile.objects.filter(
user__email="*****@*****.**").exists())
def get_or_create_user(self):
data = {}
phone_number = self.data.get('phone_number')
user_instance = models.User.query.filter_by(
username=phone_number).first()
if user_instance:
return user_instance
data.update(self.get_full_name())
data['username'] = phone_number
user_instance = models.User(**data)
db.session.add(user_instance)
db.session.commit()
return user_instance
def register(db: Session, user: validators.RegisterValidator):
response = {}
if db.query(models.User).filter(models.User.email == user.email).first():
response.update({"error": "email already exists"})
elif db.query(
models.User).filter(models.User.username == user.username).first():
response.update({"error": "username already exists"})
else:
user = user.dict()
user['password'] = gen_hash(user['password'])
db_user = models.User(**user)
db.add(db_user)
db.commit()
#create_update_public_room(db, db_user)
return response
def commit(self):
'''Process the form action'''
u = umod.User()
u.username = self.cleaned_data.get('username')
u.email = self.cleaned_data.get('email')
u.set_password(self.cleaned_data.get('password'))
u.first_name = self.cleaned_data.get('first_name')
u.last_name = self.cleaned_data.get('last_name')
u.save()
login(self.request, u, backend='django.contrib.auth.backends.ModelBackend')
def handle(self, *args, **options):
db_session = DBSession()
city = db_session.query(
models.City).filter_by(name=options['city']).first()
date_of_birth = datetime.datetime.strptime(options['date_of_birth'],
'%Y-%m-%d').date()
user = models.User(email=options['email'],
first_name=options['first_name'],
second_name=options['second_name'],
patronymic=options['patronymic'],
date_of_birth=date_of_birth,
city=city)
user.set_password(options['password'])
db_session.add(user)
db_session.commit()
def save(self):
user = user_models.User(
username=self.validated_data['username'],
first_name=self.validated_data['first_name'],
last_name=self.validated_data['last_name'],
email=self.validated_data['email']
)
password = self.validated_data['password']
confirm_password = self.validated_data['confirm_password']
if password != confirm_password:
raise serializers.ValidationError(
{'password': '******'})
user.set_password(password)
user.save()
return user
def create_patient_instance(self):
data = self.data.get('patient_data')
try:
patient_user_instance = user_model.User.query.filter_by(
username=data.get('phone_number')).first()
patient_mapping_instance = user_model.UserMapping.query.filter_by(
user_id=patient_user_instance.id).first()
patient_instance = user_model.Patient.query.filter_by(
id=patient_mapping_instance.entity_id).first()
if patient_user_instance:
self.patient_instance = patient_user_instance
return
except Exception:
pass
user_data, user_mapping_data, patient_data = {}, {}, {}
validation_error = field_validation.validate_fields(
data, 'PATIENT_INFO')
if validation_error:
return validation_error
user_data['username'] = data.get('phone_number')
full_name = data.get('patient_name')
user_data.update(self.parse_full_name(full_name))
user_instance = user_model.User(**user_data)
patient_data['dob'] = parser.parse(data.get('dob'))
patient_data['gender'] = data.get('patient_gender')
patient_data['address'] = data.get('address', str())
patient_instance = user_model.Patient(**patient_data)
try:
db.session.add(user_instance)
db.session.add(patient_instance)
db.session.commit()
user_mapping_data['user_id'] = user_instance.id
user_mapping_data['entity_id'] = patient_instance.id
user_mapping8_data['entity_type'] = 'Patient'
user_mapping_data['password'] = hashlib.sha256(
data.get('phone_number').encode('utf-8')).hexdigest()
user_mapping_instance = user_model.UserMapping(**user_mapping_data)
db.session.add(user_mapping_instance)
db.session.commit()
self.patient_instance = user_instance
except (IntegrityError, ):
db.session.rollback()
db.session.delete(patient_instance)
db.session.commit()
return {'error': 'User already exists'}
def create(self, validated_data):
"""Creates a user and adds it to the database."""
user = models.User(
username=validated_data["username"],
email=validated_data["email"],
roles=validated_data["roles"],
)
if len(validated_data["password"]) > settings.MAX_PASSWORD_LENGTH:
truncated_password = validated_data["password"][
: settings.MAX_PASSWORD_LENGTH
]
else:
truncated_password = validated_data["password"]
user.set_password(truncated_password)
user.save()
return user
def create_user(request):
if request.method != 'POST':
return JsonResponse({'status':"error", 'msg':"must make POST request"})
if 'username' not in request.POST:
return JsonResponse({'status':'error', 'msg':"missing required fields:username"})
username = request.POST.get("username")
try:
u = models.User.objects.get(username=username)
return JsonResponse({'status':'error', 'msg':"user already exists!"})
except models.User.DoesNotExist:
u = models.User(
username=request.POST.get("username"),
first_name=request.POST.get("first_name"),
last_name=request.POST.get("last_name"),
email=request.POST.get("email")
)
u.save()
return JsonResponse({'status':'success','user_id': u.pk})
def form_valid(self, form):
signup_password = form.cleaned_data['password1']
email = form.cleaned_data['email']
user_count = users.User.objects.filter(auth_user__email=email).count()
if user_count == 0:
user = form.save()
user = authenticate(username=user.username,
password=signup_password)
app_user = users.User(auth_user=user)
Token(user=user).save()
app_user.save()
login(self.request, user)
else:
raise ValidationError(
"There is already a User with the given email.")
return super(SignupView, self).form_valid(form)
def commit(self):
user = umod.User()
user.first_name = self.cleaned_data.get('first_name')
user.last_name = self.cleaned_data.get('last_name')
user.username = self.cleaned_data.get('username')
user.set_password(self.cleaned_data.get('password'))
user.street = self.cleaned_data.get('street')
user.city = self.cleaned_data.get('city')
user.state = self.cleaned_data.get('state')
user.country = self.cleaned_data.get('country')
user.zipcode = self.cleaned_data.get('zipcode')
user.phone = self.cleaned_data.get('phone')
user.email = self.cleaned_data.get('email')
user.graduation_year = self.cleaned_data.get('graduation_year')
user.graduation_semester = self.cleaned_data.get('graduation_semester')
user.program = self.cleaned_data.get('program')
user.alumni = self.cleaned_data.get('alumni')
user.save()
user.groups.set(self.cleaned_data.get('groups'))
c3 = umod.Company()
c3.name = "Microsoft"
c3.city = "Seattle"
c3.state = "WA"
c3.save()
c4 = umod.Company()
c4.name = "Exxon"
c4.city = "Austin"
c4.state = "TX"
c4.save()
###############
#person stuff
#u1
u1 = umod.User()
u1.first_name = "Jennifer"
u1.last_name = "Luther"
u1.email = "*****@*****.**"
u1.username = "******"
u1.set_password("luther")
u1.alumni = False
u1.is_superuser = True
u1.save()
d1 = umod.Donation()
d1.give_back = "Money"
d1.my_choice = "Y"
d1.user = u1
d1.save()
def create_user(db: Session, user: schemas.UsersCreate):
db_users = models.User(name=user.name, last_name=user.last_name, email=user.email)
db.add(db_users)
db.commit()
db.refresh(db_users)
return db_users
def test_created_false(self):
"""If 'created' param passed in is False then do nothing"""
user = models.User(email="*****@*****.**")
models.create_partner_user(None, user, created=False)
self.assertFalse(
models.User.objects.filter(email="*****@*****.**").exists())
