def test_fixes_base_versions(self): # Test that the script sets base_version on the DSDs. # Create a package in parent and child that has some history in # its changelog. dsp = self.makeDerivedDistroSeries() distroseries = dsp.derived_series package = self.factory.makeSourcePackageName() spph = self._makePublication(distroseries, package, '1.2') parent_spph = self._makePublication(dsp.parent_series, package, '1.1') naked_spr = removeSecurityProxy(spph.sourcepackagerelease) naked_spr.changelog = self.factory.makeChangelog( package.name, ['1.2', '1.1']) naked_parent_spr = removeSecurityProxy( parent_spph.sourcepackagerelease) naked_parent_spr.changelog = self.factory.makeChangelog( package.name, ['1.1']) # Commit so the librarian gets the changelogs. transaction.commit() script = self.makeScript([ '--distribution', distroseries.distribution.name, '--series', distroseries.name, ]) script.main() dsd = self.getDistroSeriesDiff(distroseries)[0] self.assertEqual('1.1', dsd.base_version)
def addObject(self,id_obs_value, what_is_that=None): try: flatten = getUtility(IQreatureUtility, name="Flatten") id_obs_value_list = [i for i in flatten(id_obs_value)] if len(id_obs_value_list) == 3: value = id_obs_value_list[2] elif len(id_obs_value_list) == 6: value = [id_obs_value_list[2],id_obs_value_list[5]] else: return -1 answer_id = int(id_obs_value_list[0]) ob = id_obs_value_list[1] quiz = removeSecurityProxy(self.context) sm = quiz.getSiteManager() answer = removeSecurityProxy(sm['intids'].getObject(int(answer_id))) notify(CachedObjectChangedEvent([answer])) TYPE_OBJECT_MAP = {'lead':AnswerLeads,'depend':AnswerDepends, 'value':AnswerValue} if type(value) == type([]): ob = TYPE_OBJECT_MAP[ob](int(value[0]),int(value[1])) elif ob == 'value' or ob ==u'value': ob = TYPE_OBJECT_MAP[ob](unicode(value)) else: ob = TYPE_OBJECT_MAP[ob](int(value)) notify(ObjectCreatedEvent(ob)) chooser = INameChooser(answer) name = chooser.chooseName(None, ob) if chooser.checkName(name, ob): answer[name] = ob else: return (0-1) return IAsyncDataManager(answer[name]).addSelf() except: return (0-1)
def __init__(self, context): self._context = context self.__parent__ = context self.context = removeSecurityProxy(context) self._permissions = removeSecurityProxy( IPrincipalPermissionManager(context))
def __call__(self): self.request.response.setHeader('Content-type', 'application/pdf') self.request.response.setHeader('Content-disposition', 'inline;filename="' + removeSecurityProxy(self.report.report_type) + "_" + removeSecurityProxy(self.report.start_date).strftime('%Y-%m-%d') + '.pdf"') session = Session() report = session.query(domain.Report).get(self.report.report_id) d = dict([(f.file_title, f.file_data) for f in report.attached_files]) if "pdf" not in d.keys(): params = {} params['body_text'] = self.cleanupText() openofficepath = getUtility(IOpenOfficeConfig).getPath() renderer = Renderer(self.odt_file, params, self.tempFileName, pythonWithUnoPath=openofficepath) renderer.run() f = open(self.tempFileName, 'rb') doc = f.read() f.close() os.remove(self.tempFileName) attached_file = domain.AttachedFile() attached_file.file_title = "pdf" attached_file.file_data = doc attached_file.language = report.language report.attached_files.append(attached_file) notify(ObjectCreatedEvent(attached_file)) session.add(report) session.commit() return doc else: return d["pdf"].__str__()
def fields(self): self.context = removeSecurityProxy(self.context) int_ids = getUtility(IQreatureIntIds, context = self.context) annotations = IAnnotations(removeSecurityProxy(self.context)) graf = annotations.get(GRAF_KEY) #this means it is not first question if 'form.buttons.proceed' in self.request: answers = extract_answers(self.request) #actually it is only one answer received_answer = int_ids.getObject(int(answers[0])) question_id = received_answer['lead'].question_id if question_id in graf.keys()and graf[question_id] == LAST_QUESTION_KEY: self.gimmeAction = absoluteURL(self.context, self.request) + '/result.html' #first question else: for i in graf.items(): if i[1] == FIRST_QUESTION_KEY: question_id = i[0] #it need to install idle answer answers = [] fields = field.Fields(IMultiPageQuizUnit, prefix = str(question_id)) return install_widget_factories(fields, answers)
def handleSend(self, action): request = self.request data, errors = self.extractData() if errors: IStatusMessage(request).add(self.formErrorsMessage, 'error') else: message = data['message'] members = self.context.members getPrincipal = getUtility(IAuthentication).getPrincipal invitations = getUtility(IInvitations) group = removeAllProxies(self.context) for pid in request.get('principal.users', ()): try: principal = getPrincipal(pid) except PrincipalLookupError: continue if not invitations.catalog.search( group, type = {'any_of': ('invitation.member',)}, principal = {'any_of': (pid,)}): removeSecurityProxy(members).invite(pid, message) IStatusMessage(request).add(_(u'Invitations have been sent.')) self.redirect('.')
def createAndAdd(self, data): ob = super(AddForm, self).createAndAdd(data) self.created_object = ob # !+ used by calendar/browser sitting # execute domain.Entity on create hook removeSecurityProxy(ob).on_create() # cascade_modifications(ob) return ob
def constructQuery(self, context): session= Session() trusted=removeSecurityProxy(context) parliament_id = self._get_parliament_id(context) item_id = getattr(context, self.value_field, None) trusted = removeSecurityProxy(context) existing_item_ids = [assn.item_id for assn in trusted.values()] if item_id: query = session.query(domain.ParliamentaryItem).filter( domain.ParliamentaryItem.parliamentary_item_id == item_id) else: query = session.query(domain.ParliamentaryItem).filter( sql.and_( sql.not_(domain.ParliamentaryItem.status.in_( _assignable_state_ids ) ), sql.not_( domain.ParliamentaryItem.parliamentary_item_id.in_( existing_item_ids ) ), domain.ParliamentaryItem.parliament_id == parliament_id ) ) return query
def test_findBuildCandidate_supersedes_builds(self): # IBuilder._findBuildCandidate identifies if there are builds # for superseded source package releases in the queue and marks # the corresponding build record as SUPERSEDED. archive = self.factory.makeArchive() self.publisher.getPubSource( sourcename="gedit", status=PackagePublishingStatus.PUBLISHED, archive=archive).createMissingBuilds() old_candidate = removeSecurityProxy( self.frog_builder)._findBuildCandidate() # The candidate starts off as NEEDSBUILD: build = getUtility(IBinaryPackageBuildSet).getByQueueEntry( old_candidate) self.assertEqual(BuildStatus.NEEDSBUILD, build.status) # Now supersede the source package: publication = build.current_source_publication publication.status = PackagePublishingStatus.SUPERSEDED # The candidate returned is now a different one: new_candidate = removeSecurityProxy( self.frog_builder)._findBuildCandidate() self.assertNotEqual(new_candidate, old_candidate) # And the old_candidate is superseded: self.assertEqual(BuildStatus.SUPERSEDED, build.status)
def test_inplace(self): # TODO: should test all inplace operators... P = self.c.proxy pa = P(1) pa += 2 self.assertEqual(removeSecurityProxy(pa), 3) a = [1, 2, 3] pa = qa = P(a) pa += [4, 5, 6] self.failUnless(pa is qa) self.assertEqual(a, [1, 2, 3, 4, 5, 6]) def doit(): pa = P(1) pa += 2 self.shouldFail(doit) pa = P(2) pa **= 2 self.assertEqual(removeSecurityProxy(pa), 4) def doit(): pa = P(2) pa **= 2 self.shouldFail(doit)
def testNamedViewPageViewsNoDefault(self): self.assertEqual(zapi.queryMultiAdapter((ob, request), name='test'), None) test3 = os.path.join(tests_path, 'testfiles', 'test3.pt') xmlconfig(StringIO(template % ''' <browser:view name="test" class="zope.app.component.tests.views.V1" for="zope.app.component.tests.views.IC" permission="zope.Public" > <browser:page name="index.html" attribute="index" /> <browser:page name="action.html" attribute="action" /> <browser:page name="test.html" template="%s" /> </browser:view> ''' % test3 )) view = zapi.getMultiAdapter((ob, request), name='test') view = removeSecurityProxy(view) self.assertEqual(view.browserDefault(request)[1], (u'index.html', )) v = view.publishTraverse(request, 'index.html') v = removeSecurityProxy(v) self.assertEqual(v(), 'V1 here') v = view.publishTraverse(request, 'action.html') v = removeSecurityProxy(v) self.assertEqual(v(), 'done') v = view.publishTraverse(request, 'test.html') v = removeSecurityProxy(v) self.assertEqual(str(v()), '<html><body><p>done</p></body></html>\n')
def testNamedViewPageViewsCustomTraversr(self): self.assertEqual(zapi.queryMultiAdapter((ob, request), name='test'), None) xmlconfig(StringIO(template % ''' <browser:view name="test" class="zope.app.publisher.browser.tests.test_directives.V1" for="zope.app.component.tests.views.IC" permission="zope.Public" > <browser:page name="index.html" attribute="index" /> <browser:page name="action.html" attribute="action" /> </browser:view> ''' )) view = zapi.getMultiAdapter((ob, request), name='test') view = removeSecurityProxy(view) self.assertEqual(view.browserDefault(request)[1], (u'index.html', )) v = view.publishTraverse(request, 'index.html') v = removeSecurityProxy(v) self.assertEqual(v(), 'V1 here') v = view.publishTraverse(request, 'action.html') v = removeSecurityProxy(v) self.assertEqual(v(), 'done')
def calculate_for_scale(self, received_answers): answers = self.getAnswers(received_answers) values = 0 for answer in answers: if answer.has_key('value'): values += int(answer['value'].value) self.values = values results = [result for result in self.context.values() if IQuizResult.providedBy(result)] results.sort(key=lambda x: IAnnotations(removeSecurityProxy(x)).get(INTERVAL_KEY)) if values == 0: self.result = results[0] return if values >= IAnnotations(removeSecurityProxy(results[-1])).get(INTERVAL_KEY): self.result = results[-1] return for i,v in enumerate(results): if i == 0:bottom_border = 0 else: bottom_border = IAnnotations(removeSecurityProxy(results[i-1])).get(INTERVAL_KEY) top_border = IAnnotations(removeSecurityProxy(v)).get(INTERVAL_KEY) if bottom_border <= values <= top_border: self.result = v return
def merge_pofiletranslators(from_template, to_template): """Merge POFileTranslator entries from one template into another. """ # Import here to avoid circular import. from lp.translations.interfaces.pofiletranslator import ( IPOFileTranslatorSet) pofiletranslatorset = getUtility(IPOFileTranslatorSet) affected_rows = pofiletranslatorset.getForTemplate(from_template) for pofiletranslator in affected_rows: person = pofiletranslator.person from_pofile = pofiletranslator.pofile to_pofile = to_template.getPOFileByLang(from_pofile.language.code) pofiletranslator = removeSecurityProxy(pofiletranslator) if to_pofile is None: # There's no POFile to move this to. We could create one, # but it's probably not worth the trouble. pofiletranslator.destroySelf() else: existing_row = pofiletranslatorset.getForPersonPOFile( person, to_pofile) date_last_touched = pofiletranslator.date_last_touched if existing_row is None: # Move POFileTranslator over to representative POFile. pofiletranslator.pofile = to_pofile elif existing_row.date_last_touched < date_last_touched: removeSecurityProxy(existing_row).destroySelf() else: pofiletranslator.destroySelf()
def test_unsubscribe_pillar_artifacts_specific_info_types(self): # Only remove subscriptions for bugs of the specified info type. person_grantee = self.factory.makePerson(name='grantee') owner = self.factory.makePerson(name='pillarowner') pillar = self.factory.makeProduct(owner=owner) # Make bugs the person_grantee is subscribed to. bug1, ignored = self._make_subscribed_bug( person_grantee, pillar, information_type=InformationType.USERDATA) bug2, ignored = self._make_subscribed_bug( person_grantee, pillar, information_type=InformationType.PRIVATESECURITY) # Now run the job, removing access to userdata artifacts. getUtility(IRemoveArtifactSubscriptionsJobSource).create( pillar.owner, pillar=pillar, information_types=[InformationType.USERDATA]) with block_on_job(self): transaction.commit() self.assertNotIn( person_grantee, removeSecurityProxy(bug1).getDirectSubscribers()) self.assertIn( person_grantee, removeSecurityProxy(bug2).getDirectSubscribers())
def validate_unique(self, action, data): """Validate unique. Since this class always adds a single object, we can safely return an empty list of errors. """ errors = [] dm = removeSecurityProxy(self.domain_model) # find unique columns in data model.. TODO do this statically mapper = sa.orm.class_mapper(dm) ucols = list(unique_columns(mapper)) # query out any existing values with the same unique values, session = Session() # find data matching unique columns ctx = removeSecurityProxy(self.context) ctx_is_dm_instance = isinstance(ctx, dm) # !+when is this not true? for key, col in ucols: if key in data: # on edit ignore new value if its the same as the previous value if ctx_is_dm_instance and data[key] == getattr(ctx, key, None): continue value = session.query(dm).filter(col == data[key]).count() if not value: continue errors.append(self.set_widget_error(key, _(u"A record with this value already exists"))) return errors
def delete_subobjects(self): """Delete subobjects. 1) For category maintenance, move the scheduling to the bottom of the container. 2) Delete any discussion items that have been associated to this scheduling. """ field = self.request.form['field'] reorder_form = ItemScheduleReorderForm(self.context, self.request) container = copy.copy(removeSecurityProxy(self.context.__parent__)) subset_query = container.subset_query container.subset_query = sql.and_( subset_query, container.domain_model.planned_order > self.context.planned_order) for i in range(len(container) * 2): reorder_form.handle_move.success({'mode': 'down', 'field': field}) container.subset_query = subset_query count = 0 session = Session() unproxied = removeSecurityProxy(self.context) for key, discussion in unproxied.discussions.items(): del unproxied.discussions[key] session.delete(discussion) count += 1 #session.close() return count
def constructQuery(self, context): session= Session() trusted=removeSecurityProxy(context) parliament_id = self._get_parliament_id(context) trusted = removeSecurityProxy(context) assigned_committee_ids = [] if IGroupGroupItemAssignment.providedBy(trusted): committee_id = getattr(trusted, "group_id", None) if committee_id: query = session.query(domain.Committee).filter( sql.and_( domain.Committee.parent_group_id == parliament_id, domain.Committee.group_id == committee_id ) ) return query else: assigned_committee_ids = \ [ comm.group_id for comm in trusted.__parent__.values() ] else: assigned_committee_ids = \ [ comm.group_id for comm in trusted.values() ] query = session.query(domain.Committee).filter( sql.and_( domain.Committee.status == 'active', domain.Committee.parent_group_id == parliament_id, sql.not_( domain.Committee.group_id.in_(assigned_committee_ids) ) ) ) return query
def mergeTranslationMessages(self): """Share `TranslationMessage`s between templates where possible.""" order_check = OrderingCheck( key=methodcaller('sharingKey'), reverse=True) for template_number, template in enumerate(self.potemplates): log.info("Merging template %d/%d." % ( template_number + 1, len(self.potemplates))) deletions = 0 order_check.check(template) potmsgset_ids = self._getPOTMsgSetIds(template) for potmsgset_id in potmsgset_ids: potmsgset = POTMsgSet.get(potmsgset_id) tm_ids = self._partitionTranslationMessageIds(potmsgset) before = sum([len(sublist) for sublist in tm_ids], 0) for ids in tm_ids: for id in ids: message = TranslationMessage.get(id) removeSecurityProxy(message).shareIfPossible() self.tm.endTransaction(intermediate=True) after = potmsgset.getAllTranslationMessages().count() deletions += max(0, before - after) report = "Deleted TranslationMessages: %d." % deletions if deletions > 0: log.info(report) else: log.log(DEBUG2, report)
def createAndAdd(self, data): ob = super(AddForm, self).createAndAdd(data) self.created_object = ob # execute domain.Entity on create hook removeSecurityProxy(ob).on_create() cascade_modifications(ob) return ob
def test_job_notifications_display_failed(self): job = self.makeJob('package_1', failed=True) # Manually poke an error message. removeSecurityProxy(job).extendMetadata( {'error_message': 'Job failed!'}) with person_logged_in(self.archive.owner): view = create_initialized_view( self.archive, "+packages", principal=self.archive.owner) html = view.render() packages_matches = soupmatchers.HTMLContains( # Check the main title. soupmatchers.Tag( 'job summary', 'a', text=re.compile('Copying.*'), attrs={'class': re.compile('job-summary')}), # Check the link to the source archive. soupmatchers.Tag( 'copied from', 'a', text=job.source_archive.displayname, attrs={'class': re.compile('copied-from')}), # Check the presence of the link to remove the notification. soupmatchers.Tag( 'no remove notification link', 'a', text=re.compile('\s*Remove notification\s*'), attrs={'class': re.compile('remove-notification')}), # Check the presence of the error message. soupmatchers.Tag( 'job error msg', 'div', text='Job failed!', attrs={'class': re.compile('job-failed-error-msg')}), ) self.assertThat(html, packages_matches)
def saveDiscussions(self): session = Session() new_record_keys = [] domain_model = removeSecurityProxy(self.context.domain_model) for record in self.data: discussion_text = record.get("body", "") object_id = record.get("object_id", None) if object_id: current_record = removeSecurityProxy(self.context.get(getItemKey(object_id))) current_record.body = discussion_text session.add(current_record) session.flush() notify(ObjectModifiedEvent(current_record)) new_record_keys.append(stringKey(current_record)) else: new_record = domain_model(body=discussion_text, language=get_default_language()) new_record.scheduled_item = removeSecurityProxy(self.context.__parent__) session.add(new_record) session.flush() notify(ObjectCreatedEvent(new_record)) new_record_keys.append(stringKey(new_record)) records_to_delete = [ removeSecurityProxy(self.context.get(key)) for key in self.context.keys() if key not in new_record_keys ] map(session.delete, records_to_delete) map(lambda deleted: notify(ObjectRemovedEvent(deleted)), records_to_delete)
def add_container_menu_items(self, context, container): request = self.request _url = url.absoluteURL(container, request) if IReadContainer.providedBy(container): #XXX should be the same in all containers ? container=proxy.removeSecurityProxy(container) for name, item in container.items(): if context is None: selected = False else: selected = url.same_path_names(context.__name__, name) item = proxy.removeSecurityProxy(item) if IDCDescriptiveProperties.providedBy(item): title = item.title else: props = IDCDescriptiveProperties(item) title = props.title # only items with valid title if title is not None: self.items.append(url.get_menu_item_descriptor( title, selected, _url, name)) default_view_name = queryDefaultViewName(container, self.request) default_view = component.queryMultiAdapter( (container, self.request), name=default_view_name) if hasattr(default_view, "title") and default_view.title is not None: self.items.insert(0, url.get_menu_item_descriptor( default_view.title, sameProxiedObjects(container, self.context), _url))
def setupPPA(self): """Create pending removal publications in cprov PPA. Firstly, transform the cprov & mark PPAs in a ubuntutest PPA, since ubuntu publish configuration is broken in the sampledata. Also create one respective file in disk, so it can be removed and verified. """ ubuntutest = getUtility(IDistributionSet)['ubuntutest'] cprov = getUtility(IPersonSet).getByName('cprov') removeSecurityProxy(cprov.archive).distribution = ubuntutest ppa_pubrecs = cprov.archive.getPublishedSources(u'iceweasel') self.ppa_pubrec_ids = self.markPublishingForRemoval(ppa_pubrecs) mark = getUtility(IPersonSet).getByName('mark') removeSecurityProxy(mark.archive).distribution = ubuntutest ppa_pubrecs = mark.archive.getPublishedSources(u'iceweasel') self.ppa_pubrec_ids.extend(self.markPublishingForRemoval(ppa_pubrecs)) # Fill one of the files in cprov PPA just to ensure that deathrow # will be able to remove it. The other files can remain missing # in order to test if deathrow can cope with not-found files. self.ppa_test_folder = os.path.join( config.personalpackagearchive.root, "cprov", cprov.archive.name) package_folder = os.path.join( self.ppa_test_folder, "ubuntutest/pool/main/i/iceweasel") os.makedirs(package_folder) self.ppa_package_path = os.path.join( package_folder, "iceweasel-1.0.dsc") self.writeContent(self.ppa_package_path)
def traverse(self, obj): 'See IPublisherRequest' publication = self.publication traversal_stack = self._traversal_stack traversed_names = self._traversed_names prev_object = None while True: self._last_obj_traversed = obj if removeSecurityProxy(obj) is not removeSecurityProxy(prev_object): # Invoke hooks (but not more than once). publication.callTraversalHooks(self, obj) if not traversal_stack: # Finished traversal. break prev_object = obj # Traverse to the next step. entry_name = traversal_stack.pop() traversed_names.append(entry_name) obj = publication.traverseName(self, obj, entry_name) return obj
def test_recent_translation_activity(self): # the recent_activity property lists the most recent translation # targets the person has worked on, for active projects only. self._makeReviewer() # make a translation record for an inactive project (will be excluded) [pofile] = self._makePOFiles(1, previously_worked_on=True) removeSecurityProxy(pofile.potemplate.product).active = False # and make one which has not been worked on (will be excluded) self._makePOFiles(1, previously_worked_on=False) # and make one which has a product no longer using translations (will # be excluded) [pofile] = self._makePOFiles(1, previously_worked_on=True) naked_product = removeSecurityProxy(pofile.potemplate.product) naked_product.translations_usage = ServiceUsage.NOT_APPLICABLE pofiles_worked_on = self._makePOFiles(11, previously_worked_on=True) # the expected results person_name = urllib.urlencode({'person': self.view.context.name}) expected_links = [ (pofile.potemplate.translationtarget.title, canonical_url(pofile, view_name="+filter") + "?%s" % person_name) for pofile in pofiles_worked_on[:10]] recent_activity = self.view.recent_activity self.assertContentEqual( expected_links, ((item.title, item.url) for item in recent_activity))
def make_erics_fooix_project(factory): """Make Eric, the Fooix project, and some branches. :return: a dict of objects to put into local scope. """ eric = factory.makePerson(name="eric", displayname="Eric the Viking", email="*****@*****.**") fooix = factory.makeProduct(name="fooix", displayname="Fooix", owner=eric) trunk = factory.makeProductBranch(owner=eric, product=fooix, name="trunk") removeSecurityProxy(fooix.development_focus).branch = trunk # Development is done by Fred. fred = factory.makePerson(name="fred", displayname="Fred Flintstone", email="*****@*****.**") feature = factory.makeProductBranch(owner=fred, product=fooix, name="feature") proposed = factory.makeProductBranch(owner=fred, product=fooix, name="proposed") bmp = proposed.addLandingTarget( registrant=fred, target_branch=trunk, needs_review=True, review_requests=[(eric, "code")] ) # And fake a diff. naked_bmp = removeSecurityProxy(bmp) preview = removeSecurityProxy( naked_bmp.updatePreviewDiff("".join(unified_diff("", "random content")), u"rev-a", u"rev-b") ) naked_bmp.source_branch.last_scanned_id = preview.source_revision_id naked_bmp.target_branch.last_scanned_id = preview.target_revision_id preview.diff_lines_count = 47 preview.added_lines_count = 7 preview.remvoed_lines_count = 13 preview.diffstat = {"file1": (3, 8), "file2": (4, 5)} return {"eric": eric, "fooix": fooix, "trunk": trunk, "feature": feature, "proposed": proposed, "fred": fred}
def set_sitting_parent_ids(ob, event): """We add the group ID/sesssion id if adding a sitting in contexts not bound to groups in traversal hierarchy """ scheduling_context = ISchedulingContext(ob.__parent__, None) if ob.group_id is None: if scheduling_context is not None: ob.group_id = removeSecurityProxy(scheduling_context).group_id if ob.session_id is None or IObjectModifiedEvent.providedBy(event): if scheduling_context is not None: group = scheduling_context.get_group() if interfaces.IParliament.providedBy(group): container = removeSecurityProxy(group).sessions else: return else: try: container = ob.group.sessions except AttributeError: return try: session_id = container._query.filter( sql.and_( domain.Session.start_date < ob.start_date, domain.Session.end_date > ob.end_date ) ).one().session_id ob.session_id = session_id except (orm.exc.NoResultFound, orm.exc.MultipleResultsFound): log.error("Could not determine session for sitting %s", ob)
def _makeProductSeries(self, branch): """Create a `ProductSeries` that imports templates from `branch`.""" productseries = self.factory.makeProductSeries() removeSecurityProxy(productseries).branch = branch removeSecurityProxy(productseries).translations_autoimport_mode = ( TranslationsBranchImportMode.IMPORT_TEMPLATES) return productseries
def update(self): if removeSecurityProxy(self.context).has_key('lead'): #returns LeadEditForm lead = getMultiAdapter((self.context['lead'], self.request, self),IContentProvider, name=u'qreature.QreatureGeneralVM') lead.update() self.viewlets = [lead] #handle delete if not removeSecurityProxy(self.context).has_key('lead'): #self.cleanTermsStorage() if self.first_widget: self.something_happened_with_da_first = True no_lead = getMultiAdapter((self.context, self.request, self),IContentProvider, name=u'qreature.QreatureGeneralVM') no_lead.update() no_lead.viewlets = [viewlet for viewlet in no_lead.viewlets if IInlineAddForm.providedBy(viewlet)] self.viewlets = [no_lead] else: no_lead = getMultiAdapter((self.context, self.request, self),IContentProvider, name=u'qreature.QreatureGeneralVM') no_lead.update() no_lead.viewlets = [viewlet for viewlet in no_lead.viewlets if IInlineAddForm.providedBy(viewlet)] self.viewlets = [no_lead] #handle add if removeSecurityProxy(self.context).has_key('lead'): #self.cleanTermsStorage() if self.first_widget: self.something_happened_with_da_first = True lead = getMultiAdapter((self.context['lead'], self.request, self),IContentProvider, name=u'qreature.QreatureGeneralVM') lead.update() self.viewlets = [lead]
def test_been_mirrored(self): # `check_default_stacked_on` returns the branch if it has revisions. branch = self.factory.makeAnyBranch() removeSecurityProxy(branch).branchChanged( '', self.factory.getUniqueString(), None, None, None) self.assertEqual(branch, check_default_stacked_on(branch))
def title(self): session = Session() context = session.merge(removeSecurityProxy(self.context)) return "%s %s %s" % (context.titles, context.first_name, context.last_name)
def _setDevelopmentFocus(self, product, branch): removeSecurityProxy(product).development_focus.branch = branch
def test_retargetBranch_personalBranch(self): # Retarget an existing personal branch to this target. branch = self.factory.makePersonalBranch() self.target._retargetBranch(removeSecurityProxy(branch)) self.assertEqual(self.target, branch.target)
def __init__(self, context): self.context = removeSecurityProxy(context)
def __call__(self): need("yui-datatable") self.context = removeSecurityProxy(self.context) return self.render()
def getDefaultTraversal(self, request, ob): obj, path = super(GrokBrowserPublication, self).getDefaultTraversal(request, ob) return removeSecurityProxy(obj), path
def getApplication(self, request): result = super(ZopePublicationSansProxy, self).getApplication(request) return removeSecurityProxy(result)
def handleApply(self, action): container = ITimetableContainer(self.context) container.default = removeSecurityProxy(self.context) self.ajax_settings['dialog'] = 'close'
def publish_to_xml(context): """Generates XML for object and saves it to the file. If object contains attachments - XML is saved in zip archive with all attached files. """ include = [] context = removeSecurityProxy(context) if IVersionable.implementedBy(context.__class__): include.append("versions") if IAuditable.implementedBy(context.__class__): include.append("event") data = obj2dict(context, 1, parent=None, include=include, exclude=[ "file_data", "image", "logo_data", "event", "attached_files", "changes" ]) type = IWorkflow(context).name tags = IStateController(context).get_state().tags if tags: data["tags"] = tags permissions = get_object_state_rpm(context).permissions data["permissions"] = get_permissions_dict(permissions) data["changes"] = [] for change in getattr(context, "changes", []): change_dict = obj2dict(change, 0, parent=context) change_permissions = get_head_object_state_rpm(change).permissions change_dict["permissions"] = get_permissions_dict(change_permissions) data["changes"].append(change_dict) # list of files to zip files = [] # setup path to save serialized data path = os.path.join(setupStorageDirectory(), type) if not os.path.exists(path): os.makedirs(path) # xml file path file_path = os.path.join(path, stringKey(context)) has_attachments = False if IAttachmentable.implementedBy(context.__class__): attached_files = getattr(context, "attached_files", None) if attached_files: has_attachments = True # add xml file to list of files to zip files.append("%s.xml" % (file_path)) data["attached_files"] = [] for attachment in attached_files: # serializing attachment attachment_dict = obj2dict( attachment, 1, parent=context, exclude=["file_data", "event", "versions", "changes"]) permissions = get_object_state_rpm(attachment).permissions attachment_dict["permissions"] = \ get_permissions_dict(permissions) # saving attachment to tmp with tmp(delete=False) as f: f.write(attachment.file_data) files.append(f.name) attachment_dict["saved_file"] = \ os.path.split(f.name)[-1] data["attached_files"].append(attachment_dict) # saving xml file with open("%s.xml" % (file_path), "w") as file: file.write(serialize(data, name=type)) # zipping xml and attached files # unzipped files are removed if has_attachments: zip = ZipFile("%s.zip" % (file_path), "w") for f in files: zip.write(f, os.path.split(f)[-1]) os.remove(f) zip.close()
def get_note(self): """Return Notes if supplied by context. """ context = removeSecurityProxy(self.context) if getattr(context, "note", False): return context.note
def retryErrorTypes(self, job): return removeSecurityProxy(job).retry_error_types
def assertVisible(self, distro, branch, person): self.assertTrue( # Double-checking. removeSecurityProxy(branch).visibleByUser(person)) self.assertEqual(1, len(distro.getBranchTips(user=person)))
def __init__(self, context, request): self.context = removeSecurityProxy(context) self.request = request
def __lt__(self, job): naked_job = removeSecurityProxy(job) if self.__class__ is naked_job.__class__: return self.__dict__ < naked_job.__dict__ else: return NotImplemented
def _getUserIdentifiers(self, user): """Return the user's openid_identifier.""" from zope.security.proxy import removeSecurityProxy return [ identifier.identifier for identifier in removeSecurityProxy(user.account).openid_identifiers]
def __eq__(self, job): naked_job = removeSecurityProxy(job) return (self.__class__ is naked_job.__class__ and self.__dict__ == naked_job.__dict__)
def userErrorTypes(self, job): return removeSecurityProxy(job).user_error_types
def get_feed_entries(self): return get_changes(removeSecurityProxy(self.context), "workflow")
def prefix(self): context = proxy.removeSecurityProxy(self.context) return "container_contents_%s" % (naming.as_identifier( context.__name__))
def __init__(self, context, request): super(KSSView, self).__init__(context, request) self.context = removeSecurityProxy(context)
def _getBuildQueueItem(self, behavior): """Get `BuildQueue` for an `IBuildFarmJobBehavior`.""" job = removeSecurityProxy(behavior.buildfarmjob.job) return IStore(BuildQueue).find(BuildQueue, job=job).one()
def unset_group_local_role(context): role = _get_group_local_role(context) group = removeSecurityProxy(context) ctx = _get_group_context(context) IPrincipalRoleMap(ctx).unsetRoleForPrincipal( role, group.group_principal_id)
def _get_group_context(context): if interfaces.IOffice.providedBy(context): return BungeniApp() #get_parliament(context) else: return removeSecurityProxy(context)
def set_group_local_role(context): role = _get_group_local_role(context) group = removeSecurityProxy(context) ctx = _get_group_context(context) IPrincipalRoleMap(ctx).assignRoleToPrincipal( role, group.group_principal_id)
def fetchPolicies(self, specification): # We may be dealing with private specs, so just ignore security. return IStore(Specification).execute( "SELECT access_policy, access_grants FROM specification WHERE " "id = ?", (removeSecurityProxy(specification).id, )).get_one()
def __init__(self, object): try: self.is_private = removeSecurityProxy(object).private except AttributeError: self.is_private = False
def traverseName(self, request, ob, name, check_auth=1): # Fake the virtual host if name == "vh": return ProxyFactory(ob) return super(HookPublication, self).traverseName( request, removeSecurityProxy(ob), name, check_auth=1)
def domain_model(self): return type(removeSecurityProxy(self.context))
def setParliamentId(info, context): instance = removeSecurityProxy(context) if not instance.parliament_id: parliamentId = prefs.getCurrentParliamentId() instance.parliament_id = parliamentId