fyp/logic/models/edit.go

package models

import (
	"fmt"
	"net/http"

	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"
)

func handleEdit(handle *Handle) {
	handle.GetHTML("/models/edit", func(w http.ResponseWriter, r *http.Request, c *Context) *Error {
		if !CheckAuthLevel(1, w, r, c) {
			return nil
		}

		id, err := GetIdFromUrl(r, "id")
		if err != nil {
			return ErrorCode(nil, http.StatusNotFound, AnyMap{
				"NotFoundMessage": "Model not found",
				"GoBackLink":      "/models",
			})
		}

		// TODO handle admin users
		rows, err := handle.Db.Query("select name, status, width, height, color_mode, format, model_type from models where id=$1 and user_id=$2;", id, c.User.Id)
		if err != nil {
			return Error500(err)
		}
		defer rows.Close()

		if !rows.Next() {
			return ErrorCode(nil, http.StatusNotFound, AnyMap{
				"NotFoundMessage": "Model not found",
				"GoBackLink":      "/models",
			})
		}

		type rowmodel struct {
			Name       string
			Status     int
			Id         string
			Width      *int
			Height     *int
			Color_mode *string
			Format     string
			Type       int
		}

		var model rowmodel = rowmodel{}
		model.Id = id

		err = rows.Scan(&model.Name, &model.Status, &model.Width, &model.Height, &model.Color_mode, &model.Format, &model.Type)
		if err != nil {
			return Error500(err)
		}

		// Handle errors
		// All errors will be negative
		if model.Status < 0 {
			LoadBasedOnAnswer(c.Mode, w, "/models/edit.html", c.AddMap(AnyMap{
				"Model": model,
			}))
			return nil
		}

		switch model.Status {
		case PREPARING:
			LoadBasedOnAnswer(c.Mode, w, "/models/edit.html", c.AddMap(AnyMap{
				"Model": model,
			}))
		case CONFIRM_PRE_TRAINING:

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

			cls, err := model_classes.ListClasses(handle.Db, id)
			if err != nil {
				return c.Error500(err)
			}

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

			LoadBasedOnAnswer(c.Mode, w, "/models/edit.html", c.AddMap(AnyMap{
				"Model":                 model,
				"Classes":               cls,
				"HasData":               has_data,
				"NumberOfInvalidImages": wrong_number,
			}))
		case READY:
			LoadBasedOnAnswer(c.Mode, w, "/models/edit.html", c.AddMap(AnyMap{
				"Model": model,
			}))
		case TRAINING:

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

			defs := []defrow{}

            if model.Type == 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
				Shape     string
			}

			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.Type == 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
				}
			}

			sep_mod := 100
			if len(layers) > 8 {
				sep_mod = 100 - (len(layers)-8)*10
			}

			if sep_mod < 10 {
				sep_mod = 10
			}

			LoadBasedOnAnswer(c.Mode, w, "/models/edit.html", c.AddMap(AnyMap{
				"Model":  model,
				"Defs":   defs,
				"Layers": layers,
				"SepMod": sep_mod,
			}))
		case PREPARING_ZIP_FILE:
			LoadBasedOnAnswer(c.Mode, w, "/models/edit.html", c.AddMap(AnyMap{
				"Model": model,
			}))
		default:
			fmt.Printf("Unkown Status: %d\n", model.Status)
			return Error500(nil)
		}

		return nil
	})
}