def testFromDjangoUser(self):
django_user = DjangoUser(username="******", password="******", date_joined=datetime(2011, 6, 9))
django_user.save()
user = User.from_django_user(django_user)
self.assertEqual(str(django_user.pk), user.user_id)
self.assertEqual("foo", user.username)
self.assertEqual("secret", user.password)
self.assertEqual(datetime(2011, 6, 9), user.date_joined)
self.assertFalse(bool(user.user_data))
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
User.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.client = Client()
self.prepared = True
def test_show_dashboard_with_django_user(self):
# create test user which is authenticated by Django, not AirOne
user = DjangoUser(username='******')
user.set_password('passwd')
user.save()
# login as the django-user
self.client.login(username='******', password='******')
resp = self.client.get(reverse('dashboard:index'))
self.assertEqual(resp.status_code, 200)
def test_model_User_profile_change_default_group(self):
username = "******"
user = DjangoUser(username=username)
user.save()
profile = user.profile
group = Group(name='testgroupname')
group.save()
profile.default_group = group
profile.save()
profile = User.objects.get(user=user)
self.assertEquals(profile.default_group, group)
def post(self, request):
if "username" in request.POST and "password" in request.POST:
try:
user = DjangoUser.objects.all().get(
username=request.POST["username"])
auth_res, info = user.userprofile.check_auth(
request.POST["password"])
if auth_res:
auth_res = auth.authenticate(
request,
username=request.POST["username"],
password=settings.DEFAULT_PASSWORD)
auth.login(request, auth_res)
user.userprofile.save()
messages.info(request, info)
return HttpResponseRedirect(reverse("luck"))
else:
messages.warning(request, info)
return HttpResponseRedirect(reverse("login"))
except DjangoUser.DoesNotExist:
user = DjangoUser(username=request.POST["username"],
password=settings.DEFAULT_PASSWORD)
user_profile = UserProfile(user=user)
auth_res, info = user_profile.check_auth(
request.POST["password"])
if auth_res:
user = DjangoUser.objects.create_user(
username=request.POST["username"],
password=settings.DEFAULT_PASSWORD)
UserProfile.objects.create(user=user)
auth_res = auth.authenticate(
request,
username=request.POST["username"],
password=settings.DEFAULT_PASSWORD)
if auth_res is not None:
auth.login(request, auth_res)
messages.info(request, info)
return HttpResponseRedirect(reverse("luck"))
else:
messages.warning(request, "unknown error")
return HttpResponseRedirect(reverse("login"))
else:
messages.warning(request, info)
return HttpResponseRedirect(reverse("login"))
else:
messages.error(request, "unknown error")
return HttpResponseRedirect(reverse("login"))
def test_model_user(self):
"Test User model"
username = "******"
password = "******"
user = DjangoUser(username=username, password=password)
user.set_password(password)
user.save()
self.assertEquals('test', user.username)
self.assertNotEquals(user.id, None)
group = Group(name='test')
group.save()
self.assertEquals('test', group.name)
self.assertNotEquals(group.id, None)
profile = User(user=user, default_group=group)
profile.save()
self.assertEquals(user, profile.user)
self.assertNotEquals(profile.id, None)
profile.delete()
group.delete()
def create_django_user(self):
"""Make a django.contrib.auth.User for this UserProfile."""
# Reusing the id will make our life easier, because we can use the
# OneToOneField as pk for Profile linked back to the auth.user
# in the future.
self.user = DjangoUser(id=self.pk)
self.user.first_name = ''
self.user.last_name = ''
self.user.username = self.username
self.user.email = self.email
self.user.password = self.password
self.user.date_joined = self.created
if self.groups.filter(rules='*:*').count():
self.user.is_superuser = self.user.is_staff = True
self.user.save()
self.save()
return self.user
def setUp(self):
self.factory = APIRequestFactory()
admin = DjangoUser(username='******', is_staff=True)
admin.save()
self.token = Token(user=admin)
self.token.save()
self.bad_token = 'asdf'
self.faces = {}
face_dir = os.path.join('api', 'tests', 'faces', 'att')
for subject in os.listdir(face_dir):
subject_dir = os.path.join(face_dir, subject)
if os.path.isdir(subject_dir):
self.faces[subject] = glob.glob(
os.path.join(subject_dir, '*.jpg'))
User.objects.create(username='******')
def test_sharing_box(self):
request = Mock()
request.user = DjangoUser()
request.APP = amo.FIREFOX
ctx = {
'request': request,
'APP': request.APP,
'LANG': translation.get_language()
}
doc = pq(sharing_box(ctx))
self.assert_(doc.html())
self.assertEquals(doc('li').length, len(sharing.SERVICES_LIST))
# Make sure services are in the right order.
for i in range(len(sharing.SERVICES_LIST)):
self.assertEquals(
doc('li').eq(i).attr('class'),
sharing.SERVICES_LIST[i].shortname)
assert doc('li a').eq(i).attr('target') in ('_blank', '_self'), (
'Sharing link target must either be blank or self.')
def test_model_message(self):
"""Test message"""
contact_type = ContactType(name='test')
contact_type.save()
contact = Contact(name='test', contact_type=contact_type)
contact.save()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
stream = MessageStream(name='test')
stream.save()
obj = Message(title='test', body='test', author=contact, stream=stream)
obj.save()
self.assertEquals('test', obj.title)
self.assertNotEquals(obj.id, None)
obj.delete()
def register(request):
if request.user.__str__() != "AnonymousUser":
return error(request, "Вы уже аутентифицированы")
if request.method == "POST":
if request.POST.get('new') == "false":
return email(request, request.user)
form = RegisterForm(request.POST)
if form.is_valid():
user = User()
user.username = form['username'].value()
user.password = form['password'].value()
user.email = form['email'].value()
user.first_name = form['first_name'].value()
user.last_name = form['last_name'].value()
user.date_of_birth = form['date_of_birth'].value()
user.save()
dj_user = DjangoUser(username=user.username,
password=user.password)
dj_user.save()
login(request, dj_user)
return email(request, user)
else:
form = RegisterForm()
return rend(request, 'store/register.html', {'form': form})
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.contact_type = ContactType(name='test')
self.contact_type.set_default_user()
self.contact_type.save()
self.contact = Contact(name='test', contact_type=self.contact_type)
self.contact.set_default_user()
self.contact.save()
self.user_contact = Contact(name='test',
related_user=self.user.get_profile(),
contact_type=self.contact_type)
self.user_contact.set_user(self.user)
self.user_contact.save()
self.stream = MessageStream(name='test')
self.stream.set_default_user()
self.stream.save()
self.mlist = MailingList(name='test', from_contact=self.contact)
self.mlist.set_default_user()
self.mlist.save()
self.message = Message(title='test',
body='test',
author=self.contact,
stream=self.stream)
self.message.set_default_user()
self.message.save()
self.client = Client()
self.prepared = True
def view(req):
show_alert = False
message = ''
name_admin = ''
last_name_admin = ''
dni_admin = ''
email = ''
password = ''
if req.method == "POST":
name_admin = req.POST.get("name-admin")
last_name_admin = req.POST.get("last-name-admin")
dni_admin = req.POST.get("dni-admin")
email = req.POST.get("email-admin").lower()
password_user = req.POST.get("password-admin")
from django.contrib.auth.models import User as DjangoUser
valid_email = email.endswith('@utp.edu.co')
email_exists = DjangoUser.objects.filter(email=email).count() != 0
dni_exists = SystemUser.objects.filter(dni=dni_admin).count() != 0
if not valid_email:
show_alert = True
message = 'El correo no es válido, únicamente correos @utp.edu.co'
elif email_exists:
show_alert = True
message = 'El correo ya existe'
elif dni_exists:
show_alert = True
message = 'El documento ya existe'
else:
user = DjangoUser(
username=email,
email=email,
first_name=name_admin,
last_name=last_name_admin,
password=password_user
)
user.save()
user.set_password(password_user)
user.save()
system_user = SystemUser(
user=user,
type_user='******',
dni=dni_admin
)
system_user.save()
return redirect('/dashboard/superuser/')
user = SystemUser.objects.get(user=req.user)
image_profile = user.image_profile
template = get_template('dashboard/create_admin.html')
ctx = {
'email': email,
'message': message,
'password': password,
'dni_admin': dni_admin,
'show_alert': show_alert,
'name_admin': name_admin,
'show_superuser_items': True,
'image_profile':image_profile,
'last_name_admin': last_name_admin
}
return HttpResponse(template.render(ctx, req))
def view(req):
show_alert = True
message = 'El registro solo se realiza para estudiantes'
name_student = ''
last_name_student = ''
dni_student = ''
email_student = ''
password1_student = ''
password2_student = ''
gender = ''
fecha_nacimiento_student = ''
if req.method == "POST":
name_student = req.POST.get("name-student")
last_name_student = req.POST.get("last-name-student")
dni_student = req.POST.get("dni-student")
email_student = req.POST.get("email-student").lower()
password1_student = req.POST.get("password1-student")
password2_student = req.POST.get("password2-student")
birth_date = req.POST.get("fecha-nacimiento-student")
gender = req.POST.get("gender")
from django.contrib.auth.models import User as DjangoUser
valid_email = email_student.endswith('@utp.edu.co')
email_exists = DjangoUser.objects.filter(
email=email_student).count() != 0
dni_exists = SystemUser.objects.filter(dni=dni_student).count() != 0
if not valid_email:
show_alert = True
message = 'El correo no es válido, únicamente correos @utp.edu.co'
elif password1_student != password2_student:
show_alert = True
message = 'las contraseñas no coinciden'
elif email_exists:
show_alert = True
message = 'El correo ya existe'
elif dni_exists:
show_alert = True
message = 'El documento de identidad ya existe'
else:
django_user = DjangoUser(username=email_student,
first_name=name_student,
last_name=last_name_student,
email=email_student)
django_user.save()
django_user.set_password(password1_student)
django_user.save()
system_user = SystemUser(user=django_user,
type_user='******',
dni=dni_student,
birth_date=birth_date,
gender=gender)
system_user.save()
return redirect('/login/')
genders = ['Masculino', 'Femenino']
template = get_template('signup/signup.html')
ctx = {
'show_Alert': show_alert,
'message': message,
'Inicio': False,
'name_student': name_student,
'last_name_student': last_name_student,
'dni_student': dni_student,
'fecha_nacimiento_student': fecha_nacimiento_student,
'genders': genders,
'gender': gender,
'email_student': email_student,
'password1_student': password1_student,
'password2_student': password2_student,
}
return HttpResponse(template.render(ctx, req))
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
User.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.contact_type = ContactType(name='test')
self.contact_type.set_default_user()
self.contact_type.save()
self.contact = Contact(name='test', contact_type=self.contact_type)
self.contact.set_default_user()
self.contact.save()
self.project = Project(name='test',
manager=self.contact,
client=self.contact)
self.project.set_default_user()
self.project.save()
self.status = TaskStatus(name='test')
self.status.set_default_user()
self.status.save()
self.milestone = Milestone(name='test',
project=self.project,
status=self.status)
self.milestone.set_default_user()
self.milestone.save()
self.task = Task(name='test',
project=self.project,
status=self.status,
priority=3)
self.task.set_default_user()
self.task.save()
self.time_slot = TaskTimeSlot(task=self.task,
details='test',
time_from=datetime.now(),
user=self.user.get_profile())
self.time_slot.set_default_user()
self.time_slot.save()
self.parent = Project(name='test')
self.parent.set_default_user()
self.parent.save()
self.parent_task = Task(name='test',
project=self.project,
status=self.status,
priority=3)
self.parent_task.set_default_user()
self.parent_task.save()
self.client = Client()
self.prepared = True
def make_a_user(self):
if not hasattr(self, "user"):
self.user = DjangoUser(username='******', password='******')
# username='******', channel_id=1, last_channel_id=1, recovery_key='top_secret')
self.user.save()
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
User.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.contact_type = ContactType(name='test')
self.contact_type.set_default_user()
self.contact_type.save()
self.contact = Contact(name='test', contact_type=self.contact_type)
self.contact.set_default_user()
self.contact.save()
self.category = Category(name='test')
self.category.set_default_user()
self.category.save()
self.equity = Equity(issue_price=10,
sell_price=10,
issuer=self.contact,
owner=self.contact)
self.equity.set_default_user()
self.equity.save()
self.asset = Asset(name='test', owner=self.contact)
self.asset.set_default_user()
self.asset.save()
self.tax = Tax(name='test', rate=10)
self.tax.set_default_user()
self.tax.save()
self.currency = Currency(code="GBP",
name="Pounds",
symbol="L",
is_default=True)
self.currency.set_default_user()
self.currency.save()
self.account = Account(name='test',
owner=self.contact,
balance_currency=self.currency)
self.account.set_default_user()
self.account.save()
self.liability = Liability(name='test',
source=self.contact,
target=self.contact,
account=self.account,
value=10,
value_currency=self.currency)
self.liability.set_default_user()
self.liability.save()
self.transaction = Transaction(name='test',
account=self.account,
source=self.contact,
target=self.contact,
value=10,
value_currency=self.currency)
self.transaction.set_default_user()
self.transaction.save()
self.client = Client()
self.prepared = True
def mock_register_user(username, password, email, affiliation, pubkey=None):
testuser = DjangoUser()
testuser.username = "******"
return testuser
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.type = ItemType(name='test')
self.type.set_default_user()
self.type.save()
self.status = ItemStatus(name='test')
self.status.set_default_user()
self.status.save()
self.field = ItemField(name='test', label='test', field_type='text')
self.field.set_default_user()
self.field.save()
self.item = Item(name='test', item_type=self.type, status=self.status)
self.item.set_default_user()
self.item.save()
self.value = ItemValue(field=self.field, item=self.item)
self.value.save()
self.servicing = ItemServicing(name='test')
self.servicing.set_default_user()
self.servicing.save()
self.client = Client()
self.prepared = True
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
User.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.contact_type = ContactType()
self.contact_type.slug = 'machine'
self.contact_type.name = 'machine'
self.contact_type.save()
self.contact = Contact()
self.contact.contact_type = self.contact_type
self.contact.set_default_user()
self.contact.save()
self.assertNotEquals(self.contact.id, None)
self.status = SaleStatus()
self.status.active = True
self.status.use_sales = True
self.status.use_leads = True
self.status.use_opportunities = True
self.status.set_default_user()
self.status.save()
self.assertNotEquals(self.status.id, None)
self.currency = Currency(code="GBP",
name="Pounds",
symbol="L",
is_default=True)
self.currency.save()
self.source = SaleSource()
self.source.active = True
self.source.save()
self.source.set_user(self.user)
self.assertNotEquals(self.source.id, None)
self.product = Product(name="Test")
self.product.product_type = 'service'
self.product.active = True
self.product.sell_price = 10
self.product.buy_price = 100
self.product.set_default_user()
self.product.save()
self.assertNotEquals(self.product.id, None)
self.subscription = Subscription()
self.subscription.client = self.contact
self.subscription.set_default_user()
self.subscription.save()
self.assertNotEquals(self.subscription.id, None)
self.lead = Lead()
self.lead.contact_method = 'email'
self.lead.status = self.status
self.lead.contact = self.contact
self.lead.set_default_user()
self.lead.save()
self.assertNotEquals(self.lead.id, None)
self.opportunity = Opportunity()
self.opportunity.lead = self.lead
self.opportunity.contact = self.contact
self.opportunity.status = self.status
self.opportunity.amount = 100
self.opportunity.amount_currency = self.currency
self.opportunity.amount_display = 120
self.opportunity.set_default_user()
self.opportunity.save()
self.assertNotEquals(self.opportunity.id, None)
self.order = SaleOrder(reference="Test")
self.order.opportunity = self.opportunity
self.order.status = self.status
self.order.source = self.source
self.order.currency = self.currency
self.order.total = 0
self.order.total_display = 0
self.order.set_default_user()
self.order.save()
self.assertNotEquals(self.order.id, None)
self.ordered_product = OrderedProduct()
self.ordered_product.product = self.product
self.ordered_product.order = self.order
self.ordered_product.rate = 0
self.ordered_product.subscription = self.subscription
self.ordered_product.set_default_user()
self.ordered_product.save()
self.assertNotEquals(self.ordered_product.id, None)
self.client = Client()
self.prepared = True
def view(req):
show_alert = False
editting_monitor = False
message = ''
id_monitor_editting = 0
name_monitor = ''
last_name_monitor = ''
dni_monitor = ''
email = ''
password = ''
gender = ''
fecha_nacimiento_monitor = ''
horas_por_cumplir = ''
if req.method == "POST" and 'delete-monitor' in req.POST:
id_monitor = req.POST.get("id_monitor")
user = SystemUser.objects.filter(pk=id_monitor)
if user.count() != 0:
user = user[0]
user.user.delete()
elif req.method == "POST" and 'create-monitor-submit' in req.POST:
name_monitor = req.POST.get("name-monitor")
last_name_monitor = req.POST.get("last-name-monitor")
dni_monitor = req.POST.get("dni-monitor")
email = req.POST.get("email-monitor").lower()
password_monitor = req.POST.get("password-monitor")
subjects = req.POST.getlist("subjects")
birth_date = req.POST.get("fecha-nacimiento-monitor")
gender = req.POST.get("gender")
horas_por_cumplir = req.POST.get("hours")
from django.contrib.auth.models import User as DjangoUser
valid_email = email.endswith('@utp.edu.co')
email_exists = DjangoUser.objects.filter(email=email).count() != 0
dni_exists = SystemUser.objects.filter(dni=dni_monitor).count() != 0
if not valid_email:
show_alert = True
message = 'El correo no es válido, únicamente correos @utp.edu.co'
elif email_exists:
show_alert = True
message = 'El correo ya existe'
elif dni_exists:
show_alert = True
message = 'El documento ya existe'
else:
django_user = DjangoUser(username=email,
first_name=name_monitor,
last_name=last_name_monitor,
password=password_monitor,
email=email)
django_user.save()
django_user.set_password(password_monitor)
django_user.save()
system_user = SystemUser(user=django_user,
type_user='******',
dni=dni_monitor,
birth_date=birth_date,
gender=gender,
hours=horas_por_cumplir)
system_user.save()
for id_subject in subjects:
subject = Subject.objects.filter(pk=id_subject)
if subject.count() != 0:
subject = subject[0]
system_user.subject_assigned.add(subject)
system_user.save()
elif req.method == "POST" and 'get-info-monitor' in req.POST:
id_monitor_editting = req.POST.get("id_monitor")
user = SystemUser.objects.filter(pk=id_monitor_editting)
if user.count() != 0:
user = user[0]
name_monitor = user.user.first_name
last_name_monitor = user.user.last_name
dni_monitor = user.dni
email = user.user.email
gender = user.gender
fecha_nacimiento_monitor = user.birth_date
horas_por_cumplir = user.hours
editting_monitor = True
elif req.method == "POST" and 'edit-monitor-submit' in req.POST:
id_monitor = req.POST.get("id_monitor")
monitor = SystemUser.objects.get(pk=id_monitor)
name_monitor = req.POST.get("name-monitor")
last_name_monitor = req.POST.get("last-name-monitor")
dni_monitor = req.POST.get("dni-monitor")
email = req.POST.get("email-monitor").lower()
subjects = req.POST.getlist("subjects")
birth_date = req.POST.get("fecha-nacimiento-monitor")
gender = req.POST.get("gender")
horas_por_cumplir = req.POST.get("hours")
from django.contrib.auth.models import User as DjangoUser
valid_email = email.endswith('@utp.edu.co')
email_exists = DjangoUser.objects.filter(email=email).count() != 0
dni_exists = SystemUser.objects.filter(dni=dni_monitor).count() != 0
if not valid_email:
show_alert = True
message = 'El correo no es válido, únicamente correos @utp.edu.co'
elif email_exists and email != monitor.user.email:
show_alert = True
message = 'El correo ya existe'
elif dni_exists and dni_monitor != monitor.dni:
show_alert = True
message = 'El documento ya existe'
else:
monitor.user.username = email
monitor.user.first_name = name_monitor
monitor.user.last_name = last_name_monitor
monitor.user.email = email
monitor.user.save()
monitor.dni = dni_monitor
monitor.birth_date = birth_date
monitor.gender = gender
if (horas_por_cumplir != ''):
monitor.hours = horas_por_cumplir
monitor.subject_assigned.clear()
monitor.save()
for id_subject in subjects:
subject = Subject.objects.filter(pk=id_subject)
if subject.count() != 0:
subject = subject[0]
monitor.subject_assigned.add(subject)
monitor.save()
monitors = SystemUser.objects.filter(type_user='******')
subjects = Subject.objects.all()
genders = ['Masculino', 'Femenino']
user = SystemUser.objects.get(user=req.user, type_user='******')
image_profile = user.image_profile
template = get_template('dashboard/admins/dashboard.html')
ctx = {
'show_alert': show_alert,
'message': message,
'monitors': monitors,
'show_admins_items': True,
'name_monitor': name_monitor,
'last_name_monitor': last_name_monitor,
'dni_monitor': dni_monitor,
'email': email,
'subjects': subjects,
'genders': genders,
'editting_monitor': editting_monitor,
'id_monitor_editting': id_monitor_editting,
'id_admin': user.pk,
'image_profile': image_profile,
'horas_por_cumplir': horas_por_cumplir,
'fecha_nacimiento_monitor': fecha_nacimiento_monitor,
'genero': gender
}
return HttpResponse(template.render(ctx, req))
def setUp(self):
"Initial Setup"
if not self.prepared:
# Clean up first
Object.objects.all().delete()
User.objects.all().delete()
# Create objects
try:
self.group = Group.objects.get(name='test')
except Group.DoesNotExist:
Group.objects.all().delete()
self.group = Group(name='test')
self.group.save()
try:
self.user = DjangoUser.objects.get(username=self.username)
self.user.set_password(self.password)
try:
self.profile = self.user.get_profile()
except Exception:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
except DjangoUser.DoesNotExist:
User.objects.all().delete()
self.user = DjangoUser(username=self.username, password='')
self.user.set_password(self.password)
self.user.save()
try:
perspective = Perspective.objects.get(name='default')
except Perspective.DoesNotExist:
Perspective.objects.all().delete()
perspective = Perspective(name='default')
perspective.set_user(self.user.get_profile())
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.contact_type = ContactType(name='test')
self.contact_type.set_default_user()
self.contact_type.save()
self.contact = Contact(name='test', contact_type=self.contact_type)
self.contact.set_default_user()
self.contact.save()
self.status = TicketStatus(name='TestStatus')
self.status.set_default_user()
self.status.save()
self.queue = TicketQueue(name='TestQueue',
default_ticket_status=self.status)
self.queue.set_default_user()
self.queue.save()
self.ticket = Ticket(name='TestTicket',
status=self.status,
queue=self.queue)
self.ticket.set_default_user()
self.ticket.save()
self.agent = ServiceAgent(related_user=self.user.get_profile(),
available_from=datetime.time(9),
available_to=datetime.time(17))
self.agent.set_default_user()
self.agent.save()
self.service = Service(name='test')
self.service.set_default_user()
self.service.save()
self.sla = ServiceLevelAgreement(name='test',
service=self.service,
client=self.contact,
provider=self.contact)
self.sla.set_default_user()
self.sla.save()
self.client = Client()
self.prepared = True
def view(req):
show_alert = False
editting_student = False
message = ''
id_student_editting = 0
name_student = ''
last_name_student = ''
dni_student = ''
email = ''
password = ''
gender = ''
fecha_nacimiento_student = ''
if req.method == "POST" and 'delete-student' in req.POST:
id_student = req.POST.get("id_student")
user = SystemUser.objects.filter(pk=id_student)
if user.count() != 0:
user = user[0]
user.user.delete()
elif req.method == "POST" and 'create-student-submit' in req.POST:
name_student = req.POST.get("name-student")
last_name_student = req.POST.get("last-name-student")
dni_student = req.POST.get("dni-student")
email = req.POST.get("email-student").lower()
password_student = req.POST.get("password-student")
birth_date = req.POST.get("fecha-nacimiento-student")
gender = req.POST.get("gender")
from django.contrib.auth.models import User as DjangoUser
valid_email = email.endswith('@utp.edu.co')
email_exists = DjangoUser.objects.filter(email=email).count() != 0
dni_exists = SystemUser.objects.filter(dni=dni_student).count() != 0
if not valid_email:
show_alert = True
message = 'El correo no es válido, únicamente correos @utp.edu.co'
elif email_exists:
show_alert = True
message = 'El correo ya existe'
elif dni_exists:
show_alert = True
message = 'El documento ya existe'
else:
django_user = DjangoUser(username=email,
first_name=name_student,
last_name=last_name_student,
password=password_student,
email=email)
django_user.save()
django_user.set_password(password_student)
django_user.save()
system_user = SystemUser(user=django_user,
type_user='******',
dni=dni_student,
birth_date=birth_date,
gender=gender)
system_user.save()
system_user.save()
elif req.method == "POST" and 'get-info-student' in req.POST:
id_student_editting = req.POST.get("id_student")
user = SystemUser.objects.filter(pk=id_student_editting)
if user.count() != 0:
user = user[0]
name_student = user.user.first_name
last_name_student = user.user.last_name
dni_student = user.dni
email = user.user.email
gender = user.gender
fecha_nacimiento_student = user.birth_date
editting_student = True
elif req.method == "POST" and 'edit-student-submit' in req.POST:
id_student = req.POST.get("id_student")
student = SystemUser.objects.get(pk=id_student)
name_student = req.POST.get("name-student")
last_name_student = req.POST.get("last-name-student")
dni_student = req.POST.get("dni-student")
email = req.POST.get("email-student").lower()
birth_date = req.POST.get("fecha-nacimiento-student")
gender = req.POST.get("gender")
from django.contrib.auth.models import User as DjangoUser
valid_email = email.endswith('@utp.edu.co')
email_exists = DjangoUser.objects.filter(email=email).count() != 0
dni_exists = SystemUser.objects.filter(dni=dni_student).count() != 0
if not valid_email:
show_alert = True
message = 'El correo no es válido, únicamente correos @utp.edu.co'
elif email_exists and email != student.user.email:
show_alert = True
message = 'El correo ya existe'
elif dni_exists and dni_student != student.dni:
show_alert = True
message = 'El documento ya existe'
else:
student.user.username = email
student.user.first_name = name_student
student.user.last_name = last_name_student
student.user.email = email
student.user.save()
student.dni = dni_student
student.birth_date = birth_date
student.gender = gender
student.save()
student.save()
students = SystemUser.objects.filter(type_user='******')
genders = ['Masculino', 'Femenino']
user = SystemUser.objects.get(user=req.user, type_user='******')
image_profile = user.image_profile
template = get_template('dashboard/admins/students.html')
ctx = {
'show_alert': show_alert,
'email': email,
'genero': gender,
'genders': genders,
'message': message,
'id_admin': user.pk,
'students': students,
'show_admins_items': True,
'dni_student': dni_student,
'name_student': name_student,
'image_profile': image_profile,
'editting_student': editting_student,
'last_name_student': last_name_student,
'id_student_editting': id_student_editting,
'fecha_nacimiento_student': fecha_nacimiento_student
}
return HttpResponse(template.render(ctx, req))
