class Amendment(Commentable,
CorrelableEntity,
SearchableEntity,
DuplicableEntity,
PresentableEntity):
"""Amendment class"""
icon = 'icon novaideo-icon icon-amendment'
name = renamer()
result_template = 'novaideo:views/templates/amendment_result.pt'
author = SharedUniqueProperty('author')
proposal = SharedUniqueProperty('proposal', 'amendments')
def __init__(self, **kwargs):
super(Amendment, self).__init__(**kwargs)
self.explanations = PersistentDict()
self.set_data(kwargs)
# @region.cache_on_arguments()
def get_used_ideas(self):
"""Return used ideas"""
result = []
if not hasattr(self, 'explanations'):
return result
for explanation in self.explanations.values():
if explanation['intention'] is not None:
try:
result.extend(
Intention.get_explanation_ideas(
explanation['intention'])
)
except Exception:
pass
return list(set(result))
@property
def related_ideas(self):
"""Return added ideas"""
result = []
for explanation in self.explanations.values():
if explanation['intention'] is not None:
try:
result.extend(
Intention.get_explanation_data(
explanation['intention'])['related_ideas']
)
except Exception:
pass
return list(set(result))
class RegistrationApproval(PloneBaseTool, UniqueObject, SimpleItem):
implements(IRegistrationApproval)
id = 'wcc_membership_registration_approval'
meta_type = 'WCC Registration Approval Tool'
toolicon = 'skins/plone_images/site_icon.png'
security = ClassSecurityInfo()
def __init__(self):
self._data = PersistentDict()
def is_memberid_allowed(self, key):
return not (key in self._data.keys())
def values(self):
for x in self._data.values():
if not x.has_key('username'):
x['username'] = x['email']
return sorted(self._data.values(), key=(lambda x: x['username']))
def add(self, key, data):
if key in self._data.keys():
raise ConflictError(u'User already exist in pending')
data['username'] = key
self._data[key] = data
notify(UserRegisteredEvent(data))
def get(self, key):
return self._data[key]
def approve(self, key):
if key not in self._data.keys():
raise KeyError(key)
portal = getSite()
registration = getToolByName(self, 'portal_registration')
portal_props = getToolByName(self, 'portal_properties')
mt = getToolByName(self, 'portal_membership')
props = portal_props.site_properties
use_email_as_login = props.getProperty('use_email_as_login')
data = self._data[key]
if use_email_as_login:
data['username'] = data['email']
user_id = data['username']
password = registration.generatePassword()
request = getRequest()
try:
registration.addMember(user_id, password, REQUEST=request)
except (AttributeError, ValueError), err:
logging.exception(err)
IStatusMessage(request).addStatusMessage(err, type="error")
return
# set additional properties using the user schema adapter
schema = getUtility(IUserDataSchemaProvider).getSchema()
adapter = getAdapter(portal, schema)
adapter.context = mt.getMemberById(user_id)
for name in getFieldNamesInOrder(schema):
if name in data:
setattr(adapter, name, data[name])
notify(UserApprovedEvent(data))
del self._data[key]
class OrderStorage(BTreeContainer):
def __init__(self):
super(OrderStorage, self).__init__()
self.indexes = PersistentDict({
'products': KeywordIndex(),
'user_id': FieldIndex(),
'processor_order_id': FieldIndex(),
'finance_state': FieldIndex(),
'fulfillment_state': FieldIndex(),
'creation_date': FieldIndex(),
'renewal_date': FieldIndex()
}
)
def query(self, **args):
results = self.apply(args)
return ResultSet(results, self)
def apply(self, query):
results = []
for index_name, index_query in query.items():
index = self.indexes.get(index_name)
if index is None:
continue
r = index.apply(index_query)
if r is None:
continue
if not r:
# empty results
return r
results.append((len(r), r))
if not results:
# no applicable indexes, so catalog was not applicable
return None
results.sort() # order from smallest to largest
_, result = results.pop(0)
for _, r in results:
_, result = weightedIntersection(result, r)
return result
def __setitem__(self, key, object):
super(OrderStorage, self).__setitem__(key, object)
self.index(object)
def reset_index(self):
# reindex all orders
for index in self.indexes.values():
index.clear()
for order in self.values():
self.index(order)
def reindex(self, object):
self.unindex(object.order_id)
self.index(object)
def index(self, object):
doc_id = int(object.order_id)
for attr, index in self.indexes.items():
value = getattr(object, attr, None)
if callable(value):
value = value()
if value is None:
continue
index.index_doc(doc_id, value)
def unindex(self, order_id):
for index in self.indexes.values():
index.unindex_doc(int(order_id))
def __delitem__(self, key):
super(OrderStorage, self).__delitem__(key)
doc_id = int(key)
self.unindex(doc_id)
class Amendment(CorrelableEntity, SearchableEntity, DuplicableEntity,
PresentableEntity, Debatable):
"""Amendment class"""
type_title = _('Amendment')
icon = 'icon novaideo-icon icon-amendment'
name = renamer()
templates = {
'default': 'novaideo:views/templates/amendment_result.pt',
'popover': 'novaideo:views/templates/amendment_popover.pt',
'bloc': 'novaideo:views/templates/amendment_bloc.pt'
}
author = SharedUniqueProperty('author')
proposal = SharedUniqueProperty('proposal', 'amendments')
attached_files = SharedMultipleProperty('attached_files')
def __init__(self, **kwargs):
super(Amendment, self).__init__(**kwargs)
self.explanations = PersistentDict()
self.set_data(kwargs)
self.addtoproperty('channels', Channel())
@property
def is_published(self):
return 'submitted' in self.state
@property
def working_group(self):
return self.proposal.working_group
@property
def authors(self):
return [self.author]
@property
def challenge(self):
return getattr(self.proposal, 'challenge', None)
def _init_presentation_text(self):
self._presentation_text = html_to_text(getattr(self, 'text', ''))
def __setattr__(self, name, value):
super(Amendment, self).__setattr__(name, value)
if name == 'text':
self._init_presentation_text()
def presentation_text(self, nb_characters=400):
text = getattr(self, '_presentation_text', None)
if text is None:
self._init_presentation_text()
text = getattr(self, '_presentation_text', '')
return truncate_text(text, nb_characters)
# @region.cache_on_arguments()
def get_used_ideas(self):
"""Return used ideas"""
result = []
if not hasattr(self, 'explanations'):
return result
for explanation in self.explanations.values():
if explanation['intention'] is not None:
try:
result.extend(
Intention.get_explanation_ideas(
explanation['intention']))
except Exception:
pass
return list(set(result))
@property
def related_ideas(self):
"""Return added ideas"""
result = []
for explanation in self.explanations.values():
if explanation['intention'] is not None:
try:
result.extend(
Intention.get_explanation_data(
explanation['intention'])['related_ideas'])
except Exception:
pass
return list(set(result))
class RegistrationApproval(PloneBaseTool, UniqueObject, SimpleItem):
implements(IRegistrationApproval)
id = 'wcc_minisites_registration_approval'
meta_type = 'WCC Minisite Approval Tool'
toolicon = 'skins/plone_images/site_icon.png'
security = ClassSecurityInfo()
def __init__(self):
self._data = PersistentDict()
def is_memberid_allowed(self, key):
return not (key in self._data.keys())
def values(self):
for x in self._data.values():
if not x.has_key('username'):
x['username'] = x['email']
return sorted(self._data.values(), key=(lambda x: x['username']))
def add(self, key, data):
if key in self._data.keys():
raise ConflictError(u'User already exist in pending')
data['username'] = key
self._data[key] = data
notify(UserRegisteredEvent(data))
def get(self, key):
return self._data[key]
def approve(self, key):
if key not in self._data.keys():
raise KeyError(key)
portal = getSite()
registration = getToolByName(self, 'portal_registration')
portal_props = getToolByName(self, 'portal_properties')
mt = getToolByName(self, 'portal_membership')
props = portal_props.site_properties
use_email_as_login = props.getProperty('use_email_as_login')
data = self._data[key]
if use_email_as_login:
data['username'] = data['email']
user_id = data['username']
password = registration.generatePassword()
request = getRequest()
try:
registration.addMember(user_id, password, REQUEST=request)
except (AttributeError, ValueError), err:
logging.exception(err)
IStatusMessage(request).addStatusMessage(err, type="error")
return
# set additional properties using the user schema adapter
schema = getUtility(IUserDataSchemaProvider).getSchema()
adapter = getAdapter(portal, schema)
adapter.context = mt.getMemberById(user_id)
for name in getFieldNamesInOrder(schema):
if name in data:
setattr(adapter, name, data[name])
notify(UserApprovedEvent(data))
del self._data[key]
class VideoContainer(PersistentMapping):
""" A simple container for Video objects
>>> from mint.repoze.interfaces import IVideoContainer
>>> from mint.repoze.models import VideoContainer, Video
>>> ob = VideoContainer()
>>> IVideoContainer.providedBy(ob)
True
>>> len(ob)
0
>>> ob[u'vid1'] = Video('vid1', 'Video 1', 'description', [])
>>> len(ob)
1
>>> ob.keys()
[u'vid1']
"""
__acl__ = [
(Allow, Everyone, 'view'),
(Allow, 'admin', 'add'),
(Allow, 'admin', 'edit'),
]
implements(IVideoContainer,ILocation)
encode_dir = 'var/videos/'
def __init__(self, *args, **kwargs):
self.data = PersistentDict()
for data in args:
self.add_video(*data)
for v in kwargs.values():
pass
def __getitem__(self, key):
return self.data.__getitem__(key)
def __setitem__(self, key, value):
return self.data.__setitem__(key, value)
def items(self):
return self.data.items()
def keys(self):
return self.data.keys()
def values(self):
return self.data.values()
def __repr__(self):
return u'<VideoContainer object>'
def add_video(self, name, description, tags, encodes={}):
uid = name.lower().replace(' ', '_')
counter = 1
while uid in self:
uid = '%s_%03d' % (uid, counter)
counter += 1
self.data[uid] = Video(uid, name, description, tags, encodes, self.encode_dir)
import transaction
transaction.commit()
def get_videos_by_tag(self, tag):
""" Returns a list of video objects with the given tag
>>> from mint.repoze.test.data import video_container
>>> video_container.get_videos_by_tag('feature') # doctest: +ELLIPSIS
[<Video name=...]
"""
return [video for video in self.data.values() if tag in video.tags]
class Amendment(CorrelableEntity,
SearchableEntity,
DuplicableEntity,
PresentableEntity,
Debatable):
"""Amendment class"""
type_title = _('Amendment')
icon = 'icon novaideo-icon icon-amendment'
name = renamer()
templates = {
'default': 'novaideo:views/templates/amendment_result.pt',
'popover': 'novaideo:views/templates/amendment_popover.pt',
'bloc': 'novaideo:views/templates/amendment_bloc.pt'
}
author = SharedUniqueProperty('author')
proposal = SharedUniqueProperty('proposal', 'amendments')
attached_files = SharedMultipleProperty('attached_files')
def __init__(self, **kwargs):
super(Amendment, self).__init__(**kwargs)
self.explanations = PersistentDict()
self.set_data(kwargs)
self.addtoproperty('channels', Channel())
@property
def is_published(self):
return 'submitted' in self.state
@property
def working_group(self):
return self.proposal.working_group
@property
def authors(self):
return [self.author]
@property
def challenge(self):
return getattr(self.proposal, 'challenge', None)
def _init_presentation_text(self):
self._presentation_text = html_to_text(
getattr(self, 'text', ''))
def __setattr__(self, name, value):
super(Amendment, self).__setattr__(name, value)
if name == 'text':
self._init_presentation_text()
def presentation_text(self, nb_characters=400):
text = getattr(self, '_presentation_text', None)
if text is None:
self._init_presentation_text()
text = getattr(self, '_presentation_text', '')
return truncate_text(text, nb_characters)
# @region.cache_on_arguments()
def get_used_ideas(self):
"""Return used ideas"""
result = []
if not hasattr(self, 'explanations'):
return result
for explanation in self.explanations.values():
if explanation['intention'] is not None:
try:
result.extend(
Intention.get_explanation_ideas(
explanation['intention'])
)
except Exception:
pass
return list(set(result))
@property
def related_ideas(self):
"""Return added ideas"""
result = []
for explanation in self.explanations.values():
if explanation['intention'] is not None:
try:
result.extend(
Intention.get_explanation_data(
explanation['intention'])['related_ideas']
)
except Exception:
pass
return list(set(result))
class UserProfile(grok.Model):
grok.implements(IUserProfile, ILayout)
# Derived stats
health = 0 # 1 Vitality = 10 health)
armor = 0 # Toughness + Defense
crit_chance = 0 # (Crit Chance = 5% + Precision / 21
crit_dmg = 0 # (Crit Dmg = 150% + by Ferocity/15
boon_duration = 0 # Increased by Concentration (15 = 1%)
cond_duration = 0 # Increased by Expertise (15 = 1%)
base_health = {'Warrior':9212, 'Necromancer':9212,
'Revenant':5922, 'Engineer':5922, 'Ranger':5922, 'Mesmer':5922,
'Guardian':1645, 'Thief':1645, 'Elementalist':1645 }
stats = PersistentDict()
runes = PersistentDict()
buffs = PersistentList()
selected_weapon = 0
selected_traits = []
characters = []
selected = ''
refresh = False
skill_choices = None
skill_choice = None
gear = []
trinkets = []
amulet = []
backpack = []
aquatic = []
game_modes = ["pve", "pvp", "wvw"]
gmode = "wvw"
spec_bg = grok.Container()
grok.traversable('spec_bg')
def __init__(self, user):
location.locate(self.spec_bg, self, 'spec_bg')
self.user = user
def update(self):
location.locate(self.spec_bg, self, 'spec_bg')
account = GW2API().account(self.user.gw2_apikey)
if account is not None:
self.account = account
characters = GW2API().characters(self.user.gw2_apikey)
if characters is not None:
self.characters = characters
# self.refresh=True
if len(self.selected)==0:
self.selected = self.characters[0]
self.refresh = True
if self.refresh:
core = GW2API().character_core(self.user.gw2_apikey, self.selected)
if core is not None:
self.core = core
# self.equipment = GW2API().character_equipment(self.user.gw2_apikey, self.selected)
# self.skills = GW2API().character_skills(self.user.gw2_apikey, self.selected)
# self.specializations = GW2API().character_specializations(self.user.gw2_apikey, self.selected)
self.refresh = False
self.stats = PersistentDict({'Power': 1000, 'Precision': 1000, 'Toughness': 1000, 'Vitality':1000,
'Defense':0, 'ConditionDamage': 0, 'CritDamage':0,
'Concentration':0, 'Expertise':0, 'Ferocity':0, 'Healing':0,
'BoonDuration':0, 'ConditionDuration':0
})
self.runes = PersistentDict()
self.buffs = PersistentList()
self.gear = self._gear()
self.trinkets = self._trinkets()
self.amulet = self._amulet()
self.backpack = self._backpack()
self.weapons = self._weapons()
self.aquatic = self._aquatic()
self.profession = GW2API().get_profession(self.core['profession'])
self.skill_choices = None
if self.profession['name'] == 'Elementalist':
self.skill_choices = 'attunement'
if self.skill_choice is None: self.skill_choice = 'Fire'
self.prof_skills = self._profession_skills()
self.weap_skills = self._weapon_skills()
self.rune_bonuses = []
for r in self.runes.values():
b = r['rune']['bonuses'][:r['count']]
for effect in b:
self.rune_bonuses.append(effect)
if effect.find(' to All Stats')>0:
perc = int(effect.split(' ')[0])
for stat in ['Power', 'Precision', 'Toughness', 'Vitality', 'Ferocity', 'Healing', 'ConditionDamage']:
self.stats[stat] += perc
elif effect.find('% Boon Duration') > 0:
perc = int(effect.split('%')[0])
self.stats['BoonDuration'] += perc * 15
elif self._stat_effect(effect):
pass
else:
self.buffs.append(effect)
self.health = self.stats['Vitality'] * 10 + self.base_health[self.core['profession']]
self.armor = self.stats['Toughness'] + self.stats['Defense']
self.crit_chance = (self.stats['Precision']-916) / 21.0
self.crit_dmg = 150 + (self.stats['CritDamage'] + self.stats['Ferocity']) / 15.0
self.boon_duration = (self.stats['BoonDuration'] + self.stats['Concentration']) / 15.0
self.cond_duration = (self.stats['ConditionDuration'] + self.stats['Expertise']) / 15.0
# for i in list(self.spec_bg.keys()):
# del self.spec_bg[i]
self.selected_traits = []
for spec in self.specs():
for t in spec['traits']:
if 'description' in t:
self.buffs.append("%s - %s"%(t['name'], t['description']))
else:
self.buffs.append(t['name'])
img = SpecImage(spec['id']['background'])
if img.fn not in self.spec_bg.keys():
img.retrieve()
self.spec_bg[img.fn] = img
spec['id']['img_no'] = img.fn
self.selected_traits.extend([t['name'] for t in spec['traits']])
pass
def gear_title(self, gear):
try:
if 'stats' in gear:
stats = [ "%s: +%s" % (n, s) for n, s in gear['stats']['attributes'].items()]
return "\n".join(stats)
else:
attributes = gear['id']['details']['infix_upgrade']['attributes']
return "\n".join(['%s: +%s' % (a['attribute'], a['modifier']) for a in attributes])
except Exception, e:
print "Cannot determine gear title for %s" % gear
print "%s" % str(e)
return ''
class BaseContainer(PersistentMapping):
""" Provides a basis for `container` objects
>>> container = BaseContainer()
>>> container[u'foo'] = u'bar'
>>> container[u'foo']
u'bar'
>>> container.items()
[(u'foo', u'bar')]
>>> container.keys()
[u'foo']
>>> container.values()
[u'bar']
"""
def __init__(self):
self.data = PersistentDict()
def __getitem__(self, key):
return self.data.__getitem__(key)
def __setitem__(self, key, value):
""" Acts as a proxy to the self.data PersistentDict. As it is a
persistent object, it will also try and assign the __parent__
attrubute to any object stored through this interface.
>>> container = BaseContainer()
>>> container.__setitem__('foo', 'bar')
>>> 'foo' in container.data
True
>>> container['foo'].__parent__ # doctest: +ELLIPSIS
Traceback (most recent call last):
...
AttributeError: 'str' object has no attribute '__parent__'
>>> class Child(object):
... __parent__ = None
...
>>> container.__setitem__('baz', Child())
>>> 'baz' in container.data
True
>>> container['baz'].__parent__ == container
True
"""
ret = self.data.__setitem__(key, value)
try: self.data[key].__parent__ = self
except: pass
return ret
def items(self):
return self.data.items()
def keys(self):
return self.data.keys()
def values(self):
return self.data.values()
def update(self, _data={}, **kwargs):
""" BaseContainers can be updated much the same as any Python dictionary.
By passing another mapping object:
>>> container = BaseContainer()
>>> container.update({'foo':'bar'})
By passing a list of iterables with length 2:
>>> container = BaseContainer()
>>> container.update([('foo', 'bar'),])
By passing a set of keyword arguments:
>>> container = BaseContainer()
>>> container.update(foo='bar')
"""
if kwargs:
for k,v in kwargs.items():
self.__setitem__(k,v)
return
elif isinstance(_data, dict):
for k,v in _data.items():
self.__setitem__(k,v)
elif isinstance(_data, dict):
for k,v in _data:
self.__setitem__(k,v)
