class PessoaAddForm(base.AddForm):
"""Formulário de cadastro de uma pessoa.
"""
grok.context(INavigationRoot)
grok.name('add-pessoa')
grok.require('zope2.View')
schema = IPessoa
klass = Pessoa
label = _(u'Adicionar Pessoa')
description = _(u'Formulário de cadastro de uma pessoa.')
def createAndAdd(self, data):
del data['id']
# garante que alguns campos são armazenados apenas como
# números, mesmo sendo strings
for campo in ('cep', 'cpf_cnpj'):
if data[campo] is not None:
data[campo] = ''.join([c for c in data[campo] if c.isdigit()])
pessoa = Pessoa()
pessoa.nome = data['nome']
pessoa.email = data['email']
pessoa.endereco = data['endereco']
pessoa.bairro = data['bairro']
pessoa.cep = data['cep']
pessoa.cidade = data['cidade']
pessoa.uf_id = data['uf_id']
pessoa.telefone = data['telefone']
pessoa.cpf_cnpj = data['cpf_cnpj']
pessoa.tipopessoa = data['tipopessoa']
session = Session()
session.add(pessoa)
session.flush()
class changeMigrated(grok.View):
# Change migrated property of sessions.
# No se pueden editar sessiones de la versión antigua, pero
# en algunos casos, nos han pedido que se pueda...
# Este código cambia el valor de la propiedad para eso
grok.context(IDexterityContent)
grok.name('change_migrated_to')
grok.require('cmf.ManagePortal')
grok.layer(IGenwebOrgansLayer)
def render(self):
# http:/session_url/change_migrated_to?value=False
messages = IStatusMessage(self.request)
if self.context.portal_type == 'genweb.organs.sessio':
if self.request['value'] == 'True':
elements = api.content.find(
path=self.context.absolute_url_path())
for item in elements:
value = item.getObject()
value.migrated = True
transaction.commit()
elif self.request['value'] == 'False':
elements = api.content.find(
path=self.context.absolute_url_path())
for item in elements:
value = item.getObject()
value.migrated = False
transaction.commit()
else:
return
messages.add('migrated property set to: ' +
str(self.request['value']),
type='warning')
self.request.response.redirect(self.context.absolute_url())
else:
pass
class View(grok.View):
grok.context(IABCTune)
grok.require('zope2.View')
"""
def __call__(self):
return
import pdb;pdb.set_trace()
"""
def abcAutorized(self):
context = self.context
sm = getSecurityManager()
if not sm.checkPermission(ModifyPortalContent, context):
return False
return True
def javascript(self):
auth = self.abcAutorized()
authjs = u'true'
if not auth:
authjs = u'false'
js = u"""<script type="text/javascript">\n"""
js += u'tuneModified = ' + _(u"'The tune was modified... continue ?'")
js += u';\n'
js += u'var uuid = "' + api.content.get_uuid(self.context) + '";\n'
js += u'var auth = ' + authjs + ';\n'
js += u'</script>'
# import pdb;pdb.set_trace()
return js
def sujbectsStr(self):
subjects = self.context.subject
subject_str = ''
for s in subjects:
subject_str += s + ', '
return subject_str.strip(', ')
class GridPlug(grok.View):
grok.context(ICover)
grok.name('grid_plug')
grok.require('zope2.View')
row_class = 'row'
column_class = 'cell'
def transform(self, layout):
for element in layout:
if 'type' in element:
if element['type'] == 'row':
element['class'] = self.row_class
if 'children' in element:
self.transform(
self.columns_formater(element['children']))
if element['type'] == 'group' and 'children' in element:
self.transform(element['children'])
if element['type'] == 'tile':
element['class'] = 'tile'
def columns_formater(self, columns):
#this formater works for deco, but you can implemente a custom one, for you grid system
w = 'width-'
p = 'position-'
offset = 0
for column in columns:
width = column['data']['column-size'] if 'data' in column else 1
column['class'] = self.column_class + ' ' + (
w + str(width)) + ' ' + (p + str(offset))
offset = offset + width
return columns
def render(self):
return self
class SiteManager(grok.Adapter):
grok.implements(interfaces.ISiteManager)
grok.context(interfaces.IPublication)
grok.require('zope2.ViewManagementScreens')
def make_site(self):
if self.is_site():
raise ValueError(_('Already a local site.'))
make_objectmanager_site(self.context)
def delete_site(self):
if not self.is_site():
raise ValueError(_('Not a local site.'))
if interfaces.IRoot.providedBy(self.context):
raise ValueError(_("Can't disable local site on Silva Root."))
sm = ISite(self.context).getSiteManager()
if list(sm.registeredAdapters()):
raise ValueError(_('Still have registered customizations.'))
if list(sm.registeredUtilities()):
raise ValueError(_('Still have registered services.'))
disableSite(self.context)
def is_site(self):
return ISite.providedBy(self.context)
class View(grok.View):
""" sample view class """
grok.context(IServerNode)
grok.require('zope2.View')
grok.name('view')
def details(self):
context = aq_inner(self.context)
data = getattr(context, 'serverdetails')
return json.loads(data)
def has_server_info(self):
data = self.details()
if 'nginx' in data.keys():
return True
return False
def check_server_status(self):
host = getattr(self.context, 'server')
protocol = getattr(self.context, 'protocol', 'http')
tool = getUtility(IWigoTool)
status = tool.status(hostname=host, service=protocol)
return status
class TramiteEnvioForm(base.AddForm):
"""Formulário de tramitação de envio de protocolos.
"""
grok.context(INavigationRoot)
grok.name('envio-tramite')
grok.require('zope2.View')
schema = IAddTramite
label = _(u'Tramitação de Protocolos - Envio')
description = _(u'Formulário de tramitação de envio de protocolos.')
dados = []
@log
def update(self):
self.request.set('disable_border', True)
sc = getUtility(ISecurityChecker)
sc.enforce('acessar_envio_tramite')
api = getUtility(ISPDOAPI)
self.dados = api.getProtocolosCriadosRecebidos()
super(TramiteEnvioForm, self).update()
@log
def createAndAdd(self, data):
api = getUtility(ISPDOAPI)
protocolos = self.request.protocolos
for protocolo_id in protocolos:
api.addAnexos(protocolo_id, data['anexos'])
api.TramiteEnvio(protocolos, data['areas'], data['despacho'])
def nextURL(self):
go('envio-tramite')
def cancelURL(self):
go('list-protocolo')
class HeadTitleViewlet(grok.Viewlet):
grok.context(IItem)
grok.layer(ISantaTemplatesLayer)
grok.name('santa.head.title')
grok.require('zope2.View')
grok.template('head-title')
grok.viewletmanager(IPortalHeader)
def head(self):
catalog = getToolByName(self.context, 'portal_catalog')
portal_state = getMultiAdapter((self.context, self.request),
name="plone_portal_state")
portal = portal_state.portal()
items = {
'title': portal.title,
'description': portal.description,
'portal_url': portal.absolute_url(),
}
head = portal.get('foundation')
if head:
query = {
'path': {
'query': '/'.join(head.getPhysicalPath()),
'depth': 1
}
}
brains = catalog(query)
if len(brains) > 0:
brain = brains[0]
title = brain.Title
description = brain.Description
if title:
items.update({'title': title})
if description:
items.update({'description': description})
return items
class CreateSubmittedProposal(grok.View):
grok.context(IPloneSiteRoot)
grok.name('create_submitted_proposal')
grok.require('zope2.Public')
def render(self):
jsondata = self.request.get(REQUEST_KEY)
data = json.loads(jsondata)
committee = Oguid.parse(data['committee_oguid']).resolve_object()
proposal_oguid = Oguid.parse(data['proposal_oguid'])
proposal = meeting_service().fetch_proposal_by_oguid(proposal_oguid)
with elevated_privileges():
submitted_proposal = SubmittedProposal.create(proposal, committee)
if is_word_meeting_implementation_enabled():
submitted_proposal.create_proposal_document(
filename=data['file']['filename'],
content_type=data['file']['contentType'].encode('utf-8'),
data=base64.decodestring(data['file']['data']))
self.request.response.setHeader("Content-type", "application/json")
return json.dumps(
{'path': '/'.join(submitted_proposal.getPhysicalPath())})
class ProtocoloAddForm(base.AddForm):
"""Formulário de cadastro de um protocolo.
"""
grok.context(INavigationRoot)
grok.name('add-protocolo')
grok.require('zope2.View')
schema = IAddProtocolo
label = _(u'Adicionar protocolo')
description = _(u'Formulário de cadastro de um protocolo.')
def update(self):
sc = getUtility(ISecurityChecker)
sc.enforce('acessar_add_protocolo', ajax=True)
super(ProtocoloAddForm, self).update()
@log
def createAndAdd(self, data):
api = getUtility(ISPDOAPI)
protocolo_id = api.addProtocolo(**data)
# IMPORTANTE: Por definição, exceto na criação dos protocolos,
# os anexos e as observações são sempre adicionadas ANTES da
# tramitação ocorrer.
api.TramiteInicial(protocolo_id)
api.addObservacao(protocolo_id, data['observacao'])
api.addAnexos(protocolo_id, data['anexos'])
self.protocolo_id = protocolo_id
def nextURL(self):
go('show-protocolo', id=self.protocolo_id)
def cancelURL(self):
go('list-protocolo')
class ZoomItJSON(grok.View):
grok.context(IZoomItImage)
grok.require('zope2.View')
grok.name('zoomit-json')
def update(self, **kw):
self.info = IZoomItInfo(self.context)
self.request.response.setHeader('Content-Type',
'application/json; charset=utf-8')
# Check if the widget is ready
wait_time = timedelta(seconds=self.info.retry_after or UPDATE_WAIT)
if (not self.info.ready and self.info.update_timestamp
and (datetime.now() - self.info.update_timestamp) < wait_time):
# We perform a write operation on a GET here, but only if
# the image is not ready and at most once every 10 minutes
self.info.update_status()
def render(self, **kw):
response = {}
response['ready'] = bool(self.info.ready)
response['embed'] = self.info.embed or ''
response['image_url'] = self.info.image_url
response['id'] = self.info.id
return dumps(response)
class events_listing_customview(grok.View):
grok.context(IATFolder)
grok.require('zope2.View')
@property
def catalog(self):
return getToolByName(self.context, 'portal_catalog')
def contents(self):
context = self.context
brains = self.catalog.unrestrictedSearchResults(
path={
'query': '/'.join(context.getPhysicalPath()),
'depth': 1,
'sort_order': 'reverse',
'sort_on': 'created'
})
results = []
for brain in brains:
data = {}
data['item_url'] = brain.getPath()
data['item_creator'] = brain.Creator
if hasattr(brain._unrestrictedGetObject(), 'start'):
data['item_start'] = brain._unrestrictedGetObject().start()
elif hasattr(brain._unrestrictedGetObject(), 'StartDate'):
data['item_start'] = brain._unrestrictedGetObject().StartDate()
else:
data['item_start'] = None
data['item_title_or_id'] = brain.pretty_title_or_id()
data['item_type'] = brain.portal_type
data['hasContentLeadImage'] = brain.hasContentLeadImage
data['lead_image'] = brain.getPath() + '/leadImage_preview'
results.append(data)
if results:
results.sort(key=lambda x: x['item_start'], reverse=True)
return results[:10]
class AreaListView(grok.View, BaseListView):
grok.name('list-area')
grok.context(INavigationRoot)
grok.require('cmf.ManagePortal')
dados = []
view_sufix = 'area'
@log
def update(self):
self.request.set('disable_border', True)
self.dados = []
session = Session()
items = session.query(db.Area).all()
for i in items:
self.dados.append({
'id': i.id,
'sigla': i.sigla,
'nome': i.nome,
'chefia_id': i.chefia_id,
'chefia_sigla': getattr(i.area,'sigla',''),
'chefia_nome': getattr(i.area,'nome',''),
})
class View(grok.View):
grok.context(IQuarterly)
grok.require('zope2.View')
grok.name('view')
def toLocalizedTime(self, time, long_format=None, time_only=None):
"""Convert time to localized time
"""
util = getToolByName(self.context, 'translation_service')
return util.ulocalized_time(time, long_format, time_only, self.context, domain='plonelocales')
def creator(self):
return self.context.Creator()
def author(self):
membership = getToolByName(self.context, 'portal_membership')
return membership.getMemberInfo(self.creator())
def authorname(self):
author = self.author()
return author and author['fullname'] or self.creator()
def Title(self):
return "Default Title"
class Edit(form.SchemaEditForm):
"""Override for the standard edit form so we can change the form title
for submodules.
View name: @@edit
"""
grok.context(IModule)
grok.require("cmf.ModifyPortalContent")
grok.layer(NuPloneSkin)
grok.name("edit")
@property
def label(self):
if self.context.aq_parent.portal_type == 'euphorie.module':
type_name = _('Submodule')
else:
portal_type = self.context.portal_type
fti = getUtility(IDexterityFTI, name=portal_type)
type_name = fti.Title()
return _(u"Edit ${name}", mapping={'name': type_name})
def updateWidgets(self):
super(Edit, self).updateWidgets()
self.widgets["title"].addClass("span-7")
class CheckinDocuments(layout.FormWrapper, grok.View):
"""View for checking in one or more documents. This view is either
called from a tabbed_view or folder_contents action (using the
request parameter "paths") or directly on the document itself
(without any request parameters.)
"""
grok.context(Interface)
grok.require('zope2.View')
grok.name('checkin_documents')
form = CheckinCommentForm
def __init__(self, context, request):
layout.FormWrapper.__init__(self, context, request)
grok.View.__init__(self, context, request)
def __call__(self, *args, **kwargs):
try:
return layout.FormWrapper.__call__(self, *args, **kwargs)
except NoItemsSelected:
msg = _(u'You have not selected any documents')
IStatusMessage(self.request).addStatusMessage(msg, type='error')
return get_containg_document_tab_url(self.context)
class EditForm(form.EditForm):
grok.name('edit')
grok.context(IParliamentarian)
grok.require('cmf.ModifyPortalContent')
fields = field.Fields(IParliamentarian)
fields['description'].widgetFactory = WysiwygFieldWidget
fields['party_affiliation'].widgetFactory = DataGridFieldFactory
fields['birthday'].widgetFactory = DateFieldWidget
def updateWidgets(self):
# WORKAROUND
# When DataGridField.auto_append == true a strange zodb serialization
# issue is raised during DataGridField.updateWidgets()
# We avoid this turning it off temporarily
try:
original_auto_append = DataGridField.auto_append
DataGridField.auto_append = False
super(EditForm, self).updateWidgets()
finally:
DataGridField.auto_append = original_auto_append
self.widgets['party_affiliation'].allow_reorder = True
self.widgets['party_affiliation'].auto_append = False
self.widgets['birthday'].allow_reorder = True
class UsersPropertiesMigration(REST):
"""
/api/userspropertiesmigration
"""
placeholder_type = 'person'
placeholder_id = 'username'
grok.adapts(APIRoot, IPloneSiteRoot)
grok.require('genweb.authenticated')
def GET(self):
""" Returns all users properties """
# Get all ldap users
searchString = ''
searchView = getMultiAdapter((aq_inner(self.context), self.request),
name='pas_search')
ldap_users = searchView.merge(
chain(*[
searchView.searchUsers(**{field: searchString})
for field in ['name']
]), 'userid')
result = []
for user in ldap_users:
user = api.user.get(username=user['id'])
properties = get_all_user_properties(user)
try:
info_user = dict(id=user.id, properties=properties)
result.append(info_user)
except:
logger.info('HA FALLAT LA INFO DE {}'.format(user.id))
return json.dumps(result)
class DossierActivateView(grok.View):
"""View which activates the dossier including its subdossiers."""
grok.context(IDossierMarker)
grok.name('transition-activate')
grok.require('zope2.View')
def render(self):
if self.check_preconditions():
self.activate()
return self.request.RESPONSE.redirect(self.context.absolute_url())
def check_preconditions(self):
satisfied = True
if self.context.is_subdossier():
state = api.content.get_state(self.context.get_parent_dossier())
if state == 'dossier-state-inactive':
satisfied = False
IStatusMessage(self.request).add(_(
"This subdossier can't be activated,"
"because the main dossiers is inactive"),
type='error')
return satisfied
def activate(self):
# subdossiers
for subdossier in self.context.get_subdossiers():
subdossier.getObject().activate()
# main dossier
self.context.activate()
IStatusMessage(self.request).add(_("The Dossier has been activated"),
type='info')
class VindulaUpdateFormView(grok.View):
grok.context(Interface)
grok.require('zope2.View')
grok.name('contentcore_update_form')
def render(self):
return "OK"
def update(self):
portal_catalog = getToolByName(self.context, 'portal_catalog')
portal = self.context.portal_url.getPortalObject()
itens = portal_catalog(
**{
'portal_type': ['vindula.contentcore.formulariobasico'],
'path': {
'query': '/'.join(portal.getPhysicalPath()),
'depth': 99
}
})
for item in itens:
obj = item.getObject()
print '******', obj.Title(), '******'
EditFormDataBase(obj, self.context)
class ContadorView(grok.View):
grok.context(Interface)
grok.require('zope2.View')
grok.name('contador-view')
def update(self):
"""
Essa view recebe uma url com as seguintes variáveis:
/@@contador-view?uid=ajkldfhlakjsfh&ct=BoaPratica
A view incrementa mais um no contador quando recebe as variaveis 'uid' e 'ct'
E retorna apenas a quantidade atual quando recebe apenas a variável 'uid'
"""
uid = self.request.form.get('uid')
content_type = self.request.form.get('ct')
contador = ContadorManager(uid, content_type)
if uid and content_type:
self.resultado = contador.setAcesso()
elif uid:
self.resultado = contador.getAcesso()
else:
return self.request.response.redirect('/')
return super(ContadorView, self).update()
class CanSendToPublic(grok.View):
grok.context(IElection)
grok.name("can-send-to-public")
grok.require("cmf.ReviewPortalContent")
def __call__(self):
pm = getToolByName(self.context, 'portal_membership')
auth_member = pm.getAuthenticatedMember()
ceo = self.context.chief_electoral_officer
proper_user = auth_member.getMemberId() == ceo
if not proper_user:
return False
if not (getattr(self.context, 'rolls_pdf') and
getattr(self.context, 'rolls_pdf_signature')):
return False
return True
def render(self):
return "can-send-to-public"
class fillEmptyTFGMOffers(grok.View):
grok.context(Interface)
grok.name('fillEmptyTFGMOffers')
grok.require('genweb.tfemarket.controlpanel')
grok.layer(IGenwebTfemarketLayer)
def getDegreesProgramType(self):
registry = queryUtility(IRegistry)
tfe_tool = registry.forInterface(ITfemarketSettings)
result = {}
if tfe_tool.titulacions_table:
for item in tfe_tool.titulacions_table:
result.update({item['codi_mec']: item['progam_type']})
return result
def render(self):
degrees = self.getDegreesProgramType()
pc = api.portal.get_tool('portal_catalog')
offers = pc.searchResults({'portal_type': 'genweb.tfemarket.offer'})
for data in offers:
offer = data.getObject()
if not offer.tfgm:
tfgm = []
for degree in offer.degree:
if degree in degrees:
if degrees[degree] == 'MA' and 'TFM' not in tfgm:
tfgm.append('TFM')
elif degrees[degree] == 'GR' and 'TFG' not in tfgm:
tfgm.append('TFG')
offer.tfgm = tfgm
offer.reindexObject()
return 'Finished'
class RejectView(grok.View):
grok.context(IOrganisation)
grok.require("cmf.ReviewPortalContent")
grok.name("reject")
def render(self):
""" We need to delete the current profile without shooting ourselves
in the foot. Therefore, use a low-level method for deletion and make
sure the necessary events get triggered.
"""
msg = 'The organisation profile "{0}" has been rejected'.format(
self.context.Title())
api.portal.show_message(message=msg, request=self.request)
# _send_notification(self.context, "mail_organisation_rejected")
id = self.context.id
container = aq_parent(self.context)
url = container.absolute_url()
ob = container._getOb(id)
obj_path = '/'.join(ob.getPhysicalPath())
catalog = getToolByName(container, "portal_catalog")
container._delObject(id=id, suppress_events=True)
notify(ObjectRemovedEvent(ob, container, id))
catalog.uncatalog_object(obj_path)
self.request.response.redirect(url)
class posts_by_author(grok.View):
grok.context(ISiteRoot)
grok.require('zope2.View')
grok.layer(IProductSpecific)
@property
def catalog(self):
return getToolByName(self.context, 'portal_catalog')
def contents(self):
results = []
author = self.authorValue()
brains = self.catalog.searchResults(portal_type=('News Item', 'Page',
'Event'),
sort_on='created',
sort_order='reverse',
review_state='shared_intranet')
for brain in brains:
if author in brain.listCreators or author == '':
results.append(brain)
#b_start = self.context.REQUEST.get('b_start',0)
#b_size = 1
#batch = Batch(results, b_size, int(b_start), orphan=0)
return results
def authorValue(self):
tag = ''
request = self.request
if request.form:
if 'name' in request.form:
tag = request.form['name']
return tag
def totalComments(self, context=None):
comments = IConversation(context)
return len(comments)
class View(JsonView):
grok.context(ActionPlan)
grok.require('zope2.View')
grok.name('index_html')
def do_GET(self):
info = plan_info(self.context)
info['type'] = 'actionplan'
return info
def do_DELETE(self):
session = object_session(self.context)
session.delete(self.context)
return {}
def do_PUT(self):
plan = self.context
try:
for (attr, key) in [('action_plan', 'plan'),
('prevention_plan', 'prevention'),
('requirements', 'requirements'),
('responsible', 'responsible'),
('reference', 'reference')]:
setattr(
plan, attr,
get_json_unicode(self.input, key, False,
getattr(plan, attr)))
plan.budget = get_json_int(self.input, 'budget', False,
plan.budget)
plan.planning_start = get_json_date(self.input, 'planning-start',
False, plan.planning_start)
plan.planning_end = get_json_date(self.input, 'planning-end',
False, plan.planning_end)
except (KeyError, ValueError) as e:
return {'type': 'error', 'message': str(e)}
return self.do_GET()
class CenterUpload(CenterRegister):
"""Upload support for distutils.
"""
grok.context(interfaces.ISilvaSoftwareCenter)
grok.require('silva.ChangeSilvaContent')
grok.name('file_upload')
def render(self):
status = u'Uploaded'
package, package_name, package_version = self._get_package()
release = self._get_release(package, package_version)
filename = self.request['content'].filename
archive = getattr(release, filename, None)
if archive is not None:
logger.info(u'Release %s of %s is already uploaded, replacing.' %
(package_version, package_name))
release.manage_delObjects([filename])
status = u'Replaced'
factory = release.manage_addProduct['Silva']
factory.manage_addFile(filename, filename, self.request['content'])
self.response.setStatus(200)
return status
class ViewReserve(grok.View):
grok.context(IVindulaReserve)
grok.require('zope2.View')
grok.name('view')
url_frame = '%s/vindula-api/reserva_corporativa/%s/make-reserve/%s/?iframe_id=%s'
def update(self):
context = self.context
self.portal_type = context.portal_type
try:
self.UID = context.UID()
except AttributeError:
self.UID = 'XXXXXX'
def get_id_frame(self):
return md5(self.portal_type + self.UID).hexdigest()
def get_url_frame(self):
url = self.context.portal_url()
user_token = self.request.SESSION.get('user_token')
return self.url_frame % (url, user_token, self.UID,
self.get_id_frame())
class createMAXUserForAllExistingUsers(grok.View):
grok.context(IPloneSiteRoot)
grok.require('zope2.ViewManagementScreens')
def render(self):
mtool = getToolByName(self, 'portal_membership')
searchView = getMultiAdapter((aq_inner(self.context), self.request),
name='pas_search')
searchString = ''
self.request.set('__ignore_group_roles__', True)
self.request.set('__ignore_direct_roles__', False)
explicit_users = searchView.merge(
chain(*[
searchView.searchUsers(**{field: searchString})
for field in ['login', 'fullname', 'email']
]), 'userid')
for user_info in explicit_users:
userId = user_info['id']
user = mtool.getMemberById(userId)
createMAXUser(user.getUserName())
class GlobalStatistics(form.SchemaForm, StatisticsMixin):
""" Site managers can access statistics for the whole site.
"""
grok.context(ISectorContainer)
grok.name('show-statistics')
grok.require('cmf.ModifyPortalContent')
grok.layer(IOSHAContentSkinLayer)
schema = StatisticsSchema
ignoreContext = True
label = _('title_statistics', default='Statistics Reporting')
label_detail = _('label_global', default=u'Global')
template = None
form_template = ViewPageTemplateFile("templates/statistics.pt")
@button.buttonAndHandler(_(u"Submit"))
def handleSubmit(self, action):
return self._handleSubmit()
def render(self):
if self.pdf_data is not None:
return self.pdf_data
else:
self.template = self.form_template
return self.template()
