Loading…

Flash Player 9 (or above) is needed to view presentations.
We have detected that you do not have it on your computer. To install it, go here.

Like this presentation? Why not share!

Like this? Share it with your network

Share

SilverStripe From a Developer's Perspective

on

  • 5,252 views

The presentation I gave at the Sydney PHP Users groups on 23/11/10 about SilverStripe and Sapphire from a developer's perspective.

The presentation I gave at the Sydney PHP Users groups on 23/11/10 about SilverStripe and Sapphire from a developer's perspective.

Statistics

Views

Total Views
5,252
Views on SlideShare
5,196
Embed Views
56

Actions

Likes
3
Downloads
53
Comments
0

6 Embeds 56

http://ludovic.coullet.net 29
http://dendeffe.tumblr.com 20
http://timesjobs.techgig.com 4
http://static.slidesharecdn.com 1
http://twitter.com 1
http://www.techgig.com 1

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

SilverStripe From a Developer's Perspective Presentation Transcript

  • 1. SilverStripe & Sapphire
    From a Developer’s Perspective
  • 2. About
    SilverStripe CMS is built on top of the Sapphire framework
    Sapphire is a modular PHP 5, OOP, MVC framework with lots of cool features
    Supports Apache and IIS equally well
    Can run on MySQL, SQLite, Postgres, MSSQL…
  • 3. Structure
    Everything is a module
    Sapphire is the core module, with all (except for direct file retrieval) requests routed through it
    The CMS is an module just like any other
    All code and theme assets (templates, cssetc) are listed in an automatically generated manifest - easy for the system to find
  • 4. Modules
    Module is simply a folder with a _config.phpfile
    Installation as simple as putting a folder in the root directory and building the DB
    Defined points to hook into the base CMS functionality using extensions
    Everything is a module, including your project code
  • 5.
  • 6. MVC
    Let’s look at each of those letters
  • 7. MVC Definition
    Model – contains the behaviour and data of your application. DataObjects and ORM.
    View – HTML, and other presentational elements. .ss templates.
    Controller – responds to requests and binds the model to the view. *_Controller classes.
  • 8. Data
    You define your models as subclasses of DataObject
    Define your fields, relationships, and metadata on the class, automatically built
    Uses multiple table inheritance
  • 9. Defining Your Schema
    You define your database fields in a $dbarray
    Automatically pulls casting information from this
    Define relationships in their own array
    Visit or run /dev/build to rebuild the database
    Done!
  • 10.
  • 11. Easy Relationship Management
    Several relationship types – has_one, belongs_to, has_many, many_many, belongs_many_many
    Easy accessing:
    $this->Relationship($filter);
    $this->Relationship()->addMany($items)
    $this->Relationship()->map()
  • 12. Page Types
    Complex DataObject, forms the core of most websites
    Managed via the main admin panel in the CMS
    Easy to customise, can contain any type of data
    Make SilverStripe ideal for your data, not the other way around
    Each page type is coupled to its own controller
  • 13.
  • 14.
  • 15. Retrieving Data
    Simple accessors – DataObject::get() and DataObject::get_one()
    Can use SQLQuery and DB::query() to peek behind the ORM
    Automatically caches certain things, performs default sorts and allows hooking into the process
  • 16. Changing Data
    $object->Field = $value
    $object->write()
    $object->publish(‘Stage’, ‘Live’)
    $object->delete()
  • 17. Extensions (AKA Decorators)
    Add functionality to classes at runtime, without subclassing
    Can add new methods, database fields, change and enhance behaviour
    Many core processes have hooks that extensions can hook in to
    Object::add_extension($subject, $extension)
  • 18. Extensions Continued
    Add new database fields and form fields in the CMS
    Lock a user out if a third-party criteria is not met
    Change the permissions model to either force permissions allowed or denied
    Add image editor support to the CMS image insertion form
    Restrict content to a specific subsite
    Add extra fields to the member profile
    Add static caching to the publishing process
  • 19. Core Extensions
    Versioned – adds support for staging/publishing, as well as rolling back to specific versions
    Hierarchy – Allows for a tree of objects to be stored in the DB, with related utiltitymethods
    Translatable – Adds support for saving multiple languages in one table, switch between languages, edit in CMS
  • 20. Much more than just data
    Extensions can hook into all parts of SilverStripe
    Basically anywhere a developer calls
    $this->extend(‘methodName’) you can hook extra behaviour in
  • 21. Easy Forms
    Out of the box scaffolding
    Rich form library, with both simple and complex widgets
    Form fields easily integrate with your models, save relationships
    $form->saveInto($record);$record->write();
  • 22. Form Library
    Simple Fields – TextField, DropdownField, DateField
    Structure Fields – HeaderField, LiteralField
    Relationship Fields – ComplexTableField, CheckboxSetField
    Much muchmuch more!
    Many fields in modules, and its easy to create your own!
  • 23. Forms in the CMS
    Simple to add fields in the CMS
    Just overload getCMSFields on your DataObject, and call:$fields->addFieldToTab(‘Root.Tab’, $field)
    Can also hook in using extensions to modify the fields on existing objects without subclassing
  • 24. ModelAdmin
    Fully scaffolded CRUD interface, with easy searching.
    Easily customisable, anything can be changed.
    Can be extended to very complex use cases.
  • 25.
  • 26.
  • 27. Templating
    Simple templating language, cached as raw PHP
    Not XML based, used for emails, HTML, all kinds of things
    Doesn’t limit the markup you can create
    Theming system for bundling templates
    Layout and include support across modules
  • 28.
  • 29. Requirements
    System to include, and block CSS and JS assets from templates and PHP code
    Supports minifying and combining
    Requirements::css(‘mysite/css/my.css’)Requirements::themedCSS(‘mycss’)<% require javascript (mysite/css/my.css) %>
  • 30. Controllers
    Simple URL routing:Director::addRules($priority, $rules)
    RequestHandler is a simple barebones controller, just takes a response and returns a response
    Controller has more utility methods, support for actions etc.
  • 31. Controllers Continued
    Once the initial URL routing is done, the request is still not always done.
    A controller can return a controller as its result, which then moves down the URL and uses that controller to parse the request
    This means you can easily create complex controllers from several controllers
    For example, the CMS controller returns a Form object, which then leads to a form field, which then renders a pop up
    Cascading permissions!
  • 32. Page Controllers
    Each page type also has a corresponding controller, which handles the actual request
    Can easily define custom actions, methods as you would expect
    Can also define controllers without a matching page to simulate a page without actually having one
  • 33.
  • 34. That’s a quick overview of some of the core
    Now for some cool random features!
  • 35. Caching Support
    Supports full page caching, with optional header management
    Can rsync to remote hosts
    Automatically updates cache on publish
    Partial caching, with automatic invalidation
    Integration with Zend_Cache
  • 36. 2008 DNC
  • 37. 2008 DNC
    One private CMS server, rsynced static content out to several other servers
    100M+ page view
    350 000 hours of HD video, some live
    Bi-lingual
    Could still make changes to site during heavy load times
  • 38. Easy API’s
    Simple SOAP and RESTful API’s out of the box
    Easily convert data to and from XML, JSON, form encoding
    Utility classes for consuming APIs
    Easily expose updates via RSS
  • 39. Translation and Internationalisation
    Support for simple string translation with PHP language files (in templates as well)
    Javascript translation support
    DataObjects can have an extension applied to add translatable support
    Full translation support in the CMS
  • 40. Reports
    Two types of reports – simple lists of pages in the CMS and more complex reports in their own tab
    You can easily define your own reports by extending SS_Report
    Just implement a few methods and you’re done!
  • 41.
  • 42. SearchContext
    Allows you to define an “advanced search” interface for your DataObjects
    Scaffolded by default, and used in ModelAdmin
    Works in both ModelAdmin and the frontend easily
    Define advanced search forms with simple code by using “search filters”
  • 43.
  • 44.
  • 45. And much more
    Configurable error handling, emailing and logging.
    Easily create scheduled and build tasks
    Insert dynamic content into html text fields using shortcodes
    Define widgets with a simple drag and drop interface
    Sake for running silverstripe commands from the CLI
    Easy environment-specific configuration
    Page comments
  • 46. Cool Modules!
    User Forms
    Queued Jobs
    Forum
    Blog
    Workflow
    Sphinx, Solr, Zend_Lucene
    Spam protection – recaptcha, mollom..
    And many more!
  • 47. User Forms Module
  • 48. DB Plumber
  • 49. Pixlr Image Editor
  • 50. What’s Next?
    SilverStripe 3 is currently being talked about
    New ORM?
    New template parser?
    Revamped media and download handling?
    Better module and configuration management?
    More cowbell?
  • 51. Any Questions?