def reserva_new(request):
form = ReservaForm()
context = {'label': 'Cadastrar', 'form': form}
if request.method == 'GET':
pk = request.GET.get('veiculo',None)
try:
veiculo = Veiculo.objects.get(pk=pk)
if not veiculo.disponivel:
form = ReservaForm(initial={'veiculo': pk})
form.set_veiculo(Veiculo.objects.filter(pk=pk))
form.set_cliente(Cliente.objects.all(), "---------")
context['form'] = form
else:
return HttpResponseRedirect(r('veiculo'))
except:
return HttpResponseRedirect(r('veiculo'))
return render(request, 'reserva/reserva.html', context)
form = ReservaForm(request.POST)
if not form.is_valid():
context['form'] = form
return render(request, 'reserva/reserva.html', context)
form.save()
messages.success(request, SUCCESS_MSG)
return HttpResponseRedirect(r('reserva'))
def setUp(self):
self.user = User.objects.create(username='******', password='******', is_active=True, is_staff=True, is_superuser=True)
self.user.set_password('hello')
self.user.save()
self.resp_invalid = self.client.get(r('upload'))
self.client.login(username='******', password='******')
self.resp = self.client.get(r('upload'))
def do_login(request):
if request.user.is_authenticated():
return HttpResponseRedirect(r('index'))
log_form = LoginForm(request.POST)
if request.method == 'GET'or not log_form.is_valid():
return render(request, 'login/login.html', {'form': LoginForm()})
username = log_form.cleaned_data['username']
password = log_form.cleaned_data['password']
try:
u = User.objects.get(username=username)
except ObjectDoesNotExist:
messages.error(request, ugettext_lazy(u'Usuário ou senha inválidos') )
return render(request, 'login/login.html', {'form': LoginForm()})
usuario = authenticate(username=username, password=password)
login(request, usuario)
return HttpResponseRedirect(r('index'))
# class GenericViewUpdate(UpdateView):
#
# relateds = []
# filter = None
#
# def get_context_data(self, **kwargs):
# if self.filter:
# self.initial = {'academy_id': self.request.user.asuser.academy_id}
# context = super(GenericViewUpdate, self).get_context_data(**kwargs)
# context['label'] = 'Editar'
# return context
#
# def post(self, request, *args, **kwargs):
# if self.filter:
# self.initial = {'academy_id': self.request.user.asuser.academy_id}
# object = get_object_or_404(self.model, pk=kwargs.get('pk'))
# form_class = self.get_form_class()
# form = form_class(request.POST, instance=object, initial=self.initial)
# if form.is_valid():
# object = form.save(commit=False)
# upadte_related = {}
# for related in self.relateds:
# if related in form.changed_data:
# upadte_related[related] = form.cleaned_data[related]
# object.save(upadte_related)
# messages.success(request, UPDATE_MSG)
# return super(UpdateView, self).form_valid(form)
# trainer_update = login_required(
# GenericViewUpdate.as_view(model=Trainer,
# form_class=TrainerForm,
# template_name='instrutor/trainer_form.html',
# success_url="/instrutor/",
# filter=True,
# relateds=['modalities'])
# )
def setUp(self):
self.fixture = (
{'latitude': 22, 'longitude': 43, 'category': 'F', 'device_id': 'DEVICE 1'},
{'latitude': 23, 'longitude': 42, 'category': 'C', 'device_id': 'DEVICE 2'}
)
for d in self.fixture:
self.client.post(r('api:report-list'), d, format='json')
self.resp = self.client.get(r('api:report-list'))
def setUp(self):
self.open_tasks = mommy.make('core.Task', _quantity=3)
self.completed_tasks = mommy.make(
'core.Task', completed=True, _quantity=5
)
# deleted
mommy.make('core.Task', active=False, _quantity=2)
self.resp_index = self.client.get(r('core:index_filter', filter='current'))
self.resp_completed = self.client.get(r('core:index_filter', filter='completed'))
self.resp_all = self.client.get(r('core:index_filter', filter='all'))
def test_speakers(self):
"""must show keynotes speakers"""
content = ['href="{}"'.format(r('speaker_detail', slug='grace-hopper')),
"Grace Hopper",
"http://hbn.link/hopper-pic",
'href="{}"'.format(r('speaker_detail', slug='alan-turing')),
"Alan Turing",
"http://hbn.link/turing-pic"]
for expected in content:
with self.subTest():
self.assertContains(self.response, expected)
def test_speakers(self):
"""Must show keynotes speakers"""
contents = [
'Grace Hopper',
'http://hbn.link/hopper-pic',
'href="{}"'.format(r('speaker_detail', slug='grace-hopper')),
'Alan Turing',
'http://hbn.link/turing-pic',
'href="{}"'.format(r('speaker_detail', slug='alan-turing'))
]
for content in contents:
with self.subTest():
self.assertContains(self.response, content)
def test_speakers(self):
contents = [
'href="{}"'.format(r('speaker_detail', slug='grace-hopper')),
'Grace Hopper',
'http://hbn.link/hopper-pic',
'href="{}"'.format(r('speaker_detail', slug='alan-turing')),
'Alan Turing',
'http://hbn.link/turing-pic'
]
for expected in contents:
with self.subTest():
self.assertContains(self.response, expected)
def test_has_speakers(self):
"""Must have speakers in home page"""
expected = ['Grace Hopper',
'http://hbn.link/hopper-pic',
'href="{}"'.format(r('speaker_detail', slug='grace-hopper')),
'Allan Turing',
'http://hbn.link/turing-pic',
'href="{}"'.format(r('speaker_detail', slug='alan-turing'))
]
for e in expected:
with self.subTest():
self.assertContains(self.resp, e)
def test_speakers(self):
"""Must show keynote speakers"""
contents = [
'href="{}"'.format(r("speaker_detail", slug="grace-hopper")),
"Grace Hopper",
"http://hbn.link/hopper-pic",
'href="{}"'.format(r("speaker_detail", slug="alan-turing")),
"Alan Turing",
"http://hbn.link/turing-pic",
]
for expected in contents:
with self.subTest():
self.assertContains(self.response, expected)
def setUp(self):
academy = mommy.make(Academy)
login_system(academy, self.client)
student = mommy.make(Student, name='Aluno')
self.payment = Payment.objects.create(student=student, value=80,
due_date=date.today())
self.resp = self.client.get(r('billing:payment_list'))
def setUp(self):
data = dict(name='Henrique Bastos',
cpf='12345678901',
email='*****@*****.**',
phone='21-99618-6180')
self.resp = self.client.post(r('subscriptions:new'), data)
self.email = mail.outbox[0]
def assertCodeForData(self, data, expected_code):
'''
Auxiliary method for asserting requests status codes
based on sent data.
'''
response = self.client.post(r('api:report-list'), data, format='json')
self.assertEqual(response.status_code, expected_code)
def close_occurrence(request, pk):
try:
occurrence = Occurrence.objects.get(pk=pk)
except Occurrence.DoesNotExist:
raise Http404
if request.method == "POST":
occurrence.close_occurrence()
# Send email
_send_user_mail(
"Ocorrência resolvida",
request.user.community.email,
occurrence.guest.email,
"occurrences/close_occurrence_email.txt",
{"occurrence": occurrence},
)
_send_manager_mail(
"Ocorrência resolvida",
request.user.community.email,
occurrence.guest.email,
"occurrences/close_occurrence_manager_email.txt",
{"occurrence": occurrence},
)
messages.success(request, "Ocorrência concluída com sucesso.")
return HttpResponseRedirect(r("occurrences:my_occurrences_list"))
def create(request):
form = OccurrenceForm(request.POST)
if not form.is_valid():
return render(request, "occurrences/occurrence_form.html", {"form": form})
occurrence = form.save(commit=False)
occurrence.guest = request.user
occurrence.unit = request.user.unit
occurrence.community = request.user.community
occurrence.save()
# Send email
_send_user_mail(
"Nova ocorrência criada",
request.user.community.email,
occurrence.guest,
"occurrences/occurrence_email.txt",
{"occurrence": occurrence},
)
_send_manager_mail(
"Nova ocorrência criada",
request.user.community.email,
occurrence.guest,
"occurrences/occurrence_manager_email.txt",
{"occurrence": occurrence},
)
messages.success(request, "Ocorrência criada com sucesso. Uma mensagem será encaminhada ao seu e-mail.")
return HttpResponseRedirect(r("occurrences:my_occurrences_list"))
def test_report_photo(self):
'''POST with photos should work'''
data = {'latitude': 22, 'longitude': 43, 'category': 'F',
'device_id': 'DEVICE 1', 'photo': generate_test_image()}
response = self.client.post(r('api:report-list'), data, format='multipart')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def create(request):
form = EvaluationForm(request.POST or None)
if not form.is_valid():
return render(request, 'reviewsphysicals/add.html', {'form': form})
else:
form.save()
return HttpResponseRedirect(r('reviewsphysicals:success'))
def setUp(self):
academy = mommy.make(Academy)
login_system(academy, self.client)
student = mommy.make(Student, academy=academy)
payment = mommy.make(Payment, student=student)
self.invoice = mommy.make(Invoice, payment=payment, month='12', year='2001')
self.resp = self.client.get(r('billing:invoice_update', self.invoice.pk))
def Login(request):
if request.method == 'POST':
form = LoginForm(request.POST)
if not form.is_valid():
return render(request, 'administration/login_form.html', {'form': form})
username = request.POST['username']
password = request.POST['password']
if '@' in username: # se tiver @ no nome do usuário username vai ser o email
kwargs = {'email': username}
else:
kwargs = {'username': username}
try:
# tentando buscar o usuário no banco
user = User.objects.get(**kwargs)
if user.check_password(password):
user = authenticate(username=user.username, password=password)
login(request, user)
return HttpResponseRedirect(r('administration:dash'))
except User.DoesNotExist:
return render(request, 'administration/login_form.html', {'form': form})
else:
form = LoginForm()
return render(request, 'administration/login_form.html', {'form': form})
def setUp(self):
self.tournament = Tournament.objects.create(
title='IRT Brasiliense de Xadrez Amador 2016',
start_date=date(2016, 6, 17),
end_date=date(2016, 6, 19),
inscriptions_date_limit=datetime(2016, 6, 16, 20, 30, 00),
active=True,
place='Venâncio Shopping',
url='http://estavos.com/torneios/irt-brasiliense-de-xadrez-amador-2016-sub-2200/'
)
self.inscription = Inscription.objects.create(
tournament=self.tournament,
name='Bruno Barbosa',
email='*****@*****.**',
birth=date(1989, 12, 18),
id_cbx='39035',
id_fide='',
phone='(61) 9999-9999',
confirmed=False
)
get_user_model().objects.create_superuser(
username='******',
email='*****@*****.**',
first_name='Bruno',
last_name='Barbosa',
password='******',
)
data = {
'tournament': self.tournament.pk,
'inscription': self.inscription.pk
}
self.client.login(username='******', password='******')
self.resp = self.client.post(r('tournaments:inscriptions_control_confirm', self.tournament.pk, self.inscription.pk), data, follow=True)
def create(request):
form = MonthlyPlansForm(request.POST or None)
if not form.is_valid():
return render(request, 'monthlyplans/add.html', {'form': form})
form.save()
return HttpResponseRedirect(r('monthlyplans:success'))
def setUp(self):
t1 = Talk.objects.create(
title='Título da Palestra',
start='10:00',
description='Descrição da palestra.'
)
t2 = Talk.objects.create(
title='Título da Palestra',
start='13:00',
description='Descrição da palestra.'
)
c1 = Course.objects.create(
title='Título do Curso',
start='09:00',
description='Descrição do curso.',
slots=20
)
speaker = Speaker.objects.create(
name='Henrique Bastos',
slug='henrique-bastos',
website='http://henriquebastos.net'
)
t1.speakers.add(speaker)
t2.speakers.add(speaker)
c1.speakers.add(speaker)
self.resp = self.client.get(r('talk_list'))
def setUp(self):
academy = mommy.make(Academy)
login_system(academy, self.client)
student = mommy.make(Student, academy=academy)
payment = mommy.make(Payment, student=student)
self.data = dict(month='01', year='2001', payment=payment.pk, paid=True)
self.resp = self.client.post(r('billing:invoice_new'), self.data)
def setUp(self):
data = dict(
name='Regis da Silva',
cpf='71124336656',
email='*****@*****.**',
phone='11-91234-5678')
self.resp = self.client.post(r('subscriptions:new'), data)
def setUp(self):
self.categoria = CategoriaVeiculo.objects.create(nome='carro', tipo_cnh='B')
self.cliente = Cliente.objects.create(nome='lucas', tipo_cnh='B', cpf='12345678901', email='*****@*****.**')
self.veiculo = Veiculo.objects.create(modelo='Palio', quilometragem=10, disponivel=False, categoria=self.categoria)
self.data = dict(nome="reserva_1", veiculo=self.veiculo, cliente=self.cliente)
self.obj = Reserva.objects.create(**self.data)
self.resp = self.client.get(r('reserva_detail', self.obj.pk))
def test_edit_reserva(self):
self.assertFalse(Reserva.objects.get().finalizada)
self.data['finalizada'] = True
self.data['cliente'] = self.cliente.pk
self.data['veiculo'] = self.veiculo.pk
resp = self.client.post(r('reserva_detail', self.obj.pk), self.data)
self.assertTrue(Reserva.objects.get().finalizada)
def register(request):
template_name = 'accounts/register_form.html'
if request.method == 'POST':
form = RegisterForm(request.POST)
if form.is_valid():
user = form.save()
user = authenticate(
username=user.email, password=form.cleaned_data['password1']
)
login(request, user)#login para pegar os dados e enviar email
#Send register email
_send_manager_mail('Cadastro de usuário',
request.user.community.email,
user,
'accounts/register_user_email.txt',
{'user': user})
logout(request)#logout para sair do sistema até ser ativado
messages.error(request, 'Falta pouco para você começar utilizar o AppSíndico. Aguarde a liberação de acesso pelo seu síndico.')
return HttpResponseRedirect(r('home'))
else:
form = RegisterForm()
context = {
'form': form,
}
return render(request, template_name, context)
def create(request):
form = SubscriptionForm(request.POST or None)
form_02 = HealthAnamneseForm(request.POST or None)
if not (form.is_valid() or form_02.is_valid()):
return render(request, 'externalapplication/add.html', locals())
elif form.is_valid() and form_02.is_valid():
atleta = Subscription.objects.create(**form.cleaned_data)
SaudeAnamnese.objects.create(atleta_id=atleta.pk,
quest01=form_02.cleaned_data['quest01'], quest02=form_02.cleaned_data['quest02'],
quest03=form_02.cleaned_data['quest03'], quest04=form_02.cleaned_data['quest04'],
quest05=form_02.cleaned_data['quest05'], quest06=form_02.cleaned_data['quest06'],
quest07=form_02.cleaned_data['quest07'], quest08=form_02.cleaned_data['quest08'],
quest09=form_02.cleaned_data['quest09'], quest010=form_02.cleaned_data['quest010'],
quest011=form_02.cleaned_data['quest011'],
quest012=form_02.cleaned_data['quest012'],
quest013=form_02.cleaned_data['quest013'],
quest014=form_02.cleaned_data['quest014'],
quest015=form_02.cleaned_data['quest015'],
quest016=form_02.cleaned_data['quest016'],
quest017=form_02.cleaned_data['quest017'],
quest018=form_02.cleaned_data['quest018'],
quest019=form_02.cleaned_data['quest019'],
quest020=form_02.cleaned_data['quest020'],
quest021=form_02.cleaned_data['quest021'],
quest022=form_02.cleaned_data['quest022'],
quest023=form_02.cleaned_data['quest023']
)
# form.save()
return HttpResponseRedirect(r('external:success'))
def activeConfirmeSubscription(request, *args, **kwargs):
print('FFFFFFFFFFFFFFFFFFF')
select = request.POST.getlist('valores_list[]')
for valor in select:
PlanoMensalidade.objects.filter(pk=valor).update(ativo=True)
return HttpResponseRedirect(r('monthlyplans:list'))
def setUp(self):
self.occupation = Occupation.objects.create(occupation='Vendedor')
self.obj = Customer.objects.create(
occupation=self.occupation,
**CUSTOMER_DICT)
self.resp = self.client.get(
r('crm:customer_detail', slug='mike-smith'))
def setUp(self):
user = User.objects.create_user(username='******', password='******')
Report.objects.create(type=1, user=user)
self.client.login(username='******', password='******')
self.response = self.client.get(r('reports:detail', pk=1))
def test_registration_get(self):
resp = self.client.get(r('registration_register'))
self.assertTrue(isinstance(resp.context['form'], RegistrationForm))
def get_absolute_url(self):
return r('crm:company_detail', uuid=self.pk_uuid)
def test_post(self):
"""Valid POST should redirect to /inscricao/2882400170/"""
#1 e depois ele pega a mask e muda o id
self.assertRedirects(self.resp, r('subscriptions:detail', 1))
def get_absolute_url(self):
"""Get absolute url from subscription."""
return r('subscriptions:detail', self.pk)
def test_not_found(self):
resp = self.client.get(r('subscriptions:detail', 0))
self.assertEqual(404, resp.status_code)
def setUp(self):
data = self.create_user_trainee_coordinator()
self.resp = self.client.post(r('core:login'), data)
data = {}
self.resp = self.client.post(r(view_in_test), data)
self.resp2 = self.client.post(r(view_in_test), data, follow=True)
def setUp(self):
self.resp = self.client.get(r(view_in_test))
self.resp2 = self.client.get(r(view_in_test), follow=True)
def get_absolute_url(self):
return r('crm:person_detail', uuid=self.pk_uuid)
def setUp(self):
self.response = self.client.post(r('subscriptions:new'), {})
def test_login_required(self):
self.client.logout()
self.response = self.client.get(r('reports:list'))
self.assertEqual(self.response.status_code, 302)
def setUp(self):
self.resp = self.client.get(r('bookstore:customer_add'))
def setUp(self):
data = dict(first_name='Adam',
last_name='Smith',
email='*****@*****.**',
birthday='2006-10-25 14:30:59')
self.resp = self.client.post(r('bookstore:customer_add'), data)
def setUp(self):
self.obj = Subscription.objects.create(name='Nome Fictício',
cpf='12345678901',
email='*****@*****.**',
phone='21-987654321')
self.response = self.client.get(r('subscriptions:detail', self.obj.pk))
def setUp(self):
self.response = self.client.get(r('offline'))
def test_post(self):
''' Valid POST should redirect to /customer_detail/1/ '''
self.assertRedirects(self.resp, r('bookstore:customer_detail', 1))
def setUp(self):
self.response = self.client.get(r('manifest'), format='json')
def setUp(self):
self.response = self.client.get(r('serviceworker'))
def test_post(self):
'''o post deve redirecionar para /inscricao/1/'''
self.assertRedirects(self.response, r('subscriptions:detail', 1))
def get_absolute_url(self):
return r('speaker_detail', slug=self.slug)
def setUp(self):
self.factory = RequestFactory()
user = User.objects.create_user(username='******', password='******')
self.client.login(username='******', password='******')
self.response = self.client.get(r('reports:create'))
def setUp(self):
self.response = self.client.get(r('home'))
def setUp(self):
data = dict(name='Henrique Bastos',
cpf='12345678901',
email='*****@*****.**',
phone='21-99618-6180')
self.response = self.client.post(r('subscriptions:new'), data)
def test_get_empty(self):
response = self.client.get(r("talk_list"))
self.assertContains(response, "Ainda não existem palestras de manhã.")
self.assertContains(response, "Ainda não existem palestras de tarde.")
def test_template_has_no_field_errors(self):
invalid_data = dict(name='Henrique Bastos', cpf='12345678901')
response = self.client.post(r('subscriptions:new'), invalid_data)
self.assertContains(response, '<ul class="errorlist nonfield">')
def test_not_found(self):
response = self.client.get(r('speaker_detail', slug='not-found'))
self.assertEqual(404, response.status_code)
def setUp(self):
data = dict(name='Elaine Okada',
cpf='12345678901',
email='*****@*****.**',
phone='11-12345-1234')
self.resp = self.client.post(r('subscriptions:new'), data)
def setUp(self):
self.response = self.client.get(r('subscriptions:new'))
def test_delete(self):
"""delete ideas without login must return code 302"""
response = self.client.get(r('delete', self.idea.slug))
self.assertEqual(302, response.status_code)
def setUp(self):
self.resp = self.client.get(r('contact'))
