Changeset 12371


Ignore:
Timestamp:
3 Jan 2015, 07:38:07 (10 years ago)
Author:
Henrik Bettermann
Message:

Replace 'skeleton' by 'pcn'.

Location:
main/ikobacustom.pcn/trunk
Files:
39 edited
1 moved

Legend:

Unmodified
Added
Removed

  • main/ikobacustom.pcn/trunk

    • Property svn:global-ignores set to
      bin
      develop-eggs
      parts
      sources
      var

  • main/ikobacustom.pcn/trunk/README.txt

    r12175 r12371  
    1 ikobacustom.skeleton
    2 ********************
     1ikobacustom.pcn
     2***************
    33
    44Customizations of the `waeup.ikoba` package.

  • main/ikobacustom.pcn/trunk/buildout.cfg

    r12304 r12371  
    6363# number of preopened paster threads, default 10
    6464threadpool_workers = 10
    65 devel_pkg = ikobacustom.skeleton
     65devel_pkg = ikobacustom.pcn
    6666
    6767[app]
    6868# This creates all scripts in bin/. The ikobactl created here is 'faulty'.
    6969recipe = zc.recipe.egg
    70 eggs = ikobacustom.skeleton [beaker, diazo]
     70eggs = ikobacustom.pcn [beaker, diazo]
    7171       z3c.evalexception>=2.0
    7272       Paste
    … …  
    8282# fixed path to zdaemon.conf as argument.
    8383recipe = zc.recipe.egg
    84 eggs = ikobacustom.skeleton [beaker, diazo]
     84eggs = ikobacustom.pcn [beaker, diazo]
    8585       waeup.ikoba
    8686arguments = "${buildout:parts-directory}/etc/zdaemon.conf"
    … …  
    101101[test]
    102102recipe = zc.recipe.testrunner
    103 eggs = ikobacustom.skeleton [beaker, test]
     103eggs = ikobacustom.pcn [beaker, test]
    104104defaults = ['--tests-pattern', '^f?tests$', '-v']
    105105
    … …  
    107107[i18n]
    108108recipe = z3c.recipe.i18n:i18n
    109 packages = ikobacustom.skeleton
    110 eggs = ikobacustom.skeleton
    111 domain = ikobacustom.skeleton
    112 output = src/ikobacustom/skeleton/locales
     109packages = ikobacustom.pcn
     110eggs = ikobacustom.pcn
     111domain = ikobacustom.pcn
     112output = src/ikobacustom/pcn/locales
    113113zcml =
    114114
    … …  
    117117[zpasswd]
    118118recipe = z3c.recipe.dev:script
    119 eggs = ikobacustom.skeleton
     119eggs = ikobacustom.pcn
    120120module = zope.app.server.zpasswd
    121121method = main
    … …  
    187187#[waeupdocs]
    188188#recipe = collective.recipe.sphinxbuilder
    189 #eggs = ikobacustom.skeleton[docs]
     189#eggs = ikobacustom.pcn[docs]
    190190#source = ${buildout:directory}/docs/source
    191191#build = ${buildout:directory}/docs/build
    … …  
    194194[coverage-detect]
    195195recipe = zc.recipe.testrunner
    196 eggs = ikobacustom.skeleton[beaker]
     196eggs = ikobacustom.pcn[beaker]
    197197defaults = ['--tests-pattern', '^f?tests$', '-v', '--coverage', 'coverage']
    198198
    … …  
    215215    diazo [wsgi]
    216216    PasteScript
    217     ikobacustom.skeleton [beaker,diazo]
     217    ikobacustom.pcn [beaker,diazo]

  • main/ikobacustom.pcn/trunk/etc/profile.ini.in

    r12175 r12371  
    5757
    5858[app:app]
    59 use = egg:ikobacustom.skeleton
     59use = egg:ikobacustom.pcn
    6060
    6161[pipeline:main]

  • main/ikobacustom.pcn/trunk/etc/site.zcml.in

    r12175 r12371  
    11<configure xmlns="http://namespaces.zope.org/zope"
    22           xmlns:ikoba="http://namespaces.waeup.org/ikoba"
    3            i18n_domain="ikobacustom.skeleton">
     3           i18n_domain="ikobacustom.pcn">
    44
    5   <include package="ikobacustom.skeleton" />
    6   <include package="ikobacustom.skeleton" file="mail.zcml" />
     5  <include package="ikobacustom.pcn" />
     6  <include package="ikobacustom.pcn" file="mail.zcml" />
    77
    88  <!-- install job container
    … …  
    2929      path="${buildout:directory}/var/datacenter" />
    3030
    31     <configure i18n_domain="ikobacustom.skeleton">
     31    <configure i18n_domain="ikobacustom.pcn">
    3232
    3333      <unauthenticatedPrincipal id="zope.anybody"

  • main/ikobacustom.pcn/trunk/setup.py

    r12175 r12371  
    5252    )
    5353
    54 setup(name = 'ikobacustom.skeleton',
     54setup(name = 'ikobacustom.pcn',
    5555      version = version,
    5656      description = "Customizations of the waeup.ikoba package",

  • main/ikobacustom.pcn/trunk/src

    • Property svn:global-ignores set to
      ikobacustom.pcn.egg-info

  • main/ikobacustom.pcn/trunk/src/ikobacustom/pcn/configure.zcml

    r12175 r12371  
    66  -->
    77  <include package="waeup.ikoba" />
    8   <include package="ikobacustom.skeleton" file="locales.zcml" />
     8  <include package="ikobacustom.pcn" file="locales.zcml" />
    99  <grok:grok package="." />
    1010
    … …  
    1414           zope.publisher.interfaces.browser.IBrowserRequest"
    1515      provides="zope.formlib.interfaces.ISimpleInputWidget"
    16       factory="ikobacustom.skeleton.widgets.phonewidget.NigeriaPhoneWidget"
     16      factory="ikobacustom.pcn.widgets.phonewidget.NigeriaPhoneWidget"
    1717      permission="zope.Public"
    1818      />

  • main/ikobacustom.pcn/trunk/src/ikobacustom/pcn/customers/batching.py

    r12286 r12371  
    1616## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
    1717##
    18 """Batch processing for skeleton documents.
     18"""Batch processing for pcn documents.
    1919"""
    2020import grok
    … …  
    2222    CustomerProcessor,
    2323    CustomerDocumentProcessorBase, ContractProcessorBase)
    24 from ikobacustom.skeleton.customers.interfaces import (
    25     ISkeletonCustomer,
    26     ISkeletonCustomerDocument, ISkeletonContract)
    27 from ikobacustom.skeleton.interfaces import MessageFactory as _
     24from ikobacustom.pcn.customers.interfaces import (
     25    IPCNCustomer,
     26    IPCNCustomerDocument, IPCNContract)
     27from ikobacustom.pcn.interfaces import MessageFactory as _
    2828
    2929
    30 class SkeletonCustomerProcessor(CustomerProcessor):
     30class PCNCustomerProcessor(CustomerProcessor):
    3131    """A batch processor for ICustomer objects.
    3232    """
    33     util_name = 'skeletoncustomerprocessor'
     33    util_name = 'pcncustomerprocessor'
    3434    grok.name(util_name)
    35     name = _('Skeleton Customer Processor')
    36     iface = ISkeletonCustomer
     35    name = _('PCN Customer Processor')
     36    iface = IPCNCustomer
    3737
    3838
    39 class SkeletonCustomerDocumentProcessor(CustomerDocumentProcessorBase):
    40     """A batch processor for ISkeletonCustomerDocument objects.
     39class PCNCustomerDocumentProcessor(CustomerDocumentProcessorBase):
     40    """A batch processor for IPCNCustomerDocument objects.
    4141    """
    42     util_name = 'skeletoncustomerdocumentprocessor'
     42    util_name = 'pcncustomerdocumentprocessor'
    4343    grok.name(util_name)
    44     name = _('Skeleton Customer Document Processor')
    45     iface = ISkeletonCustomerDocument
    46     factory_name = 'waeup.SkeletonCustomerDocument'
     44    name = _('PCN Customer Document Processor')
     45    iface = IPCNCustomerDocument
     46    factory_name = 'waeup.PCNCustomerDocument'
    4747
    4848
    49 class SkeletonContractProcessor(ContractProcessorBase):
    50     """A batch processor for ISkeletonContract objects.
     49class PCNContractProcessor(ContractProcessorBase):
     50    """A batch processor for IPCNContract objects.
    5151    """
    52     util_name = 'skeletoncontractprocessor'
     52    util_name = 'pcncontractprocessor'
    5353    grok.name(util_name)
    54     name = _('Skeleton Customer Contract Processor')
    55     iface = ISkeletonContract
    56     factory_name = 'waeup.SkeletonContract'
     54    name = _('PCN Customer Contract Processor')
     55    iface = IPCNContract
     56    factory_name = 'waeup.PCNContract'

  • main/ikobacustom.pcn/trunk/src/ikobacustom/pcn/customers/contracts.py

    r12335 r12371  
    2626from waeup.ikoba.customers.interfaces import ICustomerNavigation
    2727from waeup.ikoba.customers.contracts import ContractBase
    28 from ikobacustom.skeleton.interfaces import MessageFactory as _
    29 from ikobacustom.skeleton.customers.interfaces import (
    30     ISkeletonContract, ISkeletonContractEdit, ISkeletonContractProcess)
     28from ikobacustom.pcn.interfaces import MessageFactory as _
     29from ikobacustom.pcn.customers.interfaces import (
     30    IPCNContract, IPCNContractEdit, IPCNContractProcess)
    3131
    3232
    33 class SkeletonContract(ContractBase):
     33class PCNContract(ContractBase):
    3434    """This is a sample contract.
    3535    """
    3636
    3737    grok.implements(
    38         ISkeletonContractProcess,
    39         ISkeletonContract,
    40         ISkeletonContractEdit,
     38        IPCNContractProcess,
     39        IPCNContract,
     40        IPCNContractEdit,
    4141        ICustomerNavigation)
    4242
    4343    contract_category = 'sample'
    4444
    45     form_fields_interface = ISkeletonContract
     45    form_fields_interface = IPCNContract
    4646
    47     edit_form_fields_interface = ISkeletonContractEdit
     47    edit_form_fields_interface = IPCNContractEdit
    4848
    49     check_docs_interface = ISkeletonContract
     49    check_docs_interface = IPCNContract
    5050
    51 SkeletonContract = attrs_to_fields(SkeletonContract)
     51PCNContract = attrs_to_fields(PCNContract)
    5252
    5353
    5454# Contracts must be importable. So we might need a factory.
    55 class SkeletonContractFactory(grok.GlobalUtility):
     55class PCNContractFactory(grok.GlobalUtility):
    5656    """A factory for contracts.
    5757    """
    5858    grok.implements(IFactory)
    59     grok.name(u'waeup.SkeletonContract')
     59    grok.name(u'waeup.PCNContract')
    6060    title = u"Create a new contract.",
    6161    description = u"This factory instantiates new sample contract instances."
    6262
    6363    def __call__(self, *args, **kw):
    64         return SkeletonContract(*args, **kw)
     64        return PCNContract(*args, **kw)
    6565
    6666    def getInterfaces(self):
    67         return implementedBy(SkeletonContract)
     67        return implementedBy(PCNContract)

  • main/ikobacustom.pcn/trunk/src/ikobacustom/pcn/customers/customer.py

    r12272 r12371  
    2525from waeup.ikoba.customers.customer import Customer
    2626from waeup.ikoba.customers.interfaces import ICustomerNavigation
    27 from ikobacustom.skeleton.customers.interfaces import ISkeletonCustomer
    28 from ikobacustom.skeleton.interfaces import MessageFactory as _
     27from ikobacustom.pcn.customers.interfaces import IPCNCustomer
     28from ikobacustom.pcn.interfaces import MessageFactory as _
    2929
    3030
    31 class SkeletonCustomer(Customer):
     31class PCNCustomer(Customer):
    3232    """This is a customer container for the various objects
    3333    owned by customers.
    3434    """
    35     grok.implements(ISkeletonCustomer, ICustomerNavigation)
    36     grok.provides(ISkeletonCustomer)
     35    grok.implements(IPCNCustomer, ICustomerNavigation)
     36    grok.provides(IPCNCustomer)
    3737
    38 SkeletonCustomer = attrs_to_fields(SkeletonCustomer)
     38PCNCustomer = attrs_to_fields(PCNCustomer)
    3939
    4040
    41 class SkeletonCustomerFactory(grok.GlobalUtility):
     41class PCNCustomerFactory(grok.GlobalUtility):
    4242    """A factory for customers.
    4343    """
    4444    grok.implements(IFactory)
    4545    grok.name(u'waeup.Customer')
    46     title = u"Create a new skeleton customer.",
    47     description = u"This factory instantiates new skeleton customer instances."
     46    title = u"Create a new pcn customer.",
     47    description = u"This factory instantiates new pcn customer instances."
    4848
    4949    def __call__(self, *args, **kw):
    50         return SkeletonCustomer()
     50        return PCNCustomer()
    5151
    5252    def getInterfaces(self):
    53         return implementedBy(SkeletonCustomer)
     53        return implementedBy(PCNCustomer)

  • main/ikobacustom.pcn/trunk/src/ikobacustom/pcn/customers/documents.py

    r12355 r12371  
    2525from waeup.ikoba.customers.interfaces import ICustomerNavigation
    2626from waeup.ikoba.customers.documents import CustomerDocumentBase
    27 from ikobacustom.skeleton.interfaces import MessageFactory as _
    28 from ikobacustom.skeleton.customers.interfaces import ISkeletonCustomerDocument
     27from ikobacustom.pcn.interfaces import MessageFactory as _
     28from ikobacustom.pcn.customers.interfaces import IPCNCustomerDocument
    2929
    3030
    31 class SkeletonCustomerDocument(CustomerDocumentBase):
     31class PCNCustomerDocument(CustomerDocumentBase):
    3232    """This is a sample customer document.
    3333    """
    3434
    35     grok.implements(ISkeletonCustomerDocument, ICustomerNavigation)
    36     grok.provides(ISkeletonCustomerDocument)
     35    grok.implements(IPCNCustomerDocument, ICustomerNavigation)
     36    grok.provides(IPCNCustomerDocument)
    3737
    3838    # Ikoba can store any number of files per Document object.
    … …  
    4242    filenames = ('sample',)
    4343
    44     form_fields_interface = ISkeletonCustomerDocument
     44    form_fields_interface = IPCNCustomerDocument
    4545
    46 SkeletonCustomerDocument = attrs_to_fields(SkeletonCustomerDocument)
     46PCNCustomerDocument = attrs_to_fields(PCNCustomerDocument)
    4747
    4848
    4949# Customer documents must be importable. So we need a factory.
    50 class SkeletonCustomerDocumentFactory(grok.GlobalUtility):
     50class PCNCustomerDocumentFactory(grok.GlobalUtility):
    5151    """A factory for customer documents.
    5252    """
    5353    grok.implements(IFactory)
    54     grok.name(u'waeup.SkeletonCustomerDocument')
     54    grok.name(u'waeup.PCNCustomerDocument')
    5555    title = u"Create a new document.",
    5656    description = u"This factory instantiates new sample document instances."
    5757
    5858    def __call__(self, *args, **kw):
    59         return SkeletonCustomerDocument(*args, **kw)
     59        return PCNCustomerDocument(*args, **kw)
    6060
    6161    def getInterfaces(self):
    62         return implementedBy(SkeletonCustomerDocument)
     62        return implementedBy(PCNCustomerDocument)

  • main/ikobacustom.pcn/trunk/src/ikobacustom/pcn/customers/export.py

    r12298 r12371  
    1616## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
    1717##
    18 """Exporters for skeleton customer objects and subobjects.
     18"""Exporters for pcn customer objects and subobjects.
    1919"""
    2020import grok
    2121from waeup.ikoba.customers.export import (
    2222    CustomerExporter, CustomerDocumentExporterBase, ContractExporterBase)
    23 from ikobacustom.skeleton.customers.interfaces import (
    24     ISkeletonCustomer, ISkeletonCustomerDocument, ISkeletonContract)
    25 from ikobacustom.skeleton.interfaces import MessageFactory as _
     23from ikobacustom.pcn.customers.interfaces import (
     24    IPCNCustomer, IPCNCustomerDocument, IPCNContract)
     25from ikobacustom.pcn.interfaces import MessageFactory as _
    2626
    27 class SkeletonCustomerExporter(CustomerExporter):
     27class PCNCustomerExporter(CustomerExporter):
    2828    """Exporter for Customers.
    2929    """
    30     iface = ISkeletonCustomer
    31     title = _(u'Skeleton Customers')
     30    iface = IPCNCustomer
     31    title = _(u'PCN Customers')
    3232
    3333
    34 class SkeletonCustomerDocumentExporter(CustomerDocumentExporterBase):
     34class PCNCustomerDocumentExporter(CustomerDocumentExporterBase):
    3535    """Exporter for documents.
    3636    """
    37     grok.name('skeletoncustomerdocuments')
    38     iface = ISkeletonCustomerDocument
    39     title = _(u'Skeleton Customer Documents')
    40     class_name = 'SkeletonCustomerDocument'
     37    grok.name('pcncustomerdocuments')
     38    iface = IPCNCustomerDocument
     39    title = _(u'PCN Customer Documents')
     40    class_name = 'PCNCustomerDocument'
    4141
    4242
    43 class SkeletonContractExporter(ContractExporterBase):
     43class PCNContractExporter(ContractExporterBase):
    4444    """Exporter for Contract instances.
    4545    """
    46     grok.name('skeletoncontracts')
    47     iface = ISkeletonContract
    48     title = _(u'Skeleton Customer Contracts')
    49     class_name = 'SkeletonContract'
     46    grok.name('pcncontracts')
     47    iface = IPCNContract
     48    title = _(u'PCN Customer Contracts')
     49    class_name = 'PCNContract'

  • main/ikobacustom.pcn/trunk/src/ikobacustom/pcn/customers/fileviewlets.py

    r12355 r12371  
    2323    FileDisplay, FileUpload, Image)
    2424
    25 from ikobacustom.skeleton.customers.documents import SkeletonCustomerDocument
     25from ikobacustom.pcn.customers.documents import PCNCustomerDocument
    2626
    2727from waeup.ikoba.customers.browser import (
    … …  
    3939    """
    4040    grok.order(1)
    41     grok.context(SkeletonCustomerDocument)
     41    grok.context(PCNCustomerDocument)
    4242    grok.view(DocumentManageFormPage)
    4343    grok.require('waeup.manageCustomer')
    … …  
    6060    """
    6161    grok.order(1)
    62     grok.context(SkeletonCustomerDocument)
     62    grok.context(PCNCustomerDocument)
    6363    grok.require('waeup.viewCustomer')
    6464    grok.view(DocumentDisplayFormPage)
    … …  
    7272    """
    7373    grok.name('sample')
    74     grok.context(SkeletonCustomerDocument)
     74    grok.context(PCNCustomerDocument)
    7575    grok.require('waeup.viewCustomer')
    7676    download_name = u'sample'
    … …  
    8484    """
    8585    grok.view(DocumentManageFormPage)
    86     grok.context(SkeletonCustomerDocument)
     86    grok.context(PCNCustomerDocument)
    8787    grok.require('waeup.manageCustomer')
    8888    label = _(u'PDF File')
    … …  
    104104    """
    105105    grok.order(1)
    106     grok.context(SkeletonCustomerDocument)
     106    grok.context(PCNCustomerDocument)
    107107    grok.require('waeup.viewCustomer')
    108108    grok.view(DocumentDisplayFormPage)
    … …  
    116116    """
    117117    grok.name('sample.pdf')
    118     grok.context(SkeletonCustomerDocument)
     118    grok.context(PCNCustomerDocument)
    119119    grok.require('waeup.viewCustomer')
    120120    download_name = u'sample.pdf'

  • main/ikobacustom.pcn/trunk/src/ikobacustom/pcn/customers/interfaces.py

    r12335 r12371  
    2323    ConCatProductSource, CustomerDocumentSource)
    2424from waeup.ikoba.products.productoptions import ProductOptionField
    25 from ikobacustom.skeleton.interfaces import MessageFactory as _
     25from ikobacustom.pcn.interfaces import MessageFactory as _
    2626
    2727
    28 class ISkeletonCustomer(ICustomer):
     28class IPCNCustomer(ICustomer):
    2929    """Representation of a customer.
    3030
    … …  
    3434
    3535
    36 class ISkeletonCustomerDocument(ICustomerDocument):
     36class IPCNCustomerDocument(ICustomerDocument):
    3737    """A customer document.
    3838
    … …  
    4141# Customer contract interfaces
    4242
    43 class ISkeletonContract(IContract):
     43class IPCNContract(IContract):
    4444    """A customer contract sample with document attached.
    4545
    … …  
    5252        )
    5353
    54 class ISkeletonContractProcess(ISkeletonContract):
     54class IPCNContractProcess(IPCNContract):
    5555    """Interface for processing contract data.
    5656    """
    … …  
    6464        )
    6565
    66 class ISkeletonContractEdit(ISkeletonContract):
     66class IPCNContractEdit(IPCNContract):
    6767    """Interface for editing sample contract data by customers.
    6868

  • main/ikobacustom.pcn/trunk/src/ikobacustom/pcn/customers/tests/test_browser.py

    r12369 r12371  
    3030from waeup.ikoba.customers.tests.test_batching import CustomerImportExportSetup
    3131from waeup.ikoba.customers.tests.test_browser import CustomersFullSetup
    32 from ikobacustom.skeleton.customers.export import (
    33     SkeletonCustomerExporter,
    34     SkeletonCustomerDocumentExporter,
    35     SkeletonContractExporter)
    36 from ikobacustom.skeleton.customers.batching import (
    37     SkeletonCustomerProcessor,
    38     SkeletonCustomerDocumentProcessor,
    39     SkeletonContractProcessor)
    40 from ikobacustom.skeleton.testing import FunctionalLayer, samples_dir
     32from ikobacustom.pcn.customers.export import (
     33    PCNCustomerExporter,
     34    PCNCustomerDocumentExporter,
     35    PCNContractExporter)
     36from ikobacustom.pcn.customers.batching import (
     37    PCNCustomerProcessor,
     38    PCNCustomerDocumentProcessor,
     39    PCNContractProcessor)
     40from ikobacustom.pcn.testing import FunctionalLayer, samples_dir
    4141
    4242SAMPLE_IMAGE = os.path.join(os.path.dirname(__file__), 'test_image.jpg')
    … …  
    5656        IWorkflowState(customer).setState('started')
    5757        self.app['customers'].addCustomer(customer)
    58         document = createObject(u'waeup.SkeletonCustomerDocument')
     58        document = createObject(u'waeup.PCNCustomerDocument')
    5959        document.title = u'My first document'
    6060        customer['documents'].addDocument(document)
    61         contract = createObject(u'waeup.SkeletonContract')
     61        contract = createObject(u'waeup.PCNContract')
    6262        contract.tc_dict = {'en':u'Hello World'}
    6363        customer['contracts'].addContract(contract)
    … …  
    7272        # set values we can expect in export file
    7373        self.setup_for_export()
    74         exporter = SkeletonCustomerExporter()
     74        exporter = PCNCustomerExporter()
    7575        exporter.export_all(self.app, self.outfile)
    7676        result = open(self.outfile, 'rb').read()
    … …  
    8080            'K1000000,,Beate,Mueller,,,123,f,0,,,started,[]\r\n')
    8181        # We can reimport the file ...
    82         processor = SkeletonCustomerProcessor()
     82        processor = PCNCustomerProcessor()
    8383        result = processor.doImport(
    8484            self.outfile,
    … …  
    112112        # set values we can expect in export file
    113113        self.setup_for_export()
    114         exporter = SkeletonCustomerDocumentExporter()
     114        exporter = PCNCustomerDocumentExporter()
    115115        exporter.export_all(self.app, self.outfile)
    116116        result = open(self.outfile, 'rb').read()
    117117        self.assertMatches(result,
    118118            'class_name,document_id,history,state,title,user_id\r\n'
    119             'SkeletonCustomerDocument,%s,'
     119            'PCNCustomerDocument,%s,'
    120120            '[u\'2014-12-21 17:00:36 WAT - Document created by system\'],'
    121121            'created,My first document,K1000000\r\n'
    122122            % self.document.document_id)
    123123        # We can reimport the file if we change the header (user_id -> customer_id)
    124         processor = SkeletonCustomerDocumentProcessor()
     124        processor = PCNCustomerDocumentProcessor()
    125125        open(self.outfile, 'wb').write(
    126126            'customer_id,class_name,document_id,state,title\r\n'
    127             'K1000000,SkeletonCustomerDocument,%s,started,My first title\r\n'
     127            'K1000000,PCNCustomerDocument,%s,started,My first title\r\n'
    128128            % self.document.document_id)
    129129        result = processor.doImport(
    … …  
    156156        # set values we can expect in export file
    157157        self.setup_for_export()
    158         exporter = SkeletonContractExporter()
     158        exporter = PCNContractExporter()
    159159        exporter.export_all(self.app, self.outfile)
    160160        result = open(self.outfile, 'rb').read()
    … …  
    163163            'history,last_product_id,product_object,product_options,'
    164164            'state,tc_dict,title,user_id\r\n'
    165             'SkeletonContract,sample,%s,,'
     165            'PCNContract,sample,%s,,'
    166166            '[u\'2014-12-21 22:26:00 WAT - Contract created by system\']'
    167167            ',,,[],created,{\'en\': u\'Hello World\'},,K1000000\r\n'
    168168            % self.contract.contract_id)
    169169        # We can reimport the file if we change the header (user_id -> customer_id)
    170         processor = SkeletonContractProcessor()
     170        processor = PCNContractProcessor()
    171171        open(self.outfile, 'wb').write(
    172172            'class_name,contract_category,contract_id,document_object,'
    173173            'history,last_product_id,product_object,product_options,'
    174174            'state,tc_dict,title,user_id\r\n'
    175             'SkeletonContract,sample,%s,,'
     175            'PCNContract,sample,%s,,'
    176176            '[u\'2014-12-21 22:26:00 WAT - Contract created by system\']'
    177177            ',,,[],created,{\'en\': u\'Hello World\'},,K1000000\r\n'
    … …  
    219219        self.browser.open(self.customer_path + '/documents')
    220220        self.browser.getControl("Add document").click()
    221         self.browser.getControl(name="doctype").value = ['SkeletonCustomerDocument']
    222         self.browser.getControl(name="form.title").value = 'My Skeleton Document'
     221        self.browser.getControl(name="doctype").value = ['PCNCustomerDocument']
     222        self.browser.getControl(name="form.title").value = 'My PCN Document'
    223223        self.browser.getControl("Add document").click()
    224224        docid = [i for i in self.customer['documents'].keys() if len(i) > 10][0]

  • main/ikobacustom.pcn/trunk/src/ikobacustom/pcn/customers/tests/test_contract.py

    r12292 r12371  
    2828from waeup.ikoba.customers.contracts import ContractsContainer
    2929
    30 from ikobacustom.skeleton.testing import (FunctionalLayer, FunctionalTestCase)
    31 from ikobacustom.skeleton.customers.contracts import SkeletonContract
    32 from ikobacustom.skeleton.customers.interfaces import ISkeletonContract
     30from ikobacustom.pcn.testing import (FunctionalLayer, FunctionalTestCase)
     31from ikobacustom.pcn.customers.contracts import PCNContract
     32from ikobacustom.pcn.customers.interfaces import IPCNContract
    3333
    3434
    … …  
    3838
    3939    def test_interfaces(self):
    40         verify.verifyClass(ISkeletonContract, SkeletonContract)
    41         verify.verifyClass(ICustomerNavigation, SkeletonContract)
    42         verify.verifyObject(ISkeletonContract, SkeletonContract())
    43         verify.verifyObject(ICustomerNavigation, SkeletonContract())
     40        verify.verifyClass(IPCNContract, PCNContract)
     41        verify.verifyClass(ICustomerNavigation, PCNContract)
     42        verify.verifyObject(IPCNContract, PCNContract())
     43        verify.verifyObject(ICustomerNavigation, PCNContract())
    4444        return
    4545
    4646    def test_addContract(self):
    4747        container = ContractsContainer()
    48         contract = createObject(u'waeup.SkeletonContract')
     48        contract = createObject(u'waeup.PCNContract')
    4949        id = contract.contract_id
    5050        container.addContract(contract)
    5151        self.assertEqual(container[id], contract)
    5252        self.assertRaises(TypeError, container.addContract, object())
    53         self.assertEqual(contract.class_name, 'SkeletonContract')
     53        self.assertEqual(contract.class_name, 'PCNContract')
    5454        return

  • main/ikobacustom.pcn/trunk/src/ikobacustom/pcn/customers/tests/test_customer.py

    r12273 r12371  
    1717##
    1818"""
    19 Tests for skeleton customers.
     19Tests for pcn customers.
    2020"""
    2121import tempfile
    … …  
    3030from waeup.ikoba.customers.container import CustomersContainer
    3131
    32 from ikobacustom.skeleton.testing import (FunctionalLayer, FunctionalTestCase)
    33 from ikobacustom.skeleton.customers.customer import SkeletonCustomer
    34 from ikobacustom.skeleton.customers.interfaces import ISkeletonCustomer
     32from ikobacustom.pcn.testing import (FunctionalLayer, FunctionalTestCase)
     33from ikobacustom.pcn.customers.customer import PCNCustomer
     34from ikobacustom.pcn.customers.interfaces import IPCNCustomer
    3535
    36 class SkeletonCustomerTestCase(FunctionalTestCase):
     36class PCNCustomerTestCase(FunctionalTestCase):
    3737
    3838    layer = FunctionalLayer
    3939
    4040    def setUp(self):
    41         super(SkeletonCustomerTestCase, self).setUp()
     41        super(PCNCustomerTestCase, self).setUp()
    4242
    4343        # Prepopulate ZODB
    … …  
    5252
    5353    def test_interfaces(self):
    54         verify.verifyClass(ISkeletonCustomer, SkeletonCustomer)
    55         verify.verifyClass(ICustomerNavigation, SkeletonCustomer)
    56         verify.verifyObject(ISkeletonCustomer, SkeletonCustomer())
    57         verify.verifyObject(ICustomerNavigation, SkeletonCustomer())
     54        verify.verifyClass(IPCNCustomer, PCNCustomer)
     55        verify.verifyClass(ICustomerNavigation, PCNCustomer)
     56        verify.verifyObject(IPCNCustomer, PCNCustomer())
     57        verify.verifyObject(ICustomerNavigation, PCNCustomer())
    5858        return
    5959
    60     def test_addSkeletonCustomer(self):
     60    def test_addPCNCustomer(self):
    6161        customer = createObject(u'waeup.Customer')
    62         verify.verifyObject(ISkeletonCustomer, customer)
     62        verify.verifyObject(IPCNCustomer, customer)
    6363        self.app['customers'].addCustomer(customer)
    6464        self.assertEqual(customer.customer_id, 'K1000000')
    … …  
    6868    def tearDown(self):
    6969        shutil.rmtree(self.dc_root)
    70         super(SkeletonCustomerTestCase, self).tearDown()
     70        super(PCNCustomerTestCase, self).tearDown()
    7171        return

  • main/ikobacustom.pcn/trunk/src/ikobacustom/pcn/customers/tests/test_document.py

    r12292 r12371  
    2828from waeup.ikoba.customers.documents import CustomerDocumentsContainer
    2929
    30 from ikobacustom.skeleton.testing import (FunctionalLayer, FunctionalTestCase)
    31 from ikobacustom.skeleton.customers.documents import SkeletonCustomerDocument
    32 from ikobacustom.skeleton.customers.interfaces import ISkeletonCustomerDocument
     30from ikobacustom.pcn.testing import (FunctionalLayer, FunctionalTestCase)
     31from ikobacustom.pcn.customers.documents import PCNCustomerDocument
     32from ikobacustom.pcn.customers.interfaces import IPCNCustomerDocument
    3333
    3434
    … …  
    3838
    3939    def test_interfaces(self):
    40         verify.verifyClass(ISkeletonCustomerDocument, SkeletonCustomerDocument)
    41         verify.verifyClass(ICustomerNavigation, SkeletonCustomerDocument)
    42         verify.verifyObject(ISkeletonCustomerDocument, SkeletonCustomerDocument())
    43         verify.verifyObject(ICustomerNavigation, SkeletonCustomerDocument())
     40        verify.verifyClass(IPCNCustomerDocument, PCNCustomerDocument)
     41        verify.verifyClass(ICustomerNavigation, PCNCustomerDocument)
     42        verify.verifyObject(IPCNCustomerDocument, PCNCustomerDocument())
     43        verify.verifyObject(ICustomerNavigation, PCNCustomerDocument())
    4444        return
    4545
    4646    def test_addDocument(self):
    4747        container = CustomerDocumentsContainer()
    48         document = createObject(u'waeup.SkeletonCustomerDocument')
     48        document = createObject(u'waeup.PCNCustomerDocument')
    4949        id = document.document_id
    5050        container.addDocument(document)
    5151        self.assertEqual(container[id], document)
    5252        self.assertRaises(TypeError, container.addDocument, object())
    53         self.assertEqual(document.class_name, 'SkeletonCustomerDocument')
     53        self.assertEqual(document.class_name, 'PCNCustomerDocument')
    5454        return

  • main/ikobacustom.pcn/trunk/src/ikobacustom/pcn/customers/utils.py

    r12357 r12371  
    2525    SUBMITTED, VERIFIED, REJECTED,
    2626    EXPIRED)
    27 from ikobacustom.skeleton.interfaces import MessageFactory as _
     27from ikobacustom.pcn.interfaces import MessageFactory as _
    2828
    29 class SkeletonCustomersUtils(CustomersUtils):
     29class PCNCustomersUtils(CustomersUtils):
    3030    """A collection of methods subject to customization.
    3131    """
    … …  
    4747        #'CustomerPDFDocument': _('PDF Document'),
    4848
    49         'SkeletonCustomerDocument': _('Skeleton Document'),
     49        'PCNCustomerDocument': _('PCN Document'),
    5050        }
    5151
    … …  
    5353        #'SampleContract': _('Sample Contract'),
    5454
    55         'SkeletonContract': _('Skeleton Contract'),
     55        'PCNContract': _('PCN Contract'),
    5656        }
    5757
    … …  
    6262    EXPORTER_NAMES = (
    6363        'customers',
    64         'skeletoncustomerdocuments',
    65         'skeletoncontracts')
     64        'pcncustomerdocuments',
     65        'pcncontracts')

  • main/ikobacustom.pcn/trunk/src/ikobacustom/pcn/documents/__init__.py

    r12269 r12371  
    22"""
    33# Make this a package.
    4 from ikobacustom.skeleton.documents.document import SkeletonDocument
     4from ikobacustom.pcn.documents.document import PCNDocument
    55
    66__all__ = [
    7     'SkeletonDocument',
     7    'PCNDocument',
    88    ]

  • main/ikobacustom.pcn/trunk/src/ikobacustom/pcn/documents/batching.py

    r12274 r12371  
    1616## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
    1717##
    18 """Batch processing for skeleton documents.
     18"""Batch processing for pcn documents.
    1919"""
    2020import grok
    2121from waeup.ikoba.documents.batching import DocumentProcessorBase
    22 from ikobacustom.skeleton.documents.interfaces import ISkeletonDocument
    23 from ikobacustom.skeleton.interfaces import MessageFactory as _
     22from ikobacustom.pcn.documents.interfaces import IPCNDocument
     23from ikobacustom.pcn.interfaces import MessageFactory as _
    2424
    2525
    26 class SkeletonDocumentProcessor(DocumentProcessorBase):
    27     """A batch processor for ISkeletonDocument objects.
     26class PCNDocumentProcessor(DocumentProcessorBase):
     27    """A batch processor for IPCNDocument objects.
    2828    """
    29     util_name = 'skeletondocumentprocessor'
     29    util_name = 'pcndocumentprocessor'
    3030    grok.name(util_name)
    3131
    32     name = _('Skeleton Document Processor')
    33     iface = ISkeletonDocument
     32    name = _('PCN Document Processor')
     33    iface = IPCNDocument
    3434
    35     factory_name = 'waeup.SkeletonDocument'
     35    factory_name = 'waeup.PCNDocument'

  • main/ikobacustom.pcn/trunk/src/ikobacustom/pcn/documents/document.py

    r12270 r12371  
    2424from waeup.ikoba.utils.helpers import attrs_to_fields
    2525from waeup.ikoba.documents.document import PublicDocumentBase
    26 from ikobacustom.skeleton.documents.interfaces import ISkeletonDocument
    27 from ikobacustom.skeleton.interfaces import MessageFactory as _
     26from ikobacustom.pcn.documents.interfaces import IPCNDocument
     27from ikobacustom.pcn.interfaces import MessageFactory as _
    2828
    2929
    30 class SkeletonDocument(PublicDocumentBase):
     30class PCNDocument(PublicDocumentBase):
    3131    """This is a document.
    3232    """
    33     grok.implements(ISkeletonDocument)
    34     grok.provides(ISkeletonDocument)
     33    grok.implements(IPCNDocument)
     34    grok.provides(IPCNDocument)
    3535
    36 SkeletonDocument = attrs_to_fields(SkeletonDocument)
     36PCNDocument = attrs_to_fields(PCNDocument)
    3737
    3838
    39 class SkeletonDocumentFactory(grok.GlobalUtility):
     39class PCNDocumentFactory(grok.GlobalUtility):
    4040    """A factory for documents.
    4141    """
    4242    grok.implements(IFactory)
    43     grok.name(u'waeup.SkeletonDocument')
     43    grok.name(u'waeup.PCNDocument')
    4444    title = u"Create a new document.",
    45     description = u"This factory instantiates new skeleton documents."
     45    description = u"This factory instantiates new pcn documents."
    4646
    4747    def __call__(self, *args, **kw):
    48         return SkeletonDocument(*args, **kw)
     48        return PCNDocument(*args, **kw)
    4949
    5050    def getInterfaces(self):
    51         return implementedBy(SkeletonDocument)
     51        return implementedBy(PCNDocument)

  • main/ikobacustom.pcn/trunk/src/ikobacustom/pcn/documents/export.py

    r12292 r12371  
    1616## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
    1717##
    18 """Exporters for skeleton documents.
     18"""Exporters for pcn documents.
    1919"""
    2020import grok
    2121from waeup.ikoba.documents.export import DocumentExporterBase
    22 from ikobacustom.skeleton.documents.interfaces import ISkeletonDocument
    23 from ikobacustom.skeleton.interfaces import MessageFactory as _
     22from ikobacustom.pcn.documents.interfaces import IPCNDocument
     23from ikobacustom.pcn.interfaces import MessageFactory as _
    2424
    2525
    26 class SkeletonDocumentExporter(DocumentExporterBase):
     26class PCNDocumentExporter(DocumentExporterBase):
    2727    """Exporter for documents.
    2828    """
    29     grok.name('skeletondocuments')
    30     iface = ISkeletonDocument
    31     class_name = 'SkeletonDocument'
    32     title = _(u'Skeleton Documents')
     29    grok.name('pcndocuments')
     30    iface = IPCNDocument
     31    class_name = 'PCNDocument'
     32    title = _(u'PCN Documents')

  • main/ikobacustom.pcn/trunk/src/ikobacustom/pcn/documents/interfaces.py

    r12292 r12371  
    1717##
    1818from waeup.ikoba.documents.interfaces import IPublicDocument
    19 from ikobacustom.skeleton.interfaces import MessageFactory as _
     19from ikobacustom.pcn.interfaces import MessageFactory as _
    2020
    2121
    22 class ISkeletonDocument(IPublicDocument):
    23     """A representation of a skeleton document.
     22class IPCNDocument(IPublicDocument):
     23    """A representation of a pcn document.
    2424
    2525    """

  • main/ikobacustom.pcn/trunk/src/ikobacustom/pcn/documents/tests/test_browser.py

    r12290 r12371  
    2727from zope.interface.verify import verifyObject, verifyClass
    2828from waeup.ikoba.documents.tests.test_batching import DocumentImportExportSetup
    29 from ikobacustom.skeleton.documents.document import SkeletonDocument
    30 from ikobacustom.skeleton.documents.export import SkeletonDocumentExporter
    31 from ikobacustom.skeleton.documents.batching import SkeletonDocumentProcessor
    32 from ikobacustom.skeleton.testing import FunctionalLayer
     29from ikobacustom.pcn.documents.document import PCNDocument
     30from ikobacustom.pcn.documents.export import PCNDocumentExporter
     31from ikobacustom.pcn.documents.batching import PCNDocumentProcessor
     32from ikobacustom.pcn.testing import FunctionalLayer
    3333
    3434
    … …  
    3838
    3939    def setup_for_export(self):
    40         document = SkeletonDocument()
     40        document = PCNDocument()
    4141        document.document_id = u'DOC1'
    4242        document.title = u'My first document'
    … …  
    4949        # set values we can expect in export file
    5050        self.setup_for_export()
    51         exporter = SkeletonDocumentExporter()
     51        exporter = PCNDocumentExporter()
    5252        exporter.export_all(self.app, self.outfile)
    5353        result = open(self.outfile, 'rb').read()
    … …  
    5555            'class_name,description,document_id,history,state,title,'
    5656            'users_with_local_roles\r\n'
    57             'SkeletonDocument,,DOC1,'
     57            'PCNDocument,,DOC1,'
    5858            '[u\'2014-12-21 23:27:15 WAT - Document created by system\'],'
    5959            'created,My first document,[]\r\n')
    6060        # We can import the same file.
    61         processor = SkeletonDocumentProcessor()
     61        processor = PCNDocumentProcessor()
    6262        result = processor.doImport(
    6363            self.outfile,
    … …  
    7979        self.assertEqual(num_fail,0)
    8080        # We can import the same file in update mode.
    81         processor = SkeletonDocumentProcessor()
     81        processor = PCNDocumentProcessor()
    8282        result = processor.doImport(
    8383            self.outfile,

  • main/ikobacustom.pcn/trunk/src/ikobacustom/pcn/documents/tests/test_document.py

    r12292 r12371  
    1717##
    1818"""
    19 Tests for skeleton documents.
     19Tests for pcn documents.
    2020"""
    2121from zope.interface.verify import verifyClass, verifyObject
    … …  
    2323from waeup.ikoba.documents.container import DocumentsContainer
    2424
    25 from ikobacustom.skeleton.testing import (FunctionalLayer, FunctionalTestCase)
    26 from ikobacustom.skeleton.documents.document import SkeletonDocument
    27 from ikobacustom.skeleton.documents.interfaces import ISkeletonDocument
     25from ikobacustom.pcn.testing import (FunctionalLayer, FunctionalTestCase)
     26from ikobacustom.pcn.documents.document import PCNDocument
     27from ikobacustom.pcn.documents.interfaces import IPCNDocument
    2828
    29 class SkeletonDocumentTestCase(FunctionalTestCase):
     29class PCNDocumentTestCase(FunctionalTestCase):
    3030
    3131    layer = FunctionalLayer
    … …  
    3535        self.assertTrue(
    3636            verifyClass(
    37                 ISkeletonDocument, SkeletonDocument)
     37                IPCNDocument, PCNDocument)
    3838            )
    3939        self.assertTrue(
    4040            verifyObject(
    41                 ISkeletonDocument, SkeletonDocument())
     41                IPCNDocument, PCNDocument())
    4242            )
    4343        return
    4444
    45     def test_addSkeletonDocument(self):
     45    def test_addPCNDocument(self):
    4646        container = DocumentsContainer()
    47         document = createObject(u'waeup.SkeletonDocument')
     47        document = createObject(u'waeup.PCNDocument')
    4848        document.document_id = u'DOC1'
    4949        container.addDocument(document)

  • main/ikobacustom.pcn/trunk/src/ikobacustom/pcn/documents/utils.py

    r12292 r12371  
    1919"""
    2020from waeup.ikoba.documents.utils import DocumentsUtils
    21 from ikobacustom.skeleton.interfaces import MessageFactory as _
     21from ikobacustom.pcn.interfaces import MessageFactory as _
    2222
    2323
    24 class SkeletonDocumentsUtils(DocumentsUtils):
     24class PCNDocumentsUtils(DocumentsUtils):
    2525    """A collection of methods subject to customization.
    2626    """
    … …  
    2929        'PDFDocument': _('PDF Document'),
    3030        'HTMLDocument': _('HTML Document'),
    31         'SkeletonDocument': _('Skeleton Document'),
     31        'PCNDocument': _('PCN Document'),
    3232        }
    3333

  • main/ikobacustom.pcn/trunk/src/ikobacustom/pcn/ftesting.zcml

    r12175 r12371  
    22   xmlns="http://namespaces.zope.org/zope"
    33   xmlns:ikoba="http://namespaces.waeup.org/ikoba"
    4    i18n_domain="ikobacustom.skeleton"
    5    package="ikobacustom.skeleton"
     4   i18n_domain="ikobacustom.pcn"
     5   package="ikobacustom.pcn"
    66   >
    77
    88  <include package="grok" />
    9   <includeOverrides package="ikobacustom.skeleton" />
    10   <include package="ikobacustom.skeleton" file="mail.zcml" />
     9  <includeOverrides package="ikobacustom.pcn" />
     10  <include package="ikobacustom.pcn" file="mail.zcml" />
    1111
    1212  <!-- Where should the datacenter reside by default?

  • main/ikobacustom.pcn/trunk/src/ikobacustom/pcn/interfaces.py

    r12176 r12371  
    2020from zope import schema
    2121from zc.sourcefactory.basic import BasicSourceFactory
    22 from ikobacustom.skeleton.utils.lgas import LGAS
     22from ikobacustom.pcn.utils.lgas import LGAS
    2323
    24 _ = MessageFactory = zope.i18nmessageid.MessageFactory('ikobacustom.skeleton')
     24_ = MessageFactory = zope.i18nmessageid.MessageFactory('ikobacustom.pcn')
    2525
    2626

  • main/ikobacustom.pcn/trunk/src/ikobacustom/pcn/products/__init__.py

    r12177 r12371  
    22"""
    33# Make this a package.
    4 from ikobacustom.skeleton.products.product import SkeletonProduct
     4from ikobacustom.pcn.products.product import PCNProduct
    55
    66__all__ = [
    7     'SkeletonProduct',
     7    'PCNProduct',
    88    ]

  • main/ikobacustom.pcn/trunk/src/ikobacustom/pcn/products/batching.py

    r12284 r12371  
    1616## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
    1717##
    18 """Batch processing for skeleton products.
     18"""Batch processing for pcn products.
    1919"""
    2020import grok
    2121from waeup.ikoba.products.batching import ProductProcessor
    22 from ikobacustom.skeleton.products.interfaces import ISkeletonProduct
    23 from ikobacustom.skeleton.interfaces import MessageFactory as _
     22from ikobacustom.pcn.products.interfaces import IPCNProduct
     23from ikobacustom.pcn.interfaces import MessageFactory as _
    2424
    25 class SkeletonProductProcessor(ProductProcessor):
     25class PCNProductProcessor(ProductProcessor):
    2626
    27     iface = ISkeletonProduct
    28     name = _('Skeleton Product Processor')
    29     util_name = 'skeletonproductprocessor'
     27    iface = IPCNProduct
     28    name = _('PCN Product Processor')
     29    util_name = 'pcnproductprocessor'
    3030    grok.name(util_name)

  • main/ikobacustom.pcn/trunk/src/ikobacustom/pcn/products/export.py

    r12270 r12371  
    1616## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
    1717##
    18 """Exporters for skeleton products.
     18"""Exporters for pcn products.
    1919"""
    2020import grok
    2121from waeup.ikoba.utils.helpers import iface_names
    2222from waeup.ikoba.products.export import ProductExporter
    23 from ikobacustom.skeleton.products.interfaces import ISkeletonProduct
    24 from ikobacustom.skeleton.interfaces import MessageFactory as _
     23from ikobacustom.pcn.products.interfaces import IPCNProduct
     24from ikobacustom.pcn.interfaces import MessageFactory as _
    2525
    2626
    27 class SkeletonProductExporter(ProductExporter):
     27class PCNProductExporter(ProductExporter):
    2828    """Exporter for products.
    2929    """
    3030
    31     fields = tuple(sorted(iface_names(ISkeletonProduct))) + (
     31    fields = tuple(sorted(iface_names(IPCNProduct))) + (
    3232        'users_with_local_roles',)
    3333
    3434    #: The title under which this exporter will be displayed
    35     #title = _(u'Skeleton Products')
     35    #title = _(u'PCN Products')

  • main/ikobacustom.pcn/trunk/src/ikobacustom/pcn/products/interfaces.py

    r12292 r12371  
    1717##
    1818from waeup.ikoba.products.interfaces import IProduct
    19 from ikobacustom.skeleton.interfaces import MessageFactory as _
     19from ikobacustom.pcn.interfaces import MessageFactory as _
    2020
    2121
    22 class ISkeletonProduct(IProduct):
    23     """A representation of a skeleton product.
     22class IPCNProduct(IProduct):
     23    """A representation of a pcn product.
    2424
    2525    """

  • main/ikobacustom.pcn/trunk/src/ikobacustom/pcn/products/product.py

    r12270 r12371  
    2424from waeup.ikoba.utils.helpers import attrs_to_fields
    2525from waeup.ikoba.products.product import Product
    26 from ikobacustom.skeleton.products.interfaces import ISkeletonProduct
    27 from ikobacustom.skeleton.interfaces import MessageFactory as _
     26from ikobacustom.pcn.products.interfaces import IPCNProduct
     27from ikobacustom.pcn.interfaces import MessageFactory as _
    2828
    2929
    30 class SkeletonProduct(Product):
     30class PCNProduct(Product):
    3131    """This is a product.
    3232    """
    33     grok.implements(ISkeletonProduct)
    34     grok.provides(ISkeletonProduct)
     33    grok.implements(IPCNProduct)
     34    grok.provides(IPCNProduct)
    3535
    36 SkeletonProduct = attrs_to_fields(SkeletonProduct)
     36PCNProduct = attrs_to_fields(PCNProduct)
    3737
    3838
    39 class SkeletonProductFactory(grok.GlobalUtility):
     39class PCNProductFactory(grok.GlobalUtility):
    4040    """A factory for products.
    4141    """
    … …  
    4343    grok.name(u'waeup.Product')
    4444    title = u"Create a new product.",
    45     description = u"This factory instantiates new skeleton products."
     45    description = u"This factory instantiates new pcn products."
    4646
    4747    def __call__(self, *args, **kw):
    48         return SkeletonProduct(*args, **kw)
     48        return PCNProduct(*args, **kw)
    4949
    5050    def getInterfaces(self):
    51         return implementedBy(SkeletonProduct)
     51        return implementedBy(PCNProduct)

  • main/ikobacustom.pcn/trunk/src/ikobacustom/pcn/products/tests/test_browser.py

    r12367 r12371  
    2727from zope.interface.verify import verifyObject, verifyClass
    2828from waeup.ikoba.products.tests.test_batching import ProductImportExportSetup
    29 from ikobacustom.skeleton.products.product import SkeletonProduct
    30 from ikobacustom.skeleton.products.export import SkeletonProductExporter
    31 from ikobacustom.skeleton.products.batching import SkeletonProductProcessor
    32 from ikobacustom.skeleton.testing import FunctionalLayer
     29from ikobacustom.pcn.products.product import PCNProduct
     30from ikobacustom.pcn.products.export import PCNProductExporter
     31from ikobacustom.pcn.products.batching import PCNProductProcessor
     32from ikobacustom.pcn.testing import FunctionalLayer
    3333
    3434
    … …  
    3838
    3939    def setup_for_export(self):
    40         product = SkeletonProduct()
     40        product = PCNProduct()
    4141        product.product_id = u'LIC'
    4242        product.valid_from = datetime.date(2015, 12, 4)
    … …  
    4949        # set values we can expect in export file
    5050        self.setup_for_export()
    51         exporter = SkeletonProductExporter()
     51        exporter = PCNProductExporter()
    5252        exporter.export_all(self.app, self.outfile)
    5353        result = open(self.outfile, 'rb').read()
    … …  
    5757            'license,,[],LIC,,Unnamed,2015-12-04#,,[]\r\n')
    5858        # We can import the same file.
    59         processor = SkeletonProductProcessor()
     59        processor = PCNProductProcessor()
    6060        result = processor.doImport(
    6161            self.outfile,
    … …  
    7777        self.assertEqual(num_fail,0)
    7878        # We can import the same file in update mode.
    79         processor = SkeletonProductProcessor()
     79        processor = PCNProductProcessor()
    8080        result = processor.doImport(
    8181            self.outfile,

  • main/ikobacustom.pcn/trunk/src/ikobacustom/pcn/products/tests/test_product.py

    r12177 r12371  
    1717##
    1818"""
    19 Tests for skeleton products.
     19Tests for pcn products.
    2020"""
    2121from zope.interface.verify import verifyClass, verifyObject
    … …  
    2424from waeup.ikoba.products.container import ProductsContainer
    2525
    26 from ikobacustom.skeleton.testing import (FunctionalLayer, FunctionalTestCase)
    27 from ikobacustom.skeleton.products.product import SkeletonProduct
    28 from ikobacustom.skeleton.products.interfaces import ISkeletonProduct
     26from ikobacustom.pcn.testing import (FunctionalLayer, FunctionalTestCase)
     27from ikobacustom.pcn.products.product import PCNProduct
     28from ikobacustom.pcn.products.interfaces import IPCNProduct
    2929
    30 class SkeletonProductTestCase(FunctionalTestCase):
     30class PCNProductTestCase(FunctionalTestCase):
    3131
    3232    layer = FunctionalLayer
    … …  
    3636        self.assertTrue(
    3737            verifyClass(
    38                 ISkeletonProduct, SkeletonProduct)
     38                IPCNProduct, PCNProduct)
    3939            )
    4040        self.assertTrue(
    4141            verifyObject(
    42                 ISkeletonProduct, SkeletonProduct())
     42                IPCNProduct, PCNProduct())
    4343            )
    4444        return
    4545
    46     def test_addSkeletonProduct(self):
     46    def test_addPCNProduct(self):
    4747        container = ProductsContainer()
    4848        product = createObject(u'waeup.Product')

  • main/ikobacustom.pcn/trunk/src/ikobacustom/pcn/testing.py

    r12369 r12371  
    2020import os
    2121import tempfile
    22 import ikobacustom.skeleton
     22import ikobacustom.pcn
    2323from zope.app.testing.functional import ZCMLLayer
    2424from waeup.ikoba.testing import FunctionalTestCase
    2525
    26 # Some funcional layer that groks ikobacustom.skeleton.
     26# Some funcional layer that groks ikobacustom.pcn.
    2727ftesting_zcml = os.path.join(
    28     os.path.dirname(ikobacustom.skeleton.__file__), 'ftesting.zcml')
     28    os.path.dirname(ikobacustom.pcn.__file__), 'ftesting.zcml')
    2929FunctionalLayer = ZCMLLayer(ftesting_zcml, __name__, 'FunctionalLayer',
    3030                            allow_teardown=True)
    … …  
    3434    # and return its path.
    3535    tmp_dir = os.path.join(
    36         tempfile.gettempdir(), 'ikobacustom.skeleton.pdf-samples')
     36        tempfile.gettempdir(), 'ikobacustom.pcn.pdf-samples')
    3737    if not os.path.exists(tmp_dir):
    3838        os.mkdir(tmp_dir)

  • main/ikobacustom.pcn/trunk/src/ikobacustom/pcn/utils/utils.py

    r12298 r12371  
    2020import pytz
    2121from waeup.ikoba.utils.utils import IkobaUtils, sorted_phone_prefixes
    22 from ikobacustom.skeleton.interfaces import MessageFactory as _
     22from ikobacustom.pcn.interfaces import MessageFactory as _
    2323
    2424INT_PHONE_PREFIXES = [
    … …  
    3333    ]
    3434
    35 class SkeletonIkobaUtils(IkobaUtils):
     35class PCNIkobaUtils(IkobaUtils):
    3636    """A collection of methods subject to customization.
    3737    """
    … …  
    5353        'products',
    5454        'customers',
    55         'skeletoncustomerdocuments',
    56         'skeletoncontracts')
     55        'pcncustomerdocuments',
     56        'pcncontracts')
    5757
    5858    BATCH_PROCESSOR_NAMES = (
    59         'skeletoncustomerprocessor',
    60         'skeletoncustomerdocumentprocessor',
    61         'skeletoncontractprocessor',
    62         'skeletonproductprocessor',
     59        'pcncustomerprocessor',
     60        'pcncustomerdocumentprocessor',
     61        'pcncontractprocessor',
     62        'pcnproductprocessor',
    6363        'pdfdocumentprocessor',
    6464        'htmldocumentprocessor',
Note: See TracChangeset for help on using the changeset viewer.