mirror of https://github.com/mindoc-org/mindoc.git
265 lines
7.4 KiB
Go
265 lines
7.4 KiB
Go
package models
|
|
|
|
import (
|
|
"time"
|
|
"bytes"
|
|
"fmt"
|
|
"github.com/astaxie/beego"
|
|
"github.com/astaxie/beego/orm"
|
|
"github.com/lifei6671/mindoc/conf"
|
|
"strings"
|
|
"os"
|
|
"path/filepath"
|
|
"strconv"
|
|
"github.com/PuerkitoBio/goquery"
|
|
"github.com/lifei6671/mindoc/cache"
|
|
"encoding/json"
|
|
)
|
|
|
|
// Document struct.
|
|
type Document struct {
|
|
DocumentId int `orm:"pk;auto;unique;column(document_id)" json:"doc_id"`
|
|
DocumentName string `orm:"column(document_name);size(500)" json:"doc_name"`
|
|
// Identify 文档唯一标识
|
|
Identify string `orm:"column(identify);size(100);index;null;default(null)" json:"identify"`
|
|
BookId int `orm:"column(book_id);type(int);index" json:"book_id"`
|
|
ParentId int `orm:"column(parent_id);type(int);index;default(0)" json:"parent_id"`
|
|
OrderSort int `orm:"column(order_sort);default(0);type(int);index" json:"order_sort"`
|
|
// Markdown markdown格式文档.
|
|
Markdown string `orm:"column(markdown);type(text);null" json:"markdown"`
|
|
// Release 发布后的Html格式内容.
|
|
Release string `orm:"column(release);type(text);null" json:"release"`
|
|
// Content 未发布的 Html 格式内容.
|
|
Content string `orm:"column(content);type(text);null" json:"content"`
|
|
CreateTime time.Time `orm:"column(create_time);type(datetime);auto_now_add" json:"create_time"`
|
|
MemberId int `orm:"column(member_id);type(int)" json:"member_id"`
|
|
ModifyTime time.Time `orm:"column(modify_time);type(datetime);auto_now" json:"modify_time"`
|
|
ModifyAt int `orm:"column(modify_at);type(int)" json:"-"`
|
|
Version int64 `orm:"type(bigint);column(version)" json:"version"`
|
|
AttachList []*Attachment `orm:"-" json:"attach"`
|
|
}
|
|
|
|
// TableName 获取对应数据库表名.
|
|
func (m *Document) TableName() string {
|
|
return "documents"
|
|
}
|
|
|
|
// TableEngine 获取数据使用的引擎.
|
|
func (m *Document) TableEngine() string {
|
|
return "INNODB"
|
|
}
|
|
|
|
func (m *Document) TableNameWithPrefix() string {
|
|
return conf.GetDatabasePrefix() + m.TableName()
|
|
}
|
|
|
|
func NewDocument() *Document {
|
|
return &Document{
|
|
Version: time.Now().Unix(),
|
|
}
|
|
}
|
|
|
|
//根据文档ID查询指定文档.
|
|
func (m *Document) Find(id int) (*Document, error) {
|
|
if id <= 0 {
|
|
return m, ErrInvalidParameter
|
|
}
|
|
|
|
o := orm.NewOrm()
|
|
|
|
err := o.QueryTable(m.TableNameWithPrefix()).Filter("document_id", id).One(m)
|
|
|
|
if err == orm.ErrNoRows {
|
|
return m, ErrDataNotExist
|
|
}
|
|
|
|
return m, nil
|
|
}
|
|
|
|
//插入和更新文档.
|
|
func (m *Document) InsertOrUpdate(cols ...string) error {
|
|
o := orm.NewOrm()
|
|
var err error
|
|
if m.DocumentId > 0 {
|
|
_, err = o.Update(m)
|
|
} else {
|
|
_, err = o.Insert(m)
|
|
NewBook().ResetDocumentNumber(m.BookId)
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
//根据指定字段查询一条文档.
|
|
func (m *Document) FindByFieldFirst(field string, v interface{}) (*Document, error) {
|
|
|
|
o := orm.NewOrm()
|
|
|
|
err := o.QueryTable(m.TableNameWithPrefix()).Filter(field, v).One(m)
|
|
|
|
return m, err
|
|
}
|
|
|
|
//递归删除一个文档.
|
|
func (m *Document) RecursiveDocument(docId int) error {
|
|
|
|
o := orm.NewOrm()
|
|
|
|
if doc, err := m.Find(docId); err == nil {
|
|
o.Delete(doc)
|
|
NewDocumentHistory().Clear(doc.DocumentId)
|
|
}
|
|
//
|
|
//var docs []*Document
|
|
//
|
|
//_, err := o.QueryTable(m.TableNameWithPrefix()).Filter("parent_id", doc_id).All(&docs)
|
|
|
|
var maps []orm.Params
|
|
|
|
_, err := o.Raw("SELECT document_id FROM " + m.TableNameWithPrefix() + " WHERE parent_id=" + strconv.Itoa(docId)).Values(&maps)
|
|
if err != nil {
|
|
beego.Error("RecursiveDocument => ", err)
|
|
return err
|
|
}
|
|
|
|
for _, item := range maps {
|
|
if docId,ok := item["document_id"].(string); ok{
|
|
id,_ := strconv.Atoi(docId)
|
|
o.QueryTable(m.TableNameWithPrefix()).Filter("document_id", id).Delete()
|
|
m.RecursiveDocument(id)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
//发布文档
|
|
func (m *Document) ReleaseContent(bookId int) {
|
|
|
|
o := orm.NewOrm()
|
|
|
|
var docs []*Document
|
|
_, err := o.QueryTable(m.TableNameWithPrefix()).Filter("book_id", bookId).All(&docs, "document_id","identify", "content")
|
|
|
|
if err != nil {
|
|
beego.Error("发布失败 => ", err)
|
|
return
|
|
}
|
|
for _, item := range docs {
|
|
if item.Content != "" {
|
|
item.Release = item.Content
|
|
bufio := bytes.NewReader([]byte(item.Content))
|
|
//解析文档中非本站的链接，并设置为新窗口打开
|
|
if content, err := goquery.NewDocumentFromReader(bufio);err == nil {
|
|
|
|
content.Find("a").Each(func(i int, contentSelection *goquery.Selection) {
|
|
if src, ok := contentSelection.Attr("href"); ok{
|
|
if strings.HasPrefix(src, "http://") || strings.HasPrefix(src,"https://") {
|
|
//beego.Info(src,conf.BaseUrl,strings.HasPrefix(src,conf.BaseUrl))
|
|
if conf.BaseUrl != "" && !strings.HasPrefix(src,conf.BaseUrl) {
|
|
contentSelection.SetAttr("target", "_blank")
|
|
if html, err := content.Html();err == nil {
|
|
item.Release = html
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
attachList, err := NewAttachment().FindListByDocumentId(item.DocumentId)
|
|
if err == nil && len(attachList) > 0 {
|
|
content := bytes.NewBufferString("<div class=\"attach-list\"><strong>附件</strong><ul>")
|
|
for _, attach := range attachList {
|
|
if strings.HasPrefix(attach.HttpPath, "/") {
|
|
attach.HttpPath = strings.TrimSuffix(conf.BaseUrl, "/") + attach.HttpPath
|
|
}
|
|
li := fmt.Sprintf("<li><a href=\"%s\" target=\"_blank\" title=\"%s\">%s</a></li>", attach.HttpPath, attach.FileName, attach.FileName)
|
|
|
|
content.WriteString(li)
|
|
}
|
|
content.WriteString("</ul></div>")
|
|
item.Release += content.String()
|
|
}
|
|
_, err = o.Update(item, "release")
|
|
if err != nil {
|
|
beego.Error(fmt.Sprintf("发布失败 => %+v", item), err)
|
|
}else {
|
|
//当文档发布后，需要清除已缓存的转换文档和文档缓存
|
|
if doc,err := NewDocument().Find(item.DocumentId); err == nil {
|
|
doc.PutToCache()
|
|
}else{
|
|
doc.RemoveCache()
|
|
}
|
|
|
|
os.RemoveAll(filepath.Join(conf.WorkingDirectory,"uploads","books",strconv.Itoa(bookId)))
|
|
}
|
|
}
|
|
}
|
|
|
|
//将文档写入缓存
|
|
func (m *Document) PutToCache(){
|
|
go func(m Document) {
|
|
if v,err := json.Marshal(&m);err == nil {
|
|
if m.Identify == "" {
|
|
|
|
if err := cache.Put("Document.Id." + strconv.Itoa(m.DocumentId), v, time.Second*3600); err != nil {
|
|
beego.Info("文档缓存失败:", m.DocumentId)
|
|
}
|
|
}else{
|
|
if err := cache.Put("Document.Identify."+ m.Identify, v, time.Second*3600); err != nil {
|
|
beego.Info("文档缓存失败:", m.DocumentId)
|
|
}
|
|
}
|
|
}
|
|
}(*m)
|
|
}
|
|
//清除缓存
|
|
func (m *Document) RemoveCache() {
|
|
go func(m Document) {
|
|
cache.Put("Document.Id." + strconv.Itoa(m.DocumentId), m, time.Second*3600);
|
|
|
|
if m.Identify != "" {
|
|
cache.Put("Document.Identify."+ m.Identify, m, time.Second*3600);
|
|
}
|
|
}(*m)
|
|
}
|
|
|
|
//从缓存获取
|
|
func (m *Document) FromCacheById(id int) (*Document,error) {
|
|
b := cache.Get("Document.Id." + strconv.Itoa(id))
|
|
if v,ok := b.([]byte); ok {
|
|
|
|
if err := json.Unmarshal(v,m);err == nil{
|
|
beego.Info("从缓存中获取文档信息成功",m.DocumentId)
|
|
return m,nil
|
|
}
|
|
}
|
|
return m.Find(id)
|
|
}
|
|
//根据文档标识从缓存中查询文档
|
|
func (m *Document) FromCacheByIdentify(identify string) (*Document,error) {
|
|
b := cache.Get("Document.Identify." + identify)
|
|
if v,ok := b.([]byte); ok {
|
|
if err := json.Unmarshal(v,m);err == nil{
|
|
beego.Info("从缓存中获取文档信息成功",m.DocumentId)
|
|
return m,nil
|
|
}
|
|
}
|
|
return m.FindByFieldFirst("identify",identify)
|
|
}
|
|
|
|
//根据项目ID查询文档列表.
|
|
func (m *Document) FindListByBookId(bookId int) (docs []*Document, err error) {
|
|
o := orm.NewOrm()
|
|
|
|
_, err = o.QueryTable(m.TableNameWithPrefix()).Filter("book_id", bookId).OrderBy("order_sort").All(&docs)
|
|
|
|
return
|
|
}
|