personal-website/apps/personalprops/personalprops.go

package personalprops

import (
	"errors"
	"net/http"
	websiteapp "personalwebsite/apps"
	"personalwebsite/libs"
	"personalwebsite/webfilesystem"

	"github.com/gin-gonic/gin"
	"go.mongodb.org/mongo-driver/bson/primitive"
)

type PersonalPropertiesApp struct {
	fs       *webfilesystem.WebFileSystem
	manifest websiteapp.ApplicationManifest
}

func NewPersPropsApp(webFs *webfilesystem.WebFileSystem) PersonalPropertiesApp {
	newApp := PersonalPropertiesApp{
		fs: webFs,
		manifest: websiteapp.ApplicationManifest{
			AppId:      "personal-properties",
			WindowName: "About me",
		},
	}
	return newApp
}

func (p *PersonalPropertiesApp) Route(route *gin.RouterGroup) {
	route.GET("render", func(ctx *gin.Context) {
		isMobileParam := ctx.Query("isMobile")
		isMobile := isMobileParam == "true"
		ginH, err := p.Render()
		if err != nil {
			ctx.JSON(http.StatusInternalServerError, "TODO") //TODO
		}
		if isMobile {
			ctx.HTML(http.StatusOK, "personal-properties/mobile-app.tmpl", ginH)
		} else {
			ctx.HTML(http.StatusOK, "personal-properties/app.tmpl", ginH)
		}
	})
}

func (p *PersonalPropertiesApp) GetManifest() websiteapp.ApplicationManifest {
	return p.manifest
}
func (p *PersonalPropertiesApp) GetId() string {
	return p.manifest.AppId
}

func (p *PersonalPropertiesApp) WriteToDb() {
	allProps := make([]PropIsland, 0)

	// careerProps := make([]Prop, 0)
	expertiseIsland := PropIsland{
		Header: "Area Of Expertise",
		Props: []PropElement{{
			Key: "Programming",
			Values: []string{
				"Creating tools and plugins for artists",
				"Editor and basic gameplay scripting",
			},
		},
			{
				Key: "Game Art",
				Values: []string{
					"Professional modeling",
					"Complete knowledge in CG render theory",
				},
			},
		},
	}
	eduIsland := PropIsland{
		Header: "Education",
		Props: []PropElement{
			{
				Key:         "Gymnasium 526",
				KeyComments: []string{"2005-2015"},
				Values:      []string{"Extended natural sciences course", "Additional C++, media production and computer graphics courses", "Winner of conference “The future of a strong Russia is in high technology” in programming section"},
			},
			{
				Key:         "Lyceum 281",
				KeyComments: []string{"2015-2016"},
				Values:      []string{"Extended IT and Physical sciences course"},
			},
			{
				Key:         "University",
				KeyComments: []string{"2017-2019"},
				Values:      []string{"Faculty: Info-communication Networks and Systems", "Specialty: Information Security"},
			},
		},
	}
	careerProps := PropIsland{
		Header: "Career",
		Props: []PropElement{
			{
				Key:         "VR lab assistant",
				KeyComments: []string{"Academy of Digital Technologies", "2019-2020"},
				Values:      []string{"Teaching lessons for students in Unreal Engine 4, Unity and Blender editor courses", "Training students for World Skills Russia"},
			},
			{
				Key:         "3d artist",
				KeyComments: []string{"Space Time VR", "2020-2020"},
				Values:      []string{"Creating 3d assets for VR game"},
			},
			{
				Key:         "Jr. Techartist",
				KeyComments: []string{"MP Games"},
				Values:      []string{"Game content integration and production", "Shader coding", "Optimization asset production in artists pipeline"},
			},
			{
				Key:    "Techartist",
				Values: []string{"Game content optimization and production", "Profiling and debugging render pipeline", "Creating in-house tools for pipeline software", "Working process pipeline integration and maintenance", "Linux servers administration"},
			},
		},
	}
	volunteerProps := PropIsland{
		Header: "Volunteer Experience",
		Props: []PropElement{
			{
				Key: "Metrostroi Mod",
				Values: []string{
					"Help unite fragmented community on one social platform",
					"Worked on social elements of official site, create ranking",
					"Took a part on creating ranking system for players",
					"Creating models and maps for Steam Workshop"},
			},
			{
				Key: "Age of Silence",
				Values: []string{
					"Start as tech-artist, create naming system in big ue4 project",
					"Promoted to chief of 3d Department",
					"Project win Unreal Day 2019",
				},
			},
		},
	}

	allProps = append(allProps, expertiseIsland, careerProps, eduIsland, volunteerProps)
	file := webfilesystem.WebFSFile{
		MongoId: primitive.NewObjectID(),
		Name:    "personal.props",
		Type:    "props",
		Data: PropertiesFile{
			Props: allProps,
		},
	}
	err := p.fs.CreateFile(&file, "/home/user/")
	if err != nil {
		println(err.Error())
	} else {
		println("Ok")
	}
}

func (p *PersonalPropertiesApp) Render() (gin.H, error) {
	props, err := p.fs.Read("/home/user/personal.props")
	if err != nil {
		return nil, err
	}
	if props.Data == nil || props.Type != "props" {
		return nil, errors.New("bad file")
	}
	headerProps := props.Data.(primitive.D).Map()["headerprops"].(primitive.D).Map()
	// file, err := p.fs.Read(headerProps["icon"].(string))
	if err != nil {
		//TODO err catch
	}

	// data, err := wde.ReadImage(file)
	// if err != nil {
	// 	return nil, err
	// }

	hIsland := HeaderIsland{
		Name: headerProps["name"].(string),
		// Icon:  data,
		Info1: "LLL",
		Info2: "QQQ",
	}

	allProps := make([]PropIsland, 0)

	for _, v := range props.Data.(primitive.D).Map()["props"].(primitive.A) {
		island := PropIsland{}
		island.Header = v.(primitive.D).Map()["header"].(string)
		for _, prop := range v.(primitive.D).Map()["props"].(primitive.A) {
			elem := PropElement{
				Key: prop.(primitive.D).Map()["key"].(string),
			}
			if prop.(primitive.D).Map()["keycomments"] != nil {
				for _, keyComments := range prop.(primitive.D).Map()["keycomments"].(primitive.A) {
					elem.KeyComments = append(elem.KeyComments, keyComments.(string))
				}
			}
			for _, elemValues := range prop.(primitive.D).Map()["values"].(primitive.A) {
				elem.Values = append(elem.Values, elemValues.(string))
			}
			island.Props = append(island.Props, elem)
		}
		allProps = append(allProps, island)
	}

	return gin.H{
		"headerProps": hIsland,
		"allprops":    allProps,
	}, nil
}

type HeaderIsland struct {
	Name  string
	Icon  *libs.Base64Img
	Info1 string
	Info2 string
}

type PropElement struct {
	Key         string
	KeyComments []string
	Values      []string
}

type PropIsland struct {
	Header string
	Props  []PropElement
}

type PropertiesFile struct {
	Props []PropIsland `bson:"props"`
}