Python CustomizationPolicy.register Examples

Example #1

File: __init__.py Project: BenoitTalbot/bungeni-portal

def initialize(context):
    ##code-section custom-init-top #fill in your manual code here
    ##/code-section custom-init-top

    # imports packages and types for registration

    import LookAndFeel

    # Initialize portal content
    content_types, constructors, ftis = process_types(
        listTypes(PROJECTNAME),
        PROJECTNAME)

    cmfutils.ContentInit(
        PROJECTNAME + ' Content',
        content_types      = content_types,
        permission         = DEFAULT_ADD_CONTENT_PERMISSION,
        extra_constructors = constructors,
        fti                = ftis,
        ).initialize(context)

    # Apply customization-policy, if theres any
    if CustomizationPolicy and hasattr(CustomizationPolicy, 'register'):
        CustomizationPolicy.register(context)
        print 'Customization policy for BungeniSkinPanafrica installed'

Example #2

File: __init__.py Project: collective/collective.ads

def initialize(context):
    """Initializer called when used as a Zope 2 product."""
    ##code-section custom-init-top #fill in your manual code here
    ##/code-section custom-init-top

    # imports packages and types for registration
    import content
    import admin

    content_types, constructors, ftis = process_types(
        listTypes(PROJECTNAME),
        PROJECTNAME)

    cmfutils.ContentInit(
        PROJECTNAME + ' Content',
        content_types      = content_types,
        permission         = DEFAULT_ADD_CONTENT_PERMISSION,
        extra_constructors = constructors,
        fti                = ftis,
        ).initialize(context)
        
    tools = [admin.AdsAdmin.AdsAdmin]
    ToolInit("%s Tool" % PROJECTNAME,
                    tools=tools,
                    icon="browser/images/adminicon.gif",
                   ).initialize(context)
    # Apply customization-policy, if theres any
    if CustomizationPolicy and hasattr(CustomizationPolicy, 'register'):
        CustomizationPolicy.register(context)
        print 'Customization policy for Ads installed'

Example #3

File: __init__.py Project: BGCX261/zmetadata-svn-to-git

def initialize(context):
    ##code-section custom-init-top #fill in your manual code here
    ##/code-section custom-init-top

    # imports packages and types for registration

    import Custodian
    import Harvester
    import Log
    import Metadata
    import MetadataManager
    import Standard    
    import Logs
#    import MetadataCollection
    import LogContainer
    import Archive

    # Initialize portal content
    content_types, constructors, ftis = process_types(
        listTypes(PROJECTNAME),
        PROJECTNAME)

    cmfutils.ContentInit(
        PROJECTNAME + ' Content',
        content_types      = content_types,
        permission         = DEFAULT_ADD_CONTENT_PERMISSION,
        extra_constructors = constructors,
        fti                = ftis,
        ).initialize(context)

    # Apply customization-policy, if theres any
    if CustomizationPolicy and hasattr(CustomizationPolicy, 'register'):
        CustomizationPolicy.register(context)
        print 'Customization policy for ZMetadata installed'

Example #4

File: __init__.py Project: uwosh/UWOshOIE

def initialize(context):
    # imports packages and types for registration
    from Products.validation import validation
    validation.register(validators.ReferenceValidator('ReferenceValidator'))
    validation.register(validators.isValidYearValidator('isValidYearValidator'))
    validation.register(validators.isDifficultToWalkValidator('isDifficultToWalkValidator'))
    validation.register(validators.orientationSession2hoursValidator('orientationSession2hoursValidator'))
    validation.register(validators.orientationSession2DateValidator('orientationSession2DateValidator'))
    validation.register(validators.orientationConflictDateValidator('orientationConflictDateValidator'))
    validation.register(validators.financialAidValidator('financialAidValidator'))
    
    import content

    # initialize portal content
    content_types, constructors, ftis = process_types(
        listTypes(PROJECTNAME),
        PROJECTNAME)

    utils.ContentInit(
        PROJECTNAME + ' Content',
        content_types      = content_types,
        permission         = DEFAULT_ADD_CONTENT_PERMISSION,
        extra_constructors = constructors,
        fti                = ftis,
        ).initialize(context)

    # apply customization-policy, if theres any
    if CustomizationPolicy and hasattr(CustomizationPolicy, 'register'):
        CustomizationPolicy.register(context)
        print 'Customization policy for UWOshOIE installed'

Example #5

def initialize(context):
    ##code-section custom-init-top #fill in your manual code here
    ##/code-section custom-init-top

    # imports packages and types for registration

    import LookAndFeel

    # Initialize portal content
    content_types, constructors, ftis = process_types(
        listTypes(PROJECTNAME),
        PROJECTNAME)

    cmfutils.ContentInit(
        PROJECTNAME + ' Content',
        content_types      = content_types,
        permission         = DEFAULT_ADD_CONTENT_PERMISSION,
        extra_constructors = constructors,
        fti                = ftis,
        ).initialize(context)

    # Apply customization-policy, if theres any
    if CustomizationPolicy and hasattr(CustomizationPolicy, 'register'):
        CustomizationPolicy.register(context)
        print 'Customization policy for BungeniSkin installed'

Example #6

File: __init__.py Project: cislgov/cisl.portal.plone25

def initialize(context):
    ##code-section custom-init-top #fill in your manual code here
    ##/code-section custom-init-top

    # imports packages and types for registration
    import tools


    # Initialize portal tools
    tools = [tools.password_tool.password_tool]
    ToolInit( PROJECTNAME +' Tools',
                tools = tools,
                icon='tool.gif'
                ).initialize( context )

    # Initialize portal content
    content_types, constructors, ftis = process_types(
        listTypes(PROJECTNAME),
        PROJECTNAME)

    cmfutils.ContentInit(
        PROJECTNAME + ' Content',
        content_types      = content_types,
        permission         = DEFAULT_ADD_CONTENT_PERMISSION,
        extra_constructors = constructors,
        fti                = ftis,
        ).initialize(context)

    # Apply customization-policy, if theres any
    if CustomizationPolicy and hasattr(CustomizationPolicy, 'register'):
        CustomizationPolicy.register(context)
        print 'Customization policy for SERPROSenha installed'

Example #7

def initialize(context):
    # Initialize portal content
    content_types, constructors, ftis = process_types(listTypes(PROJECTNAME),
                                                      PROJECTNAME)

    cmfutils.ContentInit(
        PROJECTNAME + ' Content',
        content_types=content_types,
        permission=DEFAULT_ADD_CONTENT_PERMISSION,
        extra_constructors=constructors,
        fti=ftis,
    ).initialize(context)

    # Apply customization-policy, if theres any
    if CustomizationPolicy and hasattr(CustomizationPolicy, 'register'):
        CustomizationPolicy.register(context)
        print 'Customization policy for ZipFileTransport installed'

Example #8

File: __init__.py Project: a25kk/mp-bbb

def initialize(portal):
  import content.TabbedSubpages

  content_types, constructors, ftis = \
    process_types(listTypes(PROJECTNAME), PROJECTNAME)

  utils.ContentInit(
    PROJECTNAME,
    content_types      = content_types,
    permission         = AddTabbedSubpages,
    extra_constructors = constructors,
    fti                = ftis,
    ).initialize(portal)

  if CustomizationPolicy and hasattr(CustomizationPolicy, 'register'):
    CustomizationPolicy.register(context)
    print 'Customizationpolicy for %s installed' % PROJECTNAME

Example #9

File: __init__.py Project: liberiun/cynin-intranet

def initialize(context):
    # Initialize portal content
    content_types, constructors, ftis = process_types(
        listTypes(PROJECTNAME),
        PROJECTNAME)

    cmfutils.ContentInit(
        PROJECTNAME + ' Content',
        content_types      = content_types,
        permission         = DEFAULT_ADD_CONTENT_PERMISSION,
        extra_constructors = constructors,
        fti                = ftis,
        ).initialize(context)

    # Apply customization-policy, if theres any
    if CustomizationPolicy and hasattr(CustomizationPolicy, 'register'):
        CustomizationPolicy.register(context)
        print 'Customization policy for ZipFileTransport installed'

Example #10

File: __init__.py Project: a25kk/stv2

def initialize(context):
    ##code-section custom-init-top #fill in your manual code here
    ##/code-section custom-init-top

    # imports packages and types for registration
    import interfaces
    import content

    import WindowZTool

    # Initialize portal tools
    tools = [WindowZTool.WindowZTool]
    ToolInit( PROJECTNAME +' Tools',
                tools = tools,
                icon='tool.gif'
                ).initialize( context )

    # Initialize portal content
    all_content_types, all_constructors, all_ftis = process_types(
        listTypes(PROJECTNAME),
        PROJECTNAME)

    cmfutils.ContentInit(
        PROJECTNAME + ' Content',
        content_types      = all_content_types,
        permission         = DEFAULT_ADD_CONTENT_PERMISSION,
        extra_constructors = all_constructors,
        fti                = all_ftis,
        ).initialize(context)

    # Give it some extra permissions to control them on a per class limit
    for i in range(0,len(all_content_types)):
        klassname=all_content_types[i].__name__
        if not klassname in ADD_CONTENT_PERMISSIONS:
            continue

        context.registerClass(meta_type   = all_ftis[i]['meta_type'],
                              constructors= (all_constructors[i],),
                              permission  = ADD_CONTENT_PERMISSIONS[klassname])

    # Apply customization-policy, if theres any
    if CustomizationPolicy and hasattr(CustomizationPolicy, 'register'):
        CustomizationPolicy.register(context)
        print 'Customization policy for windowZ installed'

Example #11

def initialize(context):
    # imports packages and types for registration
    from Products.validation import validation
    validation.register(validators.ReferenceValidator('ReferenceValidator'))
    validation.register(
        validators.isValidYearValidator('isValidYearValidator'))
    validation.register(
        validators.isDifficultToWalkValidator('isDifficultToWalkValidator'))
    validation.register(
        validators.orientationSession2hoursValidator(
            'orientationSession2hoursValidator'))
    validation.register(
        validators.orientationSession2DateValidator(
            'orientationSession2DateValidator'))
    validation.register(
        validators.orientationConflictDateValidator(
            'orientationConflictDateValidator'))
    validation.register(
        validators.financialAidValidator('financialAidValidator'))

    import content

    # initialize portal content
    content_types, constructors, ftis = process_types(listTypes(PROJECTNAME),
                                                      PROJECTNAME)

    utils.ContentInit(
        PROJECTNAME + ' Content',
        content_types=content_types,
        permission=DEFAULT_ADD_CONTENT_PERMISSION,
        extra_constructors=constructors,
        fti=ftis,
    ).initialize(context)

    # apply customization-policy, if theres any
    if CustomizationPolicy and hasattr(CustomizationPolicy, 'register'):
        CustomizationPolicy.register(context)
        print 'Customization policy for UWOshOIE installed'

Example #12

File: __init__.py Project: a25kk/stv2

def initialize(context):
    ##code-section custom-init-top #fill in your manual code here
    ##/code-section custom-init-top

    # imports packages and types for registration
    import content
    import interfaces

    import utilities
    import contenthandler

    # Initialize portal content
    content_types, constructors, ftis = process_types(
        listTypes(PROJECTNAME),
        PROJECTNAME)

    cmfutils.ContentInit(
        PROJECTNAME + ' Content',
        content_types      = content_types,
        permission         = DEFAULT_ADD_CONTENT_PERMISSION,
        extra_constructors = constructors,
        fti                = ftis,
        ).initialize(context)

    # Apply customization-policy, if theres any
    if CustomizationPolicy and hasattr(CustomizationPolicy, 'register'):
        CustomizationPolicy.register(context)
        print 'Customization policy for feedfeeder installed'

    ##code-section custom-init-bottom #fill in your manual code here
    profile_registry.registerProfile(
        name='default',
        title='Feedfeeder',
        description='Profile for Feedfeeder',
        path='profiles/default',
        product='feedfeeder',
        profile_type=EXTENSION,
        for_=Products.CMFPlone.interfaces.IPloneSiteRoot)

Example #13

File: __init__.py Project: carrascoMDD/gvSIG-i18n

def initialize(context):
    ##code-section custom-init-top #fill in your manual code here
    ##/code-section custom-init-top

    # imports packages and types for registration



    import TRAConfiguracion

    import TRAColeccionInformes

    import TRAArquetipo

    import TRAModulo

    import TRAColeccionCadenas

    import TRAProgreso

    import TRAInforme

    import TRAColeccionArquetipos

    import TRAParametrosControlProgreso

    import TRAContenidoXML

    import TRAColeccionImportaciones

    import TRACadena

    import TRAColeccionSolicitudesCadenas

    import TRAElemento

    import TRAConfiguracionSolicitudesCadenas

    import TRAConfiguracionPaginaTraducciones

    import TRASimbolosOrdenados

    import TRACatalogo

    import TRAColeccionIdiomas

    import TRAConfiguracionInvalidacionInformes

    import TRAConfiguracionVarios

    import TRAContenidoIntercambio

    import TRAConfiguracionImportacion

    import TRAConfiguracionExportacion

    import TRAConRegistroActividad

    import TRAImportacion

    import TRAIdioma

    import TRAColeccionModulos

    import TRATraduccion

    import TRAColeccionContribuciones

    import TRAColeccionProgresos

    import TRAConfiguracionPermisos

    import TRAContribuciones

    import TRAConfiguracionPerfilEjecucion

    import TRASolicitudCadena



    # Initialize portal content

    all_content_types, all_constructors, all_ftis = process_types(
        listTypes(PROJECTNAME),
        PROJECTNAME)

    cmfutils.ContentInit(
        PROJECTNAME + ' Content',
        content_types      = all_content_types,
        permission         = DEFAULT_ADD_CONTENT_PERMISSION,
        extra_constructors = all_constructors,
        fti                = all_ftis,
        ).initialize(context)

    # Give it some extra permissions to control them on a per class limit
    for i in range(0,len(all_content_types)):
        klassname=all_content_types[i].__name__
        if not klassname in ADD_CONTENT_PERMISSIONS:
            continue

        context.registerClass(meta_type   = all_ftis[i]['meta_type'],
                              constructors= (all_constructors[i],),
                              permission  = ADD_CONTENT_PERMISSIONS[klassname])


    # Apply customization-policy, if theres any
    if CustomizationPolicy and hasattr(CustomizationPolicy, 'register'):
        CustomizationPolicy.register(context)
        print 'Customization policy for gvSIGi18n installed'

Example #14

File: __init__.py Project: BackupTheBerlios/ploneradio-svn

try:

Example #15

File: __init__.py Project: carrascoMDD/gvSIG-i18n

    # Give it some extra permissions to control them on a per class limit
    for i in range(0,len(all_content_types)):
        klassname=all_content_types[i].__name__
        if not klassname in ADD_CONTENT_PERMISSIONS:
            continue

        context.registerClass(meta_type   = all_ftis[i]['meta_type'],
                              constructors= (all_constructors[i],),
                              permission  = ADD_CONTENT_PERMISSIONS[klassname])
<dtml-else>
    content_types, constructors, ftis = process_types(
        listTypes(PROJECTNAME),
        PROJECTNAME)

    cmfutils.ContentInit(
        PROJECTNAME + ' Content',
        content_types      = content_types,
        permission         = DEFAULT_ADD_CONTENT_PERMISSION,
        extra_constructors = constructors,
        fti                = ftis,
        ).initialize(context)
</dtml-if>

    # Apply customization-policy, if theres any
    if CustomizationPolicy and hasattr(CustomizationPolicy, 'register'):
        CustomizationPolicy.register(context)
        print 'Customization policy for <dtml-var "product_name"> installed'

<dtml-var "protected_init_section_bottom">

Example #16

File: __init__.py Project: carrascoMDD/gvSIG-bpd

def initialize(context):
    ##code-section custom-init-top #fill in your manual code here
    ##/code-section custom-init-top

    # imports packages and types for registration

    import BPDColeccionPoliticasDeNegocio
    import BPDPlazo
    import BPDArquetipo
    import BPDSalida
    import BPDConRegistroActividad
    import BPDPoliticaDeNegocio
    import BPDProgramable
    import BPDFracasoFinal
    import BPDEnvio
    import BPDArquetipoConAdopcion
    import BPDConTraducciones
    import BPDEscenario
    import BPDParticipante
    import BPDExitoFinal
    import BPDColeccionHerramientas
    import BPDColeccionPasos
    import BPDUnidadOrganizacional
    import BPDColeccionProcesosDeNegocio
    import BPDProcesoDeNegocioSimple
    import BPDPasoEstimado
    import BPDRecepcion
    import BPDProgramado
    import BPDListaDePruebas
    import BPDCasoDePrueba
    import BPDPreCondicion
    import BPDPrograma
    import BPDColeccionArquetipos
    import BPDPuntoExtension
    import BPDColeccionCasosDePrueba
    import BPDEntrada
    import BPDPasoConAnteriores
    import BPDColeccionSalidas
    import BPDHerramienta
    import BPDColeccionPerfiles
    import BPDDecision
    import BPDElemento
    import BPDPasoSimple
    import BPDCaracteristica
    import BPDResolucionDatos
    import BPDConDatosDePrueba
    import BPDSubProceso
    import BPDPasoConExcepciones
    import BPDUsoArtefacto
    import BPDExtensionProceso
    import BPDPerfil
    import BPDCondicion
    import BPDReglaDeNegocio
    import BPDEpisodio
    import BPDPrePostCondicional
    import BPDArtefacto
    import BPDProcesoDeNegocio
    import BPDPostCondicion
    import BPDCondicionante
    import BPDCondicional
    import BPDArquetipoReferenciable
    import BPDUsoCaracteristica
    import BPDConVersiones
    import BPDPasoGeneral
    import BPDColeccionReglasDeNegocio
    import BPDReferenciaCualificada
    import BPDPasoGestorExcepciones
    import BPDColeccionListasDePruebas
    import BPDPasoMinimo
    import BPDColeccionArtefactos
    import BPDColeccionEntradas
    import BPDConResolucionesDatos
    import BPDPasoConRestriccionesTiempo
    import BPDDatosDePrueba
    import BPDColeccionUnidadesOrganizacionales
    import BPDPasoConSiguientes
    import BPDOrganizacion

    # Initialize portal content
    content_types, constructors, ftis = process_types(
        listTypes(PROJECTNAME),
        PROJECTNAME)

    cmfutils.ContentInit(
        PROJECTNAME + ' Content',
        content_types      = content_types,
        permission         = DEFAULT_ADD_CONTENT_PERMISSION,
        extra_constructors = constructors,
        fti                = ftis,
        ).initialize(context)

    # Apply customization-policy, if theres any
    if CustomizationPolicy and hasattr(CustomizationPolicy, 'register'):
        CustomizationPolicy.register(context)
        print 'Customization policy for gvSIGbpd installed'