rogee/quyun
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix: all

Browse Source
This commit is contained in:
yanghao05
2025-04-18 20:46:17 +08:00
parent a1537f9146
commit 4abd548325
8 changed files with 35 additions and 298 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
backend/app/http/admin/posts.go
View File

@@ -28,7 +28,7 @@ func (ctl *posts) List(ctx fiber.Ctx, pagination *requests.Pagination, query *Li
type PostForm struct {
Title string `json:"title"`
HeadImageIds []int64 `json:"head_image_ids"`
HeadImages []int64 `json:"head_images"`
Price int64 `json:"price"`
Discount int16 `json:"discount"`
Introduction string `json:"introduction"`
@@ -43,7 +43,7 @@ type PostForm struct {
func (ctl *posts) Create(ctx fiber.Ctx, form *PostForm) error {
post := model.Posts{
Title: form.Title,
HeadImages: fields.ToJson(form.HeadImageIds),
HeadImages: fields.ToJson(form.HeadImages),
Price: form.Price,
Discount: form.Discount,
Description: form.Introduction,
@@ -60,7 +60,7 @@ func (ctl *posts) Create(ctx fiber.Ctx, form *PostForm) error {
}
assets := lo.Map(medias, func(media *model.Medias, _ int) fields.MediaAsset {
return fields.MediaAsset{
Type: models.Medias.ConvertFileTypeByMimeType(media.MimeType),
Type: media.MimeType,
Media: media.ID,
Mark: nil,
}
@@ -86,7 +86,7 @@ func (ctl *posts) Update(ctx fiber.Ctx, id int64, form *PostForm) error {
post := &model.Posts{
Title: form.Title,
HeadImages: fields.ToJson(form.HeadImageIds),
HeadImages: fields.ToJson(form.HeadImages),
Price: form.Price,
Discount: form.Discount,
Description: form.Introduction,
@@ -108,7 +108,7 @@ func (ctl *posts) Update(ctx fiber.Ctx, id int64, form *PostForm) error {
}
assets := lo.Map(medias, func(media *model.Medias, _ int) fields.MediaAsset {
return fields.MediaAsset{
Type: models.Medias.ConvertFileTypeByMimeType(media.MimeType),
Type: media.MimeType,
Media: media.ID,
Mark: nil,
}
@@ -164,13 +164,11 @@ func (ctl *posts) Show(ctx fiber.Ctx, id int64) (*PostItem, error) {
Posts: post,
Medias: lo.Map(medias, func(media *model.Medias, _ int) *models.MediaItem {
return &models.MediaItem{
ID: media.ID,
Name: media.Name,
UploadTime: media.CreatedAt.Format("2006-01-02 15:04:05"),
FileSize: media.Size,
MimeType: media.MimeType,
FileType: models.Medias.ConvertFileTypeByMimeType(media.MimeType),
ThumbnailUrl: "",
ID: media.ID,
Name: media.Name,
UploadTime: media.CreatedAt.Format("2006-01-02 15:04:05"),
FileSize: media.Size,
MimeType: media.MimeType,
}
}),
}, nil

52
backend/app/models/medias.go
View File

@@ -5,7 +5,6 @@ import (
"time"
"quyun/app/requests"
"quyun/database/fields"
"quyun/database/schemas/public/model"
"quyun/database/schemas/public/table"
@@ -15,13 +14,11 @@ import (
)
type MediaItem struct {
ID int64 `json:"id"`
Name string `json:"name"`
UploadTime string `json:"upload_time"`
FileSize int64 `json:"file_size"`
MimeType string `json:"media_type"`
FileType fields.MediaAssetType `json:"file_type"`
ThumbnailUrl string `json:"thumbnail_url"`
ID int64 `json:"id"`
Name string `json:"name"`
UploadTime string `json:"upload_time"`
FileSize int64 `json:"file_size"`
MimeType string `json:"media_type"`
}
// @provider
@@ -97,13 +94,11 @@ func (m *mediasModel) List(ctx context.Context, pagination *requests.Pagination,
// Convert model.Medias to MediaItem
mediaItems := lo.Map(medias, func(media model.Medias, _ int) *MediaItem {
return &MediaItem{
ID: media.ID,
Name: media.Name,
UploadTime: media.CreatedAt.Format("2006-01-02 15:04:05"),
FileSize: media.Size,
MimeType: media.MimeType,
FileType: m.ConvertFileTypeByMimeType(media.MimeType),
ThumbnailUrl: "",
ID: media.ID,
Name: media.Name,
UploadTime: media.CreatedAt.Format("2006-01-02 15:04:05"),
FileSize: media.Size,
MimeType: media.MimeType,
}
})
@@ -141,33 +136,6 @@ func (m *mediasModel) Create(ctx context.Context, model *model.Medias) error {
return nil
}
func (m *mediasModel) ConvertFileTypeByMimeType(mimeType string) fields.MediaAssetType {
switch mimeType {
case "image/jpeg", "image/jpg", "image/png", "image/gif":
return fields.MediaAssetTypeImage
case "video/mp4", "video/x-m4v":
return fields.MediaAssetTypeVideo
case "audio/mpeg":
return fields.MediaAssetTypeAudio
case "application/pdf",
"application/msword",
"application/vnd.openxmlformats-officedocument.wordprocessingml.document",
"application/vnd.ms-excel",
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
"application/vnd.ms-powerpoint",
"application/vnd.openxmlformats-officedocument.presentationml.presentation":
return fields.MediaAssetTypeDocument
case "application/rar",
"application/x-rar-compressed",
"application/x-zip-compressed",
"application/x-zip",
"application/zip",
"application/x-7z-compressed":
return fields.MediaAssetTypeArchive
}
return fields.MediaAssetTypeUnknown
}
// GetByIds
func (m *mediasModel) GetByIds(ctx context.Context, ids []int64) ([]*model.Medias, error) {
if len(ids) == 0 {

24
backend/app/models/medias_test.go
View File

@@ -11,7 +11,6 @@ import (
"quyun/app/requests"
"quyun/app/service/testx"
"quyun/database"
"quyun/database/fields"
"quyun/database/schemas/public/model"
"quyun/database/schemas/public/table"
@@ -189,26 +188,3 @@ func (s *MediasTestSuite) Test_Page() {
})
})
}
// Test ConvertFileTypeByMimeType
func (s *MediasTestSuite) Test_ConvertFileTypeByMimeType() {
Convey("ConvertFileTypeByMimeType", s.T(), func() {
Convey("image", func() {
mimeType := "image/jpeg"
fileType := Medias.ConvertFileTypeByMimeType(mimeType)
So(fileType, ShouldEqual, fields.MediaAssetTypeImage)
})
Convey("video", func() {
mimeType := "video/mp4"
fileType := Medias.ConvertFileTypeByMimeType(mimeType)
So(fileType, ShouldEqual, fields.MediaAssetTypeVideo)
})
Convey("invalid mime type", func() {
mimeType := "invalid/type"
fileType := Medias.ConvertFileTypeByMimeType(mimeType)
So(fileType, ShouldEqual, fields.MediaAssetTypeUnknown)
})
})
}

4
backend/app/models/posts_test.go
View File

@@ -58,11 +58,11 @@ func (s *PostsTestSuite) Test_BatchInsert() {
Tags: fields.ToJson([]string{"tag1", "tag2", "tag3"}),
Assets: fields.ToJson([]fields.MediaAsset{
{
Type: fields.MediaAssetTypeAudio,
Type: "video/mp4",
Media: rand.Int63n(10000),
},
{
Type: fields.MediaAssetTypeVideo,
Type: "video/mp4",
Media: rand.Int63n(10000),
},
}),

190
backend/database/fields/posts.gen.go
View File

@@ -14,196 +14,6 @@ import (
"strings"
)
const (
// MediaAssetTypeUnknown is a MediaAssetType of type Unknown.
MediaAssetTypeUnknown MediaAssetType = "unknown"
// MediaAssetTypePoster is a MediaAssetType of type Poster.
MediaAssetTypePoster MediaAssetType = "poster"
// MediaAssetTypeImage is a MediaAssetType of type Image.
MediaAssetTypeImage MediaAssetType = "image"
// MediaAssetTypeVideo is a MediaAssetType of type Video.
MediaAssetTypeVideo MediaAssetType = "video"
// MediaAssetTypeAudio is a MediaAssetType of type Audio.
MediaAssetTypeAudio MediaAssetType = "audio"
// MediaAssetTypeDocument is a MediaAssetType of type Document.
MediaAssetTypeDocument MediaAssetType = "document"
// MediaAssetTypeArchive is a MediaAssetType of type Archive.
MediaAssetTypeArchive MediaAssetType = "archive"
// MediaAssetTypeOther is a MediaAssetType of type Other.
MediaAssetTypeOther MediaAssetType = "other"
)
var ErrInvalidMediaAssetType = fmt.Errorf("not a valid MediaAssetType, try [%s]", strings.Join(_MediaAssetTypeNames, ", "))
var _MediaAssetTypeNames = []string{
string(MediaAssetTypeUnknown),
string(MediaAssetTypePoster),
string(MediaAssetTypeImage),
string(MediaAssetTypeVideo),
string(MediaAssetTypeAudio),
string(MediaAssetTypeDocument),
string(MediaAssetTypeArchive),
string(MediaAssetTypeOther),
}
// MediaAssetTypeNames returns a list of possible string values of MediaAssetType.
func MediaAssetTypeNames() []string {
tmp := make([]string, len(_MediaAssetTypeNames))
copy(tmp, _MediaAssetTypeNames)
return tmp
}
// MediaAssetTypeValues returns a list of the values for MediaAssetType
func MediaAssetTypeValues() []MediaAssetType {
return []MediaAssetType{
MediaAssetTypeUnknown,
MediaAssetTypePoster,
MediaAssetTypeImage,
MediaAssetTypeVideo,
MediaAssetTypeAudio,
MediaAssetTypeDocument,
MediaAssetTypeArchive,
MediaAssetTypeOther,
}
}
// String implements the Stringer interface.
func (x MediaAssetType) String() string {
return string(x)
}
// IsValid provides a quick way to determine if the typed value is
// part of the allowed enumerated values
func (x MediaAssetType) IsValid() bool {
_, err := ParseMediaAssetType(string(x))
return err == nil
}
var _MediaAssetTypeValue = map[string]MediaAssetType{
"unknown": MediaAssetTypeUnknown,
"poster": MediaAssetTypePoster,
"image": MediaAssetTypeImage,
"video": MediaAssetTypeVideo,
"audio": MediaAssetTypeAudio,
"document": MediaAssetTypeDocument,
"archive": MediaAssetTypeArchive,
"other": MediaAssetTypeOther,
}
// ParseMediaAssetType attempts to convert a string to a MediaAssetType.
func ParseMediaAssetType(name string) (MediaAssetType, error) {
if x, ok := _MediaAssetTypeValue[name]; ok {
return x, nil
}
return MediaAssetType(""), fmt.Errorf("%s is %w", name, ErrInvalidMediaAssetType)
}
var errMediaAssetTypeNilPtr = errors.New("value pointer is nil") // one per type for package clashes
// Scan implements the Scanner interface.
func (x *MediaAssetType) Scan(value interface{}) (err error) {
if value == nil {
*x = MediaAssetType("")
return
}
// A wider range of scannable types.
// driver.Value values at the top of the list for expediency
switch v := value.(type) {
case string:
*x, err = ParseMediaAssetType(v)
case []byte:
*x, err = ParseMediaAssetType(string(v))
case MediaAssetType:
*x = v
case *MediaAssetType:
if v == nil {
return errMediaAssetTypeNilPtr
}
*x = *v
case *string:
if v == nil {
return errMediaAssetTypeNilPtr
}
*x, err = ParseMediaAssetType(*v)
default:
return errors.New("invalid type for MediaAssetType")
}
return
}
// Value implements the driver Valuer interface.
func (x MediaAssetType) Value() (driver.Value, error) {
return x.String(), nil
}
// Set implements the Golang flag.Value interface func.
func (x *MediaAssetType) Set(val string) error {
v, err := ParseMediaAssetType(val)
*x = v
return err
}
// Get implements the Golang flag.Getter interface func.
func (x *MediaAssetType) Get() interface{} {
return *x
}
// Type implements the github.com/spf13/pFlag Value interface.
func (x *MediaAssetType) Type() string {
return "MediaAssetType"
}
type NullMediaAssetType struct {
MediaAssetType MediaAssetType
Valid bool
}
func NewNullMediaAssetType(val interface{}) (x NullMediaAssetType) {
err := x.Scan(val) // yes, we ignore this error, it will just be an invalid value.
_ = err // make any errcheck linters happy
return
}
// Scan implements the Scanner interface.
func (x *NullMediaAssetType) Scan(value interface{}) (err error) {
if value == nil {
x.MediaAssetType, x.Valid = MediaAssetType(""), false
return
}
err = x.MediaAssetType.Scan(value)
x.Valid = (err == nil)
return
}
// Value implements the driver Valuer interface.
func (x NullMediaAssetType) Value() (driver.Value, error) {
if !x.Valid {
return nil, nil
}
// driver.Value accepts int64 for int values.
return string(x.MediaAssetType), nil
}
type NullMediaAssetTypeStr struct {
NullMediaAssetType
}
func NewNullMediaAssetTypeStr(val interface{}) (x NullMediaAssetTypeStr) {
x.Scan(val) // yes, we ignore this error, it will just be an invalid value.
return
}
// Value implements the driver Valuer interface.
func (x NullMediaAssetTypeStr) Value() (driver.Value, error) {
if !x.Valid {
return nil, nil
}
return x.MediaAssetType.String(), nil
}
const (
// PostStatusDraft is a PostStatus of type Draft.
PostStatusDraft PostStatus = iota

19
backend/database/fields/posts.go
View File

@@ -1,24 +1,11 @@
package fields
type MediaAsset struct {
Type MediaAssetType `json:"type"`
Media int64 `json:"media"`
Mark *string `json:"mark,omitempty"`
Type string `json:"type"`
Media int64 `json:"media"`
Mark *string `json:"mark,omitempty"`
}
// swagger:enum MediaAssetType
// ENUM(
// Unknown = "unknown",
// Poster = "poster",
// Image = "image",
// Video = "video",
// Audio = "audio",
// Document = "document",
// Archive = "archive",
// Other = "other"
// )
type MediaAssetType string
// swagger:enum PostStatus
// ENUM( draft, published )
type PostStatus int16

21
frontend/admin/src/pages/PostPage.vue
View File

@@ -1,6 +1,7 @@
<script setup>
import { postService } from '@/api/postService';
import { formatDate } from '@/utils/date';
import { getFileTypeByMimeCN } from "@/utils/filetype";
import { InputText } from 'primevue';
import Badge from 'primevue/badge';
@@ -56,18 +57,14 @@ const total = ref(0); // 总记录数
// Status mapping
const statusMap = {
0: '发布',
1: '草稿',
0: '草稿',
1: '发布',
};
// Transform assets to media types
const getMediaTypes = (assets) => {
return [...new Set(assets.map(asset => {
switch (asset.type) {
case 'audio': return '音频';
case 'video': return '视频';
default: return '文章';
}
return getFileTypeByMimeCN(asset.Type)
}))];
};
@@ -193,8 +190,8 @@ const formatPrice = (price) => {
};
// Format media types to display as comma-separated string
const formatMediaTypes = (mediaTypes) => {
return mediaTypes.join(', ');
const formatMediaTypes = (assets) => {
return assets.map(asset => getFileTypeByMimeCN(asset.type)).join(', ');
};
</script>
@@ -250,7 +247,7 @@ const formatMediaTypes = (mediaTypes) => {
<span class="text-orange-500">优惠: -{{ formatPrice(getDiscountAmount(data.price,
data.discount)) }}</span>
<span class="font-bold">实付: {{ formatPrice(getFinalPrice(data.price, data.discount))
}}</span>
}}</span>
</div>
</template>
</Column>
@@ -275,9 +272,9 @@ const formatMediaTypes = (mediaTypes) => {
</template>
</Column>
<Column field="mediaTypes" header="媒体类型" sortable>
<Column field="assets" header="媒体类型" sortable>
<template #body="{ data }">
<div class="text-sm text-gray-900">{{ formatMediaTypes(data.mediaTypes) }}</div>
<div class="text-sm text-gray-900">{{ formatMediaTypes(data.assets) }}</div>
</template>
<template #filter="{ filterModel, filterCallback }">
<Dropdown v-model="filterModel.value" @change="filterCallback()" :options="mediaTypeOptions"

1
frontend/admin/src/utils/filetype.js
View File

@@ -73,6 +73,7 @@ export function getFileTypeByMimeCN(mime) {
'other': '其他',
'unknown': '未知'
};
console.log(mime)
return typeMap[getFileTypeByMime(mime)];
}