def get_Video2(self):
     
     if 'video-2' in getSite():
         obj = getSite()['video-2']
         return obj
     else:
         return None        

    def __call__(self, value, *args, **kwargs):
        context = getSite()
        portal_membership = getToolByName(context, "portal_membership")
        user_admin = portal_membership.getMemberById('admin')

        # stash the existing security manager so we can restore it
        old_security_manager = getSecurityManager()

        # create a new context, as the owner of the folder
        newSecurityManager(context,user_admin)            
        
        portalGroup = getSite().portal_groups
        instance    = kwargs.get('instance', None)
        req = kwargs['REQUEST']
        form = req.form
        fields = ['Groups_view','Groups_edit','Groups_admin']
        for item in fields:

            id_grupo = instance.UID() +'-'+item.split('_')[1]
            atual = instance.__getattribute__(item)
            news = form.get(item)

            alterado = set(atual) - set(news)

            for j in alterado:
                portalGroup.getGroupById(id_grupo).removeMember(j) 

        # restore the original context
        setSecurityManager(old_security_manager)

def get_tool(name=None):
    """Get a portal tool in a simple way.

    :param name: [required] Name of the tool you want.
    :type name: string
    :returns: The tool that was found by name
    :Example: :ref:`portal_get_tool_example`
    """
    if not name:
        raise MissingParameterError("Missing required parameter: name")

    try:
        return getToolByName(getSite(), name)
    except AttributeError:

        # get a list of all tools so we can display their names in the error msg
        portal = getSite()
        tools = []
        for id in portal.objectIds():
            if id.startswith('portal_'):
                tools.append(id)

        raise InvalidParameterError(
            "Cannot find a tool with name '%s'. \n"
            "Available tools are:\n"
            "%s" % (name, '\n'.join(tools)))

def notifyModifiedPlumiVideo(obj ,event):
    """This gets called on IObjectEditedEvent - called whenever the object is edited."""
    workflow = getToolByName(obj,'portal_workflow')
    state = workflow.getInfoFor(obj,'review_state','')
    log = logging.getLogger('plumi.content.subscribers')
    log.info("notifyModifiedPlumiVideo... %s in state (%s) with event %s " % (obj.Title(), state,  event))
    if getSite():
        request = getSite().REQUEST
        #VISIBLE
        if state in ['private','visible'] and request.has_key('form.button.save'):
            #call IPlumiWorkflow API to decide if its ready to publish or needs hiding.
            # The adapter object will implement the logic for various content types
            if IPlumiWorkflow(obj).autoPublishOrHide():
                settings = get_settings()
                if settings.notifyReviewers:
                    IPlumiWorkflow(obj).notifyReviewersVideoSubmitted()
                    IPlumiWorkflow(obj).notifyOwnerVideoSubmitted()
        #PENDING , other states..
        if request.has_key('video_file_file'): #new video uploaded
            log.info('notifyModifiedPlumiVideo: video replaced;')
            async = getUtility(IAsyncService)
            temp_time = datetime.datetime.now(pytz.UTC) + datetime.timedelta(seconds=2)
            try:
                job = async.queueJobWithDelay(None, temp_time, setup_metadata, obj)
                log.info("job queued: %s" % job)
            except Exception as e:
                log.error('failed to queue setup_metadata job: %s' % e)

 def __call__(self):
     self.request.response.setHeader('Content-Type', 'application/json; charset=utf-8')
     form = self.request.form
     print form
     
     site = getSite()
     
     respondentid = form.get("respondentid","NULL")
     
     values = {'respondentid':respondentid, 
               'measurement' : str(form)}
 
     
     if respondentid in getSite().keys():
         print "updating " + respondentid
         new_object = getSite()[respondentid]
     
     else:
         print "New object " + respondentid
         objid = site.invokeFactory("Measurement", respondentid)
         # objid = _createObjectByType("Measurement", getSite(), respondentid)
         new_object = site[objid]
     
     new_object.setMeasurement(str(form))
     # new_object.processForm(metadata=1, values=values)
     transaction.commit()

    def get_profile_url(self, principal):
        """Returns the profile url of this `principal`.
        """
        if isinstance(principal, User):
            portal = getSite()
            return '/'.join((portal.portal_url(), '@@user-details',
                             principal.userid))

        elif self.is_inbox(principal):
            return None

        elif self.is_contact(principal):
            contact = self.get_contact(principal, check_permissions=True)
            if contact:
                return contact.getURL()
            else:
                return None

        elif self.is_user(principal):
            portal = getSite()
            user = self.get_user(principal)
            if user:
                return '/'.join((portal.portal_url(), '@@user-details',
                                 user.userid))
            else:
                # fallback with acl_users folder
                portal_membership = getToolByName(portal, 'portal_membership')
                member = portal_membership.getMemberById(principal)
                if member:
                    return portal_membership.getMemberById(
                        principal).getHomeUrl()
            return None

    def update(self):
        self.notification = RegistrationNotification(getSite())

        super(NotificationsForm, self).update()

        request = self.request

        if 'form.unsubscribe' in request:
            principals = request.get('form.principals', ())
            for pid in principals:
                self.notification.unsubscribe(pid)

            if principals:
                IStatusMessage(request).add(
                    _('Selected users have been unsubscribed.'))

        principals = []
        auth = getUtility(IAuthentication)

        for pid in self.notification.getSubscribers(getSite()):
            try:
                principal = auth.getPrincipal(pid)
            except PrincipalLookupError:
                continue

            profile = IPersonalProfile(principal)
            principals.append(
                (profile.title, {'id': pid, 'title': profile.title}))

        principals.sort()
        self.principals = [info for _t, info in principals]

    def test_setThreadSite_clearThreadSite(self):
        from zope.app.component.localservice import threadSiteSubscriber
        from zope.app.component.localservice import clearSite
        from zope.app.publication.zopepublication import BeforeTraverseEvent

        self.assertEqual(getSite(), None)

        # A non-site is traversed
        ob = object()
        request = object()
        ev = BeforeTraverseEvent(ob, request)
        threadSiteSubscriber(ev)

        self.assertEqual(getSite(), None)

        # A site is traversed
        ss = ServiceServiceStub()
        site = Folder()
        site.setSiteManager(ss)

        ev = BeforeTraverseEvent(site, request)
        threadSiteSubscriber(ev)

        self.assertEqual(getSite(), site)

        clearSite()

        self.assertEqual(getSite(), None)

    def isAvailable(self):
        if super(ErrorConfiglet, self).isAvailable():
            sm = IComponentLookup(getUtility(IErrorReportingUtility))
            if sameProxiedObjects(sm, getSite().getSiteManager()) or \
                IFolder.providedBy(getSite().__parent__):
                return True

        return False

 def _load_state(self):
     self._loaded = True
     self.uid = IUIDStrategy(self.context).getuid()
     self.portal = getSite()
     altportal = getSite()
     self.sender = invitation_sender(self.portal)
     self.localize = getToolByName(self.portal, 'translation_service')
     self.timefn = self.localize.ulocalized_time

 def getProduto(self):
     urltool = getSite().portal_url
     caminho = urltool.getPortalPath()+'/cardapio';
     ctool = getSite().portal_catalog
     items = ctool(portal_type='pizzaria.content.produto', 
                   review_state='published',
                   path=caminho)        
     return items

 def __init__(self, object):
     self.object = object
     self.site = getSite()
     import logging
     self._logger = logging.getLogger('wildcard.migrator')
     self._doc = PrettyDocument()
     self.sitepath = '/'.join(getSite().getPhysicalPath())
     self.objectpath = '/'.join(
         object.getPhysicalPath())[len(self.sitepath):]

 def getCadastro(self):
     membership = getSite().portal_membership
     user_login = membership.getAuthenticatedMember()
     try:
         cadastro= getSite()['clientes'][user_login.id]
     except:
         cadastro= None
         
     return cadastro

 def get_flash_banners(self):
     """Retorna os objetos to tipo banner em determinado local"""
     
     urltool = getSite().portal_url
     caminho = urltool.getPortalPath()+'/jornal-da-caixa/banners-do-jornal';
     ctool = getSite().portal_catalog
     items = ctool(portal_type='BannerFlash', 
                   review_state='published',
                   path=caminho)        
     return items

    def update(self):
        super(MessageTemplate, self).update()

        request, context = self.request, self.context

        self.portal_title = getMultiAdapter((getSite(), request), IBreadcrumb).name
        self.portal_url = '%s/' % absoluteURL(getSite(), request)
        self.url = '%s/' % absoluteURL(context, request)

        self.form = getMultiAdapter((context, request), IFormResults)
        self.form.update(self.record)

    def voc_listGroups(self):
        terms = []
        if 'acl_users' in getSite().keys():
            groups = getSite().get('acl_users').getGroups()

            for group in groups:
                member_id = group.id
                member_name = group.getProperties().get('title','')
                terms.append((member_id, unicode(member_name)))

        return terms

    def search(self, object=None, contexts=(),
               sort_on='date', sort_order='reverse',
               noSecurityChecks=False, **kw):

        ids = getUtility(IIntIds)

        query = dict(kw)

        # records for object
        if type(object) is not type({}) and object is not None:
            oid = ids.queryId(removeAllProxies(object))
            if oid is None:
                return ResultSet(IFBTree(), getUtility(IActivity))

            query['object'] = {'any_of': (oid,)}

        # context
        if not contexts:
            contexts = (getSite(),)

        c = []
        for context in contexts:
            id = ids.queryId(removeAllProxies(context))
            if id is not None:
                c.append(id)

        query['contexts'] = {'any_of': c}

        # security
        if not noSecurityChecks:
            request = getRequest()
            if request is not None:
                users = listAllowedRoles(request.principal, getSite())
                if 'zope.Anonymous' not in users:
                    users.append('zope.Anonymous')

                query['allowedUsers'] = {'any_of': users}

        # apply searh terms
        results = self.apply(query)
        if results is None:
            results = IFBTree()

        # sort result by index
        if sort_on and sort_on in self:
            sortable = ISortable(self[sort_on], None)
            if sortable is not None:
                results = sortable.sort(results)

        if sort_order == 'reverse':
            return ReverseResultSet(results, getUtility(IActivity))
        else:
            return ResultSet(results, getUtility(IActivity))

    def configurador(self):
        self.update()
        if "control-panel-objects" in getSite().keys():
            control = getSite()["control-panel-objects"]
            if "vindula_vindulaconfigall" in control.keys():
                return control["vindula_vindulaconfigall"]

            else:

                return False
        else:
            return False

    def getConfigurador(self):

        if 'control-panel-objects' in  getSite().keys():
            control = getSite()['control-panel-objects']
            if 'ThemeConfig' in control.keys():
                confg = control['ThemeConfig']
                try:
                    return confg.getFavicon().absolute_url()
                except:
                    return None
            else:
                return None
        else:
            return None

    def getListToOrder(self):
        result = [('effective', u'Effective Date', 'The time and date an item becomes publicly available'), \
                  ('sortable_title', u'Sortable Title', u"An item's title transformed for sorting")]

        if 'control-panel-objects' in getSite().keys():
            control = getSite()['control-panel-objects']
            if 'vindula_categories' in control.keys():
                confg = control['vindula_categories']
                try:
                    for i in confg.getOrder_list():
                        result.append(i.replace('(', '').replace(')','').replace('u\'', '').replace('\'', '').split(','))
                except:
                    return result
        return result