info

README

All the mgo model and common struct

Documentation

Index

• Constants
• type Album
• type ApiNote
  • func NoteToApiNote(note Note, files []NoteFile) ApiNote
• type ApiNoteContent
• type ApiNotebook
• type ApiRe
  • func NewApiRe() ApiRe
• type ApiUser
• type Archive
• type ArchiveMonth
• type Attach
• type AuthOk
• type BlogComment
• type BlogCommentPublic
• type BlogInfoCustom
• type BlogItem
• type BlogLike
• type BlogSingle
• type BlogStat
• type BlogUrls
• type Cate
• type Config
• type EachHistory
• type EachSharedNote
• type EachSharedNotebook
• type EachSharedNotebookAndNotes
• type EmailLog
• type File
• type Group
• type GroupUser
• type HasShareNote
• type Note
• type NoteAndContent
• type NoteContent
• type NoteContentHistory
• type NoteFile
• type NoteImage
• type NoteTag
• type Notebook
• type Notebooks
• type Page
  • func NewPage(page, perPageSize, count int, list interface{}) Page
• type Post
• type Re
  • func NewRe() Re
• type ReUpdate
  • func NewReUpdate() ReUpdate
• type Report
• type Session
• type ShareNote
• type ShareNoteWithPerm
• type ShareNotebook
• type ShareNotebooks
• type ShareNotebooksByUser
• type ShareUserInfo
• type SharedNotebookAndNotes
• type SharingNotebookAndNotes
• type SubNotebooks
  • func (this SubNotebooks) Len() int
  • func (this SubNotebooks) Less(i, j int) bool
  • func (this SubNotebooks) Swap(i, j int)
• type SubShareNotebooks
  • func (this SubShareNotebooks) Len() int
  • func (this SubShareNotebooks) Less(i, j int) bool
  • func (this SubShareNotebooks) Swap(i, j int)
• type Suggestion
• type Tag
• type TagCount
• type Theme
• type Token
• type User
• type UserAccount
• type UserAndBlog
• type UserAndBlogUrl
• type UserBlog
• type UserBlogBase
• type UserBlogComment
• type UserBlogStyle

Constants

const (
	TokenPwd = iota
	TokenActiveEmail
	TokenUpdateEmail
)

token type

const (
	PwdOverHours         = 2.0
	ActiveEmailOverHours = 48.0
	UpdateEmailOverHours = 2.0
)

过期时间

const (
	ThirdGithub = iota
	ThirdQQ
)

第三方类型

Types

type Album

type Album struct {
	AlbumId     bson.ObjectId `bson:"_id,omitempty"` //
	UserId      bson.ObjectId `bson:"UserId"`
	Name        string        `Name` // album name
	Type        int           `Type` // type, the default is image: 0
	Seq         int           `Seq`
	CreatedTime time.Time     `CreatedTime`
}

type ApiNote

type ApiNote struct {
	NoteId     string
	NotebookId string
	UserId     string
	Title      string
	Desc       string
	//	ImgSrc     string
	Tags       []string
	Abstract   string
	Content    string
	IsMarkdown bool
	//	FromUserId string // 为共享而新建
	IsBlog      bool // 是否是blog, 更新note不需要修改, 添加note时才有可能用到, 此时需要判断notebook是否设为Blog
	IsTrash     bool
	IsDeleted   bool
	Usn         int
	Files       []NoteFile
	CreatedTime time.Time
	UpdatedTime time.Time
	PublicTime  time.Time
}

func NoteToApiNote

func NoteToApiNote(note Note, files []NoteFile) ApiNote

转换

type ApiNoteContent

type ApiNoteContent struct {
	NoteId bson.ObjectId `bson:"_id,omitempty"`
	UserId bson.ObjectId `bson:"UserId"`

	Content string `Content`
}

内容

type ApiNotebook

type ApiNotebook struct {
	NotebookId       bson.ObjectId `bson:"_id,omitempty"` // 必须要设置bson:"_id" 不然mgo不会认为是主键
	UserId           bson.ObjectId `bson:"UserId"`
	ParentNotebookId bson.ObjectId `bson:"ParentNotebookId,omitempty"` // 上级
	Seq              int           `Seq`                               // 排序
	Title            string        `Title`                             // 标题
	UrlTitle         string        `UrlTitle`                          // Url标题 2014/11.11加
	IsBlog           bool          `IsBlog,omitempty`                  // 是否是Blog 2013/12/29 新加
	CreatedTime      time.Time     `CreatedTime,omitempty`
	UpdatedTime      time.Time     `UpdatedTime,omitempty`
	Usn              int           `Usn` // UpdateSequenceNum
	IsDeleted        bool          `IsDeleted`
}

---------- Notebook ----------

type ApiRe

type ApiRe struct {
	Ok  bool
	Msg string
}

一般返回

func NewApiRe

func NewApiRe() ApiRe

type ApiUser

type ApiUser struct {
	UserId   string
	Username string
	Email    string
	Verified bool
	Logo     string
}

type Archive

type Archive struct {
	Year         int
	MonthAchives []ArchiveMonth
	Posts        []*Post
}

type ArchiveMonth

type ArchiveMonth struct {
	Month int
	Posts []*Post
}

归档

type Attach

type Attach struct {
	AttachId     bson.ObjectId `bson:"_id,omitempty"` //
	NoteId       bson.ObjectId `bson:"NoteId"`        //
	UploadUserId bson.ObjectId `bson:"UploadUserId"`  // 可以不是note owner, 协作者userId
	Name         string        `Name`                 // file name, md5, such as 13232312.doc
	Title        string        `Title`                // raw file name
	Size         int64         `Size`                 // file size (byte)
	Type         string        `Type`                 // file type, "doc" = word
	Path         string        `Path`                 // the file path such as: files/userId/attachs/adfadf.doc
	CreatedTime  time.Time     `CreatedTime`
}

Attach belongs to note

type AuthOk

type AuthOk struct {
	Ok       bool
	Token    string
	UserId   bson.ObjectId
	Email    string
	Username string
}

auth

type BlogComment

type BlogComment struct {
	CommentId bson.ObjectId `bson:"_id,omitempty"`
	NoteId    bson.ObjectId `NoteId`

	UserId  bson.ObjectId `UserId`  // UserId回复ToUserId
	Content string        `Content` // 评论内容

	ToCommentId bson.ObjectId `ToCommendId,omitempty` // 对某条评论进行回复
	ToUserId    bson.ObjectId `ToUserId,omitempty`    // 为空表示直接评论, 不回空表示回复某人

	LikeNum     int      `LikeNum`     // 点赞次数, 评论也可以点赞
	LikeUserIds []string `LikeUserIds` // 点赞的用户ids

	CreatedTime time.Time `CreatedTime`
}

评论

type BlogCommentPublic

type BlogCommentPublic struct {
	BlogComment
	IsILikeIt bool
}

type BlogInfoCustom

type BlogInfoCustom struct {
	UserId      string
	Username    string
	UserLogo    string
	Title       string
	SubTitle    string
	Logo        string
	OpenComment bool
	CommentType string
	ThemeId     string
	SubDomain   string
	Domain      string
}

type BlogItem

type BlogItem struct {
	Note
	Abstract string
	Content  string // 可能是content的一部分, 截取. 点击more后就是整个信息了
	HasMore  bool   // 是否是否还有
	User     User   // 用户信息
}

type BlogLike

type BlogLike struct {
	LikeId      bson.ObjectId `bson:"_id,omitempty"`
	NoteId      bson.ObjectId `NoteId`
	UserId      bson.ObjectId `UserId`
	CreatedTime time.Time     `CreatedTime`
}

点赞记录

type BlogSingle

type BlogSingle struct {
	SingleId    bson.ObjectId `bson:"_id,omitempty"`
	UserId      bson.ObjectId `UserId`
	Title       string        `Title`
	UrlTitle    string        `UrlTitle` // 2014/11/11
	Content     string        `Content`
	UpdatedTime time.Time     `UpdatedTime`
	CreatedTime time.Time     `CreatedTime`
}

单页

type BlogStat

type BlogStat struct {
	NoteId     bson.ObjectId `bson:"_id,omitempty"`
	ReadNum    int           `ReadNum,omitempty`    // 阅读次数 2014/9/28
	LikeNum    int           `LikeNum,omitempty`    // 点赞次数 2014/9/28
	CommentNum int           `CommentNum,omitempty` // 评论次数 2014/9/28
}

博客统计信息

type BlogUrls

type BlogUrls struct {
	IndexUrl    string
	CateUrl     string
	SearchUrl   string
	SingleUrl   string
	PostUrl     string
	ArchiveUrl  string
	TagsUrl     string
	TagPostsUrl string
}

type Cate

type Cate struct {
	CateId       string
	ParentCateId string
	Title        string
	UrlTitle     string
	Children     []*Cate
}

type Config

type Config struct {
	ConfigId    bson.ObjectId       `bson:"_id"`
	UserId      bson.ObjectId       `UserId`
	Key         string              `Key`
	ValueStr    string              `ValueStr,omitempty`    // "1"
	ValueArr    []string            `ValueArr,omitempty`    // ["1","b","c"]
	ValueMap    map[string]string   `ValueMap,omitempty`    // {"a":"bb", "CC":"xx"}
	ValueArrMap []map[string]string `ValueArrMap,omitempty` // [{"a":"B"}, {}, {}]
	IsArr       bool                `IsArr`                 // 是否是数组
	IsMap       bool                `IsMap`                 // 是否是Map
	IsArrMap    bool                `IsArrMap`              // 是否是数组Map

	UpdatedTime time.Time `UpdatedTime`
}

配置, 每一个配置一行记录

type EachHistory

type EachHistory struct {
	UpdatedUserId bson.ObjectId `UpdatedUserId`
	UpdatedTime   time.Time     `UpdatedTime`
	Content       string        `Content`
}

历史记录 每一个历史记录对象

type EachSharedNote

type EachSharedNote struct {
	Seq int
}

以后可能含有其它信息

type EachSharedNotebook

type EachSharedNotebook struct {
	Seq int
}

type EachSharedNotebookAndNotes

type EachSharedNotebookAndNotes struct {
	Seq             int                           // 共享给谁的所在序号
	DefaultNotebook map[string]EachSharedNote     // noteId => 共享的note
	Notebooks       map[string]EachSharedNotebook // notebookId => 共享的notebook
}

每一个用户共享给的note, notebook

type EmailLog

type EmailLog struct {
	LogId bson.ObjectId `bson:"_id"`

	Email   string `Email`   // 发送者
	Subject string `Subject` // 主题
	Body    string `Body`    // 内容
	Msg     string `Msg`     // 发送失败信息
	Ok      bool   `Ok`      // 发送是否成功

	CreatedTime time.Time `CreatedTime`
}

发送邮件

type File

type File struct {
	FileId         bson.ObjectId `bson:"_id,omitempty"` //
	UserId         bson.ObjectId `bson:"UserId"`
	AlbumId        bson.ObjectId `bson:"AlbumId"`
	Name           string        `Name`  // file name
	Title          string        `Title` // file name or user defined for search
	Size           int64         `Size`  // file size (byte)
	Type           string        `Type`  // file type, "" = image, "doc" = word
	Path           string        `Path`  // the file path
	IsDefaultAlbum bool          `IsDefaultAlbum`
	CreatedTime    time.Time     `CreatedTime`

	FromFileId bson.ObjectId `bson:"FromFileId,omitempty"` // copy from fileId, for collaboration
}

type Group

type Group struct {
	GroupId     bson.ObjectId `bson:"_id"` // 谁的
	UserId      bson.ObjectId `UserId`     // 所有者Id
	Title       string        `Title`      // 标题
	UserCount   int           `UserCount`  // 用户数
	CreatedTime time.Time     `CreatedTime`

	Users []User `Users,omitempty` // 分组下的用户, 不保存, 仅查看
}

分组

type GroupUser

type GroupUser struct {
	GroupUserId bson.ObjectId `bson:"_id"` // 谁的
	GroupId     bson.ObjectId `GroupId`    // 分组
	UserId      bson.ObjectId `UserId`     //  用户
	CreatedTime time.Time     `CreatedTime`
}

分组好友

type HasShareNote

type HasShareNote struct {
	HasShareNotebookId bson.ObjectId `bson:"_id,omitempty"` // 必须要设置bson:"_id" 不然mgo不会认为是主键
	UserId             bson.ObjectId `bson:"UserId"`
	ToUserId           bson.ObjectId `bson:"ToUserId"`
	Seq                int           `bson:"Seq"` // 以后还可以用户排序
}

谁共享给了谁note 共享了note, notebook都要加! 唯一: UserId-ToUserId db.leanote.has_share_notes.ensureIndex({"UserId":1,"ToUserId":1},{"unique":true})

type Note

type Note struct {
	NoteId        bson.ObjectId `bson:"_id,omitempty"`           // 必须要设置bson:"_id" 不然mgo不会认为是主键
	UserId        bson.ObjectId `bson:"UserId"`                  // 谁的
	CreatedUserId bson.ObjectId `bson:"CreatedUserId,omitempty"` // 谁创建的(UserId != CreatedUserId, 是因为共享). 只是共享才有, 默认为空, 不存 必须要加omitempty
	NotebookId    bson.ObjectId `bson:"NotebookId"`
	Title         string        `Title` // 标题
	Desc          string        `Desc`  // 描述, 非html

	ImgSrc string   `ImgSrc` // 图片, 第一张缩略图地址
	Tags   []string `Tags,omitempty`

	IsTrash bool `IsTrash` // 是否是trash, 默认是false

	IsBlog         bool   `IsBlog,omitempty`      // 是否设置成了blog 2013/12/29 新加
	UrlTitle       string `UrlTitle,omitempty`    // 博客的url标题, 为了更友好的url, 在UserId, UrlName下唯一
	IsRecommend    bool   `IsRecommend,omitempty` // 是否为推荐博客 2014/9/24新加
	IsTop          bool   `IsTop,omitempty`       // blog是否置顶
	HasSelfDefined bool   `HasSelfDefined`        // 是否已经自定义博客图片, desc, abstract

	// 2014/9/28 添加评论社交功能
	ReadNum    int `ReadNum,omitempty`    // 阅读次数 2014/9/28
	LikeNum    int `LikeNum,omitempty`    // 点赞次数 2014/9/28
	CommentNum int `CommentNum,omitempty` // 评论次数 2014/9/28

	IsMarkdown bool `IsMarkdown` // 是否是markdown笔记, 默认是false

	AttachNum int `AttachNum` // 2014/9/21, attachments num

	CreatedTime   time.Time     `CreatedTime`
	UpdatedTime   time.Time     `UpdatedTime`
	RecommendTime time.Time     `RecommendTime,omitempty` // 推荐时间
	PublicTime    time.Time     `PublicTime,omitempty`    // 发表时间, 公开为博客则设置
	UpdatedUserId bson.ObjectId `bson:"UpdatedUserId"`    // 如果共享了, 并可写, 那么可能是其它他修改了

	// 2015/1/15, 更新序号
	Usn int `Usn` // UpdateSequenceNum

	IsDeleted bool `IsDeleted` // 删除位
}

只存笔记基本信息 内容不存放

type NoteAndContent

type NoteAndContent struct {
	Note
	NoteContent
}

基本信息和内容在一起

type NoteContent

type NoteContent struct {
	NoteId bson.ObjectId `bson:"_id,omitempty"`
	UserId bson.ObjectId `bson:"UserId"`

	IsBlog bool `IsBlog,omitempty` // 为了搜索博客

	Content  string `Content`
	Abstract string `Abstract` // 摘要, 有html标签, 比content短, 在博客展示需要, 不放在notes表中

	CreatedTime   time.Time     `CreatedTime`
	UpdatedTime   time.Time     `UpdatedTime`
	UpdatedUserId bson.ObjectId `bson:"UpdatedUserId"` // 如果共享了, 并可写, 那么可能是其它他修改了
}

内容

type NoteContentHistory

type NoteContentHistory struct {
	NoteId    bson.ObjectId `bson:"_id,omitempty"`
	UserId    bson.ObjectId `bson:"UserId"` // 所属者
	Histories []EachHistory `Histories`
}

type NoteFile

type NoteFile struct {
	FileId      string // 服务器端Id
	LocalFileId string // 客户端Id
	Type        string // images/png, doc, xls, 根据fileName确定
	Title       string
	HasBody     bool // 传过来的值是否要更新内容
	IsAttach    bool // 是否是附件, 不是附件就是图片
}

--------- 数据结构 ---------

type NoteImage

type NoteImage struct {
	NoteImageId bson.ObjectId `bson:"_id,omitempty"` // 必须要设置bson:"_id" 不然mgo不会认为是主键
	NoteId      bson.ObjectId `bson:"NoteId"`        // 笔记
	ImageId     bson.ObjectId `bson:"ImageId"`       // 图片fileId
}

笔记内部图片

type NoteTag

type NoteTag struct {
	TagId       bson.ObjectId `bson:"_id"`
	UserId      bson.ObjectId `UserId` // 谁的
	Tag         string        `Tag`    // UserId, Tag是唯一索引
	Usn         int           `Usn`    // Update Sequence Number
	Count       int           `Count`  // 笔记数
	CreatedTime time.Time     `CreatedTime`
	UpdatedTime time.Time     `UpdatedTime`
	IsDeleted   bool          `IsDeleted` // 删除位
}

v2 版标签

type Notebook

type Notebook struct {
	NotebookId       bson.ObjectId `bson:"_id,omitempty"` // 必须要设置bson:"_id" 不然mgo不会认为是主键
	UserId           bson.ObjectId `bson:"UserId"`
	ParentNotebookId bson.ObjectId `bson:"ParentNotebookId,omitempty"` // 上级
	Seq              int           `Seq`                               // 排序
	Title            string        `Title`                             // 标题
	UrlTitle         string        `UrlTitle`                          // Url标题 2014/11.11加
	NumberNotes      int           `NumberNotes`                       // 笔记数
	IsTrash          bool          `IsTrash,omitempty`                 // 是否是trash, 默认是false
	IsBlog           bool          `IsBlog,omitempty`                  // 是否是Blog 2013/12/29 新加
	CreatedTime      time.Time     `CreatedTime,omitempty`
	UpdatedTime      time.Time     `UpdatedTime,omitempty`

	// 2015/1/15, 更新序号
	Usn       int  `Usn` // UpdateSequenceNum
	IsDeleted bool `IsDeleted`
}

在数据库中每个 修改字段必须要在NotebookService中修改ParseAndSortNotebooks(没有匿名字段), 以后重构

type Notebooks

type Notebooks struct {
	Notebook
	Subs SubNotebooks // 子notebook 在数据库中是没有的
}

type Page

type Page struct {
	CurPage     int // 当前页码
	TotalPage   int // 总页
	PerPageSize int
	Count       int // 总记录数
	List        interface{}
}

分页数据

func NewPage

func NewPage(page, perPageSize, count int, list interface{}) Page

type Post

type Post struct {
	NoteId      string
	Title       string
	UrlTitle    string
	ImgSrc      string
	CreatedTime time.Time
	UpdatedTime time.Time
	PublicTime  time.Time
	Desc        string
	Abstract    string
	Content     string
	Tags        []string
	CommentNum  int
	ReadNum     int
	LikeNum     int
	IsMarkdown  bool
}

type Re

type Re struct {
	Ok   bool
	Code int
	Msg  string
	Id   string
	List interface{}
	Item interface{}
}

controller ajax返回

func NewRe

func NewRe() Re

type ReUpdate

type ReUpdate struct {
	Ok  bool
	Msg string
	Usn int
}

供notebook, note, tag更新的返回数据用

func NewReUpdate

func NewReUpdate() ReUpdate

type Report

type Report struct {
	ReportId bson.ObjectId `bson:"_id"`
	NoteId   bson.ObjectId `NoteId`

	UserId bson.ObjectId `UserId` // UserId回复ToUserId
	Reason string        `Reason` // 评论内容

	CommentId bson.ObjectId `CommendId,omitempty` // 对某条评论进行回复

	CreatedTime time.Time `CreatedTime`
}

举报

type Session

type Session struct {
	Id bson.ObjectId `bson:"_id,omitempty"` // 没有意义

	SessionId string `bson:"SessionId"` // SessionId

	LoginTimes int    `LoginTimes` // 登录错误时间
	Captcha    string `Captcha`    // 验证码

	UserId string `UserId` // API时有值UserId

	CreatedTime time.Time `CreatedTime`
	UpdatedTime time.Time `UpdatedTime` // 更新时间, expire这个时间会自动清空
}

http://docs.mongodb.org/manual/tutorial/expire-data/

type ShareNote

type ShareNote struct {
	ShareNoteId bson.ObjectId `bson:"_id,omitempty"` // 必须要设置bson:"_id" 不然mgo不会认为是主键
	UserId      bson.ObjectId `bson:"UserId"`
	ToUserId    bson.ObjectId `bson:"ToUserId,omitempty"`
	ToGroupId   bson.ObjectId `bson:"ToGroupId,omitempty"` // 分享给的用户组
	ToGroup     Group         `ToGroup,omitempty`          // 仅仅为了显示, 不存储, 分组信息
	NoteId      bson.ObjectId `bson:"NoteId"`
	Perm        int           `bson:"Perm"` // 权限, 0只读, 1可修改
	CreatedTime time.Time     `CreatedTime`
}

唯一: userId-ToUserId-NoteId use leanote db.leanote.share_notes.ensureIndex({"UserId":1,"ToUserId":1, "NoteId": 1},{"unique":true})

type ShareNoteWithPerm

type ShareNoteWithPerm struct {
	Note
	Perm int
}

将note与权限结合起来

type ShareNotebook

type ShareNotebook struct {
	ShareNotebookId bson.ObjectId `bson:"_id,omitempty"` // 必须要设置bson:"_id" 不然mgo不会认为是主键
	UserId          bson.ObjectId `bson:"UserId"`
	ToUserId        bson.ObjectId `bson:"ToUserId,omitempty"`
	ToGroupId       bson.ObjectId `bson:"ToGroupId,omitempty"` // 分享给的用户组
	ToGroup         Group         `ToGroup,omitempty`          // 仅仅为了显示, 不存储, 分组信息
	NotebookId      bson.ObjectId `bson:"NotebookId"`
	Seq             int           `bson:"Seq"`  // 排序
	Perm            int           `bson:"Perm"` // 权限, 其下所有notes 0只读, 1可修改
	CreatedTime     time.Time     `CreatedTime,omitempty`
}

type ShareNotebooks

type ShareNotebooks struct {
	Notebook
	ShareNotebook
	Subs SubShareNotebooks

	// Notebook与ShareNotebook公用的不能生成json
	Seq        int
	NotebookId bson.ObjectId
	IsDefault  bool // 是否是默认笔记本
}

type ShareNotebooksByUser

type ShareNotebooksByUser map[string][]ShareNotebooks

以用户进行分组 type ShareNotebooksByUsers []ShareNotebooksByUser

type ShareUserInfo

type ShareUserInfo struct {
	ToUserId          bson.ObjectId `bson:"UserId"`
	Email             string
	Perm              int  // note或其notebook的权限
	NotebookHasShared bool // 是否其notebook共享了
}

查看共享状态, 用户的信息

type SharedNotebookAndNotes

type SharedNotebookAndNotes struct {
	UserId bson.ObjectId                         `bson:"_id"`
	Shared map[string]EachSharedNotebookAndNotes // userId =>
}

type SharingNotebookAndNotes

type SharingNotebookAndNotes struct {
	UserId    bson.ObjectId       `bson:"_id"`
	Notes     map[string][]string // noteId => []string{userId1, userId2}
	Notebooks map[string][]string // notebookId => []string{userId1, userId2}
}

用户正在共享的notebook, note

type SubNotebooks

type SubNotebooks []*Notebooks // 存地址, 为了生成tree

仅仅是为了返回前台

func (SubNotebooks) Len

func (this SubNotebooks) Len() int

SubNotebook sort

func (SubNotebooks) Less

func (this SubNotebooks) Less(i, j int) bool

func (SubNotebooks) Swap

func (this SubNotebooks) Swap(i, j int)

type SubShareNotebooks

type SubShareNotebooks []ShareNotebooks

[

ShareNotebooks,
	Subs: [ShareNotebooks, ]
ShareNotebooks

]

func (SubShareNotebooks) Len

func (this SubShareNotebooks) Len() int

SubShareNotebook sort

func (SubShareNotebooks) Less

func (this SubShareNotebooks) Less(i, j int) bool

func (SubShareNotebooks) Swap

func (this SubShareNotebooks) Swap(i, j int)

type Suggestion

type Suggestion struct {
	Id         bson.ObjectId `bson:"_id"`
	UserId     bson.ObjectId `UserId`
	Addr       string        `Addr`
	Suggestion string        `Suggestion`
}

建议

type Tag

type Tag struct {
	UserId bson.ObjectId `bson:"_id"`
	Tags   []string      `Tags`
}

每个用户一条记录, 存储用户的所有tags

type TagCount

type TagCount struct {
	TagCountId bson.ObjectId `bson:"_id,omitempty"`
	UserId     bson.ObjectId `UserId` // 谁的
	Tag        string        `Tag`
	IsBlog     bool          `IsBlog` // 是否是博客的tag统计
	Count      int           `Count`  // 统计数量
}

type Theme

type Theme struct {
	ThemeId   bson.ObjectId          `bson:"_id,omitempty"` // 必须要设置bson:"_id" 不然mgo不会认为是主键
	UserId    bson.ObjectId          `UserId`
	Name      string                 `Name`
	Version   string                 `Version`
	Author    string                 `Author`
	AuthorUrl string                 `AuthorUrl`
	Path      string                 `Path`     // 文件夹路径, public/upload/54d7620d99c37b030600002c/themes/54d867c799c37b533e000001
	Info      map[string]interface{} `Info`     // 所有信息
	IsActive  bool                   `IsActive` // 是否在用

	IsDefault bool   `IsDefault`       // leanote默认主题, 如果用户修改了默认主题, 则先copy之. 也是admin用户的主题
	Style     string `Style,omitempty` // 之前的, 只有default的用户才有blog_default, blog_daqi, blog_left_fixed

	CreatedTime time.Time `CreatedTime`
	UpdatedTime time.Time `UpdatedTime`
}

主题, 每个用户有多个主题, 这里面有主题的配置信息 模板, css, js, images, 都在路径Path下

type Token

type Token struct {
	UserId      bson.ObjectId `bson:"_id"`
	Email       string        `Email`
	Token       string        `Token`
	Type        int           `Type`
	CreatedTime time.Time     `CreatedTime`
}

type User

type User struct {
	UserId      bson.ObjectId `bson:"_id,omitempty"` // 必须要设置bson:"_id" 不然mgo不会认为是主键
	Email       string        `Email`                // 全是小写
	Verified    bool          `Verified`             // Email是否已验证过?
	Username    string        `Username`             // 不区分大小写, 全是小写
	UsernameRaw string        `UsernameRaw`          // 可能有大小写
	Pwd         string        `bson:"Pwd" json:"-"`
	CreatedTime time.Time     `CreatedTime`

	Logo string `Logo` // 9-24
	// 主题
	Theme string `Theme`

	// 用户配置
	NotebookWidth int  `NotebookWidth` // 笔记本宽度
	NoteListWidth int  `NoteListWidth` // 笔记列表宽度
	MdEditorWidth int  `MdEditorWidth` // markdown 左侧编辑器宽度
	LeftIsMin     bool `LeftIsMin`     // 左侧是否是隐藏的, 默认是打开的

	// 这里 第三方登录
	ThirdUserId   string `ThirdUserId`   // 用户Id, 在第三方中唯一可识别
	ThirdUsername string `ThirdUsername` // 第三方中username, 为了显示
	ThirdType     int    `ThirdType`     // 第三方类型

	ImageNum   int           `bson:"ImageNum" json:"-"`   // 图片数量
	ImageSize  int           `bson:"ImageSize" json:"-"`  // 图片大小
	AttachNum  int           `bson:"AttachNum" json:"-"`  // 附件数量
	AttachSize int           `bson:"AttachSize" json:"-"` // 附件大小
	FromUserId bson.ObjectId `FromUserId,omitempty`       // 邀请的用户

	AccountType      string    `bson:"AccountType" json:"-"`      // normal(为空), premium
	AccountStartTime time.Time `bson:"AccountStartTime" json:"-"` // 开始日期
	AccountEndTime   time.Time `bson:"AccountEndTime" json:"-"`   // 结束日期
	// 阈值
	MaxImageNum      int `bson:"MaxImageNums" json:"-"`     // 图片数量
	MaxImageSize     int `bson:"MaxImageSize" json:"-"`     // 图片大小
	MaxAttachNum     int `bson:"MaxAttachNum" json:"-"`     // 图片数量
	MaxAttachSize    int `bson:"MaxAttachSize" json:"-"`    // 图片大小
	MaxPerAttachSize int `bson:"MaxPerAttachSize" json:"-"` // 单个附件大小

	// 2015/1/15, 更新序号
	Usn            int       `Usn`                   // UpdateSequenceNum , 全局的
	FullSyncBefore time.Time `bson:"FullSyncBefore"` // 需要全量同步的时间, 如果 > 客户端的LastSyncTime, 则需要全量更新
}

type UserAccount

type UserAccount struct {
	AccountType      string    `bson:"AccountType" json:"-"`      // normal(为空), premium
	AccountStartTime time.Time `bson:"AccountStartTime" json:"-"` // 开始日期
	AccountEndTime   time.Time `bson:"AccountEndTime" json:"-"`   // 结束日期
	// 阈值
	MaxImageNum      int `bson:"MaxImageNums" json:"-"`     // 图片数量
	MaxImageSize     int `bson:"MaxImageSize" json:"-"`     // 图片大小
	MaxAttachNum     int `bson:"MaxAttachNum" json:"-"`     // 图片数量
	MaxAttachSize    int `bson:"MaxAttachSize" json:"-"`    // 图片大小
	MaxPerAttachSize int `bson:"MaxPerAttachSize" json:"-"` // 单个附件大小
}

type UserAndBlog

type UserAndBlog struct {
	UserId    bson.ObjectId `bson:"_id,omitempty"` // 必须要设置bson:"_id" 不然mgo不会认为是主键
	Email     string        `Email`                // 全是小写
	Username  string        `Username`             // 不区分大小写, 全是小写
	Logo      string        `Logo`
	BlogTitle string        `BlogTitle` // 博客标题
	BlogLogo  string        `BlogLogo`  // 博客Logo
	BlogUrl   string        `BlogUrl`   // 博客链接, 主页

	BlogUrls // 各个页面
}

用户与博客信息结合, 公开

type UserAndBlogUrl

type UserAndBlogUrl struct {
	User
	BlogUrl string `BlogUrl`
	PostUrl string `PostUrl`
}

note主页需要

type UserBlog

type UserBlog struct {
	UserId   bson.ObjectId `bson:"_id"` // 谁的
	Logo     string        `Logo`
	Title    string        `Title`    // 标题
	SubTitle string        `SubTitle` // 副标题
	AboutMe  string        `AboutMe`  // 关于我, 弃用

	CanComment bool `CanComment` // 是否可以评论

	CommentType string `CommentType` // default 或 disqus
	DisqusId    string `DisqusId`

	Style string `Style` // 风格
	Css   string `Css`   // 自定义css

	ThemeId   bson.ObjectId `ThemeId,omitempty`         // 主题Id
	ThemePath string        `bson:"ThemePath" json:"-"` // 不存值, 从Theme中获取, 相对路径 public/

	CateIds []string            `CateIds,omitempty` // 分类Id, 排序好的
	Singles []map[string]string `Singles,omitempty` // 单页, 排序好的, map包含: ["Title"], ["SingleId"]

	PerPageSize int    `PerPageSize,omitempty`
	SortField   string `SortField`       // 排序字段
	IsAsc       bool   `IsAsc,omitempty` // 排序类型, 降序, 升序, 默认是false, 表示降序

	SubDomain string `SubDomain` // 二级域名
	Domain    string `Domain`    // 自定义域名

}

每个用户一份博客设置信息

type UserBlogBase

type UserBlogBase struct {
	Logo     string `Logo`
	Title    string `Title`    // 标题
	SubTitle string `SubTitle` // 副标题

}

type UserBlogComment

type UserBlogComment struct {
	CanComment  bool   `CanComment`  // 是否可以评论
	CommentType string `CommentType` // default 或 disqus
	DisqusId    string `DisqusId`
}

type UserBlogStyle

type UserBlogStyle struct {
	Style string `Style` // 风格
	Css   string `Css`   // 自定义css
}