sicherheitsunterweisung/packages/data/dbFuncs.go

package data

import (
	"database/sql"
	"fmt"
	"strings"

	"github.com/go-sql-driver/mysql"
)

func OpenDB(dbName string) (*DB, error) {
	var err error
	db := new(DB)

	cfg := mysql.NewConfig()
	cfg.DBName = dbName
	cfg.User, cfg.Passwd, err = getCredentials()
	if err != nil {
		return nil, fmt.Errorf("Open: getCredentials(): %v\n", err)
	}

	db.DB, err = sql.Open("mysql", cfg.FormatDSN())
	if err != nil {
		return nil, fmt.Errorf("Open: sql.Open(\"mysql\", cfg.FormatDSN()): %v\n", err)
	}
	if err := db.Ping(); err != nil {
		return nil, fmt.Errorf("Open: db.Ping(): %v\n", err)
	}

	return db, nil
}

func (db *DB) WriteBriefing(b *Briefing) error {
	result, err := db.Exec(`
  INSERT INTO briefings
  	(date, time, location, document_name, as_of, instructor_id)
  VALUES
  	(?, ?, ?, ?, ?, ?)
  `, b.Date, b.Time, b.Location, b.DocumentName, b.AsOf, b.InstructorID)
	if err != nil {
		return fmt.Errorf("*DB.writeBriefing: db.Exec(): %v\n", err)
	}

	b.ID, err = result.LastInsertId()
	if err != nil {
		return fmt.Errorf("*DB.writeBriefing: result.LastInsertId(): %v\n", err)
	}

	return nil
}

func (db *DB) WriteParticipant(p *Participant) error {
	result, err := db.Exec(`
  INSERT INTO participants
  	(first_name, last_name, company)
  VALUES
  	(?, ?, ?)
  `, p.FirstName, p.LastName, p.Company)
	if err != nil {
		return fmt.Errorf("*DB.writeParticipants: db.Exec(): %v\n", err)
	}

	p.ID, err = result.LastInsertId()
	if err != nil {
		return fmt.Errorf("*DB.writeParticipants: result.LastInsertId(): %v\n", err)
	}

	return nil
}

func (db *DB) WriteGivenAnswers(b Briefing, p Participant, sq []Question, givenAnswers []int) error {
	for i, q := range sq {
		_, err := db.Exec(`
    INSERT INTO given_answers
    	(briefing_id, participant_id, question_id, given_answer)
    VALUES
    	(?, ?, ?, ?)
    `, b.ID, p.ID, q.ID, givenAnswers[i])
		if err != nil {
			return fmt.Errorf("*DB.WriteGivenAnswers: db.Exec(): %v\n", err)
		}
	}

	return nil
}

func (db *DB) GetAllOverviewTableData() ([]OverviewTableData, error) {
	rows, err := db.Query(`
  SELECT
    i.first_name,
    i.last_name,
    b.date,
    b.time,
    b.location,
    b.document_name,
    b.as_of,
    p.first_name,
    p.last_name,
    p.company
  FROM given_answers AS g
    INNER JOIN briefings AS b
      ON b.id = g.briefing_id
    INNER JOIN participants AS p
      ON p.id = g.participant_id
    INNER JOIN questions AS q
      ON q.id = g.question_id
    INNER JOIN instructors AS i
      ON i.id = b.instructor_id
  WHERE
    q.id = 1
  ORDER BY
    b.id DESC,
    p.id
  `)
	if err != nil {
		return nil, fmt.Errorf("*DB.ReadAllBriefings: db.Query(): %v\n", err)
	}
	defer rows.Close()

	data := make([]OverviewTableData, 0)
	for rows.Next() {
		otd := new(OverviewTableData)

		err := rows.Scan(
			&otd.InstructorFirstName,
			&otd.InstructorLastName,
			&otd.BriefingDate,
			&otd.BriefingTime,
			&otd.BriefingLocation,
			&otd.BriefingDocumentName,
			&otd.BriefingAsOf,
			&otd.ParticipantFirstName,
			&otd.ParticipantLastName,
			&otd.ParticipantCompany,
		)
		if err != nil {
			return nil, fmt.Errorf("*DB.ReadAllBriefings: rows.Scan(): %v\n", err)
		}

		data = append(data, *otd)
	}

	return data, nil
}

func (db *DB) GetOverviewTableDataByName(n string) (*[]*OverviewTableData, error) {
	rows, err := db.Query(`
  SELECT
    i.first_name,
    i.last_name,
    b.date,
    b.time,
    b.location,
    b.document_name,
    b.as_of,
    p.first_name,
    p.last_name,
    p.company
  FROM given_answers AS g
    INNER JOIN briefings AS b
      ON b.id = g.briefing_id
    INNER JOIN participants AS p
      ON p.id = g.participant_id
    INNER JOIN instructors AS i
      ON i.id = b.instructor_id
  WHERE
    q.id = 1 AND
    i.first_name LIKE ? OR
    i.last_name LIKE ? OR
    p.first_name LIKE ? OR
    p.last_name LIKE ?
  ORDER BY
    b.id DESC,
    p.id
  `, "%"+n+"%", "%"+n+"%", "%"+n+"%", "%"+n+"%")
	if err != nil {
		return nil, fmt.Errorf("*DB.GetOverviewTableDataByName: db.Query(): %v\n", err)
	}
	defer rows.Close()

	data := make([]*OverviewTableData, 0)
	for rows.Next() {
		otd := new(OverviewTableData)

		err := rows.Scan(
			&otd.InstructorFirstName,
			&otd.InstructorLastName,
			&otd.BriefingDate,
			&otd.BriefingTime,
			&otd.BriefingLocation,
			&otd.BriefingDocumentName,
			&otd.BriefingAsOf,
			&otd.ParticipantFirstName,
			&otd.ParticipantLastName,
			&otd.ParticipantCompany,
		)
		if err != nil {
			return nil, fmt.Errorf("*DB.ReadAllBriefings: rows.Scan(): %v\n", err)
		}

		data = append(data, otd)
	}

	return &data, nil
}

func (db *DB) GetLastID(table string) (int, error) {
	var id int

	row := db.QueryRow(`
  SELECT id
  FROM ?
  ORDER BY id DESC
    LIMIT 0, 1
  `, table)

	if err := row.Scan(&id); err != nil {
		return -1, fmt.Errorf("*DB.GetLastID: row.Scan(): %v\n", err)
	}

	return id, nil
}

func (db *DB) GetInstructors() ([]*Instructor, error) {
	rows, err := db.Query(`
  SELECT *
  FROM instructors
  ORDER BY
    last_name,
    first_name
  `)
	if err != nil {
		return nil, fmt.Errorf("*DB.GetInstructors: db.Query(): %v\n", err)
	}
	defer rows.Close()

	instructors := make([]*Instructor, 0)
	for rows.Next() {
		instructor := new(Instructor)
		if err = rows.Scan(&instructor.ID, &instructor.FirstName, &instructor.LastName); err != nil {
			return nil, fmt.Errorf("*DB.GetInstructors: rows.Scan(): %v\n", err)
		}
		instructors = append(instructors, instructor)
	}

	return instructors, nil
}

func (db *DB) GetQuestions(nums []string) ([]Question, error) {
	rows, err := db.Query(`
  SELECT *
  FROM questions
  WHERE id IN (` + strings.Join(nums, ", ") + `)
  `)
	if err != nil {
		return nil, fmt.Errorf("*DB.GetQuestions: db.Query(): %v\n", err)
	}
	defer rows.Close()

	questions := make([]Question, 0)
	for rows.Next() {
		q := new(Question)
		a1 := new(Answer)
		a2 := new(Answer)
		a3 := new(Answer)
		a4 := new(Answer)

		a1.ID = 1
		a2.ID = 2
		a3.ID = 3
		a4.ID = 4

		if err := rows.Scan(&q.ID, &q.Text, &a1.Text, &a2.Text, &a3.Text, &a4.Text, &q.Correct); err != nil {
			return nil, fmt.Errorf("*DB.GetQuestions: rows.Scan(): %v\n", err)
		}

		q.Answers = append(q.Answers, *a1)
		q.Answers = append(q.Answers, *a2)
		q.Answers = append(q.Answers, *a3)
		q.Answers = append(q.Answers, *a4)

		questions = append(questions, *q)
	}

	return questions, nil
}

func (db *DB) GetGivenAnswers(bid, pid int64, sq []Question) ([]int, error) {
	answers := make([]int, 0)
	query := `
  SELECT given_answer
  FROM given_answers
  WHERE
    briefing_id = ? AND
    participant_id = ? AND
    question_id = ?
  `

	for _, q := range sq {
		var answer int

		row := db.QueryRow(query, bid, pid, q.ID)
		if err := row.Scan(&answer); err != nil {
			return nil, fmt.Errorf("*DB.GetGivenAnswers: row.Scan(): %v\n", err)
		}

		answers = append(answers, answer)
	}

	return answers, nil
}