Python saconfig.Session类代码示例

 def test_get(self):
     import datetime
     import json
     from z3c.saconfig import Session
     from euphorie.client.model import Company
     from euphorie.client.model import SurveySession
     from euphorie.content.tests.utils import BASIC_SURVEY
     from euphorie.client.tests.utils import addAccount
     from euphorie.client.tests.utils import addSurvey
     from euphorie.client.api.authentication import generate_token
     from Products.Five.testbrowser import Browser
     self.loginAsPortalOwner()
     addSurvey(self.portal, BASIC_SURVEY)
     account = addAccount(password='secret')
     survey_session = SurveySession(
             title=u'Dummy session',
             created=datetime.datetime(2012, 4, 22, 23, 5, 12),
             modified=datetime.datetime(2012, 4, 23, 11, 50, 30),
             zodb_path='nl/ict/software-development',
             account=account,
             company=Company(country='nl',
                             employees='1-9',
                             referer='other'))
     Session.add(survey_session)
     browser = Browser()
     browser.addHeader('X-Euphorie-Token', generate_token(account))
     browser.open(
             'http://nohost/plone/client/api/users/1/sessions/1/company')
     self.assertEqual(browser.headers['Content-Type'], 'application/json')
     response = json.loads(browser.contents)
     self.assertEqual(response['type'], 'company')

 def test_with_introduction(self):
     import datetime
     import json
     from z3c.saconfig import Session
     from euphorie.client.model import SurveySession
     from euphorie.client.api.authentication import generate_token
     from euphorie.content.tests.utils import BASIC_SURVEY
     from euphorie.client.tests.utils import addAccount
     from euphorie.client.tests.utils import addSurvey
     self.loginAsPortalOwner()
     addSurvey(self.portal, BASIC_SURVEY)
     survey = self.portal.client['nl']['ict']['software-development']
     survey.introduction = u'<p>Fancy intro.</p>'
     account = addAccount(password='secret')
     survey_session = SurveySession(
             title=u'Dummy session',
             created=datetime.datetime(2012, 4, 22, 23, 5, 12),
             modified=datetime.datetime(2012, 4, 23, 11, 50, 30),
             zodb_path='nl/ict/software-development',
             account=account)
     Session.add(survey_session)
     browser = Browser()
     browser.addHeader('X-Euphorie-Token', generate_token(account))
     browser.open('http://nohost/plone/client/api/users/1/sessions/1')
     self.assertEqual(browser.headers['Content-Type'], 'application/json')
     response = json.loads(browser.contents)
     self.assertTrue('introduction' in response)
     self.assertEqual(response['introduction'], u'<p>Fancy intro.</p>')

 def set(self, value, _sa_initiator=None):
     key = self.keyfunc(value)
     if key is None:
         session = Session()
         session.flush()
         key = self.keyfunc(value)
     self.__setitem__(key, value, _sa_initiator)

    def render(self):
        dbtable_surveys = 'statistics_surveys'
        info_surveys = self.getSurveysInfo()
        # write to db
        session = Session()
        session.execute('''DELETE FROM %s;''' % dbtable_surveys)

        def clean(value):
            if isinstance(value, basestring):
                return safe_unicode(value).strip().encode('utf-8')
            return value

        def pg_format(value):
            if value is None:
                return 'NULL'
            if isinstance(value, datetime):
                return "TIMESTAMP '%s'" % value.isoformat()
            return "'%s'" % value

        for line in info_surveys:
            insert = '''INSERT INTO %s VALUES %s;''' % \
                     (dbtable_surveys, '(%s)' % ', '.join(map(pg_format,
                      map(clean, line))))
            session.execute(insert)
        datamanager.mark_changed(session)
        transaction.get().commit()
        from pprint import pformat
        return "Written:\n" + pformat(info_surveys)

def enable_longer_zodb_paths(context):
    session = Session()
    session.execute(
        "ALTER TABLE %s ALTER COLUMN zodb_path TYPE varchar(512);" %
        model.SurveyTreeItem.__table__.name
    )
    datamanager.mark_changed(session)

 def get_kursteilnehmer(self, ktn_id):
     session = Session()
     from fernlehrgang.models import Kursteilnehmer
     ktn_id, flg_id = ktn_id.split(',')
     ktn = session.query(Kursteilnehmer).get(ktn_id)
     print {'status': ktn.status, 'un_klasse': ktn.un_klasse, 'branche': ktn.branche, 'gespraech': ktn.gespraech}
     return {'status': ktn.status, 'un_klasse': ktn.un_klasse, 'branche': ktn.branche, 'gespraech': ktn.gespraech}

 def get_categories_without_other(self):
     session = Session()
     cat = session.query(Category).filter(Category.organization_id == self.organization_id).all()
     if len(cat) != 1:
         raise IndexError('Only one Category class by organization is possible.')
     categories = cat[0].get_list()
     return categories

 def saveResult(self, body):
     from fernlehrgang import models
     session = Session()
     data = simplejson.loads(body)
     teilnehmer_id = data.pop('teilnehmer_id')
     ktn = session.query(models.Kursteilnehmer).get(data.get('kursteilnehmer_id'))
     data['datum'] = datetime.now()
     data['system'] = "Virtuelle Lernwelt"
     data['gbo'] = "OK"
     orgas = data.pop('orgas')
     gbo_daten = self.createGBODaten(ktn, orgas)
     data['gbo_daten'] = simplejson.dumps(gbo_daten)
     data['lehrheft_id'] = 1055
     data['frage_id'] = 10550
     gbo_u = data.pop('gbo_uebermittelung')
     antwort = models.Antwort(**data)
     ktn.antworten.append(antwort)
     je = models.JournalEntry(type="Abschluss Virtuelle Lernwelt", status="info", kursteilnehmer_id=ktn.id)
     ktn.teilnehmer.journal_entries.append(je)
     gbo_status=""
     if gbo_u:
         from fernlehrgang.api.gbo import GBOAPI
         gbo_api = GBOAPI()
         r = gbo_api.set_data(gbo_daten) 
         gbo_status = r.status_code
         print "TANSERFER DATA TO GBO"
     result = ICalculateResults(ktn).summary()
     result['kursteilnehmer_id'] = data.get('kursteilnehmer_id')
     result['teilnehmer_id'] = teilnehmer_id
     result['ist_gespeichert'] = True
     result['an_gbo_uebermittelt'] = gbo_u
     result['gbo_comment'] = gbo_status
     print result 
     return result

 def setLogEntry(self, body, message):
     log_entry = simplejson.loads(body)
     from fernlehrgang import models
     typ = log_entry.pop('typ')
     if typ == "ausstattung":
         log_entry['type'] = u"Ausstattung Büro %s, Lager %s, Verkauf %s" % (
             log_entry.pop('buero'),
             log_entry.pop('lager'),
             log_entry.pop('verkauf'))
     elif typ == "fortschritt":
         log_entry.pop('position')
         log_entry['kursteilnehmer_id'] = int(log_entry['kursteilnehmer_id'])
         log_entry['type'] = u"Level %s (%s) zu %s abgeschlossen." % (
             log_entry.pop('title'),
             log_entry.pop('key'),
             log_entry.pop('progress'))
         log_entry['type'] = log_entry['type'][:30]
     try:
         with transaction.manager as tm:
             session = Session()
             teilnehmer = session.query(models.Teilnehmer).get(int(log_entry.get('teilnehmer_id')))
             if teilnehmer:
                 je = models.JournalEntry(**log_entry)
                 teilnehmer.journal_entries.append(je)
                 message.ack()
     except:
         logger.exception('Error')

    def handleSubmit(self, action):
        data, errors = self.extractData()
        if not errors:
            session = Session()
            searched_categories = data.get('categories')
            search = data.get('search')
            if search == None:
                search = u""
            request = session.query(Organization)
            if search:
                additionalinformations = session.query(AdditionalInformation).filter(func.lower(AdditionalInformation.objectif).like(u'%{0}%'.format(search).lower())).all()
                request = request.filter(or_
                        (func.lower(Organization.name).like(u'%{0}%'.format(search).lower()),
                        (Organization.organization_id.in_([addit.organization_id for addit in additionalinformations]))))

            for categorie in searched_categories:
                if categorie == 'enseignement_formation':
                    request = request.filter(
                                    or_(Organization.category.has(getattr(Category, 'tutoring') == True),
                                    Organization.category.has(getattr(Category, 'training') == True),
                                    Organization.category.has(getattr(Category, 'education') == True)))
                else:
                    request = request.filter(Organization.category.has(getattr(Category, categorie) == True))
            request = request.filter(Organization.language == self.context.Language())
            request = request.order_by(Organization.name)
            self.searched_categories = searched_categories
            self.results = request.all()
            if len(self.results) == 0:
                self.status = _(u"No organization found.")
            else:
                self.request.SESSION.set(SESSION_SEARCH, self.results)
                self.request.SESSION.set(SESSION_CATEGORIES, self.searched_categories)
                self.request.response.redirect('organizations_search?search_term={0}'.format(search.encode('utf8')))

    def test_add(self):
        session = Session()
        session.add(Organization(name=u"Vin", language="fr"))
        self.assertEqual(len(session.query(Organization).all()), 1)

        orga = session.query(Organization).first()
        self.assertEqual(orga.name, u"Vin")

    def get_results(self):
        if not 'SESSION' in self.request.keys():
            return None

        if SESSION_JSON in self.request.SESSION.keys():
            self.request.SESSION.delete(SESSION_JSON)

        if len(self.results) == 0:
            return None

        session = Session()
        json_organisations = []
        sa_results = []
        for orga in self.results:
            sa_orga = session.query(Organization).get(orga.organization_id)
            sa_results.append(sa_orga)
            dict_orga = {}
            dict_orga['id'] = sa_orga.organization_id
            dict_orga['name'] = sa_orga.name
            dict_orga['x'] = sa_orga.x
            dict_orga['y'] = sa_orga.y
            dict_orga['street'] = u"{0}, {1}".format(sa_orga.address.num, sa_orga.address.street)
            dict_orga['city'] = u"{0} {1}".format(sa_orga.address.post_code, sa_orga.address.municipality)
            dict_orga['url'] = "{0}/org/{1}/oview".format(self.context.absolute_url(), sa_orga.organization_id)
            dict_orga['icon'] = "{0}/++resource++map_pin.png".format(self.context.portal_url())
            json_organisations.append({'orga': dict_orga})

        self.request.SESSION.set(SESSION_JSON, json_organisations)
        self.results = sa_results
        return sa_results

    def getStats(self):
        """Get statistics for all questions in the lecture"""

        if IQuestion.providedBy(self.context):
            # Return just the current question and it's DB object
            dbQns = (Session.query(db.Question)
                .filter(db.Question.plonePath == '/'.join(self.context.getPhysicalPath()))
                .filter(db.Question.active == True)
                .order_by(db.Question.plonePath))
        else:
            # TODO: Batching, optimise query
            dbQns = (Session.query(db.Question)
                .filter(db.Question.lectures.contains(self.getDbLecture()))
                .filter(db.Question.active == True)
                .order_by(db.Question.plonePath))

        out = []
        for dbQn in dbQns:
            plonePath = str(dbQn.plonePath)
            queryString = None
            if '?' in plonePath:
                (plonePath, queryString) = plonePath.split('?', 1)
            plQn = self.portalObject().unrestrictedTraverse(plonePath)

            out.append(dict(
                url=plQn.absolute_url() + ('?%s' % queryString if queryString else ""),
                id=plQn.getId() + ('?%s' % queryString if queryString else ""),
                title=plQn.Title(),
                timesAnswered=dbQn.timesAnswered,
                timesCorrect=dbQn.timesCorrect,
            ))
        return out

 def testTearDown(self):
     self._close_db()
     from fernlehrgang.models import Base
     session = Session()
     Base.metadata.drop_all(session.connection().engine)
     transaction.commit()
     session.close()

 def test_sessions_ordering(self):
     import datetime
     from euphorie.content.tests.utils import BASIC_SURVEY
     from z3c.saconfig import Session
     from AccessControl.SecurityManagement import newSecurityManager
     from ..model import Account
     from ..model import SurveySession
     self.loginAsPortalOwner()
     addSurvey(self.portal, BASIC_SURVEY)
     session = Session()
     account = Account(loginname='johny',
             sessions=[
                 SurveySession(zodb_path='nl/ict/software-development',
                     title=u'One',
                     modified=datetime.datetime(2012, 12, 10)),
                 SurveySession(zodb_path='nl/ict/software-development',
                     title=u'Three',
                     modified=datetime.datetime(2012, 12, 12)),
                 SurveySession(zodb_path='nl/ict/software-development',
                     title=u'Two',
                     modified=datetime.datetime(2012, 12, 11))])
     session.add(account)
     newSecurityManager(None, account)
     view = self.View(self.portal.client['nl'], None)
     self.assertEqual(
             [s['title'] for s in view.sessions()],
             [u'Three', u'Two', 'One'])