emergent-core 0.1.0

data/rails_generators/emergent_config/templates/app/controllers/contents_controller.rb

@@ -0,0 +1,114 @@
+class ContentsController < ApplicationController
+  # GET /users
+  # GET /users.xml
+  # GET /users.fxml
+  def index
+    @contents = Content.find(:first).descendants
+
+    respond_to do |format|
+      format.html # index.html.erb
+      format.fxml do
+        render :fxml => @contents
+      end
+      format.xml do
+        render :xml => @contents
+      end
+    end
+  end
+
+  # GET /users/1
+  # GET /users/1.xml
+  # GET /users/1.fxml
+  def show
+    @content = Content.find(params[:id])
+    @content_assignments = []
+    @procs
+    ContentAssignment.find(:first, :conditions => {:content_id => @content.id}).descendants.each do |child|
+      proc = Proc.new do |opts|
+        opts[:builder].tag!('parent_id', child.parent.content.id)
+      end
+      @content_assignments.push(child)
+      @procs.push(proc)
+    end
+    
+    respond_to do |format|
+      format.html # index.html.erb
+      format.fxml do
+        render :fxml => @content.to_fxml(:child_proc => @procs)
+      end
+      format.xml do 
+        render :xml => @content.to_fxml(:child_proc => @procs)
+      end
+    end
+  end
+
+  # GET /users/new
+  # GET /users/new.xml
+  def new
+    @content = Content.new
+
+    respond_to do |format|
+      format.html # new.html.erb
+      format.xml  { render :xml => @content }
+    end
+  end
+
+  # GET /users/1/edit
+  def edit
+    @content = Content.find(params[:id])
+  end
+
+  # POST /users
+  # POST /users.xml
+  # POST /users.fxml
+  def create
+    @content = Content.new(params[:content])
+    respond_to do |format|
+      if @content.save
+        flash[:notice] = 'Content was successfully created.'
+        format.html { redirect_to(@content) }
+        format.xml  { render :xml => @content, :status => :created, :location => @content }
+        format.fxml  { render :fxml => @content }
+      else
+        format.html { render :action => "new" }
+        format.xml  { render :xml => @content.errors, :status => :unprocessable_entity }
+        format.fxml  { render :fxml => @content.errors }
+      end
+    end
+  end
+
+  # PUT /users/1
+  # PUT /users/1.xml
+  # PUT /users/1.fxml
+  def update
+    @content = Content.find(params[:id])
+
+    respond_to do |format|
+      if @content.update_attributes(params[:content])
+        flash[:notice] = 'Content was successfully updated.'
+        format.html { redirect_to(@content) }
+        format.xml  { head :ok }
+        format.fxml  { render :fxml => @content.to_fxml }
+      else
+        format.html { render :action => "edit" }
+        format.xml  { render :xml => @content.errors, :status => :unprocessable_entity }
+        format.fxml  { render :fxml => @content.errors }
+      end
+    end
+  end
+
+  # DELETE /users/1
+  # DELETE /users/1.xml
+  # DELETE /users/1.fxml
+  def destroy
+    @content = Content.find(params[:id])
+    @content.destroy
+
+    respond_to do |format|
+      format.html { redirect_to(contents_url) }
+      format.xml  { head :ok }
+      format.fxml  { render :fxml => @content }
+    end
+  end
+  
+end

data/rails_generators/emergent_config/templates/app/controllers/sessions_controller.rb

@@ -0,0 +1,72 @@
+# This controller handles the login/logout function of the site.  
+class SessionsController < ApplicationController
+  
+  skip_before_filter :login_required
+  
+  # render new.rhtml
+  def new
+  end
+
+  def create
+    logout_keeping_session!
+    account = Account.authenticate(params[:login], params[:password])
+    if account
+      # Protects against session fixation attacks, causes request forgery
+      # protection if user resubmits an earlier form using back
+      # button. Uncomment if you understand the tradeoffs.
+      # reset_session
+      new_cookie_flag = (params[:remember_me] == "1")
+      handle_remember_cookie! new_cookie_flag
+      
+      Account.session_token = session.session_id
+      
+      self.current_account = account
+      respond_to do |format|
+        format.html do
+          redirect_back_or_default('/')
+          flash[:notice] = "Logged in successfully"
+        end
+        format.fxml do
+          render :fxml => account.user.to_fxml(:methods => :photo, 
+            :include => {:address => {}, :account => {:only => [:id, :login, :email, :name], 
+              :methods => [:session_token, :photo_url]}})
+        end
+        format.xml do 
+          render :xml => account.user.to_fxml(:methods => :photo, 
+            :include => {:address => {}, :account => {:only => [:id, :login, :email, :name], 
+              :methods => [:session_token, :photo_url]}})
+        end
+      end
+    else
+      note_failed_signin
+      respond_to do |format|
+        format.html do
+          @login       = params[:login]
+          @remember_me = params[:remember_me]
+          render :action => 'new'        
+        end
+        format.fxml { render :text => "login_failed" }
+        format.xml { render :text => "login_failed" }
+      end
+    end
+  end
+
+  def destroy
+    logout_killing_session!
+    respond_to do |format|
+      format.html do
+        flash[:notice] = "You have been logged out."
+        redirect_back_or_default('/')
+      end
+      format.fxml { render :text => "loggedout" }
+      format.xml { render :text => "loggedout" }
+    end
+  end
+
+protected
+  # Track failed login attempts
+  def note_failed_signin
+    flash[:error] = "Couldn't log you in as '#{params[:login]}'"
+    logger.warn "Failed login for '#{params[:login]}' from #{request.remote_ip} at #{Time.now.utc}"
+  end
+end

data/rails_generators/emergent_config/templates/app/controllers/sites_controller.rb

@@ -0,0 +1 @@
+ContentAssignment

data/rails_generators/emergent_config/templates/app/controllers/users_controller.rb

@@ -0,0 +1,97 @@
+class UsersController < ApplicationController
+  # GET /users
+  # GET /users.xml
+  # GET /users.fxml
+  def index
+    @users = User.find(:all)
+
+    respond_to do |format|
+      format.html # index.html.erb
+      format.xml  { render :xml => @users }
+      format.fxml  { render :fxml => @users }
+    end
+  end
+
+  # GET /users/1
+  # GET /users/1.xml
+  # GET /users/1.fxml
+  def show
+    @user = User.find(params[:id])
+
+    respond_to do |format|
+      format.html # show.html.erb
+      format.xml  { render :xml => @user }
+      format.fxml  { render :fxml => @user }
+    end
+  end
+
+  # GET /users/new
+  # GET /users/new.xml
+  def new
+    @user = User.new
+
+    respond_to do |format|
+      format.html # new.html.erb
+      format.xml  { render :xml => @user }
+    end
+  end
+
+  # GET /users/1/edit
+  def edit
+    @user = User.find(params[:id])
+  end
+
+  # POST /users
+  # POST /users.xml
+  # POST /users.fxml
+  def create
+    @user = User.new(params[:user])
+
+    respond_to do |format|
+      if @user.save
+        flash[:notice] = 'User was successfully created.'
+        format.html { redirect_to(@user) }
+        format.xml  { render :xml => @user, :status => :created, :location => @user }
+        format.fxml  { render :fxml => @user }
+      else
+        format.html { render :action => "new" }
+        format.xml  { render :xml => @user.errors, :status => :unprocessable_entity }
+        format.fxml  { render :fxml => @user.errors }
+      end
+    end
+  end
+
+  # PUT /users/1
+  # PUT /users/1.xml
+  # PUT /users/1.fxml
+  def update
+    @user = User.find(params[:id])
+
+    respond_to do |format|
+      if @user.update_attributes(params[:user])
+        flash[:notice] = 'User was successfully updated.'
+        format.html { redirect_to(@user) }
+        format.xml  { head :ok }
+        format.fxml  { render :fxml => @user.to_fxml(:methods => :photo) }
+      else
+        format.html { render :action => "edit" }
+        format.xml  { render :xml => @user.errors, :status => :unprocessable_entity }
+        format.fxml  { render :fxml => @user.errors }
+      end
+    end
+  end
+
+  # DELETE /users/1
+  # DELETE /users/1.xml
+  # DELETE /users/1.fxml
+  def destroy
+    @user = User.find(params[:id])
+    @user.destroy
+
+    respond_to do |format|
+      format.html { redirect_to(users_url) }
+      format.xml  { head :ok }
+      format.fxml  { render :fxml => @user }
+    end
+  end
+end

data/rails_generators/emergent_config/templates/app/flex/application/controllers/command/ICommand.as

@@ -0,0 +1,16 @@
+/* Copyright 2008 Theo Hultberg/Iconara */
+
+package <%= base_package %>.controllers.command
+{
+	/**
+	 * A very basic command interface that just provides an execute method.
+	 * Any data that the command needs in order to do its work should be injected
+	 * through the constructor or through properties.
+	 */
+	public interface ICommand {
+		
+		function execute( ) : void ;
+		
+	}
+	 
+}

data/rails_generators/emergent_config/templates/app/flex/application/controllers/command/Undoable.as

@@ -0,0 +1,46 @@
+/* Copyright 2008 Theo Hultberg/Iconara */
+
+package <%= base_package %>.controllers.command
+{
+	
+	/**
+	 * Commands that implement this interface should provide a way for undoing the
+	 * actions taken in their execute method.
+	 * 
+	 * Undoables have a redo method in addition to execute, even though those two
+	 * most often will do the same work. The default implementation may be to have
+	 * redo call execute, but more complex situations may arise where some extra
+	 * steps are necessary when redoing, compared to executing the command initially.
+	 * 
+	 * It is up to the implementation how the undoing is done. It can be done by
+	 * saving a snapshot of the state of the object being modified, or just by
+	 * applying the same set of actions in reverse, whichever works for the situation.
+	 */
+	public interface Undoable extends ICommand {
+		
+		/**
+		 * The timestamp is for enabling grouping of undoables so that many undoables
+		 * that were executed at almost the same time (say milliseconds apart) could
+		 * be undone as one. Sometimes the user's perspecive of what consitutes one
+		 * action is not the same as the application's perspective.
+		 * 
+		 * The timestamp should be recorded in the execute method. It should not be
+		 * overwritten if the execute method runs again (for example during a redo).
+		 */
+		function get timestamp( ) : Date ;
+		
+		/**
+		 * The description property is for situations where the application wants to
+		 * display an undo history. It can simply return the name of the command or a
+		 * proper description of the changes the command made.
+		 */
+		function get description( ) : String ;
+	
+	
+		function undo( ) : void ;
+		
+		function redo( ) : void ;
+		
+	}
+	 
+}

data/rails_generators/emergent_config/templates/app/flex/application/controllers/command/UpdateDocumentCommand.as

@@ -0,0 +1,73 @@
+/* Copyright 2008 Theo Hultberg/Iconara */
+
+package <%= base_package %>.controllers.command
+{
+
+	import <%= base_package %>.models.domain.Document;
+	import <%= base_package %>.models.domain.Snapshot;	
+
+	public class UpdateDocumentCommand implements Undoable {
+		
+		private var _timestamp:Date;
+		
+		private var undoSnapshot:Snapshot;
+		
+		private var document:Document;
+		
+		public var title:String;
+		public var body:String;
+		public var abstract:String;
+		public var menuTitle:String;
+		public var subTitle:String;
+
+
+		public function get timestamp():Date {
+			return _timestamp;
+		}
+		
+		public function get description():String {
+			return "Update document";
+		}
+		
+		
+		public function UpdateDocumentCommand() {
+		}
+		
+		public function prepare(document:Document, vars:*):void {
+			this.document = document;
+			document.mapProperties(this, vars, document.desiredProperties);
+			/*this.title = vars.title;
+			this.body = vars.body;
+			this.abstract = vars.abstract;
+			this.menuTitle = vars.menuTitle;
+			this.subTitle = vars.subTitle;*/
+		}
+		
+		public function execute():void {
+			undoSnapshot = document.createSnapshot();
+			
+			document.mapProperties(document.content, this, document.desiredProperties);
+			/*document.title = title;
+			document.body = body;
+			document.abstract = abstract;
+			document.menuTitle = menuTitle;
+			document.subTitle = subTitle;*/
+			
+			if ( _timestamp == null ) {
+				// don't overwrite the timestamp on redo
+				
+				_timestamp = new Date();
+			}
+		}
+		
+		public function undo():void {
+			document.loadSnapshot(undoSnapshot);
+		}
+		
+		public function redo():void {
+			execute();
+		}
+
+	}
+
+}

data/rails_generators/emergent_config/templates/app/flex/application/controllers/event/DocumentEvent.as

@@ -0,0 +1,46 @@
+/* Copyright 2008 Theo Hultberg/Iconara */
+
+package <%= base_package %>.controllers.event {
+
+	import flash.events.Event;
+
+	import <%= base_package %>.models.domain.Document;
+	import <%= base_package %>.models.constant.DocumentType;
+
+	
+	/**
+	 * Events of this type are used to request document-related actions such as opening, closing, 
+	 * deleting, creating and updating.
+	 * 
+	 * All instances of this event bubble.
+	 */
+	public class DocumentEvent extends Event {
+		
+		public static const     UPDATE : String = "update";
+		public static const CREATE_NEW : String = "createNew";
+		public static const       OPEN : String = "open";
+		public static const      CLOSE : String = "close";
+		public static const     DELETE : String = "delete";
+		public static const       SAVE : String = "save";
+		public static const      SAVED : String = "saved";
+		
+		/**
+		 * Events that refer to a specific document (UPDATE, OPEN, CLOSE, DELETE, SAVE and SAVED)
+		 * use this property to pass that document.
+		 */
+		public var reference : Document;
+		
+		/**
+		 * Events that create new documents (CREATE_NEW) use this property to specify
+		 * which kind of document to create. Must be one of the constants on the DocumentType class.
+		 */
+		public var documentType : DocumentType;
+		
+		
+		public function DocumentEvent( type : String, bubbles : Boolean = false, cancelable : Boolean = false ) {
+			super(type, true, cancelable);
+		}
+		
+	}
+	
+}

data/rails_generators/emergent_config/templates/app/flex/application/controllers/event/NavigationEvent.as

@@ -0,0 +1,31 @@
+package <%= base_package %>.controllers.event
+{
+
+	import flash.events.*;
+	
+	public class NavigationEvent extends Event
+	{
+		/**
+     	 * A NavigationEvent tells the View how to respond when some new data is loaded
+	 	 * It also allows you to finely control the View state logic
+		 * Edit this as you see fit.
+     	 */
+		public var url:Array;
+	
+		// Attach any RxModel to this.
+		public var resource:*;
+	
+		// whether or not you want to show or hide it
+		public var action:String;
+	
+		public function NavigationEvent(type:String, bubbles:Boolean = false)
+	    {
+	        super(type, bubbles);
+	    }
+
+		override public function clone():Event
+	    {
+	        return new NavigationEvent(type, bubbles);
+	    }
+	}
+}

data/rails_generators/emergent_config/templates/app/flex/application/controllers/event/ResourceEvent.as

@@ -0,0 +1,27 @@
+package <%= base_package %>.controllers.event
+{
+
+	import flash.events.*;
+	
+	public class ResourceEvent extends Event {
+		
+		// can be null, success, or failure.
+		public var result:String;
+		
+		// can be list, open, create, upload, destroy... etc or null
+		public var action:String;
+		
+		public var data:*; // RxModel
+
+		public function ResourceEvent(type:String, bubbles:Boolean = false)
+	    {
+			action = type;
+	        super(type, bubbles);
+	    }
+
+		override public function clone():Event
+	    {
+	        return new ResourceEvent(type, bubbles);
+	    }
+	}
+}

data/rails_generators/emergent_config/templates/app/flex/application/controllers/event/UndoEvent.as

@@ -0,0 +1,36 @@
+/* Copyright 2008 Theo Hultberg/Iconara */
+
+package <%= base_package %>.controllers.event
+{
+	import flash.events.Event;
+
+	import <%= base_package %>.controllers.command.Undoable;
+	
+	
+	/**
+	 * Events of this type are used to request undo-related actions.
+	 */
+	public class UndoEvent extends Event {
+		
+		public static const         UNDO : String = "undo";
+		public static const         REDO : String = "redo";
+		public static const      RESTORE : String = "restore";
+		public static const ADD_UNDOABLE : String = "addUndoable";
+		
+		
+		/**
+		 * Events that refer to a specific undoable (RESTORE, ADD_UNDOABLE) use 
+		 * this property to pass that object.
+		 */
+		public var undoable : Undoable;
+		
+		
+		public function UndoEvent( type : String, undoable : Undoable = null ) {
+			super(type, true);
+			
+			this.undoable = undoable;
+		}
+		
+	}
+	
+}

data/rails_generators/emergent_config/templates/app/flex/application/controllers/manager/AboutUsManager.as

@@ -0,0 +1,15 @@
+package <%= base_package %>.controllers.manager {
+	
+	import <%= base_package %>.models.domain.Content;
+	import <%= base_package %>.models.domain.ContentAssignment;
+	
+	import org.restfulx.Rx;
+	import org.restfulx.collections.ModelsCollection;
+	
+	public class AboutUsManager extends ContentManager {
+		
+		public function AboutUsManager() {
+			setModel(target);
+		}
+	}
+}

data/rails_generators/emergent_config/templates/app/flex/application/controllers/manager/AccountManager.as

@@ -0,0 +1,31 @@
+package <%= base_package %>.controllers.manager {
+
+	import flash.events.Event;
+	import flash.events.EventDispatcher;
+	import flash.utils.getDefinitionByName;
+	import flash.utils.getQualifiedClassName;
+	
+	import org.restfulx.Rx;
+	import org.restfulx.collections.ModelsCollection;
+	import org.restfulx.models.RxModel;
+	import org.restfulx.utils.RxUtils;
+	
+	import <%= base_package %>.models.domain.Account;
+	import <%= base_package %>.controllers.event.ResourceEvent;
+	
+	public class AccountManager extends ResourceManager {
+		
+		/** Injector targets */
+		[Bindable] public var accountEvent:ResourceEvent;
+		
+		private var _account:Account; [Bindable]
+		public function get account():Account { return _account; }
+		public function set account(value:Account):void {
+			_account = value;
+		}
+	
+		public function AccountManager() {
+			setModel(account, accountEvent);
+		}
+	}
+}

data/rails_generators/emergent_config/templates/app/flex/application/controllers/manager/AuthenticationManager.as

@@ -0,0 +1,76 @@
+package <%= base_package %>.controllers.manager {
+
+	import flash.events.Event;
+	import flash.events.EventDispatcher;
+	import flash.utils.getDefinitionByName;
+	import flash.utils.getQualifiedClassName;
+	
+	import org.restfulx.Rx;
+	import org.restfulx.collections.ModelsCollection;
+	import org.restfulx.models.RxModel;
+	import org.restfulx.utils.RxUtils;
+	
+	import <%= base_package %>.models.domain.Session;
+	import <%= base_package %>.models.domain.User;
+
+	import <%= base_package %>.models.constant.ResourceResult;
+	import <%= base_package %>.models.constant.ResourceAction;
+	import <%= base_package %>.controllers.event.ResourceEvent;
+	
+	public class AuthenticationManager extends ResourceManager {
+		
+		/** Injector targets */
+		[Bindable] public var loginEvent:ResourceEvent;
+		[Bindable] public var logoutEvent:ResourceEvent;
+		
+		private var _currentUser:User; [Bindable]
+		public function get currentUser():User { return _currentUser; }
+		public function set currentUser(value:User):void {
+			_currentUser = value;
+		}
+		
+		private var _sessionToken:*; [Bindable]
+		public function get sessionToken():* { return _sessionToken; }
+		public function set sessionToken(value:*):void {
+			_sessionToken = value;
+		}
+	
+		public function AuthenticationManager() {
+			
+		}
+		
+		override protected function create(resource:*):void {
+			var r:* = discover(resource);
+			login(r as Session);
+		}
+		
+		override protected function destroy(resource:*):void {
+			var r:* = discover(resource);
+			logout(resource as Session);
+		}
+		
+		public function login(session:Session):void {
+			Rx.http(onLoginSuccess, onLoginFailure).invoke("session.fxml", 
+			{ login: session.login, password: session.password }, "POST", true);
+		}
+		
+		public function logout(session:Session):void {
+	      Rx.http(onLogout).invoke({URL: "session.fxml", method: "DELETE"});
+		}
+		
+		private function onLoginSuccess(result:User):void {
+			currentUser = result;
+			Rx.sessionToken = result.account.sessionToken;
+			sessionToken = Rx.sessionToken;
+			success(result, loginEvent);
+		}
+
+		private function onLoginFailure(result:Object):void {
+			failure(result, loginEvent);
+		}
+
+		private function onLogout(result:Object):void {
+			inject(result, logoutEvent);
+		}
+	}
+}