Changeset 541

Show
Ignore:
Timestamp:
08/14/07 16:54:40 (1 year ago)
Author:
brian
Message:

new before_insert, manage controller

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • pagoda/trunk/Pagoda/pagoda/controllers/admin.py

    r514 r541  
    77from turbojson import jsonify 
    88from pagoda.controllers.root import PagodaController 
    9 from pagoda.controllers.util import include_widgets, map_path_to_controller 
     9from pagoda.controllers.util import * 
    1010from pagoda import config, models, widgets, plugins, validators, workflow 
    1111 
    …… 
    4444    @expose() 
    4545    def index(self, *args, **kwargs): 
    46         """Special-case the `index` method to resolve trailing forward-slash issue""" 
     46        """ 
     47        Special-case the `index` method to resolve trailing forward-slash 
     48        issue. 
     49         
     50        """ 
    4751        return self.default(*args, **kwargs) 
    4852     
    …… 
    7680        return dict(content=content) 
    7781 
     82 
    7883class AdminContentController(Controller, identity.SecureResource): 
    7984    require = identity.has_permission('pagoda_admin') 
    8085     
    8186    @expose() 
    82     def edit(self, content_type, revision_id, **kwargs): 
     87    def default(self, content_type, revision_id, *args, **kwargs): 
    8388        model = plugins.get_content_model(content_type) 
    8489        content = model.get_by(revision_id=revision_id) 
    …… 
    8691            content, revision_id 
    8792        ) 
    88         # FIXME: Always calling index() is not flexible! 
    89         return content_controller.index() 
    90  
    91     @expose() 
    92     def live(self, content_type, revision_id, **kwargs): 
    93         model = plugins.get_content_model(content_type) 
    94         content = model.get_by(revision_id=revision_id) 
    95         content_controller = plugins.controller_for_content( 
    96             content, revision_id 
    97         ) 
    98         # FIXME: Always calling index() is not flexible! 
    99         return content_controller.index() 
     93        return continue_with_controller(content_controller, *args, **kwargs) 
    10094 
    10195class PublicationScheduleController(Controller, identity.SecureResource): 
    …… 
    229223        return result 
    230224 
     225 
    231226class AccountsController(Controller, identity.SecureResource): 
    232227    require = identity.has_permission('pagoda_admin') 
    …… 
    240235        return dict(users=users, groups=groups, permissions=permissions) 
    241236 
     237 
    242238class PlaceholdersController(Controller): 
    243239    require = identity.has_permission('pagoda_admin') 
    …… 
    248244        return dict() 
    249245 
     246 
    250247class PluginsController(Controller, identity.SecureResource): 
    251248    require = identity.has_permission('pagoda_admin') 
    …… 
    256253        return dict() 
    257254 
     255 
    258256class SettingsController(Controller, identity.SecureResource): 
    259257    require = identity.has_permission('pagoda_admin') 
    …… 
    263261    def index(self, *args, **kwargs): 
    264262        return dict() 
     263 
    265264 
    266265class PagodaAdminController(RootController): 

  • pagoda/trunk/Pagoda/pagoda/models/node.py

    r449 r541  
    1313    Column('url', String(255), nullable=True), 
    1414    Column('parent_id', None, ForeignKey('node.content_id'), nullable=True), 
     15    Column('is_deleted', Boolean, default=False, nullable=False), 
    1516    Column('template_id', None, ForeignKey(Template.c.template_id), 
    1617        nullable=True 

  • pagoda/trunk/Pagoda/pagoda/models/revision.py

    r468 r541  
    33from turbogears.database import metadata, session 
    44from pagoda.models import User, Content 
    5 from pagoda.models.util import now 
     5from pagoda.models.util import * 
    66from pagoda import workflow 
    77 
    …… 
    2020    Column('revision_time', DateTime, nullable=False, default=now), 
    2121    Column('revision_comment', TEXT, nullable=False, default=""), 
    22     Column('revision_status', Integer, nullable=False, default=0), 
     22    Column('revision_status', Integer, nullable=False, 
     23        default=workflow.PENDING 
     24    ), 
    2325    Column('revision_release_time', DateTime, nullable=True), 
    2426    Column('revision_expire_time', DateTime, nullable=True) 
    …… 
    3941            ", ".join(["%s=%r" % (col, getattr(self, col)) for col in cols]) 
    4042        ) 
    41      
    42     def approve(self): 
    43         self.revision_status = workflow.APPROVED 
    44      
     43         
    4544    @classmethod 
    4645    def query_latest(cls): 
    …… 
    114113        return approved_revision is not None 
    115114 
     115    def approve(self): 
     116        self.revision_status = workflow.APPROVED 
     117 
     118    def new_revision(self, **kwargs): 
     119        """ 
     120        Create and return a new revision instance with updated values given 
     121        as keyword arguments, and all other values being the same as on 
     122        `self`. Unless provided, revision-specific values such as 
     123        `revision_time`, `revision_comment` and `revision_status` will be 
     124        reset. 
     125         
     126        """ 
     127        # TODO: If no revisioned tables are updated by `kwargs`, make a new 
     128        # revision of every table, with the same values. 
     129         
     130        cls = self.__class__ 
     131         
     132        # Determine which tables will get new revisions by looking at 
     133        # the columns in `kwargs` 
     134        # TODO: Also look at modified columns on `instance` 
     135        update_tables = util.Set() 
     136        for column_name, value in kwargs.iteritems(): 
     137            update_table = get_column_table(cls.c[column_name]) 
     138            update_tables.add(update_table) 
     139         
     140        node_table = get_column_table(cls.c.node_revision_id) 
     141        generic_table = get_column_table(cls.c.generic_revision_id) 
     142        localized_table = get_column_table(cls.c.localized_revision_id) 
     143         
     144        values = get_instance_values(self) 
     145        if node_table in update_tables: 
     146            values['node_revision_id'] = None 
     147        if generic_table in update_tables: 
     148            values['generic_revision_id'] = None 
     149        if localized_table in update_tables: 
     150            values['localized_revision_id'] = None 
     151         
     152        reset_columns = ['revision_id', 'revision_time', 'revision_status', 
     153                         'revision_comment'] 
     154         
     155        for column_name in reset_columns: 
     156            values[column_name] = None 
     157         
     158        values.update(kwargs) 
     159        return cls(**values) 
     160 
    116161assign_mapper(session.context, Revision, revision_table, 
    117162    inherits=Content.mapper, 

  • pagoda/trunk/Pagoda/pagoda/models/revision_mapper.py

    r533 r541  
    174174         
    175175        """ 
     176        if instance.content_type is None: 
     177            instance.content_type = mapper.local_table.name 
     178         
    176179        # Order of `key_columns` is important due to dependencies! 
    177180        key_columns = [ 
    …… 
    183186        ] 
    184187         
    185         insert_tables = util.OrderedSet( 
    186             [get_column_table(col) for col in key_columns] 
    187         ) 
    188          
    189         if instance.content_type is None: 
    190             instance.content_type = mapper.local_table.name 
     188        insert_tables = util.OrderedSet() 
     189         
     190        for col in key_columns: 
     191            if getattr(instance, col.name) is None: 
     192                insert_table = get_column_table(col) 
     193                insert_tables.add(insert_table) 
    191194         
    192195        for insert_table in insert_tables: 
    …… 
    198201            inserted_ids = insert_result.last_inserted_ids() 
    199202            id_values = dict(zip(primary_keys, inserted_ids)) 
    200              
     203         
    201204            for column_name, value in param_values.iteritems(): 
    202205                if mapper.c.has_key(column_name): 
    203206                    setattr(instance, column_name, value) 
    204              
     207         
    205208            for column, value in id_values.iteritems(): 
    206209                if mapper.c.has_key(column.name): 
    207210                    setattr(instance, column.name, value) 
    208211         
    209         instance.node_revision_id = instance.revision_id 
    210         instance.generic_revision_id = instance.revision_id 
    211         instance.localized_revision_id = instance.revision_id 
     212        if instance.node_revision_id is None: 
     213            instance.node_revision_id = instance.revision_id 
     214        if instance.generic_revision_id is None: 
     215            instance.generic_revision_id = instance.revision_id 
     216        if instance.localized_revision_id is None: 
     217            instance.localized_revision_id = instance.revision_id 
    212218         
    213219        # Tell the session that this instance has already been persisted, 
    …… 
    242248    kwargs['properties'] = properties 
    243249     
    244     mapper = assign_mapper(ctx, class_, *args, **kwargs) 
    245      
    246     # Update the mapped method docstrings! 
    247     for method_name in ['get', 'get_by', 'select', 'select_by']: 
    248         extension_class = extension.__class__ 
    249         extension_method = getattr(extension_class, method_name, None) 
    250         class_method = getattr(class_, method_name, None) 
    251         if callable(extension_method) and callable(class_method): 
    252             class_method.im_func.__doc__ = extension_method.__doc__ 
    253      
    254     return mapper 
     250    return assign_mapper(ctx, class_, *args, **kwargs) 

  • pagoda/trunk/Pagoda/pagoda/plugins/controllers.py

    r502 r541  
    11import pkg_resources 
    2 from turbogears.controllers import expose, Controller 
     2from turbogears import expose, flash, redirect 
     3from turbogears.database import metadata, session 
     4from turbogears.controllers import Controller 
    35from pagoda import config 
    46# Relative imports! 
    57import models 
    68 
    7 __all__ = ['ContentController', 'update_content_controllers', 
    8            'get_content_controller', 'controller_for_content', 
    9            'controller_for_content_id', 'controller_for_url'] 
     9__all__ = ['ContentController', 'ManageController', 
     10           'update_content_controllers', 'get_content_controller', 
     11           'controller_for_content', 'controller_for_content_id', 
     12           'controller_for_url'] 
    1013 
    1114CONTENT_CONTROLLERS = {} 
    …… 
    1821    """ 
    1922    update_content_controllers() 
     23 
     24class ManageController(Controller): 
     25    def __init__(self, content, revision='active'): 
     26        self.content = content 
     27        self.revision = revision 
     28 
     29    @expose() 
     30    def add(self, content_type, **kwargs): 
     31        pass 
     32 
     33    @expose(allow_json=True) 
     34    def delete(self, **kwargs): 
     35        if not self.content.is_deleted: 
     36            transaction = models.session.create_transaction() 
     37            try: 
     38                deleted_content = self.content.new_revision(is_deleted=True) 
     39                transaction.commit() 
     40            except models.exceptions.SQLAlchemyError: 
     41                transaction.rollback() 
     42                result = dict(success=False) 
     43            else: 
     44                result = dict(success=True) 
     45        else: 
     46            result = dict(success=True) 
     47        return result 
     48 
     49    @expose() 
     50    def duplicate(self, **kwargs): 
     51        raise NotImplementedError 
     52 
     53    @expose() 
     54    def edit(self, **kwargs): 
     55        raise NotImplementedError 
     56 
     57    @expose() 
     58    def live(self, **kwargs): 
     59        raise NotImplementedError 
    2060 
    2161class ContentController(Controller): 
    …… 
    4585        # mistake twice! 
    4686        self._not_found = set() 
     87         
     88        self.manage = ManageController(content, revision) 
    4789     
    4890    def __getattr__(self, url): 

  • pagoda/trunk/Pagoda/pagoda/plugins/models.py

    r449 r541  
    11import pkg_resources 
    22import sqlalchemy 
    3 from pagoda.models import Content, Node 
     3from pagoda.models import Content, Node, exceptions, session 
    44 
    55__all__ = ['get_content_model', 'update_content_models', 'model_for_url', 

Log in as guest/pagoda to create tickets