gorm+gin 教务管理系统

已于 2023-04-25 16:18:13 修改
阅读量283 收藏 3
点赞数 1
文章标签： golang
于 2023-04-24 17:56:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61618831/article/details/130348627
版权

gorm+gin 教务管理系统

搭建环境

gin框架下载

go get -u github.com/gin-gonic/gin 下载gin框架

gorm框架下载

go get gorm.io/driver/mysql
go get gorm.io/gorm

数据库搭建

create database school_go default charset=utf8;

创建指定数据库用户

create user "123" identified by '123';
grant all privileges on school_go.* to '123'@'%';
flush privileges;

拆分业务

根目录下新建main.go函数 作为项目总入口

package main

import "main/router"

func main() {
   r := router.Router()
   _ = r.Run("0.0.0.0:8080")
}

在根路径下创建router目录

里面新建app.go文件

package router

import (
	"github.com/gin-gonic/gin"
	"main/service"
)

func Router() *gin.Engine {
	router := gin.Default()

	router.GET("/ping", service.Ping)

	return router
}

在根路径下创建service目录 业务逻辑就写在这里

package service

import "github.com/gin-gonic/gin"

func Ping(c *gin.Context) {
   c.JSON(200, gin.H{
      "message": "pong",
   })

}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LKwe5n5y-1682330141324)(教务管理系统.assets/image-20230420174809720.png)]

设计数据库

连接数据库

在根目录下新建一个models目录

里面新建一个init.go文件 用来连接数据库

package models

import (
   "fmt"
   "gorm.io/driver/mysql"
   "gorm.io/gorm"
)

var DB *gorm.DB

func init() {
   username := "123"     //账号
   password := "123"     //密码
   host := "127.0.0.1"   //数据库地址，可以是Ip或者域名
   port := 3306          //数据库端口
   Dbname := "school_go" //数据库名
   timeout := "10s"      //连接超时，10秒

   // username:password@tcp(127.0.0.1:3306)/gorm?
   dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8mb4&parseTime=True&loc=Local&timeout=%s",
      username, password, host, port, Dbname, timeout)
   //连接MYSQL, 获得DB类型实例，用于后面的数据库读写操作。
   db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
   if err != nil {
      panic("连接数据库失败, error=" + err.Error())
   }
   // 连接成功
   DB = db
}

设计数据库表结构

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TNFjiLdx-1682330141325)(教务管理系统.assets/image-20230424170931797.png)]

在models中新建这样的文件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DqEE2jjD-1682330141326)(教务管理系统.assets/image-20230421152349705.png)]

class.go
package models

import "gorm.io/gorm"

// 班级表
type Class struct {
	gorm.Model
	Name              string             `gorm:"type:VARCHAR(16);COMMENT:班级名称" json:"name" form:"name"`
	Students          []Student          `gorm:"foreignKey:class_id;references:id" `
	Course_selections []Course_selection `gorm:"foreignKey:class_id;references:id"`
}
course.go
package models

import "gorm.io/gorm"

// 课程表
type Course struct {
	gorm.Model
	Name              string             `gorm:"type:VARCHAR(16);COMMENT:课程名" json:"name" form:"name"`
	Hour              int                `gorm:"type:INT;COMMENT:学时" json:"hour"  form:"hour"`
	Credit            int                `gorm:"type:INT;COMMENT:学分" json:"credit"  form:"credit"`
	Course_selections []Course_selection `gorm:"foreignKey:course_id;references:id" json:"course_selections"`
}
course_selection.go
package models

import "gorm.io/gorm"

// 选课表
type Course_selection struct {
	gorm.Model
	Positon    string  `gorm:"type:VARCHAR(32);COMMENT:上课地点" json:"position" form:"position"`
	Time       string  `gorm:"type:VARCHAR(32);COMMENT:上课时间"  json:"time" form:"time"`
	Class_id   uint    `gorm:"tpye:BIGINT;COMMENT:外键关联班级表" json:"class_id" form:"class_id"`
	Course_id  uint    `gorm:"tpye:BIGINT;COMMENT:外键关联课程表" json:"course_id" form:"course_id"`
	Teacher_id uint    `gorm:"tpye:BIGINT;COMMENT:外键关联教师表" json:"teacher_id" form:"teacher_id"`
	Exam       Exam    `gorm:"foreignKey:course_selection_id;references:id" json:"exam"`
	Grades     []Grade `gorm:"foreignKey:course_id;references:id" json:"grades"`
}
department.go
package models

import "gorm.io/gorm"

// 部门表（系表）
type Department struct {
	gorm.Model
	Name          string         `gorm:"type:VARCHAR(16);COMMENT:二级学院名称" json:"name" form:"name" binding:"required"`
	Location      string         `gorm:"type:VARCHAR(32);COMMENT:地址" json:"location" form:"location"`
	Professionals []Professional `gorm:"foreignKey:Department_id;references:id" json:"professionals" `
	Teachers      []Teacher      `gorm:"foreignKey:Department_id;references:id" json:"teachers" `
}
exam.go
package models

import "gorm.io/gorm"

// 考试安排表
type Exam struct {
	gorm.Model
	Exam_data           string `gorm:"type:DATE;COMMENT:考试时间 格式:2023-03-24" json:"exam_data"  form:"exam_data"`
	Start_time          string `gorm:"type:TIME;COMMENT:开考时间 格式:2023-04-24 12:26:53" json:"start_time"  form:"start_time"`
	End_time            string `gorm:"type:TIME;COMMENT:结束时间 格式:2023-04-24 12:26:53" json:"end_time" form:"end_time"`
	Position            string `gorm:"type:VARCHAR(32);COMMENT:考点" json:"position" form:"position"`
	Course_selection_id uint   `gorm:"type:BIGINT;COMMENT:外键关联课程选择表"  form:"course_selection_id"`
}
grade.go
package models

import "gorm.io/gorm"

// 成绩表
type Grade struct {
	gorm.Model
	Score      int  `gorm:"type:INT;COMMENT:得分" json:"score" form:"score"`
	Student_id uint `gorm:"type:BIGINT;COMMENT:外键关联学生表" json:"student_id"  form:"student_id"`
	Course_id  uint `gorm:"type:BIGINT;COMMENT:外键关联选课表" json:"course_id"  form:"course_id"` //关联的是选课表
}
professional.go
package models

import "gorm.io/gorm"

// 专业表
type Professional struct {
	gorm.Model
	Name          string    `gorm:"type:VARCHAR(16);COMMENT:专业名;" json:"name" form:"name"`
	Department_id uint      `gorm:"type:BIGINT;COMMENT:外键关联部门表" json:"department_id" form:"department_id"`
	Students      []Student `gorm:"foreignKey:professional_id;references:id" json:"students"`
}
student.go
package models

import "gorm.io/gorm"

// 学生表
type Student struct {
	gorm.Model
	Name            string  `gorm:"type:VARCHAR(16);COMMENT:姓名;" json:"name" form:"name"`
	Age             int     `gorm:"type:TINYINT(3);COMMENT:分类id;" json:"age" form:"age" `
	Gender          int     `gorm:"type:TINYINT(1);COMMENT:性别 0-女 1-男 " json:"gender"  form:"gender"`
	Class_id        uint    `gorm:"type:BIGINT;COMMENT:外键关联课程表" json:"class_id"  form:"class_id"`
	Professional_id uint    `gorm:"type:BIGINT;COMMENT:外键关联专业表" json:"professional_id"  form:"professional_id"`
	Grades          []Grade `gorm:"foreignKey:Student_id;references:ID" `
}
teacher.go
package models

import "gorm.io/gorm"

// 教师表
type Teacher struct {
	gorm.Model
	Name              string             `gorm:"type:VARCHAR(16);COMMENT:教师名" json:"name" form:"name"`
	Age               int                `gorm:"type:TINYINT(3);COMMENT:年龄" json:"age" form:"age"`
	Education         string             `gorm:"VARCHAR(32);COMMENT:学历" json:"education" form:"education"`
	Title             string             `gorm:"VARCHAR(16);COMMENT:职称"  json:"title" form:"title"`
	Gender            int                `gorm:"TINYINT(1);COMMENT:性别 0-女 1-男" json:"gender" form:"gender"`
	Department_id     uint               `gorm:"type:BIGINT;COMMENT:外键关联部门表" json:"department_id" form:"department_id"`
	Course_selections []Course_selection `gorm:"foreignKey:teacher_id;references:id" json:"course_selections"`
}

迁移数据库表结构

修改models/init.go文件

package models

import (
	"fmt"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
)

var DB = Init()

func migrate(db *gorm.DB) {
	err := db.AutoMigrate(&Department{}, &Professional{}, &Teacher{})
	err = db.AutoMigrate(&Professional{}, &Class{}, &Student{})
	err = db.AutoMigrate(&Teacher{}, &Class{}, &Course{}, &Course_selection{})
	err = db.AutoMigrate(&Course_selection{}, &Exam{})
	err = db.AutoMigrate(&Course_selection{}, &Student{}, &Grade{})

	if err != nil {
		fmt.Println(err)
		return
	}
}
func Init() *gorm.DB {
	username := "123"     //账号
	password := "123"     //密码
	host := "127.0.0.1"   //数据库地址，可以是Ip或者域名
	port := 3306          //数据库端口
	Dbname := "school_go" //数据库名
	timeout := "10s"      //连接超时，10秒

	// username:password@tcp(127.0.0.1:3306)/gorm?
	dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8mb4&parseTime=True&loc=Local&timeout=%s",
		username, password, host, port, Dbname, timeout)
	//连接MYSQL, 获得DB类型实例，用于后面的数据库读写操作。
	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
	if err != nil {
		panic("连接数据库失败, error=" + err.Error())
	}
	// 连接成功
	//数据迁移 生成数据库
	migrate(db)
	return db
}

使用swag

下载gin-swagger

go install github.com/swaggo/swag/cmd/swag@latest 
swag init
go get -u github.com/swaggo/gin-swagger
go get -u github.com/swaggo/files

修改主函数main.go

package main

import (
   swaggerfiles "github.com/swaggo/files"
   ginSwagger "github.com/swaggo/gin-swagger"
   "main/docs"
   "main/router"
)

func main() {
   r := router.Router()
// 将SwaggerInfo的BasePath设置为空字符串
docs.SwaggerInfo.BasePath = ""
// 将GET请求与Swagger UI的处理程序进行包装
r.GET("/swagger/*any", ginSwagger.WrapHandler(swaggerfiles.Handler))
   _ = r.Run("0.0.0.0:8080")
}

设计业务

新建一个define路径下的define.go

存放默认值

package define

const (
   DefaultPage = "1"
   DefaultSize = "20"
)

service路径下每个模块创建一个go文件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DipcAJl8-1682330141326)(教务管理系统.assets/image-20230424171122179.png)]

班级

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AKrRcdFD-1682330141327)(教务管理系统.assets/image-20230424164857963.png)]

package service

import (
   "fmt"
   "github.com/gin-gonic/gin"
   "log"
   "main/define"
   "main/models"
   "net/http"
   "strconv"
)

// ClassDetail
// @Tags 班级
// @Summary 班级详细
// @Param int query int true "id"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /class/detail [get]
func ClassDetail(c *gin.Context) {
   ID := c.Query("id")
   data := new(models.Class)
   err := models.DB.First(data, ID).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("ID not found:" + err.Error()),
      })
      return
   }
   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "data": data,
   })
}

// ClassCreate
// @Tags 班级
// @Summary 班级创建
// @Param name formData string true "name"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /class/create [post]
func ClassCreate(c *gin.Context) {
   var classdata models.Class
   err := c.ShouldBind(&classdata)
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("binding failed:" + err.Error()),
      })
      return
   }
   err = models.DB.Create(&classdata).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("class create error:" + err.Error()),
      })
      return
   }
   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "data": "班级创建成功",
   })
}

// ClassModify
// @Tags 班级
// @Summary 班级修改
// @Param id query int true "id"
// @Param name formData string false "name"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /class/update [put]
func ClassModify(c *gin.Context) {
   var classdata models.Class
   ID := c.Query("id")
   err := c.ShouldBind(&classdata)
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("binding failed:" + err.Error()),
      })
      return
   }

   beforedata := new(models.Class)
   err = models.DB.First(beforedata, ID).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("ID not found:" + err.Error()),
      })
      return
   }

   models.DB.Model(beforedata).Updates(&classdata)
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("class update error:" + err.Error()),
      })
      return
   }

   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "msg":  "修改成功",
   })
}

// ClassDelete
// @Tags 班级
// @Summary 班级删除
// @Param id query int true "id"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /class/delete [delete]
func ClassDelete(c *gin.Context) {
   ID := c.Query("id")
   data := new(models.Class)
   err := models.DB.First(data, ID).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("ID not found:" + err.Error()),
      })
      return
   }

   err = models.DB.Delete(data).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("class delete error:" + err.Error()),
      })
      return
   }

   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "msg":  "删除成功",
   })
}

// GetClassList
// @Tags 班级
// @Summary 班级列表
// @Param page query int false "page"
// @Param size query int false "size"
// @Param keyword query string false "keyword"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /class/list [get]
func GetClassList(c *gin.Context) {
   size, _ := strconv.Atoi(c.DefaultQuery("size", define.DefaultSize))
   page, err := strconv.Atoi(c.DefaultQuery("page", define.DefaultPage))

   if err != nil {
      log.Println("GetClassList Page strconv Error:", err)
      return
   }
   page = (page - 1) * size
   keyword := c.Query("keyword")
   var count int64
   var list = make([]models.Class, 0)

   err = models.DB.Model(new(models.Class)).Preload("Students").Preload("Course_selections").
      Count(&count).Offset(page).Limit(size).
      Where("name like ?", "%"+keyword+"%").Find(&list).Error

   if err != nil {
      log.Println("Get Class List Error", err)
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  "Get Class List Error" + err.Error(),
      })
      return
   }

   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "data": map[string]interface{}{
         "list":  list,
         "count": count,
      },
   })
}

课程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u3bMm4C8-1682330141327)(教务管理系统.assets/image-20230424165903313.png)]

package service

import (
   "fmt"
   "github.com/gin-gonic/gin"
   "log"
   "main/define"
   "main/models"
   "net/http"
   "strconv"
)

// CourseDetail
// @Tags 课程
// @Summary 课程详细
// @Param int query int true "id"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /course/detail [get]
func CourseDetail(c *gin.Context) {
   ID := c.Query("id")
   data := new(models.Course)
   err := models.DB.First(data, ID).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("ID not found:" + err.Error()),
      })
      return
   }
   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "data": data,
   })
}

// CourseCreate
// @Tags 课程
// @Summary 课程创建
// @Param name formData string true "name"
// @Param hour formData int true "hour"
// @Param credit formData int true "credit"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /course/create [post]
func CourseCreate(c *gin.Context) {
   var Coursedata models.Course
   err := c.ShouldBind(&Coursedata)
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("binding failed:" + err.Error()),
      })
      return
   }
   err = models.DB.Create(&Coursedata).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("Course create error:" + err.Error()),
      })
      return
   }
   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "data": "课程创建成功",
   })
}

// CourseModify
// @Tags 课程
// @Summary 课程修改
// @Param id query int true "id"
// @Param name formData string true "name"
// @Param hour formData int true "hour"
// @Param credit formData int true "credit"
// @Param prerequisite_id formData string false "prerequisite_id"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /course/update [put]
func CourseModify(c *gin.Context) {
   var Coursedata models.Course
   ID := c.Query("id")
   err := c.ShouldBind(&Coursedata)
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("binding failed:" + err.Error()),
      })
      return
   }

   beforedata := new(models.Course)
   err = models.DB.First(beforedata, ID).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("ID not found:" + err.Error()),
      })
      return
   }

   models.DB.Model(beforedata).Updates(&Coursedata)
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("Course update error:" + err.Error()),
      })
      return
   }

   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "msg":  "修改成功",
   })
}

// CourseDelete
// @Tags 课程
// @Summary 课程删除
// @Param id query int true "id"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /course/delete [delete]
func CourseDelete(c *gin.Context) {
   ID := c.Query("id")
   data := new(models.Course)
   err := models.DB.First(data, ID).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("ID not found:" + err.Error()),
      })
      return
   }

   err = models.DB.Delete(data).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("Course delete error:" + err.Error()),
      })
      return
   }

   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "msg":  "删除成功",
   })
}

// GetCourseList
// @Tags 课程
// @Summary 课程列表
// @Param page query int false "page"
// @Param size query int false "size"
// @Param keyword query string false "keyword"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /course/list [get]
func GetCourseList(c *gin.Context) {

   size, _ := strconv.Atoi(c.DefaultQuery("size", define.DefaultSize))
   page, err := strconv.Atoi(c.DefaultQuery("page", define.DefaultPage))

   if err != nil {
      log.Println("GetCourseList Page strconv Error:", err)
      return
   }
   page = (page - 1) * size
   keyword := c.Query("keyword")
   var count int64
   var list = make([]models.Course, 0)

   err = models.DB.Model(new(models.Course)).Preload("Course_selections").Count(&count).Offset(page).Limit(size).
      Where("name like ? ", "%"+keyword+"%").
      Find(&list).Error

   if err != nil {
      log.Println("Get Course List Error", err)
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  "Get Course List Error" + err.Error(),
      })
      return
   }

   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "data": map[string]interface{}{
         "list":  list,
         "count": count,
      },
   })
}

课程选择

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SDTaxBwI-1682330141328)(教务管理系统.assets/image-20230424165922429.png)]

package service

import (
   "fmt"
   "github.com/gin-gonic/gin"
   "log"
   "main/define"
   "main/models"
   "net/http"
   "strconv"
)

// Course_selectionDetail
// @Tags 课程选择
// @Summary 课程选择详细
// @Param int query int true "id"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /course_selection/detail [get]
func Course_selectionDetail(c *gin.Context) {
   ID := c.Query("id")
   data := new(models.Course_selection)
   err := models.DB.First(data, ID).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("ID not found:" + err.Error()),
      })
      return
   }
   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "data": data,
   })
}

// Course_selectionCreate
// @Tags 课程选择
// @Summary 课程选择创建
// @Param position formData string true "position"
// @Param time formData string true "time"
// @Param class_id formData int true "class_id"
// @Param course_id formData int true "course_id"
// @Param teacher_id formData int true "teacher_id"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /course_selection/create [post]
func Course_selectionCreate(c *gin.Context) {
   var Course_selectiondata models.Course_selection
   err := c.ShouldBind(&Course_selectiondata)
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("binding failed:" + err.Error()),
      })
      return
   }
   err = models.DB.Create(&Course_selectiondata).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("Course_selection create error:" + err.Error()),
      })
      return
   }
   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "data": "课程选择创建成功",
   })
}

// Course_selectionModify
// @Tags 课程选择
// @Summary 课程选择修改
// @Param id query int true "id"
// @Param position formData string false "position"
// @Param time formData string false "time"
// @Param class_id formData int false "class_id"
// @Param course_id formData int false "course_id"
// @Param teacher_id formData int false "teacher_id"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /course_selection/update [put]
func Course_selectionModify(c *gin.Context) {
   var Course_selectiondata models.Course_selection
   ID := c.Query("id")
   err := c.ShouldBind(&Course_selectiondata)
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("binding failed:" + err.Error()),
      })
      return
   }

   beforedata := new(models.Course_selection)
   err = models.DB.First(beforedata, ID).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("ID not found:" + err.Error()),
      })
      return
   }

   models.DB.Model(beforedata).Updates(&Course_selectiondata)
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("Course_selection update error:" + err.Error()),
      })
      return
   }

   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "msg":  "修改成功",
   })
}

// Course_selectionDelete
// @Tags 课程选择
// @Summary 课程选择删除
// @Param id query int true "id"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /course_selection/delete [delete]
func Course_selectionDelete(c *gin.Context) {
   ID := c.Query("id")
   data := new(models.Course_selection)
   err := models.DB.First(data, ID).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("ID not found:" + err.Error()),
      })
      return
   }

   err = models.DB.Delete(data).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("Course_selection delete error:" + err.Error()),
      })
      return
   }

   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "msg":  "删除成功",
   })
}

// GetCourse_selectionList
// @Tags 课程选择
// @Summary 课程选择列表
// @Param page query int false "page"
// @Param size query int false "size"
// @Param keyword query string false "keyword"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /course_selection/list [get]
func GetCourse_selectionList(c *gin.Context) {

   size, _ := strconv.Atoi(c.DefaultQuery("size", define.DefaultSize))
   page, err := strconv.Atoi(c.DefaultQuery("page", define.DefaultPage))

   if err != nil {
      log.Println("GetCourse_selectionList Page strconv Error:", err)
      return
   }
   page = (page - 1) * size
   keyword := c.Query("keyword")
   var count int64
   var list = make([]models.Course_selection, 0)

   err = models.DB.Model(new(models.Course_selection)).Preload("Exam").Preload("Grades").Count(&count).Offset(page).Limit(size).
      Where("Time like ? OR Positon like ?", "%"+keyword+"%", "%"+keyword+"%").
      Find(&list).Error

   if err != nil {
      log.Println("Get Course_selection List Error", err)
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  "Get Course_selection List Error" + err.Error(),
      })
      return
   }

   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "data": map[string]interface{}{
         "list":  list,
         "count": count,
      },
   })
}

部门

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0oyC4iUu-1682330141328)(教务管理系统.assets/image-20230424165945578.png)]

package service

import (
   "fmt"
   "github.com/gin-gonic/gin"
   "log"
   "main/define"
   "main/models"
   "net/http"
   "strconv"
)

// DepartmentCreate
// @Tags 部门
// @Summary 部门创建
// @Param name formData string true "name"
// @Param location formData string true "location"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /department/create [post]
func DepartmentCreate(c *gin.Context) {
   var departmentdata models.Department
   err := c.ShouldBind(&departmentdata)
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("binding failed:" + err.Error()),
      })
      return
   }
   err = models.DB.Create(&departmentdata).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("department create error:" + err.Error()),
      })
      return
   }
   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "data": "部门创建成功",
   })
}

// DepartmentModify
// @Tags 部门
// @Summary 部门修改
// @Param id query int true "id"
// @Param name formData string false "name"
// @Param location formData string false "location"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /department/update [put]
func DepartmentModify(c *gin.Context) {
   var departmentdata models.Department
   ID := c.Query("id")
   err := c.ShouldBind(&departmentdata)
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("binding failed:" + err.Error()),
      })
      return
   }

   beforedata := new(models.Department)
   err = models.DB.First(beforedata, ID).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("ID not found:" + err.Error()),
      })
      return
   }

   models.DB.Model(beforedata).Updates(&departmentdata)
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("department update error:" + err.Error()),
      })
      return
   }

   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "msg":  "修改成功",
   })
}

// DepartmentDelete
// @Tags 部门
// @Summary 部门删除
// @Param id query int true "id"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /department/delete [delete]
func DepartmentDelete(c *gin.Context) {
   ID := c.Query("id")
   data := new(models.Department)
   err := models.DB.First(data, ID).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("ID not found:" + err.Error()),
      })
      return
   }

   err = models.DB.Delete(data).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("department delete error:" + err.Error()),
      })
      return
   }

   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "msg":  "删除成功",
   })
}

// GetDepartmentList
// @Tags 部门
// @Summary 部门列表
// @Param page query int false "page"
// @Param size query int false "size"
// @Param keyword query string false "keyword"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /department/list [get]
func GetDepartmentList(c *gin.Context) {

   size, _ := strconv.Atoi(c.DefaultQuery("size", define.DefaultSize))
   page, err := strconv.Atoi(c.DefaultQuery("page", define.DefaultPage))

   if err != nil {
      log.Println("GetDepartmentList Page strconv Error:", err)
      return
   }
   page = (page - 1) * size
   keyword := c.Query("keyword")
   var count int64
   var list = make([]models.Department, 0)

   err = models.DB.Model(new(models.Department)).Preload("Professionals").Preload("Teachers").Count(&count).Offset(page).Limit(size).
      Where("name like ? OR location like ?", "%"+keyword+"%", "%"+keyword+"%").
      Find(&list).Error

   if err != nil {
      log.Println("Get Department List Error", err)
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  "Get Department List Error" + err.Error(),
      })
      return
   }

   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "data": map[string]interface{}{
         "list":  list,
         "count": count,
      },
   })
}

考试安排

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-x96PCFiY-1682330141328)(教务管理系统.assets/image-20230424170007930.png)]

package service

import (
   "fmt"
   "github.com/gin-gonic/gin"
   "main/models"
   "net/http"
)

// ExamDetail
// @Tags 考试安排
// @Summary 考试安排详细
// @Param int query int true "id"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /exam/detail [get]
func ExamDetail(c *gin.Context) {
   ID := c.Query("id")
   data := new(models.Exam)
   err := models.DB.First(data, ID).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("ID not found:" + err.Error()),
      })
      return
   }
   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "data": data,
   })
}

// ExamCreate
// @Tags 考试安排
// @Summary 考试安排创建
// @Param exam_data formData string true "exam_data"
// @Param start_time formData string true "start_time"
// @Param end_time formData string true "end_time"
// @Param position formData string true "position"
// @Param course_selection_id formData string true "course_selection_id"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /exam/create [post]
func ExamCreate(c *gin.Context) {
   var Examdata models.Exam
   err := c.ShouldBind(&Examdata)
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("binding failed:" + err.Error()),
      })
      return
   }
   err = models.DB.Create(&Examdata).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("Exam create error:" + err.Error()),
      })
      return
   }
   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "data": "考试安排创建成功",
   })
}

// ExamModify
// @Tags 考试安排
// @Summary 考试安排修改
// @Param id query int true "id"
// @Param exam_data formData string false "exam_data"
// @Param start_time formData string false "start_time"
// @Param end_time formData string false "end_time"
// @Param position formData string false "position"
// @Param course_selection_id formData string false "course_selection_id"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /exam/update [put]
func ExamModify(c *gin.Context) {
   var Examdata models.Exam
   ID := c.Query("id")
   err := c.ShouldBind(&Examdata)
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("binding failed:" + err.Error()),
      })
      return
   }

   beforedata := new(models.Exam)
   err = models.DB.First(beforedata, ID).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("ID not found:" + err.Error()),
      })
      return
   }

   models.DB.Model(beforedata).Updates(&Examdata)
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("Exam update error:" + err.Error()),
      })
      return
   }

   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "msg":  "修改成功",
   })
}

// ExamDelete
// @Tags 考试安排
// @Summary 考试安排删除
// @Param id query int true "id"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /exam/delete [delete]
func ExamDelete(c *gin.Context) {
   ID := c.Query("id")
   data := new(models.Exam)
   err := models.DB.First(data, ID).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("ID not found:" + err.Error()),
      })
      return
   }

   err = models.DB.Delete(data).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("Exam delete error:" + err.Error()),
      })
      return
   }

   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "msg":  "删除成功",
   })
}

成绩

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-550tlg5N-1682330141329)(教务管理系统.assets/image-20230424170019103.png)]

package service

import (
   "fmt"
   "github.com/gin-gonic/gin"
   "main/models"
   "net/http"
)

// GradeDetail
// @Tags 成绩
// @Summary 成绩详细
// @Param int query int true "id"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /grade/detail [get]
func GradeDetail(c *gin.Context) {
   ID := c.Query("id")
   data := new(models.Grade)
   err := models.DB.First(data, ID).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("ID not found:" + err.Error()),
      })
      return
   }
   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "data": data,
   })
}

// GradeCreate
// @Tags 成绩
// @Summary 成绩创建
// @Param score formData string true "score"
// @Param student_id formData string true "student_id"
// @Param course_id formData string true "course_id"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /grade/create [post]
func GradeCreate(c *gin.Context) {
   var Gradedata models.Grade
   err := c.ShouldBind(&Gradedata)
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("binding failed:" + err.Error()),
      })
      return
   }
   err = models.DB.Create(&Gradedata).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("Grade create error:" + err.Error()),
      })
      return
   }
   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "data": "成绩创建成功",
   })
}

// GradeModify
// @Tags 成绩
// @Summary 成绩修改
// @Param id query int true "id"
// @Param score formData string false "score"
// @Param student_id formData string false "student_id"
// @Param course_id formData string false "course_id"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /grade/update [put]
func GradeModify(c *gin.Context) {
   var Gradedata models.Grade
   ID := c.Query("id")
   err := c.ShouldBind(&Gradedata)
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("binding failed:" + err.Error()),
      })
      return
   }

   beforedata := new(models.Grade)
   err = models.DB.First(beforedata, ID).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("ID not found:" + err.Error()),
      })
      return
   }

   models.DB.Model(beforedata).Updates(&Gradedata)
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("Grade update error:" + err.Error()),
      })
      return
   }

   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "msg":  "修改成功",
   })
}

// GradeDelete
// @Tags 成绩
// @Summary 成绩删除
// @Param id query int true "id"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /grade/delete [delete]
func GradeDelete(c *gin.Context) {
   ID := c.Query("id")
   data := new(models.Grade)
   err := models.DB.First(data, ID).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("ID not found:" + err.Error()),
      })
      return
   }

   err = models.DB.Delete(data).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("Grade delete error:" + err.Error()),
      })
      return
   }

   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "msg":  "删除成功",
   })
}

专业

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GqbGeaTB-1682330141329)(教务管理系统.assets/image-20230424170058687.png)]

package service

import (
   "fmt"
   "github.com/gin-gonic/gin"
   "log"
   "main/define"
   "main/models"
   "net/http"
   "strconv"
)

// ProfessionalDetail
// @Tags 专业
// @Summary 专业详细
// @Param int query int true "id"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /professional/detail [get]
func ProfessionalDetail(c *gin.Context) {
   ID := c.Query("id")
   data := new(models.Professional)
   err := models.DB.First(data, ID).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("ID not found:" + err.Error()),
      })
      return
   }
   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "data": data,
   })
}

// ProfessionalCreate
// @Tags 专业
// @Summary 专业创建
// @Param name formData string true "name"
// @Param department_id formData int false "department_id"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /professional/create [post]
func ProfessionalCreate(c *gin.Context) {
   var professionaldata models.Professional
   err := c.ShouldBind(&professionaldata)
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("binding failed:" + err.Error()),
      })
      return
   }
   err = models.DB.Create(&professionaldata).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("professional create error:" + err.Error()),
      })
      return
   }
   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "data": "专业创建成功",
   })
}

// ProfessionalModify
// @Tags 专业
// @Summary 专业修改
// @Param id query int true "id"
// @Param name formData string false "name"
// @Param department_id formData int false "department_id"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /professional/update [put]
func ProfessionalModify(c *gin.Context) {
   var professionaldata models.Professional
   ID := c.Query("id")
   err := c.ShouldBind(&professionaldata)
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("binding failed:" + err.Error()),
      })
      return
   }

   beforedata := new(models.Professional)
   err = models.DB.First(beforedata, ID).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("ID not found:" + err.Error()),
      })
      return
   }

   models.DB.Model(beforedata).Updates(&professionaldata)
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("professional update error:" + err.Error()),
      })
      return
   }

   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "msg":  "修改成功",
   })
}

// ProfessionalDelete
// @Tags 专业
// @Summary 专业删除
// @Param id query int true "id"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /professional/delete [delete]
func ProfessionalDelete(c *gin.Context) {
   ID := c.Query("id")
   data := new(models.Professional)
   err := models.DB.First(data, ID).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("ID not found:" + err.Error()),
      })
      return
   }

   err = models.DB.Delete(data).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("Professional delete error:" + err.Error()),
      })
      return
   }

   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "msg":  "删除成功",
   })
}

// GetProfessionalList
// @Tags 专业
// @Summary 专业列表
// @Param page query int false "page"
// @Param size query int false "size"
// @Param keyword query string false "keyword"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /professional/list [get]
func GetProfessionalList(c *gin.Context) {
   size, _ := strconv.Atoi(c.DefaultQuery("size", define.DefaultSize))
   page, err := strconv.Atoi(c.DefaultQuery("page", define.DefaultPage))

   if err != nil {
      log.Println("GetProfessionalList Page strconv Error:", err)
      return
   }
   page = (page - 1) * size
   keyword := c.Query("keyword")
   var count int64
   var list = make([]models.Professional, 0)

   err = models.DB.Model(new(models.Professional)).Preload("Students").
      Count(&count).Offset(page).Limit(size).
      Where("name like ?", "%"+keyword+"%").Find(&list).Error

   if err != nil {
      log.Println("Get Professional List Error", err)
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  "Get Professional List Error" + err.Error(),
      })
      return
   }

   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "data": map[string]interface{}{
         "list":  list,
         "count": count,
      },
   })
}

学生

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JGGu8N3N-1682330141329)(教务管理系统.assets/image-20230424170134698.png)]

package service

import (
   "fmt"
   "github.com/gin-gonic/gin"
   "log"
   "main/define"
   "main/models"
   "net/http"
   "strconv"
)

// StudentDetail
// @Tags 学生
// @Summary 学生详细
// @Param int query int true "id"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /student/detail [get]
func StudentDetail(c *gin.Context) {
   ID := c.Query("id")
   data := new(models.Student)
   err := models.DB.First(data, ID).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("ID not found:" + err.Error()),
      })
      return
   }
   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "data": data,
   })
}

// StudentCreate
// @Tags 学生
// @Summary 学生创建
// @Param name formData string true "name"
// @Param age formData int true "age"
// @Param gender formData int true "gender"
// @Param class_id formData int true "class_id"
// @Param professional_id formData int true "professional_id"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /student/create [post]
func StudentCreate(c *gin.Context) {
   var Studentdata models.Student
   err := c.ShouldBind(&Studentdata)
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("binding failed:" + err.Error()),
      })
      return
   }
   err = models.DB.Create(&Studentdata).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("Student create error:" + err.Error()),
      })
      return
   }
   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "data": "学生创建成功",
   })
}

// StudentModify
// @Tags 学生
// @Summary 学生修改
// @Param id query int true "id"
// @Param name formData string false "name"
// @Param age formData int false "age"
// @Param gender formData int false "gender"
// @Param class_id formData int false "class_id"
// @Param professional_id formData int false "professional_id"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /student/update [put]
func StudentModify(c *gin.Context) {
   var Studentdata models.Student
   ID := c.Query("id")
   err := c.ShouldBind(&Studentdata)
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("binding failed:" + err.Error()),
      })
      return
   }

   beforedata := new(models.Student)
   err = models.DB.First(beforedata, ID).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("ID not found:" + err.Error()),
      })
      return
   }

   models.DB.Model(beforedata).Updates(&Studentdata)
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("Student update error:" + err.Error()),
      })
      return
   }

   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "msg":  "修改成功",
   })
}

// StudentDelete
// @Tags 学生
// @Summary 学生删除
// @Param id query int true "id"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /student/delete [delete]
func StudentDelete(c *gin.Context) {
   ID := c.Query("id")
   data := new(models.Student)
   err := models.DB.First(data, ID).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("ID not found:" + err.Error()),
      })
      return
   }

   err = models.DB.Delete(data).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("Student delete error:" + err.Error()),
      })
      return
   }

   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "msg":  "删除成功",
   })
}

// GetStudentList
// @Tags 学生
// @Summary 学生列表
// @Param page query int false "page"
// @Param size query int false "size"
// @Param keyword query string false "keyword"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /student/list [get]
func GetStudentList(c *gin.Context) {
   size, _ := strconv.Atoi(c.DefaultQuery("size", define.DefaultSize))
   page, err := strconv.Atoi(c.DefaultQuery("page", define.DefaultPage))
   if err != nil {
      log.Println("GetStudentList Page strconv Error:", err)
      return
   }
   page = (page - 1) * size
   keyword := c.Query("keyword")
   var count int64
   var list = make([]models.Student, 0)

   err = models.DB.Model(new(models.Student)).Preload("Grades").Count(&count).Offset(page).Limit(size).
      Where("name like ?", "%"+keyword+"%").Find(&list).Error

   if err != nil {
      log.Println("Get Student List Error", err)
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  "Get Student List Error" + err.Error(),
      })
      return
   }

   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "data": map[string]interface{}{
         "list":  list,
         "count": count,
      },
   })
}

教师

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xn7vGyk9-1682330141330)(教务管理系统.assets/image-20230424170154975.png)]

package service

import (
   "fmt"
   "github.com/gin-gonic/gin"
   "log"
   "main/define"
   "main/models"
   "net/http"
   "strconv"
)

// TeacherDetail
// @Tags 教师
// @Summary 教师详细
// @Param int query int true "id"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /teacher/detail [get]
func TeacherDetail(c *gin.Context) {
   ID := c.Query("id")
   data := new(models.Teacher)
   err := models.DB.First(data, ID).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("ID not found:" + err.Error()),
      })
      return
   }
   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "data": data,
   })
}

// TeacherCreate
// @Tags 教师
// @Summary 教师创建
// @Param name formData string true "name"
// @Param age formData int true "age"
// @Param education formData string true "education"
// @Param title formData string true "title"
// @Param gender formData int true "gender"
// @Param department_id formData int false "department_id"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /teacher/create [post]
func TeacherCreate(c *gin.Context) {
   var teacherdata models.Teacher
   err := c.ShouldBind(&teacherdata)
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("binding failed:" + err.Error()),
      })
      return
   }
   err = models.DB.Create(&teacherdata).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("teacher create error:" + err.Error()),
      })
      return
   }
   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "data": "教师创建成功",
   })
}

// TeacherModify
// @Tags 教师
// @Summary 教师修改
// @Param id query int true "id"
// @Param name formData string false "name"
// @Param age formData int false "age"
// @Param education formData string false "education"
// @Param title formData string false "title"
// @Param gender formData int false "gender"
// @Param department_id formData int false "department_id"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /teacher/update [put]
func TeacherModify(c *gin.Context) {
   var teacherdata models.Teacher
   ID := c.Query("id")
   err := c.ShouldBind(&teacherdata)
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("binding failed:" + err.Error()),
      })
      return
   }

   beforedata := new(models.Teacher)
   err = models.DB.First(beforedata, ID).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("ID not found:" + err.Error()),
      })
      return
   }

   models.DB.Model(beforedata).Updates(&teacherdata)
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("teacher update error:" + err.Error()),
      })
      return
   }

   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "msg":  "修改成功",
   })
}

// TeacherDelete
// @Tags 教师
// @Summary 教师删除
// @Param id query int true "id"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /teacher/delete [delete]
func TeacherDelete(c *gin.Context) {
   ID := c.Query("id")
   data := new(models.Teacher)
   err := models.DB.First(data, ID).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("ID not found:" + err.Error()),
      })
      return
   }

   err = models.DB.Delete(data).Error
   if err != nil {
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  fmt.Sprintf("teacher delete error:" + err.Error()),
      })
      return
   }

   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "msg":  "删除成功",
   })
}

// GetTeacherList
// @Tags 教师
// @Summary 教师列表
// @Param page query int false "page"
// @Param size query int false "size"
// @Param keyword query string false "keyword"
// @Success 200 {string} json "{"code":"200","data":""}"
// @Router /teacher/list [get]
func GetTeacherList(c *gin.Context) {
   size, _ := strconv.Atoi(c.DefaultQuery("size", define.DefaultSize))
   page, err := strconv.Atoi(c.DefaultQuery("page", define.DefaultPage))

   if err != nil {
      log.Println("GetTeacherList Page strconv Error:", err)
      return
   }
   page = (page - 1) * size
   keyword := c.Query("keyword")
   var count int64
   var list = make([]models.Teacher, 0)

   err = models.DB.Model(new(models.Teacher)).Preload("Course_selections").Count(&count).Offset(page).Limit(size).
      Where("name like ? ", "%"+keyword+"%").
      Find(&list).Error

   if err != nil {
      log.Println("Get Teacher List Error", err)
      c.JSON(http.StatusOK, gin.H{
         "code": -1,
         "msg":  "Get Teacher List Error" + err.Error(),
      })
      return
   }

   c.JSON(http.StatusOK, gin.H{
      "code": 200,
      "data": map[string]interface{}{
         "list":  list,
         "count": count,
      },
   })
}

注册路由

最后在router路径下的app.go中

package router

import (
   "github.com/gin-gonic/gin"
   "main/service"
)

func Router() *gin.Engine {
   router := gin.Default()

   department := router.Group("/department")
   {
      department.POST("/create", service.DepartmentCreate)
      department.PUT("/update", service.DepartmentModify)
      department.DELETE("/delete", service.DepartmentDelete)
      department.GET("/list", service.GetDepartmentList)
   }
   teacher := router.Group("/teacher")
   {
      teacher.GET("/detail", service.TeacherDetail)
      teacher.POST("/create", service.TeacherCreate)
      teacher.PUT("/update", service.TeacherModify)
      teacher.DELETE("/delete", service.TeacherDelete)
      teacher.GET("/list", service.GetTeacherList)
   }
   professional := router.Group("/professional")
   {
      professional.GET("/detail", service.ProfessionalDetail)
      professional.POST("/create", service.ProfessionalCreate)
      professional.PUT("/update", service.ProfessionalModify)
      professional.DELETE("/delete", service.ProfessionalDelete)
      professional.GET("/list", service.GetProfessionalList)
   }
   class := router.Group("/class")
   {
      class.GET("/detail", service.ClassDetail)
      class.POST("/create", service.ClassCreate)
      class.PUT("/update", service.ClassModify)
      class.DELETE("/delete", service.ClassDelete)
      class.GET("/list", service.GetClassList)
   }

   student := router.Group("/student")
   {
      student.GET("/detail", service.StudentDetail)
      student.POST("/create", service.StudentCreate)
      student.PUT("/update", service.StudentModify)
      student.DELETE("/delete", service.StudentDelete)
      student.GET("/list", service.GetStudentList)
   }

   course := router.Group("/course")
   {
      course.GET("/detail", service.CourseDetail)
      course.POST("/create", service.CourseCreate)
      course.PUT("/update", service.CourseModify)
      course.DELETE("/delete", service.CourseDelete)
      course.GET("/list", service.GetCourseList)
   }

   course_selection := router.Group("/course_selection")
   {
      course_selection.GET("/detail", service.Course_selectionDetail)
      course_selection.POST("/create", service.Course_selectionCreate)
      course_selection.PUT("/update", service.Course_selectionModify)
      course_selection.DELETE("/delete", service.Course_selectionDelete)
      course_selection.GET("/list", service.GetCourse_selectionList)
   }

   exam := router.Group("/exam")
   {
      exam.GET("/detail", service.ExamDetail)
      exam.POST("/create", service.ExamCreate)
      exam.PUT("/update", service.ExamModify)
      exam.DELETE("/delete", service.ExamDelete)
   }

   grade := router.Group("/grade")
   {
      grade.GET("/detail", service.GradeDetail)
      grade.POST("/create", service.GradeCreate)
      grade.PUT("/update", service.GradeModify)
      grade.DELETE("/delete", service.GradeDelete)
   }
   return router
}
  professional.GET("/detail", service.ProfessionalDetail)
      professional.POST("/create", service.ProfessionalCreate)
      professional.PUT("/update", service.ProfessionalModify)
      professional.DELETE("/delete", service.ProfessionalDelete)
      professional.GET("/list", service.GetProfessionalList)
   }
   class := router.Group("/class")
   {
      class.GET("/detail", service.ClassDetail)
      class.POST("/create", service.ClassCreate)
      class.PUT("/update", service.ClassModify)
      class.DELETE("/delete", service.ClassDelete)
      class.GET("/list", service.GetClassList)
   }

   student := router.Group("/student")
   {
      student.GET("/detail", service.StudentDetail)
      student.POST("/create", service.StudentCreate)
      student.PUT("/update", service.StudentModify)
      student.DELETE("/delete", service.StudentDelete)
      student.GET("/list", service.GetStudentList)
   }

   course := router.Group("/course")
   {
      course.GET("/detail", service.CourseDetail)
      course.POST("/create", service.CourseCreate)
      course.PUT("/update", service.CourseModify)
      course.DELETE("/delete", service.CourseDelete)
      course.GET("/list", service.GetCourseList)
   }

   course_selection := router.Group("/course_selection")
   {
      course_selection.GET("/detail", service.Course_selectionDetail)
      course_selection.POST("/create", service.Course_selectionCreate)
      course_selection.PUT("/update", service.Course_selectionModify)
      course_selection.DELETE("/delete", service.Course_selectionDelete)
      course_selection.GET("/list", service.GetCourse_selectionList)
   }

   exam := router.Group("/exam")
   {
      exam.GET("/detail", service.ExamDetail)
      exam.POST("/create", service.ExamCreate)
      exam.PUT("/update", service.ExamModify)
      exam.DELETE("/delete", service.ExamDelete)
   }

   grade := router.Group("/grade")
   {
      grade.GET("/detail", service.GradeDetail)
      grade.POST("/create", service.GradeCreate)
      grade.PUT("/update", service.GradeModify)
      grade.DELETE("/delete", service.GradeDelete)
   }
   return router
}
长河落日-
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Gin答题系统项目实战
weixin_42063529的博客
12-08 612
实战
Golang实现正方教务系统爬虫(一)
菜鸡
09-17 1672
大二上学期的时候用python实现过一个简单的爬虫,学了go以后发现go的标准库十分强大,于是想实现一个教务系统的爬虫,爬取学分和成绩页面,再搞一个web界面出来. 项目github地址:https://github.com/Nickqiaoo/go-webcrawler爬取分析爬虫无非就是模拟浏览器的HTTP请求,我们首先来看一下浏览器是怎么发请求的.这是教务系统的主页,要想登录首先要获取验证码.验证
【Golang项目实战】用Go写一个学生信息管理系统,真的太酷啦| 保姆级详解，附源码——建议收藏
Yaoyao2024的博客
05-03 2344
功能介绍添加学员信息根据学号(id)编辑学员信息展示所有学员信息退出系统综上，就是一个比较简单的，适合巩固基础的学生信息管理系统的小项目。涉及到函数、结构体、方法、构造函数等基础知识，非常适合小白拿来练手和巩固知识！欢迎在评论区交流和留下你的想法和建议Java岛冒险记【从小白到大佬之路】LeetCode每日一题–进击大厂算法C/C++Go语言核心编程数据结构。
基于Go语言Gin框架Gorm开发的一个小型学生管理系统
weixin_52690231的博客
02-17 556
文章目录代码链接如下 代码链接如下 https://gitee.com/llhgo/studentmanage.git
基于Go语言Gin+Vue+ElementUI的前后端分离后台管理系统
weixin_50196917的博客
03-05 1401
是一款基于Golang、Gin、Xorm、Vue、ElementUI、MySQL等技术栈开发平台框架，拥有完善的(RBAC)权限架构和基础核心管理模块，为了缩短研发周期，系统框架集成了代码生成器，内置平台自定义研发的模板引擎，可以一键CRUD生成整个模块的全部代码，本框架为一站式系统框架开发平台，可以帮助开发者提升开发效率、降低研发成本，同时便于后期的系统维护升级。...
github gitee go开发 热门中后台开源项目
zhaoyang10的专栏
06-22 3791
go 开源中后台管理系统
基于Go + Gin + Gorm + Vue开发的小清单.zip
05-16
基于Go + Gin + Gorm + Vue开发的小清单 基于Go + Gin + Gorm + Vue开发的小清单 基于Go + Gin + Gorm + Vue开发的小清单 基于Go + Gin + Gorm + Vue开发的小清单 ...
基于go+gorm+gin+mysql及layui构建的人力资源管理系统源码.zip
02-20
基于go+gorm+gin+mysql及layui构建的人力资源管理系统源码.zip 基于go、gorm、gin、mysql及layui构建的人力资源管理系统。提供员工管理、考试管理、通知管理、薪资考勤管理、招聘管理、权限管理及分公司分库数据隔离...
gin-web:由gin + gorm + jwt + casbin组合实现的RBAC权限管理脚手架Golang版, 搭建完成即可快速、高效投入业务开发
04-30
Gin Web由gin + gorm + jwt + casbin组合实现的RBAC权限管理脚手架Golang版, 搭建完成即可快速、高效投入业务开发特性RESTful API 设计规范Gin 一款高效的golang web框架MySQL 数据库存储Jwt 用户认证, 登入登出一键...
Gin+Gorm+Redis+ETCD的秒杀系统源码.zip
06-07
这是一个基于Go语言构建的秒杀系统源码，利用了Gin框架、Gorm ORM库、Redis内存数据库以及ETCD作为分布式协调服务。下面将详细解释这些技术及其在秒杀系统中的应用。 **Gin框架** Gin是一个用Go语言编写的高性能web...
基于go+gin+gorm+grpc+socket开发框架.zip
05-24
【标题】：“基于Go+Gin+Gorm+gRPC+Socket开发框架”的技术解析 在现代软件开发中，选择合适的技术栈对于构建高效、可扩展的系统至关重要。本篇文章将详细探讨“基于Go+Gin+Gorm+gRPC+Socket”的开发框架，以及这些...
golang后台管理系统Beego+Layui框架搭建教程
weixin_50196917的博客
04-17 3891
一款 Go 语言基于Beego、Layui、MySQL等框架精心打造的一款模块化、高性能、企业级的敏捷开发框架，本着简化开发、提升开发效率的初衷触发，框架自研了一套个性化的组件，实现了可插拔的组件式开发方式：单图上传、多图上传、下拉选择、开关按钮、单选按钮、多选按钮、图片裁剪等等一系列个性化、轻量级的组件，是一款真正意义上实现组件化开发的敏捷开发框架。...
基于gin+vue搭建的后台管理系统框架
码蝗的博客
05-29 3669
前端UI框架：element-ui 后台框架：gin 1. 基本介绍 Gin-vue-admin是一个基于vue和gin开发的全栈前后端分离的后台管理系统，集成jwt鉴权，动态路由，动态菜单，casbin鉴权，表单生成器，代码生成器等功能，提供多种示例文件，让您把更多时间专注在业务开发上。 Gin-vue-admin 是一套为后台管理平台准备的一整套前后端分离架构式的开源框架，旨在快速搭建后台管理系统。 Gin-vue-admin 的成长离不开大家的支持，如果你愿意为 gin-vue-admin
基于Go语言Gin+Vue+ElementUI的前后端分离敏捷开发框架
weixin_50196917的博客
03-05 1830
是一款基于Golang、Gin、Xorm、Vue、ElementUI、MySQL等技术栈开发平台框架，拥有完善的(RBAC)权限架构和基础核心管理模块，为了缩短研发周期，系统框架集成了代码生成器，内置平台自定义研发的模板引擎，可以一键CRUD生成整个模块的全部代码，本框架为一站式系统框架开发平台，可以帮助开发者提升开发效率、降低研发成本，同时便于后期的系统维护升级。......
[沫忘录]Golang基础类型与语法
最新发布
m0_73027268的博客
07-18 268
golang基础
Go 语言返回组装数据
qq_51110402的博客
07-14 265
【代码】Go 语言返回组装数据。
golang小案例获取命令行的的参数并求得最大值
preserveXing的博客
07-15 220
这个案例是Golang理解os.Args的案例 场景就是: 当我们打包后 生成的.exe文件 执行exe肯定会出现哪些命令 例如 npm install app 这里的npm 就是npm .exe install app 就是我们要获取的参数 我们的案例: 编写go程序---->打包成exe--->执行exe--->添加命令行参数 一些数值---->求得最大化数值
解决 go 引用私有包，安装失败
Dreamy_LIN的博客
07-17 203
go mod tidy 或者 go run main.go 时，提示失败，例如 no such host（设置GOPRIVATE）或者 x509: certificate signed by unknown authority 之类的报错（设置GOINSECURE）
Go: IM系统技术架构梳理 (2)
Wang的专栏
07-15 1071
整个IM系统的一般架构如下我们这张图展示了整个IM系统的一般架构可见分为四层那最上面这一层是前端，包括哪些东西呢？它包括两部分，第一部分是跟用户直接交互的比如说各种IOS APP, 各种安卓 APP还有各种 web APP 在浏览器里面打开的以及windows上面跑的那种客户端第二部分是跟我们程序相关的SDK，API，Websocket这些我们都统称为前端第二个是接入层，这里展示了几种常用的接入协议实际上还会用到Mqtt, Xmpp 等各种协议这是接入层。
用go+gin+gorm开发项目的文件夹目录结构是什么样子
04-21
通常，用go gin gorm开发的项目的文件夹目录结构如下： - main.go：应用程序的入口点 - config：应用程序的配置文件 - controllers：处理HTTP请求的控制器 - models：数据库模型，即数据库表的映射 - repositories...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值