Add depot, attendant, jetfire, optimus, ota services with kustomize overlays

services/ota_update_go/controllers/can_signals.go

@@ -0,0 +1,8 @@
+package controllers
+
+import "time"
+
+type CarCANSignal struct {
+	VIN  string
+	Last time.Time
+}

services/ota_update_go/controllers/errors.go

@@ -0,0 +1,7 @@
+package controllers
+
+import "github.com/pkg/errors"
+
+var ErrorUnableToConvert = errors.New("unable to convert struct")
+var ErrorPKRequired = errors.New("primary key required")
+var ErrorNotFound = errors.New("no object found")

services/ota_update_go/controllers/handle_create.go

@@ -0,0 +1,38 @@
+package controllers
+
+import (
+	"net/http"
+
+	"github.com/fiskerinc/cloud-services/pkg/utils"
+	"github.com/go-pg/pg/v10/orm"
+	"github.com/fiskerinc/cloud-services/pkg/loggerdataresp"
+)
+
+func NewCreate(helper CreateHelperInterface) *HandleCreate {
+	return &HandleCreate{Helper: helper}
+}
+
+type CreateHelperInterface interface {
+	ParseRequest(r *http.Request, model interface{}) error
+	QueryInsert(model interface{}) (orm.Result, error)
+	NewModel() interface{}
+}
+
+type HandleCreate struct {
+	Helper CreateHelperInterface
+}
+
+func (h *HandleCreate) Handle(w http.ResponseWriter, r *http.Request) {
+	model := h.Helper.NewModel()
+	err := h.Helper.ParseRequest(r, model)
+	if loggerdataresp.BadDataErrorResp(w, err, http.StatusBadRequest) {
+		return
+	}
+
+	_, err = h.Helper.QueryInsert(model)
+	if loggerdataresp.BadDataErrorResp(w, err, http.StatusServiceUnavailable) {
+		return
+	}
+
+	utils.RespJSON(w, http.StatusOK, model)
+}

services/ota_update_go/controllers/handle_delete.go

@@ -0,0 +1,47 @@
+package controllers
+
+import (
+	"net/http"
+
+	"github.com/fiskerinc/cloud-services/pkg/common"
+	"github.com/fiskerinc/cloud-services/pkg/utils"
+	"github.com/go-pg/pg/v10/orm"
+	"github.com/pkg/errors"
+	"github.com/fiskerinc/cloud-services/pkg/loggerdataresp"
+)
+
+func NewDelete(helper DeleteHelperInterface) *HandleDelete {
+	return &HandleDelete{Helper: helper}
+}
+
+type DeleteHelperInterface interface {
+	ParseDeleteQueryParams(r *http.Request) interface{}
+	QueryDelete(req interface{}) (orm.Result, error)
+	ValidatePK(model interface{}) error
+}
+
+type HandleDelete struct {
+	Helper DeleteHelperInterface
+}
+
+func (h *HandleDelete) Handle(w http.ResponseWriter, r *http.Request) {
+	filter := h.Helper.ParseDeleteQueryParams(r)
+	err := h.Helper.ValidatePK(filter)
+	if loggerdataresp.BadDataErrorResp(w, err, http.StatusBadRequest) {
+		return
+	}
+
+	result, err := h.Helper.QueryDelete(filter)
+	if loggerdataresp.BadDataErrorResp(w, err, http.StatusServiceUnavailable, loggerdataresp.PostgresNoRowsErrorCheck) {
+		return
+	}
+
+	if result != nil && result.RowsAffected() == 0 {
+		loggerdataresp.BadDataErrorResp(w, errors.New("Nothing deleted"), http.StatusNotFound)
+		return
+	}
+
+	utils.RespJSON(w, http.StatusOK, common.JSONMessage{
+		Message: "Deleted",
+	})
+}

services/ota_update_go/controllers/handle_get_list.go

@@ -0,0 +1,61 @@
+package controllers
+
+import (
+	"net/http"
+
+	"github.com/fiskerinc/cloud-services/pkg/common"
+	"github.com/fiskerinc/cloud-services/pkg/db/queries"
+	"github.com/fiskerinc/cloud-services/pkg/utils"
+	"github.com/fiskerinc/cloud-services/pkg/validator"
+	"github.com/fiskerinc/cloud-services/pkg/loggerdataresp"
+)
+
+func NewGetList(helper GetListHelperInterface) *HandleGetList {
+	return &HandleGetList{Helper: helper}
+}
+
+type GetListHelperInterface interface {
+	ParseGetListQueryParams(r *http.Request) interface{}
+	QueryCount(filter interface{}) (int, error)
+	QuerySelect(filter interface{}, options *queries.PageQueryOptions) (interface{}, error)
+	HasPK(filter interface{}) bool
+}
+
+type HandleGetList struct {
+	Helper GetListHelperInterface
+}
+
+func (h *HandleGetList) Handle(w http.ResponseWriter, r *http.Request) {
+	var total int
+
+	filter := h.Helper.ParseGetListQueryParams(r)
+	err := validator.ValidateNonRequired(filter)
+	if loggerdataresp.BadDataErrorResp(w, err, http.StatusBadRequest) {
+		return
+	}
+
+	options, err := queries.ParsePageQuery(r)
+	if loggerdataresp.BadDataErrorResp(w, err, http.StatusBadRequest) {
+		return
+	}
+	if options.Order == "" {
+		options.Order = "created_at DESC"
+	}
+
+	items, err := h.Helper.QuerySelect(filter, options)
+	if loggerdataresp.BadDataErrorResp(w, err, http.StatusServiceUnavailable, loggerdataresp.PostgresNoRowsErrorCheck) {
+		return
+	}
+
+	if options.Offset == 0 && !h.Helper.HasPK(filter) {
+		total, err = h.Helper.QueryCount(filter)
+		if loggerdataresp.BadDataErrorResp(w, err, http.StatusServiceUnavailable, loggerdataresp.PostgresNoRowsErrorCheck) {
+			return
+		}
+	}
+
+	utils.RespJSON(w, http.StatusOK, common.JSONDBQueryResult{
+		Data:  items,
+		Total: total,
+	})
+}

services/ota_update_go/controllers/handle_get_model.go

@@ -0,0 +1,38 @@
+package controllers
+
+import (
+	"net/http"
+
+	"github.com/fiskerinc/cloud-services/pkg/utils"
+	"github.com/fiskerinc/cloud-services/pkg/loggerdataresp"
+)
+
+func NewGetModel(helper GetModelHelperInterface) *HandleGetModel {
+	return &HandleGetModel{Helper: helper}
+}
+
+type GetModelHelperInterface interface {
+	ParseGetModelParams(r *http.Request) interface{}
+	QueryLoad(model interface{}) error
+	HasPK(model interface{}) bool
+}
+
+type HandleGetModel struct {
+	Helper GetModelHelperInterface
+}
+
+func (h *HandleGetModel) Handle(w http.ResponseWriter, r *http.Request) {
+	item := h.Helper.ParseGetModelParams(r)
+	hasPK := h.Helper.HasPK(item)
+	if !hasPK {
+		loggerdataresp.BadDataErrorResp(w, ErrorPKRequired, http.StatusBadRequest)
+		return
+	}
+
+	err := h.Helper.QueryLoad(item)
+	if loggerdataresp.BadDataErrorResp(w, err, http.StatusServiceUnavailable, loggerdataresp.PostgresNoRowsErrorCheck) {
+		return
+	}
+
+	utils.RespJSON(w, http.StatusOK, item)
+}

services/ota_update_go/controllers/handle_update.go

@@ -0,0 +1,48 @@
+package controllers
+
+import (
+	"net/http"
+
+	"github.com/fiskerinc/cloud-services/pkg/utils"
+	"github.com/go-pg/pg/v10/orm"
+	"github.com/fiskerinc/cloud-services/pkg/loggerdataresp"
+)
+
+func NewUpdate(helper UpdateHelperInterface) *HandleUpdate {
+	return &HandleUpdate{Helper: helper}
+}
+
+type UpdateHelperInterface interface {
+	ParseRequest(r *http.Request, model interface{}) error
+	QueryUpdate(model interface{}) (orm.Result, error)
+	NewModel() interface{}
+	ValidatePK(model interface{}) error
+}
+
+type HandleUpdate struct {
+	Helper UpdateHelperInterface
+}
+
+func (h *HandleUpdate) Handle(w http.ResponseWriter, r *http.Request) {
+	model := h.Helper.NewModel()
+	err := h.ParseRequest(r, model)
+	if loggerdataresp.BadDataErrorResp(w, err, http.StatusBadRequest) {
+		return
+	}
+
+	_, err = h.Helper.QueryUpdate(model)
+	if loggerdataresp.BadDataErrorResp(w, err, http.StatusServiceUnavailable, loggerdataresp.PostgresNoRowsErrorCheck) {
+		return
+	}
+
+	utils.RespJSON(w, http.StatusOK, model)
+}
+
+func (h *HandleUpdate) ParseRequest(r *http.Request, model interface{}) error {
+	err := h.Helper.ParseRequest(r, model)
+	if err != nil {
+		return err
+	}
+
+	return h.Helper.ValidatePK(model)
+}

services/ota_update_go/controllers/health_check.go

@@ -0,0 +1,46 @@
+package controllers
+
+import (
+	"otaupdate/services"
+	"time"
+
+	"github.com/fiskerinc/cloud-services/pkg/health"
+	"github.com/fiskerinc/cloud-services/pkg/logger"
+)
+
+func HealthCheck() {
+	redis := health.NewRedisHealth(services.RedisClientPool())
+	server := health.HealthCheckServer{}
+
+	err := server.Serve([]health.Config{
+		{
+			Name:    "db",
+			Check:   health.NewPostgresCheck(services.GetDB().GetDBClient().GetConn()),
+			Timeout: time.Second * 1,
+		},
+		{
+			Name:    "redis",
+			Check:   redis.Check,
+			Timeout: time.Second * 1,
+			Info:    redis.RedisStatus,
+		},
+		{
+			Name:    "mongodb",
+			Check:   health.NewMongoDBCheck(getMongoClient),
+			Timeout: time.Second * 1,
+		},
+	})
+	if err != nil {
+		logger.Error().Err(err).Send()
+	}
+}
+
+func getMongoClient() (health.MongoConnCheckInterface, error) {
+	client, err := services.GetMongoClient()
+	if err != nil {
+		return nil, err
+	}
+
+	conn := client.(health.MongoConnCheckInterface)
+	return conn, nil
+}

services/ota_update_go/controllers/helper_base.go

@@ -0,0 +1,14 @@
+package controllers
+
+import (
+	"net/http"
+
+	"github.com/fiskerinc/cloud-services/pkg/httphandlers"
+)
+
+type HelperBase struct {
+}
+
+func (h *HelperBase) ParseRequest(r *http.Request, data interface{}) error {
+	return httphandlers.ParseRequest(r, data)
+}

services/ota_update_go/controllers/mongo_handle_create.go

@@ -0,0 +1,43 @@
+package controllers
+
+import (
+	"net/http"
+
+	"github.com/fiskerinc/cloud-services/pkg/httphandlers"
+	"github.com/fiskerinc/cloud-services/pkg/utils"
+	"github.com/fiskerinc/cloud-services/pkg/loggerdataresp"
+)
+
+func NewMongoCreate(helper MongoCreateHelperInterface) *MongoHandleCreate {
+	return &MongoHandleCreate{Helper: helper}
+}
+
+type MongoCreateHelperInterface interface {
+	QueryInsert(model interface{}) error
+	NewModel() interface{}
+	ValidatePK(model interface{}) error
+}
+
+type MongoHandleCreate struct {
+	Helper MongoCreateHelperInterface
+}
+
+func (h *MongoHandleCreate) Handle(w http.ResponseWriter, r *http.Request) {
+	model := h.Helper.NewModel()
+	err := httphandlers.ParseRequest(r, model)
+	if loggerdataresp.BadDataErrorResp(w, err, http.StatusBadRequest) {
+		return
+	}
+
+	err = h.Helper.ValidatePK(model)
+	if loggerdataresp.BadDataErrorResp(w, err, http.StatusBadRequest) {
+		return
+	}
+
+	err = h.Helper.QueryInsert(model)
+	if loggerdataresp.BadDataErrorResp(w, err, http.StatusBadRequest) {
+		return
+	}
+
+	utils.RespJSON(w, http.StatusOK, model)
+}

services/ota_update_go/controllers/mongo_handle_delete.go

@@ -0,0 +1,41 @@
+package controllers
+
+import (
+	"net/http"
+
+	"github.com/fiskerinc/cloud-services/pkg/common"
+	"github.com/fiskerinc/cloud-services/pkg/utils"
+	"github.com/fiskerinc/cloud-services/pkg/loggerdataresp"
+
+)
+
+func NewMongoDelete(helper MongoDeleteHelperInterface) *MongoHandleDelete {
+	return &MongoHandleDelete{Helper: helper}
+}
+
+type MongoDeleteHelperInterface interface {
+	ParseDeleteURLParams(r *http.Request) interface{}
+	ValidateFields(model interface{}) error
+	QueryDelete(req interface{}) error
+}
+
+type MongoHandleDelete struct {
+	Helper MongoDeleteHelperInterface
+}
+
+func (h *MongoHandleDelete) Handle(w http.ResponseWriter, r *http.Request) {
+	filter := h.Helper.ParseDeleteURLParams(r)
+	err := h.Helper.ValidateFields(filter)
+	if loggerdataresp.BadDataErrorResp(w, err, http.StatusBadRequest) {
+		return
+	}
+
+	err = h.Helper.QueryDelete(filter)
+	if loggerdataresp.BadDataErrorResp(w, err, http.StatusNotFound) {
+		return
+	}
+
+	utils.RespJSON(w, http.StatusOK, common.JSONMessage{
+		Message: "Deleted",
+	})
+}

services/ota_update_go/controllers/mongo_handle_get_list.go

@@ -0,0 +1,60 @@
+package controllers
+
+import (
+	"net/http"
+
+	"github.com/fiskerinc/cloud-services/pkg/common"
+	"github.com/fiskerinc/cloud-services/pkg/db/queries"
+	"github.com/fiskerinc/cloud-services/pkg/utils"
+	"github.com/fiskerinc/cloud-services/pkg/loggerdataresp"
+)
+
+func NewMongoGetList(helper MongoGetListHelperInterface) *MongoHandleGetList {
+	return &MongoHandleGetList{Helper: helper}
+}
+
+type MongoGetListHelperInterface interface {
+	NewModel() interface{}
+	ParseGetListURLParams(r *http.Request, model interface{})
+	ParseGetListQueryParams(r *http.Request, model interface{})
+	ValidateStruct(model interface{}) error
+	QueryCount(filter interface{}) (int64, error)
+	QuerySelect(filter interface{}, options *queries.PageQueryOptions) (interface{}, error)
+}
+
+type MongoHandleGetList struct {
+	Helper MongoGetListHelperInterface
+}
+
+func (h *MongoHandleGetList) Handle(w http.ResponseWriter, r *http.Request) {
+	filter := h.Helper.NewModel()
+	h.Helper.ParseGetListURLParams(r, filter)
+	h.Helper.ParseGetListQueryParams(r, filter)
+	err := h.Helper.ValidateStruct(filter)
+	if loggerdataresp.BadDataErrorResp(w, err, http.StatusBadRequest) {
+		return
+	}
+
+	options, err := queries.ParsePageQuery(r)
+	if loggerdataresp.BadDataErrorResp(w, err, http.StatusBadRequest) {
+		return
+	}
+
+	items, err := h.Helper.QuerySelect(filter, options)
+	if loggerdataresp.BadDataErrorResp(w, err, http.StatusBadRequest) {
+		return
+	}
+
+	var total int64
+	if options.Offset == 0 && options.Limit != 0 {
+		total, err = h.Helper.QueryCount(filter)
+		if loggerdataresp.BadDataErrorResp(w, err, http.StatusBadRequest) {
+			return
+		}
+	}
+
+	utils.RespJSON(w, http.StatusOK, common.JSONDBQueryResult{
+		Data:  items,
+		Total: int(total),
+	})
+}

services/ota_update_go/controllers/mongo_handle_get_model.go

@@ -0,0 +1,43 @@
+package controllers
+
+import (
+	"net/http"
+
+	"github.com/fiskerinc/cloud-services/pkg/loggerdataresp"
+	"github.com/fiskerinc/cloud-services/pkg/utils"
+	"github.com/fiskerinc/cloud-services/pkg/logger"
+)
+
+func NewMongoGetModel(helper MongoGetModelHelperInterface) *MongoHandleGetModel {
+	return &MongoHandleGetModel{Helper: helper}
+}
+
+type MongoGetModelHelperInterface interface {
+	ParseGetURLParams(r *http.Request) interface{}
+	ValidatePK(model interface{}) error
+	Query(filter interface{}) (interface{}, error)
+}
+
+type MongoHandleGetModel struct {
+	Helper MongoGetModelHelperInterface
+}
+
+func (h *MongoHandleGetModel) Handle(w http.ResponseWriter, r *http.Request) {
+	filter := h.Helper.ParseGetURLParams(r)
+	err := h.Helper.ValidatePK(filter)
+	if loggerdataresp.BadDataErrorResp(w, err, http.StatusBadRequest) {
+		return
+	}
+
+	item, err := h.Helper.Query(filter)
+	if loggerdataresp.BadDataErrorResp(w, err, http.StatusBadRequest) {
+		return
+	} else if item == nil {
+		loggerdataresp.BadDataErrorResp(w, err, http.StatusNotFound)
+		return
+	}
+
+	logger.Info().Msgf("%+v", item)
+
+	utils.RespJSON(w, http.StatusOK, item)
+}

services/ota_update_go/controllers/mongo_handle_update.go

@@ -0,0 +1,53 @@
+package controllers
+
+import (
+	"net/http"
+
+	"github.com/fiskerinc/cloud-services/pkg/logger"
+	"github.com/fiskerinc/cloud-services/pkg/utils"
+	"github.com/fiskerinc/cloud-services/pkg/loggerdataresp"
+)
+
+func NewMongoUpdate(helper MongoUpdateHelperInterface) *MongoHandleUpdate {
+	return &MongoHandleUpdate{Helper: helper}
+}
+
+type MongoUpdateHelperInterface interface {
+	ParseUpdateURLParams(r *http.Request) interface{}
+	ValidateFields(model interface{}) error
+	NewModel() interface{}
+	ParseRequestBody(r *http.Request, model interface{}) error
+	QueryUpdate(filter interface{}, model interface{}) error
+}
+
+type MongoHandleUpdate struct {
+	Helper MongoUpdateHelperInterface
+}
+
+func (h *MongoHandleUpdate) Handle(w http.ResponseWriter, r *http.Request) {
+	filter := h.Helper.ParseUpdateURLParams(r)
+	err := h.Helper.ValidateFields(filter)
+	if loggerdataresp.BadDataErrorResp(w, err, http.StatusBadRequest) {
+		return
+	}
+
+	model := h.Helper.NewModel()
+	err = h.Helper.ParseRequestBody(r, model)
+	if loggerdataresp.BadDataErrorResp(w, err, http.StatusBadRequest) {
+		return
+	}
+	err = h.Helper.ValidateFields(model)
+	if loggerdataresp.BadDataErrorResp(w, err, http.StatusBadRequest) {
+		logger.Warn().Err(err).Send()
+		return
+	}
+
+	err = h.Helper.QueryUpdate(filter, model)
+	if loggerdataresp.BadDataErrorResp(w, err, http.StatusBadRequest, loggerdataresp.MongoUpdateErrorCheck) {
+		return
+	}
+
+	logger.Info().Msgf("%+v", model)
+
+	utils.RespJSON(w, http.StatusOK, model)
+}