Example #1
0
 def genernate_news_content(self, webpart):
     cache_key = "sbj" + str(self.subject.subjectId) + "_" + str(webpart.getSubjectWebpartId()) + self.cacheKeyFix
     content = cache.get(cache_key)
     if content != None:
         request.setAttribute(cache_key, content)
         return
     
     map = HashMap()
     qry = SiteNewsQuery(""" snews.newsId, snews.title, snews.createDate""")
     qry.subjectId = self.subject.subjectId
     qry.hasPicture = False
     subject_text_news = qry.query_map(6)
     
     map.put("subject_text_news", subject_text_news)
     map.put("subject", self.subject)
     map.put("SubjectRootUrl", self.subjectRootUrl)
     map.put("webpart", webpart)
     map.put("unitId", self.unitId)
     content = self.templateProcessor.processTemplate(map, "/WEB-INF/subjectpage/" + self.templateName + "/text_news.ftl", "utf-8")
     request.setAttribute(cache_key, content)
     cache.put(cache_key, content)
Example #2
0
 def genernate_preparecourse_content(self, webpart):
     cache_key = "unit" + str(self.unit.unitId) + "_" + str(
         webpart.getUnitWebpartId())
     content = cache.get(cache_key)
     if content != None:
         request.setAttribute(cache_key, content)
         return
     qry = UnitPrepareCourseQuery(
         "pc.prepareCourseId, pc.title, pc.startDate, pc.endDate, u.userId")
     qry.unitId = self.unit.unitId
     unitPrepareCourseList = qry.query_map(10)
     map = HashMap()
     map.put("unit", self.unit)
     map.put("webpart", webpart)
     map.put("UnitRootUrl", self.unitRootUrl)
     map.put("unitPrepareCourseList", unitPrepareCourseList)
     content = self.templateProcessor.processTemplate(
         map, "/WEB-INF/unitspage/" + self.templateName +
         "/unit_preparecourse.ftl", "utf-8")
     request.setAttribute(cache_key, content)
     cache.put(cache_key, content)
Example #3
0
    def genernate_jiaoyanyuan_content(self, webpart):
        cache_key = "sbj" + str(self.subject.subjectId) + "_" + str(
            webpart.getSubjectWebpartId()) + self.cacheKeyFix
        content = cache.get(cache_key)
        if content != None:
            request.setAttribute(cache_key, content)
            return

        map = HashMap()
        jiaoyanyuan = self.get_subject_comissioner()
        map.put("jiaoyanyuan", jiaoyanyuan)
        map.put("subject", self.subject)
        map.put("SubjectRootUrl", self.subjectRootUrl)
        map.put("webpart", webpart)
        map.put("unitId", self.unitId)
        content = self.templateProcessor.processTemplate(
            map,
            "/WEB-INF/subjectpage/" + self.templateName + "/jiaoyanyuan.ftl",
            "utf-8")
        request.setAttribute(cache_key, content)
        cache.put(cache_key, content)
Example #4
0
def saveRiskInfo(entityName,list,rulecode):
    riskList=autoService.findByHql("from U_BANK_RISKRULEINFO v where v.rulecode='"+rulecode+"'");
    if riskList !='null' and riskList.size()>0 :
    	riskinfoList = ArrayList()
        riskHM = riskList.get(0)
        for entity in list:
           riskinfoMap= HashMap()
           riskinfoMap.put("uniseqno",entity.get("uniseqno"))
           riskinfoMap.put("trxdate",entity.get("trxdate"))
           riskinfoMap.put("trxtime",entity.get("trxtime"))
           riskinfoMap.put("tellerno",entity.get("tellerno"))
           riskinfoMap.put("custname",entity.get("rcustname"))
           riskinfoMap.put("brno",entity.get("brno"))
           riskinfoMap.put("riskdate","20090210")
           riskinfoMap.put("risktime","110911")
           riskinfoMap.put("risklevel",riskHM.get("risklevel"))
           riskinfoMap.put("riskcode",riskHM.get("rulecode"))
           riskinfoMap.put("riskname",riskHM.get("rulename"))
           riskinfoMap.put("risktype",riskHM.get("risktype"))
           riskinfoList.add(riskinfoMap)     
        autoService.saveAll(entityName, riskinfoList)
Example #5
0
    def genernate_daitouren_content(self, webpart):
        cache_key = "sbj" + str(self.subject.subjectId) + "_" + str(
            webpart.getSubjectWebpartId()) + self.cacheKeyFix
        content = cache.get(cache_key)
        if content != None:
            request.setAttribute(cache_key, content)
            return

        map = HashMap()
        expert_user_list = self.get_expert_list()
        map.put("expert_user_list", expert_user_list)
        map.put("subject", self.subject)
        map.put("SubjectRootUrl", self.subjectRootUrl)
        map.put("webpart", webpart)
        map.put("unitId", self.unitId)
        content = self.templateProcessor.processTemplate(
            map,
            "/WEB-INF/subjectpage/" + self.templateName + "/daitouren.ftl",
            "utf-8")
        request.setAttribute(cache_key, content)
        cache.put(cache_key, content)
Example #6
0
 def __init__(self, name, results):
     self.__facetMap = HashMap()
     self.__facetList = ArrayList()
     facets = results.getFacets()
     if facets is None:
         return
     facet = facets.get(name)
     if facet is None:
         return
     facetData = facet.values()
     for value in facetData.keySet():
         count = facetData.get(value)
         facet = Facet(name, value, count)
         self.__facetMap.put(value, facet)
         slash = value.rfind("/")
         if slash == -1:
             self.__facetList.add(facet)
         else:
             parent = self.__getFacet(value[:slash])
             if parent is not None:
                 parent.addSubFacet(facet)
Example #7
0
    def __init__(self, func=None, env=None):
        self.arrows = HashMap()
        self.cls = None
        self.defaultTypes = List()

        self.selfType = None
        self.func = None
        from pysonarsq.java.Analyzer import Analyzer

        super(FunType, self).__init__()
        self.env = None
        if isinstance(func, FunctionDef):
            self.func = func
            self.env = env
        elif isinstance(func, Type):
            from_, to = func, env
            self.addMapping(from_, to)
            self.getTable().addSuper(
                Analyzer.self.builtins.BaseFunction.getTable())
            self.getTable().setPath(
                Analyzer.self.builtins.BaseFunction.getTable().getPath())
    def testPerField(self):

        perField = HashMap()
        perField.put("special", SimpleAnalyzer())
        analyzer = PerFieldAnalyzerWrapper(WhitespaceAnalyzer(), perField)

        text = "Qwerty"
        tokenStream = analyzer.tokenStream("field", StringReader(text))
        tokenStream.reset()
        termAtt = tokenStream.getAttribute(CharTermAttribute.class_)

        self.assert_(tokenStream.incrementToken())
        self.assertEqual("Qwerty", termAtt.toString(),
                         "WhitespaceAnalyzer does not lowercase")

        tokenStream = analyzer.tokenStream("special", StringReader(text))
        tokenStream.reset()
        termAtt = tokenStream.getAttribute(CharTermAttribute.class_)
        self.assert_(tokenStream.incrementToken())
        self.assertEqual("qwerty", termAtt.toString(),
                         "SimpleAnalyzer lowercases")
Example #9
0
 def testUpdateAssignment(self):
     """TurnitinReviewServiceImpl.updateAssignment
     
     TODO: I think this is suppose to actually test updating the due date.
     I believe the occasional running of doAssignments is to get around the
     5 month due date limitation."""
     tiiasnnid = "/unittests/asnnupdate/"+str(uuid.uuid1())
     tiisiteid = str(uuid.uuid1())
     opts = HashMap()
     opts.put('journal_check','1')
     self.tiireview_serv.createAssignment(tiisiteid, tiiasnnid, opts)
     Thread.sleep(1000)
     tiiresult = self.tiireview_serv.getAssignment(tiisiteid, tiiasnnid)
     Thread.sleep(1000)
     self.assertEquals(str(tiiresult['object']['searchjournals']),str('1'))
     Thread.sleep(1000)
     
     self.tiireview_serv.updateAssignment(tiisiteid, tiiasnnid)
     Thread.sleep(1000)
     tiiresult = self.tiireview_serv.getAssignment(tiisiteid, tiiasnnid)
     self.assertEquals(str(tiiresult['object']['searchjournals']),str('1'))
Example #10
0
 def getUserName(self, userStr):
     """ userStr could be an identifier of a user, e.g. an email address not a username, 
         this function currently only verifies it against email address attribute stored in HibernateAuthUserAttribute table
         and return a real username if found, otherwise, return original query string
         Warning: this function does not check if a user exists
     """
     parameters = HashMap()
     #         print "Checking user info by %s (could be email)" % userStr
     parameters.put("key", "email")
     parameters.put("value", userStr)
     authUserAttrbDao = ApplicationContextProvider.getApplicationContext(
     ).getBean("hibernateAuthUserAttributeDao")
     userObjectList = authUserAttrbDao.query(
         "getUserAttributeByKeyAndValue", parameters)
     if userObjectList.size() > 0:
         userObject = userObjectList.get(
             0)  #Check if this is a user with attributes?
         realUser = userObject.getUser()
         if realUser is not None:
             userStr = realUser.getUsername()
     return '{"realName":"' + userStr + '"}'
Example #11
0
    def getCurrencyAccounts(self, book):
#        print "getCurrencyAccounts "
        import java.util.HashMap as HashMap
        import com.infinitekind.moneydance.model.AccountUtil as AccountUtil
        import com.infinitekind.moneydance.model.AcctFilter as AcctFilter
        import com.infinitekind.moneydance.model.Account.AccountType as AccountType
        
        accounts = HashMap()
        for acct in AccountUtil.allMatchesForSearch(book.getRootAccount(), AcctFilter.ACTIVE_ACCOUNTS_FILTER ): 
	    curr = acct.getCurrencyType()                                   
	    account = accounts.get(curr)# this returns None if curr doesn't exist yet
	    if acct.getCurrentBalance() != 0 and acct.getAccountType() == AccountType.SECURITY:
              pass
	    else:
	      continue # no sense slowing everything down with stuff we don't need  . only some BONDS left mixed in with the STOCK
	    if account == None:
	      account = str(acct.getParentAccount())
	    else:  
              account = account + ' : ' + str(acct.getParentAccount()) # concatinate two strings here
            accounts.put(curr,account)
        return accounts
Example #12
0
 def _loader_dict(self, cmd={}):
     self.loader_map = dict()
     for bucket in self.cluster.buckets:
         for scope in bucket.scopes.keys():
             for collection in bucket.scopes[scope].collections.keys():
                 if collection == "_default" and scope == "_default":
                     continue
                 ws = WorkLoadSettings(
                     cmd.get("keyPrefix", self.key),
                     cmd.get("keySize", self.key_size),
                     cmd.get("docSize", self.doc_size),
                     cmd.get("cr", self.create_perc),
                     cmd.get("rd", self.read_perc),
                     cmd.get("up", self.update_perc),
                     cmd.get("dl", self.delete_perc),
                     cmd.get("ex", self.expiry_perc),
                     cmd.get("workers", self.process_concurrency),
                     cmd.get("ops", self.ops_rate),
                     cmd.get("loadType", None), cmd.get("keyType", None),
                     cmd.get("valueType", None), cmd.get("validate", False),
                     cmd.get("gtm", False), cmd.get("deleted", False),
                     cmd.get("mutated", 0))
                 hm = HashMap()
                 hm.putAll({
                     DRConstants.create_s: self.create_start,
                     DRConstants.create_e: self.create_end,
                     DRConstants.update_s: self.update_start,
                     DRConstants.update_e: self.update_end,
                     DRConstants.expiry_s: self.expire_start,
                     DRConstants.expiry_e: self.expire_end,
                     DRConstants.delete_s: self.delete_start,
                     DRConstants.delete_e: self.delete_end,
                     DRConstants.read_s: self.read_start,
                     DRConstants.read_e: self.read_end
                 })
                 dr = DocRange(hm)
                 ws.dr = dr
                 dg = DocumentGenerator(ws, self.key_type, self.val_type)
                 self.loader_map.update(
                     {bucket.name + scope + collection: dg})
Example #13
0
    def execute(self):
        self.loginName = request.getAttribute("loginName")
        writer = response.getWriter()
        # 加载当前用户对象.
        self.user = user_svc.getUserByLoginName(self.loginName)
        if self.user == None:
            writer.write(u"无法加载当前用户。")
            return
        self.userName = self.user.loginName
        fc = FileCache()
        content = fc.getUserFileCacheContent(self.userName,
                                             "user_preparecourse.html", 14400)
        if content != "":
            response.getWriter().write(content)
            fc = None
            return

        #得到当前用户的创建的活动
        qry = PrepareCourseQuery(
            """ pc.createUserId,pc.leaderId,pc.memberCount,pc.articleCount,pc.resourceCount,
                                    pc.status,pc.actionCount,pc.topicCount,pc.topicReplyCount,pc.viewCount,pc.startDate,pc.endDate,
                                    pc.title, pc.prepareCourseId, pc.createDate, pc.metaSubjectId, pc.gradeId,
                                    u.loginName,u.trueName
                                """)
        qry.status = 0
        qry.createUserId = self.user.userId
        course_list = qry.query_map(10)

        templateProcessor = __spring__.getBean("templateProcessor")
        map = HashMap()
        map.put("course_list", course_list)
        map.put("user", self.user)
        map.put("UserSiteUrl", self.getUserSiteUrl())
        content = templateProcessor.processTemplate(
            map, "/WEB-INF/user/default/user_preparecourse.ftl", "utf-8")

        fc.writeUserFileCacheContent(self.userName, "user_preparecourse.html",
                                     content)
        response.getWriter().write(content)
        fc = None
Example #14
0
File: oaa.py Project: jbalint/spark
def rawoaasolve(agent, sparkgoal, sparkparams, sparkpattern=None):
    oaa = _oaa(agent)
    iclgoal = value_to_icl(sparkgoal)
    iclparams = value_to_icl(sparkparams)
    iclanswers = IclList()
    debug("calling oaaSolve on %s", iclgoal)
    functor = iclgoal.functor
    logInfo("rawoaasolve[%s]" % functor)
    result = oaa.oaaSolve(iclgoal, iclparams, iclanswers)
    logInfo("rawoaasolve complete[%s]" % functor)

    if result:
        debug("oaaSolve returned success: %s", iclanswers)
        if not iclanswers.isList():
            raise LowError(
                "The call to oaaSolve returned a non-IclList answer: %s" %
                iclanswers)
        if sparkpattern is None:
            ans = icl_to_value(iclanswers)
        else:
            bindings = HashMap()
            iclpattern = value_to_icl(sparkpattern)
            anslist = []
            for iclans in iclanswers.iterator():
                bindings.clear()
                if UNIFIER.matchTerms(iclans, iclgoal, bindings):
                    anslist.append(
                        icl_to_value(UNIFIER.deref(iclpattern, bindings)))
                else:
                    raise LowError(
                        "The call to oaaSolve returned an answer that doesn't unify with the query:\nans=%s\query=%s"
                        % (iclans, iclgoal))
            ans = List(anslist)
        logInfo("rawoaasolve answers deconstructed[%s]" % functor)
        return ans
    else:
        debug("oaaSolve return failure: %s", iclanswers)
        logError("rawoaasolve return failure with answers [%s]" % iclanswers)
        raise OAAError("The call to oaaSolve [goal %s] failed and returned %s"\
                        %(functor, iclanswers))
Example #15
0
    def __activate__(self, context):
        self.None = context["log"]
        self.systemConfig = context["systemConfig"]
        self.sessionState = context["sessionState"]
        self.response = context["response"]
        self.request = context["request"]

        self.sessionState.set("username", "admin")
        self.writer = self.response.getPrintWriter("text/plain; charset=UTF-8")

        curationJobDao = ApplicationContextProvider.getApplicationContext(
        ).getBean("curationJobDao")
        publicationHandler = ApplicationContextProvider.getApplicationContext(
        ).getBean("publicationHandler")
        jobs = curationJobDao.query("findInProgressJobs", HashMap())
        self.writer.println(jobs.size())

        for curationJob in jobs:
            if curationJob.getCurationJobId() is not None:
                self.writer.println(curationJob.getCurationJobId())
            else:
                self.writer.println("Null huh")

            jobStatus = self.queryJobStatus(curationJob)
            self.writer.println(jobStatus.toString())
            status = jobStatus.getString("failed", "status")
            self.writeResponseToStatusResponseCache(
                jobStatus.getInteger(None, "job_id"), jobStatus)
            self.writer.println(status)
            if "complete" == status:
                publicationHandler.publishRecords(
                    jobStatus.getArray("job_items"))
                curationJob.setStatus(status)
                curationJobDao.create(curationJob)
            else:
                if "failed" == status:
                    curationJob.setStatus(status)
                    curationJobDao.create(curationJob)
            self.writer.close()
            self.sessionState.remove("username")
Example #16
0
    def __init__(self,
                 index_dir,
                 search_fields=['canonical_url', 'title', 'meta', 'content'],
                 unique_field='uq_id_str',
                 boost=dict(canonical_url=4.0,
                            title=8.0,
                            meta=2.0,
                            content=1.0),
                 date_format='%Y-%m-%dT%H:%M:%S'):
        """Constructor of Searcher.

        Parameters
        ----------
        index_dir : string
            The location of lucene index.
        search_fields : list
            A list of field names indicating fields to search on.
        unique_field : string
            The field name, on which the duplication should avoid.
        boost : dict
            This dict control the weight when computing score.
        date_format : string
            Convert the string into datetime. Should consistent with the
            index part.
        """
        self.index_dir = index_dir
        self.search_fields = search_fields
        self.sort_by_recent = Sort(
            SortField('date_published', SortField.Type.STRING, True))
        self.store = FSDirectory.open(File(index_dir))
        self.reader = DirectoryReader.open(self.store)
        self.isearcher = IndexSearcher(self.reader)
        self.analyzer = StandardAnalyzer()
        self.dup_filter = DuplicateFilter(unique_field)
        self.boost_map = HashMap()
        for k, v in boost.iteritems():
            self.boost_map.put(k, Float(v))
        self.mul_parser = MultiFieldQueryParser(search_fields, self.analyzer,
                                                self.boost_map)
        self.date_format = date_format
Example #17
0
    def genernate_links_content(self, webpart):
        cache_key = "sbj" + str(self.subject.subjectId) + "_" + str(
            webpart.getSubjectWebpartId()) + self.cacheKeyFix
        content = cache.get(cache_key)
        if content != None:
            request.setAttribute(cache_key, content)
            return

        map = HashMap()
        links = self.siteLinksService.getSiteLinksList("subject",
                                                       self.subject.subjectId)
        if links != None:
            map.put("links", links)
        map.put("subject", self.subject)
        map.put("SubjectRootUrl", self.subjectRootUrl)
        map.put("webpart", webpart)
        map.put("unitId", self.unitId)
        content = self.templateProcessor.processTemplate(
            map, "/WEB-INF/subjectpage/" + self.templateName + "/links.ftl",
            "utf-8")
        request.setAttribute(cache_key, content)
        cache.put(cache_key, content)
Example #18
0
    def genernate_group_content(self, webpart):
        cache_key = "unit" + str(self.unit.unitId) + "_" + str(
            webpart.getUnitWebpartId())
        content = cache.get(cache_key)
        if content != None:
            request.setAttribute(cache_key, content)
            return

        qry = UnitGroupQuery("ug.groupName,ug.groupTitle")
        qry.unitId = self.unit.unitId
        unitGroupList = qry.query_map(10)
        map = HashMap()
        map.put("unit", self.unit)
        map.put("webpart", webpart)
        map.put("UnitRootUrl", self.unitRootUrl)
        map.put("unitGroupList", unitGroupList)

        content = self.templateProcessor.processTemplate(
            map, "/WEB-INF/unitspage/" + self.templateName + "/unit_group.ftl",
            "utf-8")
        request.setAttribute(cache_key, content)
        cache.put(cache_key, content)
def start_pr_release(repo_full_name, pr_number, pr_title, comment):
    tag = 'pull_request_merger'
    pr_templates = templateApi.getTemplates(tag)
    if not pr_templates:
        raise Exception('Could not find any templates by tag [pull_request_merger]. '
                        'Did the xlr-development-workflow-plugin initializer run?')
    else:
        if len(pr_templates) > 1:
            logger.warn("Found more than one template with tag '%s', using the first one" % tag)
        template_id = pr_templates[0].id

    params = StartRelease()
    params.setReleaseTitle('Merge PR #%s: %s' % (pr_number, pr_title))
    variables = HashMap()
    variables.put('${pull_request_number}', '%s' % pr_number)
    variables.put('${pull_request_title}', '%s' % pr_title)
    variables.put('${repository_full_name}', '%s' % repo_full_name)
    variables.put('${pull_request_comment}', '%s' % comment)
    params.setReleaseVariables(variables)
    started_release = templateApi.start(template_id, params)
    response.entity = started_release
    logger.info("Started release %s to merge pull request %s" % (started_release.getId(), pr_number))
Example #20
0
 def getMintLabels(self, urlName, key, suffix):
     mapIds = HashMap()
     valList = self.getList(key)
     self.log.debug(valList.toString())
     ids = ""
     for eKey in valList.keySet():
         entry = valList.get(eKey)
         if len(ids) > 0:
             ids = "%s," % ids
         ids = "%s%s" % (ids, entry.get(suffix))
     if ids == "":
         return None
     else:
         labels = ArrayList()
         mapIds.put("id", ids)
         labelsMint = MintLookupHelper.get(self.systemConfig, urlName,
                                           mapIds)
         self.log.debug(labelsMint.getJsonArray().toString())
         for label in labelsMint.getJsonArray():
             labelJson = JsonSimple(label)
             labels.add(labelJson.getString("", "label"))
         return labels
Example #21
0
def start_pr_release(
    proj_name,
    repo_name,
    pr_number,
    pr_title,
    comment,
    source_hash,
    target_hash,
    tag="pull_request_merger",
):
    pr_templates = templateApi.getTemplates(tag)
    if not pr_templates:
        raise Exception(
            "Could not find any templates by tag [pull_request_merger]. "
            "Did the xlr-development-workflow-plugin initializer run?"
        )
    else:
        if len(pr_templates) > 1:
            logger.warn(
                "Found more than one template with tag '%s', using the first one" % tag
            )
        template_id = pr_templates[0].id

    params = StartRelease()
    params.setReleaseTitle("Pull Request #%s: %s" % (pr_number, pr_title))
    variables = HashMap()
    variables.put("pull_request_number", "%s" % pr_number)
    variables.put("pull_request_title", "%s" % pr_title)
    variables.put("repository_name", "%s" % repo_name)
    variables.put("pull_request_comment", "%s" % comment)
    variables.put("proj_name", "%s" % proj_name)
    variables.put("fromHash", "%s" % source_hash)
    variables.put("toHash", "%s" % target_hash)
    params.setReleaseVariables(variables)
    started_release = templateApi.start(template_id, params)
    response.entity = started_release
    logger.info(
        "Started release %s for Pull Request %s" % (started_release.getId(), pr_number)
    )
Example #22
0
    def execute(self):       
        self.pluginService =  __spring__.getBean("pluginService")
        if self.pluginService.checkPluginEnabled("questionanswer") == False:
            request.setAttribute("message",u"该插件已经被管理员禁用。")
            return "/WEB-INF/mod/show_text.ftl"
        
        if self.parentGuid == "" or self.parentType == "":
            return "/WEB-INF/mod/questionanswer/not_found.ftl"
        
        pageIndex = self.params.safeGetStringParam("page")
        if pageIndex.isdigit() == False:
            pageIndex = "1"
        
        qry = QuestionQuery(""" q.questionId,q.topic,q.createDate,q.createUserId,q.createUserName,
                                q.objectGuid,q.createUserId, q.createUserName """)
        qry.parentGuid = self.parentGuid
        pager = self.params.createPager()
        pager.itemName = u"问题"
        pager.itemUnit = u"个"
        pager.pageSize = 20
        pager.setCurrentPage(int(pageIndex))
        pager.totalRows = qry.count()
        q_list = qry.query_map(pager)        
        
        map = HashMap()
        map.put("SiteUrl",self.pageFrameService.getSiteUrl())
        map.put("UserMgrUrl",self.pageFrameService.getUserMgrUrl())
        map.put("q_list", q_list)
        map.put("pager", pager)
        map.put("parentGuid", self.parentGuid)
        map.put("parentType", self.parentType)        
        
        pagedata = self.pageFrameService.transformTemplate(map, "/WEB-INF/mod/questionanswer/listall.ftl")      
        
        page_frame = self.pageFrameService.getFramePage(self.parentGuid,self.parentType)
        page_frame = page_frame.replace("[placeholder_content]",pagedata)
        page_frame = page_frame.replace("[placeholder_title]",u"全部问题列表")

        self.writeToResponse(page_frame)
Example #23
0
    def nx_update_custom_attr(self):
        ''' Check _categoryName on node, if it is not set to the current value (or missing) update it '''

        required_attrs = {
            '_categoryName': self.category,
            'disableUnreachableAlarms': str(int(self.category in (self.WORKSTATION, self.PORTABLE, self.PRINTER))),
            'disableInterfaceAlarms': str(int(self.category in (self.WORKSTATION, self.PORTABLE, self.PRINTER)))
        }

        for attr in required_attrs:
            ca = self.node.customAttributes.get(attr, None)
            if ca and ca.value == required_attrs[attr]:
                del required_attrs[attr]
        
        if required_attrs:
            md = NXCObjectModificationData(self.node.getObjectId())
            attr_map = HashMap(self.node.getCustomAttributes())
            flags = CustomAttribute.INHERITABLE
            for attr in required_attrs:
                attr_map.put(attr, CustomAttribute(str(required_attrs[attr]), flags, 0))
            md.setCustomAttributes(attr_map)
            self.session.modifyObject(md)
Example #24
0
def scan_request(path=None, monitorsPerPoint=None, monitorsPerScan=None, det=None, file=None, allow_preprocess=False):
    """Create a ScanRequest object with the given configuration.

    See the mscan() docstring for usage.
    """
    try:
        assert path is not None
    except AssertionError:
        raise ValueError('Scan request must have a scan path.')

    # The effect of the following three lines is to make square brackets
    # optional when calling this function with length-1 lists. I.e. we can do
    # either scan([grid(...)], ...) or scan(grid(...), ...). Also _stringify
    # the monitors so users can pass either a monitor name in quotes or a
    # scannable object from the Jython namespace.
    scan_paths = _listify(path)
    monitorNamesPerPoint = ArrayList(map(_stringify, _listify(monitorsPerPoint)))
    monitorNamesPerScan = ArrayList(map(_stringify, _listify(monitorsPerScan)))
    detectors = _listify(det)

    (scan_path_models, _) = zip(*scan_paths)  # zip(* == unzip(

    # ScanRequest expects CompoundModel
    cmodel = CompoundModel()
    for (model, rois) in scan_paths:
        cmodel.addData(model, rois)

    # (Again, use a HashMap, not a Python dict.)
    detector_map = HashMap()
    for (name, model) in detectors:
        detector_map[name] = model

    return _instantiate(ScanRequest,
                        {'compoundModel': cmodel,
                         'filePath' : file,
                         'monitorNamesPerPoint': monitorNamesPerPoint,
                         'monitorNamesPerScan': monitorNamesPerScan,
                         'detectors': detector_map,
                         'ignorePreprocess': not allow_preprocess})
Example #25
0
    def testCheckAgainstInstitutionRepository(self):
        """
        institution_check / searchinstitution 
        values of 0 to not check against institutional
        repository, 1 check against it.
        """
        opts = HashMap()
        opts.put('institution_check','1')
        tiiasnnid = "/unittests/useinstitution/"+str(uuid.uuid1())
        tiisiteid = str(uuid.uuid1())
        # Test creating an assignment checked against Journals
        self.tiireview_serv.createAssignment(tiisiteid, tiiasnnid, opts)
        tiiresult = self.tiireview_serv.getAssignment(tiisiteid, tiiasnnid)
        self.assertEquals(str(tiiresult['object']['searchinstitution']),str('1'))

        # Test creating an assignment checked against Journals
        opts.put('institution_check','0')
        tiiasnnid = "/unittests/noinstitution/"+str(uuid.uuid1())
        self.tiireview_serv.createAssignment(tiisiteid, tiiasnnid, opts)
         
        tiiresult = self.tiireview_serv.getAssignment(tiisiteid, tiiasnnid)
        self.assertEquals(str(tiiresult['object']['searchinstitution']),str('0'))
Example #26
0
    def __init__(self, parent=None, type_=None):
        #  stays null for most scopes (mem opt)
        #  all are non-null except global table
        #  link to the closest non-class scope, for lifting functions out
        # ....

        if not hasattr(self, 'scopeType'):
            self.scopeType = None

        self.supers = List()
        self.globalNames = Set()
        self.type_ = None
        self.path = ""
        self.parent = parent
        self.setScopeType(type_)
        self.forwarding = None
        self.table = Map()

        if isinstance(parent, Scope) and type_ is None:
            s = parent  # case of creating a new scope from an existing one
            if s.table is not None:
                self.table = HashMap()
                self.table.update(s.table)
                self.parent = s.parent
                self.setScopeType(s.scopeType)
                self.forwarding = s.forwarding
                self.supers = s.supers
                self.globalNames = s.globalNames
            self.type_ = s.type_
            self.path = s.path
        elif parent is not None:
            self.parent = parent
            self.setScopeType(type_)
            if type_ == self.ScopeType.CLASS:
                self.forwarding = (None if parent is None else
                                   parent.getForwarding())
            else:
                self.forwarding = self
Example #27
0
    def execute(self):
        if self.parentGuid == "" or self.parentType == "":
            self.addActionError(u"无效的标识。")
            return self.ERROR

        pageIndex = self.params.safeGetStringParam("page")
        if pageIndex.isdigit() == False:
            pageIndex = "1"

        qry = VoteQuery(
            """ vote.voteId,vote.title,vote.createDate,vote.endDate """)
        qry.parentGuid = self.parentGuid
        qry.parentObjectType = self.parentType
        pager = self.params.createPager()
        pager.itemName = u"调查"
        pager.itemUnit = u"个"
        pager.pageSize = 20
        pager.setCurrentPage(int(pageIndex))
        pager.totalRows = qry.count()
        vote_list = qry.query_map(pager)

        map = HashMap()
        map.put("SiteUrl", self.pageFrameService.getSiteUrl())
        map.put("UserMgrUrl", self.pageFrameService.getUserMgrUrl())
        map.put("vote_list", vote_list)
        map.put("pager", pager)
        map.put("loginUser", self.loginUser)
        map.put("parentGuid", self.parentGuid)
        map.put("parentType", self.parentType)

        pagedata = self.pageFrameService.transformTemplate(
            map, "/WEB-INF/mod/vote/morevote.ftl")

        page_frame = self.pageFrameService.getFramePage(
            self.parentGuid, self.parentType)
        page_frame = page_frame.replace("[placeholder_content]", pagedata)
        page_frame = page_frame.replace("[placeholder_title]", u"全部调查投票")
        self.writeToResponse(page_frame)
Example #28
0
    def execute(self):
        self.userName = request.getAttribute("loginName")
        if self.userName == None or self.userName == "":
            response.getWriter().write(u"没有该用户。")
            return
        user = self.userService.getUserByLoginName(self.userName)
        if user == None:
            response.getWriter().write(u"不能加载当前用户。")
            return
        fc = FileCache()
        content = fc.getUserFileCacheContent(self.userName,
                                             "user_leaveword.html", 60)
        if content != "":
            response.getWriter().write(content)
            fc = None
            return

        count = self.params.safeGetIntParam("count")
        if count == 0: count = 10
        qry = LeaveWordQuery(
            " lwd.userId,lwd.createDate, lwd.loginName, lwd.title, lwd.content"
        )
        qry.objId = user.userId
        qry.objType = 1
        qry.orderType = 0
        leaveword_list = qry.query_map(count)
        templateProcessor = __spring__.getBean("templateProcessor")
        map = HashMap()
        map.put("user", user)
        map.put("leaveword_list", leaveword_list)
        map.put("UserSiteUrl", self.getUserSiteUrl())
        content = templateProcessor.processTemplate(
            map, "/WEB-INF/user/default/user_leaveword.ftl", "utf-8")

        fc.writeUserFileCacheContent(self.userName, "user_leaveword.html",
                                     content)
        response.getWriter().write(content)
        fc = None
Example #29
0
def checkLock(Framework):
    probe = CollectorsParameters.getValue(CollectorsParameters.KEY_PROBE_MGR_IP)
    if (probe is None) or (len(str(probe)) == 0):
        logger.debug('Probe manager ip is not specified in the DiscoveryProbe.properties file, using probe ID')
        probe = CollectorsParameters.getValue(CollectorsParameters.KEY_COLLECTORS_PROBE_NAME)
    jobType = INVENTORY_JOB_TYPE
    jobId =  Framework.getDiscoveryJobId()
    lockTime = System.currentTimeMillis()
    lockExpiration = System.currentTimeMillis() + LOCK_AGE_PERIOD_MILLISECONDS
    lock = Lock(probe, jobType, jobId, lockTime, lockExpiration)

    logger.debug('Checking remote lock with current lock:', str(lock.getLockInfo()))

    triggerid = Framework.getTriggerCIData('id')
    logger.debug('Checking lock for probe ', probe, ' and jobid ', jobId, ' and triggerid ', triggerid)
    client = Framework.getConnectedClient()
    options = getClientOptionsMap(client)
    lockOption = options.get(ScannerNodeLock)

    if (lockOption is None) or (len(lockOption.strip()) == 0):
        logger.debug('Lock on scanner node for probe "' + lock.probe + '" and job "' + lock.jobId + '" is not exists')
        return 0

    remoteLock = extractLock(lockOption)
    logger.debug('Found remote lock:', str(remoteLock.getLockInfo()))

    if remoteLock.isLockExpired():
        logger.debug('Lock on remote node is already expired, renewing lock on the node')
        options = HashMap()
        options.put(ScannerNodeLock, lock.getLockInfo())
        client.setOptionsMap(options)
    elif not lock.isSameLock(remoteLock):
        logger.debug(
            'Lock on remote node is owned by another probe/job (' + remoteLock.probe + '/' + remoteLock.jobId + ')')
        if remoteLock.jobType == CALLHOME_JOB_TYPE:
            return ScannerNodeLockedByCallHome
        return 0
    return 1
Example #30
0
    def execute(self):
        self.userName = request.getAttribute("UserName")
        fc = FileCache()
        content = fc.getUserFileCacheContent(self.userName,
                                             "user_joined_groups.html", 14400)
        if content != "":
            response.getWriter().write(content)
            fc = None
            return
        count = self.params.safeGetIntParam("count")
        if count == 0: count = 10
        user = self.userService.getUserByLoginName(self.userName)
        if self.canVisitUser(user) == False:
            response.writer.println(u"用户  " + self.userName + u" 不存在 ")
            return

        # 得到参加的协作组列表.
        qry = GroupMemberQuery(
            """ gm.id, gm.group, g.groupName, g.groupId, g.groupTitle,  g.userCount """
        )
        qry.userId = user.userId
        qry.memberStatus = 0
        qry.groupStatus = 0
        qry.orderType = 0
        group_list = qry.query_map(count)

        templateProcessor = __spring__.getBean("templateProcessor")
        map = HashMap()
        map.put("user", user)
        map.put("group_list", group_list)
        map.put("UserSiteUrl", self.getUserSiteUrl())
        content = templateProcessor.processTemplate(
            map, "/WEB-INF/user/default/user_joined_groups.ftl", "utf-8")

        fc.writeUserFileCacheContent(self.userName, "user_joined_groups.html",
                                     content)
        response.getWriter().write(content)
        fc = None