def pesquisar_alocacoes_horas(request, format=None):
periodo = request.data['periodo']
periodo = converter_string_para_data(periodo)
alocacao_horas = AlocacaoHoras.objects.filter(
data_informada__month=periodo.month,
data_informada__year=periodo.year).order_by('-data_informada',
'hora_inicio')
alocacao_horas = alocacao_horas.prefetch_related(
'atividade_profissional__pessoa_fisica__pessoa')
alocacao_horas = alocacao_horas.prefetch_related(
'atividade_profissional__atividade__fase_atividade__demanda')
if 'profissional_id' in request.data and request.data['profissional_id']:
alocacao_horas = alocacao_horas.filter(
atividade_profissional__pessoa_fisica__id=request.
data['profissional_id'])
if 'cliente_id' in request.data and request.data['cliente_id']:
alocacao_horas = alocacao_horas.filter(
atividade_profissional__atividade__fase_atividade__demanda__cliente__id
=request.data['cliente_id'])
if 'status_demanda' in request.data and request.data['status_demanda']:
alocacao_horas = alocacao_horas.filter(
atividade_profissional__atividade__fase_atividade__demanda__status_demanda
=request.data['status_demanda'])
if 'demanda' in request.data and request.data['demanda']:
alocacao_horas = alocacao_horas.filter(
atividade_profissional__atividade__fase_atividade__demanda__id=
request.data['demanda']['id'])
if not request.user.is_superuser:
eh_gestor = Prestador.objects.filter(
Q(data_fim__isnull=True)
| Q(data_fim__gte=datetime.datetime.now()), Q(cargo__gestor=True),
Q(usuario__id=request.user.id))
if len(eh_gestor) <= 0:
alocacao_horas = alocacao_horas.filter(
atividade_profissional__pessoa_fisica__prestador__usuario__id=
request.user.id)
else:
alocacao_horas = alocacao_horas.filter(
atividade_profissional__atividade__fase_atividade__demanda__unidade_administrativa__pessoafisica__prestador__usuario__id
=request.user.id)
alocacao_hora_list = RelatorioAlocacaoHorasSerializer(alocacao_horas,
many=True).data
for i in alocacao_hora_list:
i['data_alocacao'] = serializar_data(i['data_alocacao'])
i['data_informada'] = serializar_data(i['data_informada'])
return Response(alocacao_hora_list)
def buscar_lote_despesas_abertos(request, demanda_id, format=None):
lote_despesas = LoteDespesa.objects.filter(
pessoa__pessoafisica__prestador__usuario__id=request.user.id,
status='PE',
demanda__id=demanda_id)
if lote_despesas:
lote_despesa_list = LoteDespesaSerializer(lote_despesas,
many=True).data
for l in lote_despesa_list:
l['valor_total'] = formatar_para_valor_monetario(l['valor_total'])
item_despesa = ItemDespesa.objects.filter(lote_despesa__id=l['id'])
item_despesa_list = ItemDespesaSerializer(item_despesa,
many=True).data
for i in item_despesa_list:
i['valor'] = formatar_para_valor_monetario(i['valor'])
i['data'] = serializar_data(i['data'])
l['item_despesas'] = item_despesa_list
return Response(lote_despesa_list)
return Response([])
def buscar_pacote_itens_cliente(request, cliente_id, format=None):
try:
pacote_itens = PacoteItens.objects.filter(
cliente__id=cliente_id, status='P').order_by('-pk')[0]
except IndexError:
pacote_itens = PacoteItens()
pacote_itens.cliente = PessoaJuridica.objects.get(pk=cliente_id)
pacote_itens.status = 'P'
pacote_itens.data_criacao = datetime.date.today()
pacote_itens.save()
except:
raise
#buscar por pacotes recusados
try:
recusados = PacoteItens.objects.filter(cliente__id=cliente_id,
status='R')
if recusados:
for r in recusados:
parcelas_recusadas = Parcela.objects.filter(pacote_itens=r)
if parcelas_recusadas:
for pr in parcelas_recusadas:
pr.pacote_itens = pacote_itens
pr.save()
r.status = 'D'
except:
raise
lista_itens = Parcela.objects.filter(pacote_itens=pacote_itens)
pacote_itens = PacoteItensSerializer(pacote_itens).data
if lista_itens:
lista_itens = ParcelaSerializer(lista_itens, many=True).data
for i in lista_itens:
i['valor_parcela'] = formatar_para_valor_monetario(
i['valor_parcela'])
i['data_previsto_parcela'] = serializar_data(
i['data_previsto_parcela'])
parcela_fases = ParcelaFase.objects.filter(parcela__id=i['id'])
parcela_fases = ParcelaFaseSerializer(parcela_fases,
many=True).data
if parcela_fases:
for p in parcela_fases:
medicoes = Medicao.objects.filter(parcela_fase__id=p['id'])
medicoes = MedicaoSerializer(medicoes, many=True).data
if medicoes:
for m in medicoes:
m['valor_total'] = formatar_para_valor_monetario(
m['valor_total'])
p['medicoes'] = medicoes
i['parcelafases'] = parcela_fases
pacote_itens['lista_itens'] = lista_itens
return Response(pacote_itens)
def marcar_como_lido(request, mensagem_id, format=None):
mensagem = Mensagem.objects.get(
pk=mensagem_id, pessoa_fisica__prestador__usuario__id=request.user.id)
mensagem.delete()
mensagem = MensagemSerializer(mensagem).data
mensagem['data_criacao'] = serializar_data(mensagem['data_criacao'])
return Response(mensagem)
def list(request, format=None):
mensagens = Mensagem.objects.filter(
pessoa_fisica__prestador__usuario__id=request.user.id,
lido=False,
data_criacao__lte=datetime.now()).order_by('-data_criacao')
list = MensagemSerializer(mensagens, many=True).data
for i in list:
i['data_criacao'] = serializar_data(i['data_criacao'])
return Response(list)
def serializar_fase_atividade(fase_atividades):
'''
Utilizado em outros locais além desse
'''
fase_atividade_list = []
if fase_atividades:
fase_atividade_list = FaseAtividadeSerializer(fase_atividades,
many=True).data
for i in fase_atividade_list:
if 'data_inicio' in i:
i['data_inicio'] = serializar_data(i['data_inicio'])
if 'data_fim' in i:
i['data_fim'] = serializar_data(i['data_fim'])
atividades = Atividade.objects.filter(fase_atividade__id=i['id'])
atividade_list = []
if atividades:
atividade_list = AtividadeSerializer(atividades,
many=True).data
for a in atividade_list:
if 'data_inicio' in a:
a['data_inicio'] = serializar_data(a['data_inicio'])
if 'data_fim' in a:
a['data_fim'] = serializar_data(a['data_fim'])
atividade_profissionais = AtividadeProfissional.objects.filter(
atividade__id=a['id'])
if atividade_profissionais:
a['atividadeprofissionais'] = AtividadeProfissionalSerializer(
atividade_profissionais, many=True).data
i['atividades'] = atividade_list
return fase_atividade_list
def gerar_lote_despesas(request, format=None):
demanda = None
if 'demanda' in request.data:
if 'id' in request.data['demanda'] and request.data['demanda']['id']:
demanda = Demanda.objects.get(pk=request.data['demanda']['id'])
del request.data['demanda']
if 'pessoa' in request.data:
del request.data['pessoa']
pessoa = Pessoa.objects.filter(
pessoafisica__prestador__usuario__id=request.user.id)[0]
item_despesas = []
if 'item_despesas' in request.data:
item_despesas = request.data['item_despesas']
del request.data['item_despesas']
lote_despesa = LoteDespesa(**request.data)
lote_despesa.demanda = demanda
lote_despesa.pessoa = pessoa
lote_despesa.status = 'PE'
lote_despesa.data = datetime.datetime.now().date()
lote_despesa.valor_total = converter_string_para_float(
lote_despesa.valor_total)
lote_despesa.save()
item_despesa_list = []
for i in item_despesas:
if 'remover' not in i or i['remover'] is False:
tipo_despesa = None
if 'tipo_despesa' in i:
if 'id' in i['tipo_despesa'] and i['tipo_despesa']['id']:
tipo_despesa = TipoDespesa.objects.get(
pk=i['tipo_despesa']['id'])
del i['tipo_despesa']
item_despesa = ItemDespesa(**i)
item_despesa.lote_despesa = lote_despesa
item_despesa.tipo_despesa = tipo_despesa
item_despesa.data = converter_string_para_data(item_despesa.data)
item_despesa.valor = converter_string_para_float(
item_despesa.valor)
item_despesa.save()
item_despesa_list.append(item_despesa)
elif 'id' in i:
item_despesa = ItemDespesa.objects.get(pk=i['id'])
item_despesa.delete()
data = LoteDespesaSerializer(lote_despesa).data
item_despesa_list = ItemDespesaSerializer(item_despesa_list,
many=True).data
for i in item_despesa_list:
i['valor'] = formatar_para_valor_monetario(i['valor'])
i['data'] = serializar_data(i['data'])
data['item_despesas'] = item_despesa_list
return Response(data)
def serializarDemandaObject(demanda):
propostas = Proposta.objects.filter(demanda__id=demanda.id)
observacoes = Observacao.objects.filter(demanda__id=demanda.id)
ocorrencias = Ocorrencia.objects.filter(demanda__id=demanda.id)
orcamentos = Orcamento.objects.filter(demanda__id=demanda.id)
#fase_atividades = FaseAtividade.objects.filter(demanda__id=demanda.id)
parcelas = Parcela.objects.filter(demanda__id=demanda.id)
demandas_complementares = demanda.demandas_complementares
data = DemandaSerializer(demanda).data
data['data_criacao'] = formatar_data(demanda.data_criacao)
data['data_finalizacao'] = formatar_data(demanda.data_finalizacao)
propostas_list = PropostaSerializer(propostas, many=True).data
for i in propostas_list:
if 'data_recimento_solicitacao' in i:
i['data_recimento_solicitacao'] = serializar_data(
i['data_recimento_solicitacao'])
if 'data_limite_entrega' in i:
i['data_limite_entrega'] = serializar_data(
i['data_limite_entrega'])
if 'data_real_entrega' in i:
i['data_real_entrega'] = serializar_data(i['data_real_entrega'])
if 'data_aprovacao' in i:
i['data_aprovacao'] = serializar_data(i['data_aprovacao'])
observacoes_list = ObservacaoSerializer(observacoes, many=True).data
for i in observacoes_list:
if 'data_observacao' in i:
i['data_observacao'] = serializar_data(i['data_observacao'])
ocorrencias_list = OcorrenciaSerializer(ocorrencias, many=True).data
for i in ocorrencias_list:
if 'data_solicitacao' in i:
i['data_solicitacao'] = serializar_data(i['data_solicitacao'])
if 'data_prevista_conclusao' in i:
i['data_prevista_conclusao'] = serializar_data(
i['data_prevista_conclusao'])
orcamento_dict = serializar_orcamento(orcamentos)
#fase_atividade_list = serializar_fase_atividade(fase_atividades)
parcelas_list = ParcelaSerializer(parcelas, many=True).data
for i in parcelas_list:
i['data_previsto_parcela'] = serializar_data(
i['data_previsto_parcela'])
parcelafase_list = ParcelaFase.objects.filter(parcela=i['id'])
parcelafaseserializer_list = ParcelaFaseSerializer(parcelafase_list,
many=True).data
for pf in parcelafaseserializer_list:
medicoes = Medicao.objects.filter(parcela_fase__id=pf['id'])
medicao_list = MedicaoSerializer(medicoes, many=True).data
pf['medicoes'] = medicao_list
i['parcelafases'] = parcelafaseserializer_list
demandas_complementares_list = []
if demandas_complementares:
demanda_inicial_serializer = DemandaInicialSerializer(
demandas_complementares, many=True).data
for d in demanda_inicial_serializer:
demandas_complementares_list.append({'demanda': d})
data['propostas'] = propostas_list
data['observacoes'] = observacoes_list
data['ocorrencias'] = ocorrencias_list
data['orcamento'] = orcamento_dict
#data['fase_atividades'] = fase_atividade_list
data['parcelas'] = parcelas_list
data['demandas_complementares'] = demandas_complementares_list
return data