def salvar_atividade(self, atividade_list, fase_atividade):
if atividade_list:
for i in atividade_list:
if 'descricao' in i and 'data_inicio' in i and 'data_fim' in i and (
'remover' not in i or i['remover'] is False):
atividade_profissionais = None
if 'atividadeprofissionais' in i:
atividade_profissionais = i['atividadeprofissionais']
del i['atividadeprofissionais']
if 'data_inicio_string' in i:
del i['data_inicio_string']
if 'data_fim_string' in i:
del i['data_fim_string']
atividade = Atividade(**i)
atividade.fase_atividade = fase_atividade
atividade.data_inicio = converter_string_para_data(
atividade.data_inicio)
atividade.data_fim = converter_string_para_data(
atividade.data_fim)
atividade.save()
self.salvar_atividade_profissionais(
atividade_profissionais, atividade)
elif 'id' in i:
atividade = Atividade.objects.get(pk=i['id'])
atividade.delete()
def gravar_pessoa_fisica(self, pf, pessoa):
prestadores = None
if 'prestadores' in pf:
prestadores = pf['prestadores']
del pf['prestadores']
custos_prestador = None
if 'custos_prestador' in pf:
custos_prestador = pf['custos_prestador']
del pf['custos_prestador']
unidade_administrativas = None
if 'unidade_administrativas' in pf:
unidade_administrativas = pf['unidade_administrativas']
del pf['unidade_administrativas']
pessoa_fisica = PessoaFisica(**pf)
pessoa_fisica.pessoa = pessoa
pessoa_fisica.data_expedicao = converter_string_para_data(
pf['data_expedicao'])
pessoa_fisica.data_nascimento = converter_string_para_data(
pf['data_nascimento'])
pessoa_fisica.data_emicao_pis = converter_string_para_data(
pf['data_emicao_pis'])
pessoa_fisica.save()
self.gravar_prestador(prestadores, pessoa_fisica)
self.gravar_custo_prestador(custos_prestador, pessoa_fisica)
self.gravar_unidade_administrativas(unidade_administrativas,
pessoa_fisica)
def salvar_ocorrencias(self, ocorrencias, demanda):
for i in ocorrencias:
if 'remover' not in i or i['remover'] is False:
if 'tipo_ocorrencia' in i and i['tipo_ocorrencia'] is not None:
if 'show' in i:
del i['show']
responsavel = None
if 'responsavel' in i:
if i['responsavel'] is not None and 'id' in i[
'responsavel']:
responsavel = i['responsavel']
responsavel = PessoaFisica.objects.get(
pk=responsavel['id'])
del i['responsavel']
ocorrencia = Ocorrencia(**i)
ocorrencia.demanda = demanda
if responsavel is not None:
ocorrencia.responsavel = responsavel
if 'data_solicitacao' in i:
data_string = i['data_solicitacao']
ocorrencia.data_solicitacao = converter_string_para_data(
data_string)
if 'data_prevista_conclusao' in i:
data_string = i['data_prevista_conclusao']
ocorrencia.data_prevista_conclusao = converter_string_para_data(
data_string)
ocorrencia.save()
else:
if 'id' in i:
ocorrencia = Ocorrencia.objects.get(pk=i['id'])
ocorrencia.delete()
def salvar_proposta(self, propostas, demanda):
for i in propostas:
if 'remover' not in i or i['remover'] is False:
if 'data_recimento_solicitacao' in i and i[
'data_recimento_solicitacao'] is not None:
proposta = Proposta(**i)
proposta.demanda = demanda
data_string = i['data_recimento_solicitacao']
proposta.data_recimento_solicitacao = converter_string_para_data(
data_string)
if 'data_limite_entrega' in i:
data_string = i['data_limite_entrega']
proposta.data_limite_entrega = converter_string_para_data(
data_string)
if 'data_real_entrega' in i:
data_string = i['data_real_entrega']
proposta.data_real_entrega = converter_string_para_data(
data_string)
if 'data_aprovacao' in i:
data_string = i['data_aprovacao']
proposta.data_aprovacao = converter_string_para_data(
data_string)
proposta.save()
else:
if 'id' in i:
proposta = Proposta.objects.get(pk=i['id'])
proposta.delete()
def post(self, request, format=None):
data = request.data
vigencia_list = None
if 'vigencias' in data:
vigencia_list = data['vigencias']
del data['vigencias']
centro_custo = CentroCusto.objects.get(pk=data['centro_custo']['id'])
del data['centro_custo']
centro_resultado = CentroResultado.objects.get(
pk=data['centro_resultado']['id'])
del data['centro_resultado']
conta_gerencial = ContaGerencial.objects.get(
pk=data['conta_gerencial']['id'])
del data['conta_gerencial']
natureza_operacao = NaturezaOperacao.objects.get(
pk=data['natureza_operacao']['id'])
del data['natureza_operacao']
tipo_hora = TipoHora.objects.get(pk=data['tipo_hora']['id'])
del data['tipo_hora']
valor_hora = ValorHora(**data)
valor_hora.centro_custo = centro_custo
valor_hora.centro_resultado = centro_resultado
valor_hora.conta_gerencial = conta_gerencial
valor_hora.natureza_operacao = natureza_operacao
valor_hora.tipo_hora = tipo_hora
valor_hora.save()
for vigencia in vigencia_list:
if 'data_inicio' in vigencia and 'data_fim' in vigencia and 'valor' in vigencia:
data_inicio = converter_string_para_data(
vigencia['data_inicio'])
data_fim = converter_string_para_data(vigencia['data_fim'])
valor = converter_string_para_float(vigencia['valor'])
id = None
if 'id' in vigencia:
id = vigencia['id']
v = Vigencia(data_inicio=data_inicio,
data_fim=data_fim,
valor=valor,
id=id,
valor_hora=valor_hora)
v.save()
return self.serializar_valor_hora(valor_hora.id)
def post(self, request, format=None):
if 'origem' not in request.data:
if request.user.is_superuser:
origem = "Super usuário"
else:
origem = Pessoa.objects.filter(
pessoafisica__prestador__usuario__id=request.user.id)[0]
origem = origem.nome_razao_social
else:
origem = request.data['origem']
destino = None
if 'pessoa_fisica' in request.data and request.data['pessoa_fisica']:
if 'id' in request.data['pessoa_fisica']:
destino = PessoaFisica.objects.get(
pk=request.data['pessoa_fisica']['id'])
del request.data['pessoa_fisica']
else:
destino = PessoaFisica.objects.filter(
prestador__usuario__id=request.user.id)[0]
if 'data_texto' in request.data:
del request.data['data_texto']
mensagem = Mensagem(**request.data)
mensagem.origem = origem
mensagem.pessoa_fisica = destino
mensagem.data_criacao = converter_string_para_data(
request.data['data_criacao'])
mensagem.tag = 'T'
mensagem.save()
serializer = MensagemSerializer(mensagem)
return Response(serializer.data)
def salvar_fase_atividades(self, fase_atividades, demanda):
if fase_atividades:
for i in fase_atividades:
if 'fase' in i and i[
'fase'] and 'data_inicio' in i and 'data_fim' in i and (
'remover' not in i or i['remover'] is False):
atividades = None
if 'atividades' in i:
if i['atividades']:
atividades = i['atividades']
del i['atividades']
fase = None
if 'fase' in i:
if i['fase'] and 'id' in i['fase']:
fase = Fase.objects.get(pk=i['fase']['id'])
del i['fase']
responsavel = None
if 'responsavel' in i:
if i['responsavel'] and 'id' in i['responsavel'] and i[
'responsavel']['id'] is not None:
responsavel = PessoaFisica.objects.get(
pk=i['responsavel']['id'])
del i['responsavel']
fase_atividade = FaseAtividade(**i)
fase_atividade.data_inicio = converter_string_para_data(
fase_atividade.data_inicio)
fase_atividade.data_fim = converter_string_para_data(
fase_atividade.data_fim)
fase_atividade.fase = fase
fase_atividade.responsavel = responsavel
fase_atividade.demanda = demanda
fase_atividade.save()
self.salvar_atividade(atividades, fase_atividade)
elif 'id' in i:
fase_atividade = FaseAtividade.objects.get(pk=i['id'])
fase_atividade.delete()
pass
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 gravar_custo_prestador(self, custos_prestador, pessoa_fisica):
if custos_prestador:
for custo_prestador_list in custos_prestador:
if 'remover' not in custo_prestador_list or custo_prestador_list[
'remover'] == False:
custo = CustoPrestador(**custo_prestador_list)
custo.pessoa_fisica = pessoa_fisica
custo.data_inicio = converter_string_para_data(
custo_prestador_list['data_inicio'])
if 'data_fim' in custo_prestador_list:
custo.data_fim = converter_string_para_data(
custo_prestador_list['data_fim'])
custo.valor = converter_string_para_float(
custo_prestador_list['valor'])
custo.save()
elif 'id' in custo_prestador_list:
custo = CustoPrestador.objects.get(
pk=custo_prestador_list['id'])
custo.delete()
def salvar_observacoes(self, observacoes, demanda):
for i in observacoes:
if 'remover' not in i or i['remover'] is False:
if ('observacao' in i and i['observacao'] is not None
and 'data_observacao' in i
and i['data_observacao'] is not None):
observacao = Observacao(**i)
observacao.demanda = demanda
observacao.data_observacao = converter_string_para_data(
i['data_observacao'])
observacao.save()
else:
if 'id' in i:
observacao = Observacao.objects.get(pk=i['id'])
observacao.delete()
def alocar_horas_internas(request, format=None):
atividade_profissional = None
if 'atividade_profissional' in request.data:
atividade_profissional = AtividadeProfissional.objects.get(
pk=request.data['atividade_profissional']['id'])
del request.data['atividade_profissional']
if 'atividade' in request.data:
if atividade_profissional is None:
atividade = Atividade.objects.get(
pk=request.data['atividade']['id'])
atividade_profissional = AtividadeProfissional()
atividade_profissional.atividade = atividade
pessoa_fisica = PessoaFisica.objects.filter(
prestador__usuario__id=request.user.id)[0]
atividade_profissional.pessoa_fisica = pessoa_fisica
atividade_profissional.quantidade_horas = 0
atividade_profissional.percentual_calculado = 0
atividade_profissional.percentual_concluido = 0
atividade_profissional.save()
del request.data['atividade']
alocacao_horas = AlocacaoHoras(**request.data)
alocacao_horas.atividade_profissional = atividade_profissional
alocacao_horas.data_informada = converter_string_para_data(
request.data['data_informada'])
alocacao_horas.data_alocacao = datetime.datetime.now()
if 'observacao' in request.data and request.data['observacao']:
alocacao_horas.observacao = request.data['observacao']
else:
alocacao_horas.observacao = None
alocacao_horas.percentual_concluido = 0
alocacao_horas.save()
horas_alocadas_milisegundos = request.data['horas_alocadas_milisegundos']
if (atividade_profissional.horas_alocadas_milisegundos):
atividade_profissional.horas_alocadas_milisegundos += horas_alocadas_milisegundos
else:
atividade_profissional.horas_alocadas_milisegundos = horas_alocadas_milisegundos
atividade_profissional.save()
return Response(
AtividadeProfissionalSerializer(atividade_profissional).data)
def alocar_horas(request, format=None):
if 'alocacao_id' in request.data:
alocacao_horas = AlocacaoHoras.objects.get(
pk=request.data['alocacao_id'])
else:
raise Exception('Alocação não selecionado')
atividade_profissional = alocacao_horas.atividade_profissional
tipo_alocacao = None
if 'tipo_alocacao' in request.data:
if request.data['tipo_alocacao']:
tipo_alocacao = TipoAlocacao.objects.get(
pk=request.data['tipo_alocacao']['id'])
del request.data['tipo_alocacao']
hora_inicio = datetime.datetime.strptime(request.data['hora_inicio'],
'%H:%M')
hora_fim = datetime.datetime.strptime(request.data['hora_fim'], '%H:%M')
subtracao = hora_fim - hora_inicio
if (subtracao.seconds *
1000) != request.data['horas_alocadas_milisegundos']:
raise Exception("Milisegundos não confere")
alocacao_horas.horas_alocadas_milisegundos = request.data[
'horas_alocadas_milisegundos']
alocacao_horas.hora_inicio = request.data['hora_inicio']
alocacao_horas.hora_fim = request.data['hora_fim']
alocacao_horas.percentual_concluido = request.data[
'percentual_concluido'] if 'percentual_concluido' in request.data else None
alocacao_horas.observacao = request.data[
'observacao'] if 'observacao' in request.data else None
alocacao_horas.data_informada = converter_string_para_data(
request.data['data_informada'])
alocacao_horas.data_alocacao = datetime.datetime.now()
alocacao_horas.tipo_alocacao = tipo_alocacao
alocacao_horas.save()
calcular_horas_percentual_atividade(atividade_profissional)
return Response(
AtividadeProfissionalSerializer(atividade_profissional).data)
def salvar_parcelas(self, parcela_list, demanda):
if parcela_list:
for i in parcela_list:
if 'remover' not in i or i['remover'] == False:
valor_parcela = None
if 'valor_parcela' in i:
valor_parcela = converter_string_para_float(
i['valor_parcela'])
del i['valor_parcela']
data_previsto_parcela = None
if 'data_previsto_parcela' in i:
data_previsto_parcela = converter_string_para_data(
i['data_previsto_parcela'])
del i['data_previsto_parcela']
medicao_list = None
if 'medicoes' in i:
medicao_list = i['medicoes']
del i['medicoes']
if 'demanda' in i:
del i['demanda']
parcela = Parcela(**i)
parcela.valor_parcela = valor_parcela
parcela.data_previsto_parcela = data_previsto_parcela
parcela.demanda = demanda
parcela.tipo_parcela = demanda.tipo_parcela
parcela.save()
self.gravar_medicoes(parcela, medicao_list)
elif 'id' in i:
parcela = Parcela.objects.get(pk=i['id'])
parcela.delete()
def alocar_horas_internas(request, format=None):
if 'alocacao_id' in request.data:
alocacao_horas = AlocacaoHoras.objects.get(
pk=request.data['alocacao_id'])
else:
raise Exception('Alocação não selecionado')
atividade_profissional = alocacao_horas.atividade_profissional
alocacao_horas.atividade_profissional = atividade_profissional
alocacao_horas.horas_alocadas_milisegundos = request.data[
'horas_alocadas_milisegundos']
alocacao_horas.data_informada = converter_string_para_data(
request.data['data_informada'])
alocacao_horas.hora_inicio = request.data['hora_inicio']
alocacao_horas.hora_fim = request.data['hora_fim']
if 'observacao' in request.data and request.data['observacao']:
alocacao_horas.observacao = request.data['observacao']
else:
alocacao_horas.observacao = None
alocacao_horas.data_alocacao = datetime.datetime.now()
alocacao_horas.percentual_concluido = 0
alocacao_horas.save()
alocacoes = AlocacaoHoras.objects.filter(
atividade_profissional=atividade_profissional)
atividade_profissional.horas_alocadas_milisegundos = sum(
a.horas_alocadas_milisegundos for a in alocacoes)
atividade_profissional.save()
return Response(
AtividadeProfissionalSerializer(atividade_profissional).data)
def relatorio(request):
tipo_relatorio = request.POST['tipo_relatorio']
alocacao_horas = AlocacaoHoras.objects.all()
eh_gestor = verificar_gestor(request)
if not request.user.is_superuser and not eh_gestor:
alocacao_horas = alocacao_horas.filter(
atividade_profissional__pessoa_fisica__prestador__usuario__id=
request.user.id)
elif not request.user.is_superuser:
alocacao_horas = alocacao_horas.filter(
atividade_profissional__atividade__fase_atividade__demanda__unidade_administrativa__pessoafisica__prestador__usuario__id
=request.user.id)
periodo = request.POST['periodo']
periodo = converter_string_para_data(periodo)
alocacao_horas = alocacao_horas.filter(data_informada__month=periodo.month,
data_informada__year=periodo.year)
if 'profissional_id' in request.POST and request.POST['profissional_id']:
profissional_id = request.POST['profissional_id']
alocacao_horas = alocacao_horas.filter(
atividade_profissional__pessoa_fisica__id=profissional_id)
if 'cliente_id' in request.POST and request.POST['cliente_id']:
cliente_id = request.POST['cliente_id']
alocacao_horas = alocacao_horas.filter(
atividade_profissional__atividade__fase_atividade__demanda__cliente__id
=cliente_id)
if 'status_demanda' in request.POST and request.POST['status_demanda']:
status_demanda = request.POST['status_demanda']
alocacao_horas = alocacao_horas.filter(
atividade_profissional__atividade__fase_atividade__demanda__status_demanda
=status_demanda)
if 'demanda_id' in request.POST and request.POST['demanda_id']:
demanda_id = request.POST['demanda_id']
alocacao_horas = alocacao_horas.filter(
atividade_profissional__atividade__fase_atividade__demanda__id=
demanda_id)
alocacao_horas_profissional = alocacao_horas.values(
'id', 'observacao', 'atividade_profissional__pessoa_fisica__id',
'data_informada',
'atividade_profissional__pessoa_fisica__pessoa__nome_razao_social',
'hora_inicio',
'atividade_profissional__atividade__fase_atividade__demanda__cliente__nome_fantasia',
'atividade_profissional__atividade__fase_atividade__demanda__codigo_demanda',
'atividade_profissional__atividade__descricao',
'hora_fim').annotate(horas_alocadas=Sum(
'horas_alocadas_milisegundos')).order_by('hora_inicio')
alocacao_total = alocacao_horas.values('data_informada').annotate(
total_horas_dia=Sum('horas_alocadas_milisegundos')).order_by(
'data_informada')
alocacao_mensal = alocacao_horas.aggregate(
total_horas_mes=Sum('horas_alocadas_milisegundos'))
list_total = []
valor_total = 0
for total in alocacao_total:
total_dict = {'total': total}
total['total_horas_dia'] = transformar_mili_para_horas(
total['total_horas_dia'])
list_alocacao_prof = []
total_valor_dia = 0
for profissional in alocacao_horas_profissional:
if total['data_informada'] == profissional['data_informada']:
valor_profissional = None
if tipo_relatorio == 'gerar_relatorio_com_valor':
custo_prestador = buscar_custo_prestador_vigencia_profissional(
profissional['data_informada'], profissional[
'atividade_profissional__pessoa_fisica__id'])
valor_profissional = calcular_valor_em_milisegundos(
custo_prestador, profissional['horas_alocadas'])
valor_total += valor_profissional
total_valor_dia += valor_profissional
if valor_profissional:
profissional[
'valor_profissional'] = formatar_para_valor_monetario(
valor_profissional)
profissional['data_informada'] = formatar_data(
profissional['data_informada'])
profissional['horas_alocadas'] = transformar_mili_para_horas(
profissional['horas_alocadas'])
profissional['observacao'] = profissional[
'observacao'] if profissional['observacao'] else ''
list_alocacao_prof.append(profissional)
total_dict['list_alocacao_prof'] = list_alocacao_prof
total_dict['total_valor_dia'] = formatar_para_valor_monetario(
total_valor_dia)
list_total.append(total_dict)
alocacao_mensal['total_horas_mes'] = transformar_mili_para_horas(
alocacao_mensal['total_horas_mes'])
alocacao_mensal['valor_total'] = formatar_para_valor_monetario(valor_total)
context = {
'data_atual': datetime.date.today().strftime("%d/%m/%Y"),
'hora_atual': datetime.datetime.now().strftime("%H:%M"),
'periodo': periodo.strftime("%m/%Y"),
'alocacao_mensal': alocacao_mensal,
'lista': list_total
}
if tipo_relatorio == 'gerar_relatorio':
return render(request,
'relatorio_lancamentos/relatorio_sem_valor.html',
context)
elif tipo_relatorio == 'gerar_relatorio_com_valor':
return render(request,
'relatorio_lancamentos/relatorio_com_valor.html',
context)
def alocar_horas(request, format=None):
atividade_profissional = None
if 'atividade_profissional' in request.data:
atividade_profissional = AtividadeProfissional.objects.get(
pk=request.data['atividade_profissional']['id'])
del request.data['atividade_profissional']
tipo_alocacao = None
if 'tipo_alocacao' in request.data:
tipo_alocacao = TipoAlocacao.objects.get(
pk=request.data['tipo_alocacao']['id'])
del request.data['tipo_alocacao']
hora_inicio = datetime.datetime.strptime(request.data['hora_inicio'],
'%H:%M')
hora_fim = datetime.datetime.strptime(request.data['hora_fim'], '%H:%M')
subtracao = hora_fim - hora_inicio
if (subtracao.seconds *
1000) != request.data['horas_alocadas_milisegundos']:
raise Exception("Milisegundos não confere")
alocacao_horas = AlocacaoHoras(**request.data)
alocacao_horas.atividade_profissional = atividade_profissional
alocacao_horas.data_informada = converter_string_para_data(
request.data['data_informada'])
alocacao_horas.data_alocacao = datetime.datetime.now()
alocacao_horas.tipo_alocacao = tipo_alocacao
alocacao_horas.save()
horas_alocadas_milisegundos = request.data['horas_alocadas_milisegundos']
percentual_concluido = request.data['percentual_concluido']
if (atividade_profissional.horas_alocadas_milisegundos):
atividade_profissional.horas_alocadas_milisegundos += horas_alocadas_milisegundos
else:
atividade_profissional.horas_alocadas_milisegundos = horas_alocadas_milisegundos
quantidade_horas_milisegundos = atividade_profissional.quantidade_horas * 60 * 60 * 1000
percentual_calculado = (atividade_profissional.horas_alocadas_milisegundos
* 100) / quantidade_horas_milisegundos
if percentual_calculado > 100:
percentual_calculado = 100
atividade_profissional.percentual_calculado = percentual_calculado
atividade_profissional.percentual_concluido = percentual_concluido
atividade_profissional.save()
#Calcular percentual atividade
atividade = Atividade.objects.filter(
atividadeprofissional=atividade_profissional)[0]
atividades_profissionais = AtividadeProfissional.objects.filter(
atividade=atividade)
percentual_calculado = sum(
(a.percentual_calculado if a.percentual_calculado else 0)
for a in atividades_profissionais) / len(atividades_profissionais)
percentual_concluido = sum(
(a.percentual_concluido if a.percentual_concluido else 0)
for a in atividades_profissionais) / len(atividades_profissionais)
if (atividade.percentual_concluido < 100 and percentual_concluido == 100):
atividade.data_conclusao_atividade = datetime.datetime.now()
atividade.percentual_calculado = percentual_calculado
atividade.percentual_concluido = percentual_concluido
atividade.save()
#calcular percentual fase_atividade
fase_atividade = FaseAtividade.objects.filter(atividade=atividade)[0]
atividades = Atividade.objects.filter(fase_atividade=fase_atividade)
percentual_calculado = sum(
(a.percentual_calculado if a.percentual_calculado else 0)
for a in atividades) / len(atividades)
percentual_concluido = sum(
(a.percentual_concluido if a.percentual_concluido else 0)
for a in atividades) / len(atividades)
fase_atividade.percentual_calculado = percentual_calculado
fase_atividade.percentual_concluido = percentual_concluido
fase_atividade.save()
demanda = Demanda.objects.filter(faseatividade=fase_atividade)[0]
fase_atividades = FaseAtividade.objects.filter(demanda=demanda)
percentual_calculado = sum(
(a.percentual_calculado if a.percentual_calculado else 0)
for a in fase_atividades) / len(fase_atividades)
percentual_concluido = sum(
(a.percentual_concluido if a.percentual_concluido else 0)
for a in fase_atividades) / len(fase_atividades)
demanda.percentual_calculado = percentual_calculado
demanda.percentual_concluido = percentual_concluido
demanda.save()
return Response(
AtividadeProfissionalSerializer(atividade_profissional).data)
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 post(self, request, format=None):
demanda = None
if 'demanda_id' in request.data:
demanda = Demanda.objects.get(pk=request.data['demanda_id'])
else:
raise Exception('Demanda nao informada')
parcela_list = []
if 'parcelas' in request.data:
parcela_list = request.data['parcelas']
parcela_resp = []
for i in parcela_list:
if 'remover' not in i or i['remover'] == False:
valor_parcela = None
if 'valor_parcela' in i:
valor_parcela = converter_string_para_float(
i['valor_parcela'])
del i['valor_parcela']
if 'demanda' in i:
del i['demanda']
parcelafase_list = []
if 'parcelafases' in i:
parcelafase_list = i['parcelafases']
del i['parcelafases']
if 'selecionado' in i:
del i['selecionado']
pacote_itens = None
selecionado = None
if 'pacote_itens' in i and i['pacote_itens']:
pacote_itens = PacoteItens.objects.get(
pk=i['pacote_itens']['id'])
selecionado = True
del i['pacote_itens']
parcela = Parcela(**i)
parcela.valor_parcela = valor_parcela
parcela.data_previsto_parcela = converter_string_para_data(
parcela.data_previsto_parcela)
parcela.data_envio_aprovacao = converter_string_para_data(
parcela.data_envio_aprovacao)
parcela.data_aprovacao_faturamento = converter_string_para_data(
parcela.data_aprovacao_faturamento)
parcela.data_previsto_pagamento = converter_string_para_data(
parcela.data_previsto_pagamento)
parcela.data_faturamento = converter_string_para_data(
parcela.data_faturamento)
parcela.data_pagamento = converter_string_para_data(
parcela.data_pagamento)
parcela.pacote_itens = pacote_itens
parcela.demanda = demanda
parcela.save()
parcelafase_resp = self.gravar_parcelafases(
parcela, parcelafase_list)
serializer = ParcelaSerializer(parcela).data
serializer['data_previsto_parcela'] = formatar_data(
parcela.data_previsto_parcela)
serializer['data_envio_aprovacao'] = formatar_data(
parcela.data_envio_aprovacao)
serializer['data_aprovacao_faturamento'] = formatar_data(
parcela.data_aprovacao_faturamento)
serializer['data_previsto_pagamento'] = formatar_data(
parcela.data_previsto_pagamento)
serializer['data_faturamento'] = formatar_data(
parcela.data_faturamento)
serializer['data_pagamento'] = formatar_data(
parcela.data_pagamento)
serializer['selecionado'] = selecionado
serializer['parcelafases'] = parcelafase_resp
parcela_resp.append(serializer)
elif 'id' in i:
parcela = Parcela.objects.get(pk=i['id'])
parcela.delete()
context = {'parcelas': parcela_resp}
return Response(context)
def post(self, request, format=None):
data = request.data
centro_custo = None
if 'centro_custo' in data:
centro_custo = CentroCusto.objects.get(
pk=data['centro_custo']['id'])
del data['centro_custo']
if 'data_contratacao' in data:
data['data_contratacao'] = converter_string_para_data(
data['data_contratacao'])
if 'data_rescisao' in data:
data['data_rescisao'] = converter_string_para_data(
data['data_rescisao'])
if 'data_renegociacao_valor' in data and data[
'data_renegociacao_valor']:
data['data_renegociacao_valor'] = converter_string_para_data(
data['data_renegociacao_valor'])
else:
data['data_renegociacao_valor'] = None
telefones = None
if 'telefones' in data:
telefones = data['telefones']
del data['telefones']
enderecos = None
if 'enderecos' in data:
enderecos = data['enderecos']
del data['enderecos']
dados_bancarios = None
if 'dados_bancarios' in data:
dados_bancarios = data['dados_bancarios']
del data['dados_bancarios']
pessoa_fisica = None
if 'pessoa_fisica' in data:
pessoa_fisica = data['pessoa_fisica']
del data['pessoa_fisica']
pessoa_juridica = None
if 'pessoa_juridica' in data:
pessoa_juridica = data['pessoa_juridica']
del data['pessoa_juridica']
apropriacao = None
if 'apropriacao' in data:
apropriacao = data['apropriacao']
del data['apropriacao']
pessoa = Pessoa(**data)
pessoa.centro_custo = centro_custo
pessoa.save()
self.gravar_telefones(telefones, pessoa)
self.gravar_enderecos(enderecos, pessoa)
self.gravar_dados_bancarios(dados_bancarios, pessoa)
self.gravar_apropriacao(apropriacao, pessoa)
if data['tipo'] == 'F':
self.gravar_pessoa_fisica(pessoa_fisica, pessoa)
if data['tipo'] == 'J':
self.gravar_pessoa_juridica(pessoa_juridica, pessoa)
data = self.serializar_pessoa(pessoa)
return Response(data)
def gravar_prestador(self, prestadores, pessoa_fisica):
if prestadores:
for p in prestadores:
campos = ('tipo_prestador', 'pessoa_juridica',
'data_exame_admissional', 'data_exame_demissional',
'data_proxima_avaliacao', 'data_ultima_avaliacao',
'data_ultimo_exame_periodico', 'cargo')
if len([campo for campo in campos if campo in p]) > 0:
cargo = None
if 'cargo' in p and p['cargo']:
if p['cargo']['id']:
cargo = Cargo.objects.get(pk=p['cargo']['id'])
del p['cargo']
usuario = None
if 'usuario' in p and p['usuario']:
if p['usuario']['id']:
usuario = User.objects.get(pk=p['usuario']['id'])
del p['usuario']
pessoa_juridica = None
if 'pessoa_juridica' in p and p['pessoa_juridica']:
if p['pessoa_juridica']['id']:
pessoa_juridica = PessoaJuridica.objects.get(
pk=p['pessoa_juridica']['id'])
del p['pessoa_juridica']
prestador = Prestador(**p)
prestador.pessoa_fisica = pessoa_fisica
if 'data_inicio' in p:
prestador.data_inicio = converter_string_para_data(
p['data_inicio'])
if 'data_fim' in p:
prestador.data_fim = converter_string_para_data(
p['data_fim'])
if 'data_contratacao' in p:
prestador.data_contratacao = converter_string_para_data(
p['data_contratacao'])
if 'data_rescisao' in p:
prestador.data_rescisao = converter_string_para_data(
p['data_rescisao'])
if 'data_fim_aditivo' in p:
prestador.data_fim_aditivo = converter_string_para_data(
p['data_fim_aditivo'])
if 'data_exame_admissional' in p:
prestador.data_exame_admissional = converter_string_para_data(
p['data_exame_admissional'])
if 'data_exame_demissional' in p:
prestador.data_exame_demissional = converter_string_para_data(
p['data_exame_demissional'])
if 'data_proxima_avaliacao' in p:
prestador.data_proxima_avaliacao = converter_string_para_data(
p['data_proxima_avaliacao'])
if 'data_ultima_avaliacao' in p:
prestador.data_ultima_avaliacao = converter_string_para_data(
p['data_ultima_avaliacao'])
if 'data_ultimo_exame_periodico' in p:
prestador.data_ultimo_exame_periodico = converter_string_para_data(
p['data_ultimo_exame_periodico'])
prestador.cargo = cargo
prestador.usuario = usuario
prestador.pessoa_juridica = pessoa_juridica
prestador.save()
elif 'id' in p:
prestador = Prestador.objects.get(pk=p['id'])
prestador.delete()
def buscar_lista_por_parametro(request, format=None):
if request.data:
arguments = {}
if 'data_inicio' in request.data and request.data['data_inicio']:
data_inicio = converter_string_para_data(
request.data['data_inicio'])
arguments['data_criacao__gte'] = data_inicio
if 'data_fim' in request.data and request.data['data_fim']:
data_fim = converter_string_para_data(request.data['data_fim'])
arguments['data_criacao__lte'] = data_fim
if 'cliente_id' in request.data and request.data['cliente_id']:
arguments['cliente__id'] = request.data['cliente_id']
if 'nome_demanda' in request.data and request.data['nome_demanda']:
arguments['nome_demanda__icontains'] = request.data['nome_demanda']
list_status = []
if 'status' in request.data and request.data['status']:
for k in request.data['status']:
if request.data['status'][k]:
list_status.append(k)
list_responsaveis = []
if 'responsaveis' in request.data and request.data['responsaveis']:
for k in request.data['responsaveis']:
if request.data['responsaveis'][k]:
list_responsaveis.append(k)
demandas = Demanda.objects.filter(**arguments)
if not request.user.is_superuser:
demandas = demandas.filter(
unidade_administrativa__pessoafisica__prestador__usuario__id=
request.user.id)
if list_status:
demandas = demandas.filter(status_demanda__in=list_status)
if list_responsaveis:
demandas = demandas.filter(responsavel__id__in=list_responsaveis)
if 'palavra_chave' in request.data and request.data['palavra_chave']:
if request.data['palavra_chave'].isdigit():
palavra_chave = request.data['palavra_chave']
demandas = demandas.filter(
Q(id=palavra_chave)
| Q(nome_demanda__icontains=palavra_chave)
| Q(faseatividade__atividade__descricao__icontains=
palavra_chave)
| Q(descricao__icontains=palavra_chave)
| Q(cliente__pessoa__nome_razao_social__icontains=
palavra_chave)
| Q(codigo_demanda__icontains=palavra_chave)).distinct()
else:
palavra_chave = request.data['palavra_chave']
demandas = demandas.filter(
Q(nome_demanda__icontains=palavra_chave)
| Q(faseatividade__atividade__descricao__icontains=
palavra_chave)
| Q(descricao__icontains=palavra_chave)
| Q(cliente__pessoa__nome_razao_social__icontains=
palavra_chave)
| Q(codigo_demanda__icontains=palavra_chave)).distinct()
if request.data['ordenar'] is False:
demandas = demandas.order_by('pk')
else:
demandas = demandas.order_by('-pk')
pagina = request.data['pagina']
paginator = Paginator(demandas, REGISTROS_POR_PAGINA)
total_paginas = paginator.num_pages
if 'pagina' in request.data:
if pagina > total_paginas:
pagina = total_paginas
demandas = paginator.page(pagina)
else:
demandas = paginator.page(1)
else:
demandas = Demanda.objects.all().order_by('-id')
if not request.user.is_superuser:
demandas = demandas.filter(
unidade_administrativa__pessoafisica__prestador__usuario__id=
request.user.id)
paginator = Paginator(demandas, REGISTROS_POR_PAGINA)
demandas = paginator.page(1)
total_paginas = paginator.num_pages
demandas = DemandaSerializer(demandas, many=True).data
dict = {'demandas': demandas, 'total_paginas': total_paginas}
return Response(dict)
def post(self, request, format=None):
data = request.data
cliente = data['cliente']
cliente = PessoaJuridica.objects.get(pk=cliente['id'])
unidade_administrativa = data['unidade_administrativa']
unidade_administrativa = UnidadeAdministrativa.objects.get(
pk=unidade_administrativa['id'])
analista_tecnico_responsavel = None
if 'analista_tecnico_responsavel' in data:
if data['analista_tecnico_responsavel'] is not None and 'id' in data[
'analista_tecnico_responsavel']:
analista_tecnico_responsavel = data[
'analista_tecnico_responsavel']
analista_tecnico_responsavel = PessoaFisica.objects.get(
pk=analista_tecnico_responsavel['id'])
del data['analista_tecnico_responsavel']
responsavel = None
if 'responsavel' in data:
if data['responsavel'] is not None and 'id' in data['responsavel']:
responsavel = data['responsavel']
responsavel = PessoaFisica.objects.get(pk=responsavel['id'])
del data['responsavel']
natureza_demanda = None
if 'natureza_demanda' in data:
if data['natureza_demanda'] is not None and 'id' in data[
'natureza_demanda']:
natureza_demanda = NaturezaDemanda.objects.get(
pk=data['natureza_demanda']['id'])
del data['natureza_demanda']
propostas = data['propostas']
observacoes = data['observacoes']
ocorrencias = data['ocorrencias']
orcamento = data['orcamento']
fase_atividades = None
if 'fase_atividades' in data:
if data['fase_atividades']:
fase_atividades = data['fase_atividades']
del data['fase_atividades']
if 'parcelas' in data:
del data['parcelas']
demandas_complementares = None
if 'demandas_complementares' in data:
demandas_complementares = data['demandas_complementares']
del data['demandas_complementares']
del data['cliente']
del data['propostas']
del data['observacoes']
del data['ocorrencias']
del data['orcamento']
del data['unidade_administrativa']
demanda = Demanda(**data)
demanda.cliente = cliente
demanda.unidade_administrativa = unidade_administrativa
if 'data_aprovacao_demanda' in data:
data_string = data['data_aprovacao_demanda']
demanda.data_aprovacao_demanda = converter_string_para_data(
data_string)
if 'data_inicio' in data:
data_string = data['data_inicio']
demanda.data_inicio = converter_string_para_data(data_string)
if 'data_fim' in data:
data_string = data['data_fim']
demanda.data_fim = converter_string_para_data(data_string)
if 'data_criacao' in data:
data_string = data['data_criacao']
demanda.data_criacao = converter_string_para_data(data_string)
if 'data_finalizacao' in data:
data_string = data['data_finalizacao']
demanda.data_finalizacao = converter_string_para_data(data_string)
demanda.analista_tecnico_responsavel = analista_tecnico_responsavel
demanda.responsavel = responsavel
demanda.natureza_demanda = natureza_demanda
demanda.save()
self.salvar_proposta(propostas, demanda)
self.salvar_observacoes(observacoes, demanda)
self.salvar_ocorrencias(ocorrencias, demanda)
self.salvar_orcamento(orcamento, demanda)
self.salvar_fase_atividades(fase_atividades, demanda)
self.salvar_demandas_complementares(demandas_complementares, demanda)
if demanda.tipo_demanda != 'I':
self.calcular_estatisticas_demanda(demanda)
return Response(serializarDemanda(demanda.id))