package controllers

import (
	"exhibitionCentre/base"
	"exhibitionCentre/config"
	"exhibitionCentre/logging"
	"exhibitionCentre/models"
	"exhibitionCentre/utils"
	"text/template"
	"time"
)

// 创建展览消息
type CreateExhibitionRequest struct {
	Style          int    `json:"style"`
	Title          string `json:"title"`
	Subtitle       string `json:"subtitle"`
	StartTime      string `json:"start_time"`
	EndTime        string `json:"end_time"`
	Cover          string `json:"cover"`
	FineWork       bool   `json:"fine_work"`
	Master         bool   `json:"master"`
	Classification int    `json:"classification"`
}

type EditExhibitionRequest struct {
	ID int `json:"id"` // 展览id
}

// 更新展览配置消息
type UpdateExhibitionRequest struct {
	ID             int    `json:"id"`
	Style          int    `json:"style"`
	Title          string `json:"title"`
	Subtitle       string `json:"subtitle"`
	StartTime      string `json:"start_time"`
	EndTime        string `json:"end_time"`
	Cover          string `json:"cover"`
	FineWork       bool   `json:"fine_work"`
	Master         bool   `json:"master"`
	Classification int    `json:"classification"`
}

// 删除展览消息
type DeleteExhibitionRequest struct {
	ID int `json:"id"`
}

// 发布/取消发布展览请求消息
type PublishExhibitionRequest struct {
	ID int `json:"id"` // 展览id
}

// 场馆使用/取消使用请求消息
type VenueUseRequest struct {
	ID    int `json:"id"`    // 展览id
	Style int `json:"style"` // 展览场馆风格
}

// 编辑场馆请求消息
type EditVenueRequest struct {
	ID        int `json:"id"`         // 展览id
	RoomIndex int `json:"room_index"` // 场馆编号 1为开幕式，2为展厅，3为演播厅
}
type EditVenueResponse struct {
	NumberOfPosition int              `json:"number_of_position"` // 展位总数
	Exhibits         []models.Exhibit `json:"exhibits"`           // 现有展品
}

// 获取访问统计消息
type GetVisitStatisticsRequest struct {
	ID int `json:"id"` // 展览id
}
type GetVisitStatisticsResponse struct {
	ID              int                     `json:"id"`               // 展览id
	Count           int                     `json:"count"`            // 访问总数
	VisitStatistics []models.VisitStatistic `json:"visit_statistics"` // 每天访问统计
}

// 获取具有订单的展品消息
type GetExhibitsWithOrdersRequest struct {
	ID int `json:"id"` // 展览id
}
type GetExhibitsWithOrdersResponse struct {
	ID       int              `json:"id"`       // 展览id
	Exhibits []models.Exhibit `json:"exhibits"` // 展品
}

// 获取展品订单消息
type GetExhibitOrdersRequest struct {
	ID int `json:"id"` // 展品id
}
type GetExhibitOrdersResponse struct {
	ID     int            `json:"id"`     // 展品id
	Orders []models.Order `json:"orders"` // 订单列表
}

func CreateExhibition(router *base.Router) (int, []byte) {
	// 鉴权
	_, authorized := Authenticate(router)
	if !authorized {
		logging.Log.Error("创建展览鉴权失败")
		return 0, nil
	}

	// 检查是否包含创建信息
	if router.Data != nil && len(router.Data) > 0 {
		return createExhibitionInternal(router)
	}

	// 加载创建展览
	page, err := template.ParseFiles("./view/html/create_exhibition.html")
	if err != nil {
		logging.Log.Error("加载创建展览页面失败: ", err.Error())
		return 404, utils.SerializeErrorData("")
	}
	page.Execute(router.Writer, nil)
	return 200, nil
}

func EditExhibition(router *base.Router) (int, []byte) {
	// 鉴权
	user, authorized := Authenticate(router)
	if !authorized {
		logging.Log.Error("创建展览鉴权失败")
		return 0, nil
	}

	// 解析request数据
	var info EditExhibitionRequest
	if err := utils.JsonParse(router.Data, &info); err != nil {
		logging.Log.Error("解析数据失败: ", err.Error())
		return 403, utils.SerializeErrorData("获取展览详情失败!")
	}

	// 获取展览
	exhibition, err := models.GetExhibition(info.ID)
	if err != nil {
		logging.Log.Error("数据库获取展览失败: ", err.Error())
		return 403, utils.SerializeErrorData("获取展览详情失败!")
	}
	if user.UserId != exhibition.UserId && user.Role != int(models.Admin) {
		logging.Log.Errorf("此用户(%v)无权限编辑展览\n", user.Email)
		return 400, utils.SerializeErrorData("编辑展览失败!")
	}
	return 200, utils.Serialize(exhibition)
}

// 更新展览
func UpdateExhibition(router *base.Router) (int, []byte) {
	// 鉴权
	user, authorized := Authenticate(router)
	if !authorized {
		logging.Log.Error("更新展览鉴权失败")
		return 0, nil
	}

	// 解析request数据
	var info UpdateExhibitionRequest
	if err := utils.JsonParse(router.Data, &info); err != nil {
		logging.Log.Error("解析数据失败: ", err.Error())
		return 403, utils.SerializeErrorData("更新展览失败!")
	}
	startTime, _ := time.ParseInLocation("2006-01-02 15:04:05", info.StartTime, time.Local)
	endTime, _ := time.ParseInLocation("2006-01-02 15:04:05", info.EndTime, time.Local)

	// 获取展览
	exhibition, err := models.GetExhibition(info.ID)
	if err != nil {
		logging.Log.Error("数据库获取展览失败: ", err.Error())
		return 403, utils.SerializeErrorData("更新展览失败!")
	}
	if user.UserId != exhibition.UserId && user.Role != int(models.Admin) {
		logging.Log.Errorf("此用户(%v)无权限更新展览\n", user.Email)
		return 400, utils.SerializeErrorData("更新展览失败!")
	}
	oldCover := exhibition.Cover
	exhibition.Title = info.Title
	exhibition.Subtitle = info.Subtitle
	exhibition.StartTime = startTime
	exhibition.EndTime = endTime
	exhibition.Cover = info.Cover
	exhibition.FineWork = info.FineWork
	exhibition.Master = info.Master
	exhibition.Classification = info.Classification
	if err := models.UpdateExhibition(exhibition); err != nil {
		logging.Log.Error("数据库更新展览失败: ", err.Error())
		return 403, utils.SerializeErrorData("更新展览失败!")
	}
	if oldCover != exhibition.Cover && len(oldCover) > 0 {
		utils.DeleteAliOssFile(oldCover)
	}
	return 200, []byte("{}")
}

// 删除展览
func DeleteExhibition(router *base.Router) (int, []byte) {
	// 鉴权
	user, authorized := Authenticate(router)
	if !authorized {
		logging.Log.Error("更新展览鉴权失败")
		return 0, nil
	}

	// 解析request数据
	var info DeleteExhibitionRequest
	if err := utils.JsonParse(router.Data, &info); err != nil {
		logging.Log.Error("解析数据失败: ", err.Error())
		return 403, utils.SerializeErrorData("删除展览失败!")
	}

	// 获取展览
	exhibition, err := models.GetExhibition(info.ID)
	if err != nil {
		logging.Log.Error("数据库获取展览失败: ", err.Error())
		return 403, utils.SerializeErrorData("删除展览失败!")
	}
	if user.UserId != exhibition.UserId && user.Role != int(models.Admin) {
		logging.Log.Errorf("此用户(%v)无权限删除展览\n", user.Email)
		return 400, utils.SerializeErrorData("删除展览失败!")
	}
	// 删除展览
	if err := models.DeleteExhibition(int(exhibition.ID)); err != nil {
		logging.Log.Error("数据库删除展览失败: ", err.Error())
		return 400, utils.SerializeErrorData("删除展览失败!")
	}
	// 获取展览内所有展品
	exhibits, _ := models.GetExhibitsByExhibitionId(int(exhibition.ID))

	// 删除展览内所有展品
	if err := models.DeleteExhibits(exhibits); err != nil {
		logging.Log.Error("数据库删除展览内所有展品失败: ", err.Error())
	}

	// 删除展品资源
	for _, exhibit := range exhibits {
		utils.DeleteAliOssFile(exhibit.Url)
		utils.DeleteAliOssFile(exhibit.Audio)
		deleteDetailResources(exhibit.Details)
	}
	// 删除访问记录
	if err := models.DeleteVisitStatistics(int(exhibition.ID)); err != nil {
		logging.Log.Error("数据库删除展览访问记录失败: ", err.Error())
	}
	return 200, []byte("{}")
}

/****************************** 展览发布操作 ******************************/
// 发布展览
func PublishExhibition(router *base.Router) (int, []byte) {
	// 鉴权
	user, authorized := Authenticate(router)
	if !authorized {
		logging.Log.Error("发布展览鉴权失败")
		return 0, nil
	}

	// 解析request数据
	var info PublishExhibitionRequest
	if err := utils.JsonParse(router.Data, &info); err != nil {
		logging.Log.Error("解析数据失败: ", err.Error())
		return 403, utils.SerializeErrorData("发布展览失败!")
	}

	// 获取展览
	exhibition, err := models.GetExhibition(info.ID)
	if err != nil {
		logging.Log.Error("数据库获取展览失败: ", err.Error())
		return 403, utils.SerializeErrorData("发布展览失败!")
	}
	if user.UserId != exhibition.UserId && user.Role != int(models.Admin) {
		logging.Log.Errorf("此用户(%v)无权限发布展览\n", user.Email)
		return 400, utils.SerializeErrorData("发布展览失败!")
	}
	exhibition.Published = true

	if err := models.UpdateExhibition(exhibition); err != nil {
		logging.Log.Error("数据库发布展览失败: ", err.Error())
		return 403, utils.SerializeErrorData("发布展览失败!")
	}
	return 200, []byte("{}")
}

// 发布展览
func CancelPublishExhibition(router *base.Router) (int, []byte) {
	// 鉴权
	user, authorized := Authenticate(router)
	if !authorized {
		logging.Log.Error("取消发布展览鉴权失败")
		return 0, nil
	}

	// 解析request数据
	var info PublishExhibitionRequest
	if err := utils.JsonParse(router.Data, &info); err != nil {
		logging.Log.Error("解析数据失败: ", err.Error())
		return 403, utils.SerializeErrorData("取消发布展览失败!")
	}

	// 获取展览
	exhibition, err := models.GetExhibition(info.ID)
	if err != nil {
		logging.Log.Error("数据库获取展览失败: ", err.Error())
		return 403, utils.SerializeErrorData("取消发布展览失败!")
	}
	if user.UserId != exhibition.UserId && user.Role != int(models.Admin) {
		logging.Log.Errorf("此用户(%v)无权限取消发布展览\n", user.Email)
		return 400, utils.SerializeErrorData("取消发布展览失败!")
	}
	exhibition.Published = false

	if err := models.UpdateExhibition(exhibition); err != nil {
		logging.Log.Error("数据库取消发布展览失败: ", err.Error())
		return 403, utils.SerializeErrorData("取消发布展览失败!")
	}
	return 200, []byte("{}")
}

/****************************** 场馆使用操作 ******************************/
// 使用“开幕式”
func UseOpeningCeremony(router *base.Router) (int, []byte) {
	// 鉴权
	user, authorized := Authenticate(router)
	if !authorized {
		logging.Log.Error("使用展览开幕式鉴权失败")
		return 0, nil
	}

	// 解析request数据
	var info VenueUseRequest
	if err := utils.JsonParse(router.Data, &info); err != nil {
		logging.Log.Error("解析数据失败: ", err.Error())
		return 403, utils.SerializeErrorData("使用展览开幕式失败!")
	}

	// 获取展览
	exhibition, err := models.GetExhibition(info.ID)
	if err != nil {
		logging.Log.Error("数据库获取展览失败: ", err.Error())
		return 403, utils.SerializeErrorData("使用展览开幕式失败!")
	}
	if user.UserId != exhibition.UserId && user.Role != int(models.Admin) {
		logging.Log.Errorf("此用户(%v)无权限操作‘使用展览开幕式’\n", user.Email)
		return 400, utils.SerializeErrorData("使用展览开幕式失败!")
	}
	exhibition.OpeningCeremonyUsed = true

	if err := models.UpdateExhibition(exhibition); err != nil {
		logging.Log.Error("数据库使用展览开幕式失败: ", err.Error())
		return 403, utils.SerializeErrorData("使用展览开幕式失败!")
	}
	return 200, []byte("{}")
}

// 取消使用“开幕式”
func CancelUseOpeningCeremony(router *base.Router) (int, []byte) {
	// 鉴权
	user, authorized := Authenticate(router)
	if !authorized {
		logging.Log.Error("取消使用展览开幕式鉴权失败")
		return 0, nil
	}

	// 解析request数据
	var info VenueUseRequest
	if err := utils.JsonParse(router.Data, &info); err != nil {
		logging.Log.Error("解析数据失败: ", err.Error())
		return 403, utils.SerializeErrorData("取消使用展览开幕式失败!")
	}

	// 获取展览
	exhibition, err := models.GetExhibition(info.ID)
	if err != nil {
		logging.Log.Error("数据库获取展览失败: ", err.Error())
		return 403, utils.SerializeErrorData("取消使用展览开幕式失败!")
	}
	if user.UserId != exhibition.UserId && user.Role != int(models.Admin) {
		logging.Log.Errorf("此用户(%v)无权限操作‘取消使用展览开幕式’\n", user.Email)
		return 400, utils.SerializeErrorData("取消使用展览开幕式失败!")
	}
	exhibition.OpeningCeremonyUsed = false

	if err := models.UpdateExhibition(exhibition); err != nil {
		logging.Log.Error("数据库取消使用展览开幕式失败: ", err.Error())
		return 403, utils.SerializeErrorData("取消使用展览开幕式失败!")
	}
	return 200, []byte("{}")
}

// 使用“展厅”
func UseExhibitionHall(router *base.Router) (int, []byte) {
	// 鉴权
	user, authorized := Authenticate(router)
	if !authorized {
		logging.Log.Error("使用展览展厅鉴权失败")
		return 0, nil
	}

	// 解析request数据
	var info VenueUseRequest
	if err := utils.JsonParse(router.Data, &info); err != nil {
		logging.Log.Error("解析数据失败: ", err.Error())
		return 403, utils.SerializeErrorData("使用展览展厅失败!")
	}

	// 获取展览
	exhibition, err := models.GetExhibition(info.ID)
	if err != nil {
		logging.Log.Error("数据库获取展览失败: ", err.Error())
		return 403, utils.SerializeErrorData("使用展览展厅失败!")
	}
	if user.UserId != exhibition.UserId && user.Role != int(models.Admin) {
		logging.Log.Errorf("此用户(%v)无权限操作‘使用展览展厅’\n", user.Email)
		return 400, utils.SerializeErrorData("使用展览展厅失败!")
	}
	exhibition.ExhibitionHallUsed = true
	exhibition.StudioUsed = false
	exhibition.Style = info.Style

	if err := models.UpdateExhibition(exhibition); err != nil {
		logging.Log.Error("数据库使用展览展厅失败: ", err.Error())
		return 403, utils.SerializeErrorData("使用展览展厅失败!")
	}
	return 200, []byte("{}")
}

// 取消使用“展厅”
func CancelUseExhibitionHall(router *base.Router) (int, []byte) {
	// 鉴权
	user, authorized := Authenticate(router)
	if !authorized {
		logging.Log.Error("取消使用展览展厅鉴权失败")
		return 0, nil
	}

	// 解析request数据
	var info VenueUseRequest
	if err := utils.JsonParse(router.Data, &info); err != nil {
		logging.Log.Error("解析数据失败: ", err.Error())
		return 403, utils.SerializeErrorData("取消使用展览展厅失败!")
	}

	// 获取展览
	exhibition, err := models.GetExhibition(info.ID)
	if err != nil {
		logging.Log.Error("数据库获取展览失败: ", err.Error())
		return 403, utils.SerializeErrorData("取消使用展览展厅失败!")
	}
	if user.UserId != exhibition.UserId && user.Role != int(models.Admin) {
		logging.Log.Errorf("此用户(%v)无权限操作‘取消使用展览展厅’\n", user.Email)
		return 400, utils.SerializeErrorData("取消使用展览展厅失败!")
	}
	exhibition.ExhibitionHallUsed = false

	if err := models.UpdateExhibition(exhibition); err != nil {
		logging.Log.Error("数据库取消使用展览展厅失败: ", err.Error())
		return 403, utils.SerializeErrorData("取消使用展览展厅失败!")
	}
	return 200, []byte("{}")
}

// 使用“演播厅”
func UseStudio(router *base.Router) (int, []byte) {
	// 鉴权
	user, authorized := Authenticate(router)
	if !authorized {
		logging.Log.Error("使用展览演播厅鉴权失败")
		return 0, nil
	}

	// 解析request数据
	var info VenueUseRequest
	if err := utils.JsonParse(router.Data, &info); err != nil {
		logging.Log.Error("解析数据失败: ", err.Error())
		return 403, utils.SerializeErrorData("使用展览演播厅失败!")
	}

	// 获取展览
	exhibition, err := models.GetExhibition(info.ID)
	if err != nil {
		logging.Log.Error("数据库获取展览失败: ", err.Error())
		return 403, utils.SerializeErrorData("使用展览演播厅失败!")
	}
	if user.UserId != exhibition.UserId && user.Role != int(models.Admin) {
		logging.Log.Errorf("此用户(%v)无权限操作‘使用展览演播厅’\n", user.Email)
		return 400, utils.SerializeErrorData("使用展览演播厅失败!")
	}
	exhibition.ExhibitionHallUsed = false
	exhibition.StudioUsed = true
	exhibition.Style = info.Style

	if err := models.UpdateExhibition(exhibition); err != nil {
		logging.Log.Error("数据库使用展览演播厅失败: ", err.Error())
		return 403, utils.SerializeErrorData("使用展览演播厅失败!")
	}
	return 200, []byte("{}")
}

// 取消使用“演播厅”
func CancelUseStudio(router *base.Router) (int, []byte) {
	// 鉴权
	user, authorized := Authenticate(router)
	if !authorized {
		logging.Log.Error("取消使用展览演播厅鉴权失败")
		return 0, nil
	}

	// 解析request数据
	var info VenueUseRequest
	if err := utils.JsonParse(router.Data, &info); err != nil {
		logging.Log.Error("解析数据失败: ", err.Error())
		return 403, utils.SerializeErrorData("取消使用展览演播厅失败!")
	}

	// 获取展览
	exhibition, err := models.GetExhibition(info.ID)
	if err != nil {
		logging.Log.Error("数据库获取展览失败: ", err.Error())
		return 403, utils.SerializeErrorData("取消使用展览演播厅失败!")
	}
	if user.UserId != exhibition.UserId && user.Role != int(models.Admin) {
		logging.Log.Errorf("此用户(%v)无权限操作‘取消使用展览演播厅’\n", user.Email)
		return 400, utils.SerializeErrorData("取消使用展览演播厅失败!")
	}
	exhibition.StudioUsed = false

	if err := models.UpdateExhibition(exhibition); err != nil {
		logging.Log.Error("数据库取消使用展览演播厅失败: ", err.Error())
		return 403, utils.SerializeErrorData("取消使用展览演播厅失败!")
	}
	return 200, []byte("{}")
}

/****************************** 开幕式、展厅、演播厅布展操作 ******************************/
func EditVenue(router *base.Router) (int, []byte) {
	// 鉴权
	user, authorized := Authenticate(router)
	if !authorized {
		logging.Log.Error("编辑展厅鉴权失败")
		return 0, nil
	}

	// 解析request数据
	var info EditVenueRequest
	if err := utils.JsonParse(router.Data, &info); err != nil {
		logging.Log.Error("解析数据失败: ", err.Error())
		return 403, utils.SerializeErrorData("编辑展厅失败!")
	}

	// 获取展览
	exhibition, err := models.GetExhibition(info.ID)
	if err != nil {
		logging.Log.Error("数据库获取展览失败: ", err.Error())
		return 403, utils.SerializeErrorData("编辑展厅失败!")
	}
	if user.UserId != exhibition.UserId && user.Role != int(models.Admin) {
		logging.Log.Errorf("此用户(%v)无权限编辑展厅’\n", user.Email)
		return 400, utils.SerializeErrorData("编辑展厅失败!")
	}
	numberOfPosition := config.NumberOfPosition(exhibition.Style, info.RoomIndex)
	exhibits, err := models.GetExhibitsByExhibitionIdAndRoomIndex(info.ID, info.RoomIndex)
	if err != nil {
		logging.Log.Error("数据库获取展厅展品失败: ", err.Error())
		return 403, utils.SerializeErrorData("编辑展厅失败!")
	}
	resp := EditVenueResponse{
		NumberOfPosition: numberOfPosition,
		Exhibits:         exhibits,
	}
	return 200, utils.Serialize(&resp)
}

/****************************** 展览统计相关 ******************************/
func GetVisitStatistics(router *base.Router) (int, []byte) {
	// 鉴权
	_, authorized := Authenticate(router)
	if !authorized {
		logging.Log.Error("获取访问信息鉴权失败")
		return 0, nil
	}

	// 解析request数据
	var info GetVisitStatisticsRequest
	if err := utils.JsonParse(router.Data, &info); err != nil {
		logging.Log.Error("解析数据失败: ", err.Error())
		return 403, utils.SerializeErrorData("获取展览访问信息失败!")
	}
	visits, err := models.GetVisitStatisticsByExhibitionId(info.ID)
	if err != nil {
		logging.Log.Error("数据库获取展览访问信息失败: ", err.Error())
		return 400, utils.SerializeErrorData("获取展览访问信息失败!")
	}
	count := 0
	for _, v := range visits {
		count += v.Count
	}
	resp := GetVisitStatisticsResponse{
		ID:              info.ID,
		Count:           count,
		VisitStatistics: visits,
	}
	return 200, utils.Serialize(&resp)
}

func GetExhibitsWithOrders(router *base.Router) (int, []byte) {
	// 鉴权
	_, authorized := Authenticate(router)
	if !authorized {
		logging.Log.Error("获取访问信息鉴权失败")
		return 0, nil
	}

	// 解析request数据
	var info GetExhibitsWithOrdersRequest
	if err := utils.JsonParse(router.Data, &info); err != nil {
		logging.Log.Error("解析数据失败: ", err.Error())
		return 403, utils.SerializeErrorData("获取具有订单的展品信息失败!")
	}
	orders, err := models.GetOrdersByExhibitionId(info.ID)
	if err != nil {
		logging.Log.Error("数据库获取展览所有订单信息失败: ", err.Error())
		return 400, utils.SerializeErrorData("获取具有订单的展品信息失败!")
	}
	logging.Log.Info("orders: ", len(orders))
	// 获取展品id
	var ids []int
	for _, o := range orders {
		if !utils.IntArrayContains(ids, int(o.ID)) {
			ids = append(ids, int(o.ExhibitId))
		}
	}
	logging.Log.Infof("ids: %v\n", ids)
	// 获取展品
	exhibits, err := models.GetExhibitsByIds(ids)
	if err != nil {
		logging.Log.Error("数据库获取具有订单的展品信息失败: ", err.Error())
		return 400, utils.SerializeErrorData("获取具有订单的展品信息失败!")
	}
	resp := GetExhibitsWithOrdersResponse{
		ID:       info.ID,
		Exhibits: exhibits,
	}
	return 200, utils.Serialize(&resp)
}

func GetOrders(router *base.Router) (int, []byte) {
	// 鉴权
	_, authorized := Authenticate(router)
	if !authorized {
		logging.Log.Error("获取访问信息鉴权失败")
		return 0, nil
	}

	// 解析request数据
	var info GetExhibitOrdersRequest
	if err := utils.JsonParse(router.Data, &info); err != nil {
		logging.Log.Error("解析数据失败: ", err.Error())
		return 403, utils.SerializeErrorData("获取展品订单失败!")
	}
	logging.Log.Info("exhibitId: ", info.ID)
	orders, err := models.GetOrdersByExhibitId(info.ID)
	if err != nil {
		logging.Log.Error("数据库获取展品订单失败: ", err.Error())
		return 400, utils.SerializeErrorData("获取展品订单失败!")
	}
	resp := GetExhibitOrdersResponse{
		ID:     info.ID,
		Orders: orders,
	}
	return 200, utils.Serialize(&resp)
}

/****************************** Private Methods ******************************/
func createExhibitionInternal(router *base.Router) (int, []byte) {
	// 鉴权
	jwt, authorized := Authenticate(router)
	if !authorized {
		logging.Log.Error("创建展览鉴权失败")
		return 0, nil
	}

	// 解析request数据
	var info CreateExhibitionRequest
	if err := utils.JsonParse(router.Data, &info); err != nil {
		logging.Log.Errorf("解析创建展览数据失败: %s\n", err.Error())
		return 403, utils.SerializeErrorData("创建展览失败!")
	}

	startTime, _ := time.ParseInLocation("2006-01-02 15:04:05", info.StartTime, time.Local)
	endTime, _ := time.ParseInLocation("2006-01-02 15:04:05", info.EndTime, time.Local)
	logging.Log.Infof("创建展览：Title = %v, Subtitle = %v, StartTime = %v, EndTime = %v", info.Title, info.Subtitle, startTime, endTime)
	// 构建展览实例
	ex := models.Exhibition{
		Title:          info.Title,
		Subtitle:       info.Subtitle,
		StartTime:      startTime,
		EndTime:        endTime,
		Cover:          info.Cover,
		FineWork:       info.FineWork,
		Master:         info.Master,
		UserId:         jwt.UserId,
		Classification: info.Classification,
	}
	// 数据库存储
	if err := models.CreateExhibition(&ex); err != nil {
		logging.Log.Errorf("数据库创建展览失败: %s\n", err.Error())
		return 403, utils.SerializeErrorData("创建展览失败!")
	}
	return 200, []byte("{}")
}
