fyp/logic/models/edit.go

package models

import (
	"fmt"

	model_classes "git.andr3h3nriqu3s.com/andr3/fyp/logic/models/classes"
	. "git.andr3h3nriqu3s.com/andr3/fyp/logic/models/utils"
	"git.andr3h3nriqu3s.com/andr3/fyp/logic/utils"
	. "git.andr3h3nriqu3s.com/andr3/fyp/logic/utils"
)

func handleEdit(handle *Handle) {
	handle.Get("/models/edit/classes", func(c *Context) *Error {
		if !c.CheckAuthLevel(1) {
			return nil
		}

        model, err_ := c.GetModelFromId("id")
        if err_ != nil {
            return err_
        }

		wrong_number, err := model_classes.GetNumberOfWrongDataPoints(c.Db, model.Id)
		if err != nil {
			return c.Error500(err)
		}

		cls, err := model_classes.ListClasses(c, model.Id)
		if err != nil {
			return c.Error500(err)
		}

		has_data, err := model_classes.ModelHasDataPoints(handle.Db, model.Id)
		if err != nil {
			return c.Error500(err)
		}

		type ReturnType struct {
			Classes               []*model_classes.ModelClass `json:"classes"`
			HasData               bool                        `json:"has_data"`
			NumberOfInvalidImages int                         `json:"number_of_invalid_images"`
		}

		return c.SendJSON(ReturnType{
			Classes:               cls,
			HasData:               has_data,
			NumberOfInvalidImages: wrong_number,
		})
	})

	handle.Get("/models/edit/definitions", func(c *Context) *Error {
		if !c.CheckAuthLevel(1) {
			return nil
		}

        model, err_ := c.GetModelFromId("id")
        if err_ != nil {
            return err_
        }

		type defrow struct {
			Id            string
			Status        int
			EpochProgress int
			Epoch         int
			Accuracy      float64
		}

		defs := []defrow{}

		if model.ModelType == 2 {
			def_rows, err := c.Db.Query("select md.id, md.status, md.epoch, h.epoch_progress, h.accuracy from model_definition as md inner join exp_model_head as h on h.def_id = md.id where md.model_id=$1 order by md.created_on asc", model.Id)
			if err != nil {
				return c.Error500(err)
			}
			defer def_rows.Close()

			for def_rows.Next() {
				var def defrow
				err = def_rows.Scan(&def.Id, &def.Status, &def.Epoch, &def.EpochProgress, &def.Accuracy)
				if err != nil {
					return c.Error500(err)
				}
				defs = append(defs, def)
			}
		} else {
			def_rows, err := c.Db.Query("select id, status, epoch, epoch_progress, accuracy from model_definition where model_id=$1 order by created_on asc", model.Id)
			if err != nil {
				return c.Error500(err)
			}
			defer def_rows.Close()

			for def_rows.Next() {
				var def defrow
				err = def_rows.Scan(&def.Id, &def.Status, &def.Epoch, &def.EpochProgress, &def.Accuracy)
				if err != nil {
					return c.Error500(err)
				}
				defs = append(defs, def)
			}
		}

		type layerdef struct {
			id        string
			LayerType int    `json:"layer_type"`
			Shape     string `json:"shape"`
		}

		layers := []layerdef{}

		for _, def := range defs {
			if def.Status == MODEL_DEFINITION_STATUS_TRAINING {
				rows, err := c.Db.Query("select id, layer_type, shape from model_definition_layer where def_id=$1 order by layer_order asc;", def.Id)
				if err != nil {
					return c.Error500(err)
				}
				defer rows.Close()

				for rows.Next() {
					var layerdef layerdef
					err = rows.Scan(&layerdef.id, &layerdef.LayerType, &layerdef.Shape)
					if err != nil {
						return c.Error500(err)
					}
					layers = append(layers, layerdef)
				}

				if model.ModelType == 2 {

					type lastLayerType struct {
						Id          string
						Range_start int
						Range_end   int
					}

					var lastLayer lastLayerType

					err := GetDBOnce(c, &lastLayer, "exp_model_head where def_id=$1 and status=3;", def.Id)
					if err != nil {
						return c.Error500(err)
					}

					layers = append(layers, layerdef{
						id:        lastLayer.Id,
						LayerType: LAYER_DENSE,
						Shape:     fmt.Sprintf("%d, 1", lastLayer.Range_end-lastLayer.Range_start+1),
					})
				}

				break
			}
		}

		type Definitions struct {
			Id            string      `json:"id"`
			Status        int         `json:"status"`
			EpochProgress int         `json:"epoch_progress"`
			Epoch         int         `json:"epoch"`
			Accuracy      float64     `json:"accuracy"`
			Layers        *[]layerdef `json:"layers"`
		}

		defsToReturn := make([]Definitions, len(defs), len(defs))

		setLayers := false

		for i, def := range defs {
			var lay *[]layerdef = nil
			if def.Status == MODEL_DEFINITION_STATUS_TRAINING && !setLayers {
				lay = &layers
				setLayers = true
			}
			defsToReturn[i] = Definitions{
				Id:            def.Id,
				Status:        def.Status,
				EpochProgress: def.EpochProgress,
				Epoch:         def.Epoch,
				Accuracy:      def.Accuracy,
				Layers:        lay,
			}
		}

		return c.SendJSON(defsToReturn)
	})

	handle.Get("/models/edit", func(c *Context) *Error {
		if !c.CheckAuthLevel(1) {
			return nil
		}

		if !c.CheckAuthLevel(1) {
			return nil
		}

		id, err := GetIdFromUrl(c, "id")
		if err != nil {
			return c.JsonBadRequest("Model not found")
		}

		type rowmodel struct {
			Name       string  `json:"name"`
			Status     int     `json:"status"`
			Id         string  `json:"id"`
			Width      *int    `json:"width"`
			Height     *int    `json:"height"`
			Color_mode *string `json:"color_mode"`
			Format     string  `json:"format"`
			Model_type int     `json:"model_type"`
		}

		var model rowmodel = rowmodel{}
		err = utils.GetDBOnce(c, &model, "models where id=$1 and user_id=$2", id, c.User.Id)
		if err == NotFoundError {
			return c.SendJSONStatus(404, "Model not found")
		} else if err != nil {
			return c.Error500(err)
		}

		return c.SendJSON(model)
	})
}