Feature/custom colors in interactions

modules/component-loader/src/main/scala/org/corespring/container/components/loader/FileComponentLoader.scala

@@ -96,6 +96,14 @@ class FileComponentLoader(paths: Seq[String], showNonReleased: Boolean)
       .find(!_.isEmpty).flatten
   }
 
+  private def loadLess(root: String): Option[String] = {
+    val maybeFiles = Seq("styles.less")
+
+    maybeFiles
+      .map(filename => readMaybeFile(new File(s"${if (root.endsWith("/")) root else s"$root/"}$filename")))
+      .find(!_.isEmpty).flatten
+  }
+
   private def loadLibrary(org: String, packageJson: JsValue)(compRoot: File): Option[Component] = {
 
     def createServerName(n: String) = s"$org.${compRoot.getName}.server${if (n == "index") "" else s".$n"}"
@@ -108,6 +116,7 @@ class FileComponentLoader(paths: Seq[String], showNonReleased: Boolean)
         loadLibrarySources(compRoot.getPath, "client", createClientName(compRoot.getName)),
         loadLibrarySources(compRoot.getPath, "server", createServerName),
         loadCss(s"${compRoot.getPath}/src/client"),
+        loadLess(s"${compRoot.getPath}/src/client"),
         loadLibraries(packageJson)))
   }
 
@@ -121,6 +130,7 @@ class FileComponentLoader(paths: Seq[String], showNonReleased: Boolean)
         released = false,
         client = loadLibrarySources(compRoot.getPath, "client", createClientName(compRoot.getPath)),
         css = loadCss(s"${compRoot.getPath}/src/client"),
+        less = loadLess(s"${compRoot.getPath}/src/client"),
         packageInfo = packageJson))
   }
 
@@ -251,7 +261,8 @@ class FileComponentLoader(paths: Seq[String], showNonReleased: Boolean)
     val renderJs = getJsFromFile(client.getPath + "/render")
     val configureJs = getJsFromFile(client.getPath + "/configure")
     val styleCss = loadCss(client.getPath)
-    Client(renderJs, configureJs, styleCss, renderLibs, configureLibs)
+    val styleLess = loadLess(client.getPath)
+    Client(renderJs, configureJs, styleCss, styleLess, renderLibs, configureLibs)
   }
 
   private def loadServer(server: File): Server = if (!server.exists()) {

modules/component-loader/src/test/resources/org/corespring/container/components/loader/two/corespring/my-lib/src/client/styles.less

@@ -0,0 +1,3 @@
+body {
+    background-color: red;
+}

modules/component-loader/src/test/scala/org/corespring/container/components/loader/FileComponentLoaderTest.scala

@@ -54,6 +54,7 @@ class FileComponentLoaderTest extends Specification {
       lib.server.map(_.name).contains("corespring.my-lib.server") === true
       lib.server.map(_.name).contains("corespring.my-lib.server.other") === true
       lib.css.get.startsWith("body") mustEqual true
+      lib.less.get.startsWith("body") mustEqual true
     }
 
     "an interaction can specify a library" in {

modules/component-model/src/main/scala/org/corespring/container/components/model/models.scala

@@ -24,6 +24,7 @@ case class Library(
   client: Seq[LibrarySource] = Seq.empty,
   server: Seq[LibrarySource] = Seq.empty,
   css: Option[String],
+  less: Option[String],
   libraries: Seq[Id])
   extends Component(Id(org, name), packageInfo)
 
@@ -75,12 +76,14 @@ case class LayoutComponent(org: String,
   name: String,
   client: Seq[LibrarySource],
   css: Option[String],
+  less: Option[String],
   released: Boolean,
   override val packageInfo: JsValue) extends Component(Id(org, name), packageInfo)
 
 case class Client(render: String,
   configure: String,
   css: Option[String],
+  less: Option[String],
   renderLibs: Seq[LibrarySource] = Seq.empty,
   configureLibs: Seq[LibrarySource] = Seq.empty)
 

modules/component-model/src/test/scala/org/corespring/container/components/model/dependencies/ComponentMaker.scala

@@ -14,7 +14,7 @@ trait ComponentMaker {
       title = title,
       titleGroup = titleGroup,
       released = released,
-      client = Client("", "", None),
+      client = Client("", "", None, None),
       server = Server(""),
       packageInfo = Json.obj("name" -> name, "org" -> org),
       defaultData = Json.obj(),
@@ -24,16 +24,16 @@ trait ComponentMaker {
   }
 
   def widget(name: String, libs: Seq[Id] = Seq.empty, title: Option[String] = None, titleGroup: Option[String] = None, org: String = defaultOrg) = {
-    Widget(org, name, title, titleGroup, Client("", "", None), true, Json.obj("name" -> name, "org" -> org),
+    Widget(org, name, title, titleGroup, Client("", "", None, None), true, Json.obj("name" -> name, "org" -> org),
       Json.obj(), None, Map(), libs)
   }
 
   def lib(name: String, libraries: Seq[Id] = Seq.empty, org: String = defaultOrg): Library = {
-    Library(org, name, Json.obj("name" -> name), Seq.empty, Seq.empty, None, libraries)
+    Library(org, name, Json.obj("name" -> name), Seq.empty, Seq.empty, None, None, libraries)
   }
 
   def id(name: String, scope: Option[String] = None, org: String = defaultOrg) = Id(org, name, scope)
 
-  def layout(name: String, org: String = defaultOrg) = LayoutComponent(org, name, Seq.empty, None, true, Json.obj("name" -> name, "org" -> org))
+  def layout(name: String, org: String = defaultOrg) = LayoutComponent(org, name, Seq.empty, None, None, true, Json.obj("name" -> name, "org" -> org))
 
 }

modules/container-client-web/app/org/corespring/container/client/CompressedAndMinifiedComponentSets.scala

@@ -1,10 +1,13 @@
 package org.corespring.container.client
 
+import javax.xml.bind.DatatypeConverter
+
 import org.corespring.container.client.controllers.DefaultComponentSets
 import org.corespring.container.client.processing.{ CssMinifier, Gzipper, JsMinifier }
 import org.corespring.container.logging.ContainerLogger
 import play.api.Configuration
 import play.api.http.ContentTypes
+import play.api.libs.json.{ JsObject, Json }
 import play.api.mvc.{ Action, EssentialAction, RequestHeader, Result }
 
 trait CompressedAndMinifiedComponentSets extends DefaultComponentSets
@@ -43,13 +46,34 @@ trait CompressedAndMinifiedComponentSets extends DefaultComponentSets
     }
   }
 
-  override def singleResource[A >: EssentialAction](context: String, componentType: String, suffix: String): A = Action { implicit request =>
-    val (body, ct) = generate(context, allComponents.find(_.matchesType(componentType)).toSeq, suffix)
+  override def singleResource[A >: EssentialAction](context: String, componentType: String, suffix: String, resourceToken: String = "default"): A = Action { implicit request =>
+    val paramsJson = resourceToken match {
+      case "default" => Json.obj()
+      case _ =>
+        val decodedColorString = DatatypeConverter.parseBase64Binary(resourceToken).map(_.toChar).mkString
+        try {
+          Json.parse(decodedColorString).as[JsObject]
+        } catch {
+          case _ => Json.obj()
+        }
+    }
+    val (body, ct) = generate(context, allComponents.find(_.matchesType(componentType)).toSeq, suffix, paramsJson)
     process(body, ct)
   }
 
-  override def resource[A >: EssentialAction](context: String, directive: String, suffix: String) = Action { implicit request =>
-    val (body, ct) = generateBodyAndContentType(context, directive, suffix)
+  override def resource[A >: EssentialAction](context: String, directive: String, suffix: String, resourceToken: String = "default") = Action { implicit request =>
+    val paramsJson = resourceToken match {
+      case "default" => Json.obj()
+      case _ =>
+        val decodedColorString = DatatypeConverter.parseBase64Binary(resourceToken).map(_.toChar).mkString
+        try {
+          Json.parse(decodedColorString).as[JsObject]
+        } catch {
+          case _ => Json.obj()
+        }
+    }
+
+    val (body, ct) = generateBodyAndContentType(context, directive, suffix, paramsJson)
     process(body, ct)
   }
 

modules/container-client-web/app/org/corespring/container/client/component/ComponentUrls.scala

@@ -5,6 +5,7 @@ import play.api.mvc.Controller
 
 trait ComponentUrls {
   def jsUrl(context: String, components: Seq[Component], separatePaths: Boolean): Seq[String]
+  def lessUrl(context: String, components: Seq[Component], separatePaths: Boolean, encodedCustomColors: String): Seq[String]
   def cssUrl(context: String, components: Seq[Component], separatePaths: Boolean): Seq[String]
 }
 

modules/container-client-web/app/org/corespring/container/client/component/SourceGenerator.scala

@@ -5,7 +5,7 @@ import org.corespring.container.client.views.txt.js.{ ComponentServerWrapper, Co
 import org.corespring.container.components.model._
 import org.corespring.container.components.model.dependencies.ComponentTypeFilter
 import org.corespring.container.components.model.packaging.ClientSideDependency
-import play.api.libs.json.JsObject
+import play.api.libs.json.{ Json, JsValue, JsObject }
 
 object SourceGenerator {
   object Keys {
@@ -26,6 +26,8 @@ trait SourceGenerator
 
   def css(components: Seq[Component]): String
 
+  def less(components: Seq[Component], customColors: JsObject = Json.obj()): String
+
   protected def wrapComponent(moduleName: String, directiveName: String, src: String) = {
     ComponentWrapper(moduleName, directiveName, src).toString
   }
@@ -119,6 +121,29 @@ abstract class BaseGenerator
     """.stripMargin
   }
 
+  override def less(components: Seq[Component], customColors: JsObject = Json.obj()): String = {
+    val commonLessSource = scala.io.Source.fromURL(this.getClass().getResource("/public/components-common.less"))
+    val commonLess = commonLessSource.mkString
+    val (libraries, uiComps, layoutComps, widgets) = splitComponents(components)
+    val uiLess = uiComps.map(_.client.less.getOrElse("")).mkString("\n")
+    val widgetLess = widgets.map(_.client.less.getOrElse("")).mkString("\n")
+    val layoutLess = layoutComps.map(_.less.getOrElse("")).mkString("\n")
+    val libraryLess = libraries.map(_.less.getOrElse("")).mkString("\n")
+    val dynamicColors = customColors.asOpt[Map[String, String]] match {
+      case Some(cols) => cols.map { case (a, b) => s"@$a: $b;" }.mkString("\n")
+      case _ => ""
+    }
+    val res = s"""
+    |$commonLess
+    |$dynamicColors
+    |$uiLess
+    |$widgetLess
+    |$layoutLess
+    |$libraryLess
+    """.stripMargin
+    res
+  }
+
   override def js(components: Seq[Component]): String = {
     val (libs, uiComps, layoutComps, widgets) = splitComponents(components)
     val uiJs = uiComps.map(interactionToJs).mkString("\n")

modules/container-client-web/app/org/corespring/container/client/controllers/ComponentSets.scala

@@ -8,11 +8,15 @@ import org.corespring.container.components.model.dependencies.DependencyResolver
 import org.corespring.container.logging.ContainerLogger
 import play.api.http.ContentTypes
 import play.api.mvc._
+import org.lesscss.LessCompiler
+import play.api.libs.json.{ JsObject, Json }
 
 trait ComponentSets extends Controller with ComponentUrls {
 
   private lazy val logger = ContainerLogger.getLogger("ComponentSets")
 
+  private val lessCompiler = new LessCompiler()
+
   def allComponents: Seq[Component]
 
   def playerGenerator: SourceGenerator
@@ -23,15 +27,18 @@ trait ComponentSets extends Controller with ComponentUrls {
 
   def dependencyResolver: DependencyResolver
 
-  def resource[A >: EssentialAction](context: String, directive: String, suffix: String): A
+  def resource[A >: EssentialAction](context: String, directive: String, suffix: String, resourceToken: String = "default"): A
 
-  def singleResource[A >: EssentialAction](context: String, componentType: String, suffix: String): A
+  def singleResource[A >: EssentialAction](context: String, componentType: String, suffix: String, resourceToken: String = "default"): A
 
-  protected final def generate(context: String, resolvedComponents: Seq[Component], suffix: String): (String, String) = {
+  protected final def generate(context: String, resolvedComponents: Seq[Component], suffix: String, parameters: JsObject = Json.obj()): (String, String) = {
 
     def gen(generator: SourceGenerator): String = suffix match {
       case "js" => generator.js(resolvedComponents)
       case "css" => generator.css(resolvedComponents)
+      case "less" =>
+        val res = generator.less(resolvedComponents, (parameters \ "colors").asOpt[JsObject].getOrElse(Json.obj()))
+        lessCompiler.compile(res)
       case _ => ""
     }
 
@@ -46,37 +53,40 @@ trait ComponentSets extends Controller with ComponentUrls {
     val contentType = suffix match {
       case "js" => ContentTypes.JAVASCRIPT
       case "css" => ContentTypes.CSS
+      case "less" => ContentTypes.CSS
       case _ => throw new RuntimeException(s"Unknown suffix: $suffix")
     }
 
     (out, contentType)
   }
 
-  protected final def generateBodyAndContentType(context: String, directive: String, suffix: String): (String, String) = {
+  protected final def generateBodyAndContentType(context: String, directive: String, suffix: String, parameters: JsObject = Json.obj()): (String, String) = {
     val types: Seq[String] = ComponentUrlDirective(directive, allComponents)
     val usedComponents = types.map { t => allComponents.find(_.componentType == t) }.flatten
     val components = dependencyResolver.resolveComponents(usedComponents.map(_.id), Some(context))
     logger.trace(s"context: $context, comps: ${components.map(_.componentType).mkString(",")}")
-    generate(context, components, suffix)
+    generate(context, components, suffix, parameters)
   }
 
   override def cssUrl(context: String, components: Seq[Component], separatePaths: Boolean): Seq[String] = url(context, components, "css", separatePaths)
 
+  override def lessUrl(context: String, components: Seq[Component], separatePaths: Boolean, encodedCustomColors: String): Seq[String] = url(context, components, "less", separatePaths, encodedCustomColors)
+
   override def jsUrl(context: String, components: Seq[Component], separatePaths: Boolean): Seq[String] = url(context, components, "js", separatePaths)
 
-  private def url(context: String, components: Seq[Component], suffix: String, separatePaths: Boolean): Seq[String] = {
+  private def url(context: String, components: Seq[Component], suffix: String, separatePaths: Boolean, resourceToken: String = "default"): Seq[String] = {
 
     require(allComponents.length > 0, "Can't load components")
 
     if (separatePaths) {
       val resolvedComponents = dependencyResolver.resolveComponents(components.map(_.id), Some(context))
-      resolvedComponents.map { c => routes.ComponentSets.singleResource(context, c.componentType, suffix).url }
+      resolvedComponents.map { c => routes.ComponentSets.singleResource(context, c.componentType, suffix, resourceToken).url }
     } else {
       components match {
         case Nil => Seq.empty
         case _ => {
           ComponentUrlDirective.unapply(components.map(_.componentType), allComponents).map { path =>
-            routes.ComponentSets.resource(context, path, suffix).url
+            routes.ComponentSets.resource(context, path, suffix, resourceToken).url
           }.toSeq
         }
       }

modules/container-client-web/app/org/corespring/container/client/controllers/apps/App.scala

@@ -17,7 +17,7 @@ import org.corespring.container.logging.ContainerLogger
 
 import scala.concurrent._
 
-case class ComponentScriptInfo(jsUrl: Seq[String], cssUrl: Seq[String], ngDependencies: Seq[String])
+case class ComponentScriptInfo(jsUrl: Seq[String], cssUrl: Seq[String], lessUrl: Seq[String], ngDependencies: Seq[String])
 
 trait HasLogger {
   def logger: Logger
@@ -99,12 +99,17 @@ trait App[T]
     js.distinct.map(resolvePath)
   }
 
-  protected def buildCss(scriptInfo: ComponentScriptInfo)(implicit rh: RequestHeader) = {
-    val css = paths(cssSrc) ++ cssSrc.otherLibs ++ scriptInfo.cssUrl.toSeq
+  protected def buildLess(scriptInfo: ComponentScriptInfo)(implicit rh: RequestHeader) = {
+    val less = scriptInfo.lessUrl
+    less.map(resolvePath)
+  }
+
+  protected def buildCss(scriptInfo: ComponentScriptInfo, withComponents: Boolean = false)(implicit rh: RequestHeader) = {
+    val css = paths(cssSrc) ++ cssSrc.otherLibs ++ (if (withComponents) scriptInfo.cssUrl else Seq())
     css.map(resolvePath)
   }
 
-  protected def componentScriptInfo(components: Seq[String], separatePaths: Boolean): ComponentScriptInfo = {
+  protected def componentScriptInfo(components: Seq[String], separatePaths: Boolean, customColorsEncoded: String = "default"): ComponentScriptInfo = {
 
     val typeIds = components.map {
       t =>
@@ -116,9 +121,10 @@ trait App[T]
     val resolvedComponents = resolveComponents(typeIds, Some(context))
     val jsUrl = urls.jsUrl(context, resolvedComponents, separatePaths)
     val cssUrl = urls.cssUrl(context, resolvedComponents, separatePaths)
+    val lessUrl = urls.lessUrl(context, resolvedComponents, separatePaths, customColorsEncoded)
     val clientSideDependencies = getClientSideDependencies(resolvedComponents)
     val dependencies = ngModules.createAngularModules(resolvedComponents, clientSideDependencies)
-    ComponentScriptInfo(jsUrl, cssUrl, dependencies)
+    ComponentScriptInfo(jsUrl, cssUrl, lessUrl, dependencies)
   }
 
   /** Allow external domains to be configured */

modules/container-client-web/app/org/corespring/container/client/controllers/apps/Catalog.scala

@@ -2,6 +2,7 @@ package org.corespring.container.client.controllers.apps
 
 import org.corespring.container.client.component.AllItemTypesReader
 import org.corespring.container.client.controllers.GetAsset
+import org.corespring.container.client.controllers.helpers.QueryHelper
 import org.corespring.container.client.controllers.jade.Jade
 import org.corespring.container.client.hooks.{ LoadHook, CatalogHooks }
 import org.corespring.container.client.hooks.Hooks.StatusMessage
@@ -15,7 +16,8 @@ trait Catalog
   extends AllItemTypesReader
   with App[CatalogHooks]
   with Jade
-  with GetAsset[CatalogHooks] {
+  with GetAsset[CatalogHooks]
+  with QueryHelper {
 
   override def context: String = "catalog"
 
@@ -47,10 +49,11 @@ trait Catalog
 
         def ifEmpty = {
           logger.trace(s"[showCatalog]: $id")
-
+          val serviceParams = queryParams(mapToJson)
+          val colors = (serviceParams \ "colors").asOpt[String].getOrElse("default")
           val scriptInfo = componentScriptInfo(componentTypes(Json.obj()), jsMode == "dev")
           val domainResolvedJs = buildJs(scriptInfo)
-          val domainResolvedCss = buildCss(scriptInfo)
+          val domainResolvedCss = buildCss(scriptInfo) ++ buildLess(scriptInfo)
           Ok(
             renderJade(
               CatalogTemplateParams(