class admin_school_link(BaseAdminAction, ActionResult):
# 常量 机构风采系统类型 = 100.
ObjectType_System = 100
# 常量 机构风采标识 = 1 .
ObjectId_School = 1
def __init__(self):
self.link_svc = __spring__.getBean("linkService")
self.params = ParamUtil(request)
return
# 执行请求.
def execute(self):
#print "hello, admin_school_link is executed"
# 必须要求登录和具有管理权限.
if self.loginUser == None: return ActionResult.LOGIN
if self.canAdmin() == False:
self.addActionError(u"没有管理机构链接的权限.")
return ActionResult.ERROR
cmd = self.params.safeGetStringParam("cmd")
if cmd == "" or cmd == None:
cmd = "list"
if cmd == "list":
return self.list()
elif cmd == "add":
return self.add()
elif cmd == "edit":
return self.edit()
elif cmd == "save":
return self.save()
elif cmd == "delete":
return self.delete()
else:
self.addActionError(u"未知命令参数 : " + cmd)
return ActionResult.ERROR
# 按照分页列出链接.
def list(self):
pager = self.params.createPager()
pager.itemName = u"机构链接"
pager.itemUnit = u"个"
# 计算总数.
hql = """ SELECT COUNT(*) FROM Link
WHERE objectType = :objectType AND objectId = :objectId """
cmd = Command(hql)
cmd.setInteger("objectType", self.ObjectType_System)
cmd.setInteger("objectId", self.ObjectId_School)
pager.totalRows = cmd.int_scalar()
# 获取当前页.
hql = """ FROM Link
WHERE objectType = :objectType AND objectId = :objectId
ORDER BY linkId DESC """
cmd = Command(hql)
cmd.setInteger("objectType", self.ObjectType_System)
cmd.setInteger("objectId", self.ObjectId_School)
link_list = cmd.open(pager)
request.setAttribute("link_list", link_list)
request.setAttribute("pager", pager)
#DEBUG: print "link_list = ", link_list
return "/WEB-INF/ftl/admin/school_link_list.ftl"
# 增加一个链接.
def add(self):
link = Link()
link.linkAddress = "http://"
link.linkType = 1
request.setAttribute("link", link)
return "/WEB-INF/ftl/admin/school_link_add.ftl"
# 编辑一个现有链接.
def edit(self):
linkId = self.params.getIntParam("linkId")
link = self.link_svc.getLinkById(linkId)
if link == None:
self.addActionError(u"无法找到指定标识的机构风采链接对象")
return ActionResult.ERROR
request.setAttribute("link", link)
return "/WEB-INF/ftl/admin/school_link_add.ftl"
# 保存链接.
def save(self):
link = self.collect()
self.link_svc.saveLink(link)
self.addActionMessage(u"保存链接 " + link.toDisplayString() + u"成功完成")
return ActionResult.SUCCESS
def delete(self):
ids = self.params.getIdList("linkId")
if ids == None or ids.size() == 0:
self.addActionError(u"未选择任何要操作的链接")
return ActionResult.ERROR
oper_count = 0
for linkId in ids:
# 得到链接对象.
link = self.link_svc.getLinkById(linkId)
if link == None:
self.addActionMessage(u"未能找到指定标识为 " + str(linkId) + u" 的机构链接")
continue
# TODO: 验证权限.
# 实施删除.
self.link_svc.deleteLink(link)
self.addActionMessage(u"链接 " + link.toDisplayString() + u" 已经成功删除")
oper_count += 1
self.addActionMessage(u"共删除了 " + str(oper_count) + u" 个链接")
return ActionResult.SUCCESS
# 从页面提交参数收集 Link 对象.
def collect(self):
link = Link()
link.linkId = self.params.getIntParam("linkId")
# link.objectType = self.params.getIntParam("objectType")
link.objectType = self.ObjectType_System
# link.objectId = self.params.getIntParam("objectId")
link.objectId = self.ObjectId_School
link.title = self.params.getStringParam("title")
link.linkAddress = self.params.getStringParam("linkAddress")
link.linkType = self.params.getIntParam("linkType")
link.description = self.params.getStringParam("description")
link.linkIcon = self.params.getStringParam("linkIcon")
return link
class category_Order_article (ActionExecutor):
CATEGORY_LIST = "/WEB-INF/ftl/admin/category_Order.ftl"
# 构造.
def __init__(self):
self.params = ParamUtil(request)
self.cate_svc = __jitar__.categoryService
self.itemType = "user"
return
# 根据'cmd'进行派发.
def dispatcher(self, cmd):
# 以下必须要求是登录用户
if self.loginUser == None: return ActionResult.LOGIN
if self.loginUser == None:
self.addActionError(u"请重新登陆.")
return ActionResult.ERROR
# 根据cmd参数，执行相应的方法.
if cmd == "" or cmd == None or cmd == "list":
return self.list() # 列表显示.
elif cmd == "save":
return self.save() # 保存.
else :
self.addActionError(u"未知的命令参数：" + cmd)
return ActionResult.ERROR
# 系统所有机构的列表显示.
def list(self):
# 构造查询.根据传递的参数与权限结合来判断显示什么分类
# default 缺省为系统分类, 也就是文章分类
# group 群组分类
# resource 资源分类
# photo 照片分类
# blog 工作组分类
# user_1 用户１的分类
# gres_1 协助组１的分类
# user_res_1 用户1的资源分类
if self.loginUser == None: return ActionResult.LOGIN
query = AdminCategoryQuery(""" cat.categoryId, cat.name, cat.itemType, cat.parentId, cat.parentPath,cat.childNum, cat.orderNum, cat.description """)
self.localTypeName = "";
self.parentId = self.params.getIntParamZeroAsNull("parentId")
self.itemType = self.params.getStringParam("type")
#print 'parentId='+str(self.parentId)
#print 'itemType='+self.itemType
#print 'split0-4='+self.itemType[0:4]
if self.itemType == None or self.itemType == '':
self.itemType = 'default'
query.itemType = self.itemType
query.parentId = self.parentId
if self.itemType == 'default' or self.itemType == 'group' or self.itemType == 'resource' or self.itemType == 'blog' or self.itemType == 'photo':
# TODO: 权限检查.
# print self.itemType
self.localTypeName = self.itemType
if self.canAdmin() == False:
self.addActionError(u"没有管理系统分类的权限.")
return ActionResult.ERROR
elif self.itemType[0:9] == 'user_res_':
#TODO: 检查当前用户是否是本分类的用户
# print self.itemType
cateUserId = self.itemType[9:]
if str(self.loginUser.userId) == cateUserId:
self.localTypeName = "user_res"
self.cateUserId = cateUserId
else:
self.addActionError(u"您不是id=" + str(cateUserId) + u"的用户")
return ActionResult.ERROR
elif self.itemType[0:5] == 'user_':
#TODO: 检查当前用户是否是本分类的用户
# print self.itemType
cateUserId = self.itemType[5:]
# print "cateUserId=" + str(cateUserId)
# print "myID=" + str(self.loginUser.userId)
if str(self.loginUser.userId) == cateUserId:
self.localTypeName = "user"
self.cateUserId = cateUserId
else:
self.addActionError(u"您不是id=" + str(cateUserId) + u"的用户")
return ActionResult.ERROR
elif self.itemType[0:5] == 'gres_':
#TODO: 检查当前用户是否是协作组的管理员
#print self.itemType
groupId = self.itemType[5:]
#print "groupId=" + str(groupId)
gmQuery = GroupMemberQuery(""" gm.groupId, gm.groupRole """)
gmQuery.userId = self.loginUser.userId
gmQuery.groupId = int(groupId)
group_list = gmQuery.query_map(1)
if group_list.size > 0:
self.localTypeName = "gres"
self.cateGroupId = int(groupId)
else:
self.addActionError(u"您不是id=" + str(cateUserId) + u"的群组管理员")
return ActionResult.ERROR
else:
# print self.itemType
self.addActionError("无效的参数")
return ActionResult.ERROR
# 调用分页函数.
pager = self.createPager()
pager.totalRows = query.count()
# 得到所有分类的列表.
cateList = query.query_map(pager)
# 传给页面.
request.setAttribute("category_list", cateList)
request.setAttribute("pager", pager)
# 将参数放到查询的页面.
request.setAttribute("parentId", query.parentId)
request.setAttribute("itemType", query.itemType)
request.setAttribute("type", self.localTypeName)
if query.parentId == '' or query.parentId == None:
request.setAttribute("parentparentId", "")
else:
pcategory = self.cate_svc.getCategory(int(query.parentId))
if pcategory == None:
request.setAttribute("parentparentId", "")
else:
request.setAttribute("parentparentId", pcategory.parentId)
# 返回到要显示的页面.
return self.CATEGORY_LIST
# 保存分类排序结果
def save(self):
cate_ids = self.params.getIdList("cateid")
nos = self.params.getIdList("orderNo")
if cate_ids == None or cate_ids.size() == 0:
self.addActionError(u"没有选择要操作的分类.")
return ActionResult.ERROR
if nos == None or nos.size() == 0:
self.addActionError(u"没有选择要操作的分类序号.")
return ActionResult.ERROR
iIndex = -1
for id in cate_ids:
iIndex = iIndex + 1
no = nos[iIndex]
#print "id=" + str(id) + " no=" + str(no)
category = self.cate_svc.getCategory(id)
if category == None:
self.addActionError(u"未能找到标识为 " + id + u" 的分类ￂￛ")
return ActionResult.ERROR
else:
self.cate_svc.setCategoryOrder(id, no)
self.parentId = self.params.getIntParamZeroAsNull("parentId")
self.itemType = self.params.getStringParam("type")
link = "?cmd=list&type=" + str(self.itemType) + "&parentId="
if self.parentId != None:
link += str(self.parentId)
self.addActionLink(u"返回", link)
return ActionResult.SUCCESS
# 创建并返回一个分页对象.
def createPager(self):
# 调用Java的函数.
pager = self.params.createPager()
pager.itemName = u"分类"
pager.itemUnit = u"个"
pager.pageSize = 20
return pager
# coding=utf-8
class admin_stat(BaseAdminAction, SubjectMixiner):
user_svc = __jitar__.userService
# 构造.
def __init__(self):
self.params = ParamUtil(request)
self.accessControlService = __spring__.getBean("accessControlService")
# 主执行入口.
def execute(self):
cmd = self.params.getStringParam("cmd")
if cmd == None or cmd == "":
cmd = "list"
result = self.dispatcher(cmd)
if not self.hasActionLinks():
self.addDefaultReturnActionLink()
return result
# 根据'cmd'进行派发.
def dispatcher(self, cmd):
# 必须要求登录
if self.loginUser == None:
return ActionResult.LOGIN
# 必须要求具有站点统计权限.
if self.isValidUserManager() == False:
self.addActionError(u"您不具有站点统计权限！")
return ActionResult.ERROR
if cmd == "list":
return self.list()
elif cmd == "stat":
return self.stat()
self.addActionError("未知命令: " + cmd)
return ActionResult.ERROR
# 列出所有与个人信息相关的统计信息
def list(self):
# 根据参数处理.
type = self.params.safeGetStringParam("type")
if type == None or type == "":
type = ""
request.setAttribute("type", type)
request.setAttribute("typeName", self.typeToTitle(type))
if type == "group":
return self.get_group_list(type)
else:
return self.user_list(type)
def user_list123(self):
hql = """SELECT new Map(u.userId as userId, u.loginName as loginName, u.trueName as trueName)
FROM User u
ORDER BY u.userId """
user_list = Command(hql).open(6)
request.setAttribute("userList", user_list)
return "/WEB-INF/ftl/admin/Admin_Stat_List_1.ftl"
# 列出统计列表.
def user_list(self, type):
# 根据用户传递的参数执行过滤.
pager = self.createPager()
qry = AdminUserQuery(""" u.userId, u.loginName, u.trueName, u.blogName,
u.subjectId, u.gradeId, u.unitId,
subj.subjectName, grad.gradeName, unit.unitName,
u.visitCount, u.myArticleCount, u.otherArticleCount, u.recommendArticleCount, u.articleCommentCount,
u.resourceCount, u.recommendResourceCount, u.resourceCommentCount, u.resourceDownloadCount,
u.createGroupCount, u.jionGroupCount, u.photoCount, u.userStatus """)
qry.userStatus = None
qry.kk = self.params.getStringParam("k")
qry.beginDate = self.params.getStringParam("beginDate")
qry.endDate = self.params.getStringParam("endDate")
qry.subjectId = self.params.getIntParamZeroAsNull("subjectId")
qry.f = self.params.getStringParam("f")
# 根据管理员等级设置过滤.
self.applyPrivFilter(self.loginUser, qry)
# 得到数据.
pager.totalRows = qry.count()
user_list = qry.query_map(pager)
# 赋值
request.setAttribute("pager", pager)
request.setAttribute("userList", user_list)
request.setAttribute("k", qry.kk)
request.setAttribute("beginDate", qry.beginDate)
request.setAttribute("endDate", qry.endDate)
request.setAttribute("f", qry.f)
request.setAttribute("subjectId", qry.subjectId)
self.putSubjectList()
self.putGradeList()
self.putUnitList()
return "/WEB-INF/ftl/admin/Admin_Stat_List.ftl"
# 导出到 Excel
def stat(self):
request.setCharacterEncoding("GB2312")
qry = AdminUserQuery(""" u.userId, u.loginName, u.trueName, u.blogName,
u.subjectId, u.gradeId, u.unitId,
subj.subjectName, grad.gradeName, unit.unitName,
u.visitCount, u.myArticleCount, u.otherArticleCount, u.recommendArticleCount, u.articleCommentCount,
u.resourceCount, u.recommendResourceCount, u.resourceCommentCount, u.resourceDownloadCount,
u.createGroupCount, u.jionGroupCount, u.photoCount, u.userStatus """)
qry.userStatus = None
qry.kk = self.params.getStringParam("k")
qry.subjectId = self.params.getIntParamZeroAsNull("subjectId")
qry.f = self.params.getStringParam("f")
user_list = qry.query_map(65535)
request.setAttribute("user_list", user_list)
response.reset()
response.setContentType("application/vnd.ms-excel")
response.setHeader("Content-Type",
"application/vnd.ms-excel; charset=GB2312")
response.addHeader("Content-Disposition",
"attachment; filename=stat.xls")
return "/WEB-INF/ftl/admin/Admin_Stat_Excel.ftl"
# 得到机构列表
def putUnitList(self):
from cn.edustar.jitar.service import UnitQueryParam
param = UnitQueryParam()
unit_list = __jitar__.unitService.getUnitList(param, None)
request.setAttribute("unit_list", unit_list)
# 创建用户管理所用的缺省分页对象.
def createPager(self):
pager = self.params.createPager()
pager.itemName = u"用户"
pager.itemUnit = u"个"
pager.pageSize = 20
return pager
# 得到指定标识的用户.
def getUserById(self, userId):
cmd = Command(""" FROM User u WHERE u.userId = :userId """)
cmd.setInteger("userId", userId)
user_list = cmd.open(1)
if user_list == None or user_list.size() == 0:
return None
return user_list[0]
# 从提交的参数中收集用户信息.
# 注意: 包括 userId, loginName, 如果调用者不需要用户提交这两个参数, 则需自己覆盖它的值.
def collectUserInfo(self):
params = self.params
userId = params.getIntParam("userId")
if userId != 0:
user = self.getUserById(userId)
if user == None:
self.addActionError(u"没有找到指定标识为 %d 的用户." % userId)
return None
else:
user = User()
user.userId = userId
user.loginName = params.getStringParam("loginName")
user.userIcon = params.getStringParam("userIcon", "images/default.gif")
user.nickName = params.getStringParam("nickName")
user.trueName = params.getStringParam("trueName")
user.email = params.getStringParam("email")
user.blogName = params.getStringParam("blogName")
user.userTags = params.getStringParam("userTags")
user.blogIntroduce = params.getStringParam("blogIntroduce")
user.gender = params.getIntParam("gender")
user.subjectId = params.getIntParamZeroAsNull("subjectId")
user.gradeId = params.getIntParamZeroAsNull("gradeId")
user.categoryId = params.getIntParamZeroAsNull("categoryId")
user.unitId = params.getIntParamZeroAsNull("unitId")
return user
# 把工作室分类放到 request 中.
def putUserCategories(self):
user_categories = __jitar__.categoryService.getCategoryTree('blog')
request.setAttribute("syscate_tree", user_categories)
# 标准的批处理初始化, 将所选中的用户标识做为任务.
def batcher_initer(self, batcher):
if self.loginUser == None:
batcher.result = ActionResult.LOGIN
return False
user_ids = self.params.getIdList("userId")
if user_ids == None or user_ids.size() == 0:
self.addActionError(u"没有选择要操作的用户.")
batcher.result = ActionResult.ERROR
return False
batcher.taskList = user_ids
return True
# 标准的批处理结束.
def batcher_finisher(self, batcher):
self.addActionMessage(u"共对 %d 个用户执行了%s操作." %
(batcher.count, batcher.operate))
batcher.result = ActionResult.SUCCESS
return True
# 检测是否有编辑指定用户信息的权限.
def can_edit_user(self, u):
# 必须登录.
if self.loginUser == None:
batcher.result = ActionResult.LOGIN
return None
# 可以自己编辑自己.
if u.userId == self.loginUser.userId:
return True
# 禁止其它人对 'admin' 进行操作, 否则可能导致管理员不能使用.
if self.accessControlService.isSystemAdmin(u):
self.addActionError(u"不能对系统管理员 admin 执行编辑操作.")
return False
return True
# 缺省的权限检测部分, 里面有权限业务.
def default_check_right(self, u, batcher):
# 必须登录.
if self.loginUser == None:
batcher.result = ActionResult.LOGIN
return None
# 必须有管理权限.
accessControlService = __spring__.getBean("accessControlService")
if accessControlService.getAllAccessControlByUser(
self.loginUser) != None:
self.addActionError(u"不具有用户管理权限")
return False
# 禁止其它人对 'admin' 进行操作, 否则可能导致管理员不能使用.self.accessControlService.isSystemAdmin(u)
if self.accessControlService.isSystemAdmin(u):
self.addActionError(u"不能对系统管理员(admin) 执行%s操作." % batcher.operate)
return False
elif u.loginName == self.loginUser.loginName:
# 不能对自己执行管理操作.
self.addActionError(u"不能对自己执行管理操作")
return False
return True
# 构造并返回一个标准用户管理任务执行器.
def createBatcher(self,
operate='执行操作',
check_logic=empty_func,
do_business=None):
# 获取数据步骤, 得到要操作的用户.
def get_data(userId, batcher):
u = self.getUserById(userId)
if u == None:
self.addActionError(u"未能找到指定标识为 %d 的用户." % userId)
return None
batcher.data = u
return u
# 记录日志.
def do_log(u, batcher):
batcher.count += 1
self.addActionMessage(u"对用户 %s 成功地执行了%s操作." %
(u.toDisplayString(), batcher.operate))
return
batcher = BusinessBatcher(initer=self.batcher_initer,
finisher=self.batcher_finisher)
batcher.result = ActionResult.ERROR
batcher.operate = operate
batcher.get_data = get_data
batcher.check_logic = check_logic
batcher.check_right = self.default_check_right
batcher.do_business = do_business
batcher.do_log = do_log
return batcher
# 根据传递的'type'参数得到其显示文字.
def typeToTitle(self, type):
if type == "group":
return u"站点群组统计"
#elif type == "subject":
#return "学科统计";
else:
return u"站点个人统计"
class usergroup(ActionExecutor):
# 构造.
def __init__(self):
self.params = ParamUtil(request)
self.ug_svc = __spring__.getBean("UGroupService")
self.up_svc = __spring__.getBean("UserPowerService")
self.user_svc = __jitar__.userService
return
# 根据'cmd'进行派发.
def dispatcher(self, cmd):
# 必须要求是登录用户和具有管理员的权限.
if self.loginUser == None:
return ActionResult.LOGIN
if self.canAdmin() == False:
self.addActionError(u"没有管理角色组的权限.")
return ActionResult.ERROR
# 根据cmd参数，执行相应的方法.
if cmd == "" or cmd == None or cmd == "list":
return self.List() # 列表显示
elif cmd == "delete":
return self.Delete() # 删除
elif cmd == "add":
return self.Add() # 增加
elif cmd == "edit":
return self.Edit() # 修改
elif cmd == "saveadd":
return self.Save() # 保存
elif cmd == "setupuser":
return self.SetupUser() # 设置组成员
elif cmd == "adduser":
return self.AddUser() # 设置组成员
elif cmd == "deleteuser":
return self.DeleteUser() # 删除组成员
elif cmd == "setuppower":
return self.SetupPower() # 设置组权限
elif cmd == "savepower":
return self.SavePower() # 保存组权限
elif cmd == "setcondition":
return self.SetCondition() # 设置组条件
elif cmd == "savecondition":
return self.SaveCondition() # 保存组条件
else:
self.addActionError(u"未知的命令参数：" + cmd)
return ActionResult.ERROR
# 列表显示.
def List(self):
userGroups = self.ug_svc.getUGroups()
# 传给页面.
request.setAttribute("userGroups", userGroups)
# 返回到要显示的页面.
return ADMIN_GROUPUSER_LIST
def SetCondition(self):
condition1list = self.up_svc.getUCondition1()
condition2list = self.up_svc.getUCondition2()
groups = self.up_svc.getUGroups()
if (groups == None):
self.addActionError(u"没有角色组,请先设置角色组")
return ActionResult.ERROR
if (condition1list == None):
request.setAttribute("scorenum", 0)
else:
request.setAttribute("scorenum", condition1list.size())
request.setAttribute("groups", groups)
request.setAttribute("condition1list", condition1list)
request.setAttribute("condition2list", condition2list)
return ADMIN_GROUPCONDITION_LIST
def SetupPower(self):
id = self.params.getIntParam("id")
if id == None or id == 0:
self.addActionError(u"没有选择角色组")
return ActionResult.ERROR
uGroup = self.ug_svc.getUGroup(id)
uGroupPower = self.up_svc.getUGroupPower(id)
uploadArticleNum = ""
uploadResourceNum = ""
uploadDiskNum = ""
videoConference = 0
if (uGroupPower != None):
uploadArticleNum = uGroupPower.uploadArticleNum
uploadResourceNum = uGroupPower.uploadResourceNum
uploadDiskNum = uGroupPower.uploadDiskNum
videoConference = uGroupPower.videoConference
request.setAttribute("id", id)
request.setAttribute("groupName", uGroup.groupName)
request.setAttribute("uploadArticleNum", uploadArticleNum)
request.setAttribute("uploadResourceNum", uploadResourceNum)
request.setAttribute("uploadDiskNum", uploadDiskNum)
request.setAttribute("videoConference", videoConference)
return ADMIN_GROUPPOWERSETUP_LIST
def SaveCondition(self):
#保存Condition1
num = self.params.getIntParam("num")
if (num == 0 or num == None):
self.addActionError(u"分数段")
return ActionResult.ERROR
#删除原来组中的自动用户(因为条件变了)
self.up_svc.DeleteUGroupUser(0)
i = 0
score1 = 0
score2 = 0
groupId = 0
condition1list = []
while i < num:
groupId = self.params.getIntParam("group1_" + str(i))
condition1 = UCondition1()
condition1.groupId = groupId
if (i == 0):
score2 = self.params.getIntParam("score_2_0")
score1 = score2
condition1.conditionType = -1
elif (i == (num - 1)):
score1 = self.params.getIntParam("score_1_" + str(i))
score2 = score1
condition1.conditionType = 1
else:
score1 = self.params.getIntParam("score_1_" + str(i))
score2 = self.params.getIntParam("score_2_" + str(i))
condition1.conditionType = 0
condition1.score1 = score1
condition1.score2 = score2
condition1list.append(condition1)
i += 1
self.up_svc.SaveUCondition1(condition1list)
#保存Condition2
condition2list = self.up_svc.getUCondition2()
for condition2 in condition2list:
condition2Id = condition2.id
groupId = self.params.getIntParam("group2_" + str(condition2Id))
condition2.groupId = groupId
self.up_svc.SaveUCondition2(condition2)
self.addActionMessage(u"操作成功！")
self.addActionLink(u"角色组管理", "?cmd=list")
return ActionResult.SUCCESS
def SavePower(self):
id = self.params.getIntParam("id")
if id == None or id == 0:
self.addActionError(u"缺少角色组id")
return ActionResult.ERROR
uploadArticleNum = self.params.getIntParam("uploadArticleNum")
uploadResourceNum = self.params.getIntParam("uploadResourceNum")
uploadDiskNum = self.params.getIntParam("uploadDiskNum")
videoConference = self.params.getIntParam("videoConference")
if (videoConference == None):
videoConference = "0"
uGroupPower = self.up_svc.getUGroupPower(id)
if (uGroupPower == None):
uGroupPower = UGroupPower()
uGroupPower.groupId = id
uGroupPower.uploadArticleNum = uploadArticleNum
uGroupPower.uploadResourceNum = uploadResourceNum
uGroupPower.uploadDiskNum = uploadDiskNum
uGroupPower.videoConference = videoConference
self.up_svc.SaveUGroupPower(uGroupPower)
self.addActionMessage(u"操作成功！")
self.addActionLink(u"角色组管理", "?cmd=list")
return ActionResult.SUCCESS
def Save(self):
id = self.params.getIntParam("id")
if id == None:
id = 0
groupName = self.params.getStringParam("groupName")
groupInfo = self.params.getStringParam("groupInfo")
if (groupName == None or groupName == ""):
self.addActionError(u"缺少角色组名称")
return ActionResult.ERROR
group = self.ug_svc.getUGroup(groupName)
if (group != None):
if (id == 0):
self.addActionError(u"该名称已经存在")
return ActionResult.ERROR
else:
if (id != group.groupId):
self.addActionError(u"该名称已经存在")
return ActionResult.ERROR
if (id == 0):
group = UGroup()
else:
group = self.ug_svc.getUGroup(id)
group.groupName = groupName
group.groupInfo = groupInfo
self.ug_svc.Save(group)
if (id == 0):
self.addActionMessage(u"增加成功！")
else:
self.addActionMessage(u"修改成功！")
self.addActionLink(u"角色组管理", "?cmd=list")
return ActionResult.SUCCESS
def DeleteUser(self):
userids = self.params.safeGetIntValues("id")
id = self.params.getIntParam("groupid")
if id == None:
self.addActionError(u"缺少角色组id")
return ActionResult.ERROR
for userId in userids:
#print "groupid=",id
#print "userId=",userId
ugroupuser = self.up_svc.FinduGroupUser(id, userId)
if ugroupuser != None:
self.up_svc.DeleteUGroupUser(ugroupuser)
#返回设置页面
uGroup = self.ug_svc.getUGroup(id)
groupuserlist = self.up_svc.getUGroupUser(id, 1)
request.setAttribute("groupName", uGroup.groupName)
request.setAttribute("id", id)
request.setAttribute("groupuserlist", groupuserlist)
return ADMIN_GROUPUSERSETUP_LIST
def AddUser(self):
#手工设置的特殊用户，如果已经存在，需要把managed设置为1
id = self.params.getIntParam("groupid")
if id == None:
self.addActionError(u"缺少角色组id")
return ActionResult.ERROR
invite_users = self.params.safeGetIntValues("inviteUserId")
str_error = ""
for invite_userId in invite_users:
user = self.user_svc.getUserById(invite_userId)
if user == None:
str_error = str_error + u"<li>用户" + user.trueName + "[" + str(
invite_userId) + u"]不是本系统存在的用户。</li>"
else:
ugroupuser = self.up_svc.FinduGroupUser(id, invite_userId)
if (ugroupuser == None):
ugroupuser = UGroupUser()
ugroupuser.managed = 1
ugroupuser.groupId = id
ugroupuser.userId = invite_userId
else:
ugroupuser.managed = 1
#更新用户
self.up_svc.SaveUGroupUser(ugroupuser)
if str_error != "":
self.addActionError(str_error)
return ActionResult.ERROR
#返回设置页面
uGroup = self.ug_svc.getUGroup(id)
if (uGroup == None):
self.addActionError(u"没有找到角色组")
return ActionResult.ERROR
groupuserlist = self.up_svc.getUGroupUser(id, 1)
request.setAttribute("groupName", uGroup.groupName)
request.setAttribute("id", id)
request.setAttribute("groupuserlist", groupuserlist)
return ADMIN_GROUPUSERSETUP_LIST
def SetupUser(self):
id = self.params.getIntParam("id")
if id == None:
self.addActionError(u"没有选择角色组")
return ActionResult.ERROR
uGroup = self.ug_svc.getUGroup(id)
if (uGroup == None):
self.addActionError(u"没有找到角色组")
return ActionResult.ERROR
groupuserlist = self.up_svc.getUGroupUser(id, 1)
request.setAttribute("groupName", uGroup.groupName)
request.setAttribute("id", id)
request.setAttribute("groupuserlist", groupuserlist)
return ADMIN_GROUPUSERSETUP_LIST
def Add(self):
request.setAttribute("groupName", "")
request.setAttribute("groupInfo", "")
request.setAttribute("id", 0)
return ADMIN_GROUPPOWERADD_LIST
def Edit(self):
id = self.params.getIntParam("id")
if id == None:
self.addActionError(u"没有选择角色组")
return ActionResult.ERROR
uGroup = self.ug_svc.getUGroup(id)
if uGroup == None:
self.addActionError(u"没有找到角色组")
return ActionResult.ERROR
request.setAttribute("groupName", uGroup.groupName)
request.setAttribute("groupInfo", uGroup.groupInfo)
request.setAttribute("id", id)
return ADMIN_GROUPPOWERADD_LIST
# 删除
def Delete(self):
ids = self.params.getIdList("id")
if ids == None or ids.size() == 0:
self.addActionError(u"没有选择角色组")
return ActionResult.ERROR
for Id in ids:
uGroup = self.ug_svc.getUGroup(Id)
#删除
self.up_svc.DeleteGroup(uGroup)
self.addActionMessage(u"删除成功！")
self.addActionLink(u"角色组管理", "?cmd=list")
return ActionResult.SUCCESS
class punish(ActionExecutor):
# 构造.
def __init__(self):
self.params = ParamUtil(request)
self.pun_svc = __jitar__.UPunishScoreService
return
# 根据'cmd'进行派发.
def dispatcher(self, cmd):
# 必须要求是登录用户和具有管理员的权限.
if self.loginUser == None:
return ActionResult.LOGIN
if self.canAdmin() == False:
self.addActionError(u"没有管理罚分的权限.")
return ActionResult.ERROR
# 根据cmd参数，执行相应的方法.
if cmd == "" or cmd == None or cmd == "list":
return self.List() # 列表显示
elif cmd == "delete":
return self.Delete() # 删除
else:
self.addActionError(u"未知的命令参数：" + cmd)
return ActionResult.ERROR
# 列表显示.
def List(self):
# 构造查询.
param = PunishQueryParam()
param.k = self.params.safeGetStringParam("k")
param.objType = self.params.safeGetStringParam("type")
# 调用分页函数.
pager = self.createPager()
print 'a'
punishList = self.pun_svc.getUPunishScoreList(param, pager)
print 'punishList=' + str(punishList == None)
# 传给页面.
request.setAttribute("punishList", punishList)
request.setAttribute("pager", pager)
request.setAttribute("objType", param.objType)
request.setAttribute("k", param.k)
# 返回到要显示的页面.
return ADMIN_PUNISH_LIST
# 创建并返回一个分页对象.
def createPager(self):
# 调用Java的函数.
pager = self.params.createPager()
pager.itemName = u"罚分"
pager.itemUnit = u"张"
pager.pageSize = 20
return pager
# 删除(放入回收站).
def Delete(self):
ids = self.params.getIdList("id")
if ids == None or ids.size() == 0:
self.addActionError(u"没有选择罚分")
return ActionResult.ERROR
for Id in ids:
punish = self.pun_svc.getUPunishScore(Id)
self.pun_svc.deleteUPunishScore(punish)
self.addActionMessage(u"操作成功！")
self.addActionLink(u"加、罚分管理", "?cmd=list")
return ActionResult.SUCCESS
class admin_photo(ActionExecutor):
# 构造.
def __init__(self):
self.params = ParamUtil(request)
self.photoService = __jitar__.photoService
self.categoryService = __jitar__.categoryService
self.photo_service = __spring__.getBean("photoStapleService")
self.pun_svc = __jitar__.UPunishScoreService
return
# 根据'cmd'进行派发.
def dispatcher(self, cmd):
# 必须要求是登录用户和具有管理员的权限.
if self.loginUser == None:
return ActionResult.LOGIN
accessControlService = __spring__.getBean("accessControlService")
if False == accessControlService.isSystemContentAdmin(self.loginUser):
self.addActionError(u"没有管理相册的权限.")
return ActionResult.ERROR
# 根据cmd参数，执行相应的方法.
if cmd == "" or cmd == None or cmd == "list":
return self.List() # 列表显示
elif cmd == "audit":
return self.Audit() # 审核通过
elif cmd == "unaudit":
return self.UnAudit() # 取消审核
elif cmd == "delete":
return self.Delete() # 删除(放入回收站)
elif cmd == "recycle_list":
return self.RecycleList() # 回收站列表
elif cmd == "crash":
return self.Crash() # 彻底删除
elif cmd == "recover":
return self.Recover() # 恢复
elif cmd == "privateShow": # 将选择的照片只在个人空间显示
return self.show()
else:
self.addActionError(u"未知的命令参数：" + cmd)
return ActionResult.ERROR
# 系统所有照片的列表显示.
def List(self):
# 构造查询.
query = self.queryString()
# 默认不过滤照片的审核与否.
query.auditState = None
# 照片的列表中不显示已经做了删除标志的照片.
query.delState = False
#显示照片不分是否是个人空间照片
query.isPrivateShow = None
# 查询关键字.
pshow = self.params.safeGetStringParam("isPrivateShow")
if pshow == "1":
query.isPrivateShow = True
elif pshow == "0":
query.isPrivateShow = False
query.k = self.params.safeGetStringParam("k")
query.f = self.params.safeGetStringParam("f")
query.sysCateId = self.params.getIntParamZeroAsNull("sc")
query.photoStaple = self.params.getIntParamZeroAsNull("ps")
self.putSysCategoryTree()
self.putPhotoStaple()
# TODO: 权限检查.
# 调用分页函数.
pager = self.createPager()
pager.totalRows = query.count()
# 得到所有照片的列表.
photoList = query.query_map(pager)
#print "photoList = ", photoList
# 传给页面.
request.setAttribute("pshow", pshow)
request.setAttribute("photoList", photoList)
request.setAttribute("pager", pager)
request.setAttribute("k", query.k)
request.setAttribute("f", query.f)
request.setAttribute("sc", query.sysCateId)
request.setAttribute("ps", query.photoStaple)
# 返回到要显示的页面.
return ADMIN_PHOTO_LIST
# 把文章分类树放置到 request 中.
def putSysCategoryTree(self):
syscate_tree = self.categoryService.getCategoryTree('photo')
request.setAttribute("syscate_tree", syscate_tree)
# 所有照片的分类列表.
def putPhotoStaple(self):
photoStapleList = self.photo_service.getPhotoStapleList()
request.setAttribute("photoStapleList", photoStapleList)
# 审核.
def Audit(self):
def check_logic(pu, batcher):
if pu.photo.auditState == Photo.AUDIT_STATE_OK:
self.addActionError(u"照片 %s 已经审核通过了, 没有再次执行审核操作." %
pu.photoDisplay())
return False
return True
# 业务操作.
def do_business(pu, *args):
self.photoService.auditPhoto(pu.photo)
return True
batcher = self.createBatcher(operate=u'审核通过',
do_business=do_business,
check_logic=check_logic)
if not batcher.execute():
return batcher.result
return ActionResult.SUCCESS
# 取消审核.
def UnAudit(self):
def check_logic(pu, batcher):
if pu.photo.auditState != Photo.AUDIT_STATE_OK:
self.addActionError(u"照片 %s 未通过审核, 没有再次执行审核操作." %
pu.photoDisplay())
return False
return True
# 业务操作.
def do_business(pu, *args):
self.photoService.unAuditPhoto(pu.photo)
return True
batcher = self.createBatcher(operate=u'取消审核',
do_business=do_business,
check_logic=check_logic)
if not batcher.execute():
return batcher.result
return ActionResult.SUCCESS
# 构造并返回一个标准资源管理任务执行器.
def createBatcher(self,
operate=u'执行操作',
do_business=None,
check_logic=empty_func):
# 获取数据步骤.
def get_data(photoId, batcher):
pu = self.getPhotoAndAuthor(photoId)
if pu == None:
self.addActionError(u"未能找到指定标识为 " + str(photoId) + u" 的照片")
return None
batcher.data = pu
return pu
# 记录日志.
def do_log(pu, batcher):
batcher.count += 1
self.addActionMessage(u"对照片 " + pu.photoDisplay() + u" 成功地执行了" +
batcher.operate + u"操作.")
return
batcher = BusinessBatcher(initer=self.batcher_initer,
finisher=self.batcher_finisher)
batcher.result = ActionResult.ERROR
batcher.cmd = self.params.getStringParam("cmd")
batcher.operate = operate
batcher.get_data = get_data
batcher.check_logic = check_logic
batcher.do_business = do_business
batcher.do_log = do_log
return batcher
# 标准的批处理初始化, 将所选中的资源标识做为任务.
def batcher_initer(self, batcher):
if self.loginUser == None:
batcher.result = ActionResult.LOGIN
return False
photo_ids = self.params.getIdList("photoId")
if photo_ids == None or photo_ids.size() == 0:
self.addActionError(u"没有选择要操作的照片.")
batcher.result = ActionResult.ERROR
return False
batcher.taskList = photo_ids
return True
# 标准的批处理结束.
def batcher_finisher(self, batcher):
self.addActionMessage(u"共对 " + str(batcher.count) + u" 张照片执行了" +
batcher.operate)
return True
def getPhotoAndAuthor(self, photoId):
cmd = Command(
"SELECT p, u FROM Photo p, User u WHERE p.userId = u.userId AND p.photoId = :photoId"
)
cmd.setInteger("photoId", photoId)
list = cmd.open(1)
if list == None or list.size() == 0:
return None
pu = list[0]
return PhotoAndUser(pu[0], pu[1])
# 包括 photo 和 user 两个对象的容器.
# 创建并返回一个分页对象.
def createPager(self):
# 调用Java的函数.
pager = self.params.createPager()
pager.itemName = u"图片"
pager.itemUnit = u"张"
pager.pageSize = 10
return pager
# 删除(放入回收站).
def Delete(self):
ids = self.params.getIdList("photoId")
if ids == None or ids.size() == 0:
self.addActionError(u"没有选择照片")
return ActionResult.ERROR
for photoId in ids:
photo = self.photoService.findById(photoId)
self.photoService.putIntoRecycle(photoId) # 放入回收站
upun = self.pun_svc.createUPunishScore(11, photoId, photo.userId,
self.loginUser.userId,
self.loginUser.trueName)
self.pun_svc.saveUPunishScore(upun)
self.addActionMessage(u"操作成功！")
self.addActionLink(u"相册后台管理", "?cmd=list")
self.addActionLink(u"相册回收站", "?cmd=recycle_list")
return ActionResult.SUCCESS
# privateShow
def show(self):
ids = self.params.getIdList("photoId")
if ids == None or ids.size() == 0:
self.addActionError(u"没有选择照片！")
return ActionResult.ERROR
for photoId in ids:
self.photoService.privateShow(photoId) # 放入回收站
self.addActionMessage(u"操作成功")
self.addActionLink(u"返回", "?cmd=list")
self.addActionLink(u"相册回收站", "?cmd=recycle_list")
return ActionResult.SUCCESS
# 回收站列表.
def RecycleList(self):
# 构造查询.
query = self.queryString()
# 默认不过滤照片的审核与否.
query.auditState = None
# 照片的列表中不显示已经做了删除标志的照片.
query.delState = True
query.isPrivateShow = None
# 调用分页函数.
pager = self.createPager()
pager.totalRows = query.count()
# 得到所有照片的列表.
photoList = query.query_map(pager)
# 传给页面.
request.setAttribute("photoList", photoList)
request.setAttribute("pager", pager)
# 返回到要显示的页面.
return ADMIN_PHOTO_RECYCLE_LIST
# 投影查询字段.
def queryString(self):
# 构造查询.
query = PhotoQuery(
""" p.photoId, p.title, p.summary, p.href, p.tags, stap.title as stapTitle,
sc.name as sysPhotoName, p.viewCount, p.createDate, p.addIp,
u.nickName, u.loginName, p.auditState, p.delState """
)
return query
# 从回收站中恢复删除的照片.
def Recover(self):
ids = self.params.getIdList("photoId")
if ids == None or ids.size() == 0:
self.addActionError(u"没有选择照片")
return ActionResult.ERROR
for photoId in ids:
self.photoService.recoverPhoto(photoId)
upun = self.pun_svc.getUPunishScore(11, photoId)
self.pun_svc.deleteUPunishScore(upun)
self.addActionMessage(u"恢复成功")
self.addActionLink(u"返回", "?cmd=recycle_list")
self.addActionLink(u"相册管理", "?cmd=list")
self.addActionLink(u"相册回收站", "?cmd=recycle_list")
return ActionResult.SUCCESS
def Crash(self):
ids = self.params.getIdList("photoId")
if ids == None or ids.size() == 0:
self.addActionError(u"没有选择照片")
return ActionResult.ERROR
groupService = __jitar__.groupService
for photoId in ids:
photo = self.photoService.findById(photoId)
if photo != None:
groupService.deleteGroupPhotoByPhoto(photo)
self.photoService.delPhoto(photo)
self.addActionMessage(u"彻底删除成功")
self.addActionLink(u"返回", "?cmd=recycle_list")
self.addActionLink(u"相册回收站", "?cmd=recycle_list")
return ActionResult.SUCCESS
class admin_Comment(ActionExecutor):
UNIT_LIST = "/WEB-INF/ftl/admin/comment_List.ftl"
# 构造.
def __init__(self):
self.params = ParamUtil(request)
self.cmt_svc = __jitar__.commentService
self.pun_svc = __jitar__.UPunishScoreService
self.msg_svc = __spring__.getBean("messageService")
return
# 根据'cmd'进行派发.
def dispatcher(self, cmd):
# 以下必须要求是登录用户和具有管理员的权限.
if self.loginUser == None: return ActionResult.LOGIN
accessControlService = __spring__.getBean("accessControlService")
if False == accessControlService.isSystemContentAdmin(self.loginUser):
ActionError(u"没有评论管理的权限.")
return ActionResult.ERROR
if cmd == "" or cmd == None:
cmd = "list1"
# 根据cmd参数，执行相应的方法.
if cmd == "list1":
return self.list(3) # 列表显示. 3--博文
elif cmd == "list2":
return self.list(12) # 列表显示. 12--资源
elif cmd == "delete":
return self.delete() # 删除
elif cmd == "audit":
return self.audit() # 审核通过
elif cmd == "unaudit":
return self.unaudit() # 取消审核
else:
self.addActionError(u"未知的命令参数：" + cmd)
return ActionResult.ERROR
# 系统所有机构的列表显示.
def list(self, objTypeValue):
# 构造查询.
request.setAttribute("type", objTypeValue)
if objTypeValue == 3:
query = AdminCommentQuery(
""" cmt.id, cmt.title, cmt.content, cmt.audit, cmt.createDate, cmt.userId, cmt.userName,
cmt.ip, cmt.star, cmt.objType, cmt.objId,
u.loginName, u.nickName, u.trueName, a.articleId as sourceId,a.title as sourceTitle,a.userId as sourceUserId,a.createDate as sourceCreateDate """
)
elif objTypeValue == 12:
query = AdminCommentQuery(
""" cmt.id, cmt.title, cmt.content, cmt.audit, cmt.createDate, cmt.userId, cmt.userName,
cmt.ip, cmt.star, cmt.objType, cmt.objId,
u.loginName, u.nickName, u.trueName, r.resourceId as sourceId,r.title as sourceTitle,r.userId as sourceUserId ,r.createDate as sourceCreateDate,r.href """
)
else:
objTypeValue = 3
query = AdminCommentQuery(
""" cmt.id, cmt.title, cmt.content, cmt.audit, cmt.createDate, cmt.userId, cmt.userName,
cmt.ip, cmt.star, cmt.objType, cmt.objId,
u.loginName, u.nickName, u.trueName, a.articleId as sourceId,a.title as sourceTitle,a.userId as sourceUserId,a.createDate as sourceCreateDate """
)
query.objType = objTypeValue
query.kk = self.params.getStringParam("k")
request.setAttribute("k", query.kk)
query.f = self.params.getStringParam("f")
request.setAttribute("f", query.f)
query.audit = None
# 调用分页函数.
pager = self.createPager()
pager.totalRows = query.count()
# 得到所有列表.
commentList = query.query_map(pager)
#print "unitList:", unitList
# 传给页面.
request.setAttribute("commentList", commentList)
request.setAttribute("pager", pager)
# 返回到要显示的页面.
return self.UNIT_LIST
# 审核通过所选的评论.
def audit(self):
ids = self.params.getIdList("commentId")
if ids == None or ids.size() == 0:
self.addActionError(u"没有选择评论")
return ActionResult.ERROR
oper_count = 0
for id in ids:
if id != None:
comment = self.cmt_svc.getComment(id)
if comment == None:
self.addActionError(u"未能找到标识为 " + id + u" 的评论ﾵￄￆￂￛ")
else:
self.cmt_svc.auditComment(comment)
oper_count = oper_count + 1
self.addActionMessage(u"共审核通过了 " + str(oper_count) + u" 条评论")
return ActionResult.SUCCESS
# 审核通过所选的评论.
def unaudit(self):
ids = self.params.getIdList("commentId")
if ids == None or ids.size() == 0:
self.addActionError(u"没有选择评论")
return ActionResult.ERROR
oper_count = 0
for id in ids:
if id != None:
comment = self.cmt_svc.getComment(id)
if comment == None:
self.addActionError(u"未能找到标识为 " + id + u" 的评论ﾵￄￆￂￛ")
self.cmt_svc.unauditComment(comment)
oper_count = oper_count + 1
self.addActionMessage(u"共 " + str(oper_count) + u" 条评论取消了审核")
return ActionResult.SUCCESS
# 删除.
def delete(self):
score = self.params.getIntParam("score")
reason = self.params.getStringParam("reason")
ids = self.params.getIdList("commentId")
if ids == None or ids.size() == 0:
self.addActionError(u"没有选择评论")
return ActionResult.ERROR
oper_count = 0
for id in ids:
if id != None:
comment = self.cmt_svc.getComment(id)
if comment != None:
if score == None:
upun = self.pun_svc.createUPunishScore(
16, comment.id, comment.userId,
self.loginUser.userId, self.loginUser.trueName)
else:
if score < 0:
upun = self.pun_svc.createUPunishScore(
16, comment.id, comment.userId, -1 * score,
reason, self.loginUser.userId,
self.loginUser.trueName)
else:
upun = self.pun_svc.createUPunishScore(
16, comment.id, comment.userId, score, reason,
self.loginUser.userId, self.loginUser.trueName)
self.pun_svc.saveUPunishScore(upun)
#消息通知
message = Message()
message.sendId = self.loginUser.userId
message.receiveId = comment.userId
message.title = u"管理员删除了您的评论及扣分信息"
if reason != "":
message.content = u"您的评论" + comment.title + u"被删除,扣" + str(
upun.score) + u"分,原因:" + reason
else:
message.content = u"您的评论" + comment.title + u"被删除,扣" + str(
upun.score) + u"分"
self.msg_svc.sendMessage(message)
self.cmt_svc.deleteComment(comment)
oper_count = oper_count + 1
self.addActionMessage(u"删除了" + str(oper_count) + u" 条评论")
type = self.params.getStringParam("type")
if type == "3":
self.addActionLink(
u"返回", "?cmd=list1&page=" + self.params.getStringParam("ppp"))
elif type == "12":
self.addActionLink(
u"返回", "?cmd=list2&page=" + self.params.getStringParam("ppp"))
else:
self.addActionLink(
u"返回", "?cmd=list1&page=" + self.params.getStringParam("ppp"))
#self.addActionLink(ActionLink.HISTORY_BACK);
return ActionResult.SUCCESS
# 创建并返回一个分页对象.
def createPager(self):
# 调用Java的函数.
pager = self.params.createPager()
pager.itemName = u"评论"
pager.itemUnit = u"个"
pager.pageSize = 10
return pager
class admin_resource(ActionExecutor, SubjectMixiner):
# 常量定义: Result Map for admin_resource.
RESOURCE_LIST = "/WEB-INF/ftl/admin/resource_list.ftl"
RECYCLE_LIST = "/WEB-INF/ftl/admin/resource_recycle_list.ftl"
RESOURCE_EDIT = "/WEB-INF/ftl/admin/Admin_Resource_Edit.ftl"
# 构造.
def __init__(self):
self.params = ParamUtil(request)
self.res_svc = __jitar__.resourceService
self.cate_svc = __jitar__.categoryService
self.pun_svc = __jitar__.UPunishScoreService
self.msg_svc = __spring__.getBean("messageService")
self.channelPageService = __spring__.getBean("channelPageService")
self.userService = __jitar__.userService
return
# 从 ActionExecutor 调用, 根据 cmd 进行不同处理.
def dispatcher(self, cmd):
# 必须要求登录和具有管理权限.
if self.loginUser == None:
return ActionResult.LOGIN
configService = __jitar__.configService
sys_config = configService.getConfigure()
if sys_config != None:
if sys_config["topsite_url"] != None and str(
sys_config["topsite_url"]).strip() != "":
request.setAttribute("topsite_url", "")
accessControlService = __spring__.getBean("accessControlService")
if False == accessControlService.isSystemContentAdmin(self.loginUser):
self.addActionError(u"您不具有资源管理权限, 或者您的信息填写不完整, 或未经系统管理员审核.")
return ActionResult.ERROR
if cmd == "list":
return self.list()
elif cmd == "audit":
return self.audit()
elif cmd == "unaudit":
return self.unaudit()
elif cmd == "rcmd":
return self.rcmd()
elif cmd == "unrcmd":
return self.unrcmd()
elif cmd == "delete":
return self.delete()
elif cmd == "move_cate":
return self.move_cate()
if cmd == "recycle_list":
return self.recycle_list()
elif cmd == "recover":
return self.recover()
elif cmd == "crash":
return self.crash()
elif cmd == "edit":
return self.edit()
elif cmd == "save":
return self.save()
elif cmd == "push":
return self.push()
elif cmd == "unpush":
return self.unpush()
self.addActionError(u"未知命令: " + cmd)
return ActionResult.ERROR
# 显示资源列表.
def list(self):
# 构造查询.
query = AdminResourceQuery(
""" r.resourceId, r.title, r.shareMode, r.createDate, r.href, r.subjectId, r.gradeId,
r.downloadCount, r.commentCount, r.fsize, r.auditState, r.recommendState, r.tags, r.addIp, r.pushState,r.publishToZyk,
u.userId, u.loginName, u.nickName, sc.name as sysCateName, subj.subjectName """
)
query.auditState = None
query.delState = False # 过滤被删除了的.
query.shareMode = None
# 根据参数设置过滤条件.
type = self.params.getStringParam("type")
request.setAttribute("type", type)
if type == "rcmd": # 推荐.
query.rcmdState = True
elif type == "unaudit": # 待审核.
query.auditState = Resource.AUDIT_STATE_WAIT_AUDIT
zyk = self.params.getStringParam("zyk")
#print "zyk=",zyk
query.publishToZyk = None
if (zyk != None and zyk != ""):
if zyk == "0":
query.publishToZyk = False
if zyk == "1":
query.publishToZyk = True
#print "query.publishToZyk=",query.publishToZyk
query.subjectId = self.params.getIntParamZeroAsNull("su")
request.setAttribute("su", query.subjectId)
query.gradeId = self.params.getIntParamZeroAsNull("gradeId")
request.setAttribute("gradeId", query.gradeId)
query.sysCateId = self.params.getIntParamZeroAsNull("sc")
request.setAttribute("sc", query.sysCateId)
query.kk = self.params.getStringParam("k")
request.setAttribute("k", query.kk)
query.f = self.params.getStringParam("f")
request.setAttribute("f", query.f)
request.setAttribute("zyk", zyk)
servletContext = request.getSession().getServletContext()
zyk_url = servletContext.getInitParameter("reslib_url")
request.setAttribute("zyk_url", zyk_url)
request.setAttribute("isHaszykUrl", "false")
if (zyk_url != None and zyk_url != ""):
request.setAttribute("isHaszykUrl", "true")
# 根据管理员权限再设置过滤条件.
#self.applyDocPrivFilter(self.loginUser, query)
# 计算总量.
pager = self.createPager()
pager.pageSize = 10
pager.totalRows = query.count()
# 得到资源.
resource_list = query.query_map(pager)
request.setAttribute("pager", pager)
request.setAttribute("resource_list", resource_list)
self.putSubjectList()
self.putGradeList()
self.putResourceCategoryTree()
return self.RESOURCE_LIST
# 编辑.
def edit(self):
# 得到参数.
resourceId = self.params.getIntParam("resourceId")
if resourceId == 0 or resourceId == None:
self.addActionError(u"未能找到指定标识为 %d 的资源。" % resourceId)
return ActionResult.ERROR
# 得到'resourceId'对应的'资源对象'
resource = self.res_svc.getResource(resourceId)
#x 代表来源,以利于返回(不同的模块调用本页面)
x = self.params.getIntParam("x")
request.setAttribute("x", x)
subId = self.params.getIntParam("subId")
request.setAttribute("subId", subId)
# 判断以外情况下的资源是否存在.
if resource == None:
self.addActionError(u"未能找到指定标识为 %d 的资源。" % resourceId)
return ActionResult.ERROR
# 将'资源对象'传给页面.
request.setAttribute("resource", resource)
# 系统资源分类
self.putResourceCategoryTree()
# 个人资源分类(系统管理员暂不修改用户个人的资源分类)
#self.putResourceUserCategory()
# 学科, 学段.
self.putSubjectList()
self.putGradeList()
return self.RESOURCE_EDIT
# 保存.
def save(self):
# 得到页面的 resourceId，如果出现网络问题或从地址栏非法输入而获得失败的，则提示'未找到...'
resourceId = self.params.getIntParam("resourceId")
#print "===resourceId===", resourceId
if resourceId == 0 or resourceId == None:
self.addActionError(u"未能找到指定标识为 %d 的资源。" % resourceId)
return ActionResult.ERROR
# 根据'resourceId'获得其对应的文章对象.
resource = self.res_svc.getResource(resourceId)
#print "===resource===", resource
# 设置新的数据.
self.setResource(resource)
# 检查资源的合法性.
if not self.checkResource(resource):
return ActionResult.ERROR
# 保存修改的资源.
self.res_svc.updateResource(resource)
#x 代表来源,以利于返回(不同的模块调用本页面)
x = self.params.getIntParam("x")
request.setAttribute("x", x)
subId = self.params.getIntParam("subId")
request.setAttribute("subId", subId)
self.addActionMessage(u"对资源 %d 成功地执行了'修改保存'操作." % resourceId)
self.addActionLink(u"返回", "javascript:history.go(-1)")
if x == 1:
self.addActionLink(u"资源管理",
"/subject/manage/resource.py?id=" + str(subId))
else:
self.addActionLink(u"资源管理", "?cmd=list")
return ActionResult.SUCCESS
# 修改资源对象.
def setResource(self, resource):
resource.title = self.params.getStringParam("title")
resource.sysCateId = self.params.getIntParamZeroAsNull("sysCateId")
resource.gradeId = self.params.getIntParamZeroAsNull("gradeId")
resource.subjectId = self.params.getIntParamZeroAsNull("subjectId")
resource.tags = self.params.getStringParam("tags")
resource.resTypeId = self.params.getIntParamZeroAsNull("restype")
resource.shareMode = self.params.getIntParam("shareMode")
resource.author = self.params.getStringParam("author")
resource.publisher = self.params.getStringParam("publisher")
resource.summary = self.params.getStringParam("summary")
return resource
# 验证资源的属性.
def checkResource(self, resource):
if resource.title.strip() == "":
self.addActionError(u"资源标题不能为空！")
return False
return True
# 审核通过所选的资源.
def audit(self):
def check_logic(ru, batcher):
if ru.resource.auditState == Resource.AUDIT_STATE_OK:
self.addActionError(u"资源 %s 已经审核通过了, 没有再次执行审核操作." %
ru.resDisplay())
return False
return True
# 业务部分.
def do_business(ru, batcher, *args):
self.res_svc.auditResource(ru.resource)
ru.resource.setUnitPathInfo(ru.resource.orginPathInfo)
ru.resource.setApprovedPathInfo(ru.resource.orginPathInfo)
self.res_svc.updateResource(ru.resource)
return True
# 审核通过选中的一个或多个资源.
batcher = self.createBatcher(operate=u'审核通过',
do_business=do_business,
check_logic=check_logic)
if not batcher.execute():
return batcher.result
return ActionResult.SUCCESS
# 推送所选的资源.
def push(self):
def check_logic(ru, batcher):
if ru.resource.auditState != Resource.AUDIT_STATE_OK:
self.addActionError(u"资源 %s 没有被审核, 不能进行推送操作." %
ru.resDisplay())
return False
if ru.resource.pushState == 1:
self.addActionError(u"资源 %s 已经被推送, 无需再次推送操作." %
ru.resDisplay())
return False
return True
# 业务部分.
def do_business(ru, batcher, *args):
ru.resource.setPushState(2)
ru.resource.setPushUserId(self.loginUser.userId)
self.res_svc.updateResource(ru.resource)
return True
# 审核通过选中的一个或多个资源.
batcher = self.createBatcher(operate=u'设置为推送',
do_business=do_business,
check_logic=check_logic)
if not batcher.execute():
return batcher.result
return ActionResult.SUCCESS
# 推送所选的资源.
def unpush(self):
def check_logic(ru, batcher):
if ru.resource.pushState == 1:
self.addActionError(u"资源 %s 已经被推送，不能进行取消推送操作." %
ru.resDisplay())
return False
if ru.resource.pushState == 0:
self.addActionError(u"资源 %s 没有设置为推送, 无需进行取消推送操作." %
ru.resDisplay())
return False
return True
# 业务部分.
def do_business(ru, batcher, *args):
ru.resource.setPushState(0)
ru.resource.setPushUserId(None)
self.res_svc.updateResource(ru.resource)
return True
# 审核通过选中的一个或多个资源.
batcher = self.createBatcher(operate=u'取消推送',
do_business=do_business,
check_logic=check_logic)
if not batcher.execute():
return batcher.result
return ActionResult.SUCCESS
# 取消审核所选的资源, 设置其审核状态为 WAIT_AUDIT.
def unaudit(self):
def check_logic(ru, batcher):
if ru.resource.auditState != Resource.AUDIT_STATE_OK:
self.addActionError(u"资源 %s 未审核通过, 没有再次执行取消审核操作." %
ru.resDisplay())
return False
return True
# 业务部分.
def do_business(ru, batcher, *args):
self.res_svc.unauditResource(ru.resource)
ru.resource.setApprovedPathInfo(None)
self.res_svc.updateResource(ru.resource)
#self.res_svc.unauditResource(ru.resource)
return True
# 取消审核选中的一个或多个资源.
batcher = self.createBatcher(operate=u'取消审核',
do_business=do_business,
check_logic=check_logic)
if not batcher.execute():
return batcher.result
return ActionResult.SUCCESS
# 推荐所选资源.
def rcmd(self):
def check_logic(ru, batcher):
if ru.resource.recommendState:
self.addActionError(u"资源 %s 已经是推荐资源了, 没有再次执行推荐操作." %
ru.resDisplay())
return False
return True
# 业务部分.
def do_business(ru, batcher, *args):
self.res_svc.rcmdResource(ru.resource)
ru.resource.setRcmdPathInfo(ru.resource.orginPathInfo)
self.res_svc.updateResource(ru.resource)
return True
# 推荐选中的一个或多个资源.
batcher = self.createBatcher(operate=u'推荐',
do_business=do_business,
check_logic=check_logic)
if not batcher.execute():
return batcher.result
return ActionResult.SUCCESS
# 取消推荐所选资源.
def unrcmd(self):
def check_logic(ru, batcher):
if ru.resource.recommendState == False:
self.addActionError(u"资源 %s 不是推荐资源, 没有执行取消推荐操作." %
ru.resDisplay())
return False
return True
# 业务部分.
def do_business(ru, batcher, *args):
self.res_svc.unrcmdResource(ru.resource)
ru.resource.setRcmdPathInfo(None)
self.res_svc.updateResource(ru.resource)
return True
# 取消推荐选中的一个或多个资源.
batcher = self.createBatcher(operate=u'取消推荐',
do_business=do_business,
check_logic=check_logic)
if not batcher.execute():
return batcher.result
return ActionResult.SUCCESS
# 设置资源所属资源类型.
def move_cate(self):
# 得到目标分类参数, 并验证该分类的正确性.
sysCateId = self.params.getIntParamZeroAsNull("sysCateId")
if sysCateId != None:
category = self.cate_svc.getCategory(sysCateId)
if category == None:
self.addActionError(u"指定标识的资源类型不存在.")
return ActionResult.ERROR
if category.itemType != 'resource':
self.addActionError(
u"指定标识的分类 %s 不是一个正确的资源类型, 请确定您是从有效链接提交的数据." %
category.name)
return ActionResult.ERROR
def check_logic(ru, batcher):
if ru.resource.sysCateId == sysCateId:
self.addActionError(u"资源 %s 类型已经是所选类型, 未进行设置新资源类型操作." %
ru.resDisplay())
return False
return True
# 业务部分.
def do_business(ru, batcher, *args):
self.res_svc.updateResourceSysCate(ru.resource, sysCateId)
return True
# 取消推荐选中的一个或多个资源.
batcher = self.createBatcher(operate=u'设置资源类型',
do_business=do_business,
check_logic=check_logic)
if not batcher.execute():
return batcher.result
return ActionResult.SUCCESS
# 删除所选的一个或多个资源.
def delete(self):
# 删除业务部分.
def do_business(ru, batcher, *args):
score = self.params.getIntParam("score")
reason = self.params.getStringParam("reason")
#print 'AAAAAAAAA'
if score == None:
upun = self.pun_svc.createUPunishScore(12, ru.resource.id,
ru.resource.userId,
score,
self.loginUser.userId,
self.loginUser.trueName)
else:
if score < 0:
upun = self.pun_svc.createUPunishScore(
12, ru.resource.id, ru.resource.userId, -1 * score,
reason, self.loginUser.userId, self.loginUser.trueName)
else:
upun = self.pun_svc.createUPunishScore(
12, ru.resource.id, ru.resource.userId, score, reason,
self.loginUser.userId, self.loginUser.trueName)
self.pun_svc.saveUPunishScore(upun)
#消息通知
message = Message()
message.sendId = self.loginUser.userId
message.receiveId = ru.resource.userId
message.title = u"管理员删除了您的资源及扣分信息"
if reason != "":
message.content = u"您的 " + ru.resource.title + u" 被删除,扣" + str(
upun.score) + u"分,原因:" + reason
else:
message.content = u"您的 " + ru.resource.title + u" 被删除,扣" + str(
upun.score) + u"分"
self.msg_svc.sendMessage(message)
self.res_svc.deleteResource(ru.resource)
return True
# 删除选中的一个或多个资源.
self.addActionLink(
u"返回", "?cmd=list&page=" + self.params.getStringParam("ppp"))
batcher = self.createBatcher(operate=u'删除', do_business=do_business)
if not batcher.execute():
return batcher.result
return ActionResult.SUCCESS
# 显示资源回收站.
def recycle_list(self):
# 构造查询.
query = ResourceQuery(
""" r.resourceId, r.title, r.shareMode, r.createDate, u.loginName, u.nickName, r.subjectId, r.gradeId,
r.href, r.downloadCount, r.commentCount, r.fsize, sc.name as sysCateName, subj.subjectName """
)
query.auditState = None
query.delState = True # 获得被删除的.
query.shareMode = None
query.subjectId = self.params.getIntParamZeroAsNull("su")
request.setAttribute("su", query.subjectId)
query.gradeId = self.params.getIntParamZeroAsNull("gradeId")
request.setAttribute("gradeId", query.gradeId)
query.sysCateId = self.params.getIntParamZeroAsNull("sc")
request.setAttribute("sc", query.sysCateId)
query.kk = self.params.getStringParam("k")
request.setAttribute("k", query.kk)
query.f = self.params.getStringParam("f")
request.setAttribute("f", query.f)
# 计算总量.
pager = self.createPager()
pager.totalRows = query.count()
# 得到资源.
resource_list = query.query_map(pager)
request.setAttribute("pager", pager)
request.setAttribute("resource_list", resource_list)
self.putSubjectList()
self.putGradeList()
self.putResourceCategoryTree()
return self.RECYCLE_LIST
# 彻底删除选中的资源.
def crash(self):
# 彻底删除业务部分.
def crash_business(ru, batcher, *args):
self.res_svc.crashResource(ru.resource)
return True
# 彻底删除选中的一个或多个资源.
batcher = self.createBatcher(operate=u'彻底删除操作',
do_business=crash_business)
if not batcher.execute():
return batcher.result
return ActionResult.SUCCESS
# 恢复选中的一个或多个资源.
def recover(self):
# 恢复操作的逻辑验证部分.
def recover_logic_checker(ru, batcher, *args):
if ru.resource.delState == False:
self.addActionError(u"资源 " + ru.resDisplay() +
u" 并未被删除, 因此不需进行" + batcher.operate + u".")
return False
return True
# 恢复操作的实际业务执行.
def recover_business(ru, batcher, *args):
self.res_svc.recoverResource(ru.resource)
upun = self.pun_svc.getUPunishScore(12, ru.resource.id)
self.pun_svc.deleteUPunishScore(upun)
return True
batcher = self.createBatcher(operate=u'恢复操作',
check_logic=recover_logic_checker,
do_business=recover_business)
if not batcher.execute():
return batcher.result
return ActionResult.SUCCESS
# 得到指定标识的资源和其拥有用户.
def getResourceAndAuthor(self, resourceId):
cmd = Command(
"SELECT r, u FROM Resource r, User u WHERE r.userId = u.userId AND r.resourceId = :resourceId"
)
cmd.setInteger("resourceId", resourceId)
list = cmd.open(1)
if list == None or list.size() == 0:
return None
ru = list[0]
return ResourceAndUser(ru[0], ru[1])
# --
# 检查是否对资源具有指定操作权限.
def default_check_right(self, ru, batcher):
# 检测能否操作该资源.
#if self.canManageResource(ru.user, ru.resource) == False:
# self.addActionError("不具有对资源 " + ru.resDisplay() + " 的操作权限, 可能其不属于您所管理的范围.")
# return False
return True
def createPager(self):
# private 构造资源的缺省 pager.
pager = self.params.createPager()
pager.itemName = u"资源"
pager.itemUnit = u"个"
return pager
# 构造并返回一个标准资源管理任务执行器.
def createBatcher(self,
operate=u'执行操作',
check_logic=empty_func,
do_business=None):
# 获取数据步骤.
def get_data(resourceId, batcher):
ru = self.getResourceAndAuthor(resourceId)
if ru == None:
self.addActionError(u"未能找到指定标识为 " + str(resourceId) + u" 的资源")
return None
batcher.data = ru
return ru
# 记录日志.
def do_log(ru, batcher):
batcher.count += 1
self.addActionMessage(u"对资源 " + ru.resDisplay() + u" 成功地执行了" +
batcher.operate + u"操作.")
return
batcher = BusinessBatcher(initer=self.batcher_initer,
finisher=self.batcher_finisher)
batcher.result = ActionResult.ERROR
batcher.cmd = self.params.getStringParam("cmd")
batcher.operate = operate
batcher.get_data = get_data
batcher.check_logic = check_logic
batcher.check_right = self.default_check_right
batcher.do_business = do_business
batcher.do_log = do_log
return batcher
# 标准的批处理初始化, 将所选中的资源标识做为任务.
def batcher_initer(self, batcher):
if self.loginUser == None:
batcher.result = ActionResult.LOGIN
return False
res_ids = self.params.getIdList("resourceId")
if res_ids == None or res_ids.size() == 0:
self.addActionError(u"没有选择要操作的资源.")
batcher.result = ActionResult.ERROR
return False
batcher.taskList = res_ids
return True
# 标准的批处理结束.
def batcher_finisher(self, batcher):
self.addActionMessage(u"共对 " + str(batcher.count) + u" 个资源执行了" +
batcher.operate + u".")
return True
# 把资源分类放到 request 环境中.
def putResourceCategoryTree(self):
resource_categories = self.cate_svc.getCategoryTree('resource')
request.setAttribute("resource_categories", resource_categories)
def putResourceUserCategory(self):
resource_user = self.cate_svc.getCategoryTree('user_res_1')
request.setAttribute("resource_user", resource_user)
def putChannelResourceCategoryTree(self, res):
if res.userId == None: return
resUser = self.userService.getUserById(res.userId)
if resUser.channelId != None:
channel = self.channelPageService.getChannel(resUser.channelId)
if channel == None: return
channel_resource_categories = self.cate_svc.getCategoryTree(
"channel_resource_" + str(resUser.channelId))
request.setAttribute("channel_resource_categories",
channel_resource_categories)
class admin_article (ActionExecutor, SubjectMixiner):
# 常量定义.
ARTICLE_LIST = "/WEB-INF/ftl/admin/article_list.ftl"
ARTICLE_EDIT = "/WEB-INF/ftl/admin/article_edit.ftl"
ARTICLE_RECYCLE_LIST = "/WEB-INF/ftl/admin/article_recycle_list.ftl"
def __init__(self):
self.params = ParamUtil(request)
self.art_svc = __jitar__.articleService
self.cate_svc = __jitar__.categoryService
self.pun_svc = __jitar__.UPunishScoreService
self.cfg_svc = __spring__.getBean('configService')
self.msg_svc = __spring__.getBean("messageService")
self.channelPageService = __spring__.getBean("channelPageService")
self.userService = __jitar__.userService
self.specialSubjectService = __spring__.getBean("specialSubjectService")
return
def dispatcher(self, cmd):
# 必须要求登录和具有管理权限.
if self.loginUser == None:
return ActionResult.LOGIN
accessControlService = __spring__.getBean("accessControlService")
if False == accessControlService.isSystemContentAdmin(self.loginUser):
self.addActionError(u"您不具有文章管理权限, 或者您的信息填写不完整, 或未经系统管理员审核.")
return ActionResult.ERROR
if cmd == "list":
return self.list()
elif cmd == "edit":
return self.edit()
elif cmd == "recycle_list":
return self.recycle_list()
elif cmd == "audit":
return self.audit()
elif cmd == "unaudit":
return self.unaudit()
elif cmd == "rcmd":
return self.rcmd()
elif cmd == "unrcmd":
return self.unrcmd()
elif cmd == "best":
return self.best()
elif cmd == "unbest":
return self.unbest()
elif cmd == "valid":
return self.valid()
elif cmd == "invalid":
return self.invalid()
elif cmd == "delete":
return self.delete()
elif cmd == "recover":
return self.recover()
elif cmd == "crash":
return self.crash()
elif cmd == "save":
return self.save()
elif cmd == "move":
return self.moveCate()
elif cmd == "push":
return self.push()
elif cmd == "unpush":
return self.unpush()
self.addActionError(u"未知命令: " + cmd)
return ActionResult.ERROR
# 列出待管理的文章.
def list(self):
configService = __jitar__.configService
sys_config = configService.getConfigure()
if sys_config != None:
if sys_config["topsite_url"] != None and str(sys_config["topsite_url"]).strip() != "":
request.setAttribute("topsite_url", "")
# 构造查询.
query = self.createQuery()
query.delState = False # 过滤被删除了的.
# 根据参数设置过滤条件.
type = self.params.getStringParam("type")
request.setAttribute("type", type)
if type == 'best': # 精华.
query.bestState = True
elif type == 'rcmd': # 推荐.
query.rcmdState = True
elif type == 'unaudit': # 待审核.
query.auditState = Article.AUDIT_STATE_WAIT_AUDIT
query.subjectId = self.params.getIntParamZeroAsNull("su")
request.setAttribute("su", query.subjectId)
query.gradeId = self.params.getIntParamZeroAsNull("gradeId")
request.setAttribute("gradeId", query.gradeId)
query.sysCateId = self.params.getIntParamZeroAsNull("sc")
request.setAttribute("sc", query.sysCateId)
query.kk = self.params.getStringParam("k")
request.setAttribute("k", query.kk)
query.f = self.params.getStringParam("f")
request.setAttribute("f", query.f)
# 根据管理员权限再设置过滤条件.
#self.applyDocPrivFilter(self.loginUser, query)
# 构造分页对象并计算总量.
pager = self.createPager()
pager.totalRows = query.count()
# 得到文章列表.
article_list = query.query_map(pager)
request.setAttribute("pager", pager)
request.setAttribute("article_list", article_list)
self.putSubjectList()
self.putGradeList()
self.putArticleCategoryTree()
return self.ARTICLE_LIST
# 编辑一篇文章(可能是他人的).
def edit(self):
# 得到参数.
articleId = self.params.getIntParam("articleId")
if articleId == 0:
self.addActionError(u"未给出要编辑的文章标识.")
return ActionResult.ERROR
article = self.art_svc.getArticle(articleId)
if article == None:
self.addActionError(u"未能找到指定标识为 %d 的文章." % articleId)
return ActionResult.ERROR
# 管理员修改模式下.
request.setAttribute("manageMode", "admin")
request.setAttribute("article", article)
request.setAttribute("instance", self)
self.putSubjectList()
self.putGradeList()
self.putArticleCategoryTree()
ss = self.specialSubjectService.getValidSpecialSubjectList()
if ss != None:
request.setAttribute("specialsubject_list", ss)
specialSubjectArticle = self.specialSubjectService.getSpecialSubjectArticleByArticleId(article.objectUuid)
if specialSubjectArticle == None:
request.setAttribute("specialSubjectId", 0)
else:
request.setAttribute("specialSubjectId", specialSubjectArticle.specialSubjectId)
return self.ARTICLE_EDIT
# 保存.
def save(self):
# 得到页面的 articleId，如果出现网络问题或从地址栏非法输入而获得失败的，则提示'未找到...'
articleId = self.params.getIntParam("articleId")
if articleId == 0 or articleId == None:
self.addActionError(u"未能找到指定标识为 %d 的文章。" % articleId)
return ActionResult.ERROR
# 根据'articleId'获得其对应的文章对象.
article = self.art_svc.getArticle(articleId)
# 设置新的数据.
self.setArticle(article)
# 检查文章的合法性.
if not self.checkArticle(article):
return ActionResult.ERROR
# 保存
self.art_svc.updateArticle(article);
# 处理专题文章、自定义频道文章
specialSubjectId = self.params.safeGetIntParam("specialSubjectId")
channelId = self.params.safeGetIntParam("channelId")
specialSubjectArticle = self.specialSubjectService.getSpecialSubjectArticleByArticleId(article.objectUuid)
if specialSubjectArticle != None:
if specialSubjectId == 0 or specialSubjectId == None:
self.specialSubjectService.deleteSubjectArticleByArticleGuid(article.objectUuid)
else:
specialSubjectArticle.setSpecialSubjectId(specialSubjectId)
specialSubjectArticle.setTitle(article.title)
self.specialSubjectService.saveOrUpdateSpecialSubjectArticle(specialSubjectArticle)
if channelId > 0:
channelArticle = self.channelPageService.getChannelArticle(article.objectUuid)
if channelArticle != None:
channelArticle.setTitle(article.title)
if self.params.safeGetStringParam("channelCate") == "":
channelArticle.setChannelCate(None)
else:
channelArticle.setChannelCate(self.params.safeGetStringParam("channelCate"))
self.channelPageService.saveOrUpdateChannelArticle(channelArticle)
self.addActionMessage(u"对文章 %d 成功地执行了'修改保存'操作." % articleId)
self.addActionLink(u"返回", "javascript:history.go(-1)")
self.addActionLink(u"文章管理", "?cmd=list")
return ActionResult.SUCCESS
# 修改文章对象.
def setArticle(self, article):
article.title = self.params.getStringParam("articleTitle")
article.articleContent = self.params.getStringParam("articleContent")
article.articleAbstract = self.params.getStringParam("articleAbstract")
article.articleTags = self.params.getStringParam("articleTags")
article.subjectId = self.params.getIntParamZeroAsNull("subjectId")
#article.userCate = self.params.getIntParamZeroAsNull("userCate") 系统管理员不能修改别人的'个人分类'
article.sysCateId = self.params.getIntParamZeroAsNull("sysCate")
article.draftState = self.params.getBooleanParam("draftState")
article.commentState = self.params.getBooleanParam("commentState") # 评论
article.hideState = self.params.getIntParam("hideState") # 隐藏
article.recommendState = self.params.getBooleanParam("rcmd") # 推荐
audit = self.params.getStringParam("audit") # 审核
if audit == None or audit == "":
article.auditState = 1 #未审核
else:
article.auditState = 0 #通过
article.bestState = self.params.getBooleanParam("best") # 精华
#article.articlePassword = self.params.getStringParam("articlePassword", "")
article.gradeId = self.params.getIntParamZeroAsNull("gradeId")
article.typeState = self.params.getBooleanParam("articleType")
return article
# 验证文章的标题.
def checkArticle(self, article):
if article.title.strip() == "":
self.addActionError(u"文章标题不能为空！")
return False
return True
# 文章回收站列表.
def recycle_list(self):
# 构造查询.
query = self.createQuery()
query.delState = True # 过滤被删除了的.
query.draftState = None
query.subjectId = self.params.getIntParamZeroAsNull("su")
request.setAttribute("su", query.subjectId)
query.gradeId = self.params.getIntParamZeroAsNull("gradeId")
request.setAttribute("gradeId", query.gradeId)
query.sysCateId = self.params.getIntParamZeroAsNull("sc")
request.setAttribute("sc", query.sysCateId)
query.kk = self.params.getStringParam("k")
request.setAttribute("k", query.kk)
query.f = self.params.getStringParam("f")
request.setAttribute("f", query.f)
# 构造分页对象并计算总量.
pager = self.createPager()
pager.totalRows = query.count()
# 得到文章列表.
article_list = query.query_map(pager)
request.setAttribute("pager", pager)
request.setAttribute("article_list", article_list)
self.putSubjectList()
self.putGradeList()
self.putArticleCategoryTree()
return self.ARTICLE_RECYCLE_LIST
# 审核通过所选文章.
def audit(self):
def check_logic(au, batcher):
# 验证逻辑: 已经审核的不再次审核; 删除了的，未发布的草稿，非法文章不能进行审核.
if au.article.auditState == Article.AUDIT_STATE_OK:
self.addActionError(u"文章 %s 已经审核通过了, 没有再次执行审核操作." % au.artDisplay())
return False
if au.article.delState:
self.addActionError(u"文章 %s 被删除了, 其不能进行审核操作." % au.artDisplay())
return False
if au.article.draftState:
self.addActionError(u"文章 %s 是未发布的草稿, 其不能进行审核操作." % au.artDisplay())
return False
return True
# 业务部分.
def do_business(au, batcher, *args):
#管理员直接全部审核
au.article.setUnitPathInfo(au.article.orginPath)
au.article.setApprovedPathInfo(au.article.orginPath)
self.art_svc.updateArticle(au.article)
self.art_svc.auditArticle(au.article)
return True
# 审核通过选中的一个或多个文章.
batcher = self.createBatcher(operate=u"审核通过", do_business=do_business,
check_logic=check_logic)
if not batcher.execute():
return batcher.result
return ActionResult.SUCCESS
# 取消所选文章的审核.
def unaudit(self):
def check_logic(au, batcher):
# 验证逻辑: 未审核通过的不用进行操作.
if au.article.auditState != Article.AUDIT_STATE_OK:
self.addActionError(u"文章 %s 未通过审核, 不需要进行取消审核." % au.artDisplay())
return False
return True
# 业务部分.
def do_business(au, batcher, *args):
au.article.setUnitPathInfo("/" + str(au.article.unitId) + "/")
au.article.setApprovedPathInfo(None)
self.art_svc.updateArticle(au.article)
self.art_svc.unauditArticle(au.article)
return True
# 取消审核选中的一个或多个文章.
batcher = self.createBatcher(operate=u"取消审核", do_business=do_business,
check_logic=check_logic)
if not batcher.execute():
return batcher.result
return ActionResult.SUCCESS
# 推荐所选文章.
def rcmd(self):
def check_logic(au, batcher):
# 验证逻辑: 未通过审核的不能推荐; 非法文章不能推荐.
if au.article.recommendState:
self.addActionError(u"文章 %s 已经是推荐文章了, 不需要进行设置推荐操作." % au.artDisplay())
return False
if au.article.auditState != Article.AUDIT_STATE_OK:
self.addActionError(u"文章 %s 未通过审核, 不能设置为推荐文章." % au.artDisplay())
return False
return True
# 业务部分.
def do_business(au, batcher, *args):
au.article.setRcmdPathInfo(au.article.orginPath)
self.art_svc.updateArticle(au.article)
self.art_svc.rcmdArticle(au.article)
return True
batcher = self.createBatcher(operate=u"设为推荐", do_business=do_business,
check_logic=check_logic)
if not batcher.execute():
return batcher.result
return ActionResult.SUCCESS
# 取消推荐所选文章.
def unrcmd(self):
def check_logic(au, batcher):
# 验证逻辑: 不是推荐的不用操作.
if au.article.recommendState == False:
self.addActionError(u"文章 %s 不是推荐文章, 不需要进行取消推荐操作." % au.artDisplay())
return False
return True
# 业务部分.
def do_business(au, batcher, *args):
#self.art_svc.unrcmdArticle(au.article)
au.article.setRcmdPathInfo(None)
au.article.setRecommendState(False)
self.art_svc.updateArticle(au.article)
return True
batcher = self.createBatcher(operate=u"取消推荐", do_business=do_business,
check_logic=check_logic)
if not batcher.execute():
return batcher.result
return ActionResult.SUCCESS
# 推送文章
def push(self):
def check_logic(au, batcher):
# 验证逻辑: 未通过审核的不能推荐; 非法文章不能推荐.
if au.article.auditState != Article.AUDIT_STATE_OK:
self.addActionError(u"文章 %s 还未被审核, 不能进行推送." % au.artDisplay())
return False
if au.article.pushState == 1:
self.addActionError(u"文章 %s 已经是被推送了, 不需要进行设置操作." % au.artDisplay())
return False
return True
# 业务部分.
def do_business(au, batcher, *args):
au.article.setPushState(2)
au.article.setPushUserId(self.loginUser.userId)
self.art_svc.updateArticle(au.article)
return True
batcher = self.createBatcher(operate=u"设为推送", do_business=do_business,
check_logic=check_logic)
if not batcher.execute():
return batcher.result
return ActionResult.SUCCESS
# 取消推送文章，只能取消待推送的，已经完成的无法取消
def unpush(self):
def check_logic(au, batcher):
# 验证逻辑: 未通过审核的不能推荐; 非法文章不能推荐.
if au.article.pushState == 1:
self.addActionError(u"文章 %s 已经是被推送了, 不能进行取消操作." % au.artDisplay())
return False
if au.article.pushState == 0:
self.addActionError(u"文章 %s 还没有设置推送, 不需要进行取消推送." % au.artDisplay())
return False
return True
# 业务部分.
def do_business(au, batcher, *args):
au.article.setPushState(0)
au.article.setPushUserId(None)
self.art_svc.updateArticle(au.article)
return True
batcher = self.createBatcher(operate=u"取消推送", do_business=do_business,
check_logic=check_logic)
if not batcher.execute():
return batcher.result
return ActionResult.SUCCESS
# 设置为精华.
def best(self):
def check_logic(au, batcher):
# 验证逻辑: 未通过审核的不能推荐; 非法文章不能推荐.
if au.article.bestState:
self.addActionError(u"文章 %s 已经是精华文章了, 不需要进行设置精华操作." % au.artDisplay())
return False
if au.article.auditState != Article.AUDIT_STATE_OK:
self.addActionError(u"文章 %s 未通过审核, 不能设置为精华文章." % au.artDisplay())
return False
return True
# 业务部分.
def do_business(au, batcher, *args):
self.art_svc.bestArticle(au.article)
return True
batcher = self.createBatcher(operate=u"设为精华", do_business=do_business,
check_logic=check_logic)
if not batcher.execute():
return batcher.result
return ActionResult.SUCCESS
# 取消精华.
def unbest(self):
def check_logic(au, batcher):
# 验证逻辑.
if au.article.bestState == False:
self.addActionError(u"文章 %s 不是精华文章, 不需要进行取消精华操作." % au.artDisplay())
return False
return True
# 业务部分.
def do_business(au, batcher, *args):
self.art_svc.unbestArticle(au.article)
return True
batcher = self.createBatcher(operate=u"取消精华", do_business=do_business,
check_logic=check_logic)
if not batcher.execute():
return batcher.result
return ActionResult.SUCCESS
# 设置为合法文章.
def valid(self):
def check_logic(au, batcher):
return True
# 业务部分.
def do_business(au, batcher, *args):
self.art_svc.validArticle(au.article)
return True
batcher = self.createBatcher(operate=u"设为合法", do_business=do_business,
check_logic=check_logic)
if not batcher.execute():
return batcher.result
return ActionResult.SUCCESS
# 设置为非法文章.
def invalid(self):
def check_logic(au, batcher):
return True
# 业务部分.
def do_business(au, batcher, *args):
self.art_svc.invalidArticle(au.article)
return True
batcher = self.createBatcher(operate=u"设为非法文章", do_business=do_business,
check_logic=check_logic)
if not batcher.execute():
return batcher.result
return ActionResult.SUCCESS
# 删除文章.
def delete(self):
def check_logic(au, batcher):
if au.article.delState:
self.addActionError(u"文章 %s 已经删除, 不需要再次进行删除操作." % au.artDisplay())
return False
return True
# 业务部分.
def do_business(au, batcher, *args):
self.art_svc.deleteArticle(au.article)
score = self.params.getIntParam("score")
reason = self.params.getStringParam("reason")
if score == None:
upun = self.pun_svc.createUPunishScore(3, au.article.id, au.article.userId,self.loginUser.userId,self.loginUser.trueName)
else:
if score<0 :
upun = self.pun_svc.createUPunishScore(3, au.article.id, au.article.userId, -1*score, reason,self.loginUser.userId,self.loginUser.trueName)
else:
upun = self.pun_svc.createUPunishScore(3, au.article.id, au.article.userId, score, reason,self.loginUser.userId,self.loginUser.trueName)
self.pun_svc.saveUPunishScore(upun)
#消息通知
message = Message()
message.sendId = self.loginUser.userId
message.receiveId = au.article.userId
message.title = u"管理员删除了您的文章及扣分信息"
if reason != "":
message.content = u"您的 " + au.article.title + u" 被删除,扣" + str(upun.score) + u"分,原因:" + reason
else:
message.content = u"您的 " + au.article.title + u" 被删除,扣" + str(upun.score) + u"分"
self.msg_svc.sendMessage(message)
return True
self.addActionLink(u"返回", "?cmd=list&page=" + self.params.getStringParam("ppp"))
batcher = self.createBatcher(operate=u"删除", do_business=do_business,
check_logic=check_logic)
if not batcher.execute():
return batcher.result
return ActionResult.SUCCESS
# 恢复文章.
def recover(self):
def check_logic(au, batcher):
if au.article.delState == False:
self.addActionError(u"文章 %s 未被删除, 不能进行恢复操作." % au.artDisplay())
return False
return True
# 业务部分.
def do_business(au, batcher, *args):
self.art_svc.recoverArticle(au.article)
upun = self.pun_svc.getUPunishScore(3, au.article.id)
if upun != None:
self.pun_svc.deleteUPunishScore(upun)
return True
batcher = self.createBatcher(operate=u"恢复", do_business=do_business,
check_logic=check_logic)
if not batcher.execute():
return batcher.result
return ActionResult.SUCCESS
# 彻底删除文章.
def crash(self):
def check_logic(au, batcher):
if au.article.delState == False:
self.addActionError(u"文章 %s 未在回收站中, 不能进行彻底删除操作." % au.artDisplay())
return False
return True
# 业务部分.
def do_business(au, batcher, *args):
self.art_svc.crashArticle(au.article)
return True
batcher = self.createBatcher(operate=u"彻底删除", do_business=do_business,
check_logic=check_logic)
if not batcher.execute():
return batcher.result
return ActionResult.SUCCESS
# 创建后台管理中使用的查询对象.
def createQuery(self):
# 构造查询.
query = AdminArticleQuery(""" a.articleId, a.title, a.createDate, a.addIp, a.articleContent, a.subjectId, a.gradeId,
a.lastModified, a.auditState, a.bestState, a.recommendState, a.hideState, a.typeState,a.pushState,
u.loginName, u.nickName, subj.subjectName, sc.name as sysCateName """)
query.auditState = None
query.bestState = None
query.rcmdState = None
query.hideState = None
query.draftState = False # 还是草稿的归用户管理.
#query.custormAndWhereClause = "(a.orginPath LIKE '%/" + str(self.loginUser.unitId) + "/%')"
return query
# 根据当前页面参数构造一个文章管理使用的分页对象.
def createPager(self):
# private 构造文章的缺省 pager.
pager = self.params.createPager()
pager.itemName = u"文章"
pager.itemUnit = u"篇"
pager.pageSize = 10
return pager
# 检查是否对文章具有指定操作权限.
def default_check_right(self, au, batcher):
# 检测能否操作该文章.
#if self.canManageArticle(au.user, au.article) == False:
# self.addActionError("不具有对文章 " + au.artDisplay() + " 的操作权限, 可能其不属于您所管理的范围.")
# return False
return True
# 得到指定标识的文章及其作者的信息.
def getArticleAndAuthor(self, articleId):
cmd = Command("SELECT a, u FROM Article a, User u WHERE a.userId = u.userId AND a.articleId = :articleId")
cmd.setInteger("articleId", articleId)
list = cmd.open(1)
if list == None or list.size() == 0:
return None
au = list[0]
return ArticleAndUser(au[0], au[1])
def createBatcher(self, operate= u"执行操", check_logic=empty_func, do_business=None):
# 获取数据步骤.
def get_data(articleId, batcher):
au = self.getArticleAndAuthor(articleId)
if au == None:
self.addActionError(u"未能找到指定标识为 %d 的文章." % articleId)
return None
batcher.data = au
return au;
# 记录日志.
def do_log(au, batcher):
batcher.count += 1
self.addActionMessage(u"对文章 %s 成功地执行了%s操作." % (au.artDisplay(), batcher.operate))
return
batcher = BusinessBatcher(initer=self.batcher_initer,
finisher=self.batcher_finisher)
batcher.result = ActionResult.ERROR
batcher.cmd = self.params.getStringParam("cmd")
batcher.operate = operate
batcher.get_data = get_data
batcher.check_logic = check_logic
batcher.check_right = self.default_check_right
batcher.do_business = do_business
batcher.do_log = do_log
return batcher
# 标准的批处理初始化, 将所选中的文章标识做为任务.
def batcher_initer(self, batcher):
if self.loginUser == None:
batcher.result = ActionResult.LOGIN
return False
art_ids = self.params.getIdList("articleId")
if art_ids == None or art_ids.size() == 0:
self.addActionError(u"没有选择要操作的文章.")
batcher.result = ActionResult.ERROR
return False
batcher.taskList = art_ids
return True
# 标准的批处理结束.
def batcher_finisher(self, batcher):
self.addActionMessage(u"共对 " + str(batcher.count) + u"个文章执行了"+ batcher.operate + u"操作.")
return True
# 把文章分类树放置到 request 中.
def putArticleCategoryTree(self):
article_categories = self.cate_svc.getCategoryTree('default')
request.setAttribute("article_categories", article_categories)
# 把四名工程文章分类树放置到 request 中.
def putChannelArticleCategoryTree(self,art):
if art.userId == None:return
articleUser = self.userService.getUserById(art.userId)
if articleUser.channelId != None:
channel = self.channelPageService.getChannel(articleUser.channelId)
if channel == None:return
channel_article_categories = self.cate_svc.getCategoryTree("channel_article_" + str(articleUser.channelId))
request.setAttribute("channel_article_categories", channel_article_categories)
# 设置文章分类.
def moveCate(self):
# 得到目标分类参数, 并验证该分类的正确性.
sysCateId = self.params.getIntParamZeroAsNull("sysCateId")
#print sysCateId
if sysCateId != None:
category = self.cate_svc.getCategory(sysCateId)
if category == None:
self.addActionError(u"指定标识的文章分类不存在.")
return ActionResult.ERROR
#if category.itemType != 'article':
#self.addActionError("指定标识的分类 %s 不是一个正确的文章分类, 请确定您是从有效链接提交的数据." % category.name)
#return ActionResult.ERROR
def check_logic(au, batcher):
if au.article.sysCateId == sysCateId:
self.addActionError(u"文章 %s 分类已经是所选分类, 未进行转移新分类操作.")
return False
return True
# 业务部分.
def do_business(au, batcher, *args):
self.art_svc.moveArticleSysCate(au.article, sysCateId)
return True
# 取消推荐选中的一个或多个资源.
batcher = self.createBatcher(operate=u'转移文章分类', do_business=do_business, check_logic=check_logic)
if not batcher.execute():
return batcher.result
return ActionResult.SUCCESS
class admin_unit (ActionExecutor):
UNIT_LIST = "/WEB-INF/ftl/admin/Unit_List.ftl"
UNIT_EDIT = "/WEB-INF/ftl/admin/Unit_Edit.ftl"
# 构造.
def __init__(self):
self.params = ParamUtil(request)
self.unitService = __jitar__.unitService
self.userService = __jitar__.userService
return
# 根据'cmd'进行派发.
def dispatcher(self, cmd):
# 该命令不需要登录及管理权限.
if cmd == "unit_options": # ajax call.
return self.unit_options()
# 以下必须要求是登录用户和具有管理员的权限.
if self.loginUser == None: return ActionResult.LOGIN
if self.canAdmin() == False:
self.addActionError(u"没有机构管理的权限.")
return ActionResult.ERROR
# 根据cmd参数，执行相应的方法.
if cmd == "" or cmd == None or cmd == "list":
return self.list() # 列表显示.
elif cmd == "edit":
return self.edit() # 添加.
elif cmd == "save":
return self.save() # 保存.
elif cmd == "del":
return self.delete() # 删除.
else :
self.addActionError(u"未知的命令参数：" + cmd)
return ActionResult.ERROR
# 系统所有机构的列表显示.
def list(self):
# 构造查询.
query = self.queryString()
query.k = self.params.safeGetStringParam("k")
# TODO: 权限检查.
# 调用分页函数.
pager = self.createPager()
pager.totalRows = query.count()
# 得到所有照片的列表.
unitList = query.query_map(pager)
#print "unitList:", unitList
# 传给页面.
request.setAttribute("unitList", unitList)
request.setAttribute("pager", pager)
# 将参数放到查询的页面.
request.setAttribute("k", query.k)
# 返回到要显示的页面.
return self.UNIT_LIST
# 添加或修改.
def edit(self):
unitId = self.params.getIntParam("unitId")
if unitId == 0:
unit = Unit()
else:
unit = self.unitService.findUnitById(unitId)
# 传递给页面对象.
request.setAttribute("unit", unit)
# 返回跳转.
return self.UNIT_EDIT
# 保存机构.
def save(self):
# 得到页面的 unitId，如果出现网络问题或从地址栏非法输入而获得失败的，则提示'未找到...'
unitId = self.params.safeGetIntParam("unitId", 0)
if unitId > 0:
# 根据'unitId'获得其对应的机构对象.
unit = self.unitService.findUnitById(unitId)
else:
unit = Unit()
# 设置新的数据.
self.setUnit(unit)
#检查是否存在同名的机构
unitTemp = self.unitService.getAllUnitOrChildUnitList(None,[False])
if self.checkExistUnit(unitTemp, unit) == True:
self.addActionError(u"同名的机构已经存在")
return ActionResult.ERROR
# 保存
self.unitService.saveOrUpdateUnit(unit)
# 添加导航
#print "unitId", unitId
if unitId < 1:
siteNameArray = [u"总站首页", u"机构首页", u"机构文章", u"机构资源", u"机构图片", u"机构视频", u"机构工作室"];
siteUrlArray = ["py/subjectHome.action", "", "article/", "resource/", "photo/", "video/", "blog/"]
siteHightlightArray = ["index", "unit", "unit_article", "unit_resource", "unit_photo", "unit_video", "unit_user"]
siteNavService = __spring__.getBean("siteNavService")
for i in range(0, len(siteNameArray)):
#先判断是否存在
siteNav = siteNavService.getSiteNavByName(SiteNav.SITENAV_OWNERTYPE_UNIT, unit.unitId, siteNameArray[i])
if siteNav == None:
siteNav = SiteNav()
siteNav.setSiteNavName(siteNameArray[i])
siteNav.setIsExternalLink(False)
siteNav.setSiteNavUrl(siteUrlArray[i])
siteNav.setSiteNavIsShow(True)
siteNav.setSiteNavItemOrder(i)
siteNav.setCurrentNav(siteHightlightArray[i])
siteNav.setOwnerType(SiteNav.SITENAV_OWNERTYPE_UNIT)
siteNav.setOwnerId(unit.unitId)
siteNavService.saveOrUpdateSiteNav(siteNav)
# 返回.
self.addActionLink(u"返回", "javascript:history.go(-1)")
self.addActionLink(u"机构管理", "?cmd=list")
return ActionResult.SUCCESS
#检查同名机构是否存在
def checkExistUnit(self, UnitList, Unit):
for x in UnitList:
if x.unitId != Unit.unitId and x.unitName == Unit.unitName :
return True
return False
# 设置新的数据.
def setUnit(self, unit):
unit.unitName = self.params.getStringParam("unitName")
unit.unitType = self.params.getStringParam("unitType")
return unit
# 删除.
def delete(self):
ids = self.params.getIdList("unitId")
if ids == None or ids.size() == 0 :
self.addActionError(u"没有选择机构")
return ActionResult.ERROR
message = ""
delnum = 0
for unitId in ids:
#判断是否存在用户
userList = self.userService.getUserUnitList(unitId)
if userList == None or userList.size() == 0:
delnum = delnum + 1
self.unitService.removeUnit(unitId)
else:
message = message + u"\n机构ID=" + str(unitId) + u" 存在用户,不允许删除该机构"
if message == "":
self.addActionMessage(u"操作成功")
self.addActionLink(u"返回", "?cmd=list")
return ActionResult.SUCCESS
else:
if delnum == 0:
self.addActionError(message)
return ActionResult.ERROR
else:
self.addActionMessage(u"共删除了" + str(delnum) + u"个的机构\n" + message)
self.addActionLink(u"返回", "?cmd=list")
return ActionResult.SUCCESS
# 创建并返回一个分页对象.
def createPager(self):
# 调用Java的函数.
pager = self.params.createPager()
pager.itemName = u"机构"
pager.itemUnit = u"个"
pager.pageSize = 20
return pager
# 投影查询字段.
def queryString(self):
# 构造查询.
query = UnitQuery(""" unit.unitId, unit.unitName, unit.unitType """)
return query
# AJAX 提供给 user, group 等修改时候切换了 district 得到新 unit_list select.
def unit_options(self):
unit_list = __jitar__.unitService.getAllUnitOrChildUnitList(None,[False])
request.setAttribute("unit_list", unit_list)
return "/WEB-INF/ftl/admin/unit_options_ajax.ftl"
