38 |
--------------------------------------------------------------------------------
/src/application/controllers/taglibs/channelartlist.go:
--------------------------------------------------------------------------------
1 | package taglibs
2 |
3 | import (
4 | "fmt"
5 | "reflect"
6 | "strings"
7 |
8 | "github.com/CloudyKit/jet"
9 | "github.com/xiusin/pinecms/src/application/models"
10 | "github.com/xiusin/pinecms/src/application/models/tables"
11 | "xorm.io/xorm"
12 | )
13 |
14 | /*
15 | *
16 | sons 是否附带直属子分类数据, 可用于下级数据的迭代, 可取代channel的sun功能
17 | active 是否附带当前活动状态逻辑, 一般用于下级菜单激活上级菜单的高亮样式
18 | topid 记录当前所处页面的tid
19 | {{channellist = channelartlist(typeid, row, topid, sons, active)}}
20 | */
21 | func ChannelArtList(args jet.Arguments) reflect.Value {
22 | if !checkArgType(&args) {
23 | return defaultArrReturnVal
24 | }
25 | _row := int(getNumber(args.Get(1)))
26 | if _row <= 0 {
27 | _row = 20
28 | }
29 | var _typeid string
30 | if isNumber(args.Get(0)) {
31 | _typeid = fmt.Sprintf("%d", getNumber(args.Get(0)))
32 | } else {
33 | _typeid = args.Get(0).String()
34 | }
35 |
36 | var orm *xorm.Session
37 | if _typeid == "0" || _typeid == "top" {
38 | orm = getCategoryOrm().Where("parentid = 0")
39 | } else if strings.Contains(_typeid, ",") {
40 | orm = getCategoryOrm().In("catid", strings.Split(_typeid, ","))
41 | } else {
42 | orm = getCategoryOrm().Where("parentid = ?", _typeid)
43 | }
44 |
45 | _topId := getNumber(args.Get(2)) // 当前页面的ID
46 |
47 | var cats []tables.Category
48 |
49 | orm.Limit(_row).Select("id, parentid, catname, type, model_id, description, thumb, url").Asc("listorder").Find(&cats)
50 |
51 | if len(cats) == 0 {
52 | return defaultArrReturnVal
53 | }
54 | m := models.NewCategoryModel()
55 |
56 | withSons := args.Get(3).Bool()
57 | withActive := args.Get(4).Bool()
58 |
59 | for k, v := range cats {
60 | if v.Type != 2 {
61 | if withSons {
62 | var sons tables.Category
63 | count, _ := getCategoryOrm().Where("parentid = ?", v.Catid).Count(&sons)
64 | if count > 0 {
65 | cats[k].HasSon = true
66 | }
67 | }
68 | if withActive {
69 | cat1s := m.GetPosArr(v.Catid)
70 | cats[k].Url = fmt.Sprintf("/%s/", m.GetUrlPrefixWithCategoryArr(cat1s))
71 | for _, v := range cat1s {
72 | if v.Catid == _topId {
73 | cats[k].Active = true
74 | break
75 | }
76 | }
77 | }
78 | cats[k].Url = fmt.Sprintf("/%s/", m.GetUrlPrefixWithCategoryArr(m.GetPosArr(v.Catid)))
79 | }
80 | }
81 | return reflect.ValueOf(cats)
82 | }
83 |
--------------------------------------------------------------------------------
/src/application/controllers/backend/dict_controller.go:
--------------------------------------------------------------------------------
1 | package backend
2 |
3 | import (
4 | "errors"
5 |
6 | "github.com/xiusin/pinecms/src/application/models/tables"
7 | "github.com/xiusin/pinecms/src/common/helper"
8 | )
9 |
10 | type DictController struct {
11 | BaseController
12 | }
13 |
14 | func (c *DictController) Construct() {
15 | c.Group = "字典管理"
16 | c.SubGroup = "字典列表管理"
17 | c.KeywordsSearch = []SearchFieldDsl{
18 | {Field: "value", Op: "LIKE", DataExp: "%$?%"},
19 | {Field: "name", Op: "LIKE", DataExp: "%$?%"},
20 | }
21 | c.SearchFields = []SearchFieldDsl{{Field: "status"}, {Field: "cid"}}
22 |
23 | c.Table = &tables.Dict{}
24 | c.Entries = &[]*tables.Dict{}
25 | c.ApiEntityName = "字典属性"
26 |
27 | c.BaseController.Construct()
28 | c.OpBefore = c.before
29 | c.OpAfter = c.after
30 | }
31 |
32 | func (c *DictController) before(act int, param any) error {
33 | switch act {
34 | case OpAdd, OpEdit:
35 | p := param.(*tables.Dict)
36 | id, cid, name := p.Id, p.Cid, p.Name
37 | if cid == 0 {
38 | return errors.New("请选择所属字典分类")
39 | }
40 | sess := c.Orm.Table(c.Table).Where("name = ?", name).Where("cid = ?", cid)
41 | if OpEdit == act {
42 | sess = sess.Where("id <> ?", id)
43 | }
44 | exist, err := sess.Exist()
45 | if err != nil {
46 | return err
47 | }
48 | if exist {
49 | return errors.New("该分类下已经存在此标识")
50 | }
51 | }
52 | return nil
53 | }
54 |
55 | func (c *DictController) after(act int, param any) error {
56 | switch act {
57 | case OpList:
58 | entities := c.Entries.(*[]*tables.Dict)
59 | var ids []uint
60 | for _, dict := range *entities {
61 | ids = append(ids, dict.Cid)
62 | }
63 | if len(ids) > 0 {
64 | var cats []tables.DictCategory
65 | c.Orm.In("id", ids).Find(&cats)
66 | var m = map[uint]string{}
67 | for _, cat := range cats {
68 | m[cat.Id] = cat.Name
69 | }
70 | for _, dict := range *entities {
71 | dict.CatName, _ = m[dict.Cid]
72 | }
73 | }
74 | }
75 | return nil
76 | }
77 |
78 | func (c *DictController) GetSelect() {
79 | cid, _ := c.Ctx().Input().GetInt64("cid")
80 | if cid == 0 {
81 | helper.Ajax("请传入字典分类ID", 1, c.Ctx())
82 | return
83 | }
84 | var dicts []tables.KV
85 | _ = c.Orm.Where("status = 1").Where("cid = ?", cid).Find(c.Entries)
86 | m := c.Entries.(*[]tables.Dict)
87 | for _, model := range *m {
88 | dicts = append(dicts, tables.KV{Label: model.Name, Value: model.Value})
89 | }
90 | helper.Ajax(dicts, 0, c.Ctx())
91 | }
92 |
--------------------------------------------------------------------------------
/src/application/controllers/taglibs/list.go:
--------------------------------------------------------------------------------
1 | package taglibs
2 |
3 | import (
4 | "fmt"
5 | "reflect"
6 | "strconv"
7 | "strings"
8 |
9 | "github.com/CloudyKit/jet"
10 | "github.com/xiusin/pine"
11 | "github.com/xiusin/pinecms/src/application/controllers"
12 | "github.com/xiusin/pinecms/src/application/models"
13 | "github.com/xiusin/pinecms/src/common/helper"
14 | "github.com/xiusin/pinecms/src/config"
15 | )
16 |
17 | /**
18 | list(typeid, page, pagesize, modelname, titlelen, orderby, orderway)
19 | */
20 |
21 | func List(args jet.Arguments) reflect.Value {
22 | if !checkArgType(&args) {
23 | return defaultArrReturnVal
24 | }
25 | defer func() {
26 | if err := recover(); err != nil {
27 | pine.Logger().Error(fmt.Sprintf("ArcList Failed %s", err))
28 | }
29 | }()
30 | catid := getNumber(args.Get(0))
31 | page := getNumber(args.Get(1))
32 | pagesize := getNumber(args.Get(2))
33 | if pagesize == 0 {
34 | conf, _ := config.SiteConfig()
35 | ps, _ := strconv.Atoi(conf["SITE_PAGE_SIZE"])
36 | if ps == 0 {
37 | pagesize = 15
38 | } else {
39 | pagesize = int64(ps)
40 | }
41 | }
42 | if page < 1 {
43 | page = 1
44 | }
45 | offset := (page - 1) * pagesize
46 | tableName := args.Get(3).String()
47 | if tableName == "" || catid < 1 {
48 | return defaultArrReturnVal
49 | }
50 | titlelen := int(getNumber(args.Get(4)))
51 | orderBy := args.Get(5).String()
52 | orderWay := args.Get(6).String()
53 | if orderWay == "" {
54 | orderWay = "desc"
55 | }
56 | if orderBy == "" {
57 | orderBy = "listorder"
58 | }
59 | if orderBy == "rand" {
60 | if strings.ToLower(config.DB().Db.DbDriver) == "mysql" {
61 | orderBy = "RAND()"
62 | } else {
63 | orderBy = "RANDOM()"
64 | }
65 | } else {
66 | orderBy = fmt.Sprintf("%s %s", orderBy, orderWay)
67 | }
68 | categoryTable := getCategoryTable()
69 | modelTable := controllers.GetTableName(tableName)
70 | m := models.NewCategoryModel()
71 | ids := m.GetNextCategoryOnlyCatids(catid, true)
72 | sess := getOrmSess(tableName).Where(modelTable+".deleted_time IS NULL").Where(modelTable+".status = 1").In(modelTable+".catid", ids).Limit(int(pagesize), int(offset)).OrderBy(orderBy)
73 | defer sess.Close()
74 | sess.Join("LEFT", categoryTable, categoryTable+".id = "+modelTable+".catid")
75 | sess.Select(fmt.Sprintf("%s.*, %s.catname as typename", modelTable, categoryTable))
76 | list, _ := sess.QueryString()
77 | helper.HandleArtListInfo(list, titlelen)
78 | return reflect.ValueOf(list)
79 | }
80 |
--------------------------------------------------------------------------------
/src/application/controllers/backend/webssh/Apiform/Api.go:
--------------------------------------------------------------------------------
1 | package Apiform
2 |
3 | import (
4 | "encoding/json"
5 | "errors"
6 |
7 | uuid "github.com/satori/go.uuid"
8 | "github.com/xiusin/pinecms/src/application/controllers/backend/webssh/common"
9 | "github.com/xiusin/pinecms/src/application/controllers/backend/webssh/tables"
10 | "github.com/xiusin/pinecms/src/common/helper"
11 | )
12 |
13 | type Login struct {
14 | Phone int64 `form:"phone" binding:"required"`
15 | Code string `form:"code" binding:"required"`
16 | }
17 |
18 | type Send struct {
19 | Phone string `form:"phone" binding:"required"`
20 | }
21 |
22 | type Slist struct {
23 | Page int `form:"page" binding:"required"`
24 | Limit int `form:"limit" binding:"required"`
25 | }
26 |
27 | type List_resp struct {
28 | List []tables.SSHServer
29 | Count uint
30 | }
31 |
32 | type GetTerm struct {
33 | ID int64 `form:"id" binding:"required"`
34 | Password string `form:"password"`
35 | Setpass string `from:"setpass"`
36 | }
37 |
38 | type WsAuth struct {
39 | Sid string `uri:"sid" binding:"required,uuid"`
40 | }
41 |
42 | type Edit struct {
43 | ID int64 `form:"id" binding:"required"`
44 | Nickname string `form:"nickname"`
45 | Ip string `form:"ip"`
46 | Port int `form:"port"`
47 | Username string `form:"username"`
48 | }
49 |
50 | type EditPass struct {
51 | ID int64 `form:"id" binding:"required"`
52 | Password string `form:"password" binding:"required"`
53 | }
54 |
55 | type Addser struct {
56 | Nickname string `form:"nickname"`
57 | Ip string `form:"ip" binding:"required"`
58 | Port int `form:"port" binding:"required"`
59 | Username string `form:"username" binding:"required"`
60 | Password string `form:"password" binding:"required"`
61 | Desc string `form:"desc"`
62 | }
63 |
64 | type SerInfo struct {
65 | ID int64
66 | Ip string
67 | Port int
68 | Username string
69 | Password string
70 | BindUser int64
71 | }
72 |
73 | func (t *GetTerm) Decode(server tables.SSHServer) (sid string, err error) {
74 | sid = uuid.Must(uuid.NewV4(), nil).String()
75 | sPass, err := common.AesDecryptCBC(server.Password, []byte(t.Setpass))
76 | if err != nil {
77 | return "", err
78 | }
79 | if sPass == "" {
80 | return "", errors.New("秘钥验证失败")
81 | } else {
82 | var serinfo = SerInfo{server.Id, server.Ip, server.Port, server.Username, sPass, server.BindUser}
83 | sInfo, _ := json.Marshal(serinfo)
84 | helper.Cache().Set(sid, sInfo, 10)
85 | }
86 |
87 | return sid, nil
88 | }
89 |
--------------------------------------------------------------------------------
/cmd/crud/crud_stub.go:
--------------------------------------------------------------------------------
1 | package crud
2 |
3 | const (
4 | controllerDir = "src/application/controllers/backend/"
5 | tableDir = "src/application/models/tables/"
6 | feModuleDir = "src/cool/modules/"
7 | routerFile = "src/router/module.go"
8 | theme = "vim"
9 | goExt = ".go"
10 | controllerTpl = `package backend
11 | import (
12 | "github.com/xiusin/pinecms/src/application/models/tables"
13 | )
14 |
15 | type [ctrl] struct {
16 | BaseController
17 | }
18 |
19 | func (c *[ctrl]) Construct() {
20 | c.SearchFields = map[string]searchFieldDsl{
21 | [searchFieldDsl]
22 | }
23 | c.Group = "[table]管理"
24 | c.ApiEntityName = "[table]"
25 |
26 | c.Table = &tables.[table]{}
27 | c.Entries = &[]tables.[table]{}
28 | }`
29 | tableTpl = `package tables
30 |
31 | [struct]
32 | `
33 |
34 | indexVueTpl = `
35 |
36 |
37 |
38 |
39 |
40 |
41 |
42 |
43 |
44 |
45 |
46 |
47 |
48 |
49 |
50 |
51 |
52 |
53 |
54 |
55 |
56 |
57 | `
91 |
92 | serviceTsTpl = `import Router from "./router"; export default {[table]: new Router()};`
93 |
94 | serviceRouterTpl = `import { BaseService, Service, Permission } from "/@/core";
95 | @Service("[table]")
96 | class Sys[table] extends BaseService {}
97 | export default Sys[table];`
98 |
99 | serviceIndexTsTpl = `import service from "./service"; export default { service };`
100 | )
101 |
--------------------------------------------------------------------------------
/resources/themes/default/head.jet:
--------------------------------------------------------------------------------
1 | {{ import "tags.jet" }}
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 | {{yield channelartlist(typeid="top", sons=true) content}}
10 |
18 | {{end}}
19 |
20 |
21 |
22 |
23 |
33 |
34 |
36 |
37 |
38 |
39 |
40 |
41 |
42 | {{yield myad(name="top_all")}}
43 |
44 |
--------------------------------------------------------------------------------
/src/application/controllers/frontend/list.go:
--------------------------------------------------------------------------------
1 | package frontend
2 |
3 | import (
4 | "net/http"
5 | "os"
6 | "path/filepath"
7 |
8 | "github.com/xiusin/pine"
9 | "github.com/xiusin/pine/render/engine/pjet"
10 | "github.com/xiusin/pinecms/src/application/controllers"
11 | "github.com/xiusin/pinecms/src/application/models"
12 | "github.com/xiusin/pinecms/src/application/models/tables"
13 | )
14 |
15 | func (c *IndexController) List(pageFilePath string) {
16 | c.setTemplateData()
17 | pageFilePath = GetStaticFile(pageFilePath)
18 | queryTid, _ := c.Ctx().Input().GetInt64("tid")
19 | tid, _ := c.Ctx().Params().GetInt64("tid", queryTid)
20 | if tid < 1 {
21 | c.Ctx().Abort(404)
22 | return
23 | }
24 | category, err := models.NewCategoryModel().GetCategoryFByIdForBE(tid)
25 | if err != nil || category.Model.Enabled == 0 {
26 | if err == nil {
27 | pine.Logger().Error("模型禁用,无可查看", c.Ctx().Path())
28 | } else {
29 | pine.Logger().Error(err.Error())
30 | }
31 | c.Ctx().Abort(404)
32 | return
33 | }
34 | page, _ := c.Ctx().Params().GetInt("page", 1)
35 | if page < 1 {
36 | page = 1
37 | }
38 | total, _ := getOrmSess(category.Model).In("id", models.NewCategoryModel().GetNextCategoryOnlyCatids(tid, true)).Count()
39 | tpl := "list_" + category.Model.Table + ".jet" // default tpl
40 | if len(category.Model.FeTplList) > 0 { // model tpl
41 | tpl = category.Model.FeTplList
42 | }
43 | if len(category.ListTpl) > 0 { // category tpl
44 | tpl = category.ListTpl
45 | }
46 | _ = os.MkdirAll(filepath.Dir(pageFilePath), os.ModePerm)
47 | f, err := os.Create(pageFilePath)
48 | if err != nil {
49 | c.Ctx().Abort(http.StatusInternalServerError, err.Error())
50 | return
51 | }
52 | defer f.Close()
53 | jet := pine.Make(controllers.ServiceJetEngine).(*pjet.PineJet)
54 | temp, err := jet.GetTemplate(template(tpl))
55 | if err != nil {
56 | c.Ctx().Abort(http.StatusInternalServerError, err.Error())
57 | return
58 | }
59 |
60 | err = temp.Execute(f, viewDataToJetMap(c.Render().GetViewData()), struct {
61 | Field *tables.Category
62 | TypeID int64
63 | ArtCount int64
64 | ModelName string
65 | QP map[string]any
66 | PageNum int64
67 | }{
68 | Field: category,
69 | TypeID: tid,
70 | ArtCount: total,
71 | PageNum: int64(page),
72 | ModelName: category.Model.Table,
73 | QP: c.Ctx().Input().All(),
74 | })
75 | if err != nil {
76 | c.Ctx().Abort(http.StatusInternalServerError, err.Error())
77 | return
78 | }
79 | data, _ := os.ReadFile(pageFilePath)
80 | _ = c.Ctx().WriteHTMLBytes(data)
81 | }
82 |
--------------------------------------------------------------------------------
/cmd/util/util.go:
--------------------------------------------------------------------------------
1 | package util
2 |
3 | import (
4 | "os"
5 | "slices"
6 | "strings"
7 | )
8 |
9 | func AppPath() string {
10 | curPath, _ := os.Getwd()
11 | return curPath
12 | }
13 |
14 | func ScanDir(dir string, ignoreDirs []string) (list []struct {
15 | Path string
16 | IsDir bool
17 | }, err error) {
18 | fs, err := os.ReadDir(dir)
19 | if err != nil {
20 | return
21 | }
22 | list = append(list, struct {
23 | Path string
24 | IsDir bool
25 | }{Path: dir, IsDir: true})
26 |
27 | for _, f := range fs {
28 | if f.IsDir() {
29 | if InSlice(f.Name(), ignoreDirs) {
30 | continue
31 | }
32 | l, err := ScanDir(dir+"/"+f.Name(), ignoreDirs)
33 | if err != nil {
34 | return nil, err
35 | }
36 | list = append(list, l...)
37 | }
38 | // 添加目录和文件到列表， 提供给监听器
39 | list = append(list, struct {
40 | Path string
41 | IsDir bool
42 | }{Path: dir + "/" + f.Name(), IsDir: f.IsDir()})
43 | }
44 | return
45 | }
46 |
47 | func InSlice(needle string, haystacks []string) bool {
48 | return slices.Contains(haystacks, needle)
49 | }
50 | func SnakeString(s string) string {
51 | data := make([]byte, 0, len(s)*2)
52 | j := false
53 | num := len(s)
54 | for i := range num {
55 | d := s[i]
56 | if i > 0 && d >= 'A' && d <= 'Z' && j {
57 | data = append(data, '_')
58 | }
59 | if d != '_' {
60 | j = true
61 | }
62 | data = append(data, d)
63 | }
64 | return strings.ToLower(string(data[:]))
65 | }
66 |
67 | func StrFirstToUpper(str string) string {
68 | temp := strings.Split(strings.ReplaceAll(str, "_", "-"), "-")
69 | var upperStr string
70 | for y := 0; y < len(temp); y++ {
71 | vv := []rune(temp[y])
72 | if y != 0 {
73 | for i := 0; i < len(vv); i++ {
74 | if i == 0 {
75 | vv[i] -= 32
76 | upperStr += string(vv[i]) // + string(vv[i+1])
77 | } else {
78 | upperStr += string(vv[i])
79 | }
80 | }
81 | }
82 | }
83 | return temp[0] + upperStr
84 | }
85 |
86 | func CamelString(s string) string {
87 | data := make([]byte, 0, len(s))
88 | j := false
89 | k := false
90 | num := len(s) - 1
91 | for i := 0; i <= num; i++ {
92 | d := s[i]
93 | if k == false && d >= 'A' && d <= 'Z' {
94 | k = true
95 | }
96 | if d >= 'a' && d <= 'z' && (j || k == false) {
97 | d = d - 32
98 | j = false
99 | k = true
100 | }
101 | if k && d == '_' && num > i && s[i+1] >= 'a' && s[i+1] <= 'z' {
102 | j = true
103 | continue
104 | }
105 | data = append(data, d)
106 | }
107 | return string(data[:])
108 | }
109 |
--------------------------------------------------------------------------------
/src/application/controllers/backend/webssh/common/aes.go:
--------------------------------------------------------------------------------
1 | package common
2 |
3 | import (
4 | "bytes"
5 | "crypto/aes"
6 | "crypto/cipher"
7 | "crypto/md5"
8 | "encoding/base64"
9 | "encoding/hex"
10 | "errors"
11 | )
12 |
13 | func AesEncryptCBC(origData []byte, key []byte) string {
14 | // 分组秘钥
15 | // NewCipher该函数限制了输入k的长度必须为16, 24或者32
16 | key = Md5(key)[:24]
17 | block, _ := aes.NewCipher(key)
18 | blockSize := block.BlockSize() // 获取秘钥块的长度
19 | origData = pkcs7Padding(origData, blockSize) // 补全码
20 | //fmt.Println(blockSize)
21 | blockMode := cipher.NewCBCEncrypter(block, key[:blockSize]) // 加密模式
22 | //fmt.Println(string(Md5(key)[:blockSize]))
23 | encrypted := make([]byte, len(origData)) // 创建数组
24 | blockMode.CryptBlocks(encrypted, origData) // 加密
25 | return base64.StdEncoding.EncodeToString(encrypted)
26 | }
27 | func AesDecryptCBC(enc string, key []byte) (string, error) {
28 | key = Md5(key)[:24]
29 | encrypted, _ := base64.StdEncoding.DecodeString(enc)
30 | block, _ := aes.NewCipher(key) // 分组秘钥
31 | blockSize := block.BlockSize() // 获取秘钥块的长度
32 | blockMode := cipher.NewCBCDecrypter(block, key[:blockSize]) // 加密模式
33 | decrypted := make([]byte, len(encrypted)) // 创建数组
34 | blockMode.CryptBlocks(decrypted, encrypted) // 解密
35 | decrypted, err := pkcs7UnPadding(decrypted) // 去除补全码
36 | if err != nil {
37 | return "", err
38 | }
39 | return string(decrypted), nil
40 | }
41 | func pkcs5Padding(ciphertext []byte, blockSize int) []byte {
42 | padding := blockSize - len(ciphertext)%blockSize
43 | padtext := bytes.Repeat([]byte{byte(padding)}, padding)
44 | return append(ciphertext, padtext...)
45 | }
46 | func pkcs5UnPadding(origData []byte) []byte {
47 | length := len(origData)
48 | unpadding := int(origData[length-1])
49 | return origData[:(length - unpadding)]
50 | }
51 |
52 | func pkcs7Padding(ciphertext []byte, blockSize int) []byte {
53 | padding := blockSize - len(ciphertext)%blockSize
54 | padtext := bytes.Repeat([]byte{byte(padding)}, padding)
55 | return append(ciphertext, padtext...)
56 | }
57 |
58 | func pkcs7UnPadding(origData []byte) ([]byte, error) {
59 | length := len(origData)
60 | unpadding := int(origData[length-1])
61 | if length-unpadding < 0 {
62 | return []byte{}, errors.New("解密失败")
63 | }
64 | return origData[:(length - unpadding)], nil
65 | }
66 |
67 | func Md5(str []byte) []byte {
68 | h := md5.New()
69 | h.Write(str)
70 | //fmt.Println(hex.EncodeToString(h.Sum(nil)))
71 | return []byte(hex.EncodeToString(h.Sum(nil)))
72 | }
73 |
--------------------------------------------------------------------------------
{{field["title"]}}
12 | {{end}}
13 | {{yield artlist(offset=2, row=10, orderby="visit_count") content}}
14 |