Crear endpoints para oficina de contratación y ordenadores

[JuanCamiloMartinezLopez]

Se requiere realizar el desarrollo de los endpoints en el mid para la oficina de contratacion y ordenadores según https://github.com/udistrital/Cumplidos_y_certificaciones_documentacion/issues/83

Sub Tareas

• [x] Crear los controladores, helpers y modelos necesarios para las funciones propuestas.
• [x] Tener en cuenta los helpers propuesto para una refactorizacion de codigo.

Criterios de aceptación

• [x] issue documentada.
• [x] Endpoints desarrollados.

Requerimientos

No aplica

Definition of Ready - DoR

• [x] Está refinada y estimada en puntos de historia por el equipo.
• [x] 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.
• [x] No tiene bloqueos que impidan su ejecución.
• [x] Las dependencias están identificadas y resueltas.
• [x] 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]

Se inicia con actividad, donde se presentan múltiples inconvenientes ya que no reconoce el router ni el commentsRouter_controllers_controladores_ordenador, la única solución temporal es eliminar Y su implementacion

import (
auditoria "github.com/udistrital/auditoria"
)

[stevencol]

Se avanza en la creación del enpoint que trae todos los contratos del ordenador:

package helpers_ordenador

import (
    "bytes"
    "encoding/json"
    "fmt"
    "github.com/astaxie/beego"
    "github.com/udistrital/revision_cumplidos_proveedores_mid/models"
    "net/http"
    "time"
)

func ObtenerDependencias(documentoOrdenador string) (dependenciasList []models.Dependencia, errorOutput interface{}) {
    defer func() {
        if err := recover(); err != nil {
            errorOutput = map[string]interface{}{
                "Success": false,
                "Status":  400,
                "Message": "Error al consultar las dependencias: " + documentoOrdenador,
                "Error":   err,
            }
        }
    }()

    var respuesta map[string]interface{}
    var urlRequest = beego.AppConfig.String("UrlAdministrativaJBPM") + "/dependencias_sic/" + documentoOrdenador
    println(urlRequest)
    response, err := getJsonWSO2Test(urlRequest, &respuesta)
    if err != nil || response != 200 {
        errorOutput = map[string]interface{}{
            "Success": false,
            "Status":  response,
            "Message": "Error al consultar el servicio de dependencias.",
            "Error":   err,
        }

        return nil, errorOutput
    }

    if respuesta != nil {

        if dependenciasMap, ok := respuesta["DependenciasSic"].(map[string]interface{}); ok {

            for _, depList := range dependenciasMap {

                if list, ok := depList.([]interface{}); ok {

                    for _, dep := range list {

                        depMap := dep.(map[string]interface{})
                        dependencia := models.Dependencia{

                            Codigo: depMap["ESFCODIGODEP"].(string),
                            Nombre: depMap["ESFDEPENCARGADA"].(string),
                        }
                        dependenciasList = append(dependenciasList, dependencia)
                    }

                }
            }
        }
    }

    return dependenciasList, nil
}

func ObtenerContatosPorOdenador(documentoOrdenador string) (contratosList []models.ContratoSimple, errorOutput interface{}) {
    defer func() {
        if err := recover(); err != nil {
            errorOutput = map[string]interface{}{
                "Success": false,
                "Status":  400,
                "Message": "Error al consultar los contratos: " + documentoOrdenador,
                "Error":   err,
            }
        }
    }()

    now := time.Now()

    var dependenciasList, errorDependencias = ObtenerDependencias(documentoOrdenador)
    if errorDependencias != nil {
        return nil, errorDependencias
    }

    var respuesta map[string]interface{}
    yearStr := fmt.Sprintf("%d", now.Year())

    for _, dependencia := range dependenciasList {
        urlRequest := beego.AppConfig.String("UrlAdministrativaJBPM") + "/contratos_dependencia/" + dependencia.Codigo + "/" + yearStr + "/" + yearStr
        println(urlRequest)

        response, err := getJsonWSO2Test(urlRequest, &respuesta)
        if err != nil || response != 200 {
            errorOutput = map[string]interface{}{
                "Success": false,
                "Status":  response,
                "Message": "Error al consultar el servicio de dependencias.",
                "Error":   err,
            }
            return nil, errorOutput
        }

        if respuesta != nil {
            if dependenciasMap, ok := respuesta["contratos"].(map[string]interface{}); ok {
                for _, depList := range dependenciasMap {
                    if list, ok := depList.([]interface{}); ok {
                        for _, dep := range list {
                            depMap := dep.(map[string]interface{})
                            contrato := models.ContratoSimple{
                                NumeroContrato: depMap["numero_contrato"].(string),
                                Vigencia:       depMap["vigencia"].(string),
                            }
                            contratosList = append(contratosList, contrato)
                        }
                    }
                }
            }
        }
    }

    return contratosList, nil
}

func getJsonWSO2Test(urlp string, target interface{}) (status int, err error) {
    b := new(bytes.Buffer)
    client := &http.Client{}
    req, err := http.NewRequest("GET", urlp, b)
    req.Header.Set("Accept", "application/json")
    r, err := client.Do(req)
    if err != nil {
        beego.Error("error", err)
        return r.StatusCode, err
    }
    defer func() {
        if err := r.Body.Close(); err != nil {
            beego.Error(nil, err)
        }
    }()

    return r.StatusCode, json.NewDecoder(r.Body).Decode(target)
}

Respuesta:

[stevencol]

Se modifica lógica ya que lo desarrollado no era lo requerido :

Helper que devuelve los contratos :

func ObteberNumeroDeContrato(documentoOrdenador string) (dependencias string, errorOutput interface{}) {

    defer func() {
        if err := recover(); err != nil {
            errorMessage := fmt.Sprintf("%v", err)
            errorOutput = map[string]interface{}{
                "Success": false,
                "Status":  400,
                "Message": "Error al consultar las dependencias: " + documentoOrdenador + " - " + errorMessage,
                "Error":   errorMessage,
            }
            fmt.Println("Error recuperado:", errorMessage)
        }
    }()

    var respuesta map[string]interface{}
    var urlRequest = beego.AppConfig.String("UrlProveedoresCrud") + "/cambio_estado_cumplido/?query=DocumentoResponsable:" + documentoOrdenador + ",EstadoCumplidoId.Abreviacion:PRO"
    response, err := getJsonWSO2Test(urlRequest, &respuesta)

    if err != nil || response != 200 {
        errorMessage := fmt.Sprintf("%v", err)
        errorOutput = map[string]interface{}{
            "Success": false,
            "Status":  response,
            "Message": "Error al consultar Cumplidos para el proveedor." + errorMessage,
            "Error":   errorMessage,
        }
        logs.Error(err)
        return "", errorOutput
    }
    var dependenciasString []string
    var dependenciasList []models.CambioEstadoCumplido
    if len(respuesta["Data"].([]interface{})[0].(map[string]interface{})) != 0 {
        LimpiezaRespuestaRefactor(respuesta, &dependenciasList)

        for _, dependencia := range dependenciasList {

            dependenciasString = append(dependenciasString, dependencia.CumplidoProveedorId.NumeroContrato)
        }

    }
    listaString := strings.Join(dependenciasString, "|") + "|"
    return listaString, nil
}

Helper que devuelve info del proveedor :

func ObtenerInfoProveedor(IdProveedor string) (Provedor *models.Proveedor, errorOutput interface{}) {

    defer func() {
        if err := recover(); err != nil {
            errorOutput = map[string]interface{}{
                "Success": false,
                "Status":  400,
                "Message": "Error al consultar las dependencias: " + IdProveedor,
                "Error":   err,
            }
        }
    }()

    var respuesta []models.Proveedor
    urlRequest := beego.AppConfig.String("UrlcrudAgora") + "/informacion_proveedor/?query=id:" + IdProveedor
    println(urlRequest)
    response, err := getJsonWSO2Test(urlRequest, &respuesta)

    if err != nil || response != 200 {
        errorMessage := fmt.Sprintf("%v", err)
        errorOutput = map[string]interface{}{
            "Success": false,
            "Status":  400,
            "Message": "Error el consultar los contratros para el ordenador en .GetContratos" + errorMessage,
            "Error":   errorMessage,
        }
        logs.Error(err)
        return nil, errorOutput
    }

    if respuesta != nil {
        Provedor = &respuesta[0]
        return Provedor, nil
    }

    return nil, nil

}

Helper que devuelve info esperada:

func ObternerContratos(documentoOrdenador string) (ContratosList []models.Contrato, errorOutput interface{}) {

    defer func() {
        if err := recover(); err != nil {
            errorMessage := fmt.Sprintf("%v", err)
            errorOutput = map[string]interface{}{
                "Success": false,
                "Status":  400,
                "Message": "Error al consultar las dependencias: " + documentoOrdenador + " - " + errorMessage,
                "Error":   errorMessage,
            }
            fmt.Println("Error recuperado:", errorMessage)
        }
    }()

    cumplidos, e := ObteberNumeroDeContrato(documentoOrdenador)

    if e != nil || cumplidos == "" {
        return nil, e
    }

    var respuesta []models.ContratoProveedor
    urlRequest := beego.AppConfig.String("UrlcrudAgora") + "/contrato_general/?query=ContratoSuscrito.NumeroContrato.in:" + cumplidos
    println(urlRequest)
    response, err := getJsonWSO2Test(urlRequest, &respuesta)

    if err != nil || response != 200 {
        errorMessage := fmt.Sprintf("%v", err)
        errorOutput = map[string]interface{}{
            "Success": false,
            "Status":  400,
            "Message": "Error el consultar los contratros para el ordenador en .GetContratos" + errorMessage,
            "Error":   errorMessage,
        }
        logs.Error(err)
        return nil, errorOutput
    }

    for _, contrato := range respuesta {
        var ultimoContrato = len(contrato.ContratoSuscrito) - 1
        if proveedor, err := ObtenerInfoProveedor(strconv.Itoa(contrato.Contratista)); err == nil && proveedor != nil {
            //contratoDisponibilidad, _ := ObtenerContratoDisponiblidad(contrato.ContratoSuscrito[ultimoContrato].NumeroContrato.Id)
            contrato := models.Contrato{
                TipoContrato:    contrato.TipoContrato.TipoContrato,
                NumeroContrato:  contrato.ContratoSuscrito[ultimoContrato].NumeroContrato.Id,
                Vigencia:        contrato.ContratoSuscrito[ultimoContrato].Vigencia,
                Dependencia:     contrato.DependenciaSolicitante,
                NombreProveedor: proveedor.NomProveedor,
            }
            ContratosList = append(ContratosList, contrato)

        }
    }

    return ContratosList, nil
}

Respuesta Postman

[stevencol]

Se crea helper para obtener estado por abreviación

func ObtenerEstado(estado string) (Estado *models.EstadoCumplidoId, errorOutput interface{}) {

    defer func() {
        if err := recover(); err != nil {
            errorOutput = map[string]interface{}{
                "Success": false,
                "Status":  400,
                "Message": "Error al consultar las ObtenerEstado: " + estado,
                "Error":   err,
            }
        }
    }()

    var respuesta map[string]interface{}
    urlRequest := beego.AppConfig.String("UrlProveedoresCrud") + "/estado_cumplido?query=Abreviacion:" + estado
    println(urlRequest)
    response, err := getJsonWSO2Test(urlRequest, &respuesta)

    if err != nil || response != 200 {
        errorMessage := fmt.Sprintf("%v", err)
        errorOutput = map[string]interface{}{
            "Success": false,
            "Status":  400,
            "Message": "Error el consultar los contratros para el ordenador en .GetContratos" + errorMessage,
            "Error":   errorMessage,
        }
        logs.Error(err)
        return nil, errorOutput
    }
    var estado_List []models.EstadoCumplidoId

    LimpiezaRespuestaRefactor(respuesta, &estado_List)
    if respuesta != nil {
        fmt.Println(estado_List[0].Abreviacion)
        return Estado, nil

    }

    return nil, nil

}

[stevencol]

Se Crean Helpers para contratación:

package helpers_contratacion

import (
    "fmt"
    "github.com/astaxie/beego"
    "github.com/astaxie/beego/logs"
    "github.com/udistrital/revision_cumplidos_proveedores_mid/helpers"
    "github.com/udistrital/revision_cumplidos_proveedores_mid/helpers/helpers_ordenador"
    "github.com/udistrital/revision_cumplidos_proveedores_mid/models"
    "strconv"
    "strings"
)

func ObteberNumeroDeContrato() (dependencias string, errorOutput interface{}) {

    defer func() {
        if err := recover(); err != nil {
            errorMessage := fmt.Sprintf("%v", err)
            errorOutput = map[string]interface{}{
                "Success": false,
                "Status":  400,
                "Message": "Error al consultar las dependencias: " + " - " + errorMessage,
                "Error":   errorMessage,
            }
            fmt.Println("Error recuperado:", errorMessage)
        }
    }()

    var respuesta map[string]interface{}
    var urlRequest = beego.AppConfig.String("UrlProveedoresCrud") + "/cambio_estado_cumplido/?query=EstadoCumplidoId.Abreviacion:PRC"
    response, err := helpers.GetJsonWSO2Test(urlRequest, &respuesta)

    if err != nil || response != 200 {
        errorMessage := fmt.Sprintf("%v", err)
        errorOutput = map[string]interface{}{
            "Success": false,
            "Status":  response,
            "Message": "Error al consultar Cumplidos para el proveedor." + errorMessage,
            "Error":   errorMessage,
        }
        logs.Error(err)
        return "", errorOutput
    }
    var dependenciasString []string
    var dependenciasList []models.CambioEstadoCumplido
    if len(respuesta["Data"].([]interface{})[0].(map[string]interface{})) != 0 {
        helpers.LimpiezaRespuestaRefactor(respuesta, &dependenciasList)

        for _, dependencia := range dependenciasList {

            dependenciasString = append(dependenciasString, dependencia.CumplidoProveedorId.NumeroContrato)
        }

    }
    listaString := strings.Join(dependenciasString, "|") + "|"
    return listaString, nil
}

func ObternerContratos() (ContratosList []models.Contrato, errorOutput interface{}) {
    defer func() {
        if err := recover(); err != nil {
            errorMessage := fmt.Sprintf("%v", err)
            errorOutput = map[string]interface{}{
                "Success": false,
                "Status":  400,
                "Message": "Error al consultar las dependencias: " + " - " + errorMessage,
                "Error":   errorMessage,
            }
            fmt.Println("Error recuperado:", errorMessage)
        }
    }()

    cumplidos, e := ObteberNumeroDeContrato()

    if e != nil || cumplidos == "" {

        return nil, e
    }

    var respuesta []models.ContratoProveedor
    urlRequest := beego.AppConfig.String("UrlcrudAgora") + "/contrato_general/?query=ContratoSuscrito.NumeroContrato.in:" + cumplidos
    response, err := helpers.GetJsonWSO2Test(urlRequest, &respuesta)

    if err != nil || response != 200 {

        errorMessage := fmt.Sprintf("%v", err)
        errorOutput = map[string]interface{}{
            "Success": false,
            "Status":  400,
            "Message": "Error el consultar los contratros para el ordenador en .GetContratos" + errorMessage,
            "Error":   errorMessage,
        }
        logs.Error(err)
        return nil, errorOutput
    }
    for _, contrato := range respuesta {
        var ultimoContrato = len(contrato.ContratoSuscrito) - 1
        if proveedor, err := helpers_ordenador.ObtenerInfoProveedor(strconv.Itoa(contrato.Contratista)); err == nil && proveedor != nil {
            /*contratoDisponibilidad, _ := ObtenerContratoDisponiblidad(contrato.ContratoSuscrito[ultimoContrato].NumeroContrato.Id)*/
            contrato := models.Contrato{
                TipoContrato:    contrato.TipoContrato.TipoContrato,
                NumeroContrato:  contrato.ContratoSuscrito[ultimoContrato].NumeroContrato.Id,
                Vigencia:        contrato.ContratoSuscrito[ultimoContrato].Vigencia,
                Dependencia:     contrato.DependenciaSolicitante,
                NombreProveedor: proveedor.NomProveedor,
            }
            ContratosList = append(ContratosList, contrato)

        }
    }

    return ContratosList, nil
}

[stevencol]

Se crean Controlador Contratacion:

package controladores_contratacion

import (
    "github.com/astaxie/beego"
    "github.com/astaxie/beego/logs"
    "github.com/udistrital/revision_cumplidos_proveedores_mid/helpers/helpers_contratacion"
)

type RevisionCumplidoContratacionController struct {
    beego.Controller
}

func (c *RevisionCumplidoContratacionController) URLMapping() {
    c.Mapping("ObtenerPendientesContratacion", c.ObtenerPendientesContratacion)
}

//ObtenerPendientesRevisionOrdenador
//@Title ObtenerPendientesRevisionOrdenador
//@Description Metodo para que el personal de c  Obtenga los contratos para la aprobacion de pago
//Success 200 {object} models.Contrato
// @Failure 403 :document is empty
//@router /solicitudes-pago/ [get]
func (c *RevisionCumplidoContratacionController) ObtenerPendientesContratacion() {

    defer func() {
        if err := recover(); err != nil {
            logs.Error(err)
            localError := err.(map[string]interface{})
            c.Data["message"] = beego.AppConfig.String("appname") + "/" + "RevisionCumplidoOrdenadorController" + "/" + (localError["funcion"]).(string)
            c.Data["data"] = localError["err"]
            if status, ok := localError["status"]; ok {
                c.Abort(status.(string))
            } else {
                c.Abort("500")
            }
        }
    }()

    dependencias, err := helpers_contratacion.ObternerContratos()

    if err != nil {
        c.Ctx.Output.SetStatus(400)
        c.Data["json"] = err
    } else if dependencias == nil {
        println("2")
        c.Data["json"] = map[string]interface{}{"Succes": true, "Status:": 204, "Message": "No hay datos", "Data": dependencias}
    } else {
        println("3")
        c.Data["json"] = map[string]interface{}{"Succes": true, "Status:": 200, "Message": "Consulta completa", "Data": dependencias}
    }
    c.ServeJSON()
}

[jcmurilloa]

Buen dia. Por favor recuerden que las issues deben ser culminadas en el respectivo sprint, hoy estamos iniciando el sprint 14 y aún no se culmina esta tarea.

[stevencol]

Se modifica Helper que permitía actualizar estado de aprobado y regresarlo al estado anterior, por un helper que trae todos las solicitudes no mayores a 15 dias que tengan el estado aprobado por ordenador.

func ListaCumplidosReversibles(documentoOrdenador string) (soliciudes []models.Contrato, errorOutput interface{}) {
    defer func() {
        if err := recover(); err != nil {
            errorMessage := fmt.Sprintf("%v", err)
            errorOutput = map[string]interface{}{
                "Success": false,
                "Status":  400,
                "Message": "Error al consultar las dependencias: " + documentoOrdenador + " - " + errorMessage,
                "Error":   errorMessage,
            }
            fmt.Println("Error recuperado:", errorMessage)
        }
    }()
    fechaActual := time.Now()
    fechaMenosQuinceDias := fechaActual.AddDate(0, 0, -15)
    fechaFormateada := fechaMenosQuinceDias.Format("01/02/2006")
    cumplidos, e := ObteberNumerosDeContrato(documentoOrdenador, "AO,FechaCreacion__gt:"+fechaFormateada)
    fmt.Println(fechaFormateada)
    if e != nil || cumplidos == "" {
        return nil, e
    }

    var respuesta []models.ContratoProveedor
    urlRequest := beego.AppConfig.String("UrlcrudAgora") + "/contrato_general/?query=ContratoSuscrito.NumeroContrato.in:" + cumplidos
    println(urlRequest)
    response, err := helpers.GetJsonWSO2Test(urlRequest, &respuesta)

    if err != nil || response != 200 {
        errorMessage := fmt.Sprintf("%v", err)
        errorOutput = map[string]interface{}{
            "Success": false,
            "Status":  400,
            "Message": "Error el consultar los contratros para el ordenador en .GetContratos" + errorMessage,
            "Error":   errorMessage,
        }
        logs.Error(err)
        return nil, errorOutput
    }
    fmt.Println("ssdasdsadadasdasdsad")
    if respuesta == nil {

        return nil, nil

    }

    for _, contrato := range respuesta {

        var ultimoContrato = len(contrato.ContratoSuscrito) - 1
        if proveedor, err := ObtenerInfoProveedor(strconv.Itoa(contrato.Contratista)); err == nil && proveedor != nil {

            if proveedor != nil {
                fmt.Println("proverdor no es nulo")
                contratoDisponibilidad, _ := ObtenerContratoDisponiblidad(contrato.ContratoSuscrito[ultimoContrato].NumeroContrato.Id)

                if contratoDisponibilidad != nil {
                    fmt.Println("contratoDisponibilidad no es nulo")
                    cdprp, _ := ObtenerCrdp(strconv.Itoa(contratoDisponibilidad.NumeroCdp), strconv.Itoa(contratoDisponibilidad.Vigencia))

                    if cdprp != nil {
                        fmt.Println("proverdor no es nulo")
                        contrato := models.Contrato{
                            TipoContrato:       contrato.TipoContrato.TipoContrato,
                            NumeroContrato:     contrato.ContratoSuscrito[ultimoContrato].NumeroContrato.Id,
                            Vigencia:           contrato.ContratoSuscrito[ultimoContrato].Vigencia,
                            Dependencia:        contrato.DependenciaSolicitante,
                            NombreProveedor:    proveedor.NomProveedor,
                            Cdp:                strconv.Itoa(contratoDisponibilidad.NumeroCdp),
                            Rp:                 cdprp.CDPNumeroDisponibilidad,
                            DocumentoOrdenador: documentoOrdenador,
                        }
                        soliciudes = append(soliciudes, contrato)
                    }
                }
            }

        }
    }

    return soliciudes, nil

}

[stevencol]

Se agrega cdp y rp

func ObtenerSolicitudesCumplidos(documento string, estado string) (ContratosList []models.Contrato, errorOutput interface{}) {

    defer func() {
        if err := recover(); err != nil {
            errorMessage := fmt.Sprintf("%v", err)
            errorOutput = map[string]interface{}{
                "Success": false,
                "Status":  400,
                "Message": "Error al consultar las dependencias: " + documento + " - " + errorMessage,
                "Error":   errorMessage,
            }
            fmt.Println("Error recuperado:", errorMessage)
        }
    }()

    cumplidos, e := ObteberNumerosDeContrato(documento, estado)

    if e != nil || cumplidos == "" {
        return nil, e
    }

    var respuesta []models.ContratoProveedor
    urlRequest := beego.AppConfig.String("UrlcrudAgora") + "/contrato_general/?query=ContratoSuscrito.NumeroContrato.in:" + cumplidos
    println(urlRequest)
    response, err := helpers.GetJsonWSO2Test(urlRequest, &respuesta)

    if err != nil || response != 200 {
        errorMessage := fmt.Sprintf("%v", err)
        errorOutput = map[string]interface{}{
            "Success": false,
            "Status":  400,
            "Message": "Error el consultar los contratros para el ordenador en .GetContratos" + errorMessage,
            "Error":   errorMessage,
        }
        logs.Error(err)
        return nil, errorOutput
    }

    for _, contrato := range respuesta {

        var ultimoContrato = len(contrato.ContratoSuscrito) - 1
        if proveedor, err := ObtenerInfoProveedor(strconv.Itoa(contrato.Contratista)); err == nil && proveedor != nil {

            if proveedor != nil {
                fmt.Println("proverdor no es nulo")
                contratoDisponibilidad, _ := ObtenerContratoDisponiblidad(contrato.ContratoSuscrito[ultimoContrato].NumeroContrato.Id)

                if contratoDisponibilidad != nil {
                    fmt.Println("contratoDisponibilidad no es nulo")
                    cdprp, _ := ObtenerCrdp(strconv.Itoa(contratoDisponibilidad.NumeroCdp), strconv.Itoa(contratoDisponibilidad.Vigencia))

                    if cdprp != nil {
                        fmt.Println("proverdor no es nulo")
                        contrato := models.Contrato{
                            TipoContrato:    contrato.TipoContrato.TipoContrato,
                            NumeroContrato:  contrato.ContratoSuscrito[ultimoContrato].NumeroContrato.Id,
                            Vigencia:        contrato.ContratoSuscrito[ultimoContrato].Vigencia,
                            Dependencia:     contrato.DependenciaSolicitante,
                            NombreProveedor: proveedor.NomProveedor,
                            Cdp:             strconv.Itoa(contratoDisponibilidad.NumeroCdp),
                            Rp:              cdprp.CDPNumeroDisponibilidad,
                        }
                        ContratosList = append(ContratosList, contrato)
                    }
                }
            }

        }
    }

    return ContratosList, nil
}

[stevencol]

Se crea Helper para la generación del documento Autorización Pago :

func GenerarAtorizacion(Autorizacion models.AutorizacionPago) (DocumentoGenerado *models.DocuementoAutorizacionPago, errorOutput interface{}) {

    // Obtiene datos de cambio estado
    var respuestaCambioEstado map[string]interface{}
    urlRequest := beego.AppConfig.String("UrlProveedoresCrud") + "/cambio_estado_cumplido/?query=CumplidoProveedorId:" + Autorizacion.SolicitudPagoId + ",EstadoCumplidoId.Abreviacion:AO"
    response, err := helpers.GetJsonWSO2Test(urlRequest, &respuestaCambioEstado)

    if err != nil || response != 200 {
        errorMessage := fmt.Sprintf("%v", err)
        errorOutput = map[string]interface{}{
            "Success": false,
            "Status":  response,
            "Message": "Error al consultar Cumplidos para el proveedor. " + errorMessage,
            "Error":   errorMessage,
        }
        logs.Error(err)
        return nil, errorOutput
    }

    var cambioEstado []models.CambioEstadoCumplido
    data := respuestaCambioEstado["Data"]
    if len(data.([]interface{})) > 0 {
        helpers.LimpiezaRespuestaRefactor(respuestaCambioEstado, &cambioEstado)
    }

    if len(cambioEstado) == 0 {
        return nil, nil
    }

    // Obtiene información de los contratos
    var respuesta []models.ContratoProveedor
    urlRequestContrato := beego.AppConfig.String("UrlcrudAgora") + "/contrato_general/?query=ContratoSuscrito.NumeroContrato:" + cambioEstado[0].CumplidoProveedorId.NumeroContrato
    responseContrato, errContrato := helpers.GetJsonWSO2Test(urlRequestContrato, &respuesta)

    if errContrato != nil || responseContrato != 200 {
        errorMessage := fmt.Sprintf("%v", err)
        errorOutput = map[string]interface{}{
            "Success": false,
            "Status":  responseContrato,
            "Message": "Error al consultar Contrato para el proveedor. " + errorMessage,
            "Error":   errorMessage,
        }
        logs.Error(err)
        return nil, errorOutput
    }

    // Obtiene info Proveedor
    if proveedor, err := ObtenerInfoProveedor(strconv.Itoa(respuesta[0].Contratista)); err == nil && proveedor != nil {
        var respuestaOrdenador []models.Proveedor
        urlRequestOrdenador := beego.AppConfig.String("UrlcrudAgora") + "/informacion_proveedor/?query=NumDocumento:" + strconv.Itoa(cambioEstado[0].DocumentoResponsable)
        responseOrdenador, errOrdenador := helpers.GetJsonWSO2Test(urlRequestOrdenador, &respuestaOrdenador)

        if errOrdenador != nil || responseOrdenador != 200 {
            errorMessage := fmt.Sprintf("%v", err)
            errorOutput = map[string]interface{}{
                "Success": false,
                "Status":  responseOrdenador,
                "Message": "Error al consultar Información del proveedor. " + errorMessage,
                "Error":   errorMessage,
            }
            logs.Error(err)
            return nil, errorOutput
        }

        DocumentoGenerado := &models.DocuementoAutorizacionPago{
            NombreOrdenador:    respuestaOrdenador[0].NomProveedor,
            DocumentoOrdenador: respuestaOrdenador[0].NumDocumento,
            NombreProveedor:    proveedor.NomProveedor,
            DocumentoProveedor: proveedor.NumDocumento,
        }

        return DocumentoGenerado, nil
    }

    return nil, nil
}

Respuesta que se va a usar , para la creacion del documento:

[JuanCamiloMartinezLopez]

@stevencol Revisar la lógica usada en los controladores.

[stevencol]

Se modifica lógica usada y se obtiene esta respuesta

se presentan inconvenientes, ya en documentos cargados se deberían mostrar al menos dos registros;

el llamado se hace qui, tanto documentos como en lista_documentos_cargados_strings , solo hay un registro

var documentos []models.Documento
        urlRequestDocumentosGestion := "http://pruebasapi.intranetoas.udistrital.edu.co:8094/v1/documento/?query=TipoDocumento.DominioTipoDocumento.CodigoAbreviacion:CUMP_PROV,Id.in:" + idDocumentosUnidos + ",Activo:true"
        responseDocuementosGestion, erroDocumentosGestion := helpers.GetJsonWSO2Test(urlRequestDocumentosGestion, &documentos)

        var lista_documentos_cargados_strings []string
        for _, documento := range documentos {
            lista_documentos_cargados_strings = append(lista_documentos_cargados_strings, documento.TipoDocumento.CodigoAbreviacion)
        }

se uso el siente modelo para representar la respuesta :

type SoportePago struct {
    Id                  int
    DocumentoId         int
    CumplidoProveedorId *CumplidoProveedor
    FechaCreacion       time.Time
    FechaModificacion   time.Time
    Activo              bool
}

type Documento struct {
    Id                int            `json:"Id"`
    Nombre            string         `json:"Nombre"`
    Descripcion       string         `json:"Descripcion"`
    Enlace            string         `json:"Enlace"`
    TipoDocumento     *TipoDocumento `json:"TipoDocumento"`
    Metadatos         string         `json:"Metadatos"`
    Activo            bool           `json:"Activo"`
    FechaCreacion     time.Time      `json:"FechaCreacion"`
    FechaModificacion time.Time      `json:"FechaModificacion"`
}

// Estructura anidada para TipoDocumento
type TipoDocumento struct {
    Id                   int                   `json:"Id"`
    Nombre               string                `json:"Nombre"`
    Descripcion          string                `json:"Descripcion"`
    CodigoAbreviacion    string                `json:"CodigoAbreviacion"`
    Activo               bool                  `json:"Activo"`
    NumeroOrden          int                   `json:"NumeroOrden"`
    Tamano               int                   `json:"Tamano"`
    Extension            string                `json:"Extension"`
    Workspace            string                `json:"Workspace"`
    TipoDocumentoNuxeo   string                `json:"TipoDocumentoNuxeo"`
    FechaCreacion        time.Time             `json:"FechaCreacion"`
    FechaModificacion    time.Time             `json:"FechaModificacion"`
    DominioTipoDocumento *DominioTipoDocumento `json:"DominioTipoDocumento"`
}

// Estructura anidada para DominioTipoDocumento
type DominioTipoDocumento struct {
    Id                int       `json:"Id"`
    Nombre            string    `json:"Nombre"`
    Descripcion       string    `json:"Descripcion"`
    CodigoAbreviacion string    `json:"CodigoAbreviacion"`
    Activo            bool      `json:"Activo"`
    NumeroOrden       int       `json:"NumeroOrden"`
    FechaCreacion     time.Time `json:"FechaCreacion"`
    FechaModificacion time.Time `json:"FechaModificacion"`
}

[stevencol]

Se termina con tarea: Repuesta helper para traer necesarios para la generación del documento

Helper:

func GenerarAutorizacion(id_solicitud_pago string) (datos_documento *models.DocuementoAutorizacionPago, errorOutput interface{}) {

    // Obtiene datos de cambio estado
    var respuesta_cambioEstado map[string]interface{}
    url_request := beego.AppConfig.String("UrlProveedoresCrud") + "/cambio_estado_cumplido/?query=CumplidoProveedorId:" + id_solicitud_pago + ",EstadoCumplidoId.Abreviacion:AO,Activo:true"
    response, err := helpers.GetJsonWSO2Test(url_request, &respuesta_cambioEstado)
    var cambio_estado []models.CambioEstadoCumplido

    if err != nil || response != 200 {
        errorMessage := fmt.Sprintf("%v", err)
        errorOutput = map[string]interface{}{
            "Success": false,
            "Status":  response,
            "Message": "Error al consultar Cumplidos para el proveedor. " + errorMessage,
            "Error":   errorMessage,
        }
        logs.Error(err)
        return nil, errorOutput
    }

    if respuesta_cambioEstado["Data"] != nil {

        fmt.Println(len(cambio_estado))

        data := respuesta_cambioEstado["Data"]
        if len(data.([]interface{})) > 0 {
            helpers.LimpiezaRespuestaRefactor(respuesta_cambioEstado, &cambio_estado)
            if cambio_estado[0].EstadoCumplidoId == nil {
                return nil, nil
            }
        }

        if len(cambio_estado) < 0 {
            return nil, nil
            fmt.Println("entro por que esta vacio?")
        }

        // Obtiene información de los contratos
        var respuesta []models.ContratoProveedor
        url_request_contrato := beego.AppConfig.String("UrlcrudAgora") + "/contrato_general/?query=ContratoSuscrito.NumeroContrato:" + cambio_estado[0].CumplidoProveedorId.NumeroContrato
        resonse_contrato, err_contrato := helpers.GetJsonWSO2Test(url_request_contrato, &respuesta)

        if err_contrato != nil || resonse_contrato != 200 {
            errorMessage := fmt.Sprintf("%v", err)
            errorOutput = map[string]interface{}{
                "Success": false,
                "Status":  resonse_contrato,
                "Message": "Error al consultar Contrato para el proveedor. " + errorMessage,
                "Error":   errorMessage,
            }
            logs.Error(err)
            return nil, errorOutput
        }

        // Obtiene info Proveedor
        if proveedor, err := ObtenerInfoProveedor(strconv.Itoa(respuesta[0].Contratista)); err == nil && proveedor != nil {
            var info_ordenador []models.Proveedor
            url_request_ordenador := beego.AppConfig.String("UrlcrudAgora") + "/informacion_proveedor/?query=NumDocumento:" + strconv.Itoa(cambio_estado[0].DocumentoResponsable)
            response_ordenador, errOrdenador := helpers.GetJsonWSO2Test(url_request_ordenador, &info_ordenador)

            if errOrdenador != nil || response_ordenador != 200 {
                errorMessage := fmt.Sprintf("%v", err)
                errorOutput = map[string]interface{}{
                    "Success": false,
                    "Status":  response_ordenador,
                    "Message": "Error al consultar Información del proveedor. " + errorMessage,
                    "Error":   errorMessage,
                }
                logs.Error(err)
                return nil, errorOutput
            }

            var respuesta_documentos map[string]interface{}
            url_request_documentos := beego.AppConfig.String("UrlProveedoresCrud") + "/soporte_pago?query=CumplidoProveedorId.id:" + id_solicitud_pago
            responseDocuementos, error_documentos := helpers.GetJsonWSO2Test(url_request_documentos, &respuesta_documentos)
            fmt.Println(url_request_documentos)
            var documentosCargados []models.SoportePago
            if len(respuesta_documentos["Data"].([]interface{})[0].(map[string]interface{})) != 0 {
                helpers.LimpiezaRespuestaRefactor(respuesta_documentos, &documentosCargados)
            }

            var id_documentos []string
            for _, documentosCargado := range documentosCargados {
                id_documentos = append(id_documentos, strconv.Itoa(documentosCargado.DocumentoId))
            }
            id_documentos_unidos := strings.Join(id_documentos, "|")

            if error_documentos != nil || responseDocuementos != 200 {

                return nil, errorOutput
            }

            var documentos []models.Documento

            url_request_documentos_destion := "http://pruebasapi.intranetoas.udistrital.edu.co:8094/v1/documento/?query=Id.in:" + id_documentos_unidos + ",Activo:true&limit=-1"
            response_docuementos_gestion, erro_documentos_gestion := helpers.GetJsonTest(url_request_documentos_destion, &documentos)

            if erro_documentos_gestion != nil || response_docuementos_gestion != 200 {
                return nil, errorOutput
            }

            var lista_documentos_cargados_strings []string
            for _, documento := range documentos {
                lista_documentos_cargados_strings = append(lista_documentos_cargados_strings, documento.TipoDocumento.CodigoAbreviacion)
            }

            indexRespuestaOrdenador := len(respuesta) - 1
            datos_documento := &models.DocuementoAutorizacionPago{
                NombreOrdenador:    info_ordenador[indexRespuestaOrdenador].NomProveedor,
                DocumentoOrdenador: info_ordenador[indexRespuestaOrdenador].NumDocumento,
                NombreProveedor:    proveedor.NomProveedor,
                DocumentoProveedor: proveedor.NumDocumento,
                DocumentosCargados: lista_documentos_cargados_strings,
            }

            return datos_documento, nil

        }
        return nil, nil
    } else {
        return nil, nil
    }
}

[JuanCamiloMartinezLopez]

@stevencol Buen trabajo.