cml04-plb018/internal/logging/logging.go

package logging

import (
	"context"
	"time"

	"git.espin.casa/albert/cml04-plb018/internal/service"
	"git.espin.casa/albert/cml04-plb018/internal/types"
	"git.espin.casa/albert/logger"
)

type Logging struct {
	log  logger.LoggerAdapter
	next service.IService
}

// NroPaqueteActual implements service.IService.
func (l *Logging) NroPaqueteActual(ctx context.Context, req *types.NroPaqueteActualReq) (res *types.NroPaqueteActualRes, err error) {
	defer func(start time.Time) {
		logFields := logger.LogFields{
			"took": time.Since(start),
		}
		if err != nil {
			l.log.Error("Nro paquete actual failed", err, logFields)
		} else {
			l.log.Info("Nro paquete actual success", logFields)
		}
	}(time.Now())
	return l.next.NroPaqueteActual(ctx, req)

}

// NroPaqueteSiguiente implements service.IService.
func (l *Logging) NroPaqueteSiguiente(ctx context.Context, req *types.NroPaqueteSiguienteReq) (res *types.NroPaqueteSiguienteRes, err error) {
	defer func(start time.Time) {
		logFields := logger.LogFields{
			"took": time.Since(start),
		}
		if err != nil {
			l.log.Error("Nro paquete siguiente failed", err, logFields)
		} else {
			l.log.Info("Nro paquete siguiente success", logFields)
		}
	}(time.Now())
	return l.next.NroPaqueteSiguiente(ctx, req)
}

// ImprimirPaqueteRobot implements service.IService.
func (l *Logging) ImprimirPaqueteRobot(ctx context.Context, req *types.ImprimirPaqueteReq) (res *types.ImprimirPaqueteRes, err error) {
	defer func(start time.Time) {
		logFields := logger.LogFields{
			"nro_matricula": req.DatosEtiqueta.NroMatricula,
			"took":          time.Since(start),
		}
		if err != nil {
			l.log.Error("Imprimir paquete robot failed", err, logFields)
		} else {
			l.log.Info("Imprimir paquete robot success", logFields)
		}
	}(time.Now())
	return l.next.ImprimirPaqueteRobot(ctx, req)
}

// Paquete implements service.IService.
func (l *Logging) Paquete(ctx context.Context, req *types.PaqueteReq) (res *types.PaqueteRes, err error) {
	defer func(start time.Time) {
		logFields := logger.LogFields{
			"codigo_etiqueta": req.Codigo,
			"took":            time.Since(start),
		}
		if err != nil {
			l.log.Error("Paquete failed", err, logFields)
		} else {
			l.log.Info("Paquete success", logFields)
		}
	}(time.Now())
	return l.next.Paquete(ctx, req)
}

// Paquetes implements service.IService.
func (l *Logging) Paquetes(ctx context.Context, req *types.PaquetesReq) (res *types.PaquetesRes, err error) {
	defer func(start time.Time) {
		logFields := logger.LogFields{
			"inicio": req.Inicio,
			"final":  req.Final,
			"took":   time.Since(start),
		}
		if err != nil {
			l.log.Error("Paquetes failed", err, logFields)
		} else {
			l.log.Info("Paquetes success", logFields)
		}
	}(time.Now())
	return l.next.Paquetes(ctx, req)
}

// Etiqueta implements service.IService.
func (l *Logging) Etiqueta(ctx context.Context, req *types.EtiquetaReq) (res *types.EtiquetaRes, err error) {
	defer func(start time.Time) {
		logFields := logger.LogFields{
			"codigo_etiqueta": req.Codigo,
			"took":            time.Since(start),
		}
		if err != nil {
			l.log.Error("Etiqueta failed", err, logFields)
		} else {
			l.log.Info("Etiqueta success", logFields)
		}
	}(time.Now())
	return l.next.Etiqueta(ctx, req)
}

// Etiquetas implements service.IService.
func (l *Logging) Etiquetas(ctx context.Context, req *types.EtiquetasReq) (res *types.EtiquetasRes, err error) {
	defer func(start time.Time) {
		logFields := logger.LogFields{
			"took": time.Since(start),
		}
		if err != nil {
			l.log.Error("Etiquetas failed", err, logFields)
		} else {
			l.log.Info("Etiquetas success", logFields)
		}
	}(time.Now())
	return l.next.Etiquetas(ctx, req)
}

// SalvarEtiqueta implements service.IService.
func (l *Logging) SalvarEtiqueta(ctx context.Context, req *types.SalvarEtiquetaReq) (res *types.SalvarEtiquetaRes, err error) {
	defer func(start time.Time) {
		logFields := logger.LogFields{
			"codigo_etiqueta": req.Etiqueta.Codigo,
			"took":            time.Since(start),
		}
		if err != nil {
			l.log.Error("SalvarEtiqueta failed", err, logFields)
		} else {
			l.log.Info("SalvarEtiqueta success", logFields)
		}
	}(time.Now())
	return l.next.SalvarEtiqueta(ctx, req)
}

// SalvarImpresora implements service.IService.
func (l *Logging) SalvarImpresora(ctx context.Context, req *types.SalvarImpresoraReq) (res *types.SalvarImpresoraRes, err error) {
	defer func(start time.Time) {
		logFields := logger.LogFields{
			"id_impresora": req.Impresora.ID,
			"took":         time.Since(start),
		}
		if err != nil {
			l.log.Error("SalvarImpresora failed", err, logFields)
		} else {
			l.log.Info("SalvarImpresora success", logFields)
		}
	}(time.Now())
	return l.next.SalvarImpresora(ctx, req)
}

// Impresora implements service.IService.
func (l *Logging) Impresora(ctx context.Context, req *types.ImpresoraReq) (res *types.ImpresoraRes, err error) {
	defer func(start time.Time) {
		logFields := logger.LogFields{
			"id_impresora": req.ID,
			"took":         time.Since(start),
		}
		if err != nil {
			l.log.Error("Impresora failed", err, logFields)
		} else {
			l.log.Info("Impresora success", logFields)
		}
	}(time.Now())
	return l.next.Impresora(ctx, req)
}

// Impresoras implements service.IService.
func (l *Logging) Impresoras(ctx context.Context, req *types.ImpresorasReq) (res *types.ImpresorasRes, err error) {
	defer func(start time.Time) {
		logFields := logger.LogFields{
			"took": time.Since(start),
		}
		if err != nil {
			l.log.Error("Impresoras failed", err, logFields)
		} else {
			l.log.Info("Impresoras success", logFields)
		}
	}(time.Now())
	return l.next.Impresoras(ctx, req)
}

// OrdenesProduccion implements service.IService.
func (l *Logging) OrdenesProduccion(ctx context.Context, req *types.OrdenesProduccionReq) (res *types.OrdenesProduccionRes, err error) {
	defer func(start time.Time) {
		logFields := logger.LogFields{
			"limit": req.Limit,
			"took":  time.Since(start),
		}
		if err != nil {
			l.log.Error("OrdenesProduccion failed", err, logFields)
		} else {
			l.log.Info("OrdenesProduccion success", logFields)
		}
	}(time.Now())
	return l.next.OrdenesProduccion(ctx, req)
}

// OrdenCliente implements service.IService.
func (l *Logging) OrdenCliente(ctx context.Context, req *types.OrdenClienteReq) (res *types.OrdenClienteRes, err error) {
	defer func(start time.Time) {
		logFields := logger.LogFields{
			"co_id": req.CoID,
			"took":  time.Since(start),
		}
		if err != nil {
			l.log.Error("OrdenCliente failed", err, logFields)
		} else {
			l.log.Info("OrdenCliente success", logFields)
		}
	}(time.Now())
	return l.next.OrdenCliente(ctx, req)
}

// OrdenProduccion implements service.IService.
func (l *Logging) OrdenProduccion(ctx context.Context, req *types.OrdenProduccionReq) (res *types.OrdenProduccionRes, err error) {
	defer func(start time.Time) {
		logFields := logger.LogFields{
			"po_id": req.PoID,
			"took":  time.Since(start),
		}
		if err != nil {
			l.log.Error("OrdenProduccion failed", err, logFields)
		} else {
			l.log.Info("OrdenProduccion success", logFields)
		}
	}(time.Now())
	return l.next.OrdenProduccion(ctx, req)
}

// OrdenesCliente implements service.IService.
func (l *Logging) OrdenesCliente(ctx context.Context, req *types.OrdenesClienteReq) (res *types.OrdenesClienteRes, err error) {
	defer func(start time.Time) {
		logFields := logger.LogFields{
			"po_id": req.PoID,
			"took":  time.Since(start),
		}
		if err != nil {
			l.log.Error("OrdenesCliente failed", err, logFields)
		} else {
			l.log.Info("OrdenesCliente success", logFields)
		}
	}(time.Now())
	return l.next.OrdenesCliente(ctx, req)
}

// Normas implements service.IService.
func (l *Logging) Normas(ctx context.Context, req *types.NormasReq) (res *types.NormasRes, err error) {
	defer func(start time.Time) {
		logFields := logger.LogFields{
			"code": req.Codigo,
			"took": time.Since(start),
		}
		if err != nil {
			l.log.Error("Normas failed", err, logFields)
		} else {
			l.log.Info("Normas success", logFields)
		}
	}(time.Now())
	return l.next.Normas(ctx, req)
}

// ImprimirPaquete implements service.IService.
func (l *Logging) ImprimirPaquete(ctx context.Context, req *types.ImprimirPaqueteReq) (res *types.ImprimirPaqueteRes, err error) {
	defer func(start time.Time) {
		logFields := logger.LogFields{
			"took": time.Since(start),
		}
		if err != nil {
			l.log.Error("imprimir etiqueta failed", err, logFields)
		} else {
			l.log.Info("imprimir etiqueta success", logFields)
		}
	}(time.Now())
	return l.next.ImprimirPaquete(ctx, req)
}

func NewLogging(svc service.IService, log logger.LoggerAdapter) service.IService {
	return &Logging{
		log:  log,
		next: svc,
	}
}