コード例 #1
0
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
コード例 #2
0
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 用户1的分类
    # gres_1 协助组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
コード例 #3
0
ファイル: message.py プロジェクト: yxxcrtd/jitar2.0
# coding=utf-8
コード例 #4
0
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"站点个人统计"
コード例 #5
0
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
コード例 #6
0
ファイル: punish.py プロジェクト: yxxcrtd/jitar2.0
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
コード例 #7
0
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
コード例 #8
0
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
コード例 #9
0
ファイル: admin_resource.py プロジェクト: yxxcrtd/jitar2.0
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)
コード例 #10
0
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
コード例 #11
0
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"