diff --git a/Fetmailalias, b/Fetmailalias,
new file mode 100644
index 0000000..e69de29
diff --git a/Gemfile b/Gemfile
index 486db40..39c0935 100755
--- a/Gemfile
+++ b/Gemfile
@@ -13,8 +13,8 @@ gem 'webrick', '1.3.1'
 
 # Gems used only for assets and not required
 # in production environments by default.
-  gem 'sass-rails', '~> 3.2'
-  gem 'coffee-rails', '~> 3.2.1'
+  gem 'sass-rails', '~> 3.0'
+  gem 'coffee-rails', '~> 3.0'
   gem 'bootstrap-sass','~> 2.3.2.1'
   
 group :assets do
@@ -60,16 +60,17 @@ gem "paper_trail" , '~>3.0.5'#, :git=>'git://github.com/airblade/paper_trail.git
 
 # User management
 gem "devise" ,'~>2.2.3'
-gem "omniauth"
-gem "omniauth-facebook"
-gem "omniauth-ldap"
+gem "omniauth", '~>1.2.2'
+gem "omniauth-facebook", '~>2.0.0'
+gem "omniauth-ldap", '~>1.0.4'
 
-gem "fb_graph"
+gem "fb_graph",'~>2.7.17'
 gem "meta-tags"
 # Roles for users
-gem "rolify"
+gem "rolify", '~>4.0.0'
 # Abilities
-gem "cancan"
+gem "cancan", '~>1.6.0'
+
 
 # Fileupload
 
@@ -84,8 +85,16 @@ gem 'awesome_nested_set'
 gem 'annotate', ">=2.5.0"
 gem 'carrierwave', "~>0.9.0"
 group :development, :test do 
-gem 'factory_girl_rails'
-gem 'rspec-rails'
+gem 'factory_girl_rails',"~>4.5.0"
+gem 'minitest', "~>4.7.5"
+gem 'progress_bar'
+gem 'rspec-core', '~>3.3.0'
+gem 'rspec-rails', '~>3.3.0'
+gem 'rspec-collection_matchers'
+gem 'rspec-activemodel-mocks'
+gem 'rspec-html-matchers'
+gem 'rspec-expectations'
+gem 'capybara', '~>2.5.0'
 end
 
 gem "simple_calendar", "~> 0.1.9"
@@ -93,7 +102,7 @@ gem 'rmagick'
 
 gem 'bootstrap-addons-rails'
 gem "jquery-fileupload-rails", "0.4.1"
-gem "jquery-ui-rails","~> 4.1.1" 
+gem "jquery-ui-rails","~> 4.1.0" 
 gem "font-awesome-rails"
 gem "jquery-datetimepicker-rails"
 # gem "jquery-sortable-rails"
@@ -124,4 +133,6 @@ gem 'opengraph_parser'
 gem 'blueimp-gallery'
 gem 'blueimp-gallery-rails'
 
-gem 'shareable'
\ No newline at end of file
+gem 'shareable'
+
+gem 'sunspot_test'
\ No newline at end of file
diff --git a/MyText, b/MyText,
new file mode 100644
index 0000000..e69de29
diff --git a/Nachname, b/Nachname,
new file mode 100644
index 0000000..e69de29
diff --git a/Short, b/Short,
new file mode 100644
index 0000000..e69de29
diff --git a/Vorname, b/Vorname,
new file mode 100644
index 0000000..e69de29
diff --git a/app/assets/javascripts/jmpress.js b/app/assets/javascripts/jmpress.js
new file mode 100644
index 0000000..39f5624
--- /dev/null
+++ b/app/assets/javascripts/jmpress.js
@@ -0,0 +1,2659 @@
+/*!
+ * jmpress.js v0.4.5
+ * http://jmpressjs.github.com/jmpress.js
+ *
+ * A jQuery plugin to build a website on the infinite canvas.
+ *
+ * Copyright 115 Kyle Robinson Young @shama & Tobias Koppers @sokra
+ * Licensed MIT
+ * http://www.opensource.org/licenses/mit-license.php
+ *
+ * Based on the foundation laid by Bartek Szopka @bartaz
+ */
+/*
+ * core.js
+ * The core of jmpress.js
+ */
+(function( $, document, window, undefined ) {
+
+	'use strict';
+
+	/**
+	 * Set supported prefixes
+	 *
+	 * @access protected
+	 * @return Function to get prefixed property
+	 */
+	var pfx = (function () {
+		var style = document.createElement('dummy').style,
+			prefixes = 'Webkit Moz O ms Khtml'.split(' '),
+			memory = {};
+		return function ( prop ) {
+			if ( typeof memory[ prop ] === "undefined" ) {
+				var ucProp  = prop.charAt(0).toUpperCase() + prop.substr(1),
+					props   = (prop + ' ' + prefixes.join(ucProp + ' ') + ucProp).split(' ');
+				memory[ prop ] = null;
+				for ( var i in props ) {
+					if ( style[ props[i] ] !== undefined ) {
+						memory[ prop ] = props[i];
+						break;
+					}
+				}
+			}
+			return memory[ prop ];
+		};
+	}());
+
+	/**
+	 * map ex. "WebkitTransform" to "-webkit-transform"
+	 */
+	function mapProperty( name ) {
+		if(!name) {
+			return;
+		}
+		var index = 1 + name.substr(1).search(/[A-Z]/);
+		var prefix = name.substr(0, index).toLowerCase();
+		var postfix = name.substr(index).toLowerCase();
+		return "-" + prefix + "-" + postfix;
+	}
+	function addComma( attribute ) {
+		if(!attribute) {
+			return "";
+		}
+		return attribute + ",";
+	}
+	/**
+	 * Return an jquery object only if it's not empty
+	 */
+	function ifNotEmpty(el) {
+		if(el.length > 0) {
+			return el;
+		}
+		return null;
+	}
+
+	/**
+	 * Default Settings
+	 */
+	var defaults = {
+		/* CLASSES */
+		stepSelector: '.step'
+		,containerClass: ''
+		,canvasClass: ''
+		,areaClass: ''
+		,notSupportedClass: 'not-supported'
+
+		/* CONFIG */
+		,fullscreen: true
+
+		/* ANIMATION */
+		,animation: {
+			transformOrigin: 'top left'
+			,transitionProperty: addComma(mapProperty(pfx('transform'))) + addComma(mapProperty(pfx('perspective'))) + 'opacity'
+			,transitionDuration: '1s'
+			,transitionDelay: '500ms'
+			,transitionTimingFunction: 'ease-in-out'
+			,transformStyle: "preserve-3d"
+		}
+		,transitionDuration: 1500
+	};
+	var callbacks = {
+		'beforeChange': 1
+		,'beforeInitStep': 1
+		,'initStep': 1
+		,'checkNoSupport': 1
+		,'beforeInit': 1
+		,'afterInit': 1
+		,'beforeDeinit': 1
+		,'afterDeinit': 1
+		,'applyStep': 1
+		,'unapplyStep': 1
+		,'setInactive': 1
+		,'beforeActive': 1
+		,'setActive': 1
+		,'selectInitialStep': 1
+		,'selectPrev': 1
+		,'selectNext': 1
+		,'selectHome': 1
+		,'selectEnd': 1
+		,'idle': 1
+		,'applyTarget': 1
+	};
+	for(var callbackName in callbacks) {
+		defaults[callbackName] = [];
+	}
+
+
+	/**
+	 * Initialize jmpress
+	 */
+	function init( args ) {
+		args = $.extend(true, {}, args || {});
+
+		// accept functions and arrays of functions as callbacks
+		var callbackArgs = {};
+		var callbackName = null;
+		for (callbackName in callbacks) {
+			callbackArgs[callbackName] = $.isFunction( args[callbackName] ) ?
+				[ args[callbackName] ] :
+				args[callbackName];
+			args[callbackName] = [];
+		}
+
+		// MERGE SETTINGS
+		var settings = $.extend(true, {}, defaults, args);
+
+		for (callbackName in callbacks) {
+			if (callbackArgs[callbackName]) {
+				Array.prototype.push.apply(settings[callbackName], callbackArgs[callbackName]);
+			}
+		}
+
+		/*** MEMBER VARS ***/
+
+		var jmpress = $( this )
+			,container = null
+			,area = null
+			,oldStyle = {
+				container: ""
+				,area: ""
+			}
+			,canvas = null
+			,current = null
+			,active = false
+			,activeSubstep = null
+			,activeDelegated = false;
+
+
+		/*** MEMBER FUNCTIONS ***/
+		// functions have to be called with this
+
+		/**
+		 * Init a single step
+		 *
+		 * @param element the element of the step
+		 * @param idx number of step
+		 */
+		function doStepInit( element, idx ) {
+			var data = dataset( element );
+			var step = {
+				oldStyle: $(element).attr("style") || ""
+			};
+
+			var callbackData = {
+				data: data
+				,stepData: step
+			};
+			callCallback.call(this, 'beforeInitStep', $(element), callbackData);
+			step.delegate = data.delegate;
+			callCallback.call(this, 'initStep', $(element), callbackData);
+
+			$(element).data('stepData', step);
+
+			if ( !$(element).attr('id') ) {
+				$(element).attr('id', 'step-' + (idx + 1));
+			}
+
+			callCallback.call(this, 'applyStep', $(element), callbackData);
+		}
+		/**
+		 * Deinit a single step
+		 *
+		 * @param element the element of the step
+		 */
+		function doStepDeinit( element ) {
+			var stepData = $(element).data('stepData');
+
+			$(element).attr("style", stepData.oldStyle);
+
+			callCallback.call(this, 'unapplyStep', $(element), {
+				stepData: stepData
+			});
+		}
+		/**
+		 * Reapplies stepData to the element
+		 *
+		 * @param element
+		 */
+		function doStepReapply( element ) {
+			callCallback.call(this, 'unapplyStep', $(element), {
+				stepData: element.data("stepData")
+			});
+
+			callCallback.call(this, 'applyStep', $(element), {
+				stepData: element.data("stepData")
+			});
+		}
+		/**
+		 * Completly deinit jmpress
+		 *
+		 */
+		function deinit() {
+			if ( active ) {
+				callCallback.call(this, 'setInactive', active, {
+					stepData: $(active).data('stepData')
+					,reason: "deinit"
+				} );
+			}
+			if (current.jmpressClass) {
+				$(jmpress).removeClass(current.jmpressClass);
+			}
+
+			callCallback.call(this, 'beforeDeinit', $(this), {});
+
+			$(settings.stepSelector, jmpress).each(function( idx ) {
+				doStepDeinit.call(jmpress, this );
+			});
+
+			container.attr("style", oldStyle.container);
+			if(settings.fullscreen) {
+				$("html").attr("style", "");
+			}
+			area.attr("style", oldStyle.area);
+			$(canvas).children().each(function() {
+				jmpress.append( $( this ) );
+			});
+			if( settings.fullscreen ) {
+				canvas.remove();
+			} else {
+				canvas.remove();
+				area.remove();
+			}
+
+			callCallback.call(this, 'afterDeinit', $(this), {});
+
+			$(jmpress).data("jmpressmethods", false);
+
+			if(current.idleTimeout) {
+				clearTimeout(current.idleTimeout);
+			}
+		}
+		/**
+		 * Call a callback
+		 *
+		 * @param callbackName String callback which should be called
+		 * @param element some arguments to the callback
+		 * @param eventData
+		 */
+		function callCallback( callbackName, element, eventData ) {
+			eventData.settings = settings;
+			eventData.current = current;
+			eventData.container = container;
+			eventData.parents = element ? getStepParents(element) : null;
+			eventData.current = current;
+			eventData.jmpress = this;
+			var result = {};
+			$.each( settings[callbackName], function(idx, callback) {
+				result.value = callback.call( jmpress, element, eventData ) || result.value;
+			});
+			return result.value;
+		}
+		/**
+		 *
+		 */
+		function getStepParents( el ) {
+			return $(el).parentsUntil(jmpress).not(jmpress).filter(settings.stepSelector);
+		}
+		/**
+		 * Reselect the active step
+		 *
+		 * @param String type reason of reselecting step
+		 */
+		function reselect( type ) {
+			return select( { step: active, substep: activeSubstep }, type);
+		}
+		/**
+		 * Select a given step
+		 *
+		 * @param el element to select
+		 * @param type reason of changing step
+		 * @return Object element selected
+		 */
+		function select( el, type ) {
+			var substep;
+			if ( $.isPlainObject( el ) ) {
+				substep = el.substep;
+				el = el.step;
+			}
+			if ( typeof el === 'string') {
+				el = jmpress.find( el ).first();
+			}
+			if ( !el || !$(el).data('stepData') ) {
+				return false;
+			}
+
+			scrollFix.call(this);
+
+			var step = $(el).data('stepData');
+
+			var cancelSelect = false;
+			callCallback.call(this, "beforeChange", el, {
+				stepData: step
+				,reason: type
+				,cancel: function() {
+					cancelSelect = true;
+				}
+			});
+			if (cancelSelect) {
+				return undefined;
+			}
+
+			var target = {};
+
+			var delegated = el;
+			if($(el).data("stepData").delegate) {
+				delegated = ifNotEmpty($(el).parentsUntil(jmpress).filter(settings.stepSelector).filter(step.delegate)) ||
+					ifNotEmpty($(el).near(step.delegate)) ||
+					ifNotEmpty($(el).near(step.delegate, true)) ||
+					ifNotEmpty($(step.delegate, jmpress));
+				if(delegated) {
+					step = delegated.data("stepData");
+				} else {
+					// Do not delegate if expression not found
+					delegated = el;
+				}
+			}
+			if ( activeDelegated ) {
+				callCallback.call(this, 'setInactive', activeDelegated, {
+					stepData: $(activeDelegated).data('stepData')
+					,delegatedFrom: active
+					,reason: type
+					,target: target
+					,nextStep: delegated
+					,nextSubstep: substep
+					,nextStepData: step
+				} );
+			}
+			var callbackData = {
+				stepData: step
+				,delegatedFrom: el
+				,reason: type
+				,target: target
+				,substep: substep
+				,prevStep: activeDelegated
+				,prevSubstep: activeSubstep
+				,prevStepData: activeDelegated && $(activeDelegated).data('stepData')
+			};
+			callCallback.call(this, 'beforeActive', delegated, callbackData);
+			callCallback.call(this, 'setActive', delegated, callbackData);
+
+			// Set on step class on root element
+			if (current.jmpressClass) {
+				$(jmpress).removeClass(current.jmpressClass);
+			}
+			$(jmpress).addClass(current.jmpressClass = 'step-' + $(delegated).attr('id') );
+			if (current.jmpressDelegatedClass) {
+				$(jmpress).removeClass(current.jmpressDelegatedClass);
+			}
+			$(jmpress).addClass(current.jmpressDelegatedClass = 'delegating-step-' + $(el).attr('id') );
+
+			callCallback.call(this, "applyTarget", delegated, $.extend({
+				canvas: canvas
+				,area: area
+				,beforeActive: activeDelegated
+			}, callbackData));
+
+			active = el;
+			activeSubstep = callbackData.substep;
+			activeDelegated = delegated;
+
+			if(current.idleTimeout) {
+				clearTimeout(current.idleTimeout);
+			}
+			current.idleTimeout = setTimeout(function() {
+				callCallback.call(this, 'idle', delegated, callbackData);
+			}, Math.max(1, settings.transitionDuration - 100));
+
+			return delegated;
+		}
+		/**
+		 * This should fix ANY kind of buggy scrolling
+		 */
+		function scrollFix() {
+			(function fix() {
+				if ($(container)[0].tagName === "BODY") {
+					try {
+						window.scrollTo(0, 0);
+					} catch(e) {}
+				}
+				$(container).scrollTop(0);
+				$(container).scrollLeft(0);
+				function check() {
+					if ($(container).scrollTop() !== 0 ||
+						$(container).scrollLeft() !== 0) {
+							fix();
+						}
+				}
+				setTimeout(check, 1);
+				setTimeout(check, 10);
+				setTimeout(check, 100);
+				setTimeout(check, 200);
+				setTimeout(check, 400);
+			}());
+		}
+		/**
+		 * Alias for select
+		 */
+		function goTo( el ) {
+			return select.call(this, el, "jump" );
+		}
+		/**
+		 * Goto Next Slide
+		 *
+		 * @return Object newly active slide
+		 */
+		function next() {
+			return select.call(this, callCallback.call(this, 'selectNext', active, {
+				stepData: $(active).data('stepData')
+				,substep: activeSubstep
+			}), "next" );
+		}
+		/**
+		 * Goto Previous Slide
+		 *
+		 * @return Object newly active slide
+		 */
+		function prev() {
+			return select.call(this, callCallback.call(this, 'selectPrev', active, {
+				stepData: $(active).data('stepData')
+				,substep: activeSubstep
+			}), "prev" );
+		}
+		/**
+		 * Goto First Slide
+		 *
+		 * @return Object newly active slide
+		 */
+		function home() {
+			return select.call(this, callCallback.call(this, 'selectHome', active, {
+				stepData: $(active).data('stepData')
+			}), "home" );
+		}
+		/**
+		 * Goto Last Slide
+		 *
+		 * @return Object newly active slide
+		 */
+		function end() {
+			return select.call(this,   callCallback.call(this, 'selectEnd', active, {
+				stepData: $(active).data('stepData')
+			}), "end" );
+		}
+		/**
+		 * Manipulate the canvas
+		 *
+		 * @param props
+		 * @return Object
+		 */
+		function canvasMod( props ) {
+			css(canvas, props || {});
+			return $(canvas);
+		}
+		/**
+		 * Return current step
+		 *
+		 * @return Object
+		 */
+		function getActive() {
+			return activeDelegated && $(activeDelegated);
+		}
+		/**
+		 * fire a callback
+		 *
+		 * @param callbackName
+		 * @param element
+		 * @param eventData
+		 * @return void
+		 */
+		function fire( callbackName, element, eventData ) {
+			if( !callbacks[callbackName] ) {
+				$.error( "callback " + callbackName + " is not registered." );
+			} else {
+				return callCallback.call(this, callbackName, element, eventData);
+			}
+		}
+
+		/**
+		 * PUBLIC METHODS LIST
+		 */
+		jmpress.data("jmpressmethods", {
+			select: select
+			,reselect: reselect
+			,scrollFix: scrollFix
+			,goTo: goTo
+			,next: next
+			,prev: prev
+			,home: home
+			,end: end
+			,canvas: canvasMod
+			,container: function() { return container; }
+			,settings: function() { return settings; }
+			,active: getActive
+			,current: function() { return current; }
+			,fire: fire
+			,init: function(step) {
+				doStepInit.call(this, $(step), current.nextIdNumber++);
+			}
+			,deinit: function(step) {
+				if(step) {
+					doStepDeinit.call(this, $(step));
+				} else {
+					deinit.call(this);
+				}
+			}
+			,reapply: doStepReapply
+		});
+
+		/**
+		 * Check for support
+		 * This will be removed in near future, when support is coming
+		 *
+		 * @access protected
+		 * @return void
+		 */
+		function checkSupport() {
+			var ua = navigator.userAgent.toLowerCase();
+			return (ua.search(/(iphone)|(ipod)|(android)/) === -1) || (ua.search(/(chrome)/) !== -1);
+		}
+
+		// BEGIN INIT
+
+		// CHECK FOR SUPPORT
+		if (checkSupport() === false || callCallback.call(this, 'checkNoSupport', null, {})) {
+			// not supported
+			if (settings.notSupportedClass) {
+				jmpress.addClass(settings.notSupportedClass);
+			}
+			return;
+		} else {
+			if (settings.notSupportedClass) {
+				jmpress.removeClass(settings.notSupportedClass);
+			}
+		}
+
+		// grabbing all steps
+		var steps = $(settings.stepSelector, jmpress);
+
+		// GERNERAL INIT OF FRAME
+		container = jmpress;
+		area = $('<div />');
+		canvas = $('<div />');
+		$(jmpress).children().filter(steps).each(function() {
+			canvas.append( $( this ) );
+		});
+		if(settings.fullscreen) {
+			container = $('body');
+			$("html").css({
+				overflow: 'hidden'
+			});
+			area = jmpress;
+		}
+		oldStyle.area = area.attr("style") || "";
+		oldStyle.container = container.attr("style") || "";
+		if(settings.fullscreen) {
+			container.css({
+				height: '100%'
+			});
+			jmpress.append( canvas );
+		} else {
+			container.css({
+				position: "relative"
+			});
+			area.append( canvas );
+			jmpress.append( area );
+		}
+
+		$(container).addClass(settings.containerClass);
+		$(area).addClass(settings.areaClass);
+		$(canvas).addClass(settings.canvasClass);
+
+		document.documentElement.style.height = "100%";
+		container.css({
+			overflow: 'hidden'
+		});
+
+		var props = {
+			position: "absolute"
+			,transitionDuration: '0s'
+		};
+		props = $.extend({}, settings.animation, props);
+		css(area, props);
+		css(canvas, props);
+
+		current = {};
+
+		callCallback.call(this, 'beforeInit', null, {
+			canvas: canvas,
+			area: area
+		});
+
+		// INITIALIZE EACH STEP
+		steps.each(function( idx ) {
+			doStepInit.call(jmpress, this, idx );
+		});
+		current.nextIdNumber = steps.length;
+
+		callCallback.call(this, 'afterInit', null, {});
+
+		// START
+		select.call(this,  callCallback.call(this, 'selectInitialStep', "init", {}) );
+
+		if (settings.initClass) {
+			$(steps).removeClass(settings.initClass);
+		}
+	}
+	/**
+	 * Return default settings
+	 *
+	 * @return Object
+	 */
+	function getDefaults() {
+		return defaults;
+	}
+	/**
+	 * Register a callback or a jmpress function
+	 *
+	 * @access public
+	 * @param name String the name of the callback or function
+	 * @param func Function? the function to be added
+	 */
+	function register(name, func) {
+		if( $.isFunction(func) ) {
+			if( methods[name] ) {
+				$.error( "function " + name + " is already registered." );
+			} else {
+				methods[name] = func;
+			}
+		} else {
+			if( callbacks[name] ) {
+				$.error( "callback " + name + " is already registered." );
+			} else {
+				callbacks[name] = 1;
+				defaults[name] = [];
+			}
+		}
+	}
+	/**
+	 * Set CSS on element w/ prefixes
+	 *
+	 * @return Object element which properties were set
+	 *
+	 * TODO: Consider bypassing pfx and blindly set as jQuery
+	 * already checks for support
+	 */
+	function css( el, props ) {
+		var key, pkey, cssObj = {};
+		for ( key in props ) {
+			if ( props.hasOwnProperty(key) ) {
+				pkey = pfx(key);
+				if ( pkey !== null ) {
+					cssObj[pkey] = props[key];
+				}
+			}
+		}
+		$(el).css(cssObj);
+		return el;
+	}
+	/**
+	 * Return dataset for element
+	 *
+	 * @param el element
+	 * @return Object
+	 */
+	function dataset( el ) {
+		if ( $(el)[0].dataset ) {
+			return $.extend({}, $(el)[0].dataset);
+		}
+		function toCamelcase( str ) {
+			str = str.split( '-' );
+			for( var i = 1; i < str.length; i++ ) {
+				str[i] = str[i].substr(0, 1).toUpperCase() + str[i].substr(1);
+			}
+			return str.join( '' );
+		}
+		var returnDataset = {};
+		var attrs = $(el)[0].attributes;
+		$.each(attrs, function ( idx, attr ) {
+			if ( attr.nodeName.substr(0, 5) === "data-" ) {
+				returnDataset[ toCamelcase(attr.nodeName.substr(5)) ] = attr.nodeValue;
+			}
+		});
+		return returnDataset;
+	}
+	/**
+	 * Returns true, if jmpress is initialized
+	 *
+	 * @return bool
+	 */
+	function initialized() {
+		return !!$(this).data("jmpressmethods");
+	}
+
+
+	/**
+	 * PUBLIC STATIC METHODS LIST
+	 */
+	var methods = {
+		init: init
+		,initialized: initialized
+		,deinit: function() {}
+		,css: css
+		,pfx: pfx
+		,defaults: getDefaults
+		,register: register
+		,dataset: dataset
+	};
+
+	/**
+	 * $.jmpress()
+	 */
+	$.fn.jmpress = function( method ) {
+		function f() {
+			var jmpressmethods = $(this).data("jmpressmethods");
+			if ( jmpressmethods && jmpressmethods[method] ) {
+				return jmpressmethods[method].apply( this, Array.prototype.slice.call( arguments, 1 ));
+			} else if ( methods[method] ) {
+				return methods[method].apply( this, Array.prototype.slice.call( arguments, 1 ));
+			} else if ( callbacks[method] && jmpressmethods ) {
+				var settings = jmpressmethods.settings();
+				var func = Array.prototype.slice.call( arguments, 1 )[0];
+				if ($.isFunction( func )) {
+					settings[method] = settings[method] || [];
+					settings[method].push(func);
+				}
+			} else if ( typeof method === 'object' || ! method ) {
+				return init.apply( this, arguments );
+			} else {
+				$.error( 'Method ' +  method + ' does not exist on jQuery.jmpress' );
+			}
+			// to allow chaining
+			return this;
+		}
+		var args = arguments;
+		var result;
+		$(this).each(function(idx, element) {
+			result = f.apply(element, args);
+		});
+		return result;
+	};
+	$.extend({
+		jmpress: function( method ) {
+			if ( methods[method] ) {
+				return methods[method].apply( this, Array.prototype.slice.call( arguments, 1 ));
+			} else if ( callbacks[method] ) {
+				// plugin interface
+				var func = Array.prototype.slice.call( arguments, 1 )[0];
+				if ($.isFunction( func )) {
+					defaults[method].push(func);
+				} else {
+					$.error( 'Second parameter should be a function: $.jmpress( callbackName, callbackFunction )' );
+				}
+			} else {
+				$.error( 'Method ' +  method + ' does not exist on jQuery.jmpress' );
+			}
+		}
+	});
+
+}(jQuery, document, window));
+
+/*
+ * near.js
+ * Find steps near each other
+ */
+(function( $, document, window, undefined ) {
+
+	'use strict';
+
+	// add near( selector, backwards = false) to jquery
+
+
+	function checkAndGo( elements, func, selector, backwards ) {
+		var next;
+		elements.each(function(idx, element) {
+			if(backwards) {
+				next = func(element, selector, backwards);
+				if (next) {
+					return false;
+				}
+			}
+			if( $(element).is(selector) ) {
+				next = element;
+				return false;
+			}
+			if(!backwards) {
+				next = func(element, selector, backwards);
+				if (next) {
+					return false;
+				}
+			}
+		});
+		return next;
+	}
+	function findNextInChildren(item, selector, backwards) {
+		var children = $(item).children();
+		if(backwards) {
+			children = $(children.get().reverse());
+		}
+		return checkAndGo( children, findNextInChildren, selector, backwards );
+	}
+	function findNextInSiblings(item, selector, backwards) {
+		return checkAndGo(
+			$(item)[backwards ? "prevAll" : "nextAll"](),
+			findNextInChildren, selector, backwards );
+	}
+	function findNextInParents(item, selector, backwards) {
+		var next;
+		var parents = $(item).parents();
+		parents = $(parents.get());
+		$.each(parents.get(), function(idx, element) {
+			if( backwards && $(element).is(selector) ) {
+				next = element;
+				return false;
+			}
+			next = findNextInSiblings(element, selector, backwards);
+			if(next) {
+				return false;
+			}
+		});
+		return next;
+	}
+
+	$.fn.near = function( selector, backwards ) {
+		var array = [];
+		$(this).each(function(idx, element) {
+			var near = (backwards ?
+					false :
+					findNextInChildren( element, selector, backwards )) ||
+				findNextInSiblings( element, selector, backwards ) ||
+				findNextInParents( element, selector, backwards );
+			if( near ) {
+				array.push(near);
+			}
+		});
+		return $(array);
+	};
+}(jQuery, document, window));
+/*
+ * transform.js
+ * The engine that powers the transforms or falls back to other methods
+ */
+(function( $, document, window, undefined ) {
+
+	'use strict';
+
+	/* FUNCTIONS */
+	function toCssNumber(number) {
+		return (Math.round(10000*number)/10000)+"";
+	}
+
+	/**
+	 * 3D and 2D engines
+	 */
+	var engines = {
+		3: {
+			transform: function( el, data, settings ) {
+				var transform = 'translate(-' + settings.originX + ',-' + settings.originY + ')';
+				$.each(data, function(idx, item) {
+					var coord = ["X", "Y", "Z"];
+					var i;
+					if(item[0] === "translate") { // ["translate", x, y, z]
+						transform += " translate3d(" + toCssNumber(item[1] || 0) + "px," + toCssNumber(item[2] || 0) + "px," + toCssNumber(item[3] || 0) + "px)";
+					} else if(item[0] === "rotate") {
+						var order = item[4] ? [1, 2, 3] : [3, 2, 1];
+						for(i = 0; i < 3; i++) {
+							transform += " rotate" + coord[order[i]-1] + "(" + toCssNumber(item[order[i]] || 0) + "deg)";
+						}
+					} else if(item[0] === "scale") {
+						for(i = 0; i < 3; i++) {
+							transform += " scale" + coord[i] + "(" + toCssNumber(item[i+1] || 1) + ")";
+						}
+					}
+				});
+				$.jmpress("css", el, $.extend({}, { transform: transform }));
+			}
+		}
+		,2: {
+			transform: function( el, data, settings ) {
+				var transform = 'translate(-' + settings.originX + ',-' + settings.originY + ')';
+				$.each(data, function(idx, item) {
+					var coord = ["X", "Y"];
+					if(item[0] === "translate") { // ["translate", x, y, z]
+						transform += " translate(" + toCssNumber(item[1] || 0) + "px," + toCssNumber(item[2] || 0) + "px)";
+					} else if(item[0] === "rotate") {
+						transform += " rotate(" + toCssNumber(item[3] || 0) + "deg)";
+					} else if(item[0] === "scale") {
+						for(var i = 0; i < 2; i++) {
+							transform += " scale" + coord[i] + "(" + toCssNumber(item[i+1] || 1) + ")";
+						}
+					}
+				});
+				$.jmpress("css", el, $.extend({}, { transform: transform }));
+			}
+		}
+	};
+
+	/**
+	 * Engine to power cross-browser translate, scale and rotate.
+	 */
+	var engine = (function() {
+		if ($.jmpress("pfx", "perspective")) {
+			return engines[3];
+		} else if ($.jmpress("pfx", "transform")) {
+			return engines[2];
+		}
+	}());
+
+	if(!engine) {
+		$.jmpress("checkNoSupport", function() {
+			return true;
+		});
+	}
+
+	var jmpressDefaults = $.jmpress("defaults");
+	jmpressDefaults.reasonableAnimation = {};
+	jmpressDefaults.originX = "50%";
+	jmpressDefaults.originY = "50%";
+	$.jmpress("initStep", function( step, eventData ) {
+		var data = eventData.data;
+		var stepData = eventData.stepData;
+		var pf = parseFloat;
+		$.extend(stepData, {
+			x: pf(data.x) || 0
+			,y: pf(data.y) || 0
+			,z: pf(data.z) || 0
+			,r: pf(data.r) || 0
+			,phi: pf(data.phi) || 0
+			,rotate: pf(data.rotate) || 0
+			,rotateX: pf(data.rotateX) || 0
+			,rotateY: pf(data.rotateY) || 0
+			,rotateZ: pf(data.rotateZ) || 0
+			,revertRotate: false
+			,scale: pf(data.scale) || 1
+			,scaleX: pf(data.scaleX) || false
+			,scaleY: pf(data.scaleY) || false
+			,scaleZ: pf(data.scaleZ) || 1
+		});
+	});
+	$.jmpress("beforeInit", function( nil, eventData ) {
+		$.jmpress("css", eventData.area, {
+			left: eventData.settings.originX,
+			top: eventData.settings.originY,
+			perspective: '1000px',
+		});
+	});
+	$.jmpress("afterInit", function( nil, eventData ) {
+		var stepSelector = eventData.settings.stepSelector,
+			current = eventData.current;
+		current.perspectiveScale = 1;
+		current.maxNestedDepth = 0;
+		var nestedSteps = $(eventData.jmpress).find(stepSelector).children(stepSelector);
+		while(nestedSteps.length) {
+			current.maxNestedDepth++;
+			nestedSteps = nestedSteps.children(stepSelector);
+		}
+	});
+	$.jmpress("applyStep", function( step, eventData ) {
+		$.jmpress("css", $(step), {
+			position: "absolute"
+			,transformStyle: "preserve-3d"
+		});
+		if ( eventData.parents.length > 0 ) {
+			$.jmpress("css", $(step), {
+				top: "50%"
+				,left: "50%"
+			});
+		}
+		var sd = eventData.stepData;
+		var transform = [
+			["translate",
+				sd.x || (sd.r * Math.sin(sd.phi*Math.PI/180)),
+				sd.y || (-sd.r * Math.cos(sd.phi*Math.PI/180)),
+				sd.z],
+			["rotate",
+				sd.rotateX,
+				sd.rotateY,
+				sd.rotateZ || sd.rotate,
+				true],
+			["scale",
+				sd.scaleX || sd.scale,
+				sd.scaleY || sd.scale,
+				sd.scaleZ || sd.scale]
+		];
+		engine.transform( step, transform, eventData.settings );
+	});
+	$.jmpress("setActive", function( element, eventData ) {
+		var target = eventData.target;
+		var step = eventData.stepData;
+		var tf = target.transform = [];
+		target.perspectiveScale = 1;
+
+		for(var i = eventData.current.maxNestedDepth; i > (eventData.parents.length || 0); i--) {
+			tf.push(["scale"], ["rotate"], ["translate"]);
+		}
+
+		tf.push(["scale",
+			1 / (step.scaleX || step.scale),
+			1 / (step.scaleY || step.scale),
+			1 / (step.scaleZ)]);
+		tf.push(["rotate",
+			-step.rotateX,
+			-step.rotateY,
+			-(step.rotateZ || step.rotate)]);
+		tf.push(["translate",
+			-(step.x || (step.r * Math.sin(step.phi*Math.PI/180))),
+			-(step.y || (-step.r * Math.cos(step.phi*Math.PI/180))),
+			-step.z]);
+		target.perspectiveScale *= (step.scaleX || step.scale);
+
+		$.each(eventData.parents, function(idx, element) {
+			var step = $(element).data("stepData");
+			tf.push(["scale",
+				1 / (step.scaleX || step.scale),
+				1 / (step.scaleY || step.scale),
+				1 / (step.scaleZ)]);
+			tf.push(["rotate",
+				-step.rotateX,
+				-step.rotateY,
+				-(step.rotateZ || step.rotate)]);
+			tf.push(["translate",
+				-(step.x || (step.r * Math.sin(step.phi*Math.PI/180))),
+				-(step.y || (-step.r * Math.cos(step.phi*Math.PI/180))),
+				-step.z]);
+			target.perspectiveScale *= (step.scaleX || step.scale);
+		});
+
+		$.each(tf, function(idx, item) {
+			if(item[0] !== "rotate") {
+				return;
+			}
+			function lowRotate(name) {
+				if(eventData.current["rotate"+name+"-"+idx] === undefined) {
+					eventData.current["rotate"+name+"-"+idx] = item[name] || 0;
+				}
+				var cur = eventData.current["rotate"+name+"-"+idx], tar = item[name] || 0,
+					curmod = cur % 360, tarmod = tar % 360;
+				if(curmod < 0) {
+					curmod += 360;
+				}
+				if(tarmod < 0) {
+					tarmod += 360;
+				}
+				var diff = tarmod - curmod;
+				if(diff < -180) {
+					diff += 360;
+				} else if(diff > 180) {
+					diff -= 360;
+				}
+				eventData.current["rotate"+name+"-"+idx] = item[name] = cur + diff;
+			}
+			lowRotate(1);
+			lowRotate(2);
+			lowRotate(3);
+		});
+	});
+	$.jmpress("applyTarget", function( active, eventData ) {
+
+		var target = eventData.target,
+			props, step = eventData.stepData,
+			settings = eventData.settings,
+			zoomin = target.perspectiveScale * 1.3 < eventData.current.perspectiveScale,
+			zoomout = target.perspectiveScale > eventData.current.perspectiveScale * 1.3;
+
+		// extract first scale from transform
+		var lastScale = -1;
+		$.each(target.transform, function(idx, item) {
+			if(item.length <= 1) {
+				return;
+			}
+			if(item[0] === "rotate" &&
+				item[1] % 360 === 0  &&
+				item[2] % 360 === 0  &&
+				item[3] % 360 === 0) {
+				return;
+			}
+			if(item[0] === "scale") {
+				lastScale = idx;
+			} else {
+				return false;
+			}
+		});
+
+		if(lastScale !== eventData.current.oldLastScale) {
+			zoomin = zoomout = false;
+			eventData.current.oldLastScale = lastScale;
+		}
+
+		var extracted = [];
+		if(lastScale !== -1) {
+			while(lastScale >= 0) {
+				if(target.transform[lastScale][0] === "scale") {
+					extracted.push(target.transform[lastScale]);
+					target.transform[lastScale] = ["scale"];
+				}
+				lastScale--;
+			}
+		}
+
+		var animation = settings.animation;
+		if(settings.reasonableAnimation[eventData.reason]) {
+			animation = $.extend({},
+				animation,
+				settings.reasonableAnimation[eventData.reason]);
+		}
+
+		props = {
+			// to keep the perspective look similar for different scales
+			// we need to 'scale' the perspective, too
+			perspective: Math.round(target.perspectiveScale * 1000) + "px"
+		};
+		props = $.extend({}, animation, props);
+		if (!zoomin) {
+			props.transitionDelay = '0s';
+		}
+		if (!eventData.beforeActive) {
+			props.transitionDuration = '0s';
+			props.transitionDelay = '0s';
+		}
+		$.jmpress("css", eventData.area, props);
+		engine.transform(eventData.area, extracted, eventData.settings);
+
+		props = $.extend({}, animation);
+		if (!zoomout) {
+			props.transitionDelay = '0s';
+		}
+		if (!eventData.beforeActive) {
+			props.transitionDuration = '0s';
+			props.transitionDelay = '0s';
+		}
+
+		eventData.current.perspectiveScale = target.perspectiveScale;
+
+		$.jmpress("css", eventData.canvas, props);
+		engine.transform(eventData.canvas, target.transform, eventData.settings);
+	});
+
+}(jQuery, document, window));
+/*
+ * circular.js
+ * Repeat from start after end
+ */
+(function( $, document, window, undefined ) {
+
+	'use strict';
+	var $jmpress = $.jmpress;
+
+	/* FUNCTIONS */
+	function firstSlide( step, eventData ) {
+		return $(this).find(eventData.settings.stepSelector).first();
+	}
+	function prevOrNext( jmpress, step, eventData, prev) {
+		if (!step) {
+			return false;
+		}
+		var stepSelector = eventData.settings.stepSelector;
+		step = $(step);
+		do {
+			var item = step.near( stepSelector, prev );
+			if (item.length === 0 || item.closest(jmpress).length === 0) {
+				item = $(jmpress).find(stepSelector)[prev?"last":"first"]();
+			}
+			if (!item.length) {
+				return false;
+			}
+			step = item;
+		} while( step.data("stepData").exclude );
+		return step;
+	}
+
+	/* HOOKS */
+	$jmpress( 'initStep', function( step, eventData ) {
+		eventData.stepData.exclude = eventData.data.exclude && ["false", "no"].indexOf(eventData.data.exclude) === -1;
+	});
+	$jmpress( 'selectInitialStep', firstSlide);
+	$jmpress( 'selectHome', firstSlide);
+	$jmpress( 'selectEnd', function( step, eventData ) {
+		return $(this).find(eventData.settings.stepSelector).last();
+	});
+	$jmpress( 'selectPrev', function( step, eventData ) {
+		return prevOrNext(this, step, eventData, true);
+	});
+	$jmpress( 'selectNext', function( step, eventData ) {
+		return prevOrNext(this, step, eventData);
+	});
+}(jQuery, document, window));
+/*
+ * start.js
+ * Set the first step to start on
+ */
+(function( $, document, window, undefined ) {
+
+	'use strict';
+
+	/* HOOKS */
+	$.jmpress( 'selectInitialStep', function( nil, eventData ) {
+		return eventData.settings.start;
+	});
+
+}(jQuery, document, window));
+/*
+ * ways.js
+ * Control the flow of the steps
+ */
+(function( $, document, window, undefined ) {
+
+	'use strict';
+	var $jmpress = $.jmpress;
+
+	/* FUNCTIONS */
+	function routeFunc( jmpress, route, type ) {
+		for(var i = 0; i < route.length - 1; i++) {
+			var from = route[i];
+			var to = route[i+1];
+			if($(jmpress).jmpress("initialized")) {
+				$(from, jmpress).data("stepData")[type] = to;
+			} else {
+				$(from, jmpress).attr('data-' + type, to);
+			}
+		}
+	}
+	function selectPrevOrNext( step, eventData, attr, prev ) {
+		var stepData = eventData.stepData;
+		if(stepData[attr]) {
+			var near = $(step).near(stepData[attr], prev);
+			if(near && near.length) {
+				return near;
+			}
+			near = $(stepData[attr], this)[prev?"last":"first"]();
+			if(near && near.length) {
+				return near;
+			}
+		}
+	}
+
+	/* EXPORTED FUNCTIONS */
+	$jmpress( 'register', 'route', function( route, unidirectional, reversedRoute ) {
+		if( typeof route === "string" ) {
+			route = [route, route];
+		}
+		routeFunc(this, route, reversedRoute ? "prev" : "next");
+		if (!unidirectional) {
+			routeFunc(this, route.reverse(), reversedRoute ? "next" : "prev");
+		}
+	});
+
+	/* HOOKS */
+	$jmpress( 'initStep', function( step, eventData ) {
+		for(var attr in {next:1,prev:1}) {
+			eventData.stepData[attr] = eventData.data[attr];
+		}
+	});
+	$jmpress( 'selectNext', function( step, eventData ) {
+		return selectPrevOrNext.call(this, step, eventData, "next");
+	});
+	$jmpress( 'selectPrev', function( step, eventData ) {
+		return selectPrevOrNext.call(this, step, eventData, "prev", true);
+	});
+
+}(jQuery, document, window));
+/*
+ * ajax.js
+ * Load steps via ajax
+ */
+(function( $, document, window, undefined ) {
+
+	'use strict';
+	var $jmpress = $.jmpress;
+
+	/* DEFINES */
+	var afterStepLoaded = 'ajax:afterStepLoaded',
+		loadStep = 'ajax:loadStep';
+
+	/* REGISTER EVENTS */
+	$jmpress('register', loadStep);
+	$jmpress('register', afterStepLoaded);
+
+	/* DEFAULTS */
+	$jmpress('defaults').ajaxLoadedClass = "loaded";
+
+	/* HOOKS */
+	$jmpress('initStep', function( step, eventData ) {
+		eventData.stepData.src = $(step).attr('href') || eventData.data.src || false;
+		eventData.stepData.srcLoaded = false;
+	});
+	$jmpress(loadStep, function( step, eventData ) {
+		var stepData = eventData.stepData,
+			href = stepData && stepData.src,
+			settings = eventData.settings;
+		if ( href ) {
+			$(step).addClass( settings.ajaxLoadedClass );
+			stepData.srcLoaded = true;
+			$(step).load(href, function(response, status, xhr) {
+				$(eventData.jmpress).jmpress('fire', afterStepLoaded, step, $.extend({}, eventData, {
+					response: response
+					,status: status
+					,xhr: xhr
+				}));
+			});
+		}
+	});
+	$jmpress('idle', function( step, eventData ) {
+		if (!step) {
+			return;
+		}
+		var settings = eventData.settings,
+			jmpress = $(this),
+			stepData = eventData.stepData;
+		var siblings = $(step)
+			.add( $(step).near( settings.stepSelector ) )
+			.add( $(step).near( settings.stepSelector, true) )
+			.add( jmpress.jmpress('fire', 'selectPrev', step, {
+				stepData: $(step).data('stepData')
+			}))
+			.add( jmpress.jmpress('fire', 'selectNext', step, {
+				stepData: $(step).data('stepData')
+			}));
+		siblings.each(function() {
+			var step = this,
+				stepData = $(step).data("stepData");
+			if(!stepData.src || stepData.srcLoaded) {
+				return;
+			}
+			jmpress.jmpress('fire', loadStep, step, {
+				stepData: $(step).data('stepData')
+			});
+		});
+	});
+	$jmpress("setActive", function(step, eventData) {
+		var stepData = $(step).data("stepData");
+		if(!stepData.src || stepData.srcLoaded) {
+			return;
+		}
+		$(this).jmpress('fire', loadStep, step, {
+			stepData: $(step).data('stepData')
+		});
+	});
+
+}(jQuery, document, window));
+/*
+ * hash.js
+ * Detect and set the URL hash
+ */
+(function( $, document, window, undefined ) {
+
+	'use strict';
+	var $jmpress = $.jmpress,
+		hashLink = "a[href^=#]";
+
+	/* FUNCTIONS */
+	function randomString() {
+		return "" + Math.round(Math.random() * 100000, 0);
+	}
+	/**
+	 * getElementFromUrl
+	 *
+	 * @return String or undefined
+	 */
+	function getElementFromUrl(settings) {
+		// get id from url # by removing `#` or `#/` from the beginning,
+		// so both "fallback" `#slide-id` and "enhanced" `#/slide-id` will work
+		// TODO SECURITY check user input to be valid!
+		try {
+			var el = $( '#' + window.location.hash.replace(/^#\/?/,"") );
+			return el.length > 0 && el.is(settings.stepSelector) ? el : undefined;
+		} catch(e) {}
+	}
+	function setHash(stepid) {
+		var shouldBeHash = "#/" + stepid;
+		if(window.history && window.history.pushState) {
+			// shouldBeHash = "#" + stepid;
+			// consider this for future versions
+			//  it has currently issues, when startup with a link with hash (webkit)
+			if(window.location.hash !== shouldBeHash) {
+				window.history.pushState({}, '', shouldBeHash);
+			}
+		} else {
+			if(window.location.hash !== shouldBeHash) {
+				window.location.hash = shouldBeHash;
+			}
+		}
+	}
+
+	/* DEFAULTS */
+	$jmpress('defaults').hash = {
+		use: true
+		,update: true
+		,bindChange: true
+		// NOTICE: {use: true, update: false, bindChange: true}
+		// will cause a error after clicking on a link to the current step
+	};
+
+	/* HOOKS */
+	$jmpress('selectInitialStep', function( step, eventData ) {
+		var settings = eventData.settings,
+			hashSettings = settings.hash,
+			current = eventData.current,
+			jmpress = $(this);
+		eventData.current.hashNamespace = ".jmpress-"+randomString();
+		// HASH CHANGE EVENT
+		if ( hashSettings.use ) {
+			if ( hashSettings.bindChange ) {
+				$(window).bind('hashchange'+current.hashNamespace, function(event) {
+					var urlItem = getElementFromUrl(settings);
+					if ( jmpress.jmpress('initialized') ) {
+						jmpress.jmpress("scrollFix");
+					}
+					if(urlItem && urlItem.length) {
+						if(urlItem.attr("id") !== jmpress.jmpress("active").attr("id")) {
+							jmpress.jmpress('select', urlItem);
+						}
+						setHash(urlItem.attr("id"));
+					}
+					event.preventDefault();
+				});
+				$(hashLink).on("click"+current.hashNamespace, function(event) {
+					var href = $(this).attr("href");
+					try {
+						if($(href).is(settings.stepSelector)) {
+							jmpress.jmpress("select", href);
+							event.preventDefault();
+							event.stopPropagation();
+						}
+					} catch(e) {}
+				});
+			}
+			return getElementFromUrl(settings);
+		}
+	});
+	$jmpress('afterDeinit', function( nil, eventData ) {
+		$(hashLink).off(eventData.current.hashNamespace);
+		$(window).unbind(eventData.current.hashNamespace);
+	});
+	$jmpress('setActive', function( step, eventData ) {
+		var settings = eventData.settings,
+			current = eventData.current;
+		// `#/step-id` is used instead of `#step-id` to prevent default browser
+		// scrolling to element in hash
+		if ( settings.hash.use && settings.hash.update ) {
+			clearTimeout(current.hashtimeout);
+			current.hashtimeout = setTimeout(function() {
+				setHash($(eventData.delegatedFrom).attr('id'));
+			}, settings.transitionDuration + 200);
+		}
+	});
+
+}(jQuery, document, window));
+/*
+ * keyboard.js
+ * Keyboard event mapping and default keyboard actions
+ */
+(function( $, document, window, undefined ) {
+
+	'use strict';
+	var $jmpress = $.jmpress,
+		jmpressNext = "next",
+		jmpressPrev = "prev";
+
+	/* FUNCTIONS */
+	function randomString() {
+		return "" + Math.round(Math.random() * 100000, 0);
+	}
+	function stopEvent(event) {
+		event.preventDefault();
+		event.stopPropagation();
+	}
+
+	/* DEFAULTS */
+	$jmpress('defaults').keyboard = {
+		use: true
+		,keys: {
+			33: jmpressPrev // pg up
+			,37: jmpressPrev // left
+			,38: jmpressPrev // up
+
+			,9: jmpressNext+":"+jmpressPrev // tab
+			,32: jmpressNext // space
+			,34: jmpressNext // pg down
+			,39: jmpressNext // right
+			,40: jmpressNext // down
+
+			,36: "home" // home
+
+			,35: "end" // end
+		}
+		,ignore: {
+			"INPUT": [
+				32 // space
+				,37 // left
+				,38 // up
+				,39 // right
+				,40 // down
+			]
+			,"TEXTAREA": [
+				32 // space
+				,37 // left
+				,38 // up
+				,39 // right
+				,40 // down
+			]
+			,"SELECT": [
+				38 // up
+				,40 // down
+			]
+		}
+		,tabSelector: "a[href]:visible, :input:visible"
+	};
+
+	/* HOOKS */
+	$jmpress('afterInit', function( nil, eventData ) {
+		var settings = eventData.settings,
+			keyboardSettings = settings.keyboard,
+			ignoreKeyboardSettings = keyboardSettings.ignore,
+			current = eventData.current,
+			jmpress = $(this);
+
+		// tabindex make it focusable so that it can recieve key events
+		if(!settings.fullscreen) {
+			jmpress.attr("tabindex", 0);
+		}
+
+		current.keyboardNamespace = ".jmpress-"+randomString();
+
+		// KEYPRESS EVENT: this fixes a Opera bug
+		$(settings.fullscreen ? document : jmpress)
+			.bind("keypress"+current.keyboardNamespace, function( event ) {
+
+			for( var nodeName in ignoreKeyboardSettings ) {
+				if ( event.target.nodeName === nodeName && ignoreKeyboardSettings[nodeName].indexOf(event.which) !== -1 ) {
+					return;
+				}
+			}
+			if(event.which >= 37 && event.which <= 40 || event.which === 32) {
+				stopEvent(event);
+			}
+		});
+		// KEYDOWN EVENT
+		$(settings.fullscreen ? document : jmpress)
+			.bind("keydown"+current.keyboardNamespace, function( event ) {
+			var eventTarget = $(event.target);
+
+			if ( !settings.fullscreen && !eventTarget.closest(jmpress).length || !keyboardSettings.use ) {
+				return;
+			}
+
+			for( var nodeName in ignoreKeyboardSettings ) {
+				if ( eventTarget[0].nodeName === nodeName && ignoreKeyboardSettings[nodeName].indexOf(event.which) !== -1 ) {
+					return;
+				}
+			}
+
+			var reverseSelect = false;
+			var nextFocus;
+			if (event.which === 9) {
+				// tab
+				if ( !eventTarget.closest( jmpress.jmpress('active') ).length ) {
+					if ( !event.shiftKey ) {
+						nextFocus = jmpress.jmpress('active').find("a[href], :input").filter(":visible").first();
+					} else {
+						reverseSelect = true;
+					}
+				} else {
+					nextFocus = eventTarget.near( keyboardSettings.tabSelector, event.shiftKey );
+					if( !$(nextFocus)
+						.closest( settings.stepSelector )
+						.is(jmpress.jmpress('active') ) ) {
+						nextFocus = undefined;
+					}
+				}
+				if( nextFocus && nextFocus.length > 0 ) {
+					nextFocus.focus();
+					jmpress.jmpress("scrollFix");
+					stopEvent(event);
+					return;
+				} else {
+					if(event.shiftKey) {
+						reverseSelect = true;
+					}
+				}
+			}
+
+			var action = keyboardSettings.keys[ event.which ];
+			if ( typeof action === "string" ) {
+				if (action.indexOf(":") !== -1) {
+					action = action.split(":");
+					action = event.shiftKey ? action[1] : action[0];
+				}
+				jmpress.jmpress( action );
+				stopEvent(event);
+			} else if ( $.isFunction(action) ) {
+				action.call(jmpress, event);
+			} else if ( action ) {
+				jmpress.jmpress.apply( jmpress, action );
+				stopEvent(event);
+			}
+
+			if (reverseSelect) {
+				// tab
+				nextFocus = jmpress.jmpress('active').find("a[href], :input").filter(":visible").last();
+				nextFocus.focus();
+				jmpress.jmpress("scrollFix");
+			}
+		});
+	});
+	$jmpress('afterDeinit', function( nil, eventData ) {
+		$(document).unbind(eventData.current.keyboardNamespace);
+	});
+
+
+}(jQuery, document, window));
+/*
+ * viewport.js
+ * Scale to fit a given viewport
+ */
+(function( $, document, window, undefined ) {
+
+	'use strict';
+
+	function randomString() {
+		return "" + Math.round(Math.random() * 100000, 0);
+	}
+
+	var browser = (function() {
+		var ua = navigator.userAgent.toLowerCase();
+		var match = /(chrome)[ \/]([\w.]+)/.exec(ua) ||
+			/(webkit)[ \/]([\w.]+)/.exec(ua) ||
+			/(opera)(?:.*version|)[ \/]([\w.]+)/.exec(ua) ||
+			/(msie) ([\w.]+)/.exec(ua) ||
+			ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(ua) ||
+			[];
+		return match[1] || "";
+	}());
+
+	var defaults = $.jmpress("defaults");
+	defaults.viewPort = {
+		width: false
+		,height: false
+		,maxScale: 0
+		,minScale: 0
+		,zoomable: 0
+		,zoomBindMove: true
+		,zoomBindWheel: true
+	};
+	var keys = defaults.keyboard.keys;
+	keys[browser === 'mozilla' ? 107 : 187] = "zoomIn";  // +
+	keys[browser === 'mozilla' ? 109 : 189] = "zoomOut"; // -
+	defaults.reasonableAnimation.resize = {
+		transitionDuration: '0s'
+		,transitionDelay: '0ms'
+	};
+	defaults.reasonableAnimation.zoom = {
+		transitionDuration: '0s'
+		,transitionDelay: '0ms'
+	};
+	$.jmpress("initStep", function( step, eventData ) {
+		for(var variable in {"viewPortHeight":1, "viewPortWidth":1, "viewPortMinScale":1, "viewPortMaxScale":1, "viewPortZoomable":1}) {
+			eventData.stepData[variable] = eventData.data[variable] && parseFloat(eventData.data[variable]);
+		}
+	});
+	$.jmpress("afterInit", function( nil, eventData ) {
+		var jmpress = this;
+		eventData.current.viewPortNamespace = ".jmpress-"+randomString();
+		$(window).bind("resize"+eventData.current.viewPortNamespace, function (event) {
+			$(jmpress).jmpress("reselect", "resize");
+		});
+		eventData.current.userZoom = 0;
+		eventData.current.userTranslateX = 0;
+		eventData.current.userTranslateY = 0;
+		if(eventData.settings.viewPort.zoomBindWheel) {
+			$(eventData.settings.fullscreen ? document : this)
+				.bind("mousewheel"+eventData.current.viewPortNamespace+" DOMMouseScroll"+eventData.current.viewPortNamespace, function( event, delta ) {
+				delta = delta || event.originalEvent.wheelDelta || -event.originalEvent.detail /* mozilla */;
+				var direction = (delta / Math.abs(delta));
+				if(direction < 0) {
+					$(eventData.jmpress).jmpress("zoomOut", event.originalEvent.clientX, event.originalEvent.clientY);
+				} else if(direction > 0) {
+					$(eventData.jmpress).jmpress("zoomIn", event.originalEvent.clientX, event.originalEvent.clientY);
+				}
+				return false;
+			});
+		}
+		if(eventData.settings.viewPort.zoomBindMove) {
+			$(eventData.settings.fullscreen ? document : this).bind("mousedown"+eventData.current.viewPortNamespace, function (event) {
+				if(eventData.current.userZoom) {
+					eventData.current.userTranslating = { x: event.clientX, y: event.clientY };
+					event.preventDefault();
+					event.stopImmediatePropagation();
+				}
+			}).bind("mousemove"+eventData.current.viewPortNamespace, function (event) {
+				var userTranslating = eventData.current.userTranslating;
+				if(userTranslating) {
+					$(jmpress).jmpress("zoomTranslate", event.clientX - userTranslating.x, event.clientY - userTranslating.y);
+					userTranslating.x = event.clientX;
+					userTranslating.y = event.clientY;
+					event.preventDefault();
+					event.stopImmediatePropagation();
+				}
+			}).bind("mouseup"+eventData.current.viewPortNamespace, function (event) {
+				if(eventData.current.userTranslating) {
+					eventData.current.userTranslating = undefined;
+					event.preventDefault();
+					event.stopImmediatePropagation();
+				}
+			});
+		}
+	});
+	function maxAbs(value, range) {
+		return Math.max(Math.min(value, range), -range);
+	}
+	function zoom(x, y, direction) {
+		var current = $(this).jmpress("current"),
+			settings = $(this).jmpress("settings"),
+			stepData = $(this).jmpress("active").data("stepData"),
+			container = $(this).jmpress("container");
+		if(current.userZoom === 0 && direction < 0) {
+			return;
+		}
+		var zoomableSteps = stepData.viewPortZoomable || settings.viewPort.zoomable;
+		if(current.userZoom === zoomableSteps && direction > 0) {
+			return;
+		}
+		current.userZoom += direction;
+
+		var halfWidth = $(container).innerWidth()/2,
+			halfHeight = $(container).innerHeight()/2;
+
+		x = x ? x - halfWidth : x;
+		y = y ? y - halfHeight : y;
+
+		// TODO this is not perfect... too much math... :(
+		current.userTranslateX =
+			maxAbs(current.userTranslateX - direction * x / current.zoomOriginWindowScale / zoomableSteps,
+			halfWidth * current.userZoom * current.userZoom / zoomableSteps);
+		current.userTranslateY =
+			maxAbs(current.userTranslateY - direction * y / current.zoomOriginWindowScale / zoomableSteps,
+			halfHeight * current.userZoom * current.userZoom / zoomableSteps);
+
+		$(this).jmpress("reselect", "zoom");
+	}
+	$.jmpress("register", "zoomIn", function(x, y) {
+		zoom.call(this, x||0, y||0, 1);
+	});
+	$.jmpress("register", "zoomOut", function(x, y) {
+		zoom.call(this, x||0, y||0, -1);
+	});
+	$.jmpress("register", "zoomTranslate", function(x, y) {
+		var current = $(this).jmpress("current"),
+			settings = $(this).jmpress("settings"),
+			stepData = $(this).jmpress("active").data("stepData"),
+			container = $(this).jmpress("container");
+		var zoomableSteps = stepData.viewPortZoomable || settings.viewPort.zoomable;
+		var halfWidth = $(container).innerWidth(),
+			halfHeight = $(container).innerHeight();
+		current.userTranslateX =
+			maxAbs(current.userTranslateX + x / current.zoomOriginWindowScale,
+			halfWidth * current.userZoom * current.userZoom / zoomableSteps);
+		current.userTranslateY =
+			maxAbs(current.userTranslateY + y / current.zoomOriginWindowScale,
+			halfHeight * current.userZoom * current.userZoom / zoomableSteps);
+		$(this).jmpress("reselect", "zoom");
+	});
+	$.jmpress('afterDeinit', function( nil, eventData ) {
+		$(eventData.settings.fullscreen ? document : this).unbind(eventData.current.viewPortNamespace);
+		$(window).unbind(eventData.current.viewPortNamespace);
+	});
+	$.jmpress("setActive", function( step, eventData ) {
+		var viewPort = eventData.settings.viewPort;
+		var viewPortHeight = eventData.stepData.viewPortHeight || viewPort.height;
+		var viewPortWidth = eventData.stepData.viewPortWidth || viewPort.width;
+		var viewPortMaxScale = eventData.stepData.viewPortMaxScale || viewPort.maxScale;
+		var viewPortMinScale = eventData.stepData.viewPortMinScale || viewPort.minScale;
+		// Correct the scale based on the window's size
+		var windowScaleY = viewPortHeight && $(eventData.container).innerHeight()/viewPortHeight;
+		var windowScaleX = viewPortWidth && $(eventData.container).innerWidth()/viewPortWidth;
+		var windowScale = (windowScaleX || windowScaleY) && Math.min( windowScaleX || windowScaleY, windowScaleY || windowScaleX );
+
+		if(windowScale) {
+			windowScale = windowScale || 1;
+			if(viewPortMaxScale) {
+				windowScale = Math.min(windowScale, viewPortMaxScale);
+			}
+			if(viewPortMinScale) {
+				windowScale = Math.max(windowScale, viewPortMinScale);
+			}
+
+			var zoomableSteps = eventData.stepData.viewPortZoomable || eventData.settings.viewPort.zoomable;
+			if(zoomableSteps) {
+				var diff = (1/windowScale) - (1/viewPortMaxScale);
+				diff /= zoomableSteps;
+				windowScale = 1/((1/windowScale) - diff * eventData.current.userZoom);
+			}
+
+			eventData.target.transform.reverse();
+			if(eventData.current.userTranslateX && eventData.current.userTranslateY) {
+				eventData.target.transform.push(["translate", eventData.current.userTranslateX, eventData.current.userTranslateY, 0]);
+			} else {
+				eventData.target.transform.push(["translate"]);
+			}
+			eventData.target.transform.push(["scale",
+				windowScale,
+				windowScale,
+				1]);
+			eventData.target.transform.reverse();
+			eventData.target.perspectiveScale /= windowScale;
+		}
+		eventData.current.zoomOriginWindowScale = windowScale;
+	});
+	$.jmpress("setInactive", function( step, eventData ) {
+		if(!eventData.nextStep || !step || $(eventData.nextStep).attr("id") !== $(step).attr("id")) {
+			eventData.current.userZoom = 0;
+			eventData.current.userTranslateX = 0;
+			eventData.current.userTranslateY = 0;
+		}
+	});
+
+}(jQuery, document, window));
+
+/*
+ * mouse.js
+ * Clicking to select a step
+ */
+(function( $, document, window, undefined ) {
+
+	'use strict';
+	var $jmpress = $.jmpress;
+
+	/* FUNCTIONS */
+	function randomString() {
+		return "" + Math.round(Math.random() * 100000, 0);
+	}
+
+	/* DEFAULTS */
+	$jmpress("defaults").mouse = {
+		clickSelects: true
+	};
+
+	/* HOOKS */
+	$jmpress("afterInit", function( nil, eventData ) {
+		var settings = eventData.settings,
+			stepSelector = settings.stepSelector,
+			current = eventData.current,
+			jmpress = $(this);
+		current.clickableStepsNamespace = ".jmpress-"+randomString();
+		jmpress.bind("click"+current.clickableStepsNamespace, function(event) {
+			if (!settings.mouse.clickSelects || current.userZoom) {
+				return;
+			}
+
+			// get clicked step
+			var clickedStep = $(event.target).closest(stepSelector);
+
+			// clicks on the active step do default
+			if ( clickedStep.is( jmpress.jmpress("active") ) ) {
+				return;
+			}
+
+			if (clickedStep.length) {
+				// select the clicked step
+				jmpress.jmpress("select", clickedStep[0], "click");
+				event.preventDefault();
+				event.stopPropagation();
+			}
+		});
+	});
+	$jmpress('afterDeinit', function( nil, eventData ) {
+		$(this).unbind(eventData.current.clickableStepsNamespace);
+	});
+
+}(jQuery, document, window));
+/*
+ * mobile.js
+ * Adds support for swipe on touch supported browsers
+ */
+(function( $, document, window, undefined ) {
+
+	'use strict';
+	var $jmpress = $.jmpress;
+
+	/* FUNCTIONS */
+	function randomString() {
+		return "" + Math.round(Math.random() * 100000, 0);
+	}
+
+	/* HOOKS */
+	$jmpress( 'afterInit', function( step, eventData ) {
+		var settings = eventData.settings,
+			current = eventData.current,
+			jmpress = eventData.jmpress;
+		current.mobileNamespace = ".jmpress-"+randomString();
+		var data, start = [0,0];
+		$(settings.fullscreen ? document : jmpress)
+			.bind("touchstart"+current.mobileNamespace, function( event ) {
+
+			data = event.originalEvent.touches[0];
+			start = [ data.pageX, data.pageY ];
+
+		}).bind("touchmove"+current.mobileNamespace, function( event ) {
+			data = event.originalEvent.touches[0];
+			event.preventDefault();
+			return false;
+		}).bind("touchend"+current.mobileNamespace, function( event ) {
+			var end = [ data.pageX, data.pageY ],
+				diff = [ end[0]-start[0], end[1]-start[1] ];
+
+			if(Math.max(Math.abs(diff[0]), Math.abs(diff[1])) > 50) {
+				diff = Math.abs(diff[0]) > Math.abs(diff[1]) ? diff[0] : diff[1];
+				$(jmpress).jmpress(diff > 0 ? "prev" : "next");
+				event.preventDefault();
+				return false;
+			}
+		});
+	});
+	$jmpress('afterDeinit', function( nil, eventData ) {
+		var settings = eventData.settings,
+			current = eventData.current,
+			jmpress = eventData.jmpress;
+		$(settings.fullscreen ? document : jmpress).unbind(current.mobileNamespace);
+	});
+
+}(jQuery, document, window));
+/*
+ * templates.js
+ * The amazing template engine
+ */
+(function( $, document, window, undefined ) {
+
+	'use strict';
+	var $jmpress = $.jmpress,
+		templateFromParentIdent = "_template_",
+		templateFromApplyIdent = "_applied_template_";
+
+	/* STATIC VARS */
+	var templates = {};
+
+	/* FUNCTIONS */
+	function addUndefined( target, values, prefix ) {
+		for( var name in values ) {
+			var targetName = name;
+			if ( prefix ) {
+				targetName = prefix + targetName.substr(0, 1).toUpperCase() + targetName.substr(1);
+			}
+			if ( $.isPlainObject(values[name]) ) {
+				addUndefined( target, values[name], targetName );
+			} else if( target[targetName] === undefined ) {
+				target[targetName] = values[name];
+			}
+		}
+	}
+	function applyChildrenTemplates( children, templateChildren ) {
+		if ($.isArray(templateChildren)) {
+			if (templateChildren.length < children.length) {
+				$.error("more nested steps than children in template");
+			} else {
+				children.each(function(idx, child) {
+					child = $(child);
+					var tmpl = child.data(templateFromParentIdent) || {};
+					addUndefined(tmpl, templateChildren[idx]);
+					child.data(templateFromParentIdent, tmpl);
+				});
+			}
+		} else if($.isFunction(templateChildren)) {
+			children.each(function(idx, child) {
+				child = $(child);
+				var tmpl = child.data(templateFromParentIdent) || {};
+				addUndefined(tmpl, templateChildren(idx, child, children));
+				child.data(templateFromParentIdent, tmpl);
+			});
+		} // TODO: else if(object)
+	}
+	function applyTemplate( data, element, template, eventData ) {
+		if (template.children) {
+			var children = element.children( eventData.settings.stepSelector );
+			applyChildrenTemplates( children, template.children );
+		}
+		applyTemplateData( data, template );
+	}
+	function applyTemplateData( data, template ) {
+		addUndefined(data, template);
+	}
+
+	/* HOOKS */
+	$jmpress("beforeInitStep", function( step, eventData ) {
+		step = $(step);
+		var data = eventData.data,
+			templateFromAttr = data.template,
+			templateFromApply = step.data(templateFromApplyIdent),
+			templateFromParent = step.data(templateFromParentIdent);
+		if(templateFromAttr) {
+			$.each(templateFromAttr.split(" "), function(idx, tmpl) {
+				var template = templates[tmpl];
+				applyTemplate( data, step, template, eventData );
+			});
+		}
+		if (templateFromApply) {
+			applyTemplate( data, step, templateFromApply, eventData );
+		}
+		if (templateFromParent) {
+			applyTemplate( data, step, templateFromParent, eventData );
+			step.data(templateFromParentIdent, null);
+			if(templateFromParent.template) {
+				$.each(templateFromParent.template.split(" "), function(idx, tmpl) {
+					var template = templates[tmpl];
+					applyTemplate( data, step, template, eventData );
+				});
+			}
+		}
+	});
+	$jmpress("beforeInit", function( nil, eventData ) {
+		var data = $jmpress("dataset", this),
+			dataTemplate = data.template,
+			stepSelector = eventData.settings.stepSelector;
+		if (dataTemplate) {
+			var template = templates[dataTemplate];
+			applyChildrenTemplates( $(this).find(stepSelector).filter(function() {
+				return !$(this).parent().is(stepSelector);
+			}), template.children );
+		}
+	});
+
+	/* EXPORTED FUNCTIONS */
+	$jmpress("register", "template", function( name, tmpl ) {
+		if (templates[name]) {
+			templates[name] = $.extend(true, {}, templates[name], tmpl);
+		} else {
+			templates[name] = $.extend(true, {}, tmpl);
+		}
+	});
+	$jmpress("register", "apply", function( selector, tmpl ) {
+		if( !tmpl ) {
+			// TODO ERROR because settings not found
+			var stepSelector = $(this).jmpress("settings").stepSelector;
+			applyChildrenTemplates( $(this).find(stepSelector).filter(function() {
+				return !$(this).parent().is(stepSelector);
+			}), selector );
+		} else if($.isArray(tmpl)) {
+			applyChildrenTemplates( $(selector), tmpl );
+		} else {
+			var template;
+			if(typeof tmpl === "string") {
+				template = templates[tmpl];
+			} else {
+				template = $.extend(true, {}, tmpl);
+			}
+			$(selector).each(function(idx, element) {
+				element = $(element);
+				var tmpl = element.data(templateFromApplyIdent) || {};
+				addUndefined(tmpl, template);
+				element.data(templateFromApplyIdent, tmpl);
+			});
+		}
+	});
+
+}(jQuery, document, window));
+/*
+ * jqevents.js
+ * Fires jQuery events
+ */
+(function( $, document, window, undefined ) {
+
+	'use strict';
+
+	/* HOOKS */
+	// the events should not bubble up the tree
+	// elsewise nested jmpress would cause buggy behavior
+	$.jmpress("setActive", function( step, eventData ) {
+		if(eventData.prevStep !== step) {
+			$(step).triggerHandler("enterStep");
+		}
+	});
+	$.jmpress("setInactive", function( step, eventData ) {
+		if(eventData.nextStep !== step) {
+			$(step).triggerHandler("leaveStep");
+		}
+	});
+
+}(jQuery, document, window));
+/*
+ * animation.js
+ * Apply custom animations to steps
+ */
+(function( $, document, window, undefined ) {
+
+	'use strict';
+
+	function parseSubstepInfo(str) {
+		var arr = str.split(" ");
+		var className = arr[0];
+		var config = { willClass: "will-"+className, doClass: "do-"+className, hasClass: "has-"+className };
+		var state = "";
+		for(var i = 1; i < arr.length; i++) {
+			var s = arr[i];
+			switch(state) {
+			case "":
+				if(s === "after") {
+					state = "after";
+				} else {
+					$.warn("unknown keyword in '"+str+"'. '"+s+"' unknown.");
+				}
+				break;
+			case "after":
+				if(s.match(/^[1-9][0-9]*m?s?/)) {
+					var value = parseFloat(s);
+					if(s.indexOf("ms") !== -1) {
+						value *= 1;
+					} else if(s.indexOf("s") !== -1) {
+						value *= 1000;
+					} else if(s.indexOf("m") !== -1) {
+						value *= 60000;
+					}
+					config.delay = value;
+				} else {
+					config.after = Array.prototype.slice.call(arr, i).join(" ");
+					i = arr.length;
+				}
+			}
+		}
+		return config;
+	}
+	function find(array, selector, start, end) {
+		end = end || (array.length - 1);
+		start = start || 0;
+		for(var i = start; i < end + 1; i++) {
+			if($(array[i].element).is(selector)) {
+				return i;
+			}
+		}
+	}
+	function addOn(list, substep, delay) {
+		$.each(substep._on, function(idx, child) {
+			list.push({substep: child.substep, delay: child.delay + delay});
+			addOn(list, child.substep, child.delay + delay);
+		});
+	}
+	$.jmpress("defaults").customAnimationDataAttribute = "jmpress";
+	$.jmpress("afterInit", function( nil, eventData ) {
+		eventData.current.animationTimeouts = [];
+		eventData.current.animationCleanupWaiting = [];
+	});
+	$.jmpress("applyStep", function( step, eventData ) {
+		// read custom animation from elements
+		var substepsData = {};
+		var listOfSubsteps = [];
+		$(step).find("[data-"+eventData.settings.customAnimationDataAttribute+"]")
+				.each(function(idx, element) {
+			if($(element).closest(eventData.settings.stepSelector).is(step)) {
+				listOfSubsteps.push({element: element});
+			}
+		});
+		if(listOfSubsteps.length === 0) {
+			return;
+		}
+		$.each(listOfSubsteps, function(idx, substep) {
+			substep.info = parseSubstepInfo(
+				$(substep.element).data(eventData.settings.customAnimationDataAttribute));
+			$(substep.element).addClass(substep.info.willClass);
+			substep._on = [];
+			substep._after = null;
+		});
+		var current = {_after: undefined, _on: [], info: {}}; // virtual zero step
+		$.each(listOfSubsteps, function(idx, substep) {
+			var other = substep.info.after;
+			if(other) {
+				if(other === "step") {
+					other = current;
+				} else if(other === "prev") {
+					other = listOfSubsteps[idx-1];
+				} else {
+					var index = find(listOfSubsteps, other, 0, idx - 1);
+					if(index === undefined) {
+						index = find(listOfSubsteps, other);
+					}
+					other = (index === undefined || index === idx) ? listOfSubsteps[idx-1] : listOfSubsteps[index];
+				}
+			} else {
+				other = listOfSubsteps[idx-1];
+			}
+			if(other) {
+				if(!substep.info.delay) {
+					if(!other._after) {
+						other._after = substep;
+						return;
+					}
+					other = other._after;
+				}
+				other._on.push({substep: substep, delay: substep.info.delay || 0});
+			}
+		});
+		if(current._after === undefined && current._on.length === 0) {
+			var startStep = find(listOfSubsteps, eventData.stepData.startSubstep) || 0;
+			current._after = listOfSubsteps[startStep];
+		}
+		var substepsInOrder = [];
+		function findNextFunc(idx, item) {
+			if(item.substep._after) {
+				current = item.substep._after;
+				return false;
+			}
+		}
+		do {
+			var substepList = [{substep: current, delay: 0}];
+			addOn(substepList, current, 0);
+			substepsInOrder.push(substepList);
+			current = null;
+			$.each(substepList, findNextFunc);
+		} while(current);
+		substepsData.list = substepsInOrder;
+		$(step).data("substepsData", substepsData);
+	});
+	$.jmpress("unapplyStep", function( step, eventData ) {
+		var substepsData = $(step).data("substepsData");
+		if(substepsData) {
+			$.each(substepsData.list, function(idx, activeSubsteps) {
+				$.each(activeSubsteps, function(idx, substep) {
+					if(substep.substep.info.willClass) {
+						$(substep.substep.element).removeClass(substep.substep.info.willClass);
+					}
+					if(substep.substep.info.hasClass) {
+						$(substep.substep.element).removeClass(substep.substep.info.hasClass);
+					}
+					if(substep.substep.info.doClass) {
+						$(substep.substep.element).removeClass(substep.substep.info.doClass);
+					}
+				});
+			});
+		}
+	});
+	$.jmpress("setActive", function(step, eventData) {
+		var substepsData = $(step).data("substepsData");
+		if(!substepsData) {
+			return;
+		}
+		if(eventData.substep === undefined) {
+			eventData.substep =
+				(eventData.reason === "prev" ?
+					substepsData.list.length-1 :
+					0
+				);
+		}
+		var substep = eventData.substep;
+		$.each(eventData.current.animationTimeouts, function(idx, timeout) {
+			clearTimeout(timeout);
+		});
+		eventData.current.animationTimeouts = [];
+		$.each(substepsData.list, function(idx, activeSubsteps) {
+			var applyHas = idx < substep;
+			var applyDo = idx <= substep;
+			$.each(activeSubsteps, function(idx, substep) {
+				if(substep.substep.info.hasClass) {
+					$(substep.substep.element)[(applyHas?"add":"remove")+"Class"](substep.substep.info.hasClass);
+				}
+				function applyIt() {
+					$(substep.substep.element).addClass(substep.substep.info.doClass);
+				}
+				if(applyDo && !applyHas && substep.delay && eventData.reason !== "prev") {
+					if(substep.substep.info.doClass) {
+						$(substep.substep.element).removeClass(substep.substep.info.doClass);
+						eventData.current.animationTimeouts.push(setTimeout(applyIt, substep.delay));
+					}
+				} else {
+					if(substep.substep.info.doClass) {
+						$(substep.substep.element)[(applyDo?"add":"remove")+"Class"](substep.substep.info.doClass);
+					}
+				}
+			});
+		});
+	});
+	$.jmpress("setInactive", function(step, eventData) {
+		if(eventData.nextStep === step) {
+			return;
+		}
+		function cleanupAnimation( substepsData ) {
+			$.each(substepsData.list, function(idx, activeSubsteps) {
+				$.each(activeSubsteps, function(idx, substep) {
+					if(substep.substep.info.hasClass) {
+						$(substep.substep.element).removeClass(substep.substep.info.hasClass);
+					}
+					if(substep.substep.info.doClass) {
+						$(substep.substep.element).removeClass(substep.substep.info.doClass);
+					}
+				});
+			});
+		}
+		$.each(eventData.current.animationCleanupWaiting, function(idx, item) {
+			cleanupAnimation(item);
+		});
+		eventData.current.animationCleanupWaiting = [];
+		var substepsData = $(step).data("substepsData");
+		if(substepsData) {
+			eventData.current.animationCleanupWaiting.push( substepsData );
+		}
+	});
+	$.jmpress("selectNext", function( step, eventData ) {
+		if(eventData.substep === undefined) {
+			return;
+		}
+		var substepsData = $(step).data("substepsData");
+		if(!substepsData) {
+			return;
+		}
+		if(eventData.substep < substepsData.list.length-1) {
+			return {step: step, substep: eventData.substep+1};
+		}
+	});
+	$.jmpress("selectPrev", function( step, eventData ) {
+		if(eventData.substep === undefined) {
+			return;
+		}
+		var substepsData = $(step).data("substepsData");
+		if(!substepsData) {
+			return;
+		}
+		if(eventData.substep > 0) {
+			return {step: step, substep: eventData.substep-1};
+		}
+	});
+
+}(jQuery, document, window));
+/*
+ * jmpress.toggle plugin
+ * For binding a key to toggle de/initialization of jmpress.js.
+ */
+(function( $, document, window, undefined ) {
+	'use strict';
+	$.jmpress("register", "toggle", function( key, config, initial ) {
+		var jmpress = this;
+		$(document).bind("keydown", function( event ) {
+			if ( event.keyCode === key ) {
+				if ($(jmpress).jmpress("initialized")) {
+					$(jmpress).jmpress("deinit");
+				} else {
+					$(jmpress).jmpress(config);
+				}
+			}
+		});
+		if ( initial ) {
+			$(jmpress).jmpress(config);
+		}
+	});
+}(jQuery, document, window));
+
+/*
+ * jmpress.secondary plugin
+ * Apply a secondary animation when step is selected.
+ */
+(function( $, document, window, undefined ) {
+	'use strict';
+	$.jmpress("initStep", function( step, eventData ) {
+		for(var name in eventData.data) {
+			if(name.indexOf("secondary") === 0) {
+				eventData.stepData[name] = eventData.data[name];
+			}
+		}
+	});
+	function exchangeIf(childStepData, condition, step) {
+		if(childStepData.secondary &&
+			childStepData.secondary.split(" ").indexOf(condition) !== -1) {
+			for(var name in childStepData) {
+				if(name.length > 9 && name.indexOf("secondary") === 0) {
+					var tmp = childStepData[name];
+					var normal = name.substr(9);
+					normal = normal.substr(0, 1).toLowerCase() + normal.substr(1);
+					childStepData[name] = childStepData[normal];
+					childStepData[normal] = tmp;
+				}
+			}
+			$(this).jmpress("reapply", $(step));
+		}
+	}
+	$.jmpress("beforeActive", function( step, eventData ) {
+		exchangeIf.call(eventData.jmpress, $(step).data("stepData"), "self", step);
+		var parent = $(step).parent();
+		$(parent)
+			.children(eventData.settings.stepSelector)
+			.each(function(idx, child) {
+				var childStepData = $(child).data("stepData");
+				exchangeIf.call(eventData.jmpress, childStepData, "siblings", child);
+			});
+		function grandchildrenFunc(idx, child) {
+			var childStepData = $(child).data("stepData");
+			exchangeIf.call(eventData.jmpress, childStepData, "grandchildren", child);
+		}
+		for(var i = 1; i < eventData.parents.length; i++) {
+			$(eventData.parents[i])
+				.children(eventData.settings.stepSelector)
+				.each();
+		}
+	});
+	$.jmpress("setInactive", function( step, eventData ) {
+		exchangeIf.call(eventData.jmpress, $(step).data("stepData"), "self", step);
+		var parent = $(step).parent();
+		$(parent)
+			.children(eventData.settings.stepSelector)
+			.each(function(idx, child) {
+				var childStepData = $(child).data("stepData");
+				exchangeIf.call(eventData.jmpress, childStepData, "siblings", child);
+			});
+		function grandchildrenFunc(idx, child) {
+			var childStepData = $(child).data("stepData");
+			exchangeIf.call(eventData.jmpress, childStepData, "grandchildren", child);
+		}
+		for(var i = 1; i < eventData.parents.length; i++) {
+			$(eventData.parents[i])
+				.children(eventData.settings.stepSelector)
+				.each(grandchildrenFunc);
+		}
+	});
+}(jQuery, document, window));
+
+/*
+ * jmpress.duration plugin
+ * For auto advancing steps after a given duration and optionally displaying a
+ * progress bar.
+ */
+(function( $, document, window, undefined ) {
+	'use strict';
+
+	$.jmpress("defaults").duration = {
+		defaultValue: -1
+		,defaultAction: "next"
+		,barSelector: undefined
+		,barProperty: "width"
+		,barPropertyStart: "0"
+		,barPropertyEnd: "100%"
+	};
+	$.jmpress("initStep", function( step, eventData ) {
+		eventData.stepData.duration = eventData.data.duration && parseInt(eventData.data.duration, 10);
+		eventData.stepData.durationAction = eventData.data.durationAction;
+	});
+	$.jmpress("setInactive", function( step, eventData ) {
+		var settings = eventData.settings,
+			durationSettings = settings.duration,
+			current = eventData.current;
+		var dur = eventData.stepData.duration || durationSettings.defaultValue;
+		if( current.durationTimeout ) {
+			if( durationSettings.barSelector ) {
+				var css = {
+					transitionProperty: durationSettings.barProperty
+					,transitionDuration: '0'
+					,transitionDelay: '0'
+					,transitionTimingFunction: 'linear'
+				};
+				css[durationSettings.barProperty] = durationSettings.barPropertyStart;
+				var bars = $(durationSettings.barSelector);
+				$.jmpress("css", bars, css);
+				bars.each(function(idx, element) {
+					var next = $(element).next();
+					var parent = $(element).parent();
+					$(element).detach();
+					if(next.length) {
+						next.insertBefore(element);
+					} else {
+						parent.append(element);
+					}
+				});
+			}
+			clearTimeout(current.durationTimeout);
+			delete current.durationTimeout;
+		}
+	});
+	$.jmpress("setActive", function( step, eventData ) {
+		var settings = eventData.settings,
+			durationSettings = settings.duration,
+			current = eventData.current;
+		var dur = eventData.stepData.duration || durationSettings.defaultValue;
+		if( dur && dur > 0 ) {
+			if( durationSettings.barSelector ) {
+				var css = {
+					transitionProperty: durationSettings.barProperty
+					,transitionDuration: (dur-settings.transitionDuration*2/3-100)+"ms"
+					,transitionDelay: (settings.transitionDuration*2/3)+'ms'
+					,transitionTimingFunction: 'linear'
+				};
+				css[durationSettings.barProperty] = durationSettings.barPropertyEnd;
+				$.jmpress("css", $(durationSettings.barSelector), css);
+			}
+			var jmpress = this;
+			if(current.durationTimeout) {
+				clearTimeout(current.durationTimeout);
+				current.durationTimeout = undefined;
+			}
+			current.durationTimeout = setTimeout(function() {
+				var action = eventData.stepData.durationAction || durationSettings.defaultAction;
+				$(jmpress).jmpress(action);
+			}, dur);
+		}
+	});
+}(jQuery, document, window));
+
+/*
+ * jmpress.presentation-mode plugin
+ * Display a window for the presenter with notes and a control and view of the
+ * presentation
+ */
+(function( $, document, window, undefined ) {
+
+	'use strict';
+	var $jmpress = $.jmpress;
+
+	var PREFIX = "jmpress-presentation-";
+
+	/* FUNCTIONS */
+	function randomString() {
+		return "" + Math.round(Math.random() * 100000, 0);
+	}
+
+	/* DEFAULTS */
+	$jmpress("defaults").presentationMode = {
+		use: true,
+		url: "presentation-screen.html",
+		notesUrl: false,
+		transferredValues: ["userZoom", "userTranslateX", "userTranslateY"]
+	};
+	$jmpress("defaults").keyboard.keys[80] = "presentationPopup"; // p key
+
+	/* HOOKS */
+	$jmpress("afterInit", function( nil, eventData) {
+		var current = eventData.current;
+
+		current.selectMessageListeners = [];
+
+		if(eventData.settings.presentationMode.use) {
+
+			window.addEventListener("message", function(event) {
+				// We do not test orgin, because we want to accept messages
+				// from all orgins
+				try {
+					if(typeof event.data !== "string" || event.data.indexOf(PREFIX) !== 0) {
+						return;
+					}
+					var json = JSON.parse(event.data.slice(PREFIX.length));
+					switch(json.type) {
+					case "select":
+						$.each(eventData.settings.presentationMode.transferredValues, function(idx, name) {
+							eventData.current[name] = json[name];
+						});
+						if(/[a-z0-9\-]+/i.test(json.targetId) && typeof json.substep in {number:1,undefined:1}) {
+							$(eventData.jmpress).jmpress("select", {step: "#"+json.targetId, substep: json.substep}, json.reason);
+						} else {
+							$.error("For security reasons the targetId must match /[a-z0-9\\-]+/i and substep must be a number.");
+						}
+						break;
+					case "listen":
+						current.selectMessageListeners.push(event.source);
+						break;
+					case "ok":
+						clearTimeout(current.presentationPopupTimeout);
+						break;
+					case "read":
+						try {
+							event.source.postMessage(PREFIX + JSON.stringify({type: "url", url: window.location.href, notesUrl: eventData.settings.presentationMode.notesUrl}), "*");
+						} catch(e) {
+							$.error("Cannot post message to source: " + e);
+						}
+						break;
+					default:
+						throw "Unknown message type: " + json.type;
+					}
+				} catch(e) {
+					$.error("Received message is malformed: " + e);
+				}
+			});
+			try {
+				if(window.parent && window.parent !== window) {
+					window.parent.postMessage(PREFIX + JSON.stringify({
+						"type": "afterInit"
+					}), "*");
+				}
+			} catch(e) {
+				$.error("Cannot post message to parent: " + e);
+			}
+		}
+	});
+	$jmpress("afterDeinit", function( nil, eventData) {
+		if(eventData.settings.presentationMode.use) {
+			try {
+				if(window.parent && window.parent !== window) {
+					window.parent.postMessage(PREFIX + JSON.stringify({
+						"type": "afterDeinit"
+					}), "*");
+				}
+			} catch(e) {
+				$.error("Cannot post message to parent: " + e);
+			}
+		}
+	});
+	$jmpress("setActive", function( step, eventData) {
+		var stepId = $(eventData.delegatedFrom).attr("id"),
+			substep = eventData.substep,
+			reason = eventData.reason;
+		$.each(eventData.current.selectMessageListeners, function(idx, listener) {
+			try {
+				var msg = {
+					"type": "select",
+					"targetId": stepId,
+					"substep": substep,
+					"reason": reason
+				};
+				$.each(eventData.settings.presentationMode.transferredValues, function(idx, name) {
+					msg[name] = eventData.current[name];
+				});
+				listener.postMessage(PREFIX + JSON.stringify(msg), "*");
+			} catch(e) {
+				$.error("Cannot post message to listener: " + e);
+			}
+		});
+	});
+	$jmpress("register", "presentationPopup", function() {
+		function trySend() {
+			jmpress.jmpress("current").presentationPopupTimeout = setTimeout(trySend, 100);
+			try {
+				popup.postMessage(PREFIX + JSON.stringify({type: "url", url: window.location.href, notesUrl: jmpress.jmpress("settings").presentationMode.notesUrl}), "*");
+			} catch(e) {
+			}
+		}
+		var jmpress = $(this),
+			popup;
+		if(jmpress.jmpress("settings").presentationMode.use) {
+			popup = window.open($(this).jmpress("settings").presentationMode.url);
+			jmpress.jmpress("current").presentationPopupTimeout = setTimeout(trySend, 100);
+		}
+	});
+}(jQuery, document, window));
diff --git a/app/assets/stylesheets/application.css.scss b/app/assets/stylesheets/application.css.scss
index 00161b9..5ff02ef 100755
--- a/app/assets/stylesheets/application.css.scss
+++ b/app/assets/stylesheets/application.css.scss
@@ -12,6 +12,10 @@
 * require_tree .
 *= require 'calendars'
 *= require jquery.fileupload-ui
+*= require jquery.ui.progressbar
+*= require jquery.datetimepicker	
+*= require jquery.ui.dialog
+*= require jquery.ui.tabs
 * require 'bootstrap'
 *= require 'tinymce'
 
@@ -147,3 +151,4 @@ background:44F;
 
 @import 'galleries';
 @import 'tinymce';
+@import 'linkboxes';
\ No newline at end of file
diff --git a/app/assets/stylesheets/layout.css.scss b/app/assets/stylesheets/layout.css.scss
index 0eb9e1b..2fb10ff 100755
--- a/app/assets/stylesheets/layout.css.scss
+++ b/app/assets/stylesheets/layout.css.scss
@@ -44,98 +44,6 @@ a:hover {
 
 
 
-ul.linkbox-list
-{ 
-  max-width:70em;
-margin-left:auto;
-margin-right:auto;
-}
-a.linkbox, div.contentbox
-{
-	display:block;
-	padding:5px;
-	border-radius:$box-border-radius;
-	border: $box-border;
-	background: $box-background;	
-}
-
-
-a.linkbox:hover
-{
-box-shadow: 1px 1px 2px 2px lightgray;
-}
-
-a.linkbox.color-1
-{
-color:$color_schema_1;	
-}
-a.linkbox.color-2
-{
-color:$color_schema_2;	
-}
-a.linkbox.color-3
-{
-color:$color_schema_3;	
-}
-a.linkbox.color-4
-{
-color:$color_schema_4;	
-}
-a.linkbox.color-5
-{
-color:$color_schema_5;	
-}
-
-a.color-1-dark
-{
-color:$color_schema_1_dark;	
-}
-a.color-2-dark
-{
-color:$color_schema_2_dark;	
-}
-a.color-3-dark
-{
-color:$color_schema_3_dark;	
-}
-a.color-4-dark
-{
-color:$color_schema_4_dark;	
-}
-a.color-5-dark
-{
-color:$color_schema_5_dark;	
-}
-a.color-1-dark:hover
-{
-color:$color_schema_1;	
-}
-a.color-2-dark:hover
-{
-color:$color_schema_2;	
-}
-a.color-3-dark:hover
-{
-color:$color_schema_3;	
-}
-a.color-4-dark:hover
-{
-color:$color_schema_4;	
-}
-a.color-5-dark:hover
-{
-color:$color_schema_5;	
-}
-
-
-a.linkbox li
-{ 
-}
-ul.linkbox-list li
-{
-margin-bottom:10px;
-}
-
 div.contentbox
 {
 	margin: 5px;
@@ -175,28 +83,6 @@ div.smallspan {
   min-height:0;
 }
 
-ul.linklist
-{max-width:100%;
-padding:0;
-margin:5px;
-}
-ul.linklist li{
-list-style:none;
-margin-bottom:2px;
-}
-ul.linklist li a i{
-vertical-align:middle;
-margin-right:6px;
-font-size:2em;}
-span.linklist a {
-	padding:5px;
-	border-radius:$box-border-radius;
-	border: $box-border;
-	background: $box-background;
-	display:block;
-	float:left;	
-
-}
 
 form.inline div {
 float:left;}
diff --git a/app/assets/stylesheets/themes/blue1/application.css.scss b/app/assets/stylesheets/themes/blue1/application.css.scss
index fdc57b0..c150411 100755
--- a/app/assets/stylesheets/themes/blue1/application.css.scss
+++ b/app/assets/stylesheets/themes/blue1/application.css.scss
@@ -16,6 +16,7 @@
  *= require jquery.datetimepicker	
  *= require jquery.ui.dialog
  *= require jquery.ui.autocomplete
+ *= require jquery.ui.progressbar
  *= require jquery.ui.tabs
  * require 'bootstrap'
  * require 'neuigkeiten'
@@ -117,5 +118,6 @@ $box-border-radius:0px;
 $box-background: white;
 
 @import 'layout';
+@import 'linkboxes';
 @import 'calendars';
 @import 'formtastic-bootstrap'
\ No newline at end of file
diff --git a/app/assets/stylesheets/themes/blue1/linkboxes.css.scss b/app/assets/stylesheets/themes/blue1/linkboxes.css.scss
new file mode 100644
index 0000000..15bb687
--- /dev/null
+++ b/app/assets/stylesheets/themes/blue1/linkboxes.css.scss
@@ -0,0 +1,61 @@
+ul.linkbox-list
+{ 
+  max-width:70em;
+	margin-left:auto;
+	margin-right:auto;
+}
+a.linkbox, div.contentbox
+{
+	display:block;
+	padding:5px;
+	border-radius:$box-border-radius;
+	border: $box-border;
+	background: $box-background;	
+}
+
+a.linkbox:hover{ box-shadow: 1px 1px 2px 2px lightgray; }
+
+a.linkbox.color-1 { color:$color_schema_1; }
+a.linkbox.color-2 { color:$color_schema_2; }
+a.linkbox.color-3 { color:$color_schema_3; }
+a.linkbox.color-4 { color:$color_schema_4;}
+a.linkbox.color-5 { color:$color_schema_5;}
+
+a.color-1-dark { color:$color_schema_1_dark;	}
+a.color-2-dark { color:$color_schema_2_dark;	}
+a.color-3-dark { color:$color_schema_3_dark;}
+a.color-4-dark { color:$color_schema_4_dark;}
+a.color-5-dark { color:$color_schema_5_dark;}
+a.color-1-dark:hover { color:$color_schema_1;	}
+a.color-2-dark:hover { color:$color_schema_2;	}
+a.color-3-dark:hover { color:$color_schema_3;	}
+a.color-4-dark:hover { color:$color_schema_4;	}
+a.color-5-dark:hover { color:$color_schema_5;	}
+
+a.linkbox li { }
+ul.linkbox-list li {
+		margin-bottom:10px;
+}
+ul.linklist {
+		max-width:100%;
+		padding:0;
+		margin:5px;
+}
+ul.linklist li {
+		list-style:none;
+		margin-bottom:2px;
+}
+ul.linklist li a i{
+		vertical-align:middle;
+		margin-right:6px;
+		font-size:2em;}
+span.linklist a {
+		padding:5px;
+		border-radius:$box-border-radius;
+		border: $box-border;
+		background: $box-background;
+		display:block;
+		float:left;	
+
+}
+
diff --git a/app/assets/stylesheets/themes/blue2/application.css.scss b/app/assets/stylesheets/themes/blue2/application.css.scss
index 1db0ed0..07388ee 100755
--- a/app/assets/stylesheets/themes/blue2/application.css.scss
+++ b/app/assets/stylesheets/themes/blue2/application.css.scss
@@ -1,4 +1,6 @@
+/* This is the main file for theme "blue2"
 
+ */
 /*
  * This is a manifest file that'll be compiled into application.css, which will include all the files
  * listed below.
@@ -15,6 +17,8 @@
  *= require jquery.datetimepicker	
  *= require jquery.ui.dialog
  *= require jquery.ui.tabs
+ *= require jquery.ui.progressbar
+
  * require 'bootstrap'
 
  * require 'neuigkeiten'
@@ -89,9 +93,11 @@ div.header {
   height:45px;
   margin-bottom: 0 px
 }
+
 div.header_span {
   background:white
 }
+
 div.header h1 {
   padding:0;
   margin:4px;
@@ -117,16 +123,16 @@ $navbar-li-minwidth: 0;
 
 
 $box-border: lightgray solid 1px;
-$box-border-radius:4px;
+$box-border-radius:6px;
 $box-background: white;
 
 @import 'layout';
 @import 'calendars';
 @import 'formtastic-bootstrap';
-
+@import 'linkboxes';
 @import 'extra';
 body {
-background: #FFF; //#EFEFEF;
+background: #FCFCFC; //#EFEFEF;
 background-size:100%;
 }
 
diff --git a/app/assets/stylesheets/themes/blue2/linkboxes.css.scss b/app/assets/stylesheets/themes/blue2/linkboxes.css.scss
new file mode 100644
index 0000000..ea57d92
--- /dev/null
+++ b/app/assets/stylesheets/themes/blue2/linkboxes.css.scss
@@ -0,0 +1,142 @@
+ul.linkbox-list
+{ 
+  max-width:70em;
+	margin-left:auto;
+	margin-right:auto;
+}
+
+ul.linkbox-list > li {
+		margin-bottom:0px;
+}
+
+ul.linkbox-list > li:first-child  a.linkbox {
+	border-top-left-radius:$box-border-radius;
+	border-top-right-radius:$box-border-radius;
+	border: $box-border; 
+
+}
+
+ul.linkbox-list > li:last-child  a.linkbox {
+	border-bottom-left-radius:$box-border-radius;
+	border-bottom-right-radius:$box-border-radius;
+}
+
+ul.linkbox-list > li  a.linkbox {
+	border-radius: 0;
+	border-top: none; 
+
+}
+
+ul.linkbox-list > li  a.linkbox:hover {
+		z-index:2000
+}
+a.linkbox, div.contentbox
+{
+	display:block;
+	padding:5px;
+	border-radius:$box-border-radius;
+	border: $box-border; 
+	background: $box-background;	
+}
+
+a.linkbox:hover{ box-shadow: 1px 1px 2px 2px lightgray; }
+
+a.linkbox.color-1 { color:$color_schema_1; }
+a.linkbox.color-2 { color:$color_schema_2; }
+a.linkbox.color-3 { color:$color_schema_3; }
+a.linkbox.color-4 { color:$color_schema_4;}
+a.linkbox.color-5 { color:$color_schema_5;}
+
+a.color-1-dark { color:$color_schema_1_dark;	}
+a.color-2-dark { color:$color_schema_2_dark;	}
+a.color-3-dark { color:$color_schema_3_dark;}
+a.color-4-dark { color:$color_schema_4_dark;}
+a.color-5-dark { color:$color_schema_5_dark;}
+a.color-1-dark:hover { color:$color_schema_1;	}
+a.color-2-dark:hover { color:$color_schema_2;	}
+a.color-3-dark:hover { color:$color_schema_3;	}
+a.color-4-dark:hover { color:$color_schema_4;	}
+a.color-5-dark:hover { color:$color_schema_5;	}
+
+
+a.linkbox li { }
+
+
+ul.linklist {
+		max-width:100%;
+		padding:0;
+		margin:5px;
+}
+ul.linklist li {
+		list-style:none;
+
+}
+ul.linklist li a i{
+		vertical-align:middle;
+		margin-right:6px;
+		font-size:2em;}
+
+ul.linklist > li  a.linkbox {
+	border-radius: 0;
+	border:  $box-border;
+/*  border-color:white;*/
+	padding-top: 7px;
+	margin-bottom:0px;
+	margin-top:0px;
+
+/*	border-bottom: $box-border; 
+	border-top: $box-border; 
+*/
+  border-color:white; 
+/*  border-bottom-color:white; */
+
+}
+ul.linklist > li  a.linkbox:hover {
+
+	border: $box-border; 
+	border-top: $box-border; 
+  box-shadow: none;
+	border-color: black;
+	background: #FCFCFC;
+/*	margin: 0;
+	margin-bottom:0px;*/
+}
+
+
+ul.linklist > li:first-child  a.linkbox {}
+
+ul.linklist > li:last-child  a.linkbox {	
+}
+
+ul.linklist > li:first-child  a.linkbox {
+	border-top-left-radius:$box-border-radius;
+	border-top-right-radius:$box-border-radius;
+/*	border-top:$box-border; */
+	margin-top:0px;
+}
+
+ul.linklist > li:last-child  a.linkbox {
+	border-bottom-left-radius:$box-border-radius;
+	border-bottom-right-radius:$box-border-radius;
+/*	border-bottom:$box-border;*/
+margin-bottom:0px;		
+}
+
+ul.linklist { 
+	border-radius: $box-border-radius;
+	border: $box-border; 
+/* box-shadow: 0px 0px 1px 1px lightgray;*/
+}
+
+
+
+
+span.linklist li a {
+		padding:5px;
+		border: $box-border;
+		background: $box-background;
+		display:block;
+		float:left;	
+
+}
+
diff --git a/app/controllers/application_controller.rb b/app/controllers/application_controller.rb
index b88554a..881e9a1 100755
--- a/app/controllers/application_controller.rb
+++ b/app/controllers/application_controller.rb
@@ -16,7 +16,13 @@
 
       end
     end
-    I18n.locale = session[:locale] ||  request.env['HTTP_ACCEPT_LANGUAGE'].scan(/^de|en/).first || I18n.default_locale
+    http_header=request.env['HTTP_ACCEPT_LANGUAGE']
+    unless http_header.nil?
+     ht= http_header.scan(/^de|en/).first
+    else
+      ht=nil
+    end
+    I18n.locale = session[:locale] || ht || I18n.default_locale
     
 
     session[:locale] = I18n.locale
@@ -46,7 +52,8 @@
     else              
       flash[:error] = "You must first login to view this page"
       session[:user_return_to] = request.url
-      redirect_to "/users/sign_in"
+      return redirect_to "/users/sign_in"
+      
     end 
     
   end 
diff --git a/app/controllers/documents_controller.rb b/app/controllers/documents_controller.rb
index bacf9af..22361db 100644
--- a/app/controllers/documents_controller.rb
+++ b/app/controllers/documents_controller.rb
@@ -157,7 +157,7 @@ class DocumentsController < ApplicationController
       @results = Document.search do
         fulltext params['query'] do
           fields :name, :text, :meeting
-          highlight :text
+          highlight :text,:name,:meeting
         end
       end
       @res=[]
diff --git a/app/controllers/emails_controller.rb b/app/controllers/emails_controller.rb
new file mode 100644
index 0000000..a10e2b6
--- /dev/null
+++ b/app/controllers/emails_controller.rb
@@ -0,0 +1,22 @@
+class EmailsController < ApplicationController
+before_filter :authorize
+
+  def index
+    
+  end
+  def daily_reminder
+    ActionMailer::Base.default_url_options[:host] = request.host_with_port 
+    @mail =NewsMailer.daily_reminder(current_user.id)
+    if params[:send]
+      usr=User.where(:flag_getemails => true)
+      usr.each do |u|
+        NewsMailer.daily_reminder(current_user.id).deliver
+      end
+    end
+    render layout: false
+end
+  protected
+  def authorize
+    authorize! :emails, User
+  end
+end
diff --git a/app/controllers/fetprofiles_controller.rb b/app/controllers/fetprofiles_controller.rb
index ae58913..d7d99a7 100644
--- a/app/controllers/fetprofiles_controller.rb
+++ b/app/controllers/fetprofiles_controller.rb
@@ -9,18 +9,17 @@ class FetprofilesController < ApplicationController
     @fetprofiles = Fetprofile.order(:vorname,:nachname) if params[:filter]== "all"
     @fetprofiles = Fetprofile.where(:active=>false).order(:nachname,:vorname) if params[:filter]== "notactive"
 
-
     @gremientabs = Gremium.tabs
-     @toolbar_elements << {:hicon=>'icon-plus', :text=> I18n.t('profile.new_profile'),:path => new_fetprofile_path(@fetprofile) } if can? :new, @fetprofile
+    @toolbar_elements << {:hicon=>'icon-plus', :text=> I18n.t('profile.new_profile'),:path => new_fetprofile_path(@fetprofile) } if can? :new, @fetprofile
 
     respond_to do |format|
       format.html # index.html.erb
-      end
+    end
   end
 
   def internlist
     @fetprofiles = Fetprofile.order(:vorname,:nachname) 
-    end
+  end
 
   # GET /fetprofiles/1
   # GET /fetprofiles/1.json
diff --git a/app/controllers/home_controller.rb b/app/controllers/home_controller.rb
index d177155..28fd237 100755
--- a/app/controllers/home_controller.rb
+++ b/app/controllers/home_controller.rb
@@ -19,6 +19,11 @@ class HomeController < ApplicationController
   end
   def dev
 
+  end
+  def infoscreen
+    authorize! :doadmin, User
+    @neuigkeiten = Neuigkeit.accessible_by(current_ability, :show).where(flag_infoscreen: true)
+    render layout: false
   end
   def kontakt
     t=YAML.load_file("#{::Rails.root.to_s}/config/contact_topic.yml")
diff --git a/app/controllers/neuigkeiten_controller.rb b/app/controllers/neuigkeiten_controller.rb
index 4c117d3..ce08d18 100755
--- a/app/controllers/neuigkeiten_controller.rb
+++ b/app/controllers/neuigkeiten_controller.rb
@@ -3,6 +3,7 @@ class NeuigkeitenController < ApplicationController
   
   before_filter :load_toolbar_elements, :only=>[:show,:find_link]
   before_filter :load_toolbar_elements_edit, :only=>[:edit]
+  acts_as_flagable
  
 
 
@@ -119,12 +120,15 @@ end
     end  
   end
   def mail_preview
+  ActionMailer::Base.default_url_options[:host] = request.host_with_port 
+
     @neuigkeit = Neuigkeit.find(params[:id])
-   @user=current_user
+    @user=current_user
     @ability=Ability.new(@user)
+    @mail = NewsMailer.neuigkeit_mail("all@fet.at", params[:id])
 
     authorize! :publish, @neuigkeit
-    render template: "news_mailer/neuigkeit_mail", layout: false
+    render  layout: false
   end
   def newsletter_preview
     authorize! :publish, Neuigkeit
diff --git a/app/controllers/rubriken_controller.rb b/app/controllers/rubriken_controller.rb
index b6c5e0e..966edf1 100755
--- a/app/controllers/rubriken_controller.rb
+++ b/app/controllers/rubriken_controller.rb
@@ -16,7 +16,7 @@ class RubrikenController < ApplicationController
     @rubriken= Rubrik.accessible_by(current_ability, :show)
     @neuigkeiten = Neuigkeit.accessible_by(current_ability, :list).page(params[:page]).per(3)
     
-    @calentries= (@rubriken.map {|r| r.calendar}).collect(&:calentries).flatten.select {|c| c.object !=nil}
+    @calentries= (@rubriken.map {|r| r.calendar.calentries.of_month(Date.new(params[:year],params[:month],1))}).flatten.select {|c| c.object !=nil}
     respond_to do |format|
       format.html
       format.js {render action: :show}
diff --git a/app/controllers/users_controller.rb b/app/controllers/users_controller.rb
index 1e73890..4379695 100755
--- a/app/controllers/users_controller.rb
+++ b/app/controllers/users_controller.rb
@@ -1,8 +1,22 @@
 class UsersController < ApplicationController
   def index 
+    authorize!(:index,User)
     @users = User.all
   end
+  def show
+    @user=User.find(params[:id])
+    authorize!(:show, @user)    
+
+  end
+  def set_preferred_theme
+    @user=User.find(params[:id])
+    authorize!(:set_preferred_theme, @user)    
+    @user.preferredtheme=params[:theme]
+    @user.save
+    redirect_to root_url
+  end
   def add_role
+    authorize!(:add_role, User)
     @user= User.find(params[:id])
     if (params[:role]=="fetuser" && can?(:addfetuser,User))
       @user.add_role(params[:role])
@@ -13,6 +27,8 @@ class UsersController < ApplicationController
     redirect_to users_url
   end
   def fb_set_default_publish_page
+    authorize!(:doadmin, User)
+
     if Fetsite::Application.config.facebookconfig_enabled
       if params["page"].nil? || !(current_user.provider=="facebook")
         redirect_to intern_home_index_path
@@ -27,6 +43,7 @@ class UsersController < ApplicationController
   end
   
   def all_update
+    authorize! :doadmin,User
     params[:users].each do |id,u| 
       user=User.find(id) 
       user.fetprofile = Fetprofile.find(u[:fetprofile_id].to_i) if u[:fetprofile_id].to_i>0 
diff --git a/app/mailers/news_mailer.rb b/app/mailers/news_mailer.rb
index 311708e..86ee2be 100644
--- a/app/mailers/news_mailer.rb
+++ b/app/mailers/news_mailer.rb
@@ -1,23 +1,44 @@
+# -*- coding: utf-8 -*-
+
 class NewsMailer < ActionMailer::Base
   default from: "salzamt@fet.at"
   helper :plugins
-  def current_user
-    @user
-  end
+
   def neuigkeit_mail(email, neuigkeit_id)
     @neuigkeit= Neuigkeit.find(neuigkeit_id)
     @user=User.first
     @ability=Ability.new(@user)
     subject =  @neuigkeit.title
-    subject = subject + " email: " + email if Rails.env=="development"
+    subject = subject.to_s + " email: " + email.to_s if Rails.env=="development"
     email = "andis@fet.at" if Rails.env=="development"
     email="andis@fet.at"
     mail(to: email, subject: subject)
-render locals: {current_user: User.first}
+    render locals: {current_user: User.first}
   end
   def daily_newsletter(user_id)
     user=User.find(user_id)
+    self.message.perform_deliveries = false unless user.flag_getemails
     ability= Ability.new(user)
+    
     @neuigkeiten=Neuigkeit.accessible_by(ability).published_scope.where("cache_order<2")
   end
+
+  def daily_reminder(user_id)
+    user=User.find(user_id)
+    @user=user
+    self.message.perform_deliveries = false unless user.flag_getemails
+    @ability = Ability.new(user)
+    @calentries = Calentry.of_month(Date.today).limit(100)
+#    @neuigkeiten=Neuigkeit.accessiblße_by(ability).published_scope.where("cache_order<2")
+    mail(to: user.email,      content_type: "text/html", subject: "sdf")
+    render locals: {c_user: user}
+ end
+private
+include CanCan::ControllerAdditions
+  def current_user
+    @user
+  end
+  def current_ability
+    @ability
+  end 
 end
diff --git a/app/models/ability.rb b/app/models/ability.rb
index 6dfe69d..99ba5bb 100755
--- a/app/models/ability.rb
+++ b/app/models/ability.rb
@@ -152,6 +152,7 @@ end
     can :show, Neuigkeit, :cache_is_published=>true, :rubrik=>{:public=>true}
 
     if loggedin
+      can :show, :id => user.id
     end
     if( user.has_role?("fetuser") || user.has_role?("fetadmin"))
 
@@ -159,6 +160,7 @@ end
       can :showintern, Neuigkeit
       can :showintern, Rubrik
       can :seeintern, User
+      can :set_preferred_theme, user
       can :list, Neuigkeit
       can :shownonpublic, Rubrik
       can :manage, Nlink
@@ -169,8 +171,12 @@ end
     if user.has_role?("fetadmin")
       can :addfetuser, User
       can :addfetadmin, User
+      can :add_role, User
+      can :show, User
+      can :index, User
       can :edit, User
       can :manage, User
+      can :set_preferred_theme, User
     end
     
     if user.has_role?("newsadmin") || user.has_role?( "fetadmin") || user.has_role?( "fetuser") 
@@ -227,7 +233,8 @@ end
       can :doadmin, User
     end
 
-    unless user.has_role?("fetadmin")
+    if user.has_role?("fetadmin")
+      can :emails,User
     end
     
   end
diff --git a/app/models/calentry.rb b/app/models/calentry.rb
index b0908df..6421632 100644
--- a/app/models/calentry.rb
+++ b/app/models/calentry.rb
@@ -14,14 +14,14 @@
 
 class Calentry < ActiveRecord::Base
   attr_accessible :ende, :start, :summary, :typ,:calendar_ids, :calendar, :dauer, :object_id, :object_type
-  belongs_to :calendar
+  belongs_to :calendar, touch: true
   #belongs_to :neuigkeit
   validates :start, :presence => true
   validates :object, :presence => true
   validates :typ, :presence => true
   before_save :get_public
   belongs_to :object, polymorphic: true, touch: true # Objekt zu dem der Calentry gehört (derzeit ein Newsartikel)
-
+  scope :of_month, ->(d) {where("start >= ? AND start <= ?", d.beginning_of_month, d.end_of_month)}
   scope :upcoming, ->{ where("start >= ?", Time.now).order(:start)}
   scope :recent,-> {  where("start <= ?", Time.now).order(:start).reverse_order}
   validate do |entry|
@@ -31,7 +31,10 @@ class Calentry < ActiveRecord::Base
   end  
   
   resourcify
-
+  def  self.updated_at
+    #Calentry.select("MAX(updated_at) as m_updated_at").first.m_updated_at
+    Calentry.all.max_by(&:updated_at).updated_at
+ end
   def is_upcomming?
     self.start > Time.now
   end
diff --git a/app/models/document.rb b/app/models/document.rb
index f820ebc..5123b52 100644
--- a/app/models/document.rb
+++ b/app/models/document.rb
@@ -102,7 +102,7 @@ class Document < ActiveRecord::Base
     end
     text :name, :boost=>4.0, :stored=> true    
     text :meeting, stored: true do |d| 
-      (d.parent_type == "Meeting")? d.try(:parent).try(:text).to_s : "" 
+      (d.parent.is_a?(Meeting))? d.try(:parent).try(:text).to_s : "" 
     end
   end
   def maketoc
diff --git a/app/models/fetprofile.rb b/app/models/fetprofile.rb
index 804995e..fbabb4d 100644
--- a/app/models/fetprofile.rb
+++ b/app/models/fetprofile.rb
@@ -32,13 +32,13 @@ class Fetprofile < ActiveRecord::Base
   has_many :nlinks, as: :link
   def validate_birthday
     unless birth_month.nil? || birth_day.nil?
-    unless Date.valid_date?((birth_year.nil?) ? Date.today.year : birth_year, birth_month, birth_day)
-      errors.add(:birth_month, "Invalides Datum")
-      errors.add(:birth_day, "Invalides Datum")
-      v= false
-    else
-      v= true
-    end
+      unless Date.valid_date?((birth_year.nil?) ? Date.today.year : birth_year, birth_month, birth_day)
+        errors.add(:birth_month, "Invalides Datum")
+        errors.add(:birth_day, "Invalides Datum")
+        v= false
+      else
+        v= true
+      end
     else
       v= false
     end
@@ -78,3 +78,5 @@ class Fetprofile < ActiveRecord::Base
   end
 
 end
+ 
+ 
diff --git a/app/models/gremium.rb b/app/models/gremium.rb
index 8fd3c7e..8ee1800 100644
--- a/app/models/gremium.rb
+++ b/app/models/gremium.rb
@@ -23,6 +23,7 @@ class Gremium < ActiveRecord::Base
   has_many :memberships, dependent: :destroy # Mitgliedschaften bei dem Gremium
   has_many :nlinks, as: :link, dependent: :destroy
 #  scope :search, ->(query) {where("gremien.name like ? or gremien.desc like ?", "%#{query}%", "%#{query}%")}
+#  has_many :members, through: :memberships
   searchable do
     text :desc
     text :name, :boost=>4.0
diff --git a/app/models/neuigkeit.rb b/app/models/neuigkeit.rb
index 6bab7a0..0db49de 100755
--- a/app/models/neuigkeit.rb
+++ b/app/models/neuigkeit.rb
@@ -30,6 +30,7 @@ class Neuigkeit < ActiveRecord::Base
   translates :title,:text, :versioning=>{:gem=>:paper_trail, :options=>{:fallbacks_for_empty_translations => true}}
   globalize_accessors :locales => [:de, :en], :attributes =>[:text,:title]
   mount_uploader :picture, PictureUploader
+  include IsCommentable
 
   default_scope  order(:cache_order).includes(:calentries).includes(:title_pic)
   scope :recent, -> { published.limit(10)}
@@ -44,6 +45,12 @@ class Neuigkeit < ActiveRecord::Base
   before_validation :sanitize
   after_save :update_cache
   attr_accessor :no_fallbacks
+
+  acts_as_flagable
+
+  FLAG_ICONS={"infoscreen" => "fa fa-desktop", "important"=>"fa fa-exclamation"}
+  FLAG_CONFIRM={"infoscreen" => "Neuigkeit am Infoscreen anzeigen"}
+
   def globalize_fallbacks(locale)
     if self.no_fallbacks
     [locale]
diff --git a/app/models/studium.rb b/app/models/studium.rb
index 2355ae6..1fd5866 100755
--- a/app/models/studium.rb
+++ b/app/models/studium.rb
@@ -34,7 +34,7 @@ class Studium < ActiveRecord::Base
   has_many :lvas, :through=>:moduls
   has_many :semester, :dependent => :destroy
   has_many :attachments, :as=>:parent
-validates :abkuerzung, :length=>{:maximum=>5}, :format=>{:with=>/^[a-zA-z]{0,5}$/}
+  validates :abkuerzung, :length=>{:maximum=>5}, :format=>{:with=>/^[a-zA-z]{0,5}$/}
   validates :typ, :inclusion => {:in => ["Bachelor","Master"] }
   validates :name, :uniqueness => true, :presence=>true
   validates :zahl, :presence=>true, :format=>{:with=>/^[0-9A-Z]{4,10}$/}, :uniqueness => true 
diff --git a/app/models/survey/answer.rb b/app/models/survey/answer.rb
index a7d2c78..244bafe 100644
--- a/app/models/survey/answer.rb
+++ b/app/models/survey/answer.rb
@@ -1,5 +1,5 @@
 class Survey::Answer < ActiveRecord::Base
-  belongs_to :choice, class_name: 'Survey::Choice'
+  belongs_to :choice, class_name: 'Survey::Choice', touch: true
   belongs_to :user
   # attr_accessible :title, :body
 end
diff --git a/app/models/survey/choice.rb b/app/models/survey/choice.rb
index 22f8dbf..7fca518 100644
--- a/app/models/survey/choice.rb
+++ b/app/models/survey/choice.rb
@@ -1,5 +1,5 @@
 class Survey::Choice < ActiveRecord::Base
-  belongs_to :question, class_name: 'Survey::Question'
+  belongs_to :question, class_name: 'Survey::Question', touch: true
   attr_accessible :picture, :sort, :text, :icon, :picture_cache, :remove_picture, :question_id
   has_many :answers, class_name: 'Survey::Answer', dependent: :destroy
   include ActionView::Helpers::TagHelper
diff --git a/app/models/survey/question.rb b/app/models/survey/question.rb
index 9500d05..b10c199 100644
--- a/app/models/survey/question.rb
+++ b/app/models/survey/question.rb
@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 class Survey::Question < ActiveRecord::Base
   attr_accessible :text, :title, :typ, :choice_ids, :parent_type, :parent_id
-  belongs_to :parent, polymorphic: true
+  belongs_to :parent, polymorphic: true, touch: true
   has_many :choices, dependent: :destroy, class_name: "Survey::Choice"
   has_many :answers, through: :choices
   include IsCommentable
diff --git a/app/views/beispiele/_form.html.erb b/app/views/beispiele/_form.html.erb
index 7f6df24..07285a6 100755
--- a/app/views/beispiele/_form.html.erb
+++ b/app/views/beispiele/_form.html.erb
@@ -12,7 +12,7 @@
       <% end %>
       </div>
   <div class="span6">
-    <% f.file_field :beispieldatei, :label => "Neue Datei hochladen:"%>
+    <%= f.file_field :beispieldatei, :label => "Neue Datei hochladen:" if @beispiel.beispieldatei.nil? || @beispiel.beispieldatei.blank? %>
   </div>
   <%=f.input :datum , :as => :datetimepicker %>
     
@@ -20,11 +20,11 @@
     
 <div class="row-fluid">
   <%= f.input :name %>
-  
+  <%= f.input :lva  if @beispiel.lva.nil?%>
   <%= f.input :desc %>
 </div>
   <div class="span4">
-    <%= f.input :lecturer, :as=>:select, :collection => @beispiel.lva.lecturers %>
+    <%= f.input :lecturer, :as=>:select, :collection => ((@beispiel.lva.nil?|| @beispiel.lva.lecturers.empty?)? Lecturer.all : @beispiel.lva.lecturers) %>
   </div>
 <%= f.hidden_field :beispieldatei_cache %>
 <%= f.actions do %>
diff --git a/app/views/calentries/_mail.html.erb b/app/views/calentries/_mail.html.erb
new file mode 100644
index 0000000..9c75a7e
--- /dev/null
+++ b/app/views/calentries/_mail.html.erb
@@ -0,0 +1 @@
+<%= mail.icon_text %>
diff --git a/app/views/documents/_search_results.html.erb b/app/views/documents/_search_results.html.erb
index 47d616a..1d72a50 100644
--- a/app/views/documents/_search_results.html.erb
+++ b/app/views/documents/_search_results.html.erb
@@ -1,17 +1,19 @@
 <% unless search_results.nil? %>
-<%= search_results  %>
+<%#= search_results  %>
+
+
 <ul>
 	<% search_results.each_hit_with_result  do |hit,result| %>
 		<li> <%= link_to result.parent.title+": " + result.name, document_path(result) %>
 			<%  hit.highlights(:name).each do |hlgt| %>
-				<%= raw(hlgt.format{|word|"<b>#{word}</b>" } ) %>
+				<%= (hlgt.format{|word|"<b>#{word}</b>" } ).html_safe%>
 			<% end 	%>
 			<%  %>
-			<%  hit.highlights(:text).each do |hlgt| %>
-				<%=  "text:" + raw(hlgt.format {|word| raw("<b>#{word}</b>") })%> 
+			<%  hit.highlights(:text).each do |hlgt| %> 
+				<%=  ("<br>text: " + hlgt.format {|word| "<b>#{word}</b>" }).html_safe%> 
 			<%  end %>
 			<%  hit.highlights(:meeting).each do |hlgt| %>
-				<%=  "text:" + raw(hlgt.format {|word| "*#{word}*" })%> 
+				<%=  "text:" + (hlgt.format {|word| "*#{word}*" }).html_safe%> 
 			<%  end %>
 
 		</li>	
diff --git a/app/views/emails/daily_reminder.html.erb b/app/views/emails/daily_reminder.html.erb
new file mode 100644
index 0000000..ac3bb6b
--- /dev/null
+++ b/app/views/emails/daily_reminder.html.erb
@@ -0,0 +1,3 @@
+<%=link_to "reminder", daily_reminder_emails_path(params: {send: true}) %>
+<hr>Subject: <b><%= @mail.subject %></b><br>
+<%= raw(@mail.body) %>
diff --git a/app/views/emails/index.html.erb b/app/views/emails/index.html.erb
new file mode 100644
index 0000000..80b1dea
--- /dev/null
+++ b/app/views/emails/index.html.erb
@@ -0,0 +1 @@
+<%=link_to "reminder", daily_reminder_emails_path() %>
diff --git a/app/views/fetprofiles/_fetprofile.html.erb b/app/views/fetprofiles/_fetprofile.html.erb
index b934e62..e96a277 100644
--- a/app/views/fetprofiles/_fetprofile.html.erb
+++ b/app/views/fetprofiles/_fetprofile.html.erb
@@ -2,3 +2,4 @@
 <%= link_to fetprofile, {class: :linkbox} do %>
  <%= render :partial=>"fetprofiles/compact", :locals=>{:fetprofile=>fetprofile} %>
 <% end %>
+<%= root_path() %>
diff --git a/app/views/fetprofiles/show.html.erb b/app/views/fetprofiles/show.html.erb
index be47657..da582a4 100644
--- a/app/views/fetprofiles/show.html.erb
+++ b/app/views/fetprofiles/show.html.erb
@@ -51,10 +51,11 @@ end
 	<%= @fetprofile.desc %>
       </p>
       <%= render partial: "interninfo", object: @fetprofile if can?(:seeintern, @fetprofile) %>
+	
       <ul>
 	<% @memberships.each do |m| %>
 	<li>
-	  <%= link_to m.gremium do %> <%= render m %><% end %>
+	  <%= link_to gremium_path(m.gremium) do %> <%= render m %><% end %>
 	  <%= link_to I18n.t('common.edit'), edit_fetprofile_membership_path(@fetprofile,m) if params["verwalten"] && can?(:edit, m)%>
 	  <%= link_to I18n.t('common.delete'), [@fetprofile, m], method: :delete, data: {confirm: I18n.t('common.sure_del')} if params["verwalten"] && can?(:delete, m ) %>
 	</li>
diff --git a/app/views/home/admin.html.erb b/app/views/home/admin.html.erb
index 351dd50..ed68bce 100644
--- a/app/views/home/admin.html.erb
+++ b/app/views/home/admin.html.erb
@@ -2,6 +2,8 @@
 <p>
 <%= link_to "user", users_path %>
 </p>
+
+<p><%= link_to "emails", emails_path %></p>
 <% if Fetsite::Application.config.facebookconfig_enabled %>
 <h2>Facebook Konfiguration</h2>
 <p><%= link_to "Grant extra FB privileges", user_omniauth_authorize_path(:facebook,:params=>{scope:"manage_pages,publish_actions,email"}), :confirm=>"Wirklich?" %>
diff --git a/app/views/home/infoscreen.html.erb b/app/views/home/infoscreen.html.erb
new file mode 100644
index 0000000..ec873c1
--- /dev/null
+++ b/app/views/home/infoscreen.html.erb
@@ -0,0 +1,82 @@
+
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <%= stylesheet_link_tag "themes/"+theme_name+"/application", :media => "all" unless theme_name.empty?  %>
+    <%= stylesheet_link_tag "application", :media=>"all" if theme_name.empty? %>
+
+   <%= javascript_include_tag "application" %>
+    <%= javascript_include_tag "jmpress" %>
+
+	</head>
+	<body>
+<div id ="jmpress">
+<% i=1  %>
+<% @neuigkeiten.each do |n| %>
+
+	<div class="step contentbox" id="step-<%=i%>" data-x="<%= i *2000 %>" data-y="<%= Random.rand(0..5)*200 %>" data-rotate="<%= Random.rand(0..18)*10 %>" style="width:1000px; height:500px; padding: 50px; display:block" data-duration="10000"><% @toolbar_elements=[];@questions=[] %>
+		  <div class="media" style="width: 500px; height:250px; transform: scale(1.5) translate(60px,0)" >
+    <% unless n.picture_robust.big_thumb.to_s.empty? %>
+			<div class="pull-left" href="#">
+				<p><br><%= link_to image_tag(n.picture_robust.big_thumb),n.picture_robust.try(:url)  %>
+				</p>
+			</div>
+    <% end %>
+    <div class="media-body">
+			<h1 itemprop="name">
+				<%= raw(n.title) %>				<%#= link_to fa_icon("edit"), edit_rubrik_neuigkeit_path(n.rubrik, n), remote: true if can? :edit, n %>
+			</h1>
+			<div itemprop="articleBody" style="font-size:large">
+				<%= raw(n.text) %>
+
+
+			</div>
+
+		</div>
+  </div>
+	<h1>
+ <% if n.has_calentries? %>
+  <div  href="#">
+    <%= fa_icon("calendar 2x")  %>
+    <%= n.relevant_calentry.text %>
+  </div>
+  <% elsif n.has_meeting? %>
+  <div  href="#">
+    <%= fa_icon("calendar 2x")  %>
+    <%= n.meeting.calentry.text unless n.meeting.calentry.nil? %>
+  </div>
+
+  <% end %>
+	</h1>
+ 	
+	</div>
+<%  i = i+1 %>
+<% end %>
+
+</div>
+
+<div class="ui-progressbar ui-widget ui-widget-content ui-corner-all" style="height:10px; z-index: 2000; left: 5px; right: 5px; bottom: 5px; height: 10px; position:absolute">
+  <div id="" class="ui-progressbar-value ui-widget-header ui-corner-left" style=""></div>
+</div>
+
+<script>
+$(function () {
+$('#jmpress').jmpress({
+    duration: {
+			barPropertyStart: '0',
+      barSelector: '.ui-progressbar-value'
+    },
+	initStep: function(element, eventData) {
+			console.log('We\'re changing to step: #' + $(element).attr('id') + '!');
+		}
+
+  });
+setTimeout(function(){
+     
+         window.location.reload();
+         /* or window.location = window.location.href; */
+     
+}, 100000);
+
+});
+</script>
+	</body>
diff --git a/app/views/home/intern.html.erb b/app/views/home/intern.html.erb
index 4dbf69d..edcae0b 100644
--- a/app/views/home/intern.html.erb
+++ b/app/views/home/intern.html.erb
@@ -7,7 +7,9 @@
       <%= link_to "Adressliste", internlist_fetprofiles_path ,class: :linkbox %></li>
  <li>     <%= link_to "Admin" , admin_home_index_path, class: :linkbox if current_user.has_role?(:fetadmin) %>
 </li>
-</ul>
+<li>
+<%= link_to ff_icon("ffi1-setting")+"Neue Oberfläche" , set_preferred_theme_user_path(current_user, params: {theme: "blue2"}), class: :linkbox if can? :set_preferred_theme , current_user %>
+</li></ul>
       <ul class="unstyled linkbox-list">
 	<li>  
 	  <% @themengruppen.each do |themengruppe| %>
diff --git a/app/views/layouts/_login.html.erb b/app/views/layouts/_login.html.erb
index 133ed37..9ba3425 100644
--- a/app/views/layouts/_login.html.erb
+++ b/app/views/layouts/_login.html.erb
@@ -7,11 +7,11 @@
  <%= current_user.email %> is logged in.
       
     </li>
-<li><%= link_to('Logout', destroy_user_session_path, :method => :delete) %>        </li>
+<li><%= link_to('Logout', destroy_user_session_path, :method => :delete,:id => "login_link") %>        </li>
   </ul>	
 </li>
 <% else %>
 <li>
-  <%= link_to('Login', new_user_session_path)  %>  
+  <%= link_to('Login', new_user_session_path, id:"login_link")  %>  
 </li>
 <% end %>
diff --git a/app/views/neuigkeiten/_mail.html.erb b/app/views/neuigkeiten/_mail.html.erb
new file mode 100644
index 0000000..543eea2
--- /dev/null
+++ b/app/views/neuigkeiten/_mail.html.erb
@@ -0,0 +1,10 @@
+<h1>
+  <%=  mail.title%>
+</h1>
+<%= content_tag(:img,"",src: "http://" + ActionMailer::Base.default_url_options[:host].to_s + mail.picture.big_thumb.url.to_s) %>
+<%=url_for controller: "neuigkeiten",action: :show, :id=>mail.id, only_path: false %>
+<%= raw(mail.text) %>
+<% mail.questions.each do |q| %>
+<%= render partial:"survey/questions/mail", object: q %>
+<% end  %>
+<%= link_to "Auf Fet.at weiterlesen", rubrik_neuigkeit_url(mail.rubrik, mail,:locale=>:de, :theme=>nil) %> 
diff --git a/app/views/neuigkeiten/_neuigkeit_view.html.erb b/app/views/neuigkeiten/_neuigkeit_view.html.erb
index f29e612..3d9a78e 100644
--- a/app/views/neuigkeiten/_neuigkeit_view.html.erb
+++ b/app/views/neuigkeiten/_neuigkeit_view.html.erb
@@ -16,7 +16,7 @@
 			<% end %>
   </div>
   <% unless neuigkeit_view.published? %> 
-    <div class="sticker sticker-red"> Not Published <%= link_to "Publish", publish_rubrik_neuigkeit_path(@neuigkeit.rubrik,@neuigkeit),remote:true, class: :btn if can? :publish, neuigkeit_view %></div> 
+    <div class="sticker sticker-red"> Not Published <%= link_to "Publish", publish_rubrik_neuigkeit_path(neuigkeit_view.rubrik,neuigkeit_view),remote:true, class: :btn if can? :publish, neuigkeit_view %></div> 
 	<% end %>
   <% unless neuigkeit_view.origurl.nil? || neuigkeit_view.origurl.empty? %>
 		<div class="alert"><%= link_to "Zitiert von "+ neuigkeit_view.origurl, neuigkeit_view.origurl %>
diff --git a/app/views/neuigkeiten/mail_preview.html.erb b/app/views/neuigkeiten/mail_preview.html.erb
new file mode 100644
index 0000000..31ad38f
--- /dev/null
+++ b/app/views/neuigkeiten/mail_preview.html.erb
@@ -0,0 +1,5 @@
+<%= link_to "send", mail_preview_rubrik_neuigkeit_path(@neuigkeit) %>
+<%= raw(@mail.subject) %>
+
+<hr />
+<%= raw(@mail.body) %>
diff --git a/app/views/news_mailer/daily_reminder.html.erb b/app/views/news_mailer/daily_reminder.html.erb
new file mode 100644
index 0000000..468e1e9
--- /dev/null
+++ b/app/views/news_mailer/daily_reminder.html.erb
@@ -0,0 +1,13 @@
+<%= stylesheet_link_tag "http://"+ActionMailer::Base.default_url_options[:host].to_s + "/assets/themes/blue2/application.css", :media=>"all"  %>
+
+<% @calentries.each do |ce| %>
+
+<% if can?(:show , ce.object) %>
+	<hr/>
+	<h1>	<%= render partial: "calentries/mail", object: ce %>
+	</h1>
+	<%= render partial: "neuigkeiten/mail", object: ce.object if ce.object.kind_of?(Neuigkeit)%>
+<% end  %>
+
+<% end %>
+	<hr/>
diff --git a/app/views/news_mailer/neuigkeit_mail.html.erb b/app/views/news_mailer/neuigkeit_mail.html.erb
index b66792b..b1c2da5 100644
--- a/app/views/news_mailer/neuigkeit_mail.html.erb
+++ b/app/views/news_mailer/neuigkeit_mail.html.erb
@@ -4,7 +4,7 @@
 <h1>
   <%=  @neuigkeit.title%>
 </h1>
-<%= content_tag(:img,"",src: "http://"+ActionMailer::Base.default_url_options[:host].to_s+@neuigkeit.picture.big_thumb.url) %>
+<%= content_tag(:img,"",src: "http://"+ActionMailer::Base.default_url_options[:host].to_s+@neuigkeit.picture.big_thumb.url.to_s) %>
 <%=url_for controller: "neuigkeiten",action: :show, :id=>@neuigkeit.id, only_path: false %>
 <%= raw(@neuigkeit.text) %>
 <% @neuigkeit.questions.each do |q| %>
diff --git a/app/views/themes/blue2/fetprofiles/show.html.erb b/app/views/themes/blue2/fetprofiles/show.html.erb
new file mode 100644
index 0000000..26180a8
--- /dev/null
+++ b/app/views/themes/blue2/fetprofiles/show.html.erb
@@ -0,0 +1,77 @@
+<%= content_for :header do %>
+<title>FET - <%=  @fetprofile.name %></title>
+<% unless @fetprofile.picture.url.nil?
+   picture_url=URI(root_url)
+   picture_url.path=@fetprofile.picture.portrait.url
+end
+%>
+
+<% set_meta_tags :og => {
+    :image => picture_url.to_s,
+    :title => @fetprofile.name.to_s ,
+    :type => "profile",
+    :url=>fetprofile_url(@fetprofile,:theme=>nil),
+:profile=> {
+  :first_name=>@fetprofile.vorname,
+  :last_name=>@fetprofile.nachname
+  }
+}
+%>
+<% set_meta_tags :og=>{:article=> {:published_time=>I18n.l(@neuigkeit.try(:datum).try(:to_date)) }} unless @neuigkeit.try(:datum).try(:to_date).nil? %>
+
+<%= display_meta_tags %>
+<% end %>
+
+
+<%= render 'fetprofiles/tabs' %>
+
+<div class="content-wrap content-column">
+
+<p id="notice"><%= notice %></p>
+<div style="max-width:70em" itemtype="http://schema.org/Person" itemscope>
+<meta itemprop="sameAs" content="<%= fetprofile_path(@fetprofile, theme: nil) %>"/>
+<meta itemprop="url" content="<%= fetprofile_path(@fetprofile, theme: nil) %>"/>
+  <div class="media">
+    <span class="pull-left" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
+      <span itemprop="thumbnail" itemscope itemtype="http://schema.org/ImageObject">
+	<%= image_tag @fetprofile.picture.portrait.url %>
+	<meta itemprop="url" content="<%= @fetprofile.picture.portrait.url%>" />    
+      </span>
+      <meta itemprop="url" content="<%= @fetprofile.picture.url%>" /> 
+      <meta itemprop="representativeOfPage" content="true" />
+    </span>
+    <div class="media-body">
+      <h2><span itemprop="givenName"><%= @fetprofile.vorname %></span><span itemprop="familyName"> <%= @fetprofile.nachname %></span><% unless @fetprofile.short.empty? %><span itemprop=""> <%= @fetprofile.short %> </span><% end %></h2>
+      <meta itemprop="name" content="<%= @fetprofile.name %>" /> 
+
+      <p itemprop="email">
+	<%= @fetprofile.fetmail %>
+      </p>
+      <p itemprop="description">
+	<%= @fetprofile.desc %>
+      </p>
+      <%= render partial: "interninfo", object: @fetprofile if can?(:seeintern, @fetprofile) %>
+	
+      <ul>
+	<% @memberships.each do |m| %>
+	<li>
+	  <%= link_to gremium_path(m.gremium) do %> <%= render m %><% end %>
+	  <%= link_to I18n.t('common.edit'), edit_fetprofile_membership_path(@fetprofile,m) if params["verwalten"] && can?(:edit, m)%>
+	  <%= link_to I18n.t('common.delete'), [@fetprofile, m], method: :delete, data: {confirm: I18n.t('common.sure_del')} if params["verwalten"] && can?(:delete, m ) %>
+	</li>
+	<% end %>
+      </ul>
+
+    </div>
+  </div>
+</div>
+<% if can?(:edit, @fetprofile) %>
+<div>
+	<span>
+	 <%= link_to ff_icon("icon-pencil")+I18n.t('common.edit'), edit_fetprofile_path(@fetprofile) if can?(:edit, @fetprofile) %>
+	 <%= link_to fa_icon("trash")+I18n.t('common.delete'), fetprofile_path(@fetprofile),method: :delete, data: { confirm: "Are you sure?" } if can?(:delete, @fetprofile) %>
+	</span>
+</div>
+<% end  %>
+      <%#= render 'layouts/pretty_toolbar' %>
+</div>
diff --git a/app/views/themes/blue2/home/index.html.erb b/app/views/themes/blue2/home/index.html.erb
index 481b871..0b9527b 100644
--- a/app/views/themes/blue2/home/index.html.erb
+++ b/app/views/themes/blue2/home/index.html.erb
@@ -46,7 +46,7 @@
 </div>
 
 <div class="span5">
-  <ul class="unstyled linklist">
+  <ul class="unstyled linkbox-list">
 	<% @neuigkeiten.each do |n| %>
 	<li><%= render n if can?(:show, n) %> </li>
 	<% end %>
diff --git a/app/views/themes/blue2/home/intern.html.erb b/app/views/themes/blue2/home/intern.html.erb
index 86dd73a..bd98825 100644
--- a/app/views/themes/blue2/home/intern.html.erb
+++ b/app/views/themes/blue2/home/intern.html.erb
@@ -3,7 +3,7 @@
   <div class="row-fluid">
     <div class="span6">
 			<div>
-			<ul class="linklist_block">
+			<ul class="linklist">
 				<li>
 					<%= link_to fa_icon("list")+"Adressliste", internlist_fetprofiles_path ,class: :linkbox %>
 				</li>
@@ -19,6 +19,10 @@
 <li>     
 					<%= link_to ff_icon("ffi1-setting")+"Meetings" , meetingtyps_path, class: :linkbox if current_user.has_role?(:fetadmin) %>
 				</li>
+<li>     
+					<%= link_to ff_icon("ffi1-setting")+"Alte Oberfläche" , set_preferred_theme_user_path(current_user, params: {theme: "blue1"}), class: :linkbox if can? :set_preferred_theme, current_user %>
+				</li>
+
 			</ul><br>
 		</div>
 			<div>Suche nach Protokollen
diff --git a/app/views/themes/blue2/neuigkeiten/_menu.html.erb b/app/views/themes/blue2/neuigkeiten/_menu.html.erb
index eb81f26..66f4b97 100644
--- a/app/views/themes/blue2/neuigkeiten/_menu.html.erb
+++ b/app/views/themes/blue2/neuigkeiten/_menu.html.erb
@@ -1,40 +1,43 @@
 <div class="toolbar-inline">
-	<%= link_to(fa_icon("edit"), edit_rubrik_neuigkeit_path( @neuigkeit.rubrik,  @neuigkeit), remote: true , class: "btn", title: "Edit") if can? :edit, @neuigkeit 
+	<%= link_to(fa_icon("edit"), edit_rubrik_neuigkeit_path( menu.rubrik,  menu), remote: true , class: "btn", title: "Edit") if can? :edit, menu 
 	%>
 	<span class="btn-group">
-		<%= link_to(fa_icon("paperclip"), "#", 	class: "btn", id: "attachments-form-open", title: "Attachments") if can? :edit, @neuigkeit 
+		<%= link_to(fa_icon("paperclip"), "#", 	class: "btn", id: "attachments-form-open", title: "Attachments") if can? :edit, menu 
 		%>	
-		<%= link_to(fa_icon("calendar-o"),	new_calentry_path(:object_id=>@neuigkeit.id, :object_type=>"Neuigkeit"), 	:remote=>true, class: :btn) if can? :edit, @neuigkeit 
+		<%= link_to(fa_icon("calendar-o"),	new_calentry_path(:object_id=>menu.id, :object_type=>"Neuigkeit"), 	:remote=>true, class: :btn) if can? :edit, menu 
 		%>
-		<%= link_to(fa_icon("link") , "#", id: "findlink-open",title: "Neue Verknüpfung" , class: "btn") if can? :find_link, @neuigkeit 
+		<%= link_to(fa_icon("link") , "#", id: "findlink-open",title: "Neue Verknüpfung" , class: "btn") if can? :find_link, menu 
 		%>
 		
 	</span>
 	
-	<%= new_question_for(@neuigkeit, fa_icon("question")) if can? :new, Survey::Question %>
+	<%= new_question_for(menu, fa_icon("question")) if can? :new, Survey::Question %>
  
 	<span class=" pull-right">
-		<%= link_to(fa_icon("globe"), publish_rubrik_neuigkeit_path(@neuigkeit.rubrik,@neuigkeit), title:  I18n.t('neuigkeit.publish'), class: "btn") if can?(:publish, @neuigkeit) && !@neuigkeit.published? 
+			<%= flag_link(menu, "important")%>
+			<%= flag_link(menu, "infoscreen")%>
+
+		<%= link_to(fa_icon("globe"), publish_rubrik_neuigkeit_path(menu.rubrik,menu), title:  I18n.t('neuigkeit.publish'), class: "btn") if can?(:publish, menu) && !menu.published? 
 		%>
-		<%= link_to(fa_stack("globe","ban"), unpublish_rubrik_neuigkeit_path(@neuigkeit.rubrik,@neuigkeit), :remote=>true, class: "btn stacked") if  can?(:unpublish, @neuigkeit) && @neuigkeit.published? 
+		<%= link_to(fa_stack("globe","ban"), unpublish_rubrik_neuigkeit_path(menu.rubrik,menu), :remote=>true, class: "btn stacked") if  can?(:unpublish, menu) && menu.published? 
 		%>
-		<% if @neuigkeit.published? %>
+		<% if menu.published? %>
 			<div class="dropdown" style=" display:inline"">
 				<a class="dropdown-toggle btn" data-toggle="dropdown" title="publish" href="#">
 					<%= fa_icon("mail-forward")%><span class="caret"></span>
 				</a>
 				<ul class="dropdown-menu">
-					<%= li_tag(link_to(fa_icon("facebook-square") + " post on facebook", publish_to_facebook_rubrik_neuigkeit_path(@neuigkeit.rubrik,@neuigkeit))) if can?(:publish, @neuigkeit) && @neuigkeit.published? 
+					<%= li_tag(link_to(fa_icon("facebook-square") + " post on facebook", publish_to_facebook_rubrik_neuigkeit_path(menu.rubrik,menu))) if can?(:publish, menu) && menu.published? 
 					%>
 					
-					<%= li_tag(link_to(fa_icon("envelope-o") + " send mail", mail_to_fet_rubrik_neuigkeit_path(@neuigkeit.rubrik,@neuigkeit))) if can?(:publish, @neuigkeit) && @neuigkeit.published? 
+					<%= li_tag(link_to(fa_icon("envelope-o") + " send mail", mail_preview_rubrik_neuigkeit_path(menu.rubrik,menu))) if can?(:publish, menu) && menu.published? 
 					%>
 				</ul>
 			</div>
 		<% end  %>
 	</span>
 	<div class="ui-dialog" id="attachments-form">
-		<%= render_new_attachments_for(@neuigkeit, fa_icon("plus"), {class: "btn"})  %>
+		<%= render_new_attachments_for(menu, fa_icon("plus"), {class: "btn"})  %>
 	</div>
 </div>
 <script>
diff --git a/app/views/themes/blue2/neuigkeiten/_neuigkeit_view.html.erb b/app/views/themes/blue2/neuigkeiten/_neuigkeit_view.html.erb
index f8a855f..6d0e41c 100644
--- a/app/views/themes/blue2/neuigkeiten/_neuigkeit_view.html.erb
+++ b/app/views/themes/blue2/neuigkeiten/_neuigkeit_view.html.erb
@@ -4,8 +4,8 @@
 	<%= meta_itemprop("url", neuigkeit_url(neuigkeit_view,:theme=>nil)) %>
   
 	<div>
-<% cache("menu_neuigkeit"+ @neuigkeit.id.to_s + can?(:edit,@neuigkeit).to_s + can?(:find_link, @neuigkeit).to_s + can?(:new, Survey::Question).to_s + can?(:publish, @neuigkeit).to_s + can?(:unpublish, @neuigkeit).to_s + @neuigkeit.published?.to_s ) do %>
-		<%= render partial: "menu" %>		
+<% cache("menu_neuigkeit"+ neuigkeit_view.id.to_s + can?(:edit,neuigkeit_view).to_s + can?(:find_link, neuigkeit_view).to_s + can?(:new, Survey::Question).to_s + can?(:publish, neuigkeit_view).to_s + can?(:unpublish, neuigkeit_view).to_s + neuigkeit_view.published?.to_s ) do %>
+		<%= render partial: "neuigkeiten/menu", object: neuigkeit_view %>		
 <%  end %>
 	</div>  
 	<div>
@@ -26,7 +26,7 @@
   </div>
 
   <% unless neuigkeit_view.published? %> 
-    <div class="sticker sticker-red"> Not Published <%= link_to "Publish", publish_rubrik_neuigkeit_path(@neuigkeit.rubrik,@neuigkeit),remote:true, class: :btn if can? :publish, neuigkeit_view %></div> 
+    <div class="sticker sticker-red"> Not Published <%= link_to "Publish", publish_rubrik_neuigkeit_path(neuigkeit_view.rubrik,neuigkeit_view),remote:true, class: :btn if can? :publish, neuigkeit_view %></div> 
 	<% end %>
   <% unless neuigkeit_view.origurl.nil? || neuigkeit_view.origurl.empty? %>
 		<div class="alert"><%= link_to "Zitiert von "+ neuigkeit_view.origurl, neuigkeit_view.origurl %>
diff --git a/app/views/themes/blue2/neuigkeiten/show.html.erb b/app/views/themes/blue2/neuigkeiten/show.html.erb
index 24ad42c..f5ee3fb 100755
--- a/app/views/themes/blue2/neuigkeiten/show.html.erb
+++ b/app/views/themes/blue2/neuigkeiten/show.html.erb
@@ -41,8 +41,9 @@
 </div>
 <div class="fb-like" data-href"<%= rubrik_neuigkeit_url(@rubrik,@neuigkeit,{themes: nil, locale: nil})%>" data-layout="standard" data-action="like" data-show-faces="true" data-share="true"></div>
 
+<%= render_comments_for(@neuigkeit) %>
 
-<%= link_to fa_icon("link") + "Neue Verknüpfung" , "#", id: "findlink-open" if can? :find_link, @neuigkeit %>
+<%# link_to fa_icon("link") + "Neue Verknüpfung" , "#", id: "findlink-open" if can? :find_link, @neuigkeit %>
 
 <% cache(cache_array_key(@neuigkeit.nlinks, "NLinks")) do %>
 	<%= render partial: 'neuigkeiten/nlink_list_whole', :object=>@neuigkeit.nlinks %>
diff --git a/app/views/users/index.html.erb b/app/views/users/index.html.erb
index 30fc2c1..782ca37 100755
--- a/app/views/users/index.html.erb
+++ b/app/views/users/index.html.erb
@@ -33,7 +33,7 @@
     </td>
     <td>
       <%= semantic_fields_for "users[#{user.id}]", user do |f|%>
-      <%= f.input :fetprofile ,:label=>false , :as=>:select , :collection=>Fetprofile.all %>
+      <%= f.input :fetprofile ,:label=>false , :as=>:select , :collection=>Fetprofile.order(:vorname,:nachname) %>
 
       <% end %>
     </td>
diff --git a/config/environments/development.rb b/config/environments/development.rb
index e82fc64..c4acee2 100755
--- a/config/environments/development.rb
+++ b/config/environments/development.rb
@@ -16,7 +16,7 @@ Fetsite::Application.configure do
   # Don't care if the mailer can't send
   config.action_mailer.raise_delivery_errors = true
   config.action_mailer.delivery_method =:sendmail
-  config.action_mailer.default_url_options = {}#{:host=> "localhost", :port=>3000} #  :host => 'glonass.htu.tuwien.ac.at' }
+  config.action_mailer.default_url_options = {:host=> "localhost", :port=>3000} #  :host => 'glonass.htu.tuwien.ac.at' }
   # Print deprecation notices to the Rails logger
   config.active_support.deprecation = :log
 
diff --git a/config/routes.rb b/config/routes.rb
index 8416b83..896190e 100755
--- a/config/routes.rb
+++ b/config/routes.rb
@@ -8,7 +8,20 @@
        resources :comments, contstraints: {id: /[0-9]+/}, only: :show
 
 
-    
+## Inserted for testing tests
+      resources :members , controller: :fetprofiles , as: :fetprofiles do
+        collection do
+          get 'verwalten'
+          get 'internlist'
+        end
+      end
+     resources :gremien do 
+        collection do 
+          get 'verwalten'
+        end
+      end
+#
+    # #-------------------------
 
    namespace :survey do
      resources :questions do
@@ -26,7 +39,12 @@
   themes_for_rails
   devise_for :users, :controllers => { :omniauth_callbacks => "users/omniauth_callbacks" }
   resources :home, :only=>[:index] do
-  end
+end
+resources :emails, :only=>[:index] do
+     collection do
+ get :daily_reminder
+    end
+end
   get ':locale', constraints: {locale: /en|de/}, action: :language,controller: :home, as: "language"
   scope '(:locale)/admin' do
     resources :users, :only=>[]  do 
@@ -35,6 +53,7 @@
         post :all_update
       end
       member do
+         get :set_preferred_theme
         get :fb_set_default_publish_page
       end
     end
@@ -60,6 +79,7 @@
     scope '(t/:theme)' do
       get "" , controller: :home, action: :index
       get "intern" , controller: :home, action: :intern
+      get "infoscreen" , controller: :home, action: :infoscreen
       get "beispielsammlung", to: redirect('/studien')
       scope '(:ansicht)' do
         resources :studien, :only=>[:new,:edit,:update,:destroy,:show] do
@@ -125,12 +145,12 @@
           get 'verwalten'
         end
       end
-      resources :fetprofiles, as: :fetprofiles_bak do
-        collection do 
-          get 'verwalten'
-          get 'internlist'
-        end
-      end
+#      resources :fetprofiles, as: :fetprofiles_bak do
+#        collection do 
+#          get 'verwalten'
+#          get 'internlist'
+#        end
+#      end
       resources :members , controller: :fetprofiles , as: :fetprofiles do
         collection do
           get 'verwalten'
@@ -165,7 +185,7 @@
             get 'publish_to_facebook'
             get 'mail_to_fet'
             get 'mail_preview'
- 
+             get 'flag'
           end
           collection do
             get 'newsletter_preview'
diff --git a/db/migrate/20150913090628_add_infoscreen_to_neuigkeit.rb b/db/migrate/20150913090628_add_infoscreen_to_neuigkeit.rb
new file mode 100644
index 0000000..de511c4
--- /dev/null
+++ b/db/migrate/20150913090628_add_infoscreen_to_neuigkeit.rb
@@ -0,0 +1,7 @@
+class AddInfoscreenToNeuigkeit < ActiveRecord::Migration
+  def change
+    add_column :neuigkeiten, :flag_infoscreen, :boolean, default: false
+    add_column :themen, :flag_infoscreen, :boolean, default: false
+
+  end
+end
diff --git a/false b/false
new file mode 100644
index 0000000..e69de29
diff --git a/solr/conf/schema.xml b/solr/conf/schema.xml
index adcb9a8..8da24f2 100644
--- a/solr/conf/schema.xml
+++ b/solr/conf/schema.xml
@@ -60,11 +60,17 @@
     <fieldType name="rand" class="solr.RandomSortField" omitNorms="true"/>
     <!-- *** This fieldType is used by Sunspot! *** -->
     <fieldType name="text" class="solr.TextField" omitNorms="false">
-      <analyzer>
-        <tokenizer class="solr.StandardTokenizerFactory"/>
-        <filter class="solr.StandardFilterFactory"/>
+      <analyzer type="index">
+        <tokenizer class="solr.WhitespaceTokenizerFactory"/>
         <filter class="solr.LowerCaseFilterFactory"/>
-        <filter class="solr.PorterStemFilterFactory"/>
+        <filter class="solr.NGramFilterFactory" minGramSize="2" maxGramSize="30"/>
+        <filter class="solr.TrimFilterFactory" />
+        <filter class="solr.EdgeNGramFilterFactory" minGramSize="2" maxGramSize="30"/>
+      </analyzer>
+      <analyzer type="query">
+	<tokenizer class="solr.WhitespaceTokenizerFactory"/>
+	<filter class="solr.LowerCaseFilterFactory"/>
+	<filter class="solr.TrimFilterFactory" />
       </analyzer>
     </fieldType>
     <!-- *** This fieldType is used by Sunspot! *** -->
diff --git a/spec/controllers/fetprofiles_controller_spec.rb b/spec/controllers/fetprofiles_controller_spec.rb
index be40005..46607d3 100644
--- a/spec/controllers/fetprofiles_controller_spec.rb
+++ b/spec/controllers/fetprofiles_controller_spec.rb
@@ -1,160 +1,185 @@
 require 'spec_helper'
 
-# This spec was generated by rspec-rails when you ran the scaffold generator.
-# It demonstrates how one might use RSpec to specify the controller code that
-# was generated by Rails when you ran the scaffold generator.
-#
-# It assumes that the implementation code is generated by the rails scaffold
-# generator.  If you are using any extension libraries to generate different
-# controller code, this generated spec may or may not pass.
-#
-# It only uses APIs available in rails and/or rspec-rails.  There are a number
-# of tools you can use to make these specs even more expressive, but we're
-# sticking to rails and rspec-rails APIs to keep things simple and stable.
-#
-# Compared to earlier versions of this generator, there is very limited use of
-# stubs and message expectations in this spec.  Stubs are only used when there
-# is no simpler way to get a handle on the object needed for the example.
-# Message expectations are only used when there is no simpler way to specify
-# that an instance is receiving a specific message.
+describe FetprofilesController, :type => :controller  do
+  let(:valid_update_attributes) { {"vorname"=>"Neuer Vorname"}  }
+  #  let(:valid_session) { {locale: :de} }
 
-describe FetprofilesController do
+  def self.create_fetprofile
+    before(:each) do
+      @fetprofile = FactoryGirl.create(:fetprofile)    
+    end
+  end
+  def self.create_active_fetprofile
+    before(:each) do
+      @fetprofile = FactoryGirl.create(:fetprofile, active: true)    
+    end
+  end
 
-  # This should return the minimal set of attributes required to create a valid
-  # Fetprofile. As you add validations to Fetprofile, be sure to
-  # adjust the attributes here as well.
-  let(:valid_attributes) { { "vorname" => "MyString" } }
-
-  # This should return the minimal set of values that should be in the session
-  # in order to pass any filters (e.g. authentication) defined in
-  # FetprofilesController. Be sure to keep this updated too.
-  let(:valid_session) { {} }
+  let(:object_variable) {:fetprofile}    
+  let(:assigned_object_variable) {@fetprofile}
+  let(:object_class) {Fetprofile}
 
   describe "GET index" do
-    it "assigns all fetprofiles as @fetprofiles" do
-      fetprofile = Fetprofile.create! valid_attributes
-      get :index, {}, valid_session
-      assigns(:fetprofiles).should eq([fetprofile])
-    end
+    create_active_fetprofile
+    subject(:action) {  get :index, {} }
+    let(:object_variable) {:fetprofiles}    
+    let(:assigned_object_variable) {[@fetprofile]}
+    it_behaves_like "it is success"
+    it_behaves_like "it assigns object"  
   end
 
   describe "GET show" do
-    it "assigns the requested fetprofile as @fetprofile" do
-      fetprofile = Fetprofile.create! valid_attributes
-      get :show, {:id => fetprofile.to_param}, valid_session
-      assigns(:fetprofile).should eq(fetprofile)
-    end
+    create_fetprofile
+    subject(:action) { get :show, {:id => @fetprofile.to_param}}
+    it_behaves_like "it is success"
+    it_behaves_like "it assigns object"
+      it "renders the 'show' template" do
+        expect(action).to render_template("show")
+      end
+      it "assigns memberships" do
+        action
+        expect(assigns(:memberships)).to be_a(ActiveRecord::Relation)
+      end
+
   end
 
   describe "GET new" do
-    it "assigns a new fetprofile as @fetprofile" do
-      get :new, {}, valid_session
-      assigns(:fetprofile).should be_a_new(Fetprofile)
+    subject(:action) { get :new, {}}
+    describe "with fetuser" do
+      login_fet_user
+      it_behaves_like "it assigns new object"
+      it_behaves_like "it is success"  
     end
+    describe "without user" do 
+      logout_user
+      it_behaves_like "it is restricted"
+    end 
+
   end
 
   describe "GET edit" do
+
+    subject(:action) {get :edit, :id=>@fetprofile.to_param}
+    login_fet_user
+    create_fetprofile
+    it_behaves_like "it is success"
+    it_behaves_like "it assigns object"
+      it "assigns memberships" do
+        action
+        expect(assigns(:memberships)).to be_a(ActiveRecord::Relation)
+      end
+
     it "assigns the requested fetprofile as @fetprofile" do
-      fetprofile = Fetprofile.create! valid_attributes
-      get :edit, {:id => fetprofile.to_param}, valid_session
-      assigns(:fetprofile).should eq(fetprofile)
+      expect{action}.to change {assigns(:fetprofile)}.to(@fetprofile)
+ #     expect(assigns(:fetprofile)).to eq(@fetprofile)
     end
+    describe "without user" do 
+      logout_user
+      it_behaves_like "it is restricted"
+    end 
+    
   end
 
   describe "POST create" do
-    describe "with valid params" do
-      it "creates a new Fetprofile" do
-        expect {
-          post :create, {:fetprofile => valid_attributes}, valid_session
-        }.to change(Fetprofile, :count).by(1)
-      end
+    subject(:action){post :create, {:fetprofile => FactoryGirl.attributes_for(:fetprofile),:format=>:html}}
 
-      it "assigns a newly created fetprofile as @fetprofile" do
-        post :create, {:fetprofile => valid_attributes}, valid_session
-        assigns(:fetprofile).should be_a(Fetprofile)
-        assigns(:fetprofile).should be_persisted
+    login_fet_user
+    describe "with valid params" do
+
+      it "has a 302 status code" do
+        expect(action.status).to eq(302)
+      end      
+      it "creates a new Fetprofile" do
+        expect{action}.to change(Fetprofile, :count).by(1)
+      end
+      
+      it_behaves_like "it assigns persisted object"
+
+      it "assigns memberships" do
+        action
+        expect(assigns(:memberships)).to be_a(ActiveRecord::Relation)
       end
 
       it "redirects to the created fetprofile" do
-        post :create, {:fetprofile => valid_attributes}, valid_session
-        response.should redirect_to(Fetprofile.last)
+        expect(action).to redirect_to assigns(:fetprofile)
       end
     end
 
     describe "with invalid params" do
-      it "assigns a newly created but unsaved fetprofile as @fetprofile" do
-        # Trigger the behavior that occurs when invalid params are submitted
-        Fetprofile.any_instance.stub(:save).and_return(false)
-        post :create, {:fetprofile => { "vorname" => "invalid value" }}, valid_session
-        assigns(:fetprofile).should be_a_new(Fetprofile)
+      has_invalid_params
+      it "assigns memberships" do
+        action
+        expect(assigns(:memberships)).to be_a(ActiveRecord::Relation)
       end
 
+      it "assigns a newly created but unsaved fetprofile as @fetprofile" do
+        action
+        assigns(:fetprofile).should be_a_new(Fetprofile)
+        expect(assigns(:fetprofile)).not_to be_persisted
+      end
       it "re-renders the 'new' template" do
-        # Trigger the behavior that occurs when invalid params are submitted
-        Fetprofile.any_instance.stub(:save).and_return(false)
-        post :create, {:fetprofile => { "vorname" => "invalid value" }}, valid_session
-        response.should render_template("new")
+        expect(action).to render_template("new")
       end
     end
+    describe "without user" do 
+      logout_user
+      it_behaves_like "it is restricted"
+    end 
+
   end
 
   describe "PUT update" do
-    describe "with valid params" do
-      it "updates the requested fetprofile" do
-        fetprofile = Fetprofile.create! valid_attributes
-        # Assuming there are no other fetprofiles in the database, this
-        # specifies that the Fetprofile created on the previous line
-        # receives the :update_attributes message with whatever params are
-        # submitted in the request.
-        Fetprofile.any_instance.should_receive(:update_attributes).with({ "vorname" => "MyString" })
-        put :update, {:id => fetprofile.to_param, :fetprofile => { "vorname" => "MyString" }}, valid_session
-      end
+    let(:action) { put :update, {:id => @fetprofile.to_param, :fetprofile => {"vorname"=>"neuerName"}} }
+    
+    create_fetprofile
+    login_fet_user
 
-      it "assigns the requested fetprofile as @fetprofile" do
-        fetprofile = Fetprofile.create! valid_attributes
-        put :update, {:id => fetprofile.to_param, :fetprofile => valid_attributes}, valid_session
-        assigns(:fetprofile).should eq(fetprofile)
+    describe "with valid params" do
+      it_behaves_like "it assigns object"
+
+      it "updates the requested fetprofile" do
+       expect { action }.to change{Fetprofile.find(@fetprofile.id).vorname}.to("neuerName")
       end
+      it_behaves_like "it assigns persisted object"
 
       it "redirects to the fetprofile" do
-        fetprofile = Fetprofile.create! valid_attributes
-        put :update, {:id => fetprofile.to_param, :fetprofile => valid_attributes}, valid_session
-        response.should redirect_to(fetprofile)
+        expect(action).to redirect_to(@fetprofile)
       end
     end
 
     describe "with invalid params" do
-      it "assigns the fetprofile as @fetprofile" do
-        fetprofile = Fetprofile.create! valid_attributes
-        # Trigger the behavior that occurs when invalid params are submitted
-        Fetprofile.any_instance.stub(:save).and_return(false)
-        put :update, {:id => fetprofile.to_param, :fetprofile => { "vorname" => "invalid value" }}, valid_session
-        assigns(:fetprofile).should eq(fetprofile)
-      end
-
+      has_invalid_params
+      it_behaves_like "it assigns object"
       it "re-renders the 'edit' template" do
-        fetprofile = Fetprofile.create! valid_attributes
-        # Trigger the behavior that occurs when invalid params are submitted
-        Fetprofile.any_instance.stub(:save).and_return(false)
-        put :update, {:id => fetprofile.to_param, :fetprofile => { "vorname" => "invalid value" }}, valid_session
-        response.should render_template("edit")
+        expect(action).to render_template("edit")
       end
     end
+    describe "without user" do 
+      logout_user
+      it_behaves_like "it is restricted"
+    end 
   end
 
   describe "DELETE destroy" do
+    login_fet_user
+    create_fetprofile
+    subject(:action) { delete :destroy, {:id => @fetprofile.to_param}}
+
     it "destroys the requested fetprofile" do
-      fetprofile = Fetprofile.create! valid_attributes
       expect {
-        delete :destroy, {:id => fetprofile.to_param}, valid_session
+       action
       }.to change(Fetprofile, :count).by(-1)
     end
 
     it "redirects to the fetprofiles list" do
-      fetprofile = Fetprofile.create! valid_attributes
-      delete :destroy, {:id => fetprofile.to_param}, valid_session
+      action
       response.should redirect_to(fetprofiles_url)
     end
+    describe "without user" do 
+      logout_user
+      it_behaves_like "it is restricted"
+    end 
+
   end
 
 end
diff --git a/spec/controllers/gremien_controller_spec.rb b/spec/controllers/gremien_controller_spec.rb
index 6045afe..03dfc6b 100644
--- a/spec/controllers/gremien_controller_spec.rb
+++ b/spec/controllers/gremien_controller_spec.rb
@@ -1,160 +1,179 @@
 require 'spec_helper'
 
-# This spec was generated by rspec-rails when you ran the scaffold generator.
-# It demonstrates how one might use RSpec to specify the controller code that
-# was generated by Rails when you ran the scaffold generator.
-#
-# It assumes that the implementation code is generated by the rails scaffold
-# generator.  If you are using any extension libraries to generate different
-# controller code, this generated spec may or may not pass.
-#
-# It only uses APIs available in rails and/or rspec-rails.  There are a number
-# of tools you can use to make these specs even more expressive, but we're
-# sticking to rails and rspec-rails APIs to keep things simple and stable.
-#
-# Compared to earlier versions of this generator, there is very limited use of
-# stubs and message expectations in this spec.  Stubs are only used when there
-# is no simpler way to get a handle on the object needed for the example.
-# Message expectations are only used when there is no simpler way to specify
-# that an instance is receiving a specific message.
+describe GremienController, :type => :controller  do
+  let(:valid_update_attributes) { {"name"=>"NeuesGremium"}  }
+  #  let(:valid_session) { {locale: :de} }
 
-describe GremienController do
+  def self.create_gremium
+    before(:each) do
+      @gremium = FactoryGirl.create(:gremium)    
+    end
+  end
+#  def self.create_active_gremium
+#    before(:each) do
+#      @gremium = FactoryGirl.create(:gremium, active: true)    
+#    end
+#  end
 
-  # This should return the minimal set of attributes required to create a valid
-  # Gremium. As you add validations to Gremium, be sure to
-  # adjust the attributes here as well.
-  let(:valid_attributes) { { "name" => "MyString" } }
-
-  # This should return the minimal set of values that should be in the session
-  # in order to pass any filters (e.g. authentication) defined in
-  # GremienController. Be sure to keep this updated too.
-  let(:valid_session) { {} }
+  let(:object_variable) {:gremium}    
+  let(:assigned_object_variable) {@gremium}
+  let(:object_class) {Gremium}
 
   describe "GET index" do
-    it "assigns all gremien as @gremien" do
-      gremium = Gremium.create! valid_attributes
-      get :index, {}, valid_session
-      assigns(:gremien).should eq([gremium])
-    end
+    create_gremium
+    subject(:action) {  get :index, {} }
+    let(:object_variable) {:gremien}    
+    let(:assigned_object_variable) {[@gremium]}
+    it_behaves_like "it is success"
+    it_behaves_like "it assigns object"  
   end
 
   describe "GET show" do
-    it "assigns the requested gremium as @gremium" do
-      gremium = Gremium.create! valid_attributes
-      get :show, {:id => gremium.to_param}, valid_session
-      assigns(:gremium).should eq(gremium)
-    end
+    create_gremium
+    subject(:action) { get :show, {:id => @gremium.to_param}}
+    it_behaves_like "it is success"
+    it_behaves_like "it assigns object"
+      it "renders the 'show' template" do
+        expect(action).to render_template("show")
+      end
+      it "assigns memberships" do
+        action
+        expect(assigns(:memberships)).to be_a(ActiveRecord::Relation)
+      end
+
   end
 
   describe "GET new" do
-    it "assigns a new gremium as @gremium" do
-      get :new, {}, valid_session
-      assigns(:gremium).should be_a_new(Gremium)
+    subject(:action) { get :new, {}}
+    describe "with fetuser" do
+      login_fet_user
+      it_behaves_like "it assigns new object"
+      it_behaves_like "it is success"  
     end
+    describe "without user" do 
+      logout_user
+      it_behaves_like "it is restricted"
+    end 
+
   end
 
   describe "GET edit" do
+
+    subject(:action) {get :edit, :id=>@gremium.to_param}
+    login_fet_user
+    create_gremium
+    it_behaves_like "it is success"
+    it_behaves_like "it assigns object"
+      it "assigns memberships" do
+        action
+        expect(assigns(:memberships)).to be_a(ActiveRecord::Relation)
+      end
+
     it "assigns the requested gremium as @gremium" do
-      gremium = Gremium.create! valid_attributes
-      get :edit, {:id => gremium.to_param}, valid_session
-      assigns(:gremium).should eq(gremium)
+      expect{action}.to change {assigns(:gremium)}.to(@gremium)
+ #     expect(assigns(:gremium)).to eq(@gremium)
     end
+    describe "without user" do 
+      logout_user
+      it_behaves_like "it is restricted"
+    end 
+    
   end
 
   describe "POST create" do
-    describe "with valid params" do
-      it "creates a new Gremium" do
-        expect {
-          post :create, {:gremium => valid_attributes}, valid_session
-        }.to change(Gremium, :count).by(1)
-      end
+    subject(:action){post :create, {:gremium => FactoryGirl.attributes_for(:gremium),:format=>:html}}
 
-      it "assigns a newly created gremium as @gremium" do
-        post :create, {:gremium => valid_attributes}, valid_session
-        assigns(:gremium).should be_a(Gremium)
-        assigns(:gremium).should be_persisted
+    login_fet_user
+    describe "with valid params" do
+
+      it "has a 302 status code" do
+        expect(action.status).to eq(302)
+      end      
+      it "creates a new Gremium" do
+        expect{action}.to change(Gremium, :count).by(1)
       end
+      
+      it_behaves_like "it assigns persisted object"
+
 
       it "redirects to the created gremium" do
-        post :create, {:gremium => valid_attributes}, valid_session
-        response.should redirect_to(Gremium.last)
+        expect(action).to redirect_to assigns(:gremium)
       end
     end
 
     describe "with invalid params" do
-      it "assigns a newly created but unsaved gremium as @gremium" do
-        # Trigger the behavior that occurs when invalid params are submitted
-        Gremium.any_instance.stub(:save).and_return(false)
-        post :create, {:gremium => { "name" => "invalid value" }}, valid_session
-        assigns(:gremium).should be_a_new(Gremium)
-      end
+      has_invalid_params
+   
 
+      it "assigns a newly created but unsaved gremium as @gremium" do
+        action
+        assigns(:gremium).should be_a_new(Gremium)
+        expect(assigns(:gremium)).not_to be_persisted
+      end
       it "re-renders the 'new' template" do
-        # Trigger the behavior that occurs when invalid params are submitted
-        Gremium.any_instance.stub(:save).and_return(false)
-        post :create, {:gremium => { "name" => "invalid value" }}, valid_session
-        response.should render_template("new")
+        expect(action).to render_template("new")
       end
     end
+    describe "without user" do 
+      logout_user
+      it_behaves_like "it is restricted"
+    end 
+
   end
 
   describe "PUT update" do
-    describe "with valid params" do
-      it "updates the requested gremium" do
-        gremium = Gremium.create! valid_attributes
-        # Assuming there are no other gremien in the database, this
-        # specifies that the Gremium created on the previous line
-        # receives the :update_attributes message with whatever params are
-        # submitted in the request.
-        Gremium.any_instance.should_receive(:update_attributes).with({ "name" => "MyString" })
-        put :update, {:id => gremium.to_param, :gremium => { "name" => "MyString" }}, valid_session
-      end
+    let(:action) { put :update, {:id => @gremium.to_param, :gremium => {"name"=>"neuerName"}} }
+    
+    create_gremium
+    login_fet_user
 
-      it "assigns the requested gremium as @gremium" do
-        gremium = Gremium.create! valid_attributes
-        put :update, {:id => gremium.to_param, :gremium => valid_attributes}, valid_session
-        assigns(:gremium).should eq(gremium)
+    describe "with valid params" do
+      it_behaves_like "it assigns object"
+
+      it "updates the requested gremium" do
+       expect { action }.to change{Gremium.find(@gremium.id).name}.to("neuerName")
       end
+      it_behaves_like "it assigns persisted object"
 
       it "redirects to the gremium" do
-        gremium = Gremium.create! valid_attributes
-        put :update, {:id => gremium.to_param, :gremium => valid_attributes}, valid_session
-        response.should redirect_to(gremium)
+        expect(action).to redirect_to(@gremium)
       end
     end
 
     describe "with invalid params" do
-      it "assigns the gremium as @gremium" do
-        gremium = Gremium.create! valid_attributes
-        # Trigger the behavior that occurs when invalid params are submitted
-        Gremium.any_instance.stub(:save).and_return(false)
-        put :update, {:id => gremium.to_param, :gremium => { "name" => "invalid value" }}, valid_session
-        assigns(:gremium).should eq(gremium)
-      end
-
+      has_invalid_params
+      it_behaves_like "it assigns object"
       it "re-renders the 'edit' template" do
-        gremium = Gremium.create! valid_attributes
-        # Trigger the behavior that occurs when invalid params are submitted
-        Gremium.any_instance.stub(:save).and_return(false)
-        put :update, {:id => gremium.to_param, :gremium => { "name" => "invalid value" }}, valid_session
-        response.should render_template("edit")
+        expect(action).to render_template("edit")
       end
     end
+    describe "without user" do 
+      logout_user
+      it_behaves_like "it is restricted"
+    end 
   end
 
   describe "DELETE destroy" do
+    login_fet_user
+    create_gremium
+    subject(:action) { delete :destroy, {:id => @gremium.to_param}}
+
     it "destroys the requested gremium" do
-      gremium = Gremium.create! valid_attributes
       expect {
-        delete :destroy, {:id => gremium.to_param}, valid_session
+       action
       }.to change(Gremium, :count).by(-1)
     end
 
     it "redirects to the gremien list" do
-      gremium = Gremium.create! valid_attributes
-      delete :destroy, {:id => gremium.to_param}, valid_session
+      action
       response.should redirect_to(gremien_url)
     end
+    describe "without user" do 
+      logout_user
+      it_behaves_like "it is restricted"
+    end 
+
   end
 
 end
+
diff --git a/spec/controllers/shared_examples/basic.rb b/spec/controllers/shared_examples/basic.rb
new file mode 100644
index 0000000..8da6780
--- /dev/null
+++ b/spec/controllers/shared_examples/basic.rb
@@ -0,0 +1,42 @@
+  shared_examples "it is success" do
+    it "has a 200 status code" do
+      action
+      expect(response.status).to eq(200)
+    end
+    it "is success" do
+      action
+        expect(response).to be_success
+    end
+  end
+  shared_examples "it assigns object" do
+    it "assigns object variable" do 
+      action
+      expect(assigns(object_variable)).to eq(assigned_object_variable)
+    end
+  end
+  shared_examples "it assigns new object" do
+    it "assigns new object" do
+      action
+      expect(assigns(object_variable)).to be_a_new(object_class)
+      expect(assigns(object_variable)).not_to be_persisted
+
+    end
+  end
+  shared_examples "it assigns persisted object" do
+    it "assigns new object" do
+      action
+        expect(assigns(object_variable)).to be_a(object_class)
+        expect(assigns(object_variable)).to be_persisted
+    end
+  end
+
+  shared_examples "it is restricted" do
+    it "is expected to raise error" do
+      bypass_rescue
+      expect { action }.to raise_error(CanCan::AccessDenied)
+    end
+    it "is not success" do
+      action
+      expect(response).not_to be_success
+    end
+  end
diff --git a/spec/factories/attachments.rb b/spec/factories/attachments.rb
index 9c31968..4bec5f0 100644
--- a/spec/factories/attachments.rb
+++ b/spec/factories/attachments.rb
@@ -3,5 +3,7 @@
 FactoryGirl.define do
   factory :attachment do
     name "MyString"
+    datei { Rack::Test::UploadedFile.new(File.join(Rails.root,'public','fetlogo.png'))}
+    flag_titlepic false
   end
 end
diff --git a/spec/factories/beispiele.rb b/spec/factories/beispiele.rb
index f9cfcdf..861645f 100644
--- a/spec/factories/beispiele.rb
+++ b/spec/factories/beispiele.rb
@@ -2,5 +2,9 @@
 
 FactoryGirl.define do
   factory :beispiel do
+    name "BSP1"
+    desc "sdf"
+    datum Date.today
+    beispieldatei { Rack::Test::UploadedFile.new(File.join(Rails.root,'public','fetlogo.png'))}
   end
 end
diff --git a/spec/factories/fetprofiles.rb b/spec/factories/fetprofiles.rb
index 8576a20..ec37f92 100644
--- a/spec/factories/fetprofiles.rb
+++ b/spec/factories/fetprofiles.rb
@@ -9,5 +9,23 @@ FactoryGirl.define do
     desc "MyText"
     picture "MyString"
     active false
+    birth_month 4
+    birth_day 2
+    factory :fetprofile2 do 
+      vorname "Sarah"
+      nachname "Nachname2"
+      short "j"
+    end
+    factory :fetprofile3 do 
+      vorname "Thomas"
+      nachname "Mustermann"
+    end
+    factory :fetprofile_withadress do
+      street "some street"
+      plz "1231"
+      city "vienna"
+      telnr "sdf tel nummer"
+      hdynr "sdf hdy nummer"
+    end
   end
 end
diff --git a/spec/factories/gremien.rb b/spec/factories/gremien.rb
index fcce55d..b85811e 100644
--- a/spec/factories/gremien.rb
+++ b/spec/factories/gremien.rb
@@ -1,9 +1,11 @@
+# -*- coding: utf-8 -*-
+
 # Read about factories at https://github.com/thoughtbot/factory_girl
 
 FactoryGirl.define do
   factory :gremium do
-    name "MyString"
-    desc "MyText"
-    typ "MyString"
-  end
+    name "Kommission"
+    desc "Das ist eine Kommission die sich mit irgendwas beschäftigt"
+    typ 1
+   end
 end
diff --git a/spec/factories/logo2014_64.png b/spec/factories/logo2014_64.png
new file mode 100644
index 0000000..10b2ecf
Binary files /dev/null and b/spec/factories/logo2014_64.png differ
diff --git a/spec/factories/lvas.rb b/spec/factories/lvas.rb
index 7a0091b..5e9442f 100644
--- a/spec/factories/lvas.rb
+++ b/spec/factories/lvas.rb
@@ -2,5 +2,13 @@
 
 FactoryGirl.define do
   factory :lva do
+    name "Vorlesung 1"
+    desc "Das ist eine Vorlesung"
+    lvanr "001.002"
+    ects 3
+    stunden 2
+    pruefungsinformation "sdf"
+    lernaufwand "sdf"
+    typ  'VO'
   end
 end
diff --git a/spec/factories/memberships.rb b/spec/factories/memberships.rb
index 56a7e0a..5a715d1 100644
--- a/spec/factories/memberships.rb
+++ b/spec/factories/memberships.rb
@@ -2,10 +2,11 @@
 
 FactoryGirl.define do
   factory :membership do
-    fetprofile_id "MyString"
-    gremium_id "MyString"
+    gremium_id 1
+    fetprofile_id 1
     start "2013-08-19"
-    stop "2013-08-19"
-    typ "MyString"
+    stop "2013-08-23"
+    typ 1
+ 
   end
 end
diff --git a/spec/factories/moduls.rb b/spec/factories/moduls.rb
index 4bfd34f..20497fd 100644
--- a/spec/factories/moduls.rb
+++ b/spec/factories/moduls.rb
@@ -1,6 +1,7 @@
 # Read about factories at https://github.com/thoughtbot/factory_girl
 
 FactoryGirl.define do
+
   factory :modul do
     name ""
     factory :other_modul do
diff --git a/spec/factories/neuigkeit.rb b/spec/factories/neuigkeit.rb
new file mode 100644
index 0000000..e6e3bba
--- /dev/null
+++ b/spec/factories/neuigkeit.rb
@@ -0,0 +1,7 @@
+FactoryGirl.define do
+  factory :neuigkeit do
+    title "WIChtige Neuigkeit"
+    text "<p> Das ist eine wichtige Information </p>"
+    datum 1.days.ago
+    end
+end
diff --git a/spec/factories/rubrik.rb b/spec/factories/rubrik.rb
new file mode 100644
index 0000000..b390be5
--- /dev/null
+++ b/spec/factories/rubrik.rb
@@ -0,0 +1,6 @@
+FactoryGirl.define do
+  factory :rubrik do
+    name "Allgemeine"
+    desc "Allgemeine Test News"
+    end
+end
diff --git a/spec/factories/users.rb b/spec/factories/users.rb
new file mode 100644
index 0000000..cc1ea5e
--- /dev/null
+++ b/spec/factories/users.rb
@@ -0,0 +1,11 @@
+FactoryGirl.define do  
+  factory :user do
+    email "testuser@test.at"
+    password "password"
+    password_confirmation "password"
+    factory :other_user do
+      email "othertest@test.at"
+    end
+  end
+end
+
diff --git a/spec/features/admin_spec.rb b/spec/features/admin_spec.rb
new file mode 100644
index 0000000..02f0d11
--- /dev/null
+++ b/spec/features/admin_spec.rb
@@ -0,0 +1,36 @@
+
+require 'spec_helper'
+Capybara.add_selector(:href) do
+  xpath {|href| XPath.descendant[XPath.attr(:href).contains(href)] }
+end
+
+feature 'Administration', :type=> :feature do 
+  let!(:user) {FactoryGirl.create(:user)}
+  let!(:rubrik) {FactoryGirl.create(:rubrik)}
+
+
+  let!(:themengruppe){    FactoryGirl.create(:themengruppe) }
+  let!(:studium) {FactoryGirl.create(:studium,:visible=>true)}
+  before(:each) do 
+    FactoryGirl.create(:neuigkeit, rubrik_id: rubrik.id, author_id: user.id)
+    FactoryGirl.create(:thema, id: t=YAML.load_file("#{::Rails.root.to_s}/config/start_topic.yml").to_i, themengruppe_id: themengruppe.id) 
+    studium.id
+  end
+  def sign_in  
+    visit '/'
+    user.add_role(:fetadmin)
+
+    find(:href, "sign_in").click
+    fill_in 'user_email', with: user.email
+    fill_in 'user_password', with:"password"
+    click_button 'Sign in'
+  end 
+
+  scenario 'change preferred theme' do
+    sign_in
+    visit "/admin/users/#{user.id}/set_preferred_theme?theme=blue2"
+    expect(User.find(user.id).preferredtheme).to eq("blue2")
+    visit "/admin/users/#{user.id}/set_preferred_theme?theme=blue1"
+    expect(User.find(user.id).preferredtheme).to eq("blue1")
+  end
+end
diff --git a/spec/features/beispielsammlung_spec.rb b/spec/features/beispielsammlung_spec.rb
new file mode 100644
index 0000000..96864e6
--- /dev/null
+++ b/spec/features/beispielsammlung_spec.rb
@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+Capybara.add_selector(:href) do
+    xpath {|href| XPath.descendant[XPath.attr(:href).contains(href)] }
+end
+feature 'Beispielsammlung', :type=>:feature do
+  let!(:rubrik) {FactoryGirl.create(:rubrik)}
+  let!(:user) {FactoryGirl.create(:user)}
+  let!(:themengruppe){    FactoryGirl.create(:themengruppe) }
+  let!(:studium) {FactoryGirl.create(:studium,:visible=>true)}
+  before(:each) do 
+    FactoryGirl.create(:neuigkeit, rubrik_id: rubrik.id, author_id: user.id)
+    FactoryGirl.create(:thema, id: t=YAML.load_file("#{::Rails.root.to_s}/config/start_topic.yml").to_i, themengruppe_id: themengruppe.id) 
+    studium.id
+  end
+  scenario 'login' do 
+    user.add_role(:fetuser)
+    visit '/'
+    find(:href, "sign_in").click
+    fill_in 'user_email', with: user.email
+    fill_in 'user_password', with:"password"
+    click_button 'Sign in'
+    click_link 'Startseite'
+  end
+  def sign_in  
+   visit '/'
+    user.add_role(:fetadmin)
+
+    find(:href, "sign_in").click
+    fill_in 'user_email', with: user.email
+    fill_in 'user_password', with:"password"
+    click_button 'Sign in'
+  end 
+  scenario 'anonym user visits beispielsammlung' do
+#    sign_in
+    visit "/"
+    click_link 'Beispielsammlung'
+    expect(page).to have_text(studium.title)
+#    expect(page).to have_tag("link to lva")
+#    click_link 'LVA1'
+    #    expect(page).to have_text(beispiel.name)
+  end
+  scenario 'load something up' do 
+    visit "/"
+    click_link 'Beispiel hinzufügen'
+    page.attach_file('beispiel[beispieldatei]', Rails.root + 'spec/factories/logo2014_64.png')
+    click_button "Create Beispiel"
+
+   # find(:href,"/beispiele/new").click
+
+    end
+end
+    
diff --git a/spec/mailers/news_mailer_spec.rb b/spec/mailers/news_mailer_spec.rb
index 205f934..a123f83 100644
--- a/spec/mailers/news_mailer_spec.rb
+++ b/spec/mailers/news_mailer_spec.rb
@@ -1,5 +1,33 @@
 require "spec_helper"
 
 describe NewsMailer do
+include Rails.application.routes.url_helpers
   pending "add some examples to (or delete) #{__FILE__}"
+  describe 'neuigkeit_mail'  do 
+    before(:each) do
+     
+      rubrik = FactoryGirl.create(:rubrik)
+      @neuigkeit=FactoryGirl.create(:neuigkeit, author_id: user.id, rubrik_id: rubrik.id)
+      NewsMailer.stub(:default_url_options).and_return({host:"localhost", port: 3000})
+    end
+    let(:user) {User.first || FactoryGirl.create(:user)}
+    let(:email) {"test@mail.com"}
+    let(:neuigkeit) {@neuigkeit}
+    
+    let(:mail) {NewsMailer.neuigkeit_mail(email.to_s, neuigkeit.id)}
+    it "renders neuigkeit title" do 
+      expect(mail.body.to_s).to match(/#{@neuigkeit.title}/)
+    end
+    it "renders neuigkeit expect" do 
+      expect(mail.body.to_s).to match(/#{@neuigkeit.text}/)
+    end
+    it "is sent to current user" do 
+      expect(mail.to).to eq([user.email])
+    end
+    it "links to web page" do 
+      expect(mail.body.to_s).to match(/#{neuigkeit_url(@neuigkeit, locale: nil, theme: nil, host:"localhost", port: 3000)}/)
+
+    end
+
+  end
 end
diff --git a/spec/models/attachment_spec.rb b/spec/models/attachment_spec.rb
index 9981316..42c878e 100644
--- a/spec/models/attachment_spec.rb
+++ b/spec/models/attachment_spec.rb
@@ -2,4 +2,15 @@ require 'spec_helper'
 
 describe Attachment do
   pending "add some examples to (or delete) #{__FILE__}"
+  let(:attachment) {FactoryGirl.build_stubbed(:attachment)}
+  it "responds to image" do 
+    expect(attachment.respond_to?(:image?)).to be true
+  end
+  it "is an image" do 
+    expect(attachment.image?).to be true
+  end
+  it "is valid" do
+    expect(attachment).to be_valid
+  end
+
 end
diff --git a/spec/models/beispiel_spec.rb b/spec/models/beispiel_spec.rb
index cfaeb19..171456e 100644
--- a/spec/models/beispiel_spec.rb
+++ b/spec/models/beispiel_spec.rb
@@ -1,5 +1,59 @@
 require 'spec_helper'
 
-describe Beispiel do
-  pending "add some examples to (or delete) #{__FILE__}"
+describe Beispiel, :type=>:model do
+  let_studium_lva
+#  before(:each) do
+#    s=FactoryGirl.create(:studium)
+#    mg=FactoryGirl.create(:modulgruppe, studium_id: s.id)#
+
+#    m=FactoryGirl.build(:other_modul)
+#    m.modulgruppen << mg
+#    m.save!
+
+#    @l=FactoryGirl.build(:lva)  
+#    @l.modul << m
+#    @l.save!
+#  end
+  let(:lva){FactoryGirl.build_stubbed(:lva)} 
+  let(:beispiel){FactoryGirl.build(:beispiel, lva: lva)}
+    
+  it "should be created"  do
+    expect{beispiel.save!; Sunspot.commit}.to change{Beispiel.count}.by(1)
+  end
+  it "is not valid without lva" do
+    b=FactoryGirl.build(:beispiel)
+    expect(b.valid?).to be false
+  end
+  it "responds to comments" do
+    expect(beispiel.respond_to?(:comments)).to be true
+  end
+  it "responds to get_flag" do
+    expect(beispiel.respond_to?(:get_flag)).to be true
+  end
+  [:delete, :goodquality, :badquality].each do |flg|
+    it " has default false for flag #{flg}" do
+      b=beispiel
+      expect(b.respond_to?(:get_flag)).to be true
+      expect(b.get_flag(flg)).to be false
+    end
+
+  it "responds to flag setter #{flg}" do
+    expect(beispiel.respond_to?("flag_#{flg.to_s}".to_sym)).to be true
+  end  
+end 
+
+  it "should be in not_flag beispiele" do 
+    beispiel.save!
+    bsp= Beispiel.not_flag_delete
+    expect(bsp).to include beispiel
+  end
+  it "should not be in not_flag" do
+    beispiel.save!
+    bsp= Beispiel.not_flag_delete
+    expect{beispiel.flag_delete=true; beispiel.save!}.to change{ Beispiel.not_flag_delete.count }.by(-1)
+    expect{beispiel.flag_delete=nil; beispiel.save!}.to change{ Beispiel.not_flag_delete.count }.by(1)
+
+  
+end
+
 end
diff --git a/spec/models/calentry_spec.rb b/spec/models/calentry_spec.rb
index 02e654e..6420e6f 100644
--- a/spec/models/calentry_spec.rb
+++ b/spec/models/calentry_spec.rb
@@ -1,20 +1,57 @@
 require 'spec_helper'
 
 describe Calentry do
- it "should be valid with full data" do
-   e = FactoryGirl.build(:calentry)
-   c = FactoryGirl.create(:calendar)
-   e.calendars<<c
-   e.should be_valid
+
+  let(:rubrik) {FactoryGirl.create(:rubrik)}
+  let(:user) {FactoryGirl.create(:user)}
+  let(:calendar) {FactoryGirl.create(:calendar,updated_at: 1.hour.ago)}
+  let(:neuigkeit) {FactoryGirl.create(:neuigkeit, rubrik_id: rubrik.id, author_id: user.id, updated_at: 1.hour.ago)}
+  subject(:calentry)   {FactoryGirl.build(:calentry, calendar_id: calendar.id, object_type: "Neuigkeit",object_id: neuigkeit.id)}
+
+  it "is valid with full data" do
+    expect(calentry).to be_valid
+  end
+
+  [:ende,:start,:typ].each do |attr|
+    it "is not valid without #{attr}" do 
+      e= FactoryGirl.build(:calentry, calendar_id: calendar.id, object_type: "Neuigkeit",object_id: neuigkeit.id,  attr => nil)
+      expect(e).not_to be_valid 
+      expect(e).to have_at_least(1).errors_on(attr)
+    end
  end
- [:ende,:start,:typ].each do |attr|
- it "should not be valid without #{attr}" do 
-  e= FactoryGirl.build(:calentry, attr => nil)
-  c=FactoryGirl.create(:calendar)
-    e.calendars<<c
-   e.should_not be_valid 
-   e.should have_at_least(1).errors_on(attr)
- end
- end
- 
+  it "updates updated_at of neuigekit" do
+    expect {calentry.dauer+=1.hour;calentry.save}.to change{calentry.object.updated_at}
+  end
+  it "updates updated_at of calendar" do
+    expect {calentry.dauer+=1.hour;calentry.save}.to change{calentry.calendar.updated_at}
+  end 
+  it "changes ende with dauer" do
+    expect {calentry.dauer=7}.to change(calentry,:ende).to(calentry.start+7.hours)
+  end
+  it "changes dauer with ende" do 
+    expect {calentry.ende=calentry.start+7.hours}.to change(calentry,:dauer).to(7)
+  end
+  it "sets is upcomming" do
+    calentry.start=1.hour.from_now
+    calentry.dauer=2
+    expect(calentry.is_upcomming?).to be true    
+    expect(calentry.is_past?).to be false
+    expect(calentry.is_ongoing?).to be false
+
+    calentry.start=1.hour.ago
+    calentry.dauer=2
+
+    expect(calentry.is_upcomming?).to be false
+    expect(calentry.is_past?).to be false
+    expect(calentry.is_ongoing?).to be true
+
+    calentry.start=4.hour.ago
+    calentry.dauer=2
+
+    expect(calentry.is_upcomming?).to be false
+    expect(calentry.is_past?).to be true
+    expect(calentry.is_ongoing?).to be false
+
+  end
+
 end
diff --git a/spec/models/crawlobject_spec.rb b/spec/models/crawlobject_spec.rb
index dee007d..87b4ecd 100644
--- a/spec/models/crawlobject_spec.rb
+++ b/spec/models/crawlobject_spec.rb
@@ -1,5 +1,5 @@
-require 'rails_helper'
+require 'spec_helper'
 
-RSpec.describe Crawlobject, :type => :model do
+RSpec.describe Crawlobject  do
   pending "add some examples to (or delete) #{__FILE__}"
 end
diff --git a/spec/models/document_spec.rb b/spec/models/document_spec.rb
index d39f418..20eb7f2 100644
--- a/spec/models/document_spec.rb
+++ b/spec/models/document_spec.rb
@@ -1,4 +1,4 @@
-require 'rails_helper'
+require 'spec_helper'
 
 RSpec.describe Document, :type => :model do
   pending "add some examples to (or delete) #{__FILE__}"
diff --git a/spec/models/fetprofile_spec.rb b/spec/models/fetprofile_spec.rb
index 5714406..73d44af 100644
--- a/spec/models/fetprofile_spec.rb
+++ b/spec/models/fetprofile_spec.rb
@@ -1,5 +1,30 @@
 require 'spec_helper'
 
 describe Fetprofile do
-  pending "add some examples to (or delete) #{__FILE__}"
+  [:vorname,:nachname].each do |attr|
+    it "should not be valid without #{attr}" do
+      fp = FactoryGirl.build(:fetprofile)
+      fp.send("#{attr}=".to_sym,nil)
+      fp.should_not be_valid
+    end
+  end
+  it "should be created" do
+    fp=Fetprofile.new(FactoryGirl.attributes_for(:fetprofile))
+    expect(fp.save).to be true
+  end
+
+  it "should be valid" do 
+    fp = FactoryGirl.build(:fetprofile)
+    fp.should be_valid
+  end
+  it "should not be valid with short name" do 
+    fp = FactoryGirl.build(:fetprofile)
+    fp.nachname ="S"
+    fp.should_not be_valid
+    fp.vorname ="d"
+    fp.should_not be_valid
+  end
+  pending "have memberships"
+  pending "be associated to gremien"
+
 end
diff --git a/spec/models/gremium_spec.rb b/spec/models/gremium_spec.rb
index 8f34f2a..cc6d887 100644
--- a/spec/models/gremium_spec.rb
+++ b/spec/models/gremium_spec.rb
@@ -1,5 +1,42 @@
 require 'spec_helper'
 
 describe Gremium do
-  pending "add some examples to (or delete) #{__FILE__}"
+  it "can be created" do
+    g=FactoryGirl.build(:gremium)
+    expect(g.save).to be true
+  end
+  it "is valid with all attributes" do 
+    g = FactoryGirl.build(:gremium)
+    g.should be_valid
+  end
+  [:name,:typ].each do |attr|
+    it "should not be valid without #{attr}" do
+      g = FactoryGirl.build(:gremium)
+      g.send("#{attr}=".to_sym,nil)
+      expect(g).not_to be_valid
+      expect(g.errors[attr]).to have_at_least(1).items
+ 
+    end
+  end
+  it "is in tabs if typ is 1 or 3" do 
+    g = FactoryGirl.create(:gremium, typ: 1)
+    expect(Gremium.tabs).to eq([g])
+  end
+  it "is not in tabs if typ is not 1 or 3" do 
+    g = FactoryGirl.create(:gremium, typ: 2)
+    expect(Gremium.tabs).to eq([])
+  end
+  it "destroys memberships if its destroyed" do
+    g=FactoryGirl.create(:gremium)
+    fp=FactoryGirl.create(:fetprofile)
+    m=FactoryGirl.create(:membership, gremium_id: g.id, fetprofile_id: fp.id)
+    expect{g.destroy}.to change {Membership.count}.by(-1)
+
+    
+  end
+
+  it "responds to title" do
+    g=FactoryGirl.build(:gremium)
+    expect(g.respond_to?(:title)).to be true
+  end
 end
diff --git a/spec/models/key_spec.rb b/spec/models/key_spec.rb
index f94d28a..ae283cf 100644
--- a/spec/models/key_spec.rb
+++ b/spec/models/key_spec.rb
@@ -1,4 +1,4 @@
-require 'rails_helper'
+require 'spec_helper'
 
 RSpec.describe Key, :type => :model do
   pending "add some examples to (or delete) #{__FILE__}"
diff --git a/spec/models/lva_spec.rb b/spec/models/lva_spec.rb
index 4209553..5766efd 100644
--- a/spec/models/lva_spec.rb
+++ b/spec/models/lva_spec.rb
@@ -1,5 +1,28 @@
 require 'spec_helper'
 
-describe Lva do
+describe Lva, :type=>:model do
   pending "add some examples to (or delete) #{__FILE__}"
+  let_studium_lva
+  before(:each) do 
+    @l = FactoryGirl.build(:lva)
+  end
+  describe "if bare"  do
+    let(:lva) {FactoryGirl.build(:lva)}
+    it "should be created" do
+      l=lva
+      l.modul << modul
+      expect{l.save!; Sunspot.commit}.to change{Lva.count}.by(1)
+    end
+    it "should not be valid without module" do
+      l=lva
+      expect(l.valid?).to be false
+      expect(l.errors[:modul].size).to be(1)
+    end
+  end
+  it "should respond to semesters" do
+    expect(lva.respond_to?(:semester)).to be true
+  end
+  pending "should not be valid without modul"
+  pending "should have beispiele"
+  pending "should be flagable"
 end
diff --git a/spec/models/meeting_spec.rb b/spec/models/meeting_spec.rb
index 93d55f7..2e72528 100644
--- a/spec/models/meeting_spec.rb
+++ b/spec/models/meeting_spec.rb
@@ -1,4 +1,4 @@
-require 'rails_helper'
+require 'spec_helper'
 
 RSpec.describe Meeting, :type => :model do
   pending "add some examples to (or delete) #{__FILE__}"
diff --git a/spec/models/meetingtyp_spec.rb b/spec/models/meetingtyp_spec.rb
index c55d7c0..09545ef 100644
--- a/spec/models/meetingtyp_spec.rb
+++ b/spec/models/meetingtyp_spec.rb
@@ -1,4 +1,4 @@
-require 'rails_helper'
+require 'spec_helper'
 
 RSpec.describe Meetingtyp, :type => :model do
   pending "add some examples to (or delete) #{__FILE__}"
diff --git a/spec/models/modul_spec.rb b/spec/models/modul_spec.rb
index 2bc5894..262b8dd 100644
--- a/spec/models/modul_spec.rb
+++ b/spec/models/modul_spec.rb
@@ -1,14 +1,16 @@
 require 'spec_helper'
 
 describe Modul do
-  it "should not be valid without name" do
-    m = FactoryGirl.build(:modul)
-    m.should_not be_valid
-    m.should have(1).errors_on(:name)
+  [:name].each do |attr|
+    it "should not be valid without #{attr}" do
+      modul = FactoryGirl.build(:modul)
+      modul.send("#{attr}=".to_sym,nil)
+      expect(modul).not_to be_valid
+      expect(modul).to have_at_least(1).errors_on(attr)
+    end
   end
-  it "should be valid with name" do
+  it "is valid with everything" do
     m = FactoryGirl.build(:modul)
-    m.name = "Grundlagen"
-    m.should be_valid
+    expect(m).to be_valid
   end
 end
diff --git a/spec/models/modulgruppe_spec.rb b/spec/models/modulgruppe_spec.rb
index 3a863e3..d06d7bf 100644
--- a/spec/models/modulgruppe_spec.rb
+++ b/spec/models/modulgruppe_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Modulgruppe do
+describe Modulgruppe, :type =>:model do
   it "should not be valid without studium" do
   mg=FactoryGirl.build(:modulgruppe)
   mg.should_not be_valid
@@ -42,5 +42,7 @@ describe Modulgruppe do
   mg.should be_valid
 
   end    
-  
+    pending "add some examples to (or delete) #{__FILE__}"
+  pending "DRY #{__FILE__}"
+
 end
diff --git a/spec/models/neuigkeit_spec.rb b/spec/models/neuigkeit_spec.rb
new file mode 100644
index 0000000..817ea1b
--- /dev/null
+++ b/spec/models/neuigkeit_spec.rb
@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Neuigkeit do
+  let(:rubrik) {FactoryGirl.create(:rubrik)}
+  let(:user) {FactoryGirl.create(:user)}
+  let(:neuigkeit) {(FactoryGirl.build(:neuigkeit, rubrik_id: rubrik.id, author_id: user.id))} 
+  let(:attachment) {FactoryGirl.build_stubbed(:attachment)}
+
+  [:title,:text, :rubrik, :author].each do |attr|
+    it "should not be valid without #{attr}" do
+      neuigkeit.send("#{attr}=".to_sym,nil)
+      expect(neuigkeit).not_to be_valid
+      expect(neuigkeit.errors[attr]).to have_at_least(1).items
+    end
+  end
+  it "should be created" do
+    expect(neuigkeit).to be_valid
+    expect(neuigkeit.save).to be true
+  end
+
+  it "should be valid" do 
+    fp = FactoryGirl.build(:neuigkeit, rubrik_id: rubrik.id, author_id: user.id)
+    expect(fp).to  be_valid
+  end
+  it "responds to attachments" do 
+    expect(neuigkeit.respond_to?(:attachments)).to be true
+  end
+  it "uses titlepic attachments as picture" do
+    expect(neuigkeit.respond_to?(:picture_robust)).to be true
+    attachment.flag_titlepic = true
+    expect { neuigkeit.attachments << attachment }.to change {neuigkeit.picture_robust}
+  end
+  it "is an event if it has a calentry" do
+  expect(neuigkeit.event?).to be false
+  expect{neuigkeit.calentries << calentry}.to change(neuigkeit, :event?)
+  end
+
+  pending "has questions"
+  pending "has nlinks"
+  pending "has calentries" 
+  pending "can be an event"
+  pending "is published by date"
+  pending "has meeting"
+  pending "is shareable"  
+end
diff --git a/spec/models/news.rb b/spec/models/news.rb
new file mode 100644
index 0000000..0a49b2b
--- /dev/null
+++ b/spec/models/news.rb
@@ -0,0 +1,6 @@
+require 'models/neuigkeit_spec.rb'
+require 'models/rubrik_spec.rb'
+require 'models/attachment_spec.rb'
+require 'models/calentry_spec.rb'
+require 'models/calendar_spec.rb'
+require 'models/nlink_spec.rb'
diff --git a/spec/models/rubrik_spec.rb b/spec/models/rubrik_spec.rb
new file mode 100644
index 0000000..4251f9c
--- /dev/null
+++ b/spec/models/rubrik_spec.rb
@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe Rubrik do
+  pending "add some examples to (or delete) #{__FILE__}"
+
+end
diff --git a/spec/models/studium_spec.rb b/spec/models/studium_spec.rb
index 0297604..ab9a349 100644
--- a/spec/models/studium_spec.rb
+++ b/spec/models/studium_spec.rb
@@ -1,6 +1,7 @@
 require 'spec_helper'
 
 describe Studium do
+  # test if it is invalid if certain attributes are missing
   [:name, :zahl].each do |attr|
 	it "should not be valid without #{attr}" do
 		s = FactoryGirl.build(:studium, attr=>nil)
@@ -10,18 +11,20 @@ describe Studium do
 	it "should create studium with valid data" do
 		s=FactoryGirl.build(:studium)
 		lambda {
-		s.save!}.should change {Studium.count()}.by(1)
+		s.save!; Sunspot.commit}.should change {Studium.count()}.by(1)
 	end
 	it "should not accept double entrys" do
 		FactoryGirl.create(:studium)
+    Sunspot.commit
 		s=FactoryGirl.build(:studium)
 		s.should_not be_valid
 		s.should have_at_least(1).error_on(:name)
 		s.should have_at_least(1).error_on(:zahl)
 	end
 	it "should expect zahl to be 000.000" do
-		s=FactoryGirl.build(:studium, :zahl=>"000000")
+		s=FactoryGirl.build(:studium, :zahl=>"000.000")
+    Sunspot.commit
 		s.should_not be_valid
-		s.should have_at_least(1).error_on(:zahl)
+    expect(s.errors.size).to be > 0
 	end
 end
diff --git a/spec/models/survey/answer_spec.rb b/spec/models/survey/answer_spec.rb
index 518fae0..7dcc5dc 100644
--- a/spec/models/survey/answer_spec.rb
+++ b/spec/models/survey/answer_spec.rb
@@ -1,4 +1,4 @@
-require 'rails_helper'
+require 'spec_helper'
 
 RSpec.describe Survey::Answer, :type => :model do
   pending "add some examples to (or delete) #{__FILE__}"
diff --git a/spec/models/survey/choice_spec.rb b/spec/models/survey/choice_spec.rb
index 31558cb..46d24ce 100644
--- a/spec/models/survey/choice_spec.rb
+++ b/spec/models/survey/choice_spec.rb
@@ -1,5 +1,8 @@
-require 'rails_helper'
+require 'spec_helper'
 
 RSpec.describe Survey::Choice, :type => :model do
+  pending "picture"
+  pending "icon"
+  pending "depended answer"
   pending "add some examples to (or delete) #{__FILE__}"
 end
diff --git a/spec/models/survey/question_spec.rb b/spec/models/survey/question_spec.rb
index 556c094..5f26dd3 100644
--- a/spec/models/survey/question_spec.rb
+++ b/spec/models/survey/question_spec.rb
@@ -1,5 +1,11 @@
-require 'rails_helper'
+require 'spec_helper'
 
 RSpec.describe Survey::Question, :type => :model do
+  pending "have choices"
+  pending "be lockable"
+  pending "be flagable"
+  pending "copy from template"
+  pending "attributes for copy"
+  pending "have do answer"
   pending "add some examples to (or delete) #{__FILE__}"
 end
diff --git a/spec/models/user_spec.rb b/spec/models/user_spec.rb
new file mode 100644
index 0000000..1888364
--- /dev/null
+++ b/spec/models/user_spec.rb
@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe User do
+  pending "add some examples to (or delete) #{__FILE__}"
+
+end
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index d2cbea7..f283b59 100644
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -1,12 +1,33 @@
 # This file is copied to spec/ when you run 'rails generate rspec:install'
 ENV["RAILS_ENV"] ||= 'test'
-require File.expand_path("../../config/environment", __FILE__)
-require 'rspec/rails'
-require 'rspec/autorun'
+require 'rbconfig'
 
+require File.expand_path("../../config/environment", __FILE__)
+#require 'rspec/autorun'
+require 'rspec/rails'
+
+
+#require 'minitest/autorun'
+require 'sunspot_test/rspec' 
+require 'devise'
 # Requires supporting ruby files with custom matchers and macros, etc,
 # in spec/support/ and its subdirectories.
 Dir[Rails.root.join("spec/support/**/*.rb")].each { |f| require f }
+Dir[Rails.root.join("spec/models/shared_examples/**/*.rb")].each {|f| require f}
+Dir[Rails.root.join("spec/controllers/shared_examples/**/*.rb")].each {|f| require f}
+
+RSpec.configure do |config|
+  config.include Devise::TestHelpers, :type => :controller
+  config.extend ControllerMacros, :type => :controller
+  config.extend ModelMacros, :type => :model
+
+  config.include Devise::TestHelpers, :type => :view
+  config.include RSpecHtmlMatchers, :type => :view
+ config.extend ViewMacros, :type => :view
+
+end
+
+
 
 RSpec.configure do |config|
   # ## Mock Framework
@@ -18,7 +39,7 @@ RSpec.configure do |config|
   # config.mock_with :rr
 
   # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
-  config.fixture_path = "#{::Rails.root}/spec/fixtures"
+#  config.fixture_path = "#{::Rails.root}/spec/fixtures"
 
   # If you're not using ActiveRecord, or you'd prefer not to run each of your
   # examples within a transaction, remove the following line or assign false
@@ -29,10 +50,15 @@ RSpec.configure do |config|
   # automatically. This will be the default behavior in future versions of
   # rspec-rails.
   config.infer_base_class_for_anonymous_controllers = false
-
+  config.add_setting :themes
+  config.themes =[:blue2, :blue1]
   # Run specs in random order to surface order dependencies. If you find an
   # order dependency and want to debug it, you can fix the order by providing
   # the seed, which is printed after each run.
   #     --seed 1234
   config.order = "random"
+
+
+
+
 end
diff --git a/spec/support/controller_macros.rb b/spec/support/controller_macros.rb
new file mode 100644
index 0000000..229a09a
--- /dev/null
+++ b/spec/support/controller_macros.rb
@@ -0,0 +1,38 @@
+module ControllerMacros
+#  include Devise::TestHelpers, :type=>:controller
+  def login_fet_user
+    before(:each) do
+      @request.env["devise.mapping"] = Devise.mappings[:user]
+      user = FactoryGirl.build(:user)
+      user = User.find_by_email(user.email) || user
+      user.save
+      user.add_role(:fetuser)
+     # user.confirm! 
+      sign_in user
+    end
+  end
+  def login_user
+    before(:each) do
+      @request.env["devise.mapping"] = Devise.mappings[:user]
+      user = FactoryGirl.build(:other_user)
+      user = User.find_by_email(user.email) || user
+      user.save
+     # user.confirm! 
+      sign_in user
+    end
+  end
+  def logout_user
+    before(:each) do
+      sign_out :user
+    end
+  end
+  def has_invalid_params
+          before(:each) do 
+        object_class.any_instance.stub(:save).and_return(false)      
+        object_class.any_instance.stub(:update_attributes).and_return(false)      
+
+      end
+
+  end
+
+end
diff --git a/spec/support/devise.rb b/spec/support/devise.rb
new file mode 100644
index 0000000..e69de29
diff --git a/spec/support/model_macros.rb b/spec/support/model_macros.rb
new file mode 100644
index 0000000..5da7d1d
--- /dev/null
+++ b/spec/support/model_macros.rb
@@ -0,0 +1,18 @@
+module ModelMacros
+  def let_studium_lva
+    let(:studium) {FactoryGirl.create(:studium)}
+    let(:modulgruppe){FactoryGirl.create(:modulgruppe,studium_id: studium.id)}
+    let(:modul) do
+      m=FactoryGirl.build(:other_modul);
+      m.modulgruppen << modulgruppe
+      m.save!
+      m
+    end
+    let(:lva) do
+      l=FactoryGirl.build(:lva)  
+      l.modul << modul
+      l.save!
+      l
+    end
+  end
+end
diff --git a/spec/support/view_macros.rb b/spec/support/view_macros.rb
new file mode 100644
index 0000000..ad0d3d2
--- /dev/null
+++ b/spec/support/view_macros.rb
@@ -0,0 +1,45 @@
+module ViewMacros
+
+  def foreach_theme 
+    RSpec.configuration.themes.each do |theme|
+      context " with theme #{theme}" do 
+        before(:each) do
+          view.view_paths=[ "app/views/themes/#{theme}", "app/views"]
+        end
+        
+        yield
+      end
+    end
+  end
+  def login_fet_user
+    before(:each) do
+      @request.env["devise.mapping"] = Devise.mappings[:user]
+      user = FactoryGirl.build(:user)
+      user = User.find_by_email(user.email) || user
+      user.save
+      user.add_role(:fetuser)
+     # user.confirm! 
+      @user=user
+      @ability= Ability.new(@user)
+      # controller.stub(:current_ability) { @ability }
+      allow(view).to receive(:current_ability).and_return(@ability)
+      sign_in user
+    end
+  end
+  def login_fetadmin_user
+    before(:each) do
+      @request.env["devise.mapping"] = Devise.mappings[:user]
+      user = FactoryGirl.build(:user)
+      user = User.find_by_email(user.email) || user
+      user.save
+      user.add_role(:fetadmin)
+     # user.confirm! 
+      @user=user
+      @ability= Ability.new(@user)
+      # controller.stub(:current_ability) { @ability }
+      allow(view).to receive(:current_ability).and_return(@ability)
+      sign_in user
+    end
+  end
+
+end
diff --git a/spec/views/fetprofiles/edit.html.erb_spec.rb b/spec/views/fetprofiles/edit.html.erb_spec.rb
index c68d7e3..8efc992 100644
--- a/spec/views/fetprofiles/edit.html.erb_spec.rb
+++ b/spec/views/fetprofiles/edit.html.erb_spec.rb
@@ -1,30 +1,35 @@
 require 'spec_helper'
 
-describe "fetprofiles/edit" do
-  before(:each) do
-    @fetprofile = assign(:fetprofile, stub_model(Fetprofile,
-      :vorname => "MyString",
-      :nachname => "MyString",
-      :short => "MyString",
-      :fetmailalias => "MyString",
-      :desc => "MyText",
-      :picture => "MyString",
-      :active => false
-    ))
+describe "fetprofiles/edit", :type=> :view do
+  foreach_theme do 
+  login_fet_user
+   before(:each) do
+    @fetprofile = FactoryGirl.create(:fetprofile_withadress,:skype => "myskypename")
+    @memberships = []
   end
 
   it "renders the edit fetprofile form" do
     render
 
     # Run the generator again with the --webrat flag if you want to use webrat matchers
-    assert_select "form[action=?][method=?]", fetprofile_path(@fetprofile), "post" do
-      assert_select "input#fetprofile_vorname[name=?]", "fetprofile[vorname]"
-      assert_select "input#fetprofile_nachname[name=?]", "fetprofile[nachname]"
-      assert_select "input#fetprofile_short[name=?]", "fetprofile[short]"
-      assert_select "input#fetprofile_fetmailalias[name=?]", "fetprofile[fetmailalias]"
-      assert_select "textarea#fetprofile_desc[name=?]", "fetprofile[desc]"
-      assert_select "input#fetprofile_picture[name=?]", "fetprofile[picture]"
-      assert_select "input#fetprofile_active[name=?]", "fetprofile[active]"
+    expect(rendered).to have_tag('form', with: {method:"post"}) do
+      with_tag "input", with: {name: "fetprofile[vorname]", value: @fetprofile.vorname}
+      with_tag "input", with: {name: "fetprofile[nachname]", value: @fetprofile.nachname}
+      with_tag "input", with: {name: "fetprofile[short]", value: @fetprofile.short}
+      with_tag "textarea", with: {name: "fetprofile[desc]"}
+     with_tag "input", with: {name: "fetprofile[picture]"}
+     with_tag "input", with: {name: "fetprofile[picture_cache]"}
+  
+     with_tag "input", with: {name: "fetprofile[street]", value: @fetprofile.street}
+      with_tag "input", with: {name: "fetprofile[plz]", value: @fetprofile.plz}
+      with_tag "input", with: {name: "fetprofile[city]", value: @fetprofile.city}
+      with_tag "input", with: {name: "fetprofile[hdynr]", value: @fetprofile.hdynr}
+      with_tag "input", with: {name: "fetprofile[telnr]", value: @fetprofile.telnr}
+      with_tag "input", with: {name: "fetprofile[skype]", value: @fetprofile.skype.to_s}
+      with_tag "input", with: {name: "fetprofile[birth_day]", value: @fetprofile.birth_day}
+      with_tag "input", with: {name: "fetprofile[birth_month]", value: @fetprofile.birth_month}
+
     end
   end
 end
+end
diff --git a/spec/views/fetprofiles/fetprofile.html.erb_spec.rb b/spec/views/fetprofiles/fetprofile.html.erb_spec.rb
new file mode 100644
index 0000000..12c992f
--- /dev/null
+++ b/spec/views/fetprofiles/fetprofile.html.erb_spec.rb
@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe "fetprofiles/_fetprofile", :type => :view  do
+  include RSpecHtmlMatchers
+include Devise::TestHelpers
+include Rails.application.routes.url_helpers
+  before(:each) do  
+#    @fetprofile =
+ #assign(:fetprofile, stub_model(Fetprofile, FactoryGirl.attributes_for(:fetprofile)))
+    default_url_options[:locale] = :de
+    @fetprofile =  FactoryGirl.create(:fetprofile)
+#    assign(:fetprofile,@fetprofile)
+#    assign(:memberships, [])
+  end
+
+  it "has access to url_helpers" do
+    expect(fetprofile_path(@fetprofile,locale: "de",theme: nil)).to match /#{@fetprofile.id}/
+  end
+
+  it "has access to url_helpers without setting nil params" do
+    expect(fetprofile_path(@fetprofile)).to match /#{@fetprofile.id}/
+  end
+  it "renders a link" do
+   allow(view).to receive(:default_url_options).and_return({locale: "de"})
+#   allow(view).to receive(:fetprofile_path).and_return("")
+
+#    view.stub!(:fetprofile_path).and_return("path")
+    render partial: "fetprofiles/fetprofile", locals: {fetprofile: @fetprofile}
+    expect(rendered).to have_tag("a.linkbox")
+  end
+end
diff --git a/spec/views/fetprofiles/index.html.erb_spec.rb b/spec/views/fetprofiles/index.html.erb_spec.rb
index 34593da..c0ca1ad 100644
--- a/spec/views/fetprofiles/index.html.erb_spec.rb
+++ b/spec/views/fetprofiles/index.html.erb_spec.rb
@@ -1,38 +1,32 @@
 require 'spec_helper'
 
-describe "fetprofiles/index" do
+
+describe "fetprofiles/index" , :type=>:view do
+foreach_theme do
   before(:each) do
-    assign(:fetprofiles, [
-      stub_model(Fetprofile,
-        :vorname => "Vorname",
-        :nachname => "Nachname",
-        :short => "Short",
-        :fetmailalias => "Fetmailalias",
-        :desc => "MyText",
-        :picture => "Picture",
-        :active => false
-      ),
-      stub_model(Fetprofile,
-        :vorname => "Vorname",
-        :nachname => "Nachname",
-        :short => "Short",
-        :fetmailalias => "Fetmailalias",
-        :desc => "MyText",
-        :picture => "Picture",
-        :active => false
-      )
-    ])
+#    default_url_options[:locale] = :de
+    @fetprofile1 =  FactoryGirl.create(:fetprofile)
+    @fetprofile2 =  FactoryGirl.create(:fetprofile2)
+    @fetprofile3 =  FactoryGirl.create(:fetprofile3)
+    @fetprofile4 =  FactoryGirl.create(:fetprofile_withadress)
+    @fetprofiles=[@fetprofile1, @fetprofile2, @fetprofile3, @fetprofile4]
+   assign(:fetprofiles,@fetprofiles)
+     assign(:gremientabs, [])
+
   end
 
   it "renders a list of fetprofiles" do
     render
-    # Run the generator again with the --webrat flag if you want to use webrat matchers
-    assert_select "tr>td", :text => "Vorname".to_s, :count => 2
-    assert_select "tr>td", :text => "Nachname".to_s, :count => 2
-    assert_select "tr>td", :text => "Short".to_s, :count => 2
-    assert_select "tr>td", :text => "Fetmailalias".to_s, :count => 2
-    assert_select "tr>td", :text => "MyText".to_s, :count => 2
-    assert_select "tr>td", :text => "Picture".to_s, :count => 2
-    assert_select "tr>td", :text => false.to_s, :count => 2
+    expect(rendered).to match(/#{@fetprofile1.vorname}/)
+    expect(rendered).to match(/#{@fetprofile1.nachname}/)
+    expect(rendered).to match(/#{@fetprofile2.vorname}/)
+    expect(rendered).to match(/#{@fetprofile2.nachname}/)
+    expect(rendered).to match(/#{@fetprofile3.vorname}/)
+    expect(rendered).to match(/#{@fetprofile3.nachname}/)
+    expect(rendered).to match(/#{@fetprofile4.vorname}/)
+    expect(rendered).to match(/#{@fetprofile4.nachname}/)
+ #   expect(rendered).to have_tag("fetprofile_#{@fetprofile1.id}")
+    
   end
 end
+end
diff --git a/spec/views/fetprofiles/new.html.erb_spec.rb b/spec/views/fetprofiles/new.html.erb_spec.rb
index 8b6ce6c..5202ff4 100644
--- a/spec/views/fetprofiles/new.html.erb_spec.rb
+++ b/spec/views/fetprofiles/new.html.erb_spec.rb
@@ -1,30 +1,35 @@
 require 'spec_helper'
 
-describe "fetprofiles/new" do
+describe "fetprofiles/new", :type=> :view do
+  foreach_theme do
   before(:each) do
-    assign(:fetprofile, stub_model(Fetprofile,
-      :vorname => "MyString",
-      :nachname => "MyString",
-      :short => "MyString",
-      :fetmailalias => "MyString",
-      :desc => "MyText",
-      :picture => "MyString",
-      :active => false
-    ).as_new_record)
+    @fetprofile = FactoryGirl.create(:fetprofile_withadress,:skype => "myskypename")
+    @memberships = []
   end
 
-  it "renders new fetprofile form" do
+  it "renders the edit fetprofile form" do
     render
 
     # Run the generator again with the --webrat flag if you want to use webrat matchers
-    assert_select "form[action=?][method=?]", fetprofiles_path, "post" do
-      assert_select "input#fetprofile_vorname[name=?]", "fetprofile[vorname]"
-      assert_select "input#fetprofile_nachname[name=?]", "fetprofile[nachname]"
-      assert_select "input#fetprofile_short[name=?]", "fetprofile[short]"
-      assert_select "input#fetprofile_fetmailalias[name=?]", "fetprofile[fetmailalias]"
-      assert_select "textarea#fetprofile_desc[name=?]", "fetprofile[desc]"
-      assert_select "input#fetprofile_picture[name=?]", "fetprofile[picture]"
-      assert_select "input#fetprofile_active[name=?]", "fetprofile[active]"
+    expect(rendered).to have_tag('form', with: {method:"post"}) do
+      with_tag "input", with: {name: "fetprofile[vorname]"}
+      with_tag "input", with: {name: "fetprofile[nachname]"}
+      with_tag "input", with: {name: "fetprofile[short]"}
+      with_tag "textarea", with: {name: "fetprofile[desc]"}
+     with_tag "input", with: {name: "fetprofile[picture]"}
+     with_tag "input", with: {name: "fetprofile[picture_cache]"}
+  
+     with_tag "input", with: {name: "fetprofile[street]"}
+      with_tag "input", with: {name: "fetprofile[plz]"}
+      with_tag "input", with: {name: "fetprofile[city]"}
+      with_tag "input", with: {name: "fetprofile[hdynr]"}
+      with_tag "input", with: {name: "fetprofile[telnr]"}
+      with_tag "input", with: {name: "fetprofile[skype]"}
+      with_tag "input", with: {name: "fetprofile[birth_day]"}
+      with_tag "input", with: {name: "fetprofile[birth_month]"}
+
     end
   end
+  end
 end
+
diff --git a/spec/views/fetprofiles/show.html.erb_spec.rb b/spec/views/fetprofiles/show.html.erb_spec.rb
index dee3f2d..43f183f 100644
--- a/spec/views/fetprofiles/show.html.erb_spec.rb
+++ b/spec/views/fetprofiles/show.html.erb_spec.rb
@@ -1,27 +1,101 @@
 require 'spec_helper'
 
-describe "fetprofiles/show" do
-  before(:each) do
-    @fetprofile = assign(:fetprofile, stub_model(Fetprofile,
-      :vorname => "Vorname",
-      :nachname => "Nachname",
-      :short => "Short",
-      :fetmailalias => "Fetmailalias",
-      :desc => "MyText",
-      :picture => "Picture",
-      :active => false
-    ))
-  end
+describe "fetprofiles/show", :type => :view  do
+  foreach_theme do 
 
-  it "renders attributes in <p>" do
-    render
-    # Run the generator again with the --webrat flag if you want to use webrat matchers
-    rendered.should match(/Vorname/)
-    rendered.should match(/Nachname/)
-    rendered.should match(/Short/)
-    rendered.should match(/Fetmailalias/)
-    rendered.should match(/MyText/)
-    rendered.should match(/Picture/)
-    rendered.should match(/false/)
+    before(:each) do
+      default_url_options[:locale] = :de
+      @fetprofile =  FactoryGirl.create(:fetprofile_withadress)
+      assign(:fetprofile,@fetprofile)
+      @gremium =  FactoryGirl.create(:gremium)
+      @gremium2 =  FactoryGirl.create(:gremium, name:"Kommission2")
+      @gremium3 =  FactoryGirl.create(:gremium, name:"Kommission3", typ: 2)
+
+      assign(:memberships, [FactoryGirl.create(:membership,gremium_id: @gremium.id, fetprofile_id: @fetprofile.id)])
+      assign(:gremientabs, [@gremium2])
+      #    view.theme "blue2"
+    end
+
+    it "has working filters" do 
+      expect(true).to be true
+    end
+    it "calls vorname on fetprofile" do
+      expect(@fetprofile).to receive(:vorname).at_least(1).times
+
+      render
+    end
+    
+    it "doesn't call users" do
+      Fetprofile.any_instance.should_not_receive(:users)
+      #  expect(Fetprofile.any_instance).to receive(:vorname) 
+      render
+    end
+
+    it "doesn't call memberships" do
+      Fetprofile.any_instance.should_not_receive(:memberships)
+      render
+    end
+
+    it "doesn't call gremien" do
+      Fetprofile.any_instance.should_not_receive(:gremien)
+      render
+    end
+    
+    it "renders public attributes" do
+      render
+      expect(rendered).to match(/#{@fetprofile.vorname}/)
+      expect(rendered).to match(/#{@fetprofile.nachname}/)
+      expect(rendered).to match(/#{@fetprofile.desc}/)
+      expect(rendered).to match(/#{@fetprofile.fetmail}/)
+      
+      expect(rendered).to have_tag('div')
+      
+      #    rendered.should match(/Nachname/)
+      #    rendered.should match(/Short/)
+      #    rendered.should match(/Fetmailalias/)
+      #    rendered.should match(/MyText/)
+
+      #    rendered.should match(/false/)
+    end
+    it "doesn't render address" do
+      render 
+      expect(rendered).not_to match(/#{@fetprofile.street}/)
+      expect(rendered).not_to match(/#{@fetprofile.city}/)
+      expect(rendered).not_to match(/#{@fetprofile.hdynr}/)
+      expect(rendered).not_to match(/#{@fetprofile.telnr}/)
+      expect(rendered).not_to match(/#{@fetprofile.plz}/)
+
+    end
+    it  "renders links to gremium" do
+      render
+      expect(rendered).to match(/#{gremium_path(@gremium)}/)
+    end
+    it  "renders  gremium links"  do
+      render
+      expect(rendered).to match(/#{gremium_path(@gremium2)}/)
+    end
+    it  "doesn't render  gremium links for hidden gremium"  do
+      render
+      expect(rendered).not_to match(/#{gremium_path(@gremium3)}/)
+    end
+
+    describe "with fet user" do 
+      login_fet_user
+
+      #    let(:current_ability) {@ability}
+      it "renders address" do 
+        render
+        expect(rendered).to match(/#{@fetprofile.street}/)
+        expect(rendered).to match(/#{@fetprofile.plz}/)
+        expect(rendered).to match(/#{@fetprofile.city}/)
+        expect(rendered).to match(/#{@fetprofile.hdynr}/)
+        expect(rendered).to match(/#{@fetprofile.telnr}/)
+
+      end
+      it  "renders edit path" do
+        render
+        expect(rendered).to match(/#{edit_fetprofile_path(@fetprofile)}/)
+      end
+    end
   end
 end