class View(grok.View):
grok.context(ISector)
grok.require("zope2.View")
grok.layer(NuPloneSkin)
grok.template("sector_view")
grok.name("nuplone-view")
def update(self):
self.add_survey_url = "%s/++add++euphorie.surveygroup" % \
aq_inner(self.context).absolute_url()
self.surveys = getSurveys(self.context)
super(View, self).update()
class CartView(grok.View):
""" sample view class """
grok.context(ISiteRoot)
grok.require('zope2.View')
grok.name('cart')
grok.template('cartview')
def update(self):
smd = self.context.session_data_manager
session = smd.getSessionData(create=True)
self.cart = session.get('cart', {})
class View(grok.View):
grok.context(IHOAHouse)
grok.require("zope2.View")
grok.template("hoa_house")
def update(self):
"""
get email html structure for all home owners and set them as view attribute
"""
context = self.context
owner_one = getattr(context, 'owner_one', '')
self.owner_one = getOwnerAndEmailStructureById(owner_one)
owner_two = getattr(context, 'owner_two', '')
self.owner_two = getOwnerAndEmailStructureById(owner_two)
resident_one = getattr(context, 'resident_one', '')
self.resident_one = getOwnerAndEmailStructureById(resident_one)
resident_two = getattr(context, 'resident_two', '')
self.resident_two = getOwnerAndEmailStructureById(resident_two)
property_manager = getattr(context, 'property_manager', '')
self.property_manager = getOwnerAndEmailStructureById(property_manager)
self.hasOwners = False
self.hasRenters = False
self.hasPM = False
if owner_one or owner_two:
self.hasOwners = True
if resident_one or resident_two:
self.hasRenters = True
if property_manager:
self.hasPM = True
house_inspection_objs = context.listFolderContents(
contentFilter={
"portal_type": "hoa_house_inspection",
"sort_on": "created",
"sort_order": "ascending"
})
self.inspections = house_inspection_objs
def getRentalStatus(self):
if getattr(self.context, 'rental'):
return 'Is Rental'
else:
return ''
def getState(self, obj):
status = api.content.get_state(obj=obj)
return HOME_INSPECTION_STATE_TITLES.get(status)
class DeleteBankView(grok.View):
grok.context(IKollkoll)
grok.name('delete-bank')
grok.require('hejasverige.ViewKollkoll')
grok.template('deletebank')
#grok.implements(IMyPages)
def update(self):
''' Shows confirmation view before removing bank
'''
#import pdb; pdb.set_trace()
session = ISession(self.request, None)
self.card_id = self.request.get('id', None)
self.return_url = self.request.get('return_url', None)
available_cards = {}
for card in session[SessionKeys.available_cards]:
available_cards[card['id']] = card
self.bank = available_cards[self.card_id]
#import pdb; pdb.set_trace()
button_ok = self.request.form.get('form.button.Ok') or None
if button_ok:
utils = getToolByName(self, "plone_utils")
if self.card_id in [
x.get('id') for x in session[SessionKeys.available_cards]
]:
kollkoll = Kollkoll()
try:
result = kollkoll.removeCard(uid=get_pid(),
bid=self.card_id)
utils.addPortalMessage(
_('Din inlogging till ' + self.bank['name'] +
' togs bort'), 'info')
except Exception, ex:
utils.addPortalMessage(
_('Det uppstod ett fel i samband med att din inloggning skulle tas bort'
), 'error')
logger.exception('Exception occured: %s' % str(ex))
else:
utils.addPortalMessage(_('Bank med angivet id saknas'),
'error')
if self.return_url and self.return_url != 'None':
url = self.return_url
else:
url = self.context.absolute_url()
return self.request.response.redirect(url)
class PreviewSurvey(form.Form):
"""Generate a preview for a survey. A preview is exactly like a normally
published survey, except for two differences: there can only be one preview
for a sector, which has the id `preview`, and after previewing the user is
redirected to the preview instead of the original context.
View name: @@preview
"""
grok.context(ISurvey)
grok.require("euphorie.client.PublishSurvey")
grok.name("preview")
grok.template("preview")
def publish(self):
survey = aq_inner(self.context)
return PublishToClient(survey, True)
def preview_url(self):
"""Return the URL the preview will have."""
config = getUtility(IAppConfig)
client_url = config.get("euphorie", {}).get("client")
if client_url:
client_url = client_url.rstrip("/")
else:
client_url = getPortal(self.context).client.absolute_url()
source = aq_inner(self.context)
surveygroup = aq_parent(source)
sector = aq_parent(surveygroup)
country = aq_parent(sector)
return "/".join([client_url, country.id, sector.id, "preview"])
@button.buttonAndHandler(_(u"button_cancel", default=u"Cancel"))
def handleCancel(self, action):
state = getMultiAdapter((aq_inner(self.context), self.request),
name="plone_context_state")
self.request.response.redirect(state.view_url())
@button.buttonAndHandler(_(u"button_preview", default=u"Create preview"))
def handlePreview(self, action):
self.publish()
url = make_tag('a', href=self.preview_url(), c=self.preview_url())
IStatusMessage(self.request).addHTMLStatusMessage(_(
"message_preview_success",
default=u"Succesfully created a preview for the OiRA Tool. "
u"It can be accessed at ${url}.",
mapping={'url': url}),
type="success")
state = getMultiAdapter((aq_inner(self.context), self.request),
name="plone_context_state")
self.request.response.redirect(state.view_url())
class View(dexterity.DisplayForm):
grok.context(IRepresentative)
grok.require('zope2.View')
grok.template('representative_view')
grok.name('view')
def person(self):
person_raw = requests.get(
'http://sinar-malaysia.popit.mysociety.org/api/v0.1/persons/' +
self.context.popit_id)
person_json = json.loads(person_raw.content)
try:
person = person_json['result']
if person.has_key('birth_date'):
birth_date = person['birth_date']
born = parser.parse(birth_date)
today = datetime.date.today()
age = today.year - born.year - ((today.month, today.day) < (born.month, born.day))
person['age'] = age
except:
print "Popit Error: " + person_json['errors'][0]
person = None
return person
def mp_post(self):
"""
Return back references from source object on specified attribute_name
"""
catalog = getUtility(ICatalog)
intids = getUtility(IIntIds)
source_object = self.context
attribute_name = 'representative'
result = []
for rel in catalog.findRelations(
dict(to_id=intids.getId(aq_inner(source_object)),
from_attribute=attribute_name)
):
obj = intids.queryObject(rel.from_id)
if obj is not None and checkPermission('zope2.View', obj):
result.append(obj)
return result
class RetrieveIndicadors(grok.View):
grok.name('retrieve_indicadors')
grok.context(IServeiTIC)
grok.layer(IGenwebServeisticLayer)
grok.template('retrieve_indicadors')
def parse_parameters(self):
try:
count_indicator = int(
self.request.form.get('count_indicator', None))
except (TypeError, ValueError):
count_indicator = None
try:
count_category = int(self.request.form.get('count_category', None))
except (TypeError, ValueError):
count_category = None
apply_order = True if self.request.form.get(
'apply_order', 'no') in ('yes', 'true') else False
return count_indicator, count_category, apply_order
@property
def count(self):
return self.parse_parameters()[0]
@property
def indicadors_href(self):
servei = get_servei(self)
return servei.absolute_url() + "/indicadors_list"
@property
def indicadors(self):
reporter = IndicadorsDataReporter(get_ws_indicadors_client(),
self.context)
count_indicator, count_category, apply_order = self.parse_parameters()
service_id = self.context.service_id
service_indicators_order = (self.context.service_indicators_order
if apply_order else None)
if not service_id:
return None
try:
return reporter.list_by_service_id_and_indicators_order(
service_id, service_indicators_order, count_indicator,
count_category)
except IndicadorsDataReporterException as e:
logger.warning("Error when listing indicators ({0})".format(e))
return None
class AdditionalHead(Head):
"""
Extra tags included in <head> which do not conflict with gomobiletheme.basic resources.
See plonecommunity.app for usage example.
"""
grok.template("additionalhead")
def update(self):
portal_state = getView(self.context, self.request,
"plone_portal_state")
self.portal_url = portal_state.portal_url()
class ContactDetails(grok.View):
grok.name('contactdetails')
grok.template('contactdetails')
grok.context(IContactContent)
def update(self):
contactable = IContactable(self.context)
self.contact_details = contactable.get_contact_details()
def render_address(self):
template_path = os.path.join(TEMPLATES_DIR, 'address.pt')
template = ViewPageTemplateFile(template_path)
return template(self, self.contact_details['address'])
class Update(Profile):
"""Update a survey session after a survey has been republished. If a
the survey has a profile the user is asked to confirm the current
profile before continueing.
The behaviour is exactly the same as the normal start page for a session
(see the :py:class:`Profile` view), but uses a different template with more
detailed instructions for the user.
"""
grok.context(ISurvey)
grok.require("euphorie.client.ViewSurvey")
grok.layer(IClientSkinLayer)
grok.template("updated")
class newsCollectionView(grok.View):
grok.context(IFolderish)
grok.name('newscollection_view')
grok.template("newscollectionview")
grok.require('zope2.View')
grok.layer(IGenwebTheme)
def published_news_items(self):
return self._data()
@memoize
def _data(self):
context = aq_inner(self.context)
catalog = getToolByName(context, 'portal_catalog')
state = ['published', 'intranet']
results = catalog(portal_type=('News Item'),
review_state=state,
is_important=True,
sort_on="getObjPositionInParent")
results = [a for a in results]
results2 = catalog(portal_type=('News Item', 'Link'),
review_state=state,
is_important=False,
sort_on=('Date'),
sort_order='reverse')
results3 = []
#import ipdb;ipdb.set_trace()
path_folder_news = self.all_news_link()
for brain in results2:
brain_url = brain.getURL()
brain_type = brain.Type
if brain_type == 'Link' and brain_url.startswith(
path_folder_news) or brain_type == 'News Item':
results3.append(brain)
return results + results3
def all_news_link(self):
context = aq_inner(self.context)
portal_state = getMultiAdapter((context, self.request),
name=u'plone_portal_state')
self.portal = portal_state.portal()
if self.have_news_folder:
news = self.portal.noticies.getTranslation()
return '%s' % news.absolute_url()
else:
return '%s/news_listing' % self.portal_url
@memoize
def have_news_folder(self):
return 'news' in self.navigation_root_object.objectIds()
class CommitteeOverview(grok.View, GeverTabMixin):
"""The overview tab for the committee tabbeview.
"""
grok.context(ICommittee)
grok.name('tabbedview_view-overview')
grok.require('zope2.View')
grok.template('overview')
show_searchform = False
def boxes(self):
items = [
[{'id': 'period',
'label': _('label_current_period', default=u'Current Period'),
'content': [self.period()],
'href': ''},
{'id': 'upcoming_meetings',
'label': _('label_upcoming_meetings', default=u'Upcoming meetings'),
'content': self.upcoming_meetings(),
'href': 'meetings'}],
[{'id': 'unscheduled_proposals',
'label': _('label_unscheduled_proposals',
default=u'Unscheduled proposals'),
'content': self.unscheduled_proposals(),
'href': 'submittedproposals'}],
[{'id': 'current_members',
'label': _('label_current_members',
default=u'Current members'),
'content': self.current_members(),
'href': 'memberships'}]]
return items
def upcoming_meetings(self):
meetings = self.context.get_upcoming_meetings()
return [meeting.get_link() for meeting in meetings[:10]]
def unscheduled_proposals(self):
proposals = self.context.get_unscheduled_proposals()
return [proposal.get_submitted_link() for proposal in proposals]
def current_members(self):
memberships = self.context.get_active_memberships().all()
members = [membership.member for membership in memberships]
return [member.get_link(self.context) for member in members]
def period(self):
period = Period.query.get_current(self.context.load_model())
return period.get_title()
class View(dexterity.DisplayForm):
grok.context(IEguideStorage)
grok.require('zope2.View')
grok.template("eguides")
implements(IFullWidth)
@property
def eguides(self):
obj = self.context
eguides = []
if obj.Language() != 'en':
obj = ITranslationManager(obj).get_translation('en')
for item in obj.eguides:
eguide = {}
eguide['country'] = COUNTRIES[item['country']]
eguide['flagname'] = eguide['country'].lower().replace(" ", "_")
eguide['online'] = obj.online_version_url.format(
country=item['country'], language=item['language'].upper())
eguide['offline'] = obj.offline_version_url.format(
country=item['country'], language=item['language'].upper())
eguide['language'] = item['language']
eguides.append(eguide)
eguides = sorted(eguides, key=lambda a: a['country'] + a['language'])
return eguides
def get_languages(self):
ldict = {}
langtool = api.portal.get_tool('portal_languages')
linfo = langtool.getAvailableLanguageInformation()
for item in self.eguides:
lang = item['language']
if not ldict.get(lang):
ldict[lang] = \
u"({0}) {1}".format(lang.upper(), linfo.get(lang)['native'])
return OrderedDict(sorted(ldict.items(), key=lambda t: t[1].lower()))
def get_countries(self):
countries = set()
for item in self.eguides:
countries.add(item['country'])
countries = list(countries)
countries.sort()
return countries
def get_current_language(self):
""" @return: Two-letter string, the active language code
"""
return component.getMultiAdapter(
(self.context, self.request),
name=u'plone_portal_state').language()
class MessageView(BaseView):
"emc memberArea message view"
grok.context(IMessage)
grok.template('message_view')
grok.name('view')
grok.require('emc.memberArea.view_message')
def update(self):
"update workflow status info"
portal = api.portal.get()
state = api.content.get_state(obj=self.context, default='Unknown')
if state == "unreaded":
api.content.transition(obj=self.context, transition='done')
class Problemes(grok.View):
grok.name('problemes_list')
grok.context(IServeiTIC)
grok.layer(IGenwebServeisticLayer)
grok.template('problemes')
def js_retrieve(self):
return """
$(document).ready(function()
{{
var url = '{url}';
retrieve_problemes(url, '');
}});
""".format(url="retrieve_problemes")
class View(sectorcontainer.View):
grok.context(sectorcontainer.ISectorContainer)
grok.require("zope2.View")
grok.layer(IOSHAContentSkinLayer)
grok.template("sectorcontainer_view")
grok.name("nuplone-view")
def update(self):
self.countries = summarizeCountries(aq_inner(self.context),
self.request)
library = get_library(self.context)
self.library_info = [
dict(title=lib['title'], url=lib['url']) for lib in library
]
class Committees(grok.View, GeverTabMixin):
grok.name('tabbedview_view-committees')
grok.context(ICommitteeContainer)
grok.require('zope2.View')
grok.template('committee')
filterlist_name = 'committee_state_filter'
filterlist_available = True
filterlist = FilterList(
Filter('filter_all', tmf('all')),
ActiveOnlyFilter('filter_active', tmf('Active'), default=True))
def __call__(self):
self.selected_filter_id = self.request.get(self.filterlist_name)
return super(Committees, self).__call__()
def extend_query_with_statefilter(self, query):
return self.filterlist.update_query(
query, self.request.get(self.filterlist_name))
def committees(self):
committees = []
filter = self.get_filter_text()
query = Committee.query.order_by(Committee.title)
query = query.by_searchable_text(text_filters=filter)
query = self.extend_query_with_statefilter(query)
for committee in query.all():
content_obj = committee.resolve_committee()
if not content_obj:
continue
if not api.user.has_permission('View', obj=content_obj):
continue
committees.append({
'title':
committee.title,
'url':
committee.get_url(),
'state_class':
'active' if committee.is_active() else 'inactive',
'number_unscheduled_proposals':
len(meeting_service().get_submitted_proposals(committee)),
'next_meeting':
Meeting.query.get_next_meeting(committee),
'last_meeting':
Meeting.query.get_last_meeting(committee)
})
return committees
class SelectContentScreenlet(grok.View):
"""
screenlet for selecting
"""
grok.context(Interface)
grok.name('select-content-screenlet')
grok.require('zope2.View')
grok.template('content_screenlet')
def update(self):
pass
def post_url(self):
return self.context.absolute_url() + "/@@content-search"
class Identification(grok.View):
"""Survey identification start page.
This view shows the introduction text for the identification phase. This
includes an option to print a report with all questions.
This view is registered for :py:class:`PathGhost` instead of
:py:obj:`euphorie.content.survey.ISurvey` since the
:py:class:`SurveyPublishTraverser` generates a :py:class:`PathGhost` object
for the *identification* component of the URL.
View name: @@index_html
"""
grok.context(PathGhost)
grok.require("euphorie.client.ViewSurvey")
grok.layer(IIdentificationPhaseSkinLayer)
grok.template("identification")
grok.name("index_html")
question_filter = None
def update(self):
if redirectOnSurveyUpdate(self.request):
return
self.survey = survey = aq_parent(aq_inner(self.context))
question = FindFirstQuestion(filter=self.question_filter)
if question is not None:
self.next_url = QuestionURL(survey,
question,
phase="identification")
self.tree = getTreeData(self.request, question)
else:
self.next_url = None
@property
def extra_text(self):
appconfig = getUtility(IAppConfig)
settings = appconfig.get('euphorie')
have_extra = settings.get('extra_text_identification', False)
if not have_extra:
return None
lang = getattr(self.request, 'LANGUAGE', 'en')
# Special handling for Flemish, for which LANGUAGE is "nl-be". For
# translating the date under plone locales, we reduce to generic "nl".
# For the specific oira translation, we rewrite to "nl_BE"
if "-" in lang:
elems = lang.split("-")
lang = "{0}_{1}".format(elems[0], elems[1].upper())
return translate(_(u"extra_text_identification", default=u""),
target_language=lang)
class View(grok.View):
grok.context(IHomePage)
grok.require("zope2.View")
grok.layer(IOSHAClientSkinLayer)
grok.template("custom_homepage")
grok.name("nuplone-view")
def update(self):
plt = api.portal.get_tool('portal_languages')
self.language_info = plt.getAvailableLanguageInformation()
props = api.portal.get_tool('portal_properties')
self.json_url = props.site_properties.getProperty(
'tools_json_url', 'https://oiraproject.eu/oira-ws/tools.json')
self.tools = self.prepare_tools()
return self.render()
def get_json(self):
tools_json = requests.get(self.json_url)
return loads(tools_json.content)
@property
def cached_json(self):
from plone.protect.auto import safeWrite
safeWrite(self.context, self.request)
now = datetime.now()
short_cache = now + timedelta(minutes=5)
long_cache = now + timedelta(minutes=15)
if self.request.get('invalidate-cache'):
mtool = api.portal.get_tool('portal_membership')
if mtool.checkPermission('cmf.ModifyPortalContent', self.context):
self.context.cache_until = now
if not hasattr(self.context, 'json'):
try:
self.context.json = self.get_json()
self.context.cache_until = long_cache
except (ValueError, AttributeError), err:
log.error('Failed to retrieve tools JSON from {}: {}'.format(
self.json_url, err))
return []
if now >= getattr(self.context, 'cache_until', datetime.min):
try:
self.context.json = self.get_json()
self.context.cache_until = long_cache
except (ValueError, AttributeError), err:
log.error('Failed to update tools JSON from {}: {}'.format(
self.json_url, err))
self.context.cache_until = short_cache
class SelectContent(grok.View):
"""
contentchooser for selecting
"""
grok.context(Interface)
grok.name('select-content-contentchooser')
grok.require('zope2.View')
grok.template('content_contentchooser')
def update(self):
pass
def post_url(self):
return self.context.absolute_url() + '/@@content-search'
class resetCountOffers(grok.View):
grok.name('reset_offers_counter')
grok.context(Interface)
grok.template('reset_offers_counter')
grok.require('cmf.ManagePortal')
grok.layer(IGenwebTfemarketLayer)
def update(self):
if 'confirm' in self.request.form:
registry = queryUtility(IRegistry)
tfe_tool = registry.forInterface(ITfemarketSettings)
tfe_tool.count_offers = 0
transaction.commit()
self.request.response.redirect(self.context.absolute_url() + "/tfemarket-settings#fieldsetlegend-2")
class ConfirmInvitationView(grok.View):
"""View (called "@@confirm-invititation") when user opens a link to an invite.
The associated template is found in invitation_templates/invite.pt.
"""
grok.context(INavigationRoot)
grok.require('zope2.View')
grok.name('confirm-invitation')
grok.implements(IMyPages)
grok.template('confirminvitation')
def change_state(self, item, transition, comment=''):
workflow = getToolByName(item, 'portal_workflow')
#import pdb; pdb.set_trace()
try:
workflow.doActionFor(item, transition, comment=comment)
new_state = workflow.getInfoFor(item, 'review_state')
logger.info("Object %s changed state to %s" %
(item.absolute_url_path(), new_state))
except WorkflowException:
logger.exception(
"Could not apply workflow transition %s. %s state not changed"
% (transition, item.absolute_url_path()))
return False
return True
def add_relation(self, id, container, member_type='supporter'):
relobj = createContent(
portal_type='hejasverige.relation',
foreign_id=id,
)
#import pdb; pdb.set_trace()
try:
item = addContentToContainer(container=container,
object=relobj,
checkConstraints=False)
except Exception, ex:
err = 'Unable to add relation with id', id, 'to', str(
container), 'due to', str(ex)
logger.exception(err)
utils = getToolByName(self, "plone_utils")
utils.addPortalMessage(_(err), 'error')
return None
else:
class Index(dexterity.DisplayForm):
grok.context(ICOP)
grok.require('zope2.View')
grok.template('cop_view')
grok.name('view')
@property
def catalog(self):
return getToolByName(self.context, 'portal_catalog')
def contents(self):
context = self.context
catalog = self.catalog
path = '/'.join(context.getPhysicalPath())
results = []
brains = catalog.searchResults(path={'query': path, 'depth':1},portal_type='ilo.cop.copitem',sort_on='created', sort_order='reverse')[:5]
return brains
def searchedValue(self, name=None):
result = 0
if self.request.form.has_key(name):
form = self.request.form
result = form[name]
return result
def highlight_news(self):
context = self.context
catalog = self.catalog
path = '/'.join(context.getPhysicalPath())
brains = catalog.unrestrictedSearchResults(path={'query':path, 'depth':5}, portal_type='News Item', Subject=('highlight',), sort_order='reverse', sort_on='created', review_state='shared_intranet')
if brains:
return brains[0]
return []
def news(self):
context = self.context
catalog = self.catalog
path = '/'.join(context.getPhysicalPath())
results = []
brains = catalog.unrestrictedSearchResults(path={'query':path, 'depth':5}, portal_type='News Item', sort_order='reverse', sort_on='created', review_state='shared_intranet')
for brain in brains or []:
if 'highlight' not in brain.Subject:
if len(results) < 3:
results.append({'title':brain.Title, 'desc':brain.Description, 'img':brain.getObject().getImage(), 'url':brain.getPath()})
else:
break
return results
class signatories_view(dexterity.DisplayForm):
grok.context(IStatement)
grok.require('zope2.View')
grok.template('signatories_view')
@property
def catalog(self):
return getToolByName(self.context, 'portal_catalog')
def statement_results(self):
context = self.context
catalog = self.catalog
path = '/'.join(context.getPhysicalPath())
brains = catalog.searchResults(
path={
'query': path,
'depth': 2
},
portal_type='interfaithclimate.signup.signature',
review_state='published')
# results = []
# for brain1 in brains:
# obj = brain1._unrestrictedGetObject()
# results.append({'first_name': obj.first_name,
# 'last_name': obj.last_name,
# 'organization': obj.organization,
# 'designation': obj.designation,
# # 'city':obj.city,
# 'country': obj.country,
# 'email1':obj.email1})
results = []
results1 = []
for brain1 in brains:
obj = brain1._unrestrictedGetObject()
value = ''
value1 = ''
if obj.first_name and obj.last_name:
value += '%s %s' % (obj.first_name, obj.last_name)
if obj.designation:
value1 += ', ' + obj.designation
if obj.organization:
value1 += ', ' + obj.organization
if obj.country:
value1 += ', ' + obj.country
if value:
results.append({'value': value, 'value1': value1})
return results
class View(grok.View):
grok.require('zope2.View')
grok.context(IApplication)
grok.template('application_view')
def redirectToMarket(self):
roles = api.user.get_current().getRoles()
market_path = self.context.getParentNode().getParentNode(
).absolute_url()
if 'Manager' in roles or 'TFE Manager' in roles:
self.redirect(market_path + "?searchOffer&offer=" +
self.context.offer_id + "&open=Y")
else:
self.redirect(market_path)
class OSHASurveyView(survey.View):
grok.layer(IOSHAContentSkinLayer)
grok.template("survey_view")
def modules_and_profile_questions(self):
return [self._morph(child) for child in self.context.values()]
def _morph(self, child):
state = getMultiAdapter((child, self.request),
name="plone_context_state")
return dict(id=child.id,
title=child.title,
url=state.view_url(),
is_profile_question=IProfileQuestion.providedBy(child))
class TTWFields(grok.View):
"""Show fields that were added TTW
"""
grok.name('ttwfields')
grok.template('ttwfields')
grok.context(Interface)
def update(self):
contact_view = self.context.unrestrictedTraverse('view')
contact_view.update()
self.widgets = contact_view.widgets
ttw_fields = get_ttw_fields(self.context)
self.ttw_fields = [
field for field in ttw_fields if field in self.widgets.keys()
]
class AdminEdit(dexterity.EditForm):
grok.context(sector.ISector)
grok.require("cmf.ManagePortal")
grok.layer(IOSHAContentSkinLayer)
grok.name("admin-edit")
grok.template('sector_admin_edit')
def extractData(self):
self.fields = self.fields.omit("login", "password")
if "login" in self.widgets:
del self.widgets["login"]
if "password" in self.widgets:
del self.widgets["password"]
return super(AdminEdit, self).extractData()
class View(grok.View):
grok.context(IOutcomeccvalues)
grok.template('outcomeccvalues_view')
grok.require('zope2.View')
def getData(self):
results = []
value = self.context.wop_program
result = api.content.find(portal_type="OutcomeCCItem", Title=quote_chars(value))[0]
results.append(dict(
icon=result.getObject().icon,
title=result.Title,
category=result.getObject().category,
))
return results[0]
