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'
