Agregar funcionalidad para firmar la evaluacion.

[JuanCamiloMartinezLopez]

Se requiere realizar en la vista visualización evaluación la funcionalidad para ver y firmar el documento resultante.

Sub Tareas

• Implementar la firma múltiple para el módulo de evaluación.

• Crear un servicio en el mid que a partir del asignacion_evaluador_id pueda validar estados para permitir la firma, así como calcular la etapa en la que se encuentra según los estados de los evaluadores asignados.
  

• Implementar en el cliente un componente de visualización del documento, como un botón para firmarlo.

• La acción de firmar debe realizar el cambio de estado de la asignación.

Criterios de aceptación

• Funcionalidad para firmar creada en el mid.
• Funcionalidad implementada en el cliente.
• Issue documentada.

Requerimientos

No aplica

Definition of Ready - DoR

• Está refinada y estimada en puntos de historia por el equipo.
• Incluye la descripción y criterios de aceptación, con el detalle funcional y especificaciones técnicas, de forma entendible por cualquier miembro del equipo.
• No tiene bloqueos que impidan su ejecución.
• Las dependencias están identificadas y resueltas.
• Puede ser probada dentro del Sprint.

Definition of Done - DoD - Desarrollo

• Desarrollo en local.
• Push en Feature.
• Pruebas locales (funcionales).
• PR a Develop.
• Criterios de aceptación cumplidos.
• Documentación de issue realizada.
• Aprobada por SM/Líder técnico.

[stevencol]

Para poder implementar la funcionalidad mayor parte en el mid, se requieren ciertas funcionalidades para obtener ciertos datos:

1- Consultar id_documento de evaluación id -> crear consutla

2: Nombre de Firmante , cargo-> crear consulta

3, tipo documento , numero documento ---> se obtiene desde el token

4 File -- se obtiene desde el cliente

[stevencol]

Se crea lógica en el back:

1: Consultando la info de la persona que va a firma:

func ConsultarInfoPersonaNatural(numero_documento string) (info_persona_natural *models.Persona, outputError error) {

	defer func() {
		if err := recover(); err != nil {
			outputError = fmt.Errorf("%v", err)
			panic(outputError.Error())
		}
	}()

	var consulta_info_persona_natural []models.Persona
	query := fmt.Sprintf("/informacion_persona_natural?query=Id:%s", numero_documento)
	fmt.Print(beego.AppConfig.String("UrlcrudAgora") + query)
	if response, err := helpers.GetJsonWSO2Test(beego.AppConfig.String("UrlcrudAgora")+query, &consulta_info_persona_natural); err == nil && response == 200 {

		if consulta_info_persona_natural != nil && consulta_info_persona_natural[0].Id != "" {

			info_persona_natural = &consulta_info_persona_natural[0]

		} else {
			outputError = fmt.Errorf("error al consultar la información de la persona natural")
			return nil, outputError
		}
	} else {
		outputError = fmt.Errorf("error al consultar la información de la persona natural")
		return info_persona_natural, outputError
	}
	fmt.Println(info_persona_natural)
	return info_persona_natural, nil
}

2: consultado la inflo de la asignación

func ConsultarAsignacion(id_asiganacion int) (asignacion *models.AsignacionEvaluador, outputError error) {

	defer func() {
		if err := recover(); err != nil {
			outputError = fmt.Errorf("%v", err)
			panic(outputError.Error())
		}
	}()
	var map_response = make(map[string]interface{})
	var consulta_asignaciones []models.AsignacionEvaluador

	query := fmt.Sprintf("/asignacion_evaluador?query=Id:%d", id_asiganacion)
	fmt.Println(beego.AppConfig.String("urlEvaluacionCumplidosCrud") + query)
	if response, err := helpers.GetJsonWSO2Test(beego.AppConfig.String("urlEvaluacionCumplidosCrud")+query, &map_response); err == nil && response == 200 {

		helpers.LimpiezaRespuestaRefactor(map_response, &consulta_asignaciones)

		if consulta_asignaciones != nil && consulta_asignaciones[0].Id != 0 {

			asignacion = &consulta_asignaciones[0]

		} else {
			outputError = fmt.Errorf("no hay información de la asignación")
			return nil, outputError
		}

	} else {
		outputError = fmt.Errorf("error al consultar la información de la asignación")
		return asignacion, outputError
	}
	fmt.Println(asignacion)
	return asignacion, nil
}

3 - Consultar Información de la evaluación con la finalidad de consultar el documento id:

func ConsultarEvaluacion(id_evalacion int) (evaluacion *models.Evaluacion, outputError error) {

	defer func() {
		if err := recover(); err != nil {
			outputError = fmt.Errorf("%v", err)
			panic(outputError.Error())
		}
	}()

	var consulta_evaluaciones []models.Evaluacion
	var map_response = make(map[string]interface{})
	query := fmt.Sprintf("/evaluacion/?query=Id:%d", id_evalacion)
	if response, err := helpers.GetJsonWSO2Test(beego.AppConfig.String("urlEvaluacionCumplidosCrud")+query, &map_response); err == nil && response == 200 {
		helpers.LimpiezaRespuestaRefactor(map_response, &consulta_evaluaciones)
		if consulta_evaluaciones != nil && consulta_evaluaciones[0].Id != 0 {

			evaluacion = &consulta_evaluaciones[0]

		} else {
			outputError = fmt.Errorf("error al consultar la información de la persona natural")
			return nil, outputError
		}
	} else {
		outputError = fmt.Errorf("error al consultar la información de la persona natural")
		return nil, outputError
	}
	fmt.Println(evaluacion)
	return evaluacion, nil
}

4 : consultar documentos crud:

func consultarDocumentocrud(id_documento int) (documento *models.DocumentoCrud, outputError error) {

	defer func() {
		if err := recover(); err != nil {
			outputError = fmt.Errorf("%v", err)
			panic(outputError.Error())
		}
	}()

	var peticion_consulta_documento []models.DocumentoCrud

	query := fmt.Sprintf("/documento/?limit=-1&query=Id.in:%d", id_documento)
	fmt.Println(beego.AppConfig.String("UrlDocumentosCrud") + query)
	if response, _ := helpers.GetJsonTest(beego.AppConfig.String("UrlDocumentosCrud")+query, &peticion_consulta_documento); response == 200 {

		if peticion_consulta_documento != nil && peticion_consulta_documento[0].Id != 0 {

			documento = &peticion_consulta_documento[0]
			return documento, nil

		}

	}
	outputError = fmt.Errorf("error al consultar el documento en el documento crud")

	return nil, outputError
}

5 Consultar el documento en gestor documental

func consultarGestorDocumental(enlace string) (documento *models.DocumentoEnlace, outputError error) {

	defer func() {
		if err := recover(); err != nil {
			outputError = fmt.Errorf("%v", err)
			panic(outputError.Error())
		}
	}()

	var peticion_consulta_documento models.DocumentoEnlace
	query := fmt.Sprintf("/document/%s", enlace)
	fmt.Println(beego.AppConfig.String("UrlGestorDocumental") + query)
	if response, err := helpers.GetJsonWSO2Test(beego.AppConfig.String("UrlGestorDocumental")+query, &peticion_consulta_documento); err == nil && response == 200 {

		if peticion_consulta_documento.File != "" {
			documento = &peticion_consulta_documento
			return documento, nil
		}

	} else {
		outputError = fmt.Errorf("error al consultar el documento en el gestor documental")
		return nil, outputError
	}
	return nil, nil
}

6 Verificar si es primer firmante

func VerificarPrimerFirmante(id_evaluacion int, estado_abreviacion string) (primer_firmante bool, outputError error) {

	primer_firmante = true

	asiganciones, err := ConsultarAsignacionesPorIdEvaluacion(id_evaluacion)

	if err != nil {
		outputError = fmt.Errorf("error al consultar asignaciones")
		return false, outputError
	}

	for _, asigancion := range *asiganciones {

		estado_asiganacion, err := ConsultarEstadoActualAsingacion(asigancion.Id)

		if err != nil {
			fmt.Printf("error al consultar el estado de la asignacion %s", estado_asiganacion.Id)

		}

		if estado_asiganacion.EstadoAsignacionEvaluador.CodigoAbreviacion == estado_abreviacion {
			primer_firmante = false
			break
		}

	}

	return primer_firmante, outputError

}

Consultar si es ultimo firmante

func VerificarUltimoFirmanteFirmante(id_evaluacion int, estado_abreviacion string) (ultimo_firmante bool, outputError error) {

	ultimo_firmante = true
	var estados []string

	asiganciones, err := ConsultarAsignacionesPorIdEvaluacion(id_evaluacion)

	if err != nil {
		outputError = fmt.Errorf("error al consultar asignaciones")
		return false, outputError
	}

	for _, asigancion := range *asiganciones {

		estado_asiganacion, err := ConsultarEstadoActualAsingacion(asigancion.Id)

		if err != nil {
			fmt.Printf("error al consultar el estado de la asignacion %s", estado_asiganacion.Id)

		}

		if estado_asiganacion.EstadoAsignacionEvaluador.CodigoAbreviacion != "EAP" {
			estados = append(estados, estado_asiganacion.EstadoAsignacionEvaluador.CodigoAbreviacion)
		}

	}

	if len(estados) > 1 {
		ultimo_firmante = false
	}
	return ultimo_firmante, outputError

}

"Con la información recolectada de las peticiones anteriores, se crea el cuerpo de la solicitud."

func crearPeticionFirmaElectronica(persona models.Persona, documento_gestor_documental models.DocumentoEnlace, evaluacion models.Evaluacion, estapa_firma int) (peticion_firma models.PeticionFirmaElectronicaCrud) {

	peticion_firma = models.PeticionFirmaElectronicaCrud{
		IdTipoDocumento: 158,
		Nombre:          fmt.Sprintf("Evaluacion del contrato %s , con vigencioa", evaluacion.ContratoSuscritoId, evaluacion.VigenciaContrato),
		Metadatos:       models.Metadatos{},
		Representantes:  []models.FirmanteRepresentante{},
		Firmantes: []models.FirmanteRepresentante{
			{Nombre: persona.PrimerApellido + " " + persona.SegundoNombre + " " + persona.PrimerApellido + " " + persona.SegundoApellido, Cargo: "Evaluador", TipoId: persona.TipoDocumento.Abreviatura, Identificacion: persona.Id},
		},
		Descripcion: "Firma de la evaluación del contrato",
		EtapaFirma:  estapa_firma,
		File:        documento_gestor_documental.File,
	}

	return peticion_firma

}

7 Funcion que reliza la peticon dela firma:

func FirmarDocumento(peticion_firma models.PeticionFirmaElectronicaCrud) (mapResponse map[string]interface{}, outputError error) {

	defer func() {
		if err := recover(); err != nil {
			outputError = fmt.Errorf("%v", err)
			panic(outputError.Error())
		}
	}()

	query := fmt.Sprintf("/firma_electronica_mid/v1/firma_electronica")
	var respuestaPeticion map[string]interface{}
	if err := helpers.SendJson(beego.AppConfig.String("UrlFirmaElectronica")+query, "POST", &respuestaPeticion, peticion_firma); err != nil {
		mapResponse := make(map[string]interface{})
		mapResponse["Message"] = "La solicitud de firma se completo correctamente"
	}

	if respuestaPeticion["Success"] == false {
		outputError = fmt.Errorf("error al desabilitar el estado")
		return nil, outputError
	}

	return mapResponse, nil

}

8: Función que agrupa la peticiones

func EjecutarProcesoDefirma(peticion_firma models.PeticionFirmaElectronica) (mapResponse map[string]interface{}, outputError error) {

	defer func() {
		if err := recover(); err != nil {
			outputError = fmt.Errorf("%v", err)
			panic(outputError.Error())
		}
	}()

	var estapa_evalucion = 0

	estado_actual, err := ConsultarEstadoActualAsingacion(peticion_firma.AsignacionId)

	if err != nil {
		outputError = fmt.Errorf("error al consultar el estado de la evaluacion")
	}

	if estado_actual.EstadoAsignacionEvaluador.CodigoAbreviacion == "ER" {
		//Consultar información de la persona natural
		info_persona_natural, err := ConsultarInfoPersonaNatural(peticion_firma.PersonaId)

		if err != nil {
			outputError = fmt.Errorf("error al consultar la información de la persona natural")
			return nil, outputError
		}

		//consultar la asignacion
		asignacion, err := ConsultarAsignacion(peticion_firma.AsignacionId)

		if err != nil {
			outputError = fmt.Errorf("error al consultar la información de la asignación")
			return nil, outputError
		}

		//consultar la evaluacion
		evaluacion, err := ConsultarEvaluacion(asignacion.EvaluacionId.Id)

		if err != nil {
			outputError = fmt.Errorf("error al consultar la información de la evaluación")
			return nil, outputError
		}

		//consultar el documento en documento crud
		documento_crud, err := consultarDocumentocrud(evaluacion.DocumentoId)

		if err != nil {
			outputError = fmt.Errorf("error al consultar el documento en el documento crud")
			return nil, outputError
		}

		primero_firmante, err := VerificarPrimerFirmante(asignacion.EvaluacionId.Id, "EAP")
		if primero_firmante {
			estapa_evalucion = 2
		}

		ultimo_firmante, err := VerificarUltimoFirmanteFirmante(asignacion.EvaluacionId.Id, "EAP")

		if ultimo_firmante {
			estapa_evalucion = 3
		}

		//consultar el documento en el gestor documental
		documento_gestor_documental, err := consultarGestorDocumental(documento_crud.Enlace)

		//crear la peticion de firma

		peticion_firma_electronica := crearPeticionFirmaElectronica(*info_persona_natural, *documento_gestor_documental, *evaluacion, estapa_evalucion)

		fmt.Println(peticion_firma_electronica)

		FirmarDocumento(peticion_firma_electronica)

		respuesta_firma, err := CambioEstadoAsignacionEvaluacion(peticion_firma.AsignacionId, "EAP")

		fmt.Println(respuesta_firma)

		guardarDocumentoFirmado(1, asignacion.EvaluacionId.Id)

		if err != nil {

			return nil, err
		}

		mapResponse := make(map[string]interface{})
		mapResponse["Message"] = "El documento se firmo correctamente"

	} else {
		mapResponse := make(map[string]interface{})
		mapResponse["Message"] = "El estado de la asignación no permite la firma"

	}

	return mapResponse, nil
}

Por el momento se probo hasta el flujo de realizar la petición a la firma , pero no es posible continuar ya que alpercer el servico esta falladando_

[stevencol]

Se sigue avanzando con el desarrollo y se prueba.

1: Se prueba con una asignación ya firmada

2: Se prueba con la posibilidad de que llegue a haber un solo firmante.

[stevencol]

1 : Se prueba con 2 evaluadores con la finalidad de colocar el header y footer :

• Primer firmante:
  

[stevencol]

Se espera que el flujo del sistema esta completo , no se pude realizar pruebas de último firmante con etapa 3, ya que informa que la lista de firmantes es requerida

Json de la solicitud *Se omite base64 por tamaña de textoy tambien numero de documento

[
    {
        "descripcion": "Firma de la evaluación del contrato",
        "file": "",
        "firmantes": [
            {
                "cargo": "Evaluador",
                "identificacion": "++++",
                "nombre": "DAZA PAOLO DAZA CORREDOR",
                "tipoId": "CC"
            }
        ],
        "etapa_firma": 3,
        "IdTipoDocumento": 158,
        "metadatos": {},
        "nombre": "Evaluacion del contrato 2035 , con vigencia 2024",
        "representantes": []
    }
]