solara 0.1.0

data/solara/lib/core/dashboard/handler/base_handler.rb

@@ -0,0 +1,25 @@
+class BaseHandler
+    def initialize(server, dashboard_server)
+        @server = server
+        @dashboard_server = dashboard_server
+    end
+
+    def mount
+        raise NotImplementedError, "Subclasses must implement the 'mount' method"
+    end
+
+    protected
+
+    def handle_error(res, error, message, status = 500)
+        Solara.logger.failure("#{message}: #{error.message}")
+        res.status = status
+        res.body = JSON.generate({ success: false, error: "#{message}: #{error.message}" })
+        res.content_type = 'application/json'
+    end
+
+    def method_not_allowed(res)
+        res.status = 405
+        res.body = JSON.generate({ success: false, error: 'Method Not Allowed' })
+        res.content_type = 'application/json'
+    end
+end

data/solara/lib/core/dashboard/handler/brand_alisases_handler.rb

@@ -0,0 +1,33 @@
+class BrandAliasesHandler < BaseHandler
+    def mount
+        @server.mount_proc('/brand/aliases') do |req, res|
+            if req.request_method == 'GET'
+                begin
+                    query = CGI.parse(req.query_string)
+                    brand_key = query['brand_key']&.first
+
+                    if brand_key
+                        aliases = get_brand_aliases(brand_key)
+                        res.status = 200
+                        res.body = JSON.generate({ success: true, aliases: aliases })
+                    else
+                        res.status = 400
+                        res.body = JSON.generate({ success: false, error: 'Missing brand_key parameter' })
+                    end
+                rescue StandardError => e
+                    handle_error(res, e, "Error fetching brand aliases")
+                end
+            else
+                method_not_allowed(res)
+            end
+            res.content_type = 'application/json'
+        end
+    end
+
+    def get_brand_aliases(brand_key)
+        AliasGeneratorManager.aliases_json
+    rescue StandardError => e
+        Solara.logger.failure("Error getting brand aliases: #{e.message}")
+        raise
+    end
+end

data/solara/lib/core/dashboard/handler/brand_configurations_handler.rb

@@ -0,0 +1,18 @@
+class BrandConfigurationsHandler < BaseHandler
+    def mount
+        @server.mount_proc('/configurations') do |req, res|
+            begin
+                query = CGI.parse(req.query_string)
+                brand_key = query['brand_key']&.first
+
+                response_data = BrandsManager.instance.brand_with_configurations(brand_key)
+                res.body = JSON.generate({ success: true, message: "Configurations response", result: response_data })
+                res['Content-Type'] = 'application/json'
+            rescue StandardError => e
+                handle_error(res, e, "Error in brand configurations handler")
+            end
+        end
+    end
+
+end
+

data/solara/lib/core/dashboard/handler/brand_configurations_manager.rb

@@ -0,0 +1,73 @@
+class BrandConfigurationsManager
+
+    def initialize(brand_key)
+        @brand_key = brand_key
+    end
+
+    def template_with_key(key)
+        templates.select { |section| section[:key] === key }.first
+    end
+
+    def templates
+        [
+            {
+                key: 'theme',
+                name: 'Theme Configuration',
+                input_type: 'color',
+                path: FilePath.brand_theme(@brand_key)
+            },
+            {
+                key: 'brand_config',
+                name: 'Brand Configuration',
+                input_type: 'text',
+                path: FilePath.brand_config(@brand_key)
+            },
+            {
+                key: 'android_config',
+                name: 'Android Platform Configuration',
+                input_type: 'text',
+                path: FilePath.android_brand_config(@brand_key)
+            },
+            {
+                key: 'android_signing',
+                name: 'Android Signing',
+                input_type: 'text',
+                path: FilePath.brand_signing(@brand_key, Platform::Android)
+            },
+            {
+                key: 'ios_config',
+                name: 'iOS Platform Configuration',
+                input_type: 'text',
+                path: FilePath.ios_config(@brand_key)
+            },
+            {
+                key: 'ios_signing',
+                name: 'iOS Signing',
+                input_type: 'text',
+                path: FilePath.brand_signing(@brand_key, Platform::IOS)
+            }
+        ]
+    end
+
+    def create
+        config_templates = templates
+
+        config_templates.map do |template|
+            create_config_item(
+                template[:key],
+                template[:name],
+                template[:input_type],
+                template[:path].tap { |p| File.expand_path(p) }
+            )
+        end
+    end
+
+    def create_config_item(key, name, input_type, path)
+        {
+            key: key,
+            name: name,
+            inputType: input_type,
+            content: JSON.parse(File.read(path)),
+        }
+    end
+end

data/solara/lib/core/dashboard/handler/brand_icon_handler.rb

@@ -0,0 +1,20 @@
+class BrandIconHandler < BaseHandler
+    def mount
+        @server.mount_proc("/brand/icon") do |req, res|
+            begin
+                brand_key = req.query['brand_key']
+                filepath = FilePath.launcher_icon(brand_key)
+                if File.exist?(filepath)
+                    res.body = File.read(filepath)
+                    res['Content-Type'] = 'image/png' # Adjust as necessary
+                else
+                    res.status = 404
+                    res.body = JSON.generate({ error: "Icon not found for brand: #{brand_key}" })
+                    res['Content-Type'] = 'application/json'
+                end
+            rescue StandardError => e
+                handle_error(res, e, "Error fetching brand icon")
+            end
+        end
+    end
+end

data/solara/lib/core/dashboard/handler/brand_section_handler.rb

@@ -0,0 +1,20 @@
+class BrandSectionHandler < BaseHandler
+    def mount
+        @server.mount_proc("/section") do |req, res|
+            begin
+                query = CGI.parse(req.query_string)
+                path = query['path']&.first
+                if File.exist?(path)
+                    res.body = File.read(path)
+                    res['Content-Type'] = 'application/json'
+                else
+                    res.status = 404
+                    res.body = JSON.generate({ error: "Config file not found: #{path}" })
+                    res['Content-Type'] = 'application/json'
+                end
+            rescue StandardError => e
+                handle_error(res, e, "Error in brand section handler")
+            end
+        end
+    end
+end

data/solara/lib/core/dashboard/handler/brands_handler.rb

@@ -0,0 +1,14 @@
+class BrandsHandler < BaseHandler
+    def mount
+        @server.mount_proc('/brands.json') do |req, res|
+            begin
+                brands_list = BrandsManager.instance.brands_list
+                json = JSON.generate(brands_list)
+                res.body = json
+                res['Content-Type'] = 'application/json'
+            rescue StandardError => e
+                handle_error(res, e, "Error fetching brands list")
+            end
+        end
+    end
+end

data/solara/lib/core/dashboard/handler/current_brand_handler.rb

@@ -0,0 +1,18 @@
+class CurrentBrandHandler < BaseHandler
+    def mount
+        @server.mount_proc('/brand/current') do |req, res|
+            begin
+                current_brand = BrandsManager.instance.current_brand
+                if current_brand
+                    res.status = 200
+                    res.body = JSON.generate(current_brand)
+                else
+                    res.status = 204 # No Content
+                end
+                res.content_type = 'application/json'
+            rescue StandardError => e
+                handle_error(res, e, "Error fetching current brand")
+            end
+        end
+    end
+end

data/solara/lib/core/dashboard/handler/doctor_handler.rb

@@ -0,0 +1,39 @@
+class DoctorHandler < BaseHandler
+    def mount
+        @server.mount_proc('/brand/doctor') do |req, res|
+            if req.request_method == 'GET'
+                begin
+                    query = CGI.parse(req.query_string)
+                    brand_key = query['brand_key']&.first
+
+                    if brand_key
+                        doctor_result = run_doctor(brand_key)
+                        res.status = 200
+                        res.body = JSON.generate({ success: true, result: doctor_result })
+                    else
+                        res.status = 400
+                        res.body = JSON.generate({ success: false, error: 'Missing brand_key parameter' })
+                    end
+                rescue StandardError => e
+                    handle_error(res, e, "Error running doctor")
+                end
+            else
+                method_not_allowed(res)
+            end
+            res.content_type = 'application/json'
+        end
+    end
+
+    def run_doctor(brand_key)
+        errors = SolaraManager.new.doctor(brand_key)
+        {
+            message: "Health check completed.",
+            brand_key: brand_key,
+            passed: errors.empty?,
+            errors: errors
+        }
+    rescue StandardError => e
+        Solara.logger.failure("Error running doctor: #{e.message}")
+        raise
+    end
+end

data/solara/lib/core/dashboard/handler/edit_section_handler.rb

@@ -0,0 +1,55 @@
+Dir['*.rb'].each { |file| require_relative file }
+
+class EditSectionHandler < BaseHandler
+    def mount
+        @server.mount_proc('/section/edit') do |req, res|
+            if req.request_method == 'POST'
+                begin
+                    request_payload = JSON.parse(req.body)
+                    brand_key = request_payload['brand_key']
+                    key = request_payload['key']
+                    data = request_payload['data']
+
+                    update_section(key, data, brand_key)
+                    set_current_brand_content_changed(brand_key, true)
+
+                    res.status = 200
+                    res.body = JSON.generate({ success: true, message: "Configuration for #{key} updated successfully" })
+                    res.content_type = 'application/json'
+                rescue JSON::ParserError => e
+                    handle_error(res, e, "Invalid JSON in request body", 400)
+                rescue StandardError => e
+                    handle_error(res, e, "Error updating configuration")
+                end
+            else
+                method_not_allowed(res)
+            end
+        end
+    end
+
+    def update_section(key, data, brand_key)
+        template = BrandConfigurationsManager.new(brand_key).template_with_key(key)
+
+        path = template[:path]
+        if File.exist?(path)
+            File.write(path, JSON.pretty_generate(data))
+            Solara.logger.debug("Updated Config for #{path}: #{data}")
+        else
+            raise "Config file not found: #{path}"
+        end
+    rescue StandardError => e
+        Solara.logger.failure("Error updating section: #{e.message}")
+        raise
+    end
+
+    def update_theme(path, data)
+        json = JSON.parse(File.read(path))
+        json['colors'] = data
+        File.write(path, JSON.pretty_generate(json))
+    end
+
+    def set_current_brand_content_changed(brand_key, changed)
+        BrandsManager.instance.set_current_brand_content_changed(brand_key, changed)
+    end
+
+end

data/solara/lib/core/dashboard/handler/offboard_brand_handler.rb

@@ -0,0 +1,34 @@
+class OffboardBrandHandler < BaseHandler
+    def mount
+        @server.mount_proc('/brand/offboard') do |req, res|
+            if req.request_method == 'GET'
+                begin
+                    query = CGI.parse(req.query_string)
+                    brand_key = query['brand_key']&.first
+
+                    if brand_key
+                        offboard(brand_key)
+                        res.status = 200
+                        res.body = JSON.generate({ success: true, message: "Deleted brand: #{brand_key}" })
+                    else
+                        res.status = 400
+                        res.body = JSON.generate({ success: false, error: 'Missing brand_key parameter' })
+                    end
+                rescue StandardError => e
+                    handle_error(res, e, "Error deleting brand")
+                end
+            else
+                method_not_allowed(res)
+            end
+            res.content_type = 'application/json'
+        end
+    end
+
+    def offboard(brand_key)
+        SolaraManager.new.offboard(brand_key, confirm: false)
+    rescue StandardError => e
+        Solara.logger.failure("Error deleting brand: #{e.message}")
+        raise
+    end
+
+end

data/solara/lib/core/dashboard/handler/onboard_brand_handler.rb

@@ -0,0 +1,53 @@
+class OnboardBrandHandler < BaseHandler
+    def mount
+        @server.mount_proc('/brand/onboard') do |req, res|
+            if req.request_method == 'POST'
+                begin
+                    data = JSON.parse(req.body)
+                    brand_name = data['brand_name']
+                    brand_key = data['brand_key']
+                    clone_brand_key = data['clone_brand_key']
+
+                    if brand_key
+                        result = onboard_brand(brand_name, brand_key, clone_brand_key)
+                        res.status = result[:success] ? 200 : 409 # 409 Conflict for existing brand
+                        res.body = JSON.generate(result)
+                    else
+                        res.status = 400
+                        res.body = JSON.generate({ success: false, error: 'Missing brand_key parameter' })
+                    end
+                rescue JSON::ParserError => e
+                    handle_error(res, e, "Invalid JSON in request body", 400)
+                rescue StandardError => e
+                    handle_error(res, e, "Error adding brand")
+                end
+            else
+                method_not_allowed(res)
+            end
+            res.content_type = 'application/json'
+        end
+
+        def onboard_brand(brand_name, brand_key, clone_brand_key = nil)
+            if BrandsManager.instance.exists(brand_key)
+                return { success: false, message: "Brand with key (#{brand_key}) already added!" }
+            end
+            SolaraManager.new.onboard(brand_key, brand_name, clone_brand_key: clone_brand_key, open_dashboard: false)
+            { success: true, message: "Brand added successfully" }
+        rescue StandardError => e
+            Solara.logger.failure("Error adding brand: #{e.message}")
+            raise
+        end
+
+    end
+
+    def onboard_brand(brand_name, brand_key, clone_brand_key = nil)
+        if BrandsManager.instance.exists(brand_key)
+            return { success: false, message: "Brand with key (#{brand_key}) already added!" }
+        end
+        SolaraManager.new.onboard(brand_key, brand_name, clone_brand_key: clone_brand_key, open_dashboard: false)
+        { success: true, message: "Brand added successfully" }
+    rescue StandardError => e
+        Solara.logger.failure("Error adding brand: #{e.message}")
+        raise
+    end
+end

data/solara/lib/core/dashboard/handler/redirect_handler.rb

@@ -0,0 +1,12 @@
+class RedirectHandler < BaseHandler
+    def mount
+        @server.mount_proc('/redirect') do |req, res|
+            begin
+                res.content_type = 'application/json'
+                res.body = JSON.generate({ redirect_url: @dashboard_server.home })
+            rescue StandardError => e
+                handle_error(res, e, "Error in redirect handler")
+            end
+        end
+    end
+end

data/solara/lib/core/dashboard/handler/switch_handler.rb

@@ -0,0 +1,25 @@
+class SwitchToBrandHandler < BaseHandler
+    def mount
+        @server.mount_proc('/switch') do |req, res|
+            if req.request_method == 'POST'
+                begin
+                    request_payload = JSON.parse(req.body)
+                    brand_key = request_payload['brand_key']
+
+                    result = SolaraManager.new.switch(brand_key)
+                    Solara.logger.debug(result)
+
+                    res.status = 200
+                    res.body = JSON.generate({ success: true, message: "Switched to brand: #{brand_key}", result: result })
+                    res.content_type = 'application/json'
+                rescue JSON::ParserError => e
+                    handle_error(res, e, "Invalid JSON in request body", 400)
+                rescue StandardError => e
+                    handle_error(res, e, "Error switching to brand")
+                end
+            else
+                method_not_allowed(res)
+            end
+        end
+    end
+end

data/solara/lib/core/dashboard/index.html

@@ -0,0 +1,36 @@
+<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>Redirecting...</title>
+        <style>
+            body, html {
+                height: 100%;
+                margin: 0;
+                display: flex;
+                justify-content: center;
+                align-items: center;
+                background-color: #f0f0f0;
+            }
+            .container {
+                text-align: center;
+            }
+            img {
+                max-width: 50%;
+                max-height: 80vh;
+                object-fit: contain;
+            }
+        </style>
+        <script>
+            setTimeout(() => {
+                window.location.href = 'brand/brand.html?source=remote';
+            }, 500);
+        </script>
+    </head>
+    <body>
+        <div class="container">
+            <img src="solara.png" alt="Logo Image">
+        </div>
+    </body>
+</html>

data/solara/lib/core/dashboard/local.html

@@ -0,0 +1,41 @@
+<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>Redirecting...</title>
+        <style>
+            body, html {
+                height: 100%;
+                margin: 0;
+                display: flex;
+                justify-content: center;
+                align-items: center;
+                background-color: #f0f0f0;
+            }
+            .container {
+                text-align: center;
+            }
+            img {
+                max-width: 50%;
+                max-height: 80vh;
+                object-fit: contain;
+            }
+        </style>
+        <script>
+            fetch('/redirect')
+                .then(response => response.json())
+                .then(data => {
+                    setTimeout(() => {
+                        window.location.href = data.redirect_url;
+                    }, 500);
+                })
+                .catch(error => console.error('Error:', error));
+        </script>
+    </head>
+    <body>
+        <div class="container">
+            <img src="solara.png" alt="Logo Image">
+        </div>
+    </body>
+</html>

data/solara/lib/core/dashboard/res/favicon/site.webmanifest

@@ -0,0 +1 @@
+{"name":"","short_name":"","icons":[{"src":"/android-chrome-192x192.png","sizes":"192x192","type":"image/png"},{"src":"/android-chrome-512x512.png","sizes":"512x512","type":"image/png"}],"theme_color":"#ffffff","background_color":"#ffffff","display":"standalone"}

data/solara/lib/core/doctor/brand_doctor.rb

@@ -0,0 +1,94 @@
+Dir.glob("#{__dir__}/*.rb").each { |file| require file }
+Dir.glob("#{__dir__}/../../.solara/core/brands/*.rb").each { |file| require file }
+Dir.glob("#{__dir__}/validator/template/*.rb").each { |file| require file }
+
+class Issue < StandardError
+    ERROR = 'ERROR'
+    WARNING = 'WARNING'
+
+    attr_reader :type, :error
+
+    def initialize(type, error)
+        @type = type
+        @error = error
+    end
+
+    def to_s
+        "#{@type}: #{@error}"
+    end
+
+    def <=>(other)
+        [type, error] <=> [other.type, other.error]
+    end
+
+    def self.error(error)
+        Issue.new(ERROR, error)
+    end
+
+    def self.warning(error)
+        Issue.new(WARNING, error)
+    end
+end
+
+class BrandDoctor
+    def initialize
+    end
+
+    def visit(brand_keys = [], print_logs: true)
+        keys = brand_keys.empty? ? BrandsManager.instance.brands_list.map { |brand| brand['key'] } : brand_keys
+        issues = []
+
+        keys.each do |brand_key|
+            validator = TemplateValidator.new(FilePath.brand(brand_key), FilePath.template_validation_config)
+            errors = validator.validate
+
+            errors.each { |error|
+                issues << Issue.error(error)
+            }
+        end
+
+        # Validate settings only if all validations so far are passed to avoid files issues
+        if issues.select { |issue| issue.type == Issue::ERROR }.empty?
+            issues += BrandSettingsValidatorManager.new.validate
+        end
+
+        if print_logs && !issues.empty?
+            Solara.logger.title("Healt Check Result")
+
+            issues.sort!.each { |issue|
+                case issue.type
+                when Issue::ERROR
+                    Solara.logger.failure(issue.to_s)
+                when Issue::WARNING
+                    Solara.logger.warn(issue.to_s)
+                else
+                    Solara.logger.failure(issue.to_s)
+                    issues.sort!
+                end
+            }
+        end
+
+        issues.sort!
+    end
+
+    def validate_brand(brand_key, strategies = [])
+        Solara.logger.start_step("Brand Health Check: #{brand_key}")
+
+        project_path = FilePath.brand(brand_key)
+        issues = []
+
+        strategies.each do |strategy|
+            Solara.logger.debug("Running #{strategy.class.name}...")
+            begin
+                strategy.validate(project_path)
+                Solara.logger.debug("#{strategy.class.name} passed.")
+            rescue => e
+                issues << Issue.error("#{e.message} (#{strategy.class.name})")
+            end
+        end
+
+        Solara.logger.end_step("Brand Health Check #{brand_key}")
+        issues
+    end
+end
+