path: root/interface/main.go

package main

import (
	"fmt"
	"fyne.io/fyne/v2"
	"fyne.io/fyne/v2/app"
	"fyne.io/fyne/v2/container"
	"fyne.io/fyne/v2/layout"
	"fyne.io/fyne/v2/widget"
)

type DBInterface struct {
	application fyne.App
	window      fyne.Window
	db          SQLConnection
}

func genMainView(view fyne.CanvasObject, buttons []fyne.CanvasObject) fyne.CanvasObject {
	return container.NewBorder(
		nil, container.NewGridWithColumns(len(buttons), buttons...), nil, nil, view)
}

func (app *DBInterface) insertAdminView(table string) {
	app.window.SetTitle(fmt.Sprintf("Insert into table %s", table))
	columns, _ := app.db.getColumns(table)

	var elements []fyne.CanvasObject
	for _, val := range columns {
		label := widget.NewLabel(val)
		input := widget.NewEntry()
		elements = append(elements, container.New(
			layout.NewBorderLayout(nil, nil, label, nil),
			label, input))
	}

	insertBtn := widget.NewButton("Вставить", func() {})
	backBtn := widget.NewButton("Назад", func() {
		app.showAdminTable(table)
	})
	mainContainer := container.NewVBox(elements...)
	app.window.SetContent(
		genMainView(
			container.NewVScroll(mainContainer),
			[]fyne.CanvasObject{insertBtn, backBtn}))
}

func (app *DBInterface) deleteAdminView(table string) {
	app.window.SetTitle(fmt.Sprintf("Delete from table %s", table))

	queryLabel := widget.NewLabel(fmt.Sprintf("DELETE FROM [%s] WHERE", table))

	var query []fyne.CanvasObject
	newConstraintBtn := widget.NewButton("Добавить новое ограничение", func() {})
	updateView := func() {
		queryBox := container.NewVBox(queryLabel, container.NewVBox(query...), newConstraintBtn)
		deleteBtn := widget.NewButton("Выполнить удаление", func() {

		})
		backBtn := widget.NewButton("Назад", func() {
			app.showAdminTable(table)
		})
		app.window.SetContent(
			genMainView(
				container.NewVScroll(queryBox),
				[]fyne.CanvasObject{deleteBtn, backBtn}))
	}

	columns, _ := app.db.getColumns(table)
	newConstraintBtn.OnTapped = func() {
		selectBtn := widget.NewSelect(columns, func(value string) {
			fmt.Println("Select set to", value)
		})
		operatorBtn := widget.NewSelect([]string{"=", "<", "<=", ">=", "LIKE"}, func(value string) {
			fmt.Println("Select set to", value)
		})
		compareField := widget.NewEntry()

		fieldConstraint := container.NewGridWithColumns(3, selectBtn, operatorBtn, compareField)
		query = append(query, fieldConstraint)
		updateView()
	}
	updateView()
}

func (app *DBInterface) selectAdminView(table string) {
	app.window.SetTitle(fmt.Sprintf("Select from table %s", table))

	columns, _ := app.db.getColumns(table)

	var selectFields []fyne.CanvasObject
	newField := widget.NewButton("Добавить новое поле", func() {})

	var query []fyne.CanvasObject
	newConstraintBtn := widget.NewButton("Добавить новое ограничение", func() {})
	updateView := func() {
		var widgets []fyne.CanvasObject
		widgets = append(widgets, widget.NewLabel("SELECT"))
		for _, val := range selectFields {
			widgets = append(widgets, container.NewHBox(val, widget.NewLabel(",")))
		}
		widgets = append(widgets, newField)
		widgets = append(widgets, widget.NewLabel(fmt.Sprintf("FROM [%s] WHERE", table)))

		for _, val := range query {
			widgets = append(widgets, val)
		}
		widgets = append(widgets, newConstraintBtn)

		selectBtn := widget.NewButton("Показать результаты выбора", func() {
			w := app.application.NewWindow("hello")
			w.Resize(fyne.NewSize(100, 100))
			//conn := DBInterface{app.application, w, app.db}
			w.Show()
		})
		backBtn := widget.NewButton("Назад", func() {
			app.showAdminTable(table)
		})

		app.window.SetContent(
			genMainView(
				container.NewVScroll(container.NewVBox(widgets...)),
				[]fyne.CanvasObject{selectBtn, backBtn}))
	}

	newField.OnTapped = func() {
		selectBtn := widget.NewSelect(columns, func(value string) {
			fmt.Println("Select set to", value)
		})
		selectFields = append(selectFields, selectBtn)
		updateView()
	}
	newConstraintBtn.OnTapped = func() {
		selectBtn := widget.NewSelect(columns, func(value string) {
			fmt.Println("Select set to", value)
		})
		operatorBtn := widget.NewSelect([]string{"=", "<", "<=", ">=", "LIKE"}, func(value string) {
			fmt.Println("Select set to", value)
		})
		compareField := widget.NewEntry()

		fieldConstraint := container.NewGridWithColumns(3, selectBtn, operatorBtn, compareField)
		query = append(query, fieldConstraint)
		updateView()
	}
	updateView()
}

func (app *DBInterface) showAdminTable(table string) {
	data, err := app.db.getTable(table)
	if err != nil {
		fmt.Println(err)
		return
	}
	columns, err := app.db.getColumns(table)

	list := widget.NewTable(
		func() (int, int) {
			return len(data), len(columns)
		},
		func() fyne.CanvasObject {
			return widget.NewLabel("wide content")
		},
		func(i widget.TableCellID, o fyne.CanvasObject) {
			o.(*widget.Label).SetText(fmt.Sprintf("%v", data[i.Row][i.Col]))
		})

	selectBtn := widget.NewButton("Выбрать", func() {
		app.selectAdminView(table)
	})

	insertBtn := widget.NewButton("Вставить", func() {
		app.insertAdminView(table)
	})

	deleteBtn := widget.NewButton("Удалить", func() {
		app.deleteAdminView(table)
	})

	back := widget.NewButton("Назад", func() {
		app.adminView()
	})

	app.window.SetContent(genMainView(list, []fyne.CanvasObject{selectBtn, insertBtn, deleteBtn, back}))
}

func (app *DBInterface) adminView() {
	tables, _ := app.db.getTables()

	var tableBtns []fyne.CanvasObject
	tableBtns = append(tableBtns, container.NewCenter(widget.NewLabel("Таблицы")))
	for _, val := range tables {
		e := val
		tableBtns = append(
			tableBtns, widget.NewButton(
				fmt.Sprintf("Показать %s", val),
				func() {
					app.showAdminTable(e)
				}))
	}

	views, _ := app.db.getViews()
	var viewsBtns []fyne.CanvasObject
	viewsBtns = append(viewsBtns, container.NewCenter(widget.NewLabel("Представления")))
	for _, val := range views {
		e := val
		viewsBtns = append(
			viewsBtns, widget.NewButton(
				fmt.Sprintf("Показать %s", val),
				func() {
					app.showAdminTable(e)
				}))
	}

	tablesScroll := container.NewVScroll(container.NewVBox(tableBtns...))
	viewsScroll := container.NewVScroll(container.NewVBox(viewsBtns...))

	dataBox := container.NewGridWithColumns(2, tablesScroll, viewsScroll)
	menuBtn := widget.NewButton("В меню", func() {
		app.menu()
	})

	app.window.SetContent(genMainView(dataBox, []fyne.CanvasObject{menuBtn}))
}

func (app *DBInterface) showUserTable(table string) {
	data, err := app.db.getTable(table)
	if err != nil {
		fmt.Println(err)
		return
	}
	columns, err := app.db.getColumns(table)

	list := widget.NewTable(
		func() (int, int) {
			return len(data), len(columns)
		},
		func() fyne.CanvasObject {
			return widget.NewLabel("wide content")
		},
		func(i widget.TableCellID, o fyne.CanvasObject) {
			o.(*widget.Label).SetText(fmt.Sprintf("%v", data[i.Row][i.Col]))
		})

	back := widget.NewButton("Назад", func() {
		app.userView()
	})

	app.window.SetContent(genMainView(list, []fyne.CanvasObject{back}))
}

func (app *DBInterface) userView() {
	views, _ := app.db.getViews()
	var viewsBtns []fyne.CanvasObject
	viewsBtns = append(viewsBtns, container.NewCenter(widget.NewLabel("Представления")))
	for _, val := range views {
		e := val
		viewsBtns = append(
			viewsBtns, widget.NewButton(
				fmt.Sprintf("Показать %s", val),
				func() {
					app.showUserTable(e)
				}))
	}

	viewsScroll := container.NewVScroll(container.NewVBox(viewsBtns...))
	menuBtn := widget.NewButton("В меню", func() {
		app.menu()
	})

	app.window.SetContent(container.NewBorder(nil, menuBtn, nil, nil, viewsScroll))
}

func (app *DBInterface) menu() {
	app.window.SetContent(container.NewCenter(
		container.NewVBox(
			widget.NewButton("Режим Администратора", func() {
				app.adminView()
			}),
			widget.NewButton("Режим Пользователя", func() {
				app.userView()
			}),
		),
	))
}

func main() {
	myApp := app.New()
	window := myApp.NewWindow("Table Widget")
	window.Resize(fyne.NewSize(700, 480))

	db := SQLConnection{}
	err := db.init()
	if err != nil {
		fmt.Println(err)
		return
	}

	dbApp := DBInterface{myApp, window, db}
	dbApp.menu()
	window.ShowAndRun()
}