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))