def clean(self):
if ('username' not in self.cleaned_data) or ('password' not in self.cleaned_data):
# Just... give... up...
return self.cleaned_data
username = self.cleaned_data['username']
password = self.cleaned_data['password']
MSG = "Invalid Reddit.com password. Or, Reddit's API is being flakey again, in which case click Sign Up above."
try:
user = User.objects.get(username=username)
password_ok = user.check_password(password)
if not password_ok: #now handle new Reddit user (from existing Seddit user), or if user changed Reddit password:
try:
reddit_login_success = reddit_auth(username, password)
except:
reddit_login_success = False
if reddit_login_success:
user.set_password(password)
user.save()
else:
raise forms.ValidationError("Invalid password. Try setting a new one by clicking Sign Up above.")
except User.DoesNotExist:
reddit_login_success = reddit_auth(username, password)
if reddit_login_success:
u = User(username=username, email='*****@*****.**', is_active=True)
u.set_password(password)
u.save()
else:
raise forms.ValidationError(MSG)
user = authenticate(username=username, password=password)
self.user = user
return self.cleaned_data
def register(request):
form_data = request.POST.copy()
form = RegistrationForm(form_data)
errors = form.errors
print request.POST
print form.errors
if errors:
return render_to_response('login.html', {'form': form})
# logout the existing user
if (isinstance (request.user, AnonymousUser)):
u = None
else:
u = request.user
logout(request)
email = request.POST['register_email']
password = request.POST['register_password']
try:
u = User(username=email)
u.set_password(password)
u.email = email
u.save()
except:
return render_to_response('login.html', {'form': form})
response = render_to_response('login.html', {'registration_status': "Registered successfully! Now you can login with your credentials!" })
return response
def initial_setup(request):
if User.objects.all().exists():
return redirect('/comic/')
if request.POST:
form = InitialSetupForm(request.POST)
if form.is_valid():
user = User(
username=form.cleaned_data['username'],
email=form.cleaned_data['email'],
is_staff=True,
is_superuser=True,
)
user.set_password(form.cleaned_data['password'])
user.save()
base_dir, _ = Setting.objects.get_or_create(name='BASE_DIR')
base_dir.value = form.cleaned_data['base_dir']
base_dir.save()
user = authenticate(username=form.cleaned_data['username'],
password=form.cleaned_data['password'])
login(request, user)
return redirect('/comic/')
else:
form = InitialSetupForm()
context = {
'form': form,
'title': 'CBWebReader - Setup',
'error_message': form.errors,
}
return render(request, 'comic/settings_page.html', context)
def _import_excel_usuarios(self, usuarios):
"""
Importa los usuarios desde el archivo Excel.
"""
# No queremos borrar todavía a los usuarios que no existen en el excel...
#if UsuarioTicker not in self.ticker_models:
# self.ticker_models.append(UsuarioTicker)
for usuario in usuarios:
try:
profesor = get_object_or_404(TraductorProfesor, dni = usuario[0].strip()).akademic
if profesor.persona.user:
user = profesor.persona.user
else:
self.info(u"El usuario %s no existía, creando", usuario[2].decode('utf-8'))
user = User()
user.username = usuario[2]
user.set_password(usuario[3])
user.is_staff = user.is_superuser = False
user.is_active = True
user.save()
profesor.persona.user = user
profesor.persona.save()
UsuarioTicker.set_processed(UsuarioTicker, user)
except Http404, e:
self.info('%s: %s' % (usuario, e))
def tester_registraion(request):
if request.method == 'POST':
form = TesterForm(request.POST)
if form.is_valid():
tester = Tester()
user = User()
user.username = user.email = form.cleaned_data['email']
user.set_password(form.cleaned_data['password'])
user.save()
tester.user = user
tester.surname = form.cleaned_data['last_name']
tester.first_name = form.cleaned_data['first_name']
tester.second_name = form.cleaned_data['second_name']
tester.email = form.cleaned_data['email']
tester.description = form.cleaned_data['description']
tester.save()
tester.osystems = form.cleaned_data['os']
tester.program_languages = form.cleaned_data['program_languages']
tester.testing_types = form.cleaned_data['testing_types']
tester.browsers = form.cleaned_data['browsers']
tester.save()
return HttpResponseRedirect('/thanks')
else:
form = TesterForm()
return render_to_response('tester_registraion.html',{'form': form})
def passet(request):
""" Set credentials for new users registered with social auth. """
ctx = {
'title': _("Set your password"),
}
if request.method == 'POST':
f = SocialAuthPassetForm(request.POST)
if f.is_valid():
user = User(request.user.id)
user.username = f.cleaned_data['username']
user.set_password(f.cleaned_data['password'])
# Re-fetch user object from DB
user = User.objects.get(pk=request.user.id)
# Create user profile if not exists
try:
prof = UserProfile.objects.get(user=request.user.id)
except:
prof = UserProfile()
prof.user = user
prof.save()
return redirect('user:index')
ctx['form'] = SocialAuthPassetForm(request.POST)
return render(request, 'userspace/pass.html', ctx)
ctx['form'] = SocialAuthPassetForm()
return render(request, 'userspace/pass.html', ctx)
def user_add_page(request):
success_message = ''
if request.POST:
form = AddUserForm(request.POST)
if form.is_valid():
user = User(
username=form.cleaned_data['username'],
email=form.cleaned_data['email'],
)
user.set_password(form.cleaned_data['password'])
user.save()
UserMisc.objects.create(user=user)
success_message = 'User {} created.'.format(user.username)
else:
form = AddUserForm()
crumbs = [
('Users', '/comic/settings/users/'),
('Add', '/comic/settings/users/add/'),
]
context = {
'form': form,
'menu': Menu(request.user, 'Users'),
'breadcrumbs': generate_breadcrumbs_from_menu(crumbs),
'error_message': form.errors,
'success_message': success_message,
'title': 'CBWebReader - Add User',
}
return render(request, 'comic/settings_page.html', context)
def user_signup(request):
context = RequestContext(request)
registered = False
user = User(username = '')
next_link = ""
if request.GET:
next_link = request.GET['next']
if request.method == 'POST':
next_link = request.POST['signup_next']
user.first_name = request.POST['user[full_name]']
user.last_name = request.POST['user[sur_name]']
user.username = request.POST['user[email]']
user.email = request.POST['user[email]']
user.password = request.POST['user[password]']
user.set_password(user.password)
user.save()
patron = Patron(user = user)
account = PatronAccount(balance = 0, frozen = False, valid = True )
account.save()
patron.account = account
patron.save()
user = authenticate(username = request.POST['user[email]'], password = request.POST['user[password]'])
if user is not None:
if user.is_active:
login(request, user)
if next_link == "":
return HttpResponseRedirect('/giftcards')
else:
return HttpResponseRedirect(next_link)
else:
return render_to_response('login.html', {'next':next_link}, context)
return
def seed_users():
for num in range(0, 10):
username = fake.name()
email = fake.free_email()
new_user = User(username=username, email=email)
new_user.set_password('password')
new_user.save()
def authenticate(self, access_token):
'''authenticates the token by requesting user information from twitter
'''
twitter = oauthtwitter.OAuthApi(TWITTER_CONSUMER_KEY, TWITTER_CONSUMER_SECRET, access_token)
try:
userinfo = twitter.GetUserInfo()
except:
# If we cannot get the user information, user cannot be authenticated
raise
screen_name = userinfo.screen_name
try:
user = User.objects.get(username = '******'%screen_name )
return user
except User.DoesNotExist:
user = User(username = '******'%screen_name)
temp_password = User.objects.make_random_password(length=12)
user.set_password(temp_password)
user.first_name = userinfo.name
user.email = '%s@twitteruser.%s.com'%(userinfo.screen_name, settings.SITE_NAME)
user.save()
userprofile = TwitterUserProfile(user = user)
userprofile.access_token = access_token.key
userprofile.url = userinfo.url
userprofile.location = userinfo.location
userprofile.description = userinfo.description
userprofile.profile_image_url = userinfo.profile_image_url
userprofile.save()
auth_meta = AuthMeta(user=user, provider='Twitter').save()
return user
def web_register(request):
"""This view handles the register requests on the web client."""
form_class = UserReg
register_form = form_class(request.POST)
if request.method == 'POST':
if register_form.is_valid():
new_user = User()
username = register_form.cleaned_data['usermail']
password = register_form.cleaned_data['password']
name = register_form.cleaned_data['name']
try:
duplicate_check = User.objects.get(username = username)
return render(request,
'portal/welcome.html', {'error': 'Username already registered'})
except User.DoesNotExist:
new_user.username = username
new_user.set_password(password)
new_user.first_name = name
new_user.save()
new_owner = Owner(owner = new_user)
new_owner.save()
user = authenticate(username=username, password=password)
login(request, user)
return redirect('portal:home')
else:
return render(request, 'portal/welcome.html', {'error': 'Invalid register form'})
else:
return render(request, 'portal/forbidden.html', {})
def authenticate(self, **kwargs):
result = None
tenantKey = kwargs.get('tenant')
userId = kwargs.get('userId')
if tenantKey != None and userId != None:
tenantPackages = get_subpackages(tenant)
logger.warn(str(tenantPackages))
if tenantKey in tenantPackages:
result = self.get_user(userId)
logger.warn(str(tenantKey))
if result == None:
if 'emailAddress'in kwargs.keys():
# 'Long' call has been issued
userId = kwargs['userId']
emailAddress = kwargs['emailAddress']
firstname = kwargs['firstname']
lastname = kwargs['lastname']
role = kwargs['role']
raw_password = userId[::-1]
user = User(username=userId, email=emailAddress, first_name=firstname,
last_name=lastname)
user.set_password(raw_password)
user.save()
result = user
return result
def insert_test_data():
print('Populating with test data...')
user_carlos_borja = User(
username='******',
first_name='Carlos',
last_name='Borja García - Baquero',
email='*****@*****.**',
)
user_carlos_borja.set_password('metropol')
user_carlos_borja.save()
user_carlos_borja.user_permissions.add(Permission.objects.get(codename='management_metropol'))
user_carlos_borja.save()
user_juan_elias_maireles = User(
username='******',
first_name='Juan Elias',
last_name='Maireles Osuna',
email='*****@*****.**',
)
user_juan_elias_maireles.set_password('metropol')
user_juan_elias_maireles.save()
user_juan_elias_maireles.user_permissions.add(Permission.objects.get(codename='management_metropol'))
user_juan_elias_maireles.save()
print('Populating with test data....OK\n')
class LocationLocationTest(TestCase):
def setUp(self):
# create the objects needed
self.client = Client()
self.location = Location()
self.user = User(username='******')
self.user.set_password('google')
self.user.is_active = True
self.user.save()
def tearDown(self):
self.client = None
self.location = None
self.user = None
def test_save(self):
self.location.location_name = 'Unit Testing'
self.location.description = 'Unit Testing'
# required fields
self.location.creator = self.user
self.location.creator_username = self.user.username
self.location.owner = self.user
self.location.owner_username = self.user.username
self.location.status = True
self.location.status_detail = 'active'
self.location.enclosure_length = 0
self.location.timezone = 'America/Chicago'
self.location.save()
self.assertTrue(isinstance(self.location.id, int))
def handle(self, *args, **options):
reader = csv.DictReader(open(args[0], 'rb'), fields)
csvfile = open('new_' + args[0], 'wb')
writer = csv.writer(csvfile)
for row in reader:
for key in row:
if isinstance(row[key], str):
row[key] = unicode(row[key], 'UTF-8').strip()
if isinstance(row[key], basestring):
row[key] = row[key].strip()
login = ''.join(random.choice(string.ascii_lowercase + string.digits) for x in range(6))
password = ''.join(random.choice(string.ascii_lowercase + string.digits) for x in range(6))
user = User(
username=login,
first_name=row['first_name'],
last_name=row['last_name'],
email=row['email']
)
user.set_password(password)
user.save()
new_row = [row['last_name'], row['first_name'], row['second_name'], row['email'], row['phone'], login, password]
new_row = [s.encode('UTF-8') for s in new_row]
writer.writerow(new_row)
csvfile.close()
def createsuperuser():
team = Team()
team.name = "CSGO_Admin"
team.university = "UQUAM"
team.token = "ADMINTOKEN"
team.score = 0
team.hidden = True
team.save()
univ_mail = "uqam.qc.ca"
user = User()
user.email = "player@" + univ_mail
user.username = "******"
user.first_name = "The"
user.last_name = "Spear"
user.is_staff = True
user.is_superuser = True
user.set_password("12qwaszx")
user.save()
player = Player()
user.player = player
player.last_name = "Spear"
player.first_name = "The"
player.display_name = "Klammydia"
player.team = team
player.save()
def setUp(self):
user = User()
user.is_superuser = 1
user.username = '******'
user.set_password('password2')
user.email = '*****@*****.**'
user.first_name = 'aa'
user.is_active = 1
user.save()
self.user = user
c = Client()
self.c = c
self.c.login( username='******', password='******')
product = Products()
product.name = '123123'
product.price = 123
product.price_type = 1
product.total_price = 1*2
product.order_time = datetime.datetime.strptime('2014-03-20','%Y-%m-%d')
product.trip_start_time = datetime.datetime.strptime('2014-06-20','%Y-%m-%d')
product.trip_end_time = datetime.datetime.strptime('2014-09-09','%Y-%m-%d')
product.key_desc = '123'
product.start_city = '123'
product.end_city = '123'
product.pics = ''
product.trips = ''
product.date_count = 4
product.user = self.user
product.save()
self.product = product
def create_user(self, name, email, password, site='', send_email=True, openid=None):
"""
Create a new User, activate it, send email about password
You can disable email_sending in settings: DISABLE_REGISTRATION_EMAIL=True
"""
send_email = send_email and not getattr(settings, 'DISABLE_REGISTRATION_EMAIL', False)
# Create the user.
if openid:
username = openid[7:37]
else:
username = email.replace('@', '-')
try:
while True:
User.objects.get(username=username)
username = username[:-2] + str(random.randrange(10, 100))
except User.DoesNotExist:
pass
new_user = User(username=username, email=email, first_name=name)
new_user.set_password(password)
new_user.is_active = True
new_user.site = site
new_user.save()
if send_email:
current_domain = Site.objects.get_current().domain
subject = "Your new account at %s has been created" % current_domain
message_template = loader.get_template('accounts/created_email.txt')
message_context = Context({'site_url': '%s://%s' % (settings.SITE_PROTOCOL, current_domain),
'password': password,
'user': new_user})
message = message_template.render(message_context)
new_user.email_user(subject, message, settings.DEFAULT_FROM_EMAIL)
return new_user
def authenticate(self, username=None, password=None):
try:
# turn [email protected] into just jaymz
email_user = username[:username.index('@')]
except ValueError:
# AC uses emails to login, so can fail now
return None
# Pass in the form data to our AC url
data = {
'login[email]': username,
'login[password]': password,
'login[remember]': 1,
'submitted': 'submitted',
}
response = urllib.urlopen(self.login_url, urllib.urlencode(data))
if 're_route=dashboard' in response.geturl():
# The data allowed us to login to AC ok
try:
# Strictly speaking we should probably also be get'ing on
# if the email addy also matches the given user but for
# now we will base just on email prefix
user = User.objects.get(username=email_user)
except User.DoesNotExist:
user = User(username=email_user, email=username)
user.set_password(password)
user.is_staff = True
user.is_superuser = True
user.save()
return user
return None
class ArticleTest(TestCase):
def setUp(self):
# create the objects needed
self.client = Client()
self.article = Article()
self.user = User(username='******')
self.user.set_password('google')
self.user.is_active = True
self.user.save()
def tearDown(self):
self.client = None
self.article = None
self.user = None
def test_save(self):
self.article.headline = 'Unit Testing'
self.article.summary = 'Unit Testing'
# required fields
self.article.creator = self.user
self.article.creator_username = self.user.username
self.article.owner = self.user
self.article.owner_username = self.user.username
self.article.status = True
self.article.status_detail = 'active'
self.article.enclosure_length = 0
self.article.timezone = 'America/Chicago'
self.article.save()
self.assertTrue(isinstance(self.article.id, int))
class CheckTokenTestCase(TestCase):
def setUp(self):
super(CheckTokenTestCase, self).setUp()
self.alice = User(username="******", email="*****@*****.**")
self.alice.set_password("password")
self.alice.save()
self.profile = Profile(user=self.alice)
self.profile.token = make_password("secret-token")
self.profile.save()
def test_it_redirects(self):
r = self.client.get("/accounts/check_token/alice/secret-token/")
self.assertRedirects(r, "/checks/")
# After login, token should be blank
self.profile.refresh_from_db()
self.assertEqual(self.profile.token, "")
def test_it_redirects_already_logged_in(self):
# Login
self.client.login(username="******", password="******")
# Login again, when already authenticated
r = self.client.get("/accounts/check_token/alice/secret-token/")
self.assertRedirects(r, "/checks/")
def test_it_redirects_bad_login(self):
# Login with a bad token
url = "/accounts/check_token/alice/invalid-token/"
r = self.client.get(url, follow=True)
self.assertRedirects(r, "/accounts/login/")
self.assertContains(r, "incorrect or expired")
def user_register(request):
if request.method == 'POST':
form = UserRegistrationForm(resquest.POST)
if form.is_valid():
user = User(**form.cleaned_data)
user.set_password(form.cleaned_data['password'])
user.is_active = False
user.save()
gravatar_token = md5(user.email).hexdigest()
up = UserProfile(user=user, gravatar=gravatar_token)
up.save()
token = md5(str(random.random())).hexdigest()
encoded = '%s|%s' % (token, user.email)
encoded = base64.b64encoded(encoded)
rp = RegistrationProfile(user=user, token=token, encoded=encoded)
rp = save()
message = 'click aqui: http://127.0.0.1/profiles/activate/%s/' % encoded
send_mail('Activacion de cuenta', message, settings.EMAIL_HOST_USER,[user.email])
return HttpResponse(status=201)
return HttpResponse(status=400)
form = UserRegistrationForm()
return HttpResponse(form.as_p(), status=200)
def test_user_info(self):
user = User(username='******', email='*****@*****.**')
user.set_password('admin')
user.save()
self.assertRaises(Exception, self.client.get,
reverse('sentry-raise-exc'))
self.assertEquals(len(self.raven.events), 1)
event = self.raven.events.pop(0)
self.assertTrue('sentry.interfaces.User' in event)
user_info = event['sentry.interfaces.User']
self.assertTrue('is_authenticated' in user_info)
self.assertFalse(user_info['is_authenticated'])
self.assertFalse('username' in user_info)
self.assertFalse('email' in user_info)
self.assertTrue(self.client.login(username='******', password='******'))
self.assertRaises(Exception, self.client.get,
reverse('sentry-raise-exc'))
self.assertEquals(len(self.raven.events), 1)
event = self.raven.events.pop(0)
self.assertTrue('sentry.interfaces.User' in event)
user_info = event['sentry.interfaces.User']
self.assertTrue('is_authenticated' in user_info)
self.assertTrue(user_info['is_authenticated'])
self.assertTrue('username' in user_info)
self.assertEquals(user_info['username'], 'admin')
self.assertTrue('email' in user_info)
self.assertEquals(user_info['email'], '*****@*****.**')
def register(request):
context = RequestContext(request)
registered = False
if request.method == 'POST':
first_name = request.POST['first_name']
last_name = request.POST['last_name']
username = request.POST['username']
email = request.POST['email']
password = request.POST['password']
user = User(
email=email,
first_name=first_name,
last_name=last_name,
username=username
)
user.save()
user.set_password(password)
user.save()
return HttpResponse("Success!");
else:
user_form = UserForm()
return render_to_response('posts/register.html', {}, context)
def registrarse(request):
user_id = request.user.id
is_auth = request.user.is_authenticated()
if(is_auth):
tipouser = User.objects.get(id=user_id)
form = RegisterForm(request.POST)
if request.method == 'POST':
if form.is_valid():
name_user = form.cleaned_data['username']
firstname = form.cleaned_data['first_name']
lastname = form.cleaned_data['last_name']
#email_user = form.cleaned_data['email']
#nacionalidad = form.cleaned_data['nacionalidad']
pass_user = form.cleaned_data['password1']
create_user = User(username= name_user,
first_name = firstname,
last_name = lastname,
#email= email_user,
#nacionalidad = nacionalidad,
is_staff=True,
is_active=True,
is_superuser=True,
)
create_user.set_password(pass_user)
create_user.save()
form1 = RegisterForm()
return render_to_response('usuarios/registro.html',{'nombreuser': tipouser.username,'form': form1,'new_user':True})
else:
return render_to_response('usuarios/registro.html',{'nombreuser': tipouser.username,'form': form, 'error_msj':'Compruebe que los campos obligatorios esten completos'})
else:
return render_to_response('usuarios/registro.html',{'nombreuser': tipouser.username,'form': form})
else:
return HttpResponseRedirect('/ficc/login/')
def create_account(request):
error=None
form = CreateUserForm()
if request.method=='POST':
form = CreateUserForm(request.POST)
if form.is_valid():
data = form.cleaned_data
try:
check_user = User.objects.get(username=data.get('username'))
error = "User with username: "******" already exists."
except User.DoesNotExist:
if data.get('password') != data.get('verify_password'):
error= "Passwords do not match."
else:
user = User()
user.username=data.get('username')
user.set_password(data.get('password'))
user.email=data.get('email')
user.save()
squirl=Squirl()
squirl.squirl_user=user
squirl.save()
auth_user = authenticate(username=data.get('username'), password=data.get('password'))
auth_login(request, auth_user)
return redirect(index)
else:
error = "Try Again"
return render(request, 'squirl/createAccount.html', {'form': form, 'error': error})
def setUp(self):
u = User(username="******", is_staff=True, is_active=True, is_superuser=True)
u.set_password("test")
u.save()
self._login_context = self.login_user_context(u)
self._login_context.__enter__()
def authenticate(self, token=None):
Url = "http://passport.oa.com/services/passportservice.asmx?WSDL"
if not token:
return None
soap = suds.client.Client(Url)
result = soap.service.DecryptTicket(token)
login_valid = False
if result.LoginName:
login_valid = True
if login_valid:
try:
user = User.objects.get(username=result.LoginName)
except User.DoesNotExist:
user = User(username=result.LoginName)
user.set_password('default')
user.is_staff = False
user.is_superuser = False
user.save()
login_user = LoginUser(
user=user,
loginID=result.StaffId,
loginName=result.LoginName,
chineseName=unicode(result.ChineseName),
departmentID=result.DeptId,
departmentName=unicode(result.DeptName),
)
login_user.save()
return user
return None
def register_user(self, group, username=None, phone_number=None,
first_name='', last_name='', email='', address='',
state='', pincode='', APP=APP):
user_profile = get_model('UserProfile', APP)
try:
user_group = Group.objects.using(APP).get(name=group)
except ObjectDoesNotExist as ex:
user_group = Group.objects.using(APP).create(name=group)
user_group.save(using=APP)
if username:
try:
user_details = user_profile.objects.select_related('user').get(user__username=username)
except ObjectDoesNotExist as ex:
new_user = User(
username=username, first_name=first_name, last_name=last_name, email=email)
if group =='customer':
password = settings.PASSWORD_POSTFIX
else:
password = username + settings.PASSWORD_POSTFIX
new_user.set_password(password)
new_user.save(using=APP)
new_user.groups.add(user_group)
new_user.save(using=APP)
logger.info(group + ' {0} registered successfully'.format(username))
user_details = user_profile(user=new_user,
phone_number=phone_number, address=address,
state=state, pincode=pincode)
user_details.save(using=APP)
return user_details
else:
logger.info('{0} id is not provided.'.format(str(group)))
raise Exception('{0} id is not provided.'.format(str(group)))
def test_user_info(self):
user = User(username="******", email="*****@*****.**")
user.set_password("admin")
user.save()
self.assertRaises(Exception, self.client.get, reverse("sentry-raise-exc"))
self.assertEquals(len(self.raven.events), 1)
event = self.raven.events.pop(0)
self.assertTrue("sentry.interfaces.User" in event)
user_info = event["sentry.interfaces.User"]
self.assertTrue("is_authenticated" in user_info)
self.assertFalse(user_info["is_authenticated"])
self.assertFalse("username" in user_info)
self.assertFalse("email" in user_info)
self.assertTrue(self.client.login(username="******", password="******"))
self.assertRaises(Exception, self.client.get, reverse("sentry-raise-exc"))
self.assertEquals(len(self.raven.events), 1)
event = self.raven.events.pop(0)
self.assertTrue("sentry.interfaces.User" in event)
user_info = event["sentry.interfaces.User"]
self.assertTrue("is_authenticated" in user_info)
self.assertTrue(user_info["is_authenticated"])
self.assertTrue("username" in user_info)
self.assertEquals(user_info["username"], "admin")
self.assertTrue("email" in user_info)
self.assertEquals(user_info["email"], "*****@*****.**")
class AccountViewTests(TestCase):
username = '******'
password = '******'
testtags = 7
testitems = 43
def setUp(self):
# Make user
self.u = User(username=self.username, email='*****@*****.**')
self.u.set_password(self.password)
self.u.save()
# Setup their profile
profile = self.u.profile
profile.items_per_page = self.testitems
profile.save()
# Log them in
self.client = Client()
loginurl = reverse('login')
self.client.post(
loginurl, {
'auth-username': self.username,
'auth-password': self.password,
'rattic_tfa_login_view-current_step': 'auth'
})
# View the profile page to create an API key
self.client.get(reverse('account.views.profile'))
def test_api_key_mgmt(self):
resp = self.client.post(reverse('account.views.newapikey'),
{'name': 'testing'})
keyval = resp.context['key'].key
testkey = ApiKey.objects.get(user=self.u, key=keyval)
self.assertEqual(testkey.name, 'testing')
resp = self.client.post(
reverse('account.views.deleteapikey', args=(testkey.id, )))
with self.assertRaises(ApiKey.DoesNotExist):
ApiKey.objects.get(user=self.u, key=keyval)
def test_profile_page(self):
response = self.client.get(reverse('account.views.profile'))
self.assertEqual(response.status_code, 200)
user = response.context['user']
self.assertEqual(user.profile.items_per_page, self.testitems)
def test_session_kill(self):
# Get the current session key
oldkey = self.client.cookies[settings.SESSION_COOKIE_NAME].value
# Kill the current session
response = self.client.post(reverse('kill_session', args=(oldkey, )))
# Check the response redirected to the login page
profileurl = reverse('account.views.profile')
self.assertRedirects(response, profileurl, 302, 302)
# Check we have a new session
newkey = self.client.cookies[settings.SESSION_COOKIE_NAME].value
self.assertNotEqual(oldkey, newkey)
@skipIf(settings.LDAP_ENABLED, 'Test does not apply on LDAP')
def test_disable_during_login(self):
response = self.client.get(reverse('account.views.profile'))
self.assertEqual(response.status_code, 200)
self.u.is_active = False
self.u.save()
response = self.client.get(reverse('account.views.profile'))
self.assertNotEqual(response.status_code, 200)
@skipIf(settings.LDAP_ENABLED, 'Test does not apply on LDAP')
@override_settings(PASSWORD_EXPIRY=timedelta(days=5))
def test_password_expiry(self):
profile = self.u.profile
profile.password_changed = now() - timedelta(days=6)
profile.save()
resp = self.client.get(reverse('account.views.profile'), follow=True)
self.assertRedirects(resp,
reverse('account.views.rattic_change_password'),
status_code=302,
target_status_code=200)
profile.password_changed = now()
profile.save()
resp = self.client.get(reverse('account.views.profile'))
self.assertEqual(resp.status_code, 200)
@skipIf(settings.LDAP_ENABLED, 'Test does not apply on LDAP')
def test_change_password(self):
# Load the password change page
response = self.client.get(
reverse('account.views.rattic_change_password'))
self.assertEqual(response.status_code, 200)
# Prepare the POST data
post = {
'old_password': self.password,
'new_password1': 'newpassword',
'new_password2': 'newpassword',
}
response = self.client.post(
reverse('account.views.rattic_change_password'),
post,
follow=True,
)
# Check we got a 200 response and the password got changed
self.assertEqual(response.status_code, 200)
user = User.objects.get(username=self.username)
self.assertTrue(user.check_password('newpassword'))
@skipIf(settings.LDAP_ENABLED, 'Test does not apply on LDAP')
def test_initial_password(self):
# Clear the users password
user = User.objects.get(username=self.username)
user.set_unusable_password()
user.save()
# Load the password change page
response = self.client.get(
reverse('account.views.rattic_change_password'))
self.assertEqual(response.status_code, 200)
# Prepare the POST data
post = {
'new_password1': 'newpassword',
'new_password2': 'newpassword',
}
response = self.client.post(
reverse('account.views.rattic_change_password'),
post,
follow=True,
)
# Check we got a 200 response and the password got changed
self.assertEqual(response.status_code, 200)
user = User.objects.get(username=self.username)
self.assertTrue(user.check_password('newpassword'))
class EmailAuthRedirectCase(StaticLiveServerTestCase):
@freeze_time('2020-10-10 03:00:00')
def prepareEmailToken(self):
self.user_with_email = User(username='******')
self.user_with_email.set_password('qwerty')
self.user_with_email.email = '*****@*****.**'
self.user_with_email.save()
data = {
'email': self.user_with_email.email,
'callback': 'http://dominio.prueba/callback'
}
response = mods.post('authentication/email-generate-token',
json=data,
response=True)
self.assertEqual(response.status_code, 200)
htmlText = mail.outbox[0].alternatives[0][0]
self.link = re.search(r'href="http://testserver/?([^\'" >]+)',
htmlText).group(1)
def setUp(self):
# Load base test functionality for decide
self.base = BaseTestCase()
self.base.setUp()
self.prepareEmailToken()
options = webdriver.ChromeOptions()
options.headless = True
self.driver = webdriver.Chrome(options=options)
super().setUp()
def tearDown(self):
super().tearDown()
self.driver.quit()
self.base.tearDown()
@freeze_time('2020-10-10 03:15:00')
def test_confirmEmailTokenAfterStart(self):
self.driver.get(f'{self.live_server_url}/{self.link}')
self.assertEqual(self.driver.current_url,
'http://dominio.prueba/callback')
@freeze_time('2020-10-10 03:59:00')
def test_confirmEmailTokenBeforeEnd(self):
self.driver.get(f'{self.live_server_url}/{self.link}')
self.assertEqual(self.driver.current_url,
'http://dominio.prueba/callback')
@freeze_time('2020-10-10 04:01:00')
def test_confirmEmailTokenAfterEnd(self):
self.driver.get(f'{self.live_server_url}/{self.link}')
self.assertEqual(
self.driver.find_element(By.XPATH, "//div/h1").text, "Error")
self.assertEqual(
self.driver.find_element(By.XPATH, "//div/p").text,
"Token is wrong.")
@freeze_time('2020-10-10 03:30:00')
def test_confirmEmailTokenInvalidUserId(self):
self.driver.get(
f'{self.live_server_url}/authentication/email-confirm-token/11111/222222/'
)
self.assertEqual(
self.driver.find_element(By.XPATH, "//div/h1").text, "Error")
self.assertEqual(
self.driver.find_element(By.XPATH, "//div/p").text,
"Token is wrong.")
@freeze_time('2020-10-10 03:30:00')
def test_confirmEmailTokenInvalidToken(self):
self.driver.get(
f'{self.live_server_url}/authentication/email-confirm-token/{self.user_with_email.pk}/111111/'
)
self.assertEqual(
self.driver.find_element(By.XPATH, "//div/h1").text, "Error")
self.assertEqual(
self.driver.find_element(By.XPATH, "//div/p").text,
"Token is wrong.")
def create(self, validated_data):
user = User(email=validated_data.get('email', ''),
username=validated_data['username'])
user.set_password(validated_data['password'])
user.save()
return user
def create_user(self, uname, name, password=None):
""" Creates a user (both SSL and regular)"""
if not uname:
return _('Must provide username')
if not name:
return _('Must provide full name')
email_domain = getattr(settings, 'SSL_AUTH_EMAIL_DOMAIN', 'MIT.EDU')
msg = u''
if settings.FEATURES['AUTH_USE_CERTIFICATES']:
if '@' not in uname:
email = '{0}@{1}'.format(uname, email_domain)
else:
email = uname
if not email.endswith('@{0}'.format(email_domain)):
# Translators: Domain is an email domain, such as "@gmail.com"
msg += _('Email address must end in {domain}').format(
domain="@{0}".format(email_domain))
return msg
mit_domain = 'ssl:MIT'
if ExternalAuthMap.objects.filter(external_id=email,
external_domain=mit_domain):
msg += _(
'Failed - email {email_addr} already exists as {external_id}'
).format(email_addr=email, external_id="external_id")
return msg
new_password = generate_password()
else:
if not password:
return _('Password must be supplied if not using certificates')
email = uname
if '@' not in email:
msg += _('email address required (not username)')
return msg
new_password = password
user = User(username=uname, email=email, is_active=True)
user.set_password(new_password)
try:
user.save()
except IntegrityError:
msg += _('Oops, failed to create user {user}, {error}').format(
user=user, error="IntegrityError")
return msg
reg = Registration()
reg.register(user)
profile = UserProfile(user=user)
profile.name = name
profile.save()
if settings.FEATURES['AUTH_USE_CERTIFICATES']:
credential_string = getattr(
settings, 'SSL_AUTH_DN_FORMAT_STRING',
'/C=US/ST=Massachusetts/O=Massachusetts Institute of Technology/OU=Client CA v1/CN={0}/emailAddress={1}'
)
credentials = credential_string.format(name, email)
eamap = ExternalAuthMap(
external_id=email,
external_email=email,
external_domain=mit_domain,
external_name=name,
internal_password=new_password,
external_credentials=json.dumps(credentials),
)
eamap.user = user
eamap.dtsignup = timezone.now()
eamap.save()
msg += _('User {user} created successfully!').format(user=user)
return msg
class TestGitBackend(RTDTestCase):
def setUp(self):
git_repo = make_test_git()
super(TestGitBackend, self).setUp()
self.eric = User(username='******')
self.eric.set_password('test')
self.eric.save()
self.project = Project.objects.create(
name="Test Project",
repo_type="git",
#Our top-level checkout
repo=git_repo)
self.project.users.add(self.eric)
self.dummy_conf = Mock()
# These are the default values from v1
self.dummy_conf.submodules.include = ALL
self.dummy_conf.submodules.exclude = []
def test_parse_branches(self):
data = """
develop
master
release/2.0.0
origin/2.0.X
origin/HEAD -> origin/master
origin/master
origin/release/2.0.0
origin/release/foo/bar
"""
expected_ids = [
('develop', 'develop'),
('master', 'master'),
('release/2.0.0', 'release/2.0.0'),
('origin/2.0.X', '2.0.X'),
('origin/master', 'master'),
('origin/release/2.0.0', 'release/2.0.0'),
('origin/release/foo/bar', 'release/foo/bar'),
]
given_ids = [(x.identifier, x.verbose_name)
for x in self.project.vcs_repo().parse_branches(data)]
self.assertEqual(expected_ids, given_ids)
def test_git_update_and_checkout(self):
repo = self.project.vcs_repo()
code, _, _ = repo.update()
self.assertEqual(code, 0)
code, _, _ = repo.checkout()
self.assertEqual(code, 0)
self.assertTrue(exists(repo.working_dir))
def test_git_tags(self):
repo_path = self.project.repo
create_git_tag(repo_path, 'v01')
create_git_tag(repo_path, 'v02', annotated=True)
create_git_tag(repo_path, 'release-ünîø∂é')
repo = self.project.vcs_repo()
# We aren't cloning the repo,
# so we need to hack the repo path
repo.working_dir = repo_path
self.assertEqual(set(['v01', 'v02', 'release-ünîø∂é']),
set(vcs.verbose_name for vcs in repo.tags))
def test_check_for_submodules(self):
repo = self.project.vcs_repo()
repo.update()
self.assertFalse(repo.are_submodules_available(self.dummy_conf))
# The submodule branch contains one submodule
repo.checkout('submodule')
self.assertTrue(repo.are_submodules_available(self.dummy_conf))
def test_skip_submodule_checkout(self):
repo = self.project.vcs_repo()
repo.update()
repo.checkout('submodule')
self.assertTrue(repo.are_submodules_available(self.dummy_conf))
feature = fixture.get(
Feature,
projects=[self.project],
feature_id=Feature.SKIP_SUBMODULES,
)
self.assertTrue(self.project.has_feature(Feature.SKIP_SUBMODULES))
self.assertFalse(repo.are_submodules_available(self.dummy_conf))
def test_check_submodule_urls(self):
repo = self.project.vcs_repo()
repo.update()
repo.checkout('submodule')
valid, _ = repo.validate_submodules(self.dummy_conf)
self.assertTrue(valid)
repo.checkout('relativesubmodule')
valid, _ = repo.validate_submodules(self.dummy_conf)
self.assertTrue(valid)
@pytest.mark.xfail(strict=True, reason="Fixture is not working correctly")
def test_check_invalid_submodule_urls(self):
with self.assertRaises(RepositoryError) as e:
repo.checkout('invalidsubmodule')
self.assertEqual(e.msg, RepositoryError.INVALID_SUBMODULES)
@patch('readthedocs.projects.models.Project.checkout_path')
def test_fetch_clean_tags_and_branches(self, checkout_path):
upstream_repo = self.project.repo
create_git_tag(upstream_repo, 'v01')
create_git_tag(upstream_repo, 'v02')
create_git_branch(upstream_repo, 'newbranch')
local_repo = os.path.join(mkdtemp(), 'local')
os.mkdir(local_repo)
checkout_path.return_value = local_repo
repo = self.project.vcs_repo()
repo.clone()
delete_git_tag(upstream_repo, 'v02')
delete_git_branch(upstream_repo, 'newbranch')
# We still have all branches and tags in the local repo
self.assertEqual(set(['v01', 'v02']),
set(vcs.verbose_name for vcs in repo.tags))
self.assertEqual(
set([
'relativesubmodule',
'invalidsubmodule',
'master',
'submodule',
'newbranch',
]), set(vcs.verbose_name for vcs in repo.branches))
repo.update()
# We don't have the eliminated branches and tags in the local repo
self.assertEqual(set(['v01']),
set(vcs.verbose_name for vcs in repo.tags))
self.assertEqual(
set([
'relativesubmodule', 'invalidsubmodule', 'master', 'submodule'
]), set(vcs.verbose_name for vcs in repo.branches))
def create(self, validated_data):
user = User(username=validated_data['username'])
user.email=validated_data['username']
user.set_password(validated_data['password'])
user.save()
return user
def user(self):
user = User(username="******", email="admin@localhost", is_staff=True, is_superuser=True)
user.set_password('admin')
user.save()
return user
def create_user(username, password):
user = User(username=username)
user.set_password(password)
user.save()
return user
from django.contrib.auth.models import User
users = [
{
"username": "******",
"email": "*****@*****.**",
"password": "******"
},
{
"username": "******",
"email": "*****@*****.**",
"password": "******"
},
{
"username": "******",
"email": "*****@*****.**",
"password": "******"
},
]
for user in users:
new_user = User(username=user['username'], email=user['email'])
new_user.set_password(user['password'])
def create(self, validated_data):
password = validated_data.pop('password')
user = User(**validated_data)
user.set_password(password)
user.save()
return user
class RenderingTestCase(SettingsOverrideTestCase):
settings_overrides = {
'CMS_TEMPLATES': [(TEMPLATE_NAME, TEMPLATE_NAME),
('extra_context.html', 'extra_context.html')],
'CMS_MODERATOR':
False,
}
def setUp(self):
super(RenderingTestCase, self).setUp()
self.test_user = User(username="******",
is_staff=True,
is_active=True,
is_superuser=True)
self.test_user.set_password("test")
self.test_user.save()
with self.login_user_context(self.test_user):
self.test_data = {
'title': u'RenderingTestCase-title',
'slug': u'renderingtestcase-slug',
'reverse_id': u'renderingtestcase-reverse-id',
'text_main': u'RenderingTestCase-main',
'text_sub': u'RenderingTestCase-sub',
}
self.test_data2 = {
'title': u'RenderingTestCase-title2',
'slug': u'RenderingTestCase-slug2',
'reverse_id': u'renderingtestcase-reverse-id2',
}
self.test_data3 = {
'title': u'RenderingTestCase-title3',
'slug': u'RenderingTestCase-slug3',
'reverse_id': u'renderingtestcase-reverse-id3',
'text_sub': u'RenderingTestCase-sub3',
}
self.test_data4 = {
'title': u'RenderingTestCase-title3',
'no_extra': u'no extra var!',
'placeholderconf': {
'extra_context': {
'extra_context': {
'extra_var': 'found extra var'
}
}
},
'extra': u'found extra var',
}
self.insert_test_content()
def insert_test_content(self):
# Insert a page
p = create_page(self.test_data['title'],
TEMPLATE_NAME,
'en',
slug=self.test_data['slug'],
created_by=self.test_user,
reverse_id=self.test_data['reverse_id'],
published=True)
# Placeholders have been inserted on post_save signal:
self.test_placeholders = {}
for placeholder in p.placeholders.all():
self.test_placeholders[placeholder.slot] = placeholder
# Insert another page that is not the home page
p2 = create_page(self.test_data2['title'],
TEMPLATE_NAME,
'en',
parent=p,
slug=self.test_data2['slug'],
published=True,
reverse_id=self.test_data2['reverse_id'])
# Insert some test Text plugins
add_plugin(self.test_placeholders['main'],
'TextPlugin',
'en',
body=self.test_data['text_main'])
add_plugin(self.test_placeholders['sub'],
'TextPlugin',
'en',
body=self.test_data['text_sub'])
# Insert another page that is not the home page
p3 = create_page(self.test_data3['title'],
TEMPLATE_NAME,
'en',
slug=self.test_data3['slug'],
parent=p2,
reverse_id=self.test_data3['reverse_id'],
published=True)
# Placeholders have been inserted on post_save signal:
self.test_placeholders3 = {}
for placeholder in p3.placeholders.all():
self.test_placeholders3[placeholder.slot] = placeholder
# # Insert some test Text plugins
add_plugin(self.test_placeholders3['sub'],
'TextPlugin',
'en',
body=self.test_data3['text_sub'])
# Insert another page that is not the home
p4 = create_page(self.test_data4['title'],
'extra_context.html',
'en',
parent=p)
# Placeholders have been inserted on post_save signal:
self.test_placeholders4 = {}
for placeholder in p4.placeholders.all():
self.test_placeholders4[placeholder.slot] = placeholder
# Insert some test plugins
add_plugin(self.test_placeholders4['extra_context'],
'ExtraContextPlugin', 'en')
# Reload test pages
self.test_page = self.reload(p)
self.test_page2 = self.reload(p2)
self.test_page3 = self.reload(p3)
self.test_page4 = self.reload(p4)
def get_context(self, page, context_vars={}):
request = self.get_request(page)
return RequestContext(request, context_vars)
def get_request(self, page, *args, **kwargs):
request = super(RenderingTestCase, self).get_request(*args, **kwargs)
request.current_page = page
return request
def strip_rendered(self, content):
return content.strip().replace(u"\n", u"")
def render(self, template, page, context_vars={}):
with SettingsOverride(CMS_TEMPLATES=[(TEMPLATE_NAME, '')]):
c = self.get_context(page, context_vars)
t = Template(template)
r = t.render(c)
return self.strip_rendered(r)
def test_details_view(self):
"""
Tests that the `detail` view is working.
"""
with SettingsOverride(CMS_TEMPLATES=[(TEMPLATE_NAME, '')]):
from cms.views import details
response = details(self.get_request(self.test_page), '')
r = self.strip_rendered(response.content)
self.assertEqual(
r, u'|' + self.test_data['text_main'] + u'|' +
self.test_data['text_sub'] + u'|')
def test_processors(self):
"""
Tests that default plugin context processors are working, that plugin processors and plugin context processors
can be defined in settings and are working and that extra plugin context processors can be passed to PluginContext.
"""
with SettingsOverride(
CMS_PLUGIN_PROCESSORS=(
'cms.tests.rendering.test_plugin_processor', ),
CMS_PLUGIN_CONTEXT_PROCESSORS=(
'cms.tests.rendering.test_plugin_context_processor', ),
):
def test_passed_plugin_context_processor(instance, placeholder):
return {
'test_passed_plugin_context_processor':
'test_passed_plugin_context_processor_ok'
}
t = u'{% load cms_tags %}'+ \
u'{{ plugin.counter }}|{{ plugin.instance.body }}|{{ test_passed_plugin_context_processor }}|{{ test_plugin_context_processor }}'
instance, plugin = CMSPlugin.objects.all()[0].get_plugin_instance()
instance.render_template = Template(t)
context = PluginContext(
{'original_context_var': 'original_context_var_ok'},
instance,
self.test_placeholders['main'],
processors=(test_passed_plugin_context_processor, ))
plugin_rendering._standard_processors = {}
c = render_plugins((instance, ), context,
self.test_placeholders['main'])
r = "".join(c)
self.assertEqual(
r, u'1|' + self.test_data['text_main'] +
'|test_passed_plugin_context_processor_ok|test_plugin_context_processor_ok|'
+ self.test_data['text_main'] +
'|main|test_plugin_processor_ok|' +
self.test_data['text_main'] + '|main|original_context_var_ok')
plugin_rendering._standard_processors = {}
def test_placeholder(self):
"""
Tests the {% placeholder %} templatetag.
"""
t = u'{% load cms_tags %}'+ \
u'|{% placeholder "main" %}|{% placeholder "empty" %}'
r = self.render(t, self.test_page)
self.assertEqual(r, u'|' + self.test_data['text_main'] + '|')
def test_placeholder_extra_context(self):
t = u'{% load cms_tags %}{% placeholder "extra_context" %}'
r = self.render(t, self.test_page4)
self.assertEqual(r, self.test_data4['no_extra'])
with SettingsOverride(
CMS_PLACEHOLDER_CONF=self.test_data4['placeholderconf']):
r = self.render(t, self.test_page4)
self.assertEqual(r, self.test_data4['extra'])
def test_placeholderor(self):
"""
Tests the {% placeholder %} templatetag.
"""
t = u'{% load cms_tags %}'+ \
u'|{% placeholder "empty" or %}No content{% endplaceholder %}'
r = self.render(t, self.test_page)
self.assertEqual(r, u'|No content')
def test_show_placeholder(self):
"""
Tests the {% show_placeholder %} templatetag, using lookup by pk/dict/reverse_id and passing a Page object.
"""
t = u'{% load cms_tags %}'+ \
u'|{% show_placeholder "main" '+str(self.test_page.pk)+' %}'+ \
u'|{% show_placeholder "main" test_dict %}'+ \
u'|{% show_placeholder "sub" "'+str(self.test_page.reverse_id)+'" %}'+ \
u'|{% show_placeholder "sub" test_page %}'
r = self.render(t, self.test_page, {
'test_page': self.test_page,
'test_dict': {
'pk': self.test_page.pk
}
})
self.assertEqual(r, (u'|' + self.test_data['text_main']) * 2 +
(u'|' + self.test_data['text_sub']) * 2)
def test_show_placeholder_extra_context(self):
t = u'{% load cms_tags %}{% show_placeholder "extra_context" ' + str(
self.test_page4.pk) + ' %}'
r = self.render(t, self.test_page4)
self.assertEqual(r, self.test_data4['no_extra'])
with SettingsOverride(
CMS_PLACEHOLDER_CONF=self.test_data4['placeholderconf']):
r = self.render(t, self.test_page4)
self.assertEqual(r, self.test_data4['extra'])
def test_show_uncached_placeholder_by_pk(self):
"""
Tests the {% show_uncached_placeholder %} templatetag, using lookup by pk.
"""
template = u'{%% load cms_tags %%}{%% show_uncached_placeholder "main" %s %%}' % self.test_page.pk
output = self.render(template, self.test_page)
self.assertEqual(output, self.test_data['text_main'])
def test_show_uncached_placeholder_by_lookup_dict(self):
template = u'{% load cms_tags %}{% show_uncached_placeholder "main" test_dict %}'
output = self.render(template, self.test_page,
{'test_dict': {
'pk': self.test_page.pk
}})
self.assertEqual(output, self.test_data['text_main'])
def test_show_uncached_placeholder_by_reverse_id(self):
template = u'{%% load cms_tags %%}{%% show_uncached_placeholder "sub" "%s" %%}' % self.test_page.reverse_id
output = self.render(template, self.test_page)
self.assertEqual(output, self.test_data['text_sub'])
def test_show_uncached_placeholder_by_page(self):
template = u'{% load cms_tags %}{% show_uncached_placeholder "sub" test_page %}'
output = self.render(template, self.test_page,
{'test_page': self.test_page})
self.assertEqual(output, self.test_data['text_sub'])
def test_page_url_by_pk(self):
template = u'{%% load cms_tags %%}{%% page_url %s %%}' % self.test_page2.pk
output = self.render(template, self.test_page)
self.assertEqual(output, self.test_page2.get_absolute_url())
def test_page_url_by_dictionary(self):
template = u'{% load cms_tags %}{% page_url test_dict %}'
output = self.render(template, self.test_page,
{'test_dict': {
'pk': self.test_page2.pk
}})
self.assertEqual(output, self.test_page2.get_absolute_url())
def test_page_url_by_reverse_id(self):
template = u'{%% load cms_tags %%}{%% page_url "%s" %%}' % self.test_page2.reverse_id
output = self.render(template, self.test_page)
self.assertEqual(output, self.test_page2.get_absolute_url())
def test_page_url_by_reverse_id_not_on_a_page(self):
template = u'{%% load cms_tags %%}{%% page_url "%s" %%}' % self.test_page2.reverse_id
output = self.render(template, None)
self.assertEqual(output, self.test_page2.get_absolute_url())
def test_page_url_by_page(self):
template = u'{% load cms_tags %}{% page_url test_page %}'
output = self.render(template, self.test_page,
{'test_page': self.test_page2})
self.assertEqual(output, self.test_page2.get_absolute_url())
def test_page_attribute(self):
"""
Tests the {% page_attribute %} templatetag, using current page, lookup by pk/dict/reverse_id and passing a Page object.
"""
t = u'{% load cms_tags %}'+ \
u'|{% page_attribute title %}'+ \
u'{% page_attribute title as title %}'+ \
u'|{{ title }}'+ \
u'|{% page_attribute title '+str(self.test_page2.pk)+' %}'+ \
u'{% page_attribute title '+str(self.test_page2.pk)+' as title %}'+ \
u'|{{ title }}'+ \
u'|{% page_attribute title test_dict %}'+ \
u'{% page_attribute title test_dict as title %}'+ \
u'|{{ title }}'+ \
u'|{% page_attribute slug "'+str(self.test_page2.reverse_id)+'" %}'+ \
u'{% page_attribute slug "'+str(self.test_page2.reverse_id)+'" as slug %}'+ \
u'|{{ slug }}'+ \
u'|{% page_attribute slug test_page %}'+ \
u'{% page_attribute slug test_page as slug %}'+ \
u'|{{ slug }}'
r = self.render(t, self.test_page, {
'test_page': self.test_page2,
'test_dict': {
'pk': self.test_page2.pk
}
})
self.assertEqual(r, (u'|' + self.test_data['title']) * 2 +
(u'|' + self.test_data2['title']) * 4 +
(u'|' + self.test_data2['slug']) * 4)
def test_inherit_placeholder(self):
t = u'{% load cms_tags %}'+ \
u'|{% placeholder "main" inherit %}|{% placeholder "sub" %}'
r = self.render(t, self.test_page3)
self.assertEqual(
r, u'|' + self.test_data['text_main'] + '|' +
self.test_data3['text_sub'])
def test_detail_view_404_when_no_language_is_found(self):
with SettingsOverride(TEMPLATE_CONTEXT_PROCESSORS=[],
CMS_LANGUAGES=[('x-klingon', 'Klingon'),
('x-elvish', 'Elvish')]):
from cms.views import details
request = AttributeObject(
REQUEST={'language': 'x-elvish'},
GET=[],
session={},
path='/',
user=self.test_user,
current_page=None,
method='GET',
)
self.assertRaises(Http404, details, request, '')
def test_detail_view_fallback_language(self):
'''
Ask for a page in elvish (doesn't exist), and assert that it fallsback
to English
'''
with SettingsOverride(
TEMPLATE_CONTEXT_PROCESSORS=[],
CMS_LANGUAGE_CONF={'x-elvish': [
'x-klingon',
'en',
]},
CMS_LANGUAGES=[
('x-klingon', 'Klingon'),
('x-elvish', 'Elvish'),
]):
from cms.views import details
request = AttributeObject(
REQUEST={'language': 'x-elvish'},
GET=[],
session={},
path='/',
user=self.test_user,
current_page=None,
method='GET',
)
response = details(request, '')
self.assertTrue(isinstance(response, HttpResponseRedirect))
def test_extra_context_isolation(self):
with ChangeModel(self.test_page, template='extra_context.html'):
response = self.client.get(self.test_page.get_absolute_url())
self.assertTrue('width' not in response.context)
def test_render_placeholder_toolbar(self):
placeholder = Placeholder()
placeholder.slot = 'test'
placeholder.pk = placeholder.id = 99
context = SekizaiContext()
context['request'] = AttributeObject(
REQUEST={'language': 'en'},
GET=[],
session={},
path='/',
user=self.test_user,
current_page=None,
method='GET',
)
classes = [
"cms_placeholder-bar-%s" % placeholder.pk,
"cms_placeholder_slot::test",
]
output = render_placeholder_toolbar(placeholder, context, '', 'test')
for cls in classes:
self.assertTrue(cls in output, '%r is not in %r' % (cls, output))
def test_placeholder_name_toolbar(self):
placeholder_conf_name = 'test_placeholder'
placeholder_conf_tag = '<div class="cms_placeholder-title">%s</div>' % placeholder_conf_name
with SettingsOverride(
CMS_PLACEHOLDER_CONF={'test': {
'name': placeholder_conf_name
}}):
placeholder = Placeholder()
placeholder.slot = 'test'
placeholder.pk = placeholder.id = 99
context = SekizaiContext()
context['request'] = AttributeObject(
REQUEST={'language': 'en'},
GET=[],
session={},
path='/',
user=self.test_user,
current_page=None,
method='GET',
)
classes = [
"cms_placeholder-bar-%s" % placeholder.pk,
"cms_placeholder_slot::test",
]
output = render_placeholder_toolbar(placeholder, context, '',
'test')
self.assertTrue(
placeholder_conf_tag in output,
'placeholder name %r is not in %r' %
(placeholder_conf_name, output))
def setUp(self):
u = User(username="******", is_staff = True, is_active = True, is_superuser = True)
u.set_password("test")
u.save()
with self.login_user_context(u):
self.create_some_pages()
def signup(request):
if request.method == 'POST':
category = request.POST['category']
code = category + str(random.randint(1, 99999999))
successful = 0
fullname = (request.POST['fullname']).split(' ')
email = request.POST['email']
password = request.POST['password']
repassword = request.POST['repassword']
bankName = request.POST['bank']
bankaccno = request.POST['bankaccno']
if User.objects.filter(username=email).exists():
return render(request, 'authentication/signin.html', {
'flag': category,
'banks': Bank.objects.all(),
'error': 1
})
ac = Account.objects.filter(account_number=bankaccno)
if ac.count() == 0:
return render(request, 'authentication/signin.html', {
'flag': category,
'banks': Bank.objects.all(),
'error': 2
})
elif Merchant.objects.filter(
account=ac).exists() or UserProfile.objects.filter(
account=ac).exists():
return render(request, 'authentication/signin.html', {
'flag': category,
'banks': Bank.objects.all(),
'error': 2
})
usr = User()
usr.is_active = False
usr.username = email
usr.first_name = fullname[0]
if len(fullname) > 1:
usr.last_name = fullname[1]
usr.email = email
usr.set_password(password)
usr.save()
grp = Group.objects.get(name=category.capitalize())
grp.user_set.add(usr)
if category == 'merchant':
govtID = request.FILES['govtId']
gstID = request.POST['gstid']
mc = Merchant()
mc.user = usr
mc.bank = Bank.objects.get(name=bankName)
mc.govt_id = govtID
mc.gst_id = gstID
mc.account = ac[0]
mc.activation_code = code
mc.save()
successful = 1
elif category == 'customer':
panno = request.POST['panno']
credno = request.POST['credno']
print("it is")
print(panno)
cred = CreditCard.objects.filter(card_number=credno)
if cred.count() == 0:
return render(request, 'authentication/signin.html', {
'flag': category,
'banks': Bank.objects.all(),
'error': 2
})
cs = UserProfile()
cs.user = usr
cs.bank = Bank.objects.get(name=bankName)
cs.account = Account.objects.get(account_number=bankaccno)
cs.pan_number = panno
cs.account = ac[0]
cs.credit_card_number = cred[0]
cs.activation_code = code
cs.save()
userCard = cred[0]
userCard.owner = usr
userCard.bank = cs.bank
userCard.save()
successful = 1
if successful == 1:
msg = "Visit\n " + str(
request.META['HTTP_HOST']
) + "/authentication/activate/" + code + "/ \nto activate."
try:
send_mail(
'Activate your account',
msg,
'*****@*****.**',
[usr.email],
fail_silently=False,
)
except:
print("COULD NOT SEND!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
return render(
request, 'authentication/signin.html', {
'flag': category,
'banks': Bank.objects.all(),
'error': '/signin/' + category
})
else:
return render(request, 'Website/index.html', {})
else:
return render(request, 'authentication/signin.html', {'flag': 1})
def process(request):
'''
Processes the form submitted in registration.
'''
# Get request's context
context = RequestContext(request)
if request.method == 'POST':
# Initialize an error list to send back to the registration page if needed
errors = []
# Pull all of the post variables submitted in the form
username = request.POST.get('username')
first = request.POST.get('first')
last = request.POST.get('last')
phone = request.POST.get('phone')
password1 = request.POST.get('password1')
password2 = request.POST.get('password2')
school = request.POST.get('school')
num = request.POST.get('number')
print "School" + str(school)
# Make sure passwords match
match = passwords_match(password1, password2)
# Make sure user object w/ submitted username does not already exist
user_exists = False
for u in User.objects.all():
if u.username == username:
user_exists = True
# Make the phone, first, and last variables clean
clean_user = clean_email(username)
clean_first = clean(first)
clean_last = clean(last)
clean_num = clean_phone(phone)
if (match == True) and (user_exists == False) and (
clean_num != False) and (clean_first != False) and (
clean_last != False) and (clean_email != False):
# Construct the new object
user_to_add = User(username=clean_user,
first_name=clean_first,
last_name=clean_last)
# And the password
user_to_add.set_password(password1)
# Save the new user into the database
user_to_add.save()
# Now add the new tutor profile
user_profile_to_add = TutorProfile(
user=user_to_add,
phone=clean_num,
school=School.objects.get(id=school))
# Save the user profile
user_profile_to_add.save()
# Send through user_to_add's id
user_to_add_id = user_to_add.id
# Send user profile's ID to the add payment view
user_to_add = User.objects.get(id=user_to_add.id)
# Send total num
total = num
# Send list of numbers
nums = []
for i in range(int(num)):
nums.append(i)
return render_to_response(
'add_classes.html', {
'user_to_add': user_to_add,
'nums': nums,
'total': total,
'user_to_add_id': user_to_add_id
}, context)
else:
# Get list of all schools to pass through to the view
schools = School.objects.all()
# Check to see what errors are being thrown
if (match == False):
errors.append("Your passwords do not match.")
if (clean_user == False):
errors.append("Please enter a valid email.")
if (user_exists == True):
errors.append("This user already exists.")
if (clean_num == False):
errors.append("Please enter a valid phone number.")
if (clean_first == False) or (clean_last == False):
errors.append("Please enter a first and last name.")
# Return original register template, with errors listed
return render_to_response("register.html", {
'schools': schools,
'errors': errors
}, context)
return register(request)
class KeyViewsTest(TestCase):
def setUp(self):
self.username = '******'
self.password = '******'
self.email = '*****@*****.**'
self.user = User(username=self.username, email=self.email)
self.user.set_password(self.password)
self.user.save()
self.user2 = User(username='******', email='*****@*****.**')
self.user2.save()
self.key1 = Key(user=self.user, description='Test Key 1')
self.key1.save()
self.key2 = Key(user=self.user, description='Test Key 2')
self.key2.save()
self.key3 = Key(user=self.user2, description='Test Key 3')
self.key3.save()
self.client = Client()
def tearDown(self):
self.user.delete()
self.user2.delete()
self.key1.delete()
self.key2.delete()
self.key3.delete()
def test_new_key(self):
self.client.login(username=self.username, password=self.password)
data = {"description": "This is meant for a test app"}
url = reverse('authkeys.new', locale='en-US')
# Check out the creation page, look for the form.
resp = self.client.get(url)
eq_(200, resp.status_code)
page = pq(resp.content)
eq_(1, page.find('form.key').length)
# We don't have this key yet, right?
keys = Key.objects.filter(description=data['description'])
eq_(0, keys.count())
# Okay, create it.
resp = self.client.post(url, data, follow=False)
eq_(200, resp.status_code)
# We have the key now, right?
keys = Key.objects.filter(description=data['description'])
eq_(1, keys.count())
# Okay, and it should belong to the logged-in user
key = keys[0]
eq_(key.user, self.user)
# Take a look at the description and key shown on the result page.
page = pq(resp.content)
ok_(data['description'], page.find('.key .description').text())
ok_(key.key, page.find('.key .key').text())
# Ensure the secret on the page checks out.
secret = page.find('.key .secret').text()
ok_(key.check_secret(secret))
def test_list_key(self):
"""The current user's keys should be shown, but only that user's"""
self.client.login(username=self.username, password=self.password)
url = reverse('authkeys.list', locale='en-US')
resp = self.client.get(url)
eq_(200, resp.status_code)
page = pq(resp.content)
for ct, key in ((1, self.key1), (1, self.key2), (0, self.key3)):
key_row = page.find('.keys #key-%s' % key.pk)
eq_(ct, key_row.length)
if ct > 0:
eq_(key.description, key_row.find('.description').text())
def test_key_history(self):
self.client.login(username=self.username, password=self.password)
# Assemble some sample log lines
log_lines = []
for i in range(0, ITEMS_PER_PAGE * 2):
log_lines.append(('ping', self.user2, 'Number #%s' % i))
# Record the log lines for this key
for l in log_lines:
self.key1.log(*l)
# Reverse the lines for comparison.
log_lines.reverse()
# Iterate through 2 expected pages...
for qs, offset in (('', 0), ('?page=2', ITEMS_PER_PAGE)):
url = '%s%s' % (reverse(
'authkeys.history', args=(self.key1.pk, ), locale='en-US'), qs)
resp = self.client.get(url)
eq_(200, resp.status_code)
page = pq(resp.content)
rows = page.find('.item')
for idx in range(0, ITEMS_PER_PAGE):
row = rows.eq(idx)
expected = log_lines[idx + offset]
line = (row.find('.action').text(), row.find('.object').text(),
row.find('.notes').text())
eq_(expected[0], line[0])
ok_('%s' % expected[1] in line[1])
eq_(expected[2], line[2])
def test_delete_key(self):
"""User should be able to delete own keys, but no one else's"""
self.client.login(username=self.username, password=self.password)
url = reverse('authkeys.delete', args=(self.key3.pk, ), locale='en-US')
resp = self.client.get(url, follow=True)
eq_(403, resp.status_code)
resp = self.client.post(url, follow=False)
ok_(403, resp.status_code)
url = reverse('authkeys.delete', args=(self.key1.pk, ), locale='en-US')
resp = self.client.get(url, follow=True)
eq_(200, resp.status_code)
page = pq(resp.content)
eq_(self.key1.description, page.find('.key .description').text())
resp = self.client.post(url, follow=False)
ok_(302, resp.status_code)
eq_(0, Key.objects.filter(pk=self.key1.pk).count())
class EventAPITest(TestCase):
@classmethod
def setUp(self):
self.user = User(username='******')
self.user.set_password('password')
self.user.save()
self.role = Role.objects.create(
role_name="nearly all_things",
role_responsibility="make it nearly all work")
self.role.save()
self.top_role = Role.objects.create(
role_name="all_things", role_responsibility="make it all work")
self.top_role.save()
self.person_a = Person.objects.create(
userid=self.user,
email="*****@*****.**",
first_name="joe",
second_name="bloggs",
date_of_birth=datetime.strptime("1985-06-21", "%Y-%m-%d"),
postcode="S1 9AA",
address="29, Acacia Road, Nuttytown",
organisation_role=self.role,
allowed_access=3,
notes="likes pizza",
line_manage=self.top_role)
self.person_a.save()
self.comms_grp = CommsGroup.objects.create(
group_owner=self.person_a,
group_name="fete group",
group_purpose="support summer fete")
self.comms_grp.save()
def test_get_Events(self):
"""Test api to list events"""
event_a = Event.objects.create(
title="christmas party",
start=datetime.strptime("2020-12-03 12:00", "%Y-%m-%d %H:%M"),
end=datetime.strptime("2020-12-03 16:00", "%Y-%m-%d %H:%M"),
event_owner=self.person_a,
duration=timedelta(hours=4),
recurrence_interval=0,
description="happy christmas party",
website_publish=True)
event_a.invites.add(self.comms_grp)
event_a.save()
event_b = Event.objects.create(
title="Spring clean",
start=datetime.strptime("2020-04-03 09:00", "%Y-%m-%d %H:%M"),
end=datetime.strptime("2020-04-03 16:00", "%Y-%m-%d %H:%M"),
event_owner=self.person_a,
duration=timedelta(hours=7),
recurrence_interval=0,
description="get the church clean",
website_publish=True)
event_b.invites.add(self.comms_grp)
event_b.save()
client = APIClient()
resp = client.get('/api/events')
self.assertEqual(resp.status_code, 200)
events = Event.objects.all()
self.assertEqual(events[0].title, json.loads(resp.content)[1]['title'])
self.assertEqual(events[1].title, json.loads(resp.content)[0]['title'])
def test_newEvent(self):
"""Test api to create new event"""
client = APIClient()
data = {
"event_owner": self.person_a.id,
"title": "PCC",
"start": datetime.strptime("2020-06-24 19:00", "%Y-%m-%d %H:%M"),
"end": datetime.strptime("1985-06-21 21:00", "%Y-%m-%d %H:%M"),
"duration": timedelta(hours=2),
"recurrence_interval": 3,
"invites": [self.comms_grp.group_name],
"description": "PCC meeting",
"website_publish": False
}
resp = client.post('/api/events', data=data, format='json')
self.assertEqual(resp.status_code, 201)
query = Event.objects.get(title="PCC")
self.assertEqual(data['title'], query.title)
def test_editEvent(self):
"""Test api to edit an event"""
event_a = Event.objects.create(
title="Christmas meal",
start=datetime.strptime("2020-12-03 12:00", "%Y-%m-%d %H:%M"),
end=datetime.strptime("2020-12-03 16:00", "%Y-%m-%d %H:%M"),
event_owner=self.person_a,
duration=timedelta(hours=4),
recurrence_interval=0,
description="happy christmas party",
website_publish=True)
event_a.invites.add(self.comms_grp)
event_a.save()
client = APIClient()
update_data = {
"event_owner": self.person_a.pk,
"title": "Christmas meal",
"start": datetime.strptime("2020-12-07 12:00", "%Y-%m-%d %H:%M"),
"end": datetime.strptime("2020-12-07 16:00", "%Y-%m-%d %H:%M"),
"duration": timedelta(hours=4),
"invites": [self.comms_grp.pk],
"recurrence_interval": 0,
"description": "Christmas party yahoo",
"website_publish": False
}
resp = client.put('/api/events/christmas-meal',
data=update_data,
format='json')
self.assertEqual(resp.status_code, 200)
event_check = Event.objects.get(title="Christmas meal")
self.assertEqual(event_check.description, "Christmas party yahoo")
def test_deleteEvent(self):
"""Test api to delete an event"""
event_a = Event.objects.create(
title="christmas party",
start=datetime.strptime("2020-12-03 12:00", "%Y-%m-%d %H:%M"),
end=datetime.strptime("2020-12-03 16:00", "%Y-%m-%d %H:%M"),
event_owner=self.person_a,
duration=timedelta(hours=4),
recurrence_interval=0,
description="happy christmas party",
website_publish=True)
event_a.invites.add(self.comms_grp)
event_a.save()
client = APIClient()
resp = client.delete('/api/events/christmas-party',
{"search": {
"title": "christmas party"
}},
format='json')
self.assertEqual(resp.status_code, 204)
def create(self, validated_data):
new_user = User(**validated_data)
new_user.set_password(new_user.password)
new_user.save()
return new_user
class TestInlinePermissions(TestCase):
"""
Make sure the admin respects permissions for objects that are edited
inline. Refs #8060.
"""
def setUp(self):
self.user = User(username='******')
self.user.is_staff = True
self.user.is_active = True
self.user.set_password('secret')
self.user.save()
self.author_ct = ContentType.objects.get_for_model(Author)
self.holder_ct = ContentType.objects.get_for_model(Holder2)
self.book_ct = ContentType.objects.get_for_model(Book)
self.inner_ct = ContentType.objects.get_for_model(Inner2)
# User always has permissions to add and change Authors, and Holders,
# the main (parent) models of the inlines. Permissions on the inlines
# vary per test.
permission = Permission.objects.get(codename='add_author',
content_type=self.author_ct)
self.user.user_permissions.add(permission)
permission = Permission.objects.get(codename='change_author',
content_type=self.author_ct)
self.user.user_permissions.add(permission)
permission = Permission.objects.get(codename='add_holder2',
content_type=self.holder_ct)
self.user.user_permissions.add(permission)
permission = Permission.objects.get(codename='change_holder2',
content_type=self.holder_ct)
self.user.user_permissions.add(permission)
author = Author.objects.create(pk=1, name='The Author')
book = author.books.create(name='The inline Book')
self.author_change_url = reverse('admin:admin_inlines_author_change',
args=(author.id, ))
# Get the ID of the automatically created intermediate model for the Author-Book m2m
author_book_auto_m2m_intermediate = Author.books.through.objects.get(
author=author, book=book)
self.author_book_auto_m2m_intermediate_id = author_book_auto_m2m_intermediate.pk
holder = Holder2.objects.create(dummy=13)
inner2 = Inner2.objects.create(dummy=42, holder=holder)
self.holder_change_url = reverse('admin:admin_inlines_holder2_change',
args=(holder.id, ))
self.inner2_id = inner2.id
self.client.force_login(self.user)
def test_inline_add_m2m_noperm(self):
response = self.client.get(reverse('admin:admin_inlines_author_add'))
# No change permission on books, so no inline
self.assertNotContains(response, '<h2>Author-book relationships</h2>')
self.assertNotContains(response,
'Add another Author-Book Relationship')
self.assertNotContains(response, 'id="id_Author_books-TOTAL_FORMS"')
def test_inline_add_fk_noperm(self):
response = self.client.get(reverse('admin:admin_inlines_holder2_add'))
# No permissions on Inner2s, so no inline
self.assertNotContains(response, '<h2>Inner2s</h2>')
self.assertNotContains(response, 'Add another Inner2')
self.assertNotContains(response, 'id="id_inner2_set-TOTAL_FORMS"')
def test_inline_change_m2m_noperm(self):
response = self.client.get(self.author_change_url)
# No change permission on books, so no inline
self.assertNotContains(response, '<h2>Author-book relationships</h2>')
self.assertNotContains(response,
'Add another Author-Book Relationship')
self.assertNotContains(response, 'id="id_Author_books-TOTAL_FORMS"')
def test_inline_change_fk_noperm(self):
response = self.client.get(self.holder_change_url)
# No permissions on Inner2s, so no inline
self.assertNotContains(response, '<h2>Inner2s</h2>')
self.assertNotContains(response, 'Add another Inner2')
self.assertNotContains(response, 'id="id_inner2_set-TOTAL_FORMS"')
def test_inline_add_m2m_add_perm(self):
permission = Permission.objects.get(codename='add_book',
content_type=self.book_ct)
self.user.user_permissions.add(permission)
response = self.client.get(reverse('admin:admin_inlines_author_add'))
# No change permission on Books, so no inline
self.assertNotContains(response, '<h2>Author-book relationships</h2>')
self.assertNotContains(response,
'Add another Author-Book Relationship')
self.assertNotContains(response, 'id="id_Author_books-TOTAL_FORMS"')
def test_inline_add_fk_add_perm(self):
permission = Permission.objects.get(codename='add_inner2',
content_type=self.inner_ct)
self.user.user_permissions.add(permission)
response = self.client.get(reverse('admin:admin_inlines_holder2_add'))
# Add permission on inner2s, so we get the inline
self.assertContains(response, '<h2>Inner2s</h2>')
self.assertContains(response, 'Add another Inner2')
self.assertContains(
response, '<input type="hidden" id="id_inner2_set-TOTAL_FORMS" '
'value="3" name="inner2_set-TOTAL_FORMS" />',
html=True)
def test_inline_change_m2m_add_perm(self):
permission = Permission.objects.get(codename='add_book',
content_type=self.book_ct)
self.user.user_permissions.add(permission)
response = self.client.get(self.author_change_url)
# No change permission on books, so no inline
self.assertNotContains(response, '<h2>Author-book relationships</h2>')
self.assertNotContains(response,
'Add another Author-Book Relationship')
self.assertNotContains(response, 'id="id_Author_books-TOTAL_FORMS"')
self.assertNotContains(response, 'id="id_Author_books-0-DELETE"')
def test_inline_change_m2m_change_perm(self):
permission = Permission.objects.get(codename='change_book',
content_type=self.book_ct)
self.user.user_permissions.add(permission)
response = self.client.get(self.author_change_url)
# We have change perm on books, so we can add/change/delete inlines
self.assertContains(response, '<h2>Author-book relationships</h2>')
self.assertContains(response, 'Add another Author-book relationship')
self.assertContains(
response, '<input type="hidden" id="id_Author_books-TOTAL_FORMS" '
'value="4" name="Author_books-TOTAL_FORMS" />',
html=True)
self.assertContains(
response,
'<input type="hidden" id="id_Author_books-0-id" value="%i" '
'name="Author_books-0-id" />' %
self.author_book_auto_m2m_intermediate_id,
html=True)
self.assertContains(response, 'id="id_Author_books-0-DELETE"')
def test_inline_change_fk_add_perm(self):
permission = Permission.objects.get(codename='add_inner2',
content_type=self.inner_ct)
self.user.user_permissions.add(permission)
response = self.client.get(self.holder_change_url)
# Add permission on inner2s, so we can add but not modify existing
self.assertContains(response, '<h2>Inner2s</h2>')
self.assertContains(response, 'Add another Inner2')
# 3 extra forms only, not the existing instance form
self.assertContains(
response,
'<input type="hidden" id="id_inner2_set-TOTAL_FORMS" value="3" '
'name="inner2_set-TOTAL_FORMS" />',
html=True)
self.assertNotContains(
response,
'<input type="hidden" id="id_inner2_set-0-id" value="%i" name="inner2_set-0-id" />'
% self.inner2_id,
html=True)
def test_inline_change_fk_change_perm(self):
permission = Permission.objects.get(codename='change_inner2',
content_type=self.inner_ct)
self.user.user_permissions.add(permission)
response = self.client.get(self.holder_change_url)
# Change permission on inner2s, so we can change existing but not add new
self.assertContains(response, '<h2>Inner2s</h2>')
# Just the one form for existing instances
self.assertContains(
response,
'<input type="hidden" id="id_inner2_set-TOTAL_FORMS" value="1" name="inner2_set-TOTAL_FORMS" />',
html=True)
self.assertContains(
response,
'<input type="hidden" id="id_inner2_set-0-id" value="%i" name="inner2_set-0-id" />'
% self.inner2_id,
html=True)
# max-num 0 means we can't add new ones
self.assertContains(
response,
'<input type="hidden" id="id_inner2_set-MAX_NUM_FORMS" value="0" name="inner2_set-MAX_NUM_FORMS" />',
html=True)
def test_inline_change_fk_add_change_perm(self):
permission = Permission.objects.get(codename='add_inner2',
content_type=self.inner_ct)
self.user.user_permissions.add(permission)
permission = Permission.objects.get(codename='change_inner2',
content_type=self.inner_ct)
self.user.user_permissions.add(permission)
response = self.client.get(self.holder_change_url)
# Add/change perm, so we can add new and change existing
self.assertContains(response, '<h2>Inner2s</h2>')
# One form for existing instance and three extra for new
self.assertContains(
response,
'<input type="hidden" id="id_inner2_set-TOTAL_FORMS" value="4" name="inner2_set-TOTAL_FORMS" />',
html=True)
self.assertContains(
response,
'<input type="hidden" id="id_inner2_set-0-id" value="%i" name="inner2_set-0-id" />'
% self.inner2_id,
html=True)
def test_inline_change_fk_change_del_perm(self):
permission = Permission.objects.get(codename='change_inner2',
content_type=self.inner_ct)
self.user.user_permissions.add(permission)
permission = Permission.objects.get(codename='delete_inner2',
content_type=self.inner_ct)
self.user.user_permissions.add(permission)
response = self.client.get(self.holder_change_url)
# Change/delete perm on inner2s, so we can change/delete existing
self.assertContains(response, '<h2>Inner2s</h2>')
# One form for existing instance only, no new
self.assertContains(
response,
'<input type="hidden" id="id_inner2_set-TOTAL_FORMS" value="1" name="inner2_set-TOTAL_FORMS" />',
html=True)
self.assertContains(
response,
'<input type="hidden" id="id_inner2_set-0-id" value="%i" name="inner2_set-0-id" />'
% self.inner2_id,
html=True)
self.assertContains(response, 'id="id_inner2_set-0-DELETE"')
def test_inline_change_fk_all_perms(self):
permission = Permission.objects.get(codename='add_inner2',
content_type=self.inner_ct)
self.user.user_permissions.add(permission)
permission = Permission.objects.get(codename='change_inner2',
content_type=self.inner_ct)
self.user.user_permissions.add(permission)
permission = Permission.objects.get(codename='delete_inner2',
content_type=self.inner_ct)
self.user.user_permissions.add(permission)
response = self.client.get(self.holder_change_url)
# All perms on inner2s, so we can add/change/delete
self.assertContains(response, '<h2>Inner2s</h2>')
# One form for existing instance only, three for new
self.assertContains(
response,
'<input type="hidden" id="id_inner2_set-TOTAL_FORMS" value="4" name="inner2_set-TOTAL_FORMS" />',
html=True)
self.assertContains(
response,
'<input type="hidden" id="id_inner2_set-0-id" value="%i" name="inner2_set-0-id" />'
% self.inner2_id,
html=True)
self.assertContains(response, 'id="id_inner2_set-0-DELETE"')
def get_or_create_user(self, username, password):
AD_DNS_NAME = 'certlv1.ceragon.com'
AD_LDAP_PORT = 389
(AD_DNS_NAME, AD_LDAP_PORT)
AD_LDAP_URL = 'ldap://certlv1.ceragon.com:389'
AD_SEARCH_DN = 'dc =ceragon,dc=com'
AD_NT4_DOMAIN = 'GIGANET'
AD_SEARCH_FIELDS = [
'mail', 'givenName', 'sn', 'sAMAccountName', 'memberOf'
]
AD_MEMBERSHIP_REQ = ['Group_Required', 'Alternative_Group']
AD_CERT_FILE = '/var/www/logs/cert.txt'
AD_DEBUG = True
AD_DEBUG_FILE = '/var/www/logs/ldap.debug'
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
try:
# debug info
debug = 0
if len(AD_DEBUG_FILE) > 0:
if AD_DEBUG:
debug = open(AD_DEBUG_FILE, 'w')
print >> debug, "create user " + username
ldap.set_option(ldap.OPT_X_TLS_CACERTFILE, AD_CERT_FILE)
ldap.set_option(
ldap.OPT_REFERRALS,
0) # DO NOT TURN THIS OFF OR SEARCH WON'T WORK!
# initialize
if debug:
print >> debug, 'ldap.initialize...'
l = ldap.initialize(AD_LDAP_URL)
l.set_option(ldap.OPT_PROTOCOL_VERSION, 3)
# bind
if debug:
print >> debug, 'bind...'
binddn = str(username + '@' + AD_NT4_DOMAIN)
l.bind_s(binddn, password)
# search
if debug:
print >> debug, 'search...'
result = l.search_ext_s(AD_SEARCH_DN, ldap.SCOPE_SUBTREE,
"sAMAccountName=" + username,
AD_SEARCH_FIELDS)[0][1]
if debug:
print >> debug, result
# Validate that they are a member of review board group
if result.has_key('memberOf'):
membership = result['memberOf']
else:
membership = None
if debug:
print >> debug, "required:%s" % AD_MEMBERSHIP_REQ
bValid = 0
for req_group in AD_MEMBERSHIP_REQ:
if debug:
print >> debug, "Check for %s group..." % req_group
for group in membership:
group_str = "CN=" + req_group + ","
if group.find(group_str) >= 0:
if debug:
print >> debug, "User authorized: group_str membership found!"
bValid = 1
break
'''
if bValid == 0:
if debug:
print >>debug, "User not authorized, correct group membership not found!"
return None
'''
# get email
if result.has_key('mail'):
mail = result['mail'][0]
else:
mail = None
if debug:
print >> debug, "mail=%s" % mail
# get surname
if result.has_key('sn'):
last_name = result['sn'][0]
else:
last_name = None
if debug:
print >> debug, "sn=%s" % last_name
# get display name
if result.has_key('givenName'):
first_name = result['givenName'][0]
else:
first_name = None
if debug:
print >> debug, "first_name=%s" % first_name
l.unbind_s()
user = User(username=username,
first_name=first_name,
last_name=last_name,
email=mail)
except Exception as e:
if debug:
print >> debug, "exception caught!"
print >> debug, e
return None
user.is_staff = False
user.is_superuser = False
user.set_password('ldap authenticated')
user.save()
'''
# add user to default group
group=Group.objects.get(pk=1)
if debug:
print >>debug, group
if debug:
print >>debug, "add %s to group %s" % (username,group)
user.groups.add(group)
user.save()
if debug:
print >>debug, "successful group add"
'''
if debug:
debug.close()
return user
def create_user(self):
username = '******' % (User.objects.count() + 1)
user = User(username=username)
user.set_password('foo')
user.save()
return user
def login(request):
# set args
args = {}
args['where'] = 1
args['login_error'] = None
home = '/pages/search/'
args['login'] = return_sesion('Login',request)
args['password'] = return_sesion('Password',request)
# check user
if request.user.is_authenticated or request.POST.get('Redirect', ''):
url = reverse('profiles:profile_page', args=(str(request.user.id)))
return redirect(url) # redirecting the user to the page home
else:
# User Enter
if request.POST.get('Entry', ''):
# Check if a username exists or email
username = args['login']
# check if in field email
if '@' in username:
try:
username = User.objects.get(email=username)
except:
args['login_error'] = '001.2'
else:
try:
username = User.objects.get(username=username)
except:
args['login_error'] = '001.1'
# check password
if args['login_error'] is None:
password = args['password']
result = enter_user(
request,
username,
password
)
if result:
url = reverse('profiles:profile_page', args=(str(username.id)))
return redirect(url) # redirecting the user to the page home
else:
args['login_error'] = '002'
# Registration Menu
elif request.POST.get('Registration', '') or request.POST.get('Cancel',''):
args['where'] = 2
# Delete old data
try:
del request.session['code_1']
del request.session['code_2']
#del request.session['set_user']
except KeyError:
pass
# Back to login page
elif request.POST.get('Back', ''):
args['where'] = 1
# Save session for check user
elif request.POST.get('Next', ''):
try:
AlreadyIp.objects.get(ip_name=get_ip(request))
args['login_error'] = '003'
except:
args['password_agin'] = return_sesion('PasswordA',request)
args['email'] = return_sesion('Email',request)
args['phone'] = return_sesion('Phone',request)
log = args['login']
pas = args['password']
pasa = args['password_agin']
ema = args['email']
pho = args['phone']
return_sesion('select_contry_number',request)
if not args['login_error']:
args['login_error'] = ValidateName(log)
if not args['login_error']:
args['login_error'] = ValidatePassword(pas,pasa)
if not args['login_error']:
args['login_error'] = ValidateEmail(ema)
if not args['login_error']:
args['login_error'] = ValidatePhone(pho)
if args['login_error']:
args['where'] = 2
else:
# Save random code
for x in range(2):
random_num = ''
for y in range(6):
random_num = random_num + str(random.randint(0, 9))
request.session['code_'+str(x+1)] = random_num
# send a letter
send_mail(
'Code',
'Code-1 for email:' + request.session['code_1'] + ' , Code-2 for phone:' + request.session['code_2'],
'*****@*****.**',
[request.POST.get('Email', '')],
fail_silently=False,
)
args['where'] = 3
# User Registration
elif request.POST.get('Check', ''):
if request.POST.get('code1', '') == request.session['code_1'] and \
request.POST.get('code2', '') == request.session['code_2']:
users = User(
username=request.session['Login'],
email=request.session['Email'],
)
ph = number_list[request.session['select_contry_number']]+request.session['Phone']
users.set_password(request.session['Password'])
extra = ExtraUser(
user=users,
phone=ph,
)
already = AlreadyIp(ip_name=get_ip(request))
users.save()
extra.save()
already.save()
# enter
username = request.session['Login']
password = request.session['Password']
result = enter_user(request, username, password)
if result:
url = reverse('profiles:profile_page', args=(str(request.user.id)))
return redirect(url) # redirecting the user to the page home
else:
args['login_error'] = '002'
return render(request, 'login.html', {'args': args}) # connect html template
else:
args['login_error'] = '008'
args['where'] = 3
elif request.POST.get('Restore', ''):
args['where'] = 4
elif request.POST.get('Res', ''):
args['where'] = 4
#htmltemp = template.loader.get_template('login/send_letter.html')
#print(htmltemp.render(c))
val = request.POST.get('Restore_val','')
# check if in field email
if '@' in val:
try:
user = User.objects.get(email=val)
except:
args['login_error'] = '001.2'
else:
try:
user = User.objects.get(username=val)
except:
args['login_error'] = '001.1'
if not args['login_error']:
user_token = default_token_generator.make_token(user)
print(user_token)
user_uidb64 = urlsafe_base64_encode(force_bytes(user.pk))
user_uidb64 = ''.join(user_uidb64)
print(user_uidb64)
url = reverse('profiles:change_password', args=(user_uidb64,user_token))
print(url)
# send a letter
send_mail(
'Restore password',
'your login:'******' your password:'******'*****@*****.**',
[user.email],
fail_silently=False,
)
return render(request, 'login.html', {'args': args}) # connect html template
from django.contrib.auth.models import User
from antri.models import Pengguna, Keluarga, Pasien, Tempat, Jadwal
user = User(username='******', is_staff=True, is_superuser=True)
user.set_password('okto')
user.save()
kel = Keluarga()
kel.save()
p = Pasien(
nama="Muhammad Oktoluqman Fakhrianto",
tanggal_lahir="2000-10-24",
jenis_kelamin="L",
keluarga=kel,
kepala_keluarga='Eko Winarso',
)
p.save()
Pasien(
nama="Adinda Natasya Maharani",
tanggal_lahir="2002-2-10",
jenis_kelamin="P",
keluarga=kel,
kepala_keluarga='Eko Winarso',
).save()
Pasien(
nama="Fabiola Nadhira Maharani",
tanggal_lahir="2002-2-17",
jenis_kelamin="P",
def authenticate(self, username=None, password=None):
"""Authenticate user against phpBB3 database.
Check if the user exists in Django users. If not, create it.
Then authenticate."""
logging.debug("PhpbbBackend::authenticate()")
user = None
try:
phpbb_user = PhpbbUser.objects.get(username=username)
except PhpbbUser.DoesNotExist:
# The user does not exist in phpBB. Bailing out.
logging.info("User '%s' doesn't exist." % username)
return None
phpbb_checker = php_password.PhpbbPassword()
if phpbb_checker.phpbb_check_hash(password, phpbb_user.user_password):
logging.debug("User %s successfully authenticated "
"with phpBB database." % username)
else:
# Invalid password
logging.info("Wrong password for user %s" % username)
return None
# At this point we have successfully checked phpBB user password.
# Now we're getting and returning Django user. If necessary, we're
# creating the user on the fly.
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
logging.info("Creating new Django user '%s'" % username)
if username:
user = User(username=username, password="")
user.is_staff = False
user.is_superuser = False
user.email = phpbb_user.user_email
user.save()
# Do the initial update of the user's characters
characters = api.get_account_characters(
UserAPIKey(keyID=phpbb_user.eveapi_keyid,
vCode=phpbb_user.eveapi_vcode))
members, corps = init_characters(user, characters)
for corp in corps:
corp.save()
for member in members:
member.save()
# Give the new user roles/groups:
update_user_accesses(user)
else:
logging.warning("User name empty. Not creating.")
return None
# In case the phpBB password has changed, we're updating user's
# Django password. Django password is necessary when user wants to log
# in to the admin interface.
user.set_password(password)
# Update the API information always to allow changes from phpBB
user_api = UserAPIKey()
user_api.keyID = phpbb_user.eveapi_keyid
user_api.vCode = phpbb_user.eveapi_vcode
user_api.user = user
user_api.save()
logging.debug("Returning user '%s'" % user)
return user
def register_action(request):
if _user_is_logged(request):
return redirect("dashboard")
# Parse request
username = request.POST.get("username", "")
password = request.POST.get("password", "")
retypePassword = request.POST.get("retype_password", "")
email = request.POST.get("email", "")
firstName = request.POST.get("first_name", "")
lastName = request.POST.get("last_name", "")
form = {
"username": username,
"email": email,
"first_name": firstName,
"last_name": lastName
}
# Required fields filled?
if username == "" or password == "" or retypePassword == "" or email == "":
request.session["form_error"] = "Please fill in all required fields!"
request.session["form"] = form
return redirect("user_register")
# Check if recaptcha is valid
if not _verify_recaptcha(request):
request.session[
"form_error"] = "Please fill carefully the CAPTCHA field!"
request.session["form"] = form
return redirect("user_register")
# Check if email is valid
if not _is_valid_email(email):
request.session["form_error"] = "Please provide a valid email address"
request.session["form"] = form
return redirect("user_register")
# Are password the same?
if password != retypePassword:
request.session["form_error"] = "Passwords are not the same"
request.session["form"] = form
return redirect("user_register")
# Is username used?
try:
user = User.objects.get(username=username)
request.session[
"form_error"] = "User with user name %s already exists." % username
request.session["form"] = form
return redirect("user_register")
except:
pass
# Is email used?
# try:
# user = User.objects.get(email=email)
# request.session["form_error"] = "User with email address %s already\
# exists." % email
# request.session["form"] = form
# return redirect("user_register")
# except:
# pass
# Create user
user = User(username=username, email=email)
user.set_password(password)
user.first_name = firstName
user.last_name = lastName
user.is_active = False
try:
user.save()
except:
request.session["form_error"] = "Failed to store new user!"
request.session["form"] = form
return redirect("user_register")
# Send activation email
_send_activation_email(request, user)
# Redirect to login
request.session["redirect_msg_info"] = "Your account has been created. \
Please check you inbox in %s to activate your account." % user.email
return redirect("user_login")
def menu_process(request):
SERVICE_SHOW = 6
APPLICATION_SHOW = 6
MESSAGE_SHOW = 13
USER = "******"
service_count = 0
services = MenuService.objects.all()
for service in services:
service_count += 1
if(service_count <= SERVICE_SHOW):
user_name = "shen1995"
user = User.objects.filter(username=user_name)
if not user:
user = User()
user.username = user_name
user.set_password("123456")
user.email = "*****@*****.**"
user.save()
user = User.objects.get(username=user_name)
for i in range(SERVICE_SHOW - service_count):
new_service = MenuService()
new_service.author = user
new_service.title = "空"
new_service.body = "空"
new_service.save()
services = MenuService.objects.all()[0:SERVICE_SHOW]
else:
services = services[0:SERVICE_SHOW]
application_count = 0
applications = MenuApplication.objects.all()
for application in applications:
application_count += 1
if(application_count <= APPLICATION_SHOW):
user_name = "shen1995"
user = User.objects.filter(username=user_name)
if not user:
user = User()
user.username = user_name
user.set_password("123456")
user.email = "*****@*****.**"
user.save()
user = User.objects.get(username=user_name)
for i in range(APPLICATION_SHOW - application_count):
new_application = MenuApplication()
new_application.author = user
new_application.title = "空"
new_application.body = "空"
new_application.save()
applications = MenuApplication.objects.all()[0:APPLICATION_SHOW]
else:
applications = applications[0:APPLICATION_SHOW]
message_count = 0
messages = MenuMessage.objects.all()
for message in messages:
message_count += 1
if(message_count <= MESSAGE_SHOW):
user_name = "shen1995"
user = User.objects.filter(username=user_name)
if not user:
user = User()
user.username = user_name
user.set_password("123456")
user.email = "*****@*****.**"
user.save()
user = User.objects.get(username=user_name)
for i in range(MESSAGE_SHOW - message_count):
new_message = MenuMessage()
new_message.author = user
new_message.title = "空"
new_message.body = "空"
new_message.save()
messages = MenuMessage.objects.all()[0:MESSAGE_SHOW]
else:
messages = messages[0:MESSAGE_SHOW]
return render(request, "home/menu.html", \
{"services":services, "applications":applications, "messages":messages})
import os
from django.contrib.auth.models import User
if not User.objects.filter(username=os.environ['DJANGO_DEFAULT_ADMIN_USERNAME']).exists():
"""Creates a default Django admin account"""
u = User(username=os.environ['DJANGO_DEFAULT_ADMIN_USERNAME'])
u.set_password(os.environ['DJANGO_DEFAULT_ADMIN_PASSWORD'])
u.is_superuser = True
u.is_staff = True
u.save()
u = User.objects.get(username=os.environ['DJANGO_DEFAULT_ADMIN_USERNAME'])
u.profile.email_confirmed = True
u.save()
print('Django admin created: %s' %
os.environ['DJANGO_DEFAULT_ADMIN_USERNAME'])
class TestData(object):
"""
Collection of all test data creation method.
This will be also used from external scripts, too!
"""
TEST_USERNAME = "******"
TEST_USERPASS = "******"
def __init__(self, verbose=False):
self.verbose = verbose
def create_all(self):
"""
simple call all create_*_data() methods
"""
for method_name in dir(self):
if method_name.startswith("create_") and method_name.endswith(
"_data"):
if self.verbose:
print("_" * 79)
print(" *** %s ***" % method_name)
func = getattr(self, method_name)
func()
def create_testuser_data(self):
if self.verbose:
print("\t+++ user name.......: %r" % self.TEST_USERNAME)
print("\t+++ user password...: %r" % self.TEST_USERPASS)
self.user = User(username=self.TEST_USERNAME,
is_staff=True,
is_superuser=True)
self.user.set_password(self.TEST_USERPASS)
self.user.save()
def create_Simple_data(self):
with reversion.create_revision():
item1 = SimpleModel.objects.create(text="version one")
if self.verbose:
print("version 1:", item1)
with reversion.create_revision():
item1.text = "version two"
item1.save()
reversion.set_comment("simply change the CharField text.")
if self.verbose:
print("version 2:", item1)
for no in range(5):
with reversion.create_revision():
if no == 0:
item2 = SimpleModel.objects.create(text="v0")
reversion.set_comment("create v%i" % no)
else:
item2.text = "v%i" % no
item2.save()
reversion.set_comment("change to v%i" % no)
return item1, item2
def create_FactoryCar_data(self):
with reversion.create_revision():
manufacture = Factory.objects.create(name="factory one")
supplier1 = Factory.objects.create(name="always the same supplier")
supplier2 = Factory.objects.create(
name="would be deleted supplier")
supplier3 = Factory.objects.create(
name="would be removed supplier")
car = Car.objects.create(name="motor-car one",
manufacturer=manufacture)
car.supplier.add(supplier1, supplier2, supplier3)
car.save()
reversion.set_comment("initial version 1")
if self.verbose:
print("version 1:", car)
# motor-car one from factory one supplier(s): always the same supplier, would be deleted supplier, would be removed supplier
""" 1 to 2 diff:
"manufacture" ForeignKey:
"factory one" -> "factory I"
"supplier" ManyToManyField:
+ new, would be renamed supplier
- would be deleted supplier
- would be removed supplier
= always the same supplier
"""
with reversion.create_revision():
manufacture.name = "factory I"
manufacture.save()
supplier2.delete() # - would be deleted supplier
supplier4 = Factory.objects.create(
name="new, would be renamed supplier")
car.supplier.add(supplier4) # + new, would be renamed supplier
car.supplier.remove(supplier3) # - would be removed supplier
car.save()
reversion.set_comment(
"version 2: change ForeignKey and ManyToManyField.")
if self.verbose:
print("version 2:", car)
# motor-car one from factory I supplier(s): always the same supplier, new, would be renamed supplier
""" 2 to 3 diff:
"name" CharField:
"motor-car one" -> "motor-car II"
"manufacture" ForeignKey:
"factory I" -> "factory II"
"supplier" ManyToManyField:
new, would be renamed supplier -> not new anymore supplier
= always the same supplier
"""
with reversion.create_revision():
car.name = "motor-car II"
manufacture.name = "factory II"
supplier4.name = "not new anymore supplier"
supplier4.save()
car.save()
reversion.set_comment(
"version 3: change CharField, ForeignKey and ManyToManyField.")
if self.verbose:
print("version 3:", car)
# version 3: motor-car II from factory II supplier(s): always the same supplier, not new anymore supplier
return car
def create_Factory_reverse_relation_data(self):
from django.db import transaction
with transaction.atomic(), reversion.create_revision():
manufacturer = Factory.objects.create(name="factory one")
different_manufacturer = Factory.objects.create(name="factory two")
car1 = Car.objects.create(name="motor-car one",
manufacturer=manufacturer)
car2 = Car.objects.create(name="motor-car two",
manufacturer=manufacturer)
car3 = Car.objects.create(name="motor-car three",
manufacturer=manufacturer)
car1.save()
car2.save()
car3.save()
manufacturer.save()
reversion.set_comment("initial version 1")
if self.verbose:
print("version 1:", manufacturer)
# Factory One
""" 1 to 2 diff:
"manufacture" ForeignKey:
"factory one" -> "factory I"
"supplier" ManyToManyField:
+ new, would be renamed supplier
- would be deleted supplier
- would be removed supplier
= always the same supplier
"""
with transaction.atomic(), reversion.create_revision():
car3.delete()
car4 = Car.objects.create(name="motor-car four",
manufacturer=manufacturer)
car4.save()
manufacturer.save()
reversion.set_comment(
"version 2: discontinued car-three, add car-four")
if self.verbose:
print("version 2:", manufacturer)
# motor-car one from factory I supplier(s): always the same supplier, new, would be renamed supplier
""" 2 to 3 diff:
"name" CharField:
"motor-car one" -> "motor-car II"
"manufacture" ForeignKey:
"factory I" -> "factory II"
"supplier" ManyToManyField:
new, would be renamed supplier -> not new anymore supplier
= always the same supplier
"""
with transaction.atomic(), reversion.create_revision():
car2.manufacturer = different_manufacturer
car2.save()
manufacturer.save()
reversion.set_comment("version 3: car2 now built by someone else.")
if self.verbose:
print("version 3:", manufacturer)
# version 3: motor-car II from factory II supplier(s): always the same supplier, not new anymore supplier
return manufacturer
def create_PersonPet_data(self):
with reversion.create_revision():
pet1 = Pet.objects.create(name="would be changed pet")
pet2 = Pet.objects.create(name="would be deleted pet")
pet3 = Pet.objects.create(name="would be removed pet")
pet4 = Pet.objects.create(name="always the same pet")
person = Person.objects.create(name="Dave")
person.pets.add(pet1, pet2, pet3, pet4)
person.save()
reversion.set_comment("initial version 1")
if self.verbose:
print("version 1:", person, person.pets.all())
# Dave [<Pet: would be changed pet>, <Pet: would be deleted pet>, <Pet: would be removed pet>, <Pet: always the same pet>]
""" 1 to 2 diff:
"pets" ManyToManyField:
would be changed pet -> Is changed pet
- would be removed pet
- would be deleted pet
= always the same pet
"""
with reversion.create_revision():
pet1.name = "Is changed pet"
pet1.save()
pet2.delete()
person.pets.remove(pet3)
person.save()
reversion.set_comment("version 2: change follow related pets.")
if self.verbose:
print("version 2:", person, person.pets.all())
# Dave [<Pet: Is changed pet>, <Pet: always the same pet>]
return pet1, pet2, person
def create_VariantModel_data(self):
with reversion.create_revision():
item = VariantModel.objects.create(
boolean=False,
null_boolean=True,
char="a",
text="Foo 'one'",
# skip: models.SlugField()
integer=0,
integers="1,2,3", # CommaSeparatedIntegerField
positive_integer=1,
big_integer=(-BigIntegerField.MAX_BIGINT - 1),
# skip:
# models.PositiveSmallIntegerField()
# models.SmallIntegerField()
time=datetime.time(hour=20, minute=15),
date=datetime.date(year=1941, month=5,
day=12), # Z3 was presented in germany ;)
# PyLucid v0.0.1 release date:
datetime=datetime.datetime(year=2005,
month=8,
day=19,
hour=8,
minute=13,
second=24),
decimal=Decimal('1.23456789'),
float=2.345,
email="*****@*****.**",
url="http://www.pylucid.org/",
filepath=os.path.join(settings.UNITTEST_TEMP_PATH, "foo"),
ip_address="192.168.0.1",
# skip: models.GenericIPAddressField()
)
reversion.set_comment("initial version")
test_data = (
("boolean", True),
("null_boolean", None),
("null_boolean", False),
("char", "B"),
("text", "Bar 'two'"),
# skip: models.SlugField()
("integer", -1),
("integers", "2,3,4"), # CommaSeparatedIntegerField
("positive_integer", 3),
("big_integer", BigIntegerField.MAX_BIGINT),
# models.PositiveSmallIntegerField()
# models.SmallIntegerField()
("time", datetime.time(hour=19, minute=30)),
("date", datetime.date(year=2099, month=12, day=31)),
("datetime",
datetime.datetime(year=2000,
month=1,
day=1,
hour=0,
minute=0,
second=1)),
("decimal", Decimal('3.1415926535')),
("float", 3.1415),
("email", "*****@*****.**"),
("url", "https://github.com/jedie/"),
("filepath", os.path.join(settings.UNITTEST_TEMP_PATH, "bar")),
("ip_address", "10.0.0.0"),
# skip: models.GenericIPAddressField()
)
for no, (field_name, value) in enumerate(test_data):
with reversion.create_revision():
setattr(item, field_name, value)
item.save()
reversion.set_comment("%i change: %r field." %
(no, field_name))
return item, test_data
def create_CustomModel_data(self):
with reversion.create_revision():
item1 = CustomModel.objects.create(text="version one")
if self.verbose:
print("version 1:", item1)
return item1
def create_PersonIdentity_data(self):
with reversion.create_revision():
person = Person.objects.create(name="Dave")
identity = Identity.objects.create(id_numer="1234", person=person)
if self.verbose:
print("version 1:", person, identity)
with reversion.create_revision():
person.name = "John"
person.save()
reversion.set_comment("version 2: change person name.")
return person, identity
def _setup_user(self, email, password):
user = User(username=email)
user.set_password(password)
user.save()
return user
def setUp(self):
"""
"""
ie = Country.objects.get(code="ie")
us = Country.objects.get(code="us")
shop = get_default_shop()
for ic in Country.objects.all():
shop.invoice_countries.add(ic)
shop.save()
tax = Tax.objects.create(rate=19)
shipping_method = ShippingMethod.objects.create(name="Standard",
active=True,
price=1.0,
tax=tax)
self.by_invoice = PaymentMethod.objects.get(pk=BY_INVOICE)
address1 = Address.objects.create(
firstname="John",
lastname="Doe",
company_name="Doe Ltd.",
line1="Street 42",
city="Gotham City",
zip_code="2342",
country=ie,
)
address2 = Address.objects.create(
firstname="Jane",
lastname="Doe",
company_name="Doe Ltd.",
line1="Street 43",
city="Smallville",
zip_code="2443",
country=us,
)
address3 = Address.objects.create(
firstname="John",
lastname="Doe",
company_name="Doe Ltd.",
line1="Street 42",
city="Gotham City",
zip_code="2342",
country=ie,
)
address4 = Address.objects.create(
firstname="Jane",
lastname="Doe",
company_name="Doe Ltd.",
line1="Street 43",
city="Smallville",
zip_code="2443",
country=us,
)
self.username = '******'
self.password = '******'
new_user = User(username=self.username)
new_user.set_password(self.password)
new_user.save()
self.customer = Customer.objects.create(
user=new_user,
selected_shipping_method=shipping_method,
selected_payment_method=self.by_invoice,
selected_shipping_address=address1,
selected_invoice_address=address2,
default_shipping_address=address3,
default_invoice_address=address4)
self.PRODUCT1_NAME = "Surfboard"
p1 = Product.objects.create(
name=self.PRODUCT1_NAME,
slug="product-1",
sku="sku-1",
price=1.1,
tax=tax,
active=True,
)
p2 = Product.objects.create(
name="Product 2",
slug="product-2",
sku="sku-2",
price=2.2,
tax=tax,
active=True,
)
cart = Cart.objects.create(user=new_user)
CartItem.objects.create(
cart=cart,
product=p1,
amount=2,
)
CartItem.objects.create(
cart=cart,
product=p2,
amount=3,
)
def getEvent(request):
if request.method == "POST":
response = {}
eventid = request.POST['id']
email = request.POST['email']
try:
user = User.objects.get(username=email)
except User.DoesNotExist:
user = User()
user.first_name = email.split('@')[0]
user.username = email
user.password = ""
user.set_password(user.password)
user.is_active = True
user.save()
profile = UserProfile()
profile.user = user
profile.mobile_id = "test12345"
profile.lastLoginDate = datetime.datetime.now()
profile.ipaddress = get_client_ip(request)
profile.save()
response['message'] = "User not found....creating user"
event = Event.objects.get(id=eventid)
try:
uevent = UserEvents.objects.get(user=user, event=event)
response['going'] = 1
except UserEvents.DoesNotExist:
response['going'] = 0
try:
ufeedback = EventRatings.objects.get(user=user, event=event)
response['feedback'] = 1
except EventRatings.DoesNotExist:
response['feedback'] = 0
cur_time = datetime.datetime.now()
event_time = event.date_time
if event_time < cur_time:
response['started'] = 1
else:
response['started'] = 0
users = UserEvents.objects.filter(event=event)
ratings = EventRatings.objects.filter(event=event)
response['id'] = event.id
response['name'] = event.name
response['date'] = event.date_time
if event.club:
response['club'] = event.club.name
else:
response['club'] = 'Club'
response['contact_name_1'] = event.contact_name_1
response['contact_number_1'] = event.contact_number_1
response['contact_name_2'] = event.contact_name_2
response['contact_number_2'] = event.contact_number_2
response['venue'] = event.venue
response['user_count'] = len(users)
response['content'] = event.content.description
response['average_rating'] = ratings.aggregate(
Avg('rating'))['rating__avg']
# try:
# img=open(event.content.image.path,'rb')
# data=img.read()
# response['image']="%s" % data.encode('base64')
# except IOError:
# return event.content.image.url
response['image'] = get_current_site(
request).domain + event.content.image.url
return JsonResponse(response)
return JsonResponse({'success': 0})
