models

type Cathedra struct {
	gorm.Model
	Name        string       `gorm:"unique_index"`
	Disciplines []Discipline `gorm:"foreignkey:Cathedra;association_foreignkey:Name"`
	Teachers    []*Teacher   `gorm:"many2many:cathedras_teachers"`
}

type Discipline struct {
	gorm.Model
	Name     string
	Cathedra string
	Teachers []*Teacher `gorm:"many2many:disciplines_teachers"`
	Skips    []Skip
	Scores   []Score
	Groups   []*Group `gorm:"many2many:disciplines_groups"`
}

type FilterScoresQueryParams struct {
	GroupID  *uint   `schema:"group_id"`
	Year     *int    `schema:"year"`
	Semester *string `schema:"semester"`
}

type FilterSkipsQueryParams struct {
	GroupID  *uint   `schema:"group_id"`
	Year     *int    `schema:"year"`
	Semester *string `schema:"semester"`
}

type Group struct {
	gorm.Model
	Name     string     `gorm:"not null;unique_index"`
	Students []*Student `gorm:"many2many:students_groups"` //`gorm:"many2many:students_groups;foreignkey:Name;association_foreignkey:ID"`
	Status   string     `sql:"type:group_status"`
	//Status bool // пока оставлю логический тип, дабы избавиться от if-ов лучше использовать enum тип, если есть [возможность]
	Year               uint          // год начала обучения
	EducationPeriod    int           // период обучения, например, 4
	Numbers            []Number      `gorm:"foreignkey:Group;association_foreignkey:Name"`
	EducationForm      string        `sql:"type:education_form"`
	EducationLevel     string        `sql:"type:education_level"`
	Institute          string        `sql:"type:institute"`
	Teachers           []*Teacher    `gorm:"many2many:groups_teachers"`
	Disciplines        []*Discipline `gorm:"many2many:disciplines_groups"`
	Starosta           Student
	Schedules          []Schedule
	GroupSemesterInfos []GroupSemesterInfo
}

type GroupDB interface {
	ByUserStatuses(user *User) ([]StarostaGroupStatuses, error)
	Update(group *Group) error
}

type GroupSemesterInfo struct {
	gorm.Model
	Semester           string `sql:"type:semester"`
	Year               uint   // год начала обучения
	GroupID            uint
	EducationStartDate time.Time
	EducationEndDate   time.Time
	DisciplinesIDs     pq.Int64Array `gorm:"type:integer[]"`
}

type GroupService interface {
	GroupDB
}

type Number struct {
	gorm.Model
	Number    uint `sql:"unique"`
	StudentID uint
	Group     string
}

type Schedule struct {
	gorm.Model
	Day time.Weekday
	//Disciplines []Discipline // не сейвит
	DisciplinesIDs pq.Int64Array `gorm:"type:integer[]"`
	Semester       string        `sql:"type:semester"`
	Year           uint          // год начала обучения
	GroupID        uint
	IsEvenWeek     bool
}

type Score struct {
	gorm.Model
	// todo лучше поменять uint на int
	Year                    uint   // год начала обучения, e.g. если учебный год 2016 - 2017, то Year = 2016
	AttestationOne          string `sql:"type:score_value"`
	AttestationTwo          string `sql:"type:score_value"`
	AttestationThree        string `sql:"type:score_value"`
	IntermediateAttestation string `sql:"type:score_value"`
	Semester                string `sql:"type:semester"`
	StudentID               uint
	DisciplineID            uint
}

type ScoreDB interface {
	LastUpdated() (string, error)
	ByUser(user *User, GETParams interface{}) (*ScoresResult, []string, error)
	ByUserFilterData(user *User, GETParams *FilterScoresQueryParams) (*ScoresResult, error)
	Update(score *Score) error
	ReportByUser(user *User, GETParams *ScoresStarostaQueryParams) (*excelize.File, error)
}

type ScoreService interface {
	ScoreDB
}

type ScoresResult struct {
	StudentScoresResult
	StarostaScoresResult
}

type ScoresStarostaQueryParams struct {
	GroupID      *uint   `schema:"group_id"`
	Year         *uint   `schema:"year"`
	Semester     *string `schema:"semester"`
	DisciplineID *uint   `schema:"discipline_id"`
}

type ScoresStudentQueryParams struct {
	GroupID        *uint   `schema:"group_id"`
	Year           *uint   `schema:"year"`
	Semester       *string `schema:"semester"`
	DisciplinesIDs []uint  `schema:"disciplines_ids"`
}

type SelectOptionData struct {
	Value      interface{}
	Text       string
	IsSelected bool
}

type Services struct {
	User UserService

	Score ScoreService
	Group GroupService
	Skip  SkipService
	// contains filtered or unexported fields
}

type ServicesConfig func(*Services) error

type Skip struct {
	gorm.Model          // дата содержится в Created_at - отменено использование этого поля в кач-ве даты, выделено отдельное
	Reason       string `sql:"type:reason"`
	DisciplineID uint
	StudentID    uint
	Date         time.Time // нужна потому, что в методе skipsC.Show отсутсвующие пропуски за конкретную дату создаются на ходу
	LessonNumber int
}

type SkipDB interface {
	ByUser(user *User, GETParams interface{}) (*SkipsResult, []string, error)
	Update(skip *Skip) error
	Edit(user *User, GETParams *SkipsEditStarostaQueryParams) (*StarostaSkipsEditResult, error)
	ByUserFilterData(user *User, GETParams interface{}) (interface{}, error)
	ByUserEditFilterData(user *User, GETParams *SkipsEditStarostaQueryParams) (*StarostaSkipsEditResult, error)
}

type SkipRow struct {
	SkipDate   string
	SkipReason string
}

type SkipService interface {
	SkipDB
}

type SkipsEditStarostaQueryParams struct {
	GroupID        *uint   `schema:"group_id"`
	Date           *string `schema:"date"`
	DisciplineInfo *string `schema:"discipline_info"`
}

type SkipsResult struct {
	StudentSkipsResult
	StarostaSkipsResult
}

type SkipsStarostaQueryParams struct {
	GroupID   *uint   `schema:"group_id"`
	Year      *uint   `schema:"year"`
	Semester  *string `schema:"semester"`
	StudentID *uint   `schema:"student_id"`
}

type SkipsStudentQueryParams struct {
	GroupID  *uint   `schema:"group_id"`
	Year     *uint   `schema:"year"`
	Semester *string `schema:"semester"`
}

type StarostaGroupStatuses struct {
	GroupName string
	GroupID   uint
	IsActual  bool
}

type StarostaScoresFilterData struct {
	Groups      []SelectOptionData
	Years       []SelectOptionData
	Semesters   []SelectOptionData
	Disciplines []SelectOptionData
}

type StarostaScoresResult struct {
	StarostaScoresFilterData
	StarostaScoresResultData
}

type StarostaScoresResultData struct {
	Result StarostaScoresRows
}

type StarostaScoresRows struct {
	DisciplineID uint   //исп-ся в методе ReportByStarosta - больше так не делать, отдельную структуру на каждый метод
	Discipline   string //исп-ся в методе ReportByStarosta
	Teacher      string
	Cathedra     string
	StudentsInfo []StarostaScoresStudentInfo
}

type StarostaScoresStudentInfo struct {
	ScoreID         uint
	StudentName     string
	AttOne          string
	AttTwo          string
	AttThree        string
	AttIntermediate string
	Skips           string
}

type StarostaSkipsEditFilterData struct {
	Groups      []SelectOptionData
	Date        string
	Disciplines []SelectOptionData
}

type StarostaSkipsEditResult struct {
	StarostaSkipsEditFilterData
	StarostaSkipsEditResultData
}

type StarostaSkipsEditResultData struct {
	Rows []StarostaSkipsEditRow
}

type StarostaSkipsEditRow struct {
	StudentName string
	SkipID      uint
	SkipReason  string
}

type StarostaSkipsFilterData struct {
	Groups    []SelectOptionData
	Years     []SelectOptionData
	Semesters []SelectOptionData
	Students  []SelectOptionData
}

type StarostaSkipsResult struct {
	StarostaSkipsFilterData
	StarostaSkipsResultData
}

type StarostaSkipsResultData struct {
	Rows []StarostaSkipsRow
}

type StarostaSkipsRow struct {
	DisciplineName string
	Skips          []SkipRow
	NumberOfUHours float32
	NumberOfNHours float32
	TotalHours     float32
}

type Student struct {
	gorm.Model
	FirstName  string
	MiddleName string // отчество
	LastName   string
	Numbers    []Number // Номера зачеток, без тегов возможно не будет подгружаться
	Users      []*User  `gorm:"many2many:users_students"`
	Groups     []*Group `gorm:"many2many:students_groups"`
	Scores     []Score
	Skips      []Skip
	GroupID    uint
}

type StudentScoresFilterData struct {
	Groups      []SelectOptionData
	Years       []SelectOptionData
	Semesters   []SelectOptionData
	Disciplines []SelectOptionData
	Teachers    []SelectOptionData
}

type StudentScoresResult struct {
	StudentScoresFilterData
	StudentScoresResultData
}

type StudentScoresResultData struct {
	Result []StudentScoresRows
}

type StudentScoresRows struct {
	DisciplineName  string
	TeacherName     string
	Cathedra        string
	AttOne          string
	AttTwo          string
	AttThree        string
	AttIntermediate string
	Skips           string
}

type StudentSkipsFilterData struct {
	Groups    []SelectOptionData
	Years     []SelectOptionData
	Semesters []SelectOptionData
}

type StudentSkipsResult struct {
	StudentSkipsFilterData
	StudentSkipsResultData
}

type StudentSkipsResultData struct {
	Rows []StudentSkipsRow
}

type StudentSkipsRow struct {
	DisciplineName string
	Skips          []SkipRow
	NumberOfUHours float32
	NumberOfNHours float32
	TotalHours     float32
}

type Teacher struct {
	gorm.Model
	FirstName   string
	MiddleName  string // отчество
	LastName    string
	Disciplines []*Discipline `gorm:"many2many:disciplines_teachers"`
	Cathedras   []*Cathedra   `gorm:"many2many:cathedras_teachers"`
	Groups      []*Group      `gorm:"many2many:groups_teachers"`
}

type User struct {
	gorm.Model
	FirstName    string
	MiddleName   string // отчество
	LastName     string
	Email        string     //`gorm:"not null;unique_index"`
	Password     string     `gorm:"-"`
	PasswordHash string     `gorm:"not null"`
	Remember     string     `gorm:"-"`
	RememberHash string     `gorm:"not null;unique_index"`
	Login        string     `gorm:"not null;unique_index"`
	Class        string     `sql:"type:class"`
	Students     []*Student `gorm:"many2many:users_students"`
}

type UserDB interface {
	// Methods for querying for single users
	ByID(id uint) (*User, error)
	ByEmail(email string) (*User, error)
	ByRemember(token string) (*User, error)
	ByLogin(login string) (*User, error)
	// Methods for altering users
	Create(user *User) error
	Update(user *User) error
	Delete(id uint) error
	//
	Authenticate(login, password string) (*User, error)
}

type UserService interface {
	// Authenticate will verify the provided email address and
	// password are correct. If they are correct, the user
	// corresponding to that email will be returned. Otherwise
	// You will receive either:
	// ErrNotFound, ErrPasswordIncorrect, or another error if
	// something goes wrong.
	UserDB
}