833 lines
25 KiB
Go
833 lines
25 KiB
Go
package service
|
|
|
|
import (
|
|
"github.com/leanote/leanote/app/db"
|
|
"github.com/leanote/leanote/app/info"
|
|
. "github.com/leanote/leanote/app/lea"
|
|
"gopkg.in/mgo.v2/bson"
|
|
"sort"
|
|
"time"
|
|
)
|
|
|
|
// 共享Notebook, Note服务
|
|
type ShareService struct {
|
|
}
|
|
|
|
//-----------------------------------
|
|
// 返回shareNotebooks, sharedUserInfos
|
|
// info.ShareNotebooksByUser, []info.User
|
|
|
|
// 总体来说, 这个方法比较麻烦, 速度未知. 以后按以下方案来缓存用户基础数据
|
|
|
|
// 以后建个用户的基本数据表, 放所有notebook, sharedNotebook的缓存!!
|
|
// 每更新一次则启动一个goroutine异步更新
|
|
// 共享只能共享本notebook下的, 如果其子也要共享, 必须设置其子!!!
|
|
// 那么, 父, 子在shareNotebooks表中都会有记录
|
|
|
|
// 得到用户的所有*被*共享的Notebook
|
|
// 1 得到别人共享给我的所有notebooks
|
|
// 2 按parent进行层次化
|
|
// 3 每个层按seq进行排序
|
|
// 4 按用户分组
|
|
// [ok]
|
|
|
|
// 谁共享给了我的Query
|
|
func (this *ShareService) getOrQ(userId string) bson.M {
|
|
// 得到我和和我参与的组织
|
|
groupIds := groupService.GetMineAndBelongToGroupIds(userId)
|
|
|
|
q := bson.M{}
|
|
if len(groupIds) > 0 {
|
|
orQ := []bson.M{
|
|
bson.M{"ToUserId": bson.ObjectIdHex(userId)},
|
|
bson.M{"ToGroupId": bson.M{"$in": groupIds}},
|
|
}
|
|
// 不是trash的
|
|
q["$or"] = orQ
|
|
} else {
|
|
q["ToUserId"] = bson.ObjectIdHex(userId)
|
|
}
|
|
return q
|
|
}
|
|
|
|
// 得到共享给我的笔记本和用户(谁共享给了我)
|
|
func (this *ShareService) GetShareNotebooks(userId string) (info.ShareNotebooksByUser, []info.User) {
|
|
myUserId := userId
|
|
|
|
// 得到共享给我的用户s信息
|
|
// 得到我参与的组织
|
|
q := this.getOrQ(userId)
|
|
|
|
// 不查hasShareNotes
|
|
// 直接查shareNotes, shareNotebooks表得到userId
|
|
userIds1 := []bson.ObjectId{}
|
|
db.Distinct(db.ShareNotes, q, "UserId", &userIds1)
|
|
|
|
userIds2 := []bson.ObjectId{}
|
|
db.Distinct(db.ShareNotebooks, q, "UserId", &userIds2) // BUG之前是userId1, 2014/12/29
|
|
|
|
userIds := append(userIds1, userIds2...)
|
|
|
|
userInfos := userService.GetUserInfosOrderBySeq(userIds)
|
|
// 不要我的id
|
|
for i, userInfo := range userInfos {
|
|
if userInfo.UserId.Hex() == myUserId {
|
|
userInfos = append(userInfos[:i], userInfos[i+1:]...)
|
|
break
|
|
}
|
|
}
|
|
|
|
//--------------------
|
|
// 得到他们共享给我的notebooks
|
|
|
|
// 这里可能会得到重复的记录
|
|
// 权限: 笔记本分享给个人 > 笔记本分享给组织
|
|
shareNotebooks := []info.ShareNotebook{}
|
|
db.ShareNotebooks.Find(q).Sort("-ToUserId").All(&shareNotebooks) // 按ToUserId降序排序, 那么有ToUserId的在前面
|
|
|
|
if len(shareNotebooks) == 0 {
|
|
return nil, userInfos
|
|
}
|
|
|
|
shareNotebooksLen := len(shareNotebooks)
|
|
|
|
// 找到了所有的notbookId, 那么找notebook表得到其详细信息
|
|
notebookIds := []bson.ObjectId{}
|
|
shareNotebooksMap := make(map[bson.ObjectId]info.ShareNotebook, shareNotebooksLen)
|
|
for _, each := range shareNotebooks {
|
|
// 之后的就不要了, 只留权限高的
|
|
if _, ok := shareNotebooksMap[each.NotebookId]; !ok {
|
|
// 默认的是没有notebookId的
|
|
notebookIds = append(notebookIds, each.NotebookId)
|
|
shareNotebooksMap[each.NotebookId] = each
|
|
}
|
|
}
|
|
|
|
// 1, 2
|
|
subNotebooks := notebookService.GetNotebooksByNotebookIds(notebookIds)
|
|
// 填充其它信息变成SubShareNotebooks
|
|
subShareNotebooks := this.parseToSubShareNotebooks(&subNotebooks, &shareNotebooksMap)
|
|
|
|
// 3 按用户进行分组成ShareNotebooksByUser
|
|
shareNotebooksByUsersMap := map[bson.ObjectId][]info.ShareNotebooks{}
|
|
// 先建立userId => []
|
|
for _, eachSub := range subShareNotebooks {
|
|
userId := eachSub.Notebook.UserId
|
|
// 我自己的, 算了
|
|
if userId.Hex() == myUserId {
|
|
continue
|
|
}
|
|
|
|
if _, ok := shareNotebooksByUsersMap[userId]; ok {
|
|
shareNotebooksByUsersMap[userId] = append(shareNotebooksByUsersMap[userId], eachSub)
|
|
} else {
|
|
shareNotebooksByUsersMap[userId] = []info.ShareNotebooks{eachSub}
|
|
}
|
|
}
|
|
shareNotebooksByUser := info.ShareNotebooksByUser{}
|
|
for userId, eachShareNotebooks := range shareNotebooksByUsersMap {
|
|
// 4, 按用户排序
|
|
shareNotebooksByUser[userId.Hex()] = sortSubShareNotebooks(eachShareNotebooks)
|
|
}
|
|
|
|
return shareNotebooksByUser, userInfos
|
|
}
|
|
|
|
// 排序
|
|
func sortSubShareNotebooks(eachNotebooks info.SubShareNotebooks) info.SubShareNotebooks {
|
|
// 遍历子, 则子往上进行排序
|
|
for _, eachNotebook := range eachNotebooks {
|
|
if eachNotebook.Subs != nil && len(eachNotebook.Subs) > 0 {
|
|
eachNotebook.Subs = sortSubShareNotebooks(eachNotebook.Subs)
|
|
}
|
|
}
|
|
|
|
// 子排完了, 本层排
|
|
sort.Sort(&eachNotebooks)
|
|
return eachNotebooks
|
|
}
|
|
|
|
// 将普通的notebooks添加perm及shareNotebook信息
|
|
func (this *ShareService) parseToSubShareNotebooks(subNotebooks *info.SubNotebooks, shareNotebooksMap *map[bson.ObjectId]info.ShareNotebook) info.SubShareNotebooks {
|
|
subShareNotebooks := info.SubShareNotebooks{}
|
|
for _, each := range *subNotebooks {
|
|
shareNotebooks := info.ShareNotebooks{}
|
|
shareNotebooks.Notebook = each.Notebook // 基本信息有了
|
|
shareNotebooks.ShareNotebook = (*shareNotebooksMap)[each.NotebookId] // perm有了
|
|
|
|
// 公用的, 单独赋值
|
|
shareNotebooks.Seq = shareNotebooks.ShareNotebook.Seq
|
|
shareNotebooks.NotebookId = shareNotebooks.ShareNotebook.NotebookId
|
|
|
|
// 还有其子, 递归解析之
|
|
if each.Subs != nil && len(each.Subs) > 0 {
|
|
shareNotebooks.Subs = this.parseToSubShareNotebooks(&each.Subs, shareNotebooksMap)
|
|
}
|
|
subShareNotebooks = append(subShareNotebooks, shareNotebooks)
|
|
}
|
|
|
|
return subShareNotebooks
|
|
}
|
|
|
|
//-------------
|
|
|
|
// 得到共享笔记本下的notes
|
|
func (this *ShareService) ListShareNotesByNotebookId(notebookId, myUserId, sharedUserId string,
|
|
page, pageSize int, sortField string, isAsc bool) []info.ShareNoteWithPerm {
|
|
// 1 首先判断是否真的sharedUserId 共享了 notebookId 给 myUserId
|
|
q := this.getOrQ(myUserId)
|
|
q["NotebookId"] = bson.ObjectIdHex(notebookId)
|
|
q["UserId"] = bson.ObjectIdHex(sharedUserId)
|
|
shareNotebook := info.ShareNotebook{}
|
|
db.GetByQ(db.ShareNotebooks,
|
|
q,
|
|
&shareNotebook)
|
|
|
|
if shareNotebook.NotebookId == "" {
|
|
return nil
|
|
}
|
|
|
|
perm := shareNotebook.Perm
|
|
|
|
// 2 得到该notebook下分页显示所有的notes
|
|
_, notes := noteService.ListNotes(sharedUserId, notebookId, false, page, pageSize, sortField, isAsc, false)
|
|
|
|
// 3 添加权限信息
|
|
// 3.1 如果该notebook自己有其它权限信息, 比如1, 那么覆盖notebook的权限信息
|
|
noteIds := make([]bson.ObjectId, len(notes))
|
|
for i, note := range notes {
|
|
noteIds[i] = note.NoteId
|
|
}
|
|
// 笔记的权限
|
|
shareNotes := []info.ShareNote{}
|
|
delete(q, "NotebookId")
|
|
q["NoteId"] = bson.M{"$in": noteIds}
|
|
db.ShareNotes.Find(q).Sort("-ToUserId").All(&shareNotes) // 给个的权限>给组织的权限
|
|
notePerms := map[bson.ObjectId]int{}
|
|
for _, each := range shareNotes {
|
|
if _, ok := notePerms[each.NoteId]; !ok {
|
|
notePerms[each.NoteId] = each.Perm
|
|
}
|
|
}
|
|
Log("笔记权限")
|
|
LogJ(notePerms)
|
|
|
|
// 3.2 组合
|
|
notesWithPerm := make([]info.ShareNoteWithPerm, len(notes))
|
|
for i, each := range notes {
|
|
thisPerm := perm
|
|
if selfPerm, ok := notePerms[each.NoteId]; ok {
|
|
thisPerm = selfPerm
|
|
}
|
|
|
|
notesWithPerm[i] = info.ShareNoteWithPerm{each, thisPerm}
|
|
}
|
|
return notesWithPerm
|
|
}
|
|
|
|
// 得到note的perm信息
|
|
//func (this *ShareService) getNotesPerm(noteIds []bson.ObjectId, myUserId, sharedUserId string) map[bson.ObjectId]int {
|
|
// shareNotes := []info.ShareNote{}
|
|
// db.ListByQ(db.ShareNotes,
|
|
// bson.M{
|
|
// "NoteId": bson.M{"$in": noteIds},
|
|
// "UserId": bson.ObjectIdHex(sharedUserId),
|
|
// "ToUserId": bson.ObjectIdHex(myUserId)}, &shareNotes)
|
|
//
|
|
// notesPerm := make(map[bson.ObjectId]int, len(shareNotes))
|
|
// for _, each := range shareNotes {
|
|
// notesPerm[each.NoteId] = each.Perm
|
|
// }
|
|
//
|
|
// return notesPerm
|
|
//}
|
|
|
|
// 得到默认的单个的notes 共享集
|
|
// 如果真要支持排序, 这里得到所有共享的notes, 到noteService方再sort和limit
|
|
// 可以这样! 到时将零散的共享noteId放在用户基本数据中
|
|
// 这里不好排序
|
|
func (this *ShareService) ListShareNotes(myUserId, sharedUserId string,
|
|
pageNumber, pageSize int, sortField string, isAsc bool) []info.ShareNoteWithPerm {
|
|
|
|
skipNum, _ := parsePageAndSort(pageNumber, pageSize, sortField, isAsc)
|
|
shareNotes := []info.ShareNote{}
|
|
|
|
q := this.getOrQ(myUserId)
|
|
q["UserId"] = bson.ObjectIdHex(sharedUserId)
|
|
|
|
db.ShareNotes.
|
|
Find(q).
|
|
Sort("-ToUserId"). // 给个人的权限 > 给组织的权限
|
|
Skip(skipNum).
|
|
Limit(pageSize).
|
|
All(&shareNotes)
|
|
|
|
if len(shareNotes) == 0 {
|
|
return nil
|
|
}
|
|
|
|
noteIds := make([]bson.ObjectId, len(shareNotes))
|
|
for i, each := range shareNotes {
|
|
noteIds[i] = each.NoteId
|
|
}
|
|
notes := noteService.ListNotesByNoteIds(noteIds)
|
|
notesMap := map[bson.ObjectId]info.Note{}
|
|
for _, each := range notes {
|
|
notesMap[each.NoteId] = each
|
|
}
|
|
|
|
// 将shareNotes与notes结合起来
|
|
notesWithPerm := []info.ShareNoteWithPerm{}
|
|
hasAdded := map[bson.ObjectId]bool{} // 防止重复, 只要前面权限高的
|
|
for _, each := range shareNotes {
|
|
if !hasAdded[each.NoteId] {
|
|
// 待优化
|
|
notesWithPerm = append(notesWithPerm, info.ShareNoteWithPerm{notesMap[each.NoteId], each.Perm})
|
|
hasAdded[each.NoteId] = true
|
|
}
|
|
}
|
|
return notesWithPerm
|
|
}
|
|
|
|
func (this *ShareService) notes2NotesWithPerm(notes []info.Note) {
|
|
|
|
}
|
|
|
|
// 添加一个notebook共享
|
|
// [ok]
|
|
func (this *ShareService) AddShareNotebook1(shareNotebook info.ShareNotebook) bool {
|
|
// 添加一条记录说明两者存在关系
|
|
this.AddHasShareNote(shareNotebook.UserId.Hex(), shareNotebook.ToUserId.Hex())
|
|
|
|
shareNotebook.CreatedTime = time.Now()
|
|
return db.Insert(db.ShareNotebooks, shareNotebook)
|
|
}
|
|
|
|
// 添加共享笔记本
|
|
func (this *ShareService) AddShareNotebook(notebookId string, perm int, userId, email string) (bool, string, string) {
|
|
// 通过email得到被共享的userId
|
|
toUserId := userService.GetUserId(email)
|
|
if toUserId == "" {
|
|
return false, "无该用户", ""
|
|
}
|
|
return this.AddShareNotebookToUserId(notebookId, perm, userId, toUserId)
|
|
}
|
|
|
|
// 第三方注册时没有email
|
|
func (this *ShareService) AddShareNotebookToUserId(notebookId string, perm int, userId, toUserId string) (bool, string, string) {
|
|
// 添加一条记录说明两者存在关系
|
|
this.AddHasShareNote(userId, toUserId)
|
|
|
|
// 先删除之
|
|
db.Delete(db.ShareNotebooks, bson.M{"NotebookId": bson.ObjectIdHex(notebookId),
|
|
"UserId": bson.ObjectIdHex(userId),
|
|
"ToUserId": bson.ObjectIdHex(toUserId),
|
|
})
|
|
|
|
shareNotebook := info.ShareNotebook{NotebookId: bson.ObjectIdHex(notebookId),
|
|
UserId: bson.ObjectIdHex(userId),
|
|
ToUserId: bson.ObjectIdHex(toUserId),
|
|
Perm: perm,
|
|
CreatedTime: time.Now(),
|
|
}
|
|
return db.Insert(db.ShareNotebooks, shareNotebook), "", toUserId
|
|
}
|
|
|
|
// 添加一个note共享
|
|
// [ok]
|
|
/*
|
|
func (this *ShareService) AddShareNote(shareNote info.ShareNote) bool {
|
|
shareNote.CreatedTime = time.Now()
|
|
return db.Insert(db.ShareNotes, shareNote)
|
|
}
|
|
*/
|
|
func (this *ShareService) AddShareNote(noteId string, perm int, userId, email string) (bool, string, string) {
|
|
// 通过email得到被共享的userId
|
|
toUserId := userService.GetUserId(email)
|
|
if toUserId == "" {
|
|
return false, "无该用户", ""
|
|
}
|
|
return this.AddShareNoteToUserId(noteId, perm, userId, toUserId)
|
|
}
|
|
|
|
// 第三方测试没有userId
|
|
func (this *ShareService) AddShareNoteToUserId(noteId string, perm int, userId, toUserId string) (bool, string, string) {
|
|
// 添加一条记录说明两者存在关系
|
|
this.AddHasShareNote(userId, toUserId)
|
|
|
|
// 先删除之
|
|
db.Delete(db.ShareNotes, bson.M{"NoteId": bson.ObjectIdHex(noteId),
|
|
"UserId": bson.ObjectIdHex(userId),
|
|
"ToUserId": bson.ObjectIdHex(toUserId),
|
|
})
|
|
|
|
shareNote := info.ShareNote{NoteId: bson.ObjectIdHex(noteId),
|
|
UserId: bson.ObjectIdHex(userId),
|
|
ToUserId: bson.ObjectIdHex(toUserId),
|
|
Perm: perm,
|
|
CreatedTime: time.Now(),
|
|
}
|
|
return db.Insert(db.ShareNotes, shareNote), "", toUserId
|
|
}
|
|
|
|
// updatedUserId是否有查看userId noteId的权限?
|
|
// userId是所有者
|
|
func (this *ShareService) HasReadPerm(userId, updatedUserId, noteId string) bool {
|
|
q := this.getOrQ(updatedUserId) // (toUserId == "xxx" || ToGroupId in (1, 2,3))
|
|
q["UserId"] = bson.ObjectIdHex(userId)
|
|
q["NoteId"] = bson.ObjectIdHex(noteId)
|
|
if !db.Has(db.ShareNotes, q) {
|
|
// noteId的notebookId是否被共享了?
|
|
notebookId := noteService.GetNotebookId(noteId)
|
|
if notebookId.Hex() == "" {
|
|
return false
|
|
}
|
|
|
|
delete(q, "NoteId")
|
|
q["NotebookId"] = notebookId
|
|
|
|
// 判断notebook是否被共享
|
|
if !db.Has(db.ShareNotebooks, q) {
|
|
return false
|
|
} else {
|
|
return true
|
|
}
|
|
} else {
|
|
return true
|
|
}
|
|
}
|
|
|
|
// updatedUserId是否有修改userId noteId的权限?
|
|
func (this *ShareService) HasUpdatePerm(userId, updatedUserId, noteId string) bool {
|
|
q := this.getOrQ(updatedUserId) // (toUserId == "xxx" || ToGroupId in (1, 2,3))
|
|
q["UserId"] = bson.ObjectIdHex(userId)
|
|
q["NoteId"] = bson.ObjectIdHex(noteId)
|
|
|
|
// note的权限
|
|
shares := []info.ShareNote{}
|
|
db.ShareNotes.Find(q).Sort("-ToUserId").All(&shares) // 个人 > 组织
|
|
for _, share := range shares {
|
|
return share.Perm == 1 // 第1个权限最大
|
|
}
|
|
|
|
// notebook的权限
|
|
notebookId := noteService.GetNotebookId(noteId)
|
|
if notebookId.Hex() == "" {
|
|
return false
|
|
}
|
|
|
|
delete(q, "NoteId")
|
|
q["NotebookId"] = notebookId
|
|
shares2 := []info.ShareNotebook{}
|
|
db.ShareNotebooks.Find(q).Sort("-ToUserId").All(&shares2) // 个人 > 组织
|
|
for _, share := range shares2 {
|
|
return share.Perm == 1 // 第1个权限最大
|
|
}
|
|
return false
|
|
}
|
|
|
|
// updatedUserId是否有修改userId notebookId的权限?
|
|
func (this *ShareService) HasUpdateNotebookPerm(userId, updatedUserId, notebookId string) bool {
|
|
q := this.getOrQ(updatedUserId) // (toUserId == "xxx" || ToGroupId in (1, 2,3))
|
|
q["UserId"] = bson.ObjectIdHex(userId)
|
|
q["NotebookId"] = bson.ObjectIdHex(notebookId)
|
|
shares2 := []info.ShareNotebook{}
|
|
db.ShareNotebooks.Find(q).Sort("-ToUserId").All(&shares2) // 个人 > 组织
|
|
for _, share := range shares2 {
|
|
return share.Perm == 1 // 第1个权限最大
|
|
}
|
|
return false
|
|
}
|
|
|
|
// 共享note, notebook时使用
|
|
func (this *ShareService) AddHasShareNote(userId, toUserId string) bool {
|
|
db.Insert(db.HasShareNotes, info.HasShareNote{UserId: bson.ObjectIdHex(userId), ToUserId: bson.ObjectIdHex(toUserId)})
|
|
return true
|
|
}
|
|
|
|
// userId是否被共享了noteId
|
|
func (this *ShareService) HasSharedNote(noteId, myUserId string) bool {
|
|
return db.Has(db.ShareNotes, bson.M{"ToUserId": bson.ObjectIdHex(myUserId), "NoteId": bson.ObjectIdHex(noteId)})
|
|
}
|
|
|
|
// noteId的notebook是否共享了给我
|
|
func (this *ShareService) HasSharedNotebook(noteId, myUserId, sharedUserId string) bool {
|
|
notebookId := noteService.GetNotebookId(noteId)
|
|
if notebookId != "" {
|
|
return db.Has(db.ShareNotebooks, bson.M{"NotebookId": notebookId,
|
|
"UserId": bson.ObjectIdHex(sharedUserId),
|
|
"ToUserId": bson.ObjectIdHex(myUserId),
|
|
})
|
|
}
|
|
return false
|
|
}
|
|
|
|
// 得到共享的笔记内容
|
|
// 并返回笔记的权限!!!
|
|
func (this *ShareService) GetShareNoteContent(noteId, myUserId, sharedUserId string) (noteContent info.NoteContent) {
|
|
noteContent = info.NoteContent{}
|
|
// 是否单独共享了该notebook
|
|
// 或者, 其notebook共享了我
|
|
// Log(this.HasSharedNote(noteId, myUserId))
|
|
// Log(this.HasSharedNotebook(noteId, myUserId, sharedUserId))
|
|
// Log(this.HasReadPerm(sharedUserId, myUserId, noteId))
|
|
|
|
if this.HasReadPerm(sharedUserId, myUserId, noteId) {
|
|
// if this.HasSharedNote(noteId, myUserId) || this.HasSharedNotebook(noteId, myUserId, sharedUserId) {
|
|
db.Get(db.NoteContents, noteId, ¬eContent)
|
|
} else {
|
|
}
|
|
return
|
|
}
|
|
|
|
// 查看note的分享信息
|
|
// 分享给了哪些用户和权限
|
|
// ShareNotes表 userId = me, noteId = ...
|
|
// 还要查看该note的notebookId分享的信息
|
|
func (this *ShareService) ListNoteShareUserInfo(noteId, userId string) []info.ShareUserInfo {
|
|
// 得到shareNote信息, 得到所有的ToUserId
|
|
shareNotes := []info.ShareNote{}
|
|
db.ListByQLimit(db.ShareNotes,
|
|
bson.M{
|
|
"NoteId": bson.ObjectIdHex(noteId),
|
|
"UserId": bson.ObjectIdHex(userId),
|
|
"ToGroupId": bson.M{"$exists": false},
|
|
}, &shareNotes, 100)
|
|
|
|
// Log("<<>>>>")
|
|
// Log(len(shareNotes))
|
|
|
|
if len(shareNotes) == 0 {
|
|
return nil
|
|
}
|
|
|
|
shareNotesMap := make(map[bson.ObjectId]info.ShareNote, len(shareNotes))
|
|
for _, each := range shareNotes {
|
|
shareNotesMap[each.ToUserId] = each
|
|
}
|
|
|
|
toUserIds := make([]bson.ObjectId, len(shareNotes))
|
|
for i, eachShareNote := range shareNotes {
|
|
toUserIds[i] = eachShareNote.ToUserId
|
|
}
|
|
|
|
note := noteService.GetNote(noteId, userId)
|
|
if note.NoteId == "" {
|
|
return nil
|
|
}
|
|
|
|
// 查看其notebook的shareNotebooks信息
|
|
shareNotebooks := []info.ShareNotebook{}
|
|
db.ListByQ(db.ShareNotebooks,
|
|
bson.M{"NotebookId": note.NotebookId, "UserId": bson.ObjectIdHex(userId), "ToUserId": bson.M{"$in": toUserIds}},
|
|
&shareNotebooks)
|
|
shareNotebooksMap := make(map[bson.ObjectId]info.ShareNotebook, len(shareNotebooks))
|
|
for _, each := range shareNotebooks {
|
|
shareNotebooksMap[each.ToUserId] = each
|
|
}
|
|
|
|
// 得到用户信息
|
|
userInfos := userService.ListUserInfosByUserIds(toUserIds)
|
|
|
|
if len(userInfos) == 0 {
|
|
return nil
|
|
}
|
|
|
|
shareUserInfos := make([]info.ShareUserInfo, len(userInfos))
|
|
|
|
for i, userInfo := range userInfos {
|
|
_, hasNotebook := shareNotebooksMap[userInfo.UserId]
|
|
shareUserInfos[i] = info.ShareUserInfo{ToUserId: userInfo.UserId,
|
|
Email: userInfo.Email,
|
|
Perm: shareNotesMap[userInfo.UserId].Perm,
|
|
NotebookHasShared: hasNotebook,
|
|
}
|
|
}
|
|
|
|
return shareUserInfos
|
|
}
|
|
|
|
// 得到notebook的share信息
|
|
// TODO 这里必须要分页, 最多取100个用户; 限制
|
|
func (this *ShareService) ListNotebookShareUserInfo(notebookId, userId string) []info.ShareUserInfo {
|
|
// notebook的shareNotebooks信息
|
|
shareNotebooks := []info.ShareNotebook{}
|
|
|
|
db.ListByQLimit(db.ShareNotebooks,
|
|
bson.M{
|
|
"NotebookId": bson.ObjectIdHex(notebookId),
|
|
"UserId": bson.ObjectIdHex(userId),
|
|
"ToGroupId": bson.M{"$exists": false},
|
|
},
|
|
&shareNotebooks, 100)
|
|
|
|
if len(shareNotebooks) == 0 {
|
|
return nil
|
|
}
|
|
|
|
// 得到用户信息
|
|
toUserIds := make([]bson.ObjectId, len(shareNotebooks))
|
|
for i, each := range shareNotebooks {
|
|
toUserIds[i] = each.ToUserId
|
|
}
|
|
userInfos := userService.ListUserInfosByUserIds(toUserIds)
|
|
|
|
if len(userInfos) == 0 {
|
|
return nil
|
|
}
|
|
|
|
shareNotebooksMap := make(map[bson.ObjectId]info.ShareNotebook, len(shareNotebooks))
|
|
for _, each := range shareNotebooks {
|
|
shareNotebooksMap[each.ToUserId] = each
|
|
}
|
|
|
|
shareUserInfos := make([]info.ShareUserInfo, len(userInfos))
|
|
for i, userInfo := range userInfos {
|
|
shareUserInfos[i] = info.ShareUserInfo{ToUserId: userInfo.UserId,
|
|
Email: userInfo.Email,
|
|
Perm: shareNotebooksMap[userInfo.UserId].Perm,
|
|
}
|
|
}
|
|
|
|
return shareUserInfos
|
|
}
|
|
|
|
//----------------
|
|
// 改变note share权限
|
|
func (this *ShareService) UpdateShareNotePerm(noteId string, perm int, userId, toUserId string) bool {
|
|
return db.UpdateByQField(db.ShareNotes,
|
|
bson.M{"NoteId": bson.ObjectIdHex(noteId), "UserId": bson.ObjectIdHex(userId), "ToUserId": bson.ObjectIdHex(toUserId)},
|
|
"Perm",
|
|
perm,
|
|
)
|
|
}
|
|
|
|
func (this *ShareService) UpdateShareNotebookPerm(notebookId string, perm int, userId, toUserId string) bool {
|
|
return db.UpdateByQField(db.ShareNotebooks,
|
|
bson.M{"NotebookId": bson.ObjectIdHex(notebookId), "UserId": bson.ObjectIdHex(userId), "ToUserId": bson.ObjectIdHex(toUserId)},
|
|
"Perm",
|
|
perm,
|
|
)
|
|
}
|
|
|
|
//---------------
|
|
// 删除share note
|
|
func (this *ShareService) DeleteShareNote(noteId string, userId, toUserId string) bool {
|
|
return db.DeleteAll(db.ShareNotes,
|
|
bson.M{"NoteId": bson.ObjectIdHex(noteId), "UserId": bson.ObjectIdHex(userId), "ToUserId": bson.ObjectIdHex(toUserId)})
|
|
}
|
|
|
|
// 删除笔记时要删除该noteId的所有...
|
|
func (this *ShareService) DeleteShareNoteAll(noteId string, userId string) bool {
|
|
return db.DeleteAll(db.ShareNotes,
|
|
bson.M{"NoteId": bson.ObjectIdHex(noteId), "UserId": bson.ObjectIdHex(userId)})
|
|
}
|
|
|
|
// 删除share notebook
|
|
func (this *ShareService) DeleteShareNotebook(notebookId string, userId, toUserId string) bool {
|
|
return db.DeleteAll(db.ShareNotebooks,
|
|
bson.M{"NotebookId": bson.ObjectIdHex(notebookId), "UserId": bson.ObjectIdHex(userId), "ToUserId": bson.ObjectIdHex(toUserId)})
|
|
}
|
|
|
|
// 删除userId分享给toUserId的所有
|
|
func (this *ShareService) DeleteUserShareNoteAndNotebook(userId, toUserId string) bool {
|
|
query := bson.M{"UserId": bson.ObjectIdHex(userId), "ToUserId": bson.ObjectIdHex(toUserId)}
|
|
db.DeleteAll(db.ShareNotebooks, query)
|
|
db.DeleteAll(db.ShareNotes, query)
|
|
db.DeleteAll(db.HasShareNotes, query)
|
|
|
|
return true
|
|
}
|
|
|
|
// 用户userId是否有修改noteId的权限
|
|
func (this *ShareService) HasUpdateNotePerm(noteId, userId string) bool {
|
|
if noteId == "" || userId == "" {
|
|
return false
|
|
}
|
|
note := noteService.GetNoteById(noteId)
|
|
LogJ(note)
|
|
if note.UserId != "" {
|
|
noteUserId := note.UserId.Hex()
|
|
if noteUserId != userId {
|
|
// 是否是有权限协作的
|
|
if this.HasUpdatePerm(noteUserId, userId, noteId) {
|
|
return true
|
|
} else {
|
|
return false
|
|
}
|
|
} else {
|
|
return true
|
|
}
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
|
|
// 用户userId是否有查看noteId的权限
|
|
func (this *ShareService) HasReadNotePerm(noteId, userId string) bool {
|
|
if noteId == "" || userId == "" {
|
|
return false
|
|
}
|
|
note := noteService.GetNoteById(noteId)
|
|
if note.UserId != "" {
|
|
noteUserId := note.UserId.Hex()
|
|
if noteUserId != userId {
|
|
// 是否是有权限协作的
|
|
if this.HasReadPerm(noteUserId, userId, noteId) {
|
|
return true
|
|
} else {
|
|
return false
|
|
}
|
|
} else {
|
|
return true
|
|
}
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
|
|
//----------------
|
|
// 用户分组
|
|
|
|
// 得到笔记分享给的groups
|
|
func (this *ShareService) GetNoteShareGroups(noteId, userId string) []info.ShareNote {
|
|
groups := groupService.GetGroupsContainOf(userId)
|
|
|
|
// 得到有分享的分组
|
|
shares := []info.ShareNote{}
|
|
db.ListByQ(db.ShareNotes,
|
|
bson.M{"NoteId": bson.ObjectIdHex(noteId), "UserId": bson.ObjectIdHex(userId), "ToGroupId": bson.M{"$exists": true}}, &shares)
|
|
mapShares := map[bson.ObjectId]info.ShareNote{}
|
|
for _, share := range shares {
|
|
mapShares[share.ToGroupId] = share
|
|
}
|
|
|
|
// 所有的groups都有share, 但没有share的group没有shareId
|
|
shares2 := make([]info.ShareNote, len(groups))
|
|
for i, group := range groups {
|
|
share, ok := mapShares[group.GroupId]
|
|
if !ok {
|
|
share = info.ShareNote{}
|
|
}
|
|
share.ToGroup = group
|
|
shares2[i] = share
|
|
}
|
|
|
|
return shares2
|
|
}
|
|
|
|
// 共享笔记给分组
|
|
func (this *ShareService) AddShareNoteGroup(userId, noteId, groupId string, perm int) bool {
|
|
if !groupService.IsExistsGroupUser(userId, groupId) {
|
|
return false
|
|
}
|
|
|
|
// 先删除之
|
|
this.DeleteShareNoteGroup(userId, noteId, groupId)
|
|
|
|
shareNote := info.ShareNote{NoteId: bson.ObjectIdHex(noteId),
|
|
UserId: bson.ObjectIdHex(userId), // 冗余字段
|
|
ToGroupId: bson.ObjectIdHex(groupId),
|
|
Perm: perm,
|
|
CreatedTime: time.Now(),
|
|
}
|
|
return db.Insert(db.ShareNotes, shareNote)
|
|
}
|
|
|
|
// 删除
|
|
func (this *ShareService) DeleteShareNoteGroup(userId, noteId, groupId string) bool {
|
|
return db.Delete(db.ShareNotes, bson.M{"NoteId": bson.ObjectIdHex(noteId),
|
|
"UserId": bson.ObjectIdHex(userId),
|
|
"ToGroupId": bson.ObjectIdHex(groupId),
|
|
})
|
|
}
|
|
|
|
//-------
|
|
|
|
// 得到笔记本分享给的groups
|
|
func (this *ShareService) GetNotebookShareGroups(notebookId, userId string) []info.ShareNotebook {
|
|
groups := groupService.GetGroupsContainOf(userId)
|
|
|
|
// 得到有分享的分组
|
|
shares := []info.ShareNotebook{}
|
|
db.ListByQ(db.ShareNotebooks,
|
|
bson.M{"NotebookId": bson.ObjectIdHex(notebookId), "UserId": bson.ObjectIdHex(userId), "ToGroupId": bson.M{"$exists": true}}, &shares)
|
|
mapShares := map[bson.ObjectId]info.ShareNotebook{}
|
|
for _, share := range shares {
|
|
mapShares[share.ToGroupId] = share
|
|
}
|
|
LogJ(shares)
|
|
|
|
// 所有的groups都有share, 但没有share的group没有shareId
|
|
shares2 := make([]info.ShareNotebook, len(groups))
|
|
for i, group := range groups {
|
|
share, ok := mapShares[group.GroupId]
|
|
if !ok {
|
|
share = info.ShareNotebook{}
|
|
}
|
|
share.ToGroup = group
|
|
shares2[i] = share
|
|
}
|
|
|
|
return shares2
|
|
}
|
|
|
|
// 共享笔记给分组
|
|
func (this *ShareService) AddShareNotebookGroup(userId, notebookId, groupId string, perm int) bool {
|
|
if !groupService.IsExistsGroupUser(userId, groupId) {
|
|
return false
|
|
}
|
|
|
|
// 先删除之
|
|
this.DeleteShareNotebookGroup(userId, notebookId, groupId)
|
|
|
|
shareNotebook := info.ShareNotebook{NotebookId: bson.ObjectIdHex(notebookId),
|
|
UserId: bson.ObjectIdHex(userId), // 冗余字段
|
|
ToGroupId: bson.ObjectIdHex(groupId),
|
|
Perm: perm,
|
|
CreatedTime: time.Now(),
|
|
}
|
|
return db.Insert(db.ShareNotebooks, shareNotebook)
|
|
}
|
|
|
|
// 删除
|
|
func (this *ShareService) DeleteShareNotebookGroup(userId, notebookId, groupId string) bool {
|
|
return db.Delete(db.ShareNotebooks, bson.M{"NotebookId": bson.ObjectIdHex(notebookId),
|
|
"UserId": bson.ObjectIdHex(userId),
|
|
"ToGroupId": bson.ObjectIdHex(groupId),
|
|
})
|
|
}
|
|
|
|
//--------------------
|
|
// 删除组时, 删除所有的
|
|
//--------------------
|
|
|
|
func (this *ShareService) DeleteAllShareNotebookGroup(groupId string) bool {
|
|
return db.Delete(db.ShareNotebooks, bson.M{
|
|
"ToGroupId": bson.ObjectIdHex(groupId),
|
|
})
|
|
}
|
|
func (this *ShareService) DeleteAllShareNoteGroup(groupId string) bool {
|
|
return db.Delete(db.ShareNotes, bson.M{
|
|
"ToGroupId": bson.ObjectIdHex(groupId),
|
|
})
|
|
}
|
|
|
|
//--------------------
|
|
// 删除组内用户时, 删除其分享的
|
|
//--------------------
|
|
|
|
func (this *ShareService) DeleteShareNotebookGroupWhenDeleteGroupUser(userId, groupId string) bool {
|
|
return db.Delete(db.ShareNotebooks, bson.M{
|
|
"UserId": bson.ObjectIdHex(userId),
|
|
"ToGroupId": bson.ObjectIdHex(groupId),
|
|
})
|
|
}
|
|
|
|
func (this *ShareService) DeleteShareNoteGroupWhenDeleteGroupUser(userId, groupId string) bool {
|
|
return db.Delete(db.ShareNotes, bson.M{
|
|
"UserId": bson.ObjectIdHex(userId),
|
|
"ToGroupId": bson.ObjectIdHex(groupId),
|
|
})
|
|
}
|