def get_userimg(self, team_id): session = named_scoped_session('footballchallenge') team = session.query(Team).filter(Team.id_ == team_id).one() portal_membership = getToolByName(self.context, 'portal_membership') userid = team.user_id portrait = portal_membership.getPersonalPortrait(userid) return portrait.tag()
def updateWidgets(self): super(EditTeamForm, self).updateWidgets() membershiptool = getToolByName(self.context, 'portal_membership') userid = membershiptool.getAuthenticatedMember().getId() session = named_scoped_session('footballchallenge') event_id = session.query(Event).filter(Event.deadline > datetime.now()).one().id_ if not len(session.query(Team).filter_by(user_id=userid).filter_by(event_id=event_id).all()): super(EditTeamForm, self).updateWidgets() return team = session.query(Team).filter_by(user_id=userid).filter_by(event_id=event_id).one() starters = session.query(Teams_Players).filter_by(team_id=team.id_).filter_by(is_starter=True).all() substitutes = session.query(Teams_Players).filter_by(team_id=team.id_).filter_by(is_starter=False).all() self.widgets['name'].value = team.name count = {'defender':1, 'midfield':1, 'striker':1} for starter in starters: if not starter.player.position=="keeper": self.widgets[(starter.player.position + str(count[starter.player.position])).encode('utf-8')].value = str(starter.player.id_), count[starter.player.position] += 1 else: self.widgets["keeper"].value = str(starter.player.id_), count = {'defender':1, 'midfield':1, 'striker':1} for substitute in substitutes: if not substitute.player.position=="keeper": self.widgets["substitute_"+(substitute.player.position + str(count[substitute.player.position])).encode('utf-8')].value = str(substitute.player.id_), count[substitute.player.position] += 1 else: self.widgets["substitute_keeper"].value = str(substitute.player.id_),
def get_ranking(self): """Gets the teams and Totalpoints in right order""" session = named_scoped_session('footballchallenge') league = session.query(League).filter(League.id_ == self.league_id).one() teams = league.teams team_ids = [team.id_ for team in teams] ranking = session.query(Teamstatistics).filter(Teamstatistics.team_id.in_(team_ids)).order_by(desc(Teamstatistics.game_id)).all() teams_in_ranking = {} for rank in ranking: teams_in_ranking[rank.team_id] = teams_in_ranking.get(rank.team_id, 0) + rank.points clean_ranking = sorted(teams_in_ranking.items(), key=lambda k: k[1], reverse=True) correct_ranks = [] rank = 1 last_rank = 1 for index, team in enumerate(clean_ranking): if index >= 1: if clean_ranking[index-1][1] == team[1]: correct_ranks.append([last_rank, team]) rank += 1 else: correct_ranks.append([rank, team]) last_rank = rank rank += 1 else: correct_ranks.append([last_rank, team]) rank += 1 return correct_ranks return clean_ranking
def calculate_team_points(game): """recalculates the team points after a game""" session = named_scoped_session('footballchallenge') teams = session.query(Team).filter_by(event_id = game.events_id).filter_by(valid = True).all() session.query(Teamstatistics).filter(Teamstatistics.game_id == game.id_).delete() points = {} for team in teams: for player in game.players: for teams_players in player.teams: if teams_players.team == team: playerstats = session.query(Playerstatistics).filter_by( player_id = player.id_).filter_by(game_id = game.id_).one() team_player = session.query(Teams_Players).filter_by( team_id = team.id_).filter_by( player_id = player.id_).one() if not points.get(team.id_, None): points[team.id_] = 0 if not team_player.is_starter: points[team.id_]+= playerstats.points/2 else: points[team.id_]+= playerstats.points if not points.get(team.id_): stats=Teamstatistics(team.id_, game.id_, 0) session.add(stats) for key, value in points.items(): old_entry = session.query(Teamstatistics).filter_by(team_id=key).filter_by(game_id=game.id_).all() if len(old_entry): old_entry[0].points = value else: stats=Teamstatistics(key, game.id_, value) session.add(stats) game.calculated = True
def producers(context): items = [] session = named_scoped_session('sqlsession') for producer in session.query(Producer).all(): items.append( SimpleTerm(producer, token=producer.id, title=producer.name)) return SimpleVocabulary(items)
def handleImport(self, action): data, errors = self.extractData() if len(errors) == 0: urls = data['urls'] event = data['event'] session = named_scoped_session('footballchallenge') import_team(urls, session, event) return self.request.RESPONSE.redirect(self.context.absolute_url())
def __call__(self, context): """Returns the Events as SimpleVocabulary to use it as Source for fields""" session = named_scoped_session('footballchallenge') terms=[] events = session.query(Event).all() for event in events: terms.append(vocabulary.SimpleTerm(event.id_, event.id_, event.name)) return vocabulary.SimpleVocabulary(terms)
def updateWidgets(self): super(AssignUserForm, self).updateWidgets() session = named_scoped_session('footballchallenge') league = session.query(League).filter(League.id_ == self.league_id).one() if league.teams: user_ids = [team.user_id for team in league.teams] self.widgets['teams'].value = user_ids self.widgets['teams'].update()
def __call__(self,context): session = named_scoped_session('footballchallenge') terms=[] nations = session.query(Nation).all() for nation in nations: terms.append(vocabulary.SimpleTerm(nation.id_, nation.id_, nation.name)) return vocabulary.SimpleVocabulary(terms)
def get_link(self, team_id): session = named_scoped_session('footballchallenge') team = session.query(Team).filter(Team.id_ == team_id).one() portal_url = getToolByName(self.context, 'portal_url') portal = portal_url.getPortalObject() url = portal.absolute_url() link = '<a href="%s/team_overview/%s">%s</a>' % (url, team.id_, team.name) return link
def __call__(self, context): """a Proxy function which returns keeper term""" session = named_scoped_session("footballchallenge") event_id = session.query(Event).filter(Event.deadline > datetime.now()).one().id_ leagues = session.query(League).filter(League.event_id == event_id).all() terms = [] for league in leagues: terms.append(vocabulary.SimpleTerm(league.id_, league.id_, league.name)) return vocabulary.SimpleVocabulary(terms)
def __call__(self): session = named_scoped_session('footballchallenge') if not session.query(Event).filter(Event.deadline > datetime.now()).all(): msg = _(u'label_not_edit', default="The Event has started. You can't edit your Team now.") IStatusMessage(self.request).addStatusMessage( msg, type='error') return self.request.response.redirect(self.context.absolute_url()) else: return super(EditTeamForm, self).__call__()
def plominoSqlSync(session, plominoDocument, **table_infos): """ table_infos = dict(schema='<schema_table>') """ if isinstance(session, basestring): session = named_scoped_session(session) engine = session.get_bind() db = SqlSoup(engine, session=session) table_name = plominoDocument.Form main_table = db.entity(table_name, **table_infos) values = dict() plominoItems = plominoDocument.getItems() for column in main_table.c: if column.key == u"id": continue if column.key in plominoItems and (plominoDocument.getItem(column.key, None) != None): values[column.key] = plominoDocument.getItem(column.key) plominoDatabase = plominoDocument.getParentDatabase() values[u"modified_by"] = plominoDatabase.getCurrentUser().id values[u"last_update"] = plominoDocument.plomino_modification_time.asdatetime() if plominoDocument.isNewDocument(): values[u"plominoId"] = plominoDocument.id main_table.insert(**values) else: if not main_table.filter(main_table.plominoId == plominoDocument.id).update(values): values[u"plominoId"] = plominoDocument.id main_table.insert(**values) plominoForm = plominoDatabase.getForm(plominoDocument.Form) plominoFields = plominoForm.getFormFields(includesubforms=True, applyhidewhen=True) for field in plominoFields: if field.getFieldType() in ("DATAGRID",) and (plominoDocument.getItem(field.id) != None): gridItem = plominoDocument.getItem(field.id) grid_table_name = field.id # oppure field.getSettings(key='associated_form') try: grid_table = db.entity(grid_table_name, **table_infos) except NoSuchTableError, err: pass else: grid_table.filter(grid_table.parentId == plominoDocument.id).delete() vals = dict() for record in gridItem: field_mapping = field.getSettings(key="field_mapping").split(",") for idx, key in enumerate(field_mapping): if record[idx] != None: vals[key] = record[idx] vals[u"parentId"] = plominoDocument.id grid_table.insert(**vals)
def __call__(self): session = named_scoped_session('footballchallenge') player = session.query(Player).filter( Player.id_ == self.player_id).first() if player is None: raise NotFound(self, self.player_id, self.request) self.request.response.setHeader('Content-Type', 'image/jpeg') self.request.response.setHeader('Content-Length', len(player.image)) self.request.response.write(player.image)
def __call__(self): session = named_scoped_session('footballchallenge') games = session.query(Game).filter(Game.calculated == False).all() for game in games: calculate_player_points(game) # calculate_team_points(game) game.calculated = True transaction.commit() return self.request.response.redirect(self.context.absolute_url())
def session(self): if not self._session: xmlconfig.xmlconfig(StringIO(""" <configure xmlns="http://namespaces.zope.org/db"> <session name="footballchallenge" engine="footballchallenge.db" /> </configure>""")) self._session = named_scoped_session("footballchallenge") return self._session
def create_sql_content(event): try: print "Injecting SQL content" with transaction.manager: session = named_scoped_session('sqlsession') for id, name in CATEGORIES: cat = Category(id=id, name=name) session.add(cat) except IntegrityError: # data already exists, skipping. print "SQL content was already created"
def get_tabs(self): tabs = [] session = named_scoped_session("footballchallenge") event_id = session.query(Event).all()[-1].id_ leagues = session.query(League).filter(League.event_id == event_id).all() for league in leagues: self.register_league_tab(league) tabs.append({'id': _('league-%i' % league.id_, default=league.name), 'class': ''}) return tabs
def handleSave(self, action): """Handles the Edit action of the form""" data, errors = self.extractData() #If all validators are ok: proceed if len(errors) == 0: #get the session from z3c.sacofig session = named_scoped_session('footballchallenge') event_id = session.query(Event).filter( Event.deadline > datetime.now()).one().id_ #get the userid we need it to find the right team membershiptool = getToolByName(self.context, 'portal_membership') userid = membershiptool.getAuthenticatedMember().getId() if not session.query(Team).filter_by(user_id=userid).filter_by(event_id=event_id).all(): #create the team if it doesn't exist. team = Team(userid, event_id, name=data['name']) session.add(team) else: team = session.query(Team).filter_by(user_id=userid).filter_by(event_id=event_id).one() session.query(Teams_Players).filter(Teams_Players.team_id==\ team.id_).delete() team.name = data['name'] nations = [] all_nations = [] for k, v in data.items(): if not k == 'name' and v: player = session.query(Player).filter(Player.id_ == v).one() #Create relationsship between Team and Player if bool(not 'substitute' in k): if not player.nation_id in nations: nations.append(player.nation_id) if not player.nation_id in all_nations: all_nations.append(player.nation_id) else: if not player.nation_id in all_nations: all_nations.append(player.nation_id) team.players.append(Teams_Players(team.id_, player, bool(not 'substitute' in k))) if len(nations) >= 6 and len(all_nations) >=12 and len(team.players) == 22: team.valid = True else: msg = _(u'label_not_valid', default=u'Your Team is not valid and will not receive any points') IStatusMessage(self.request).addStatusMessage( msg, type='warning') team.valid = False msg = _(u'label_changes_saved', default=u'Your changes are saved successfully') IStatusMessage(self.request).addStatusMessage( msg, type='info') return self.request.RESPONSE.redirect(self.context.absolute_url()+'/team_overview')
def handleImport(self, action): data, errors = self.extractData() if len(errors) == 0: name = data['name'] event = data['event'] session = named_scoped_session('footballchallenge') league = League(name, event) session.add(league) portal_actions = getToolByName(self.context, 'portal_actions') transaction.commit() msg = _(u'league_created', default=u'League created successfully') IStatusMessage(self.request).addStatusMessage( msg, type='information') return self.request.RESPONSE.redirect(self.context.absolute_url()+'/ranking/'+str(league.id_))
def nations(self): context = aq_inner(self.context) base_url = context.absolute_url() session = named_scoped_session('footballchallenge') results = [] for nation in session.query(Nation).order_by(Nation.name).all(): info = dict( title=nation.name, url='%s/%s' % (base_url.rstrip('/')+'/nation', nation.id_), coach=nation.coach, participations=nation.participations, rank=nation.fifa_rank, ) results.append(info) return results
def update(self): session = named_scoped_session('footballchallenge') last_game = session.query(Game).filter(Game.calculated == True).order_by(desc(Game.date)).first() self.ranking = None if last_game: round_ = last_game.round_ gameids = session.query(Game.id_).filter_by(calculated = True).filter_by(round_ = round_).all() teamstats = session.query(Teamstatistics).filter(Teamstatistics.game_id.in_(gameids)).all() teams = {} for teamstat in teamstats: if not teams.get(teamstat.team_id): teams[teamstat.team_id] = {'team': teamstat.team, 'points':teamstat.points} else: teams[teamstat.team_id]['points'] += teamstat.points self.ranking = sorted(teams.iteritems(), key=lambda (k,v): itemgetter(1)(v))
def get_player_term(context, position=None, nation=None): """Returns the players as SimpleVocabulary""" terms=[] session = named_scoped_session('footballchallenge') event_id = session.query(Event).filter( Event.deadline > datetime.now()).one().id_ if not position and not nation: players = session.query(Player).filter( Player.event_id == event_id).order_by(Player.name).all() elif position and not nation: players = session.query(Player).filter( Player.position==position and \ Player.event_id == event_id).order_by(Player.name).all() for player in players: terms.append(vocabulary.SimpleTerm(player.id_, player.id_, player.name+' [%s]' % player.nation.country)) return vocabulary.SimpleVocabulary(terms)
def handleImport(self, action): data, errors = self.extractData() if len(errors) == 0: name = data['name'] date = data['date'] session = named_scoped_session('footballchallenge') if IEvent.providedBy(self.context): event = session.query(Event).filter(Event.id_==self.context.id_).one() event.name = name event.date = date transaction.commit() else: event = Event(name, date) session.add(event) transaction.commit() return self.request.RESPONSE.redirect(self.context.absolute_url())
def player_only_once(data): """A Validator that checks if every Player is only used once""" keys = EditTeamSchema playerset = set([getattr(data, name) for name in keys.names()]) playerlist = [getattr(data, name) for name in keys.names()] if len(playerset) == len(keys.names()): return True double_players = [x for x in playerset if playerlist.count(x) > 1] playernames = '' session = named_scoped_session('footballchallenge') if len(double_players) == 1: if not double_players[0]: return True for player_id in double_players: if player_id: playernames += session.query(Player).filter( Player.id_ == player_id).one().name raise Invalid(_(u"You can't use the player ${players} multiple times", mapping={'players':playernames}))
def handleImport(self, action): data, errors = self.extractData() if len(errors) == 0: session = named_scoped_session('footballchallenge') league = session.query(League).filter(League.id_ == self.league_id).one() teams = [] event_id = session.query(Event).order_by(desc(Event.deadline)).first().id_ for user_id in data['teams']: if session.query(Team).filter(Team.user_id == user_id).all(): team = session.query(Team).filter(Team.user_id == user_id).one() else: team = Team(user_id, event_id) session.add(team) teams.append(team) league.teams = teams msg = _(u'label_teams_assign', default=u'Teams were assigned successfully.') IStatusMessage(self.request).addStatusMessage( msg, type='information') return self.request.RESPONSE.redirect(self.context.absolute_url() + '/assign_users/'+self.league_id)
def __call__(self): self.request.set('disable_border', True) if self.request.form.get('form.submited'): authenticator = getMultiAdapter((self.context, self.request), name=u"authenticator") if not authenticator.verify(): raise Forbidden() playing_players = self.request.form.get('played', {}) yellow = self.request.form.get('yellow', {}) second_yellow = self.request.form.get('2ndyellow', {}) red = self.request.form.get('red', {}) goals = self.request.form.get('goals', {}) saves = self.request.form.get('saves', {}) penaltys = self.request.form.get('penalty', {}) assists = self.request.form.get('assists', {}) self.write_to_db(playing_players, yellow, second_yellow, red, goals, penaltys, assists, saves) self.request.response.redirect(self.context.absolute_url() + '/schedule') else: session = named_scoped_session('footballchallenge') try: game = session.query(Game).filter(Game.id_==self.game_id).one() game.calculated = False except NoResultFound: raise NotFound(self, self.game_id, self.request) for player in game.players: self.request.form[str(player.id_)+'_played'] = "checked" for card in game.cards: self.request.form[str(card.player_id)+'_'+card.color] = "checked" for goal in game.goals: if goal.is_penalty == False: self.request.form[str(goal.player_id)+'_goals'] = 1 + self.request.form.get(str(goal.player_id)+'_goals', 0) else: self.request.form[str(goal.player_id)+'_penalty'] = 1 + self.request.form.get(str(goal.player_id)+'_penalty', 0) for assist in game.assists: self.request.form[str(assist.player_id)+'_assists'] = 1 + self.request.form.get(str(assist.player_id)+'_assists', 0) for save in game.saves: self.request.form[str(save.player_id)+'_saves'] = 1 + self.request.form.get(str(save.player_id)+'_saves', 0) return self.template()
# -*- coding: utf-8 -*- from pas.plugins.sqlalchemy.plugin import graceful_recovery from pas.plugins.sqlalchemy.plugin import logger from sqlalchemy import exc from z3c.saconfig import named_scoped_session import logging import unittest Session = named_scoped_session("pas.plugins.sqlalchemy") class TestRecovery(unittest.TestCase): def testGracefulRecovery(self): records = [] class TestHandler(logging.Handler): def emit(self, record): records.append(record) handler = TestHandler() logger.addHandler(handler) @graceful_recovery(False) def raises_sql_exc(msg): raise exc.SQLAlchemyError(msg) @graceful_recovery(log_args=False) def raises_sql_exc_no_args(msg): raise exc.SQLAlchemyError(msg)
def categories(context): items = [] session = named_scoped_session('sqlsession') for cat in session.query(Category).all(): items.append(SimpleTerm(cat, token=cat.id, title=cat.name)) return SimpleVocabulary(items)
# -*- coding: utf-8 -*- from Products.Five.browser import BrowserView from Products.Five.browser.pagetemplatefile import ViewPageTemplateFile from plone.protect import CheckAuthenticator from Products.statusmessages.interfaces import IStatusMessage from z3c.saconfig import named_scoped_session from project.model.testdata import TestData Session = named_scoped_session('zcmlsession') class ORMView(BrowserView): template = ViewPageTemplateFile('templates/view.pt') label = u'Using SQLAlchemy model' def __init__(self, context, request): super(ORMView, self).__init__(context, request) def __call__(self): self.status = IStatusMessage(self.request) if self.request.form.has_key('submitted'): CheckAuthenticator(self.request) if self.request.form.has_key('add_row'): self.status.addStatusMessage(u"Added row.", type='info') self.add_row() return self.template()
from collective.transmogrifier.interfaces import ISection from collective.transmogrifier.interfaces import ISectionBlueprint from opengever.ogds.models.group import Group from opengever.ogds.models.user import User from z3c.saconfig import named_scoped_session from zope.interface import classProvides, implements import logging Session = named_scoped_session("opengever") SQLSOURCE_KEY = 'transmogrify.sqlinserter.sqlinsertersection' class GroupUsersSection(object): """This section write all relations beetwen users and groups, import all users of all LDAP groups """ classProvides(ISectionBlueprint) implements(ISection) def __init__(self, transmogrifier, name, options, previous): self.previous = previous self.logger = logging.getLogger(options['blueprint']) self.context = transmogrifier.context self.session = Session() def __iter__(self): for item in self.previous: groups = self.session.query(Group).filter_by( groupid=item.get('groupid')).all()
def Session(): return named_scoped_session('alchemyform_session')
import plugin import model from z3c.saconfig import named_scoped_session Session = named_scoped_session("fritzing.SqlPasPlugin") plugin_name = "sql" def install_pas_plugin(self): pas = self.acl_users if not plugin_name in pas.objectIds(): manager = plugin.Plugin(plugin_name, "SQLAlchemy user/group/prop store") pas._setObject(plugin_name, manager) provider = pas[plugin_name] provider.manage_activateInterfaces([ # 'IGroupsPlugin', # 'IGroupEnumerationPlugin', # 'IGroupIntrospection', # 'IGroupManagement', 'IAuthenticationPlugin', 'IUserEnumerationPlugin', 'IUserManagement', # 'IUserAdderPlugin', # 'IRolesPlugin', # 'IRoleAssignerPlugin', 'IPropertiesPlugin', 'IUpdatePlugin']) def uninstall_pas_plugin(self): pas = self.acl_users if plugin_name in pas.objectIds():
import sqlalchemy.types import sqlalchemy.schema from zope.interface import implements from sqlalchemy.ext import declarative from z3c.saconfig import named_scoped_session from .interfaces import IMessage Base = declarative.declarative_base() Session = named_scoped_session("mydb") class Message(Base): """Database-backed implementation of IMessage Cfr. Documentazione di SQLAlchemy """ implements(IMessage) __tablename__ = 'message' message_id = sqlalchemy.schema.Column( sqlalchemy.types.Integer(), primary_key=True, autoincrement=True, ) year = sqlalchemy.schema.Column( sqlalchemy.types.Integer(4), nullable=False, )
def session(self): return named_scoped_session(self.db_key)
def OpenGeverSessionName(object): return named_scoped_session('opengever')
from zope import schema from zope.interface import Invalid import z3c.form.widget from z3c.form import field, form, button, validator from z3c.form.interfaces import DISPLAY_MODE, HIDDEN_MODE from plone.z3cform.layout import FormWrapper, wrap_form from plone.z3cform.crud import crud from plone.app.z3cform.wysiwyg.widget import WysiwygFieldWidget from z3c.saconfig import named_scoped_session from headnet.formexamples.model.demo import IDemo, Demo from plone.z3cform import MessageFactory as _ Session = named_scoped_session("headnet.formexamples") class BaseCrudForm(crud.CrudForm): def __init__(self, context, request): super(BaseCrudForm, self).__init__(context, request) self._db_session = None @property def db_session(self): if not self._db_session: self._db_session = Session() return self._db_session @property def portal(self):
#from z3c.saconfig import named_scoped_session #Session = named_scoped_session('default') #session=Session() #session.add(Person(name='Donald Duck')) #assume we have a Person class ##If you use the package standalone, do it that way: from zope.configuration.xmlconfig import XMLConfig import zope.component.event #neccesary to initialize subscription system import transaction import c3s.dev XMLConfig('configure.zcml', c3s.dev)() #assume we have a few classes in a module 'personal' from c3s.dev.creation import Agent, Work from z3c.saconfig import named_scoped_session Session = named_scoped_session('default') session = Session() #now play around with the database agent = Agent(Username='******') work = Work(Name='Work1') work1 = Work(Name='Work2') work.children.append(work1) session.add_all([agent, work]) #finally commit everything, now it lands in the db transaction.commit()
from collective.transmogrifier.interfaces import ISection from collective.transmogrifier.interfaces import ISectionBlueprint from opengever.ogds.models.group import Group from opengever.ogds.models.user import User from z3c.saconfig import named_scoped_session from zope.interface import classProvides, implements import logging Session = named_scoped_session("opengever") SQLSOURCE_KEY = 'transmogrify.sqlinserter.sqlinsertersection' class GroupUsersSection(object): """This section write all relations beetwen users and groups, import all users of all LDAP groups """ classProvides(ISectionBlueprint) implements(ISection) def __init__(self, transmogrifier, name, options, previous): self.previous = previous self.logger = logging.getLogger(options['blueprint']) self.context = transmogrifier.context self.session = Session() def __iter__(self): for item in self.previous: groups = self.session.query(Group).filter_by(
# PlonePAS from Products.PlonePAS.interfaces.plugins import IUserManagement from Products.PlonePAS.interfaces.capabilities import IDeleteCapability from Products.PlonePAS.interfaces.capabilities import IPasswordSetCapability from Products.PlonePAS.interfaces.capabilities import IAssignRoleCapability from Products.PlonePAS.interfaces.capabilities import IGroupCapability from Products.PlonePAS.interfaces.plugins import IMutablePropertiesPlugin from Products.PlonePAS.interfaces.group import IGroupIntrospection from Products.PlonePAS.interfaces.group import IGroupManagement from Products.PlonePAS.plugins.group import PloneGroup from Products.PlonePAS.interfaces.propertysheets import IMutablePropertySheet from pas.plugins.sqlalchemy import model from z3c.saconfig import named_scoped_session Session = named_scoped_session("pas.plugins.sqlalchemy") logger = logging.getLogger("pas.plugins.sqlalchemy") manage_addSqlalchemyPlugin = PageTemplateFile("templates/addPlugin", globals(), __name__="manage_addPlugin") def addSqlalchemyPlugin(self, id, title="", user_model=None, principal_model=None, group_model=None, REQUEST=None): """Add an SQLAlchemy plugin to a PAS.""" p = Plugin(id, title) p.user_model = user_model p.principal_model = principal_model p.group_model = group_model self._setObject(p.getId(), p)
def __call__(self): from z3c.saconfig import named_scoped_session session = named_scoped_session('testing')() result = session.execute('SELECT 1') return result.scalar()
from zope.component import getUtility from zope.globalrequest import getRequest import json import os.path import urllib import urllib2 EXPECTED_ENCODINGS = ( 'utf8', 'iso-8859-1', 'latin1', ) Session = named_scoped_session('opengever') def create_session(): """Returns a new sql session bound to the defined named scope. """ return Session() def get_current_client(): """Returns the current client. """ session = create_session() client_id = get_client_id()
def Session(): return named_scoped_session('spdo_session')
def calculate_player_points(game): """This function calculates the playerpoints and rewrites it to a playerstatistics instance """ session = named_scoped_session("footballchallenge") session.query(Playerstatistics).filter(Playerstatistics.game_id == game.id_).delete() for player in game.players: points = 0 #get right mapping if player.position == "striker": mapping = POINT_MAPPING_STRIKER elif player.position == "midfield": mapping = POINT_MAPPING_MIDFIELD elif player.position == "defender": mapping = POINT_MAPPING_DEFENDER else: mapping = POINT_MAPPING_KEEPER #calculate points for game result if player.nation_id == game.nation1_id: if game.score_nation1 > game.score_nation2: points += mapping['victory'] elif game.score_nation1 == game.score_nation2: points += mapping['draw'] else: points += mapping['loss'] else: if game.score_nation1 < game.score_nation2: points += mapping['victory'] elif game.score_nation1 == game.score_nation2: points += mapping['draw'] else: points += mapping['loss'] #get points for playerspecific events like cards or goals goals = player.get_goals(session, game.id_) for goal in goals: if goal.is_penalty == False: points +=mapping['goal'] else: points += mapping['penalty'] assists = player.get_assists(session, game.id_) points += mapping['assist']*len(assists) card = player.get_cards(session, game.id_) if card: points += mapping[card[0].color] if player.position == "keeper" or player.position == "defender": if player.nation_id == game.nation1_id: if game.score_nation2 == 0: points += mapping['no_goals'] elif game.score_nation2 >= 3: points += mapping['3_goals'] else: if game.score_nation1 == 0: points += mapping['no_goals'] elif game.score_nation1 >= 3: points += mapping['3_goals'] if player.position == "keeper": saves = player.get_saves(session, game.id_) points += mapping['save']*len(saves) # Store player statistics stats = session.query(Playerstatistics).filter_by( player_id=player.id_).filter_by( game_id=game.id_).all() if len(stats) == 0: stats = Playerstatistics(player.id_, game.id_, points) session.add(stats) else: stats[0].points = points
tables = [ 'favorites', ] def get_locale(): try: ltool = api.portal.get_tool('portal_languages') except CannotGetPortalError: return DEFAULT_LOCALE language_code = ltool.getPreferredLanguage() return language_code.split('-')[0] Session = named_scoped_session('opengever') BASE.session = Session Base = query_base(Session) make_translatable(options={'locales': SUPPORTED_LOCALES}) sqlalchemy_utils.i18n.get_locale = get_locale def get_tables(table_names): tables = Base.metadata.tables return [tables.get(table_name) for table_name in table_names] def create_session(): """Returns a new sql session bound to the defined named scope.
# -*- coding: utf-8 -*- """Init and utils.""" import logging from sqlalchemy.ext import declarative from z3c.saconfig import named_scoped_session from zope.i18nmessageid import MessageFactory _ = MessageFactory('collective.awstats_cache') logger = logging.getLogger('collective.awstats_cache') ORMBase = declarative.declarative_base() Session = named_scoped_session('awstats_statistics')
# -*- coding: utf-8 -*- from z3c.saconfig import named_scoped_session from project.browser.reflection_example import ReflectionView # Here we use our own session utility defined in dbutility: Session = named_scoped_session('demo_session_1') class Reflection2View(ReflectionView): label = u'Using SQLAlchemy reflection and own session utility'